Agda 2.3.0.1 → 2.9.0
raw patch · 686 files changed
This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.
Files
- Agda.cabal +1086/−341
- CHANGELOG.md +1378/−0
- LICENSE +31/−35
- README +0/−299
- README.md +37/−0
- Setup.hs +0/−12
- dist/build/Agda/Syntax/Parser/Lexer.hs +0/−434
- dist/build/Agda/Syntax/Parser/Parser.hs +0/−5040
- doc/release-notes/2-2-0.txt +0/−102
- doc/release-notes/2-2-10.txt +0/−214
- doc/release-notes/2-2-2.txt +0/−23
- doc/release-notes/2-2-4.txt +0/−47
- doc/release-notes/2-2-6.txt +0/−257
- doc/release-notes/2-2-8.txt +0/−564
- doc/release-notes/2-3-0.txt +0/−1005
- doc/release-notes/2.2.0.md +102/−0
- doc/release-notes/2.2.10.md +238/−0
- doc/release-notes/2.2.2.md +22/−0
- doc/release-notes/2.2.4.md +54/−0
- doc/release-notes/2.2.6.md +290/−0
- doc/release-notes/2.2.8.md +626/−0
- doc/release-notes/2.3.0.md +1124/−0
- doc/release-notes/2.3.2.1.md +16/−0
- doc/release-notes/2.3.2.2.md +10/−0
- doc/release-notes/2.3.2.md +806/−0
- doc/release-notes/2.4.0.1.md +8/−0
- doc/release-notes/2.4.0.2.md +90/−0
- doc/release-notes/2.4.0.md +1211/−0
- doc/release-notes/2.4.2.1.md +214/−0
- doc/release-notes/2.4.2.2.md +20/−0
- doc/release-notes/2.4.2.3.md +303/−0
- doc/release-notes/2.4.2.4.md +295/−0
- doc/release-notes/2.4.2.5.md +78/−0
- doc/release-notes/2.4.2.md +391/−0
- doc/release-notes/2.5.1.1.md +79/−0
- doc/release-notes/2.5.1.2.md +5/−0
- doc/release-notes/2.5.1.md +1600/−0
- doc/release-notes/2.5.2.md +1184/−0
- doc/release-notes/2.5.3.md +822/−0
- doc/release-notes/2.5.4.1.md +16/−0
- doc/release-notes/2.5.4.2.md +23/−0
- doc/release-notes/2.5.4.md +859/−0
- doc/release-notes/2.6.0.1.md +22/−0
- doc/release-notes/2.6.0.md +849/−0
- doc/release-notes/2.6.1.1.md +4/−0
- doc/release-notes/2.6.1.2.md +8/−0
- doc/release-notes/2.6.1.3.md +4/−0
- doc/release-notes/2.6.1.md +850/−0
- doc/release-notes/2.6.2.1.md +149/−0
- doc/release-notes/2.6.2.2.md +109/−0
- doc/release-notes/2.6.2.md +1250/−0
- doc/release-notes/2.6.3.md +522/−0
- doc/release-notes/2.6.4.1.md +75/−0
- doc/release-notes/2.6.4.2.md +47/−0
- doc/release-notes/2.6.4.3.md +17/−0
- doc/release-notes/2.6.4.md +588/−0
- doc/release-notes/2.7.0.1.md +72/−0
- doc/release-notes/2.7.0.md +436/−0
- doc/release-notes/2.8.0.1.md +6/−0
- doc/release-notes/2.8.0.2.md +11/−0
- doc/release-notes/2.8.0.md +639/−0
- doc/user-manual/agda.svg +43/−0
- src/agda-mode/Main.hs +74/−167
- src/data/Agda.css +0/−31
- src/data/EpicInclude/AgdaPrelude.e +0/−229
- src/data/EpicInclude/stdagda.c +0/−95
- src/data/EpicInclude/stdagda.h +0/−41
- src/data/JS/agda-rts.amd.js +377/−0
- src/data/JS/agda-rts.js +389/−0
- src/data/JS/agda-rts.mjs +393/−0
- src/data/MAlonzo/src/MAlonzo/RTE.hs +121/−0
- src/data/MAlonzo/src/MAlonzo/RTE/Float.hs +285/−0
- src/data/emacs-mode/agda-input.el +1593/−772
- src/data/emacs-mode/agda2-abbrevs.el +23/−21
- src/data/emacs-mode/agda2-highlight.el +420/−164
- src/data/emacs-mode/agda2-mode-pkg.el +3/−0
- src/data/emacs-mode/agda2-mode.el +2554/−1204
- src/data/emacs-mode/agda2-queue.el +45/−0
- src/data/emacs-mode/agda2.el +41/−2
- src/data/emacs-mode/annotation.el +238/−114
- src/data/emacs-mode/eri.el +11/−4
- src/data/html/Agda.css +42/−0
- src/data/html/highlight-hover.js +35/−0
- src/data/latex/agda.sty +741/−0
- src/data/latex/postprocess-latex.pl +24/−0
- src/data/lib/prim/Agda/Builtin/Bool.agda +15/−0
- src/data/lib/prim/Agda/Builtin/Char.agda +35/−0
- src/data/lib/prim/Agda/Builtin/Char/Properties.agda +10/−0
- src/data/lib/prim/Agda/Builtin/Coinduction.agda +15/−0
- src/data/lib/prim/Agda/Builtin/Cubical/Equiv.agda +113/−0
- src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda +18/−0
- src/data/lib/prim/Agda/Builtin/Cubical/HCompU.agda +84/−0
- src/data/lib/prim/Agda/Builtin/Cubical/Path.agda +15/−0
- src/data/lib/prim/Agda/Builtin/Cubical/Sub.agda +18/−0
- src/data/lib/prim/Agda/Builtin/Equality.agda +9/−0
- src/data/lib/prim/Agda/Builtin/Equality/Erase.agda +7/−0
- src/data/lib/prim/Agda/Builtin/Equality/Rewrite.agda +9/−0
- src/data/lib/prim/Agda/Builtin/Erased/Box-cong.agda +33/−0
- src/data/lib/prim/Agda/Builtin/Erased/Erased.agda +32/−0
- src/data/lib/prim/Agda/Builtin/Erased/Funext.agda +25/−0
- src/data/lib/prim/Agda/Builtin/Erased/Propext.agda +28/−0
- src/data/lib/prim/Agda/Builtin/Erased/Quotient.agda +78/−0
- src/data/lib/prim/Agda/Builtin/Float.agda +209/−0
- src/data/lib/prim/Agda/Builtin/Float/Properties.agda +10/−0
- src/data/lib/prim/Agda/Builtin/FromNat.agda +16/−0
- src/data/lib/prim/Agda/Builtin/FromNeg.agda +16/−0
- src/data/lib/prim/Agda/Builtin/FromString.agda +16/−0
- src/data/lib/prim/Agda/Builtin/IO.agda +10/−0
- src/data/lib/prim/Agda/Builtin/Int.agda +16/−0
- src/data/lib/prim/Agda/Builtin/List.agda +16/−0
- src/data/lib/prim/Agda/Builtin/Maybe.agda +9/−0
- src/data/lib/prim/Agda/Builtin/Nat.agda +173/−0
- src/data/lib/prim/Agda/Builtin/Reflection.agda +486/−0
- src/data/lib/prim/Agda/Builtin/Reflection/External.agda +17/−0
- src/data/lib/prim/Agda/Builtin/Reflection/Properties.agda +11/−0
- src/data/lib/prim/Agda/Builtin/Sigma.agda +17/−0
- src/data/lib/prim/Agda/Builtin/Size.agda +21/−0
- src/data/lib/prim/Agda/Builtin/Strict.agda +9/−0
- src/data/lib/prim/Agda/Builtin/String.agda +36/−0
- src/data/lib/prim/Agda/Builtin/String/Properties.agda +11/−0
- src/data/lib/prim/Agda/Builtin/TrustMe.agda +15/−0
- src/data/lib/prim/Agda/Builtin/Unit.agda +10/−0
- src/data/lib/prim/Agda/Builtin/Word.agda +13/−0
- src/data/lib/prim/Agda/Builtin/Word/Properties.agda +10/−0
- src/data/lib/prim/Agda/Primitive.agda +41/−0
- src/data/lib/prim/Agda/Primitive/Cubical.agda +75/−0
- src/data/lib/prim/agda-builtins.agda-lib +2/−0
- src/full/Agda/Auto/Auto.hs +0/−445
- src/full/Agda/Auto/CaseSplit.hs +0/−645
- src/full/Agda/Auto/Convert.hs +0/−752
- src/full/Agda/Auto/NarrowingSearch.hs +0/−614
- src/full/Agda/Auto/SearchControl.hs +0/−362
- src/full/Agda/Auto/Syntax.hs +0/−325
- src/full/Agda/Auto/Typecheck.hs +0/−808
- src/full/Agda/Benchmarking.hs +172/−0
- src/full/Agda/Compiler/Backend.hs +207/−0
- src/full/Agda/Compiler/Backend/Base.hs +108/−0
- src/full/Agda/Compiler/Builtin.hs +24/−0
- src/full/Agda/Compiler/CallCompiler.hs +106/−0
- src/full/Agda/Compiler/Common.hs +197/−0
- src/full/Agda/Compiler/Epic/AuxAST.hs +0/−167
- src/full/Agda/Compiler/Epic/CaseOpts.hs +0/−42
- src/full/Agda/Compiler/Epic/CompileState.hs +0/−214
- src/full/Agda/Compiler/Epic/Compiler.hs +0/−265
- src/full/Agda/Compiler/Epic/Epic.hs +0/−110
- src/full/Agda/Compiler/Epic/Erasure.hs +0/−215
- src/full/Agda/Compiler/Epic/ForceConstrs.hs +0/−75
- src/full/Agda/Compiler/Epic/Forcing.hs +0/−309
- src/full/Agda/Compiler/Epic/FromAgda.hs +0/−257
- src/full/Agda/Compiler/Epic/Injection.hs +0/−323
- src/full/Agda/Compiler/Epic/Interface.hs +0/−87
- src/full/Agda/Compiler/Epic/NatDetection.hs +0/−77
- src/full/Agda/Compiler/Epic/Primitive.hs +0/−211
- src/full/Agda/Compiler/Epic/Smashing.hs +0/−135
- src/full/Agda/Compiler/Epic/Static.hs +0/−101
- src/full/Agda/Compiler/HaskellTypes.hs +0/−132
- src/full/Agda/Compiler/JS/Case.hs +0/−127
- src/full/Agda/Compiler/JS/Compiler.hs +990/−448
- src/full/Agda/Compiler/JS/Parser.hs +0/−187
- src/full/Agda/Compiler/JS/Pretty.hs +316/−67
- src/full/Agda/Compiler/JS/Substitution.hs +47/−28
- src/full/Agda/Compiler/JS/Syntax.hs +104/−41
- src/full/Agda/Compiler/MAlonzo/Coerce.hs +81/−0
- src/full/Agda/Compiler/MAlonzo/Compiler.hs +1379/−549
- src/full/Agda/Compiler/MAlonzo/Compiler.hs-boot +0/−10
- src/full/Agda/Compiler/MAlonzo/Encode.hs +33/−88
- src/full/Agda/Compiler/MAlonzo/HaskellTypes.hs +252/−0
- src/full/Agda/Compiler/MAlonzo/Misc.hs +345/−131
- src/full/Agda/Compiler/MAlonzo/Pragmas.hs +266/−0
- src/full/Agda/Compiler/MAlonzo/Pretty.hs +233/−7
- src/full/Agda/Compiler/MAlonzo/Primitives.hs +288/−205
- src/full/Agda/Compiler/MAlonzo/Strict.hs +91/−0
- src/full/Agda/Compiler/ToTreeless.hs +677/−0
- src/full/Agda/Compiler/Treeless/AsPatterns.hs +76/−0
- src/full/Agda/Compiler/Treeless/Builtin.hs +211/−0
- src/full/Agda/Compiler/Treeless/Compare.hs +66/−0
- src/full/Agda/Compiler/Treeless/EliminateDefaults.hs +62/−0
- src/full/Agda/Compiler/Treeless/EliminateLiteralPatterns.hs +77/−0
- src/full/Agda/Compiler/Treeless/Erase.hs +385/−0
- src/full/Agda/Compiler/Treeless/Erase.hs-boot +8/−0
- src/full/Agda/Compiler/Treeless/GuardsToPrims.hs +56/−0
- src/full/Agda/Compiler/Treeless/Identity.hs +106/−0
- src/full/Agda/Compiler/Treeless/NormalizeNames.hs +43/−0
- src/full/Agda/Compiler/Treeless/Pretty.hs +216/−0
- src/full/Agda/Compiler/Treeless/Pretty.hs-boot +7/−0
- src/full/Agda/Compiler/Treeless/Simplify.hs +650/−0
- src/full/Agda/Compiler/Treeless/Subst.hs +153/−0
- src/full/Agda/Compiler/Treeless/Uncase.hs +70/−0
- src/full/Agda/Compiler/Treeless/Unused.hs +101/−0
- src/full/Agda/ImpossibleTest.hs +18/−4
- src/full/Agda/Interaction/AgdaTop.hs +87/−0
- src/full/Agda/Interaction/Base.hs +542/−0
- src/full/Agda/Interaction/BasicOps.hs +1514/−551
- src/full/Agda/Interaction/BuildLibrary.hs +124/−0
- src/full/Agda/Interaction/Command.hs +55/−0
- src/full/Agda/Interaction/CommandLine.hs +358/−0
- src/full/Agda/Interaction/CommandLine/CommandLine.hs +0/−301
- src/full/Agda/Interaction/Emacs/Lisp.hs +52/−0
- src/full/Agda/Interaction/EmacsCommand.hs +62/−30
- src/full/Agda/Interaction/EmacsTop.hs +490/−0
- src/full/Agda/Interaction/Exceptions.hs +0/−22
- src/full/Agda/Interaction/ExitCode.hs +37/−0
- src/full/Agda/Interaction/FindFile.hs +191/−107
- src/full/Agda/Interaction/FindFile.hs-boot +0/−7
- src/full/Agda/Interaction/GhciTop.hs +0/−1083
- src/full/Agda/Interaction/Highlighting/Common.hs +49/−0
- src/full/Agda/Interaction/Highlighting/Dot.hs +5/−88
- src/full/Agda/Interaction/Highlighting/Dot/Backend.hs +254/−0
- src/full/Agda/Interaction/Highlighting/Dot/Base.hs +44/−0
- src/full/Agda/Interaction/Highlighting/Emacs.hs +91/−73
- src/full/Agda/Interaction/Highlighting/FromAbstract.hs +708/−0
- src/full/Agda/Interaction/Highlighting/Generate.hs +814/−555
- src/full/Agda/Interaction/Highlighting/Generate.hs-boot +7/−0
- src/full/Agda/Interaction/Highlighting/HTML.hs +6/−179
- src/full/Agda/Interaction/Highlighting/HTML/Backend.hs +204/−0
- src/full/Agda/Interaction/Highlighting/HTML/Base.hs +436/−0
- src/full/Agda/Interaction/Highlighting/HTML/Forester.hs +147/−0
- src/full/Agda/Interaction/Highlighting/JSON.hs +85/−0
- src/full/Agda/Interaction/Highlighting/LaTeX.hs +12/−0
- src/full/Agda/Interaction/Highlighting/LaTeX/Backend.hs +214/−0
- src/full/Agda/Interaction/Highlighting/LaTeX/Base.hs +852/−0
- src/full/Agda/Interaction/Highlighting/Precise.hs +246/−234
- src/full/Agda/Interaction/Highlighting/Range.hs +22/−88
- src/full/Agda/Interaction/Highlighting/Vim.hs +52/−44
- src/full/Agda/Interaction/Imports.hs +1742/−574
- src/full/Agda/Interaction/Imports.hs-boot +8/−5
- src/full/Agda/Interaction/InteractionTop.hs +1266/−0
- src/full/Agda/Interaction/JSON.hs +151/−0
- src/full/Agda/Interaction/JSONTop.hs +490/−0
- src/full/Agda/Interaction/Library.hs +733/−0
- src/full/Agda/Interaction/Library/Base.hs +644/−0
- src/full/Agda/Interaction/Library/Parse.hs +324/−0
- src/full/Agda/Interaction/MakeCase.hs +603/−106
- src/full/Agda/Interaction/Monad.hs +38/−15
- src/full/Agda/Interaction/Options.hs +7/−448
- src/full/Agda/Interaction/Options/Arguments.hs +102/−0
- src/full/Agda/Interaction/Options/Base.hs +2225/−0
- src/full/Agda/Interaction/Options/BashCompletion.hs +158/−0
- src/full/Agda/Interaction/Options/Default.hs +140/−0
- src/full/Agda/Interaction/Options/Errors.hs +562/−0
- src/full/Agda/Interaction/Options/HasOptions.hs +47/−0
- src/full/Agda/Interaction/Options/Help.hs +65/−0
- src/full/Agda/Interaction/Options/Lenses.hs +177/−0
- src/full/Agda/Interaction/Options/ProfileOptions.hs +115/−0
- src/full/Agda/Interaction/Options/Types.hs +330/−0
- src/full/Agda/Interaction/Options/Warnings.hs +700/−0
- src/full/Agda/Interaction/Output.hs +14/−0
- src/full/Agda/Interaction/Response.hs +25/−0
- src/full/Agda/Interaction/Response/Base.hs +183/−0
- src/full/Agda/Interaction/SearchAbout.hs +77/−0
- src/full/Agda/Main.hs +494/−128
- src/full/Agda/Mimer/Mimer.hs +690/−0
- src/full/Agda/Mimer/Monad.hs +789/−0
- src/full/Agda/Mimer/Options.hs +88/−0
- src/full/Agda/Mimer/Types.hs +412/−0
- src/full/Agda/Packaging/Config.hs +0/−23
- src/full/Agda/Packaging/Database.hs +0/−234
- src/full/Agda/Packaging/Monad.hs +0/−38
- src/full/Agda/Packaging/Types.hs +0/−20
- src/full/Agda/Syntax/Abstract.hs +1270/−476
- src/full/Agda/Syntax/Abstract/Name.hs +682/−132
- src/full/Agda/Syntax/Abstract/Pattern.hs +512/−0
- src/full/Agda/Syntax/Abstract/PatternSynonyms.hs +91/−0
- src/full/Agda/Syntax/Abstract/Pretty.hs +14/−10
- src/full/Agda/Syntax/Abstract/UsedNames.hs +186/−0
- src/full/Agda/Syntax/Abstract/Views.hs +655/−17
- src/full/Agda/Syntax/Builtin.hs +1099/−0
- src/full/Agda/Syntax/Common.hs +4385/−179
- src/full/Agda/Syntax/Common/Aspect.hs +205/−0
- src/full/Agda/Syntax/Common/KeywordRange.hs +41/−0
- src/full/Agda/Syntax/Common/Pretty.hs +438/−0
- src/full/Agda/Syntax/Common/Pretty/ANSI.hs +112/−0
- src/full/Agda/Syntax/Concrete.hs +1573/−502
- src/full/Agda/Syntax/Concrete/Attribute.hs +315/−0
- src/full/Agda/Syntax/Concrete/Definitions.hs +1761/−674
- src/full/Agda/Syntax/Concrete/Definitions/Errors.hs +651/−0
- src/full/Agda/Syntax/Concrete/Definitions/Monad.hs +284/−0
- src/full/Agda/Syntax/Concrete/Definitions/Types.hs +360/−0
- src/full/Agda/Syntax/Concrete/Fixity.hs +306/−0
- src/full/Agda/Syntax/Concrete/Generic.hs +398/−0
- src/full/Agda/Syntax/Concrete/Glyph.hs +154/−0
- src/full/Agda/Syntax/Concrete/Name.hs +402/−122
- src/full/Agda/Syntax/Concrete/Operators.hs +987/−411
- src/full/Agda/Syntax/Concrete/Operators/Parser.hs +325/−158
- src/full/Agda/Syntax/Concrete/Operators/Parser/Monad.hs +132/−0
- src/full/Agda/Syntax/Concrete/Pattern.hs +391/−0
- src/full/Agda/Syntax/Concrete/Pretty.hs +599/−397
- src/full/Agda/Syntax/DoNotation.hs +156/−0
- src/full/Agda/Syntax/Fixity.hs +118/−99
- src/full/Agda/Syntax/IdiomBrackets.hs +72/−0
- src/full/Agda/Syntax/Info.hs +241/−82
- src/full/Agda/Syntax/Internal.hs +2057/−327
- src/full/Agda/Syntax/Internal/Blockers.hs +319/−0
- src/full/Agda/Syntax/Internal/Defs.hs +140/−0
- src/full/Agda/Syntax/Internal/Elim.hs +106/−0
- src/full/Agda/Syntax/Internal/Generic.hs +134/−74
- src/full/Agda/Syntax/Internal/MetaVars.hs +109/−0
- src/full/Agda/Syntax/Internal/Names.hs +432/−0
- src/full/Agda/Syntax/Internal/Pattern.hs +357/−29
- src/full/Agda/Syntax/Internal/SanityCheck.hs +79/−0
- src/full/Agda/Syntax/Internal/Univ.hs +103/−0
- src/full/Agda/Syntax/Literal.hs +92/−40
- src/full/Agda/Syntax/Notation.hs +412/−69
- src/full/Agda/Syntax/Parser.hs +218/−44
- src/full/Agda/Syntax/Parser/Alex.hs +87/−34
- src/full/Agda/Syntax/Parser/Comments.hs +28/−30
- src/full/Agda/Syntax/Parser/Helpers.hs +835/−0
- src/full/Agda/Syntax/Parser/Layout.hs +189/−82
- src/full/Agda/Syntax/Parser/Layout.hs-boot +10/−3
- src/full/Agda/Syntax/Parser/LexActions.hs +192/−114
- src/full/Agda/Syntax/Parser/LexActions.hs-boot +17/−9
- src/full/Agda/Syntax/Parser/Lexer.x +179/−127
- src/full/Agda/Syntax/Parser/Literate.hs +347/−0
- src/full/Agda/Syntax/Parser/LookAhead.hs +73/−44
- src/full/Agda/Syntax/Parser/Monad.hs +473/−176
- src/full/Agda/Syntax/Parser/Parser.y +1948/−1407
- src/full/Agda/Syntax/Parser/StringLiterals.hs +72/−74
- src/full/Agda/Syntax/Parser/Tokens.hs +136/−42
- src/full/Agda/Syntax/Position.hs +902/−472
- src/full/Agda/Syntax/Position.hs-boot +3/−0
- src/full/Agda/Syntax/Reflected.hs +77/−0
- src/full/Agda/Syntax/Scope/Base.hs +1743/−608
- src/full/Agda/Syntax/Scope/Monad.hs +1192/−438
- src/full/Agda/Syntax/Scope/Operator.hs +220/−0
- src/full/Agda/Syntax/Scope/State.hs +52/−0
- src/full/Agda/Syntax/Scope/UnusedImports.hs +327/−0
- src/full/Agda/Syntax/Strict.hs +0/−100
- src/full/Agda/Syntax/TopLevelModuleName.hs +204/−0
- src/full/Agda/Syntax/TopLevelModuleName/Boot.hs +63/−0
- src/full/Agda/Syntax/Translation/AbstractToConcrete.hs +1944/−853
- src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs +4057/−1256
- src/full/Agda/Syntax/Translation/InternalToAbstract.hs +1700/−588
- src/full/Agda/Syntax/Translation/ReflectedToAbstract.hs +307/−0
- src/full/Agda/Syntax/Treeless.hs +355/−0
- src/full/Agda/Termination/CallGraph.hs +183/−533
- src/full/Agda/Termination/CallMatrix.hs +218/−0
- src/full/Agda/Termination/CutOff.hs +51/−0
- src/full/Agda/Termination/Lexicographic.hs +0/−238
- src/full/Agda/Termination/Matrix.hs +0/−339
- src/full/Agda/Termination/Monad.hs +705/−0
- src/full/Agda/Termination/Order.hs +327/−0
- src/full/Agda/Termination/RecCheck.hs +182/−0
- src/full/Agda/Termination/Semiring.hs +17/−62
- src/full/Agda/Termination/SparseMatrix.hs +331/−293
- src/full/Agda/Termination/TermCheck.hs +1602/−807
- src/full/Agda/Termination/Termination.hs +106/−224
- src/full/Agda/Tests.hs +0/−48
- src/full/Agda/TheTypeChecker.hs +9/−0
- src/full/Agda/TypeChecker.hs +0/−13
- src/full/Agda/TypeChecking/Abstract.hs +381/−59
- src/full/Agda/TypeChecking/CheckInternal.hs +425/−0
- src/full/Agda/TypeChecking/CheckInternal.hs-boot +35/−0
- src/full/Agda/TypeChecking/CompiledClause.hs +249/−46
- src/full/Agda/TypeChecking/CompiledClause/Compile.hs +405/−85
- src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot +4/−1
- src/full/Agda/TypeChecking/CompiledClause/Match.hs +198/−65
- src/full/Agda/TypeChecking/CompiledClause/Match.hs-boot +4/−2
- src/full/Agda/TypeChecking/Constraints.hs +309/−188
- src/full/Agda/TypeChecking/Constraints.hs-boot +17/−0
- src/full/Agda/TypeChecking/Conversion.hs +2389/−782
- src/full/Agda/TypeChecking/Conversion.hs-boot +18/−11
- src/full/Agda/TypeChecking/Conversion/Errors.hs +842/−0
- src/full/Agda/TypeChecking/Conversion/Errors.hs-boot +7/−0
- src/full/Agda/TypeChecking/Conversion/Pure.hs +92/−0
- src/full/Agda/TypeChecking/Coverage.hs +1626/−438
- src/full/Agda/TypeChecking/Coverage/Cubical.hs +1153/−0
- src/full/Agda/TypeChecking/Coverage/Match.hs +369/−85
- src/full/Agda/TypeChecking/Coverage/SplitClause.hs +137/−0
- src/full/Agda/TypeChecking/Coverage/SplitPattern.hs +137/−0
- src/full/Agda/TypeChecking/Coverage/SplitTree.hs +127/−0
- src/full/Agda/TypeChecking/Datatypes.hs +285/−45
- src/full/Agda/TypeChecking/Datatypes.hs-boot +6/−3
- src/full/Agda/TypeChecking/DeadCode.hs +199/−0
- src/full/Agda/TypeChecking/DiscrimTree.hs +443/−0
- src/full/Agda/TypeChecking/DiscrimTree/Types.hs +140/−0
- src/full/Agda/TypeChecking/DisplayForm.hs +270/−55
- src/full/Agda/TypeChecking/DropArgs.hs +82/−0
- src/full/Agda/TypeChecking/Eliminators.hs +0/−71
- src/full/Agda/TypeChecking/Empty.hs +105/−29
- src/full/Agda/TypeChecking/Empty.hs-boot +17/−5
- src/full/Agda/TypeChecking/Errors.hs +2344/−681
- src/full/Agda/TypeChecking/Errors.hs-boot +34/−0
- src/full/Agda/TypeChecking/Errors/Names.hs +387/−0
- src/full/Agda/TypeChecking/EtaContract.hs +91/−34
- src/full/Agda/TypeChecking/EtaContract.hs-boot +8/−0
- src/full/Agda/TypeChecking/Forcing.hs +235/−60
- src/full/Agda/TypeChecking/Free.hs +489/−161
- src/full/Agda/TypeChecking/Free/Base.hs +317/−0
- src/full/Agda/TypeChecking/Free/Generic.hs +356/−0
- src/full/Agda/TypeChecking/Free/Precompute.hs +122/−0
- src/full/Agda/TypeChecking/Free/Reduce.hs +258/−0
- src/full/Agda/TypeChecking/Free/Reduce.hs-boot +13/−0
- src/full/Agda/TypeChecking/Functions.hs +103/−0
- src/full/Agda/TypeChecking/Generalize.hs +1053/−0
- src/full/Agda/TypeChecking/IApplyConfluence.hs +245/−0
- src/full/Agda/TypeChecking/Implicit.hs +256/−32
- src/full/Agda/TypeChecking/Injectivity.hs +447/−185
- src/full/Agda/TypeChecking/Inlining.hs +29/−0
- src/full/Agda/TypeChecking/InstanceArguments.hs +1272/−0
- src/full/Agda/TypeChecking/InstanceArguments.hs-boot +8/−0
- src/full/Agda/TypeChecking/Irrelevance.hs too large to diff
- src/full/Agda/TypeChecking/Irrelevance.hs-boot too large to diff
- src/full/Agda/TypeChecking/Level.hs too large to diff
- src/full/Agda/TypeChecking/Level.hs-boot too large to diff
- src/full/Agda/TypeChecking/Level/Solve.hs too large to diff
- src/full/Agda/TypeChecking/LevelConstraints.hs too large to diff
- src/full/Agda/TypeChecking/Lock.hs too large to diff
- src/full/Agda/TypeChecking/Lock.hs-boot too large to diff
- src/full/Agda/TypeChecking/MetaVars.hs too large to diff
- src/full/Agda/TypeChecking/MetaVars.hs-boot too large to diff
- src/full/Agda/TypeChecking/MetaVars/Mention.hs too large to diff
- src/full/Agda/TypeChecking/MetaVars/Occurs.hs too large to diff
- src/full/Agda/TypeChecking/Modalities.hs too large to diff
- src/full/Agda/TypeChecking/Monad.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Base.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Base/Types.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Base/Warning.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Benchmark.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Builtin.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Builtin.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Caching.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Closure.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Constraints.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Context.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Context.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Debug.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Debug.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Env.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Exception.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Imports.hs too large to diff
- src/full/Agda/TypeChecking/Monad/MetaVars.hs too large to diff
- src/full/Agda/TypeChecking/Monad/MetaVars.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Modality.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Mutual.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Open.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Options.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Options.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Pure.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Pure.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Signature.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Signature.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/SizedTypes.hs too large to diff
- src/full/Agda/TypeChecking/Monad/State.hs too large to diff
- src/full/Agda/TypeChecking/Monad/State.hs-boot too large to diff
- src/full/Agda/TypeChecking/Monad/Statistics.hs too large to diff
- src/full/Agda/TypeChecking/Monad/Trace.hs too large to diff
- src/full/Agda/TypeChecking/Names.hs too large to diff
- src/full/Agda/TypeChecking/Opacity.hs too large to diff
- src/full/Agda/TypeChecking/Opacity.hs-boot too large to diff
- src/full/Agda/TypeChecking/Patterns/Abstract.hs too large to diff
- src/full/Agda/TypeChecking/Patterns/Internal.hs too large to diff
- src/full/Agda/TypeChecking/Patterns/Match.hs too large to diff
- src/full/Agda/TypeChecking/Patterns/Match.hs-boot too large to diff
- src/full/Agda/TypeChecking/Polarity.hs too large to diff
- src/full/Agda/TypeChecking/Polarity.hs-boot too large to diff
- src/full/Agda/TypeChecking/Positivity.hs too large to diff
- src/full/Agda/TypeChecking/Positivity/Occurrence.hs too large to diff
- src/full/Agda/TypeChecking/Positivity/OccurrenceAnalysis.hs too large to diff
- src/full/Agda/TypeChecking/Positivity/Warnings.hs too large to diff
- src/full/Agda/TypeChecking/Pretty.hs too large to diff
- src/full/Agda/TypeChecking/Pretty.hs-boot too large to diff
- src/full/Agda/TypeChecking/Pretty/Call.hs too large to diff
- src/full/Agda/TypeChecking/Pretty/Call.hs-boot too large to diff
- src/full/Agda/TypeChecking/Pretty/Constraint.hs too large to diff
- src/full/Agda/TypeChecking/Pretty/Constraint.hs-boot too large to diff
- src/full/Agda/TypeChecking/Pretty/Warning.hs too large to diff
- src/full/Agda/TypeChecking/Pretty/Warning.hs-boot too large to diff
- src/full/Agda/TypeChecking/Primitive.hs too large to diff
- src/full/Agda/TypeChecking/Primitive.hs-boot too large to diff
- src/full/Agda/TypeChecking/Primitive/Base.hs too large to diff
- src/full/Agda/TypeChecking/Primitive/Cubical.hs too large to diff
- src/full/Agda/TypeChecking/Primitive/Cubical/Base.hs too large to diff
- src/full/Agda/TypeChecking/Primitive/Cubical/Base.hs-boot too large to diff
- src/full/Agda/TypeChecking/Primitive/Cubical/Glue.hs too large to diff
- src/full/Agda/TypeChecking/Primitive/Cubical/HCompU.hs too large to diff
- src/full/Agda/TypeChecking/ProjectionLike.hs too large to diff
- src/full/Agda/TypeChecking/ProjectionLike.hs-boot too large to diff
- src/full/Agda/TypeChecking/Quote.hs too large to diff
- src/full/Agda/TypeChecking/Rebind.hs too large to diff
- src/full/Agda/TypeChecking/ReconstructParameters.hs too large to diff
- src/full/Agda/TypeChecking/RecordPatterns.hs too large to diff
- src/full/Agda/TypeChecking/Records.hs too large to diff
- src/full/Agda/TypeChecking/Records.hs-boot too large to diff
- src/full/Agda/TypeChecking/Reduce.hs too large to diff
- src/full/Agda/TypeChecking/Reduce.hs-boot too large to diff
- src/full/Agda/TypeChecking/Reduce/Fast.hs too large to diff
- src/full/Agda/TypeChecking/Reduce/Fast.hs-boot too large to diff
- src/full/Agda/TypeChecking/Reduce/Monad.hs too large to diff
- src/full/Agda/TypeChecking/Rewriting.hs too large to diff
- src/full/Agda/TypeChecking/Rewriting.hs-boot too large to diff
- src/full/Agda/TypeChecking/Rewriting/Clause.hs too large to diff
- src/full/Agda/TypeChecking/Rewriting/Confluence.hs too large to diff
- src/full/Agda/TypeChecking/Rewriting/NonLinMatch.hs too large to diff
- src/full/Agda/TypeChecking/Rewriting/NonLinPattern.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Application.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Application.hs-boot too large to diff
- src/full/Agda/TypeChecking/Rules/Builtin.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs-boot too large to diff
- src/full/Agda/TypeChecking/Rules/Data.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Data.hs-boot too large to diff
- src/full/Agda/TypeChecking/Rules/Decl.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Decl.hs-boot too large to diff
- src/full/Agda/TypeChecking/Rules/Def.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Def.hs-boot too large to diff
- src/full/Agda/TypeChecking/Rules/Display.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Instantiate.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Problem.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/ProblemRest.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Split.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Unify.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Unify/LeftInverse.hs too large to diff
- src/full/Agda/TypeChecking/Rules/LHS/Unify/Types.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Record.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Record/Cubical.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Term.hs too large to diff
- src/full/Agda/TypeChecking/Rules/Term.hs-boot too large to diff
- src/full/Agda/TypeChecking/Serialise.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Base.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/Abstract.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/Common.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/Compilers.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/Errors.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/General.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/Highlighting.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs too large to diff
- src/full/Agda/TypeChecking/Serialise/Node.hs too large to diff
- src/full/Agda/TypeChecking/SizedTypes.hs too large to diff
- src/full/Agda/TypeChecking/SizedTypes/Pretty.hs too large to diff
- src/full/Agda/TypeChecking/SizedTypes/Solve.hs too large to diff
- src/full/Agda/TypeChecking/SizedTypes/Syntax.hs too large to diff
- src/full/Agda/TypeChecking/SizedTypes/Utils.hs too large to diff
- src/full/Agda/TypeChecking/SizedTypes/WarshallSolver.hs too large to diff
- src/full/Agda/TypeChecking/Sort.hs too large to diff
- src/full/Agda/TypeChecking/Substitute.hs too large to diff
- src/full/Agda/TypeChecking/Substitute/Class.hs too large to diff
- src/full/Agda/TypeChecking/Substitute/DeBruijn.hs too large to diff
- src/full/Agda/TypeChecking/SyntacticEquality.hs too large to diff
- src/full/Agda/TypeChecking/Telescope.hs too large to diff
- src/full/Agda/TypeChecking/Telescope.hs-boot too large to diff
- src/full/Agda/TypeChecking/Telescope/Path.hs too large to diff
- src/full/Agda/TypeChecking/Test/Generators.hs too large to diff
- src/full/Agda/TypeChecking/Tests.hs too large to diff
- src/full/Agda/TypeChecking/UniversePolymorphism.hs too large to diff
- src/full/Agda/TypeChecking/UniversePolymorphism.hs-boot too large to diff
- src/full/Agda/TypeChecking/Unquote.hs too large to diff
- src/full/Agda/TypeChecking/Warnings.hs too large to diff
- src/full/Agda/TypeChecking/With.hs too large to diff
- src/full/Agda/Utils/AffineHole.hs too large to diff
- src/full/Agda/Utils/Applicative.hs too large to diff
- src/full/Agda/Utils/AssocList.hs too large to diff
- src/full/Agda/Utils/Atomic.hs too large to diff
- src/full/Agda/Utils/Bag.hs too large to diff
- src/full/Agda/Utils/Benchmark.hs too large to diff
- src/full/Agda/Utils/BiMap.hs too large to diff
- src/full/Agda/Utils/BinTree.hs too large to diff
- src/full/Agda/Utils/BinTree1.hs too large to diff
- src/full/Agda/Utils/BoolSet.hs too large to diff
- src/full/Agda/Utils/Boolean.hs too large to diff
- src/full/Agda/Utils/ByteArray.hs too large to diff
- src/full/Agda/Utils/CallStack.hs too large to diff
- src/full/Agda/Utils/CallStack/Base.hs too large to diff
- src/full/Agda/Utils/CallStack/Pretty.hs too large to diff
- src/full/Agda/Utils/Char.hs too large to diff
- src/full/Agda/Utils/Cluster.hs too large to diff
- src/full/Agda/Utils/CompactRegion.hs too large to diff
- src/full/Agda/Utils/CompressedTrie.hs too large to diff
- src/full/Agda/Utils/DocTree.hs too large to diff
- src/full/Agda/Utils/Either.hs too large to diff
- src/full/Agda/Utils/Empty.hs too large to diff
- src/full/Agda/Utils/Environment.hs too large to diff
- src/full/Agda/Utils/ExpandCase.hs too large to diff
- src/full/Agda/Utils/Fail.hs too large to diff
- src/full/Agda/Utils/Favorites.hs too large to diff
- src/full/Agda/Utils/FileId.hs too large to diff
- src/full/Agda/Utils/FileName.hs too large to diff
- src/full/Agda/Utils/Float.hs too large to diff
- src/full/Agda/Utils/Fresh.hs too large to diff
- src/full/Agda/Utils/Function.hs too large to diff
- src/full/Agda/Utils/Functor.hs too large to diff
- src/full/Agda/Utils/Generics.hs too large to diff
- src/full/Agda/Utils/GetOpt.hs too large to diff
- src/full/Agda/Utils/Graph.hs too large to diff
- src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional.hs too large to diff
- src/full/Agda/Utils/Graph/TopSort.hs too large to diff
- src/full/Agda/Utils/Hash.hs too large to diff
- src/full/Agda/Utils/HashTable.hs too large to diff
- src/full/Agda/Utils/Haskell/Syntax.hs too large to diff
- src/full/Agda/Utils/IArray.hs too large to diff
- src/full/Agda/Utils/IO.hs too large to diff
- src/full/Agda/Utils/IO/Binary.hs too large to diff
- src/full/Agda/Utils/IO/Directory.hs too large to diff
- src/full/Agda/Utils/IO/Locale.hs too large to diff
- src/full/Agda/Utils/IO/TempFile.hs too large to diff
- src/full/Agda/Utils/IO/Terminal.hs too large to diff
- src/full/Agda/Utils/IO/UTF8.hs too large to diff
- src/full/Agda/Utils/IORef.hs too large to diff
- src/full/Agda/Utils/IORef/Strict.hs too large to diff
- src/full/Agda/Utils/Impossible.hs too large to diff
- src/full/Agda/Utils/IndexMap.hs too large to diff
- src/full/Agda/Utils/IndexedList.hs too large to diff
- src/full/Agda/Utils/IntMap.hs too large to diff
- src/full/Agda/Utils/IntSet/Infinite.hs too large to diff
- src/full/Agda/Utils/Lens.hs too large to diff
- src/full/Agda/Utils/Lens/Examples.hs too large to diff
- src/full/Agda/Utils/List.hs too large to diff
- src/full/Agda/Utils/List1.hs too large to diff
- src/full/Agda/Utils/List1.hs-boot too large to diff
- src/full/Agda/Utils/List2.hs too large to diff
- src/full/Agda/Utils/ListInf.hs too large to diff
- src/full/Agda/Utils/ListT.hs too large to diff
- src/full/Agda/Utils/Map.hs too large to diff
- src/full/Agda/Utils/Map1.hs too large to diff
- src/full/Agda/Utils/Maybe.hs too large to diff
- src/full/Agda/Utils/Maybe/Strict.hs too large to diff
- src/full/Agda/Utils/Maybe/Unboxable.hs too large to diff
- src/full/Agda/Utils/Memo.hs too large to diff
- src/full/Agda/Utils/MinimalArray/Lifted.hs too large to diff
- src/full/Agda/Utils/MinimalArray/MutableLifted.hs too large to diff
- src/full/Agda/Utils/MinimalArray/MutablePrim.hs too large to diff
- src/full/Agda/Utils/MinimalArray/Prim.hs too large to diff
- src/full/Agda/Utils/Monad.hs too large to diff
- src/full/Agda/Utils/Monoid.hs too large to diff
- src/full/Agda/Utils/Null.hs too large to diff
- src/full/Agda/Utils/POMonoid.hs too large to diff
- src/full/Agda/Utils/Parser/MemoisedCPS.hs too large to diff
- src/full/Agda/Utils/PartialOrd.hs too large to diff
- src/full/Agda/Utils/Permutation.hs too large to diff
- src/full/Agda/Utils/Pointer.hs too large to diff
- src/full/Agda/Utils/Pretty.hs too large to diff
- src/full/Agda/Utils/QuickCheck.hs too large to diff
- src/full/Agda/Utils/Range.hs too large to diff
- src/full/Agda/Utils/RangeMap.hs too large to diff
- src/full/Agda/Utils/ReadP.hs too large to diff
- src/full/Agda/Utils/SemiRing.hs too large to diff
- src/full/Agda/Utils/Semigroup.hs too large to diff
- src/full/Agda/Utils/Serialize.hs too large to diff
- src/full/Agda/Utils/Set.hs too large to diff
- src/full/Agda/Utils/Set1.hs too large to diff
- src/full/Agda/Utils/Singleton.hs too large to diff
- src/full/Agda/Utils/Size.hs too large to diff
- src/full/Agda/Utils/SmallSet.hs too large to diff
- src/full/Agda/Utils/StrictEndo.hs too large to diff
- src/full/Agda/Utils/StrictFlipEndo.hs too large to diff
- src/full/Agda/Utils/StrictReader.hs too large to diff
- src/full/Agda/Utils/StrictState.hs too large to diff
- src/full/Agda/Utils/StrictState2.hs too large to diff
- src/full/Agda/Utils/StrictWriter.hs too large to diff
- src/full/Agda/Utils/String.hs too large to diff
- src/full/Agda/Utils/Suffix.hs too large to diff
- src/full/Agda/Utils/TestHelpers.hs too large to diff
- src/full/Agda/Utils/Three.hs too large to diff
- src/full/Agda/Utils/Time.hs too large to diff
- src/full/Agda/Utils/Trie.hs too large to diff
- src/full/Agda/Utils/Tuple.hs too large to diff
- src/full/Agda/Utils/Tuple/Strict.hs too large to diff
- src/full/Agda/Utils/TypeLevel.hs too large to diff
- src/full/Agda/Utils/TypeLits.hs too large to diff
- src/full/Agda/Utils/Unicode.hs too large to diff
- src/full/Agda/Utils/Unsafe.hs too large to diff
- src/full/Agda/Utils/Update.hs too large to diff
- src/full/Agda/Utils/VarSet.hs too large to diff
- src/full/Agda/Utils/Warshall.hs too large to diff
- src/full/Agda/Utils/WithDefault.hs too large to diff
- src/full/Agda/Utils/Word.hs too large to diff
- src/full/Agda/Utils/Zip.hs too large to diff
- src/full/Agda/Utils/Zipper.hs too large to diff
- src/full/Agda/Version.hs too large to diff
- src/full/Agda/undefined.h too large to diff
- src/main/Main.hs too large to diff
- src/setup/Agda/Setup.hs too large to diff
- src/setup/Agda/Setup/DataFiles.hs too large to diff
- src/setup/Agda/Setup/EmacsMode.hs too large to diff
- src/setup/Agda/Setup/LockFile.hs too large to diff
- src/setup/Agda/Version.hs too large to diff
- src/setup/Agda/VersionCommit.hs too large to diff
- stack-9.10.3.yaml too large to diff
- stack-9.12.4.yaml too large to diff
- stack-9.14.1.yaml too large to diff
- stack-9.2.8.yaml too large to diff
- stack-9.4.8.yaml too large to diff
- stack-9.6.7.yaml too large to diff
- stack-9.8.4.yaml too large to diff
@@ -1,341 +1,1086 @@-name: Agda-version: 2.3.0.1-cabal-version: >= 1.8-build-type: Simple-license: OtherLicense-license-file: LICENSE-author: Ulf Norell, Nils Anders Danielsson, Catarina Coquand, Makoto Takeyama, Andreas Abel, Darin Morrison...-maintainer: Ulf Norell <ulfn@chalmers.se>-homepage: http://wiki.portal.chalmers.se/agda/-bug-reports: http://code.google.com/p/agda/issues/list-category: Dependent types-synopsis: A dependently typed functional programming language and proof assistant-description:- Agda is a dependently typed functional programming language: It has- inductive families, which are similar to Haskell's GADTs, but they- can be indexed by values and not just types. It also has- parameterised modules, mixfix operators, Unicode characters, and an- interactive Emacs interface (the type checker can assist in the- development of your code).- .- Agda is also a proof assistant: It is an interactive system for- writing and checking proofs. Agda is based on intuitionistic type- theory, a foundational system for constructive mathematics developed- by the Swedish logician Per Martin-Löf. It has many- similarities with other proof assistants based on dependent types,- such as Coq, Epigram and NuPRL.- .- Note that if you want to use the command-line program (agda), then- you should also install the Agda-executable package. The Agda- package includes an Emacs mode for Agda, but you need to set up the- Emacs mode yourself (for instance by running @agda-mode setup@; see- the README).- .- Note also that this library does not follow the package versioning- policy, because the library is only intended to be used by the Emacs- mode and the Agda-executable package.-tested-with: GHC == 7.4.1-extra-source-files: src/full/Agda/undefined.h- README- doc/release-notes/*.txt-data-dir: src/data-data-files: Agda.css- emacs-mode/*.el- EpicInclude/AgdaPrelude.e- EpicInclude/stdagda.c- EpicInclude/stdagda.h--source-repository head- type: darcs- location: http://code.haskell.org/Agda/--source-repository this- type: darcs- location: http://code.haskell.org/Agda/- tag: 2.3.0--flag use-locale- description:- Try to use the character encoding specified by the locale for most- of the IO going to/from stdin and stdout. (Note that source files- must always be encoded using UTF8.)--flag epic- default: False- manual: True- description:- Install the Epic compiler.--library- hs-source-dirs: src/full- if flag(use-locale)- build-depends: base >= 4.2 && < 4.6- else- build-depends: base == 4.1.*,- utf8-string == 0.3.*- if flag(epic)- build-depends: epic >= 0.1.13 && < 0.10- build-depends: mtl == 2.0.*,- QuickCheck >= 2.3 && < 2.5,- haskell-src-exts >= 1.9.6 && < 1.12,- containers >= 0.1 && < 0.5,- pretty >= 1.0 && < 1.2,- directory >= 1.0 && < 1.2,- old-time >= 1.0 && < 1.2,- bytestring >= 0.9.0.1 && < 0.10,- array >= 0.1 && < 0.5,- binary >= 0.4.4 && < 0.6,- zlib >= 0.4.0.1 && < 0.6,- filepath >= 1.1 && < 1.4,- process >= 1.0.1.0 && < 1.2,- haskeline >= 0.6.3.2 && < 0.7,- xhtml == 3000.2.*,- hashable == 1.1.*,- hashtables == 1.0.*,- syb >= 0.1 && < 0.4- build-tools: happy >= 1.15 && < 2,- alex >= 2.3.1 && < 3.1- extensions: CPP- exposed-modules: Agda.Main- Agda.ImpossibleTest- Agda.Interaction.BasicOps- Agda.Interaction.GhciTop- Agda.Compiler.HaskellTypes- Agda.Compiler.Epic.AuxAST- Agda.Compiler.Epic.CaseOpts- Agda.Compiler.Epic.Compiler- Agda.Compiler.Epic.CompileState- Agda.Compiler.Epic.Epic- Agda.Compiler.Epic.Erasure- Agda.Compiler.Epic.ForceConstrs- Agda.Compiler.Epic.Forcing- Agda.Compiler.Epic.FromAgda- Agda.Compiler.Epic.Injection- Agda.Compiler.Epic.Interface- Agda.Compiler.Epic.NatDetection- Agda.Compiler.Epic.Primitive- Agda.Compiler.Epic.Smashing- Agda.Compiler.Epic.Static- Agda.Compiler.JS.Case- Agda.Compiler.JS.Compiler- Agda.Compiler.JS.Syntax- Agda.Compiler.JS.Substitution- Agda.Compiler.JS.Parser- Agda.Compiler.JS.Pretty- Agda.Compiler.MAlonzo.Compiler- Agda.Compiler.MAlonzo.Encode- Agda.Compiler.MAlonzo.Misc- Agda.Compiler.MAlonzo.Pretty- Agda.Compiler.MAlonzo.Primitives- Agda.Packaging.Config- Agda.Packaging.Database- Agda.Packaging.Monad- Agda.Packaging.Types- Agda.Interaction.CommandLine.CommandLine- Agda.Interaction.EmacsCommand- Agda.Interaction.Exceptions- Agda.Interaction.FindFile- Agda.Interaction.Highlighting.Dot- Agda.Interaction.Highlighting.Emacs- Agda.Interaction.Highlighting.Generate- Agda.Interaction.Highlighting.HTML- Agda.Interaction.Highlighting.Precise- Agda.Interaction.Highlighting.Range- Agda.Interaction.Highlighting.Vim- Agda.Interaction.Imports- Agda.Interaction.MakeCase- Agda.Interaction.Monad- Agda.Interaction.Options- Agda.Syntax.Abstract.Name- Agda.Syntax.Abstract.Pretty- Agda.Syntax.Abstract.Views- Agda.Syntax.Abstract- Agda.Syntax.Common- Agda.Syntax.Concrete.Definitions- Agda.Syntax.Concrete.Name- Agda.Syntax.Concrete.Operators.Parser- Agda.Syntax.Concrete.Operators- Agda.Syntax.Concrete.Pretty- Agda.Syntax.Concrete- Agda.Syntax.Fixity- Agda.Syntax.Info- Agda.Syntax.Internal- Agda.Syntax.Internal.Generic- Agda.Syntax.Internal.Pattern- Agda.Syntax.Literal- Agda.Syntax.Notation- Agda.Syntax.Parser.Alex- Agda.Syntax.Parser.Comments- Agda.Syntax.Parser.Layout- Agda.Syntax.Parser.LexActions- Agda.Syntax.Parser.Lexer- Agda.Syntax.Parser.LookAhead- Agda.Syntax.Parser.Monad- Agda.Syntax.Parser.Parser- Agda.Syntax.Parser.StringLiterals- Agda.Syntax.Parser.Tokens- Agda.Syntax.Parser- Agda.Syntax.Position- Agda.Syntax.Scope.Base- Agda.Syntax.Scope.Monad- Agda.Syntax.Strict- Agda.Syntax.Translation.AbstractToConcrete- Agda.Syntax.Translation.ConcreteToAbstract- Agda.Syntax.Translation.InternalToAbstract- Agda.Termination.CallGraph- Agda.Termination.Lexicographic- Agda.Termination.Matrix- Agda.Termination.SparseMatrix- Agda.Termination.Semiring- Agda.Termination.TermCheck- Agda.Termination.Termination- Agda.Tests- Agda.TypeChecker- Agda.TypeChecking.Abstract- Agda.TypeChecking.CompiledClause- Agda.TypeChecking.CompiledClause.Compile- Agda.TypeChecking.CompiledClause.Match- Agda.TypeChecking.Constraints- Agda.TypeChecking.Conversion- Agda.TypeChecking.Coverage- Agda.TypeChecking.Coverage.Match- Agda.TypeChecking.Datatypes- Agda.TypeChecking.DisplayForm- Agda.TypeChecking.Eliminators- Agda.TypeChecking.Empty- Agda.TypeChecking.EtaContract- Agda.TypeChecking.Errors- Agda.TypeChecking.Free- Agda.TypeChecking.Forcing- Agda.TypeChecking.Implicit- Agda.TypeChecking.Injectivity- Agda.TypeChecking.Irrelevance- Agda.TypeChecking.Level- Agda.TypeChecking.LevelConstraints- Agda.TypeChecking.MetaVars- Agda.TypeChecking.MetaVars.Mention- Agda.TypeChecking.MetaVars.Occurs- Agda.TypeChecking.Monad.Base- Agda.TypeChecking.Monad.Builtin- Agda.TypeChecking.Monad.Closure- Agda.TypeChecking.Monad.Constraints- Agda.TypeChecking.Monad.Context- Agda.TypeChecking.Monad.Debug- Agda.TypeChecking.Monad.Env- Agda.TypeChecking.Monad.Exception- Agda.TypeChecking.Monad.Imports- Agda.TypeChecking.Monad.MetaVars- Agda.TypeChecking.Monad.Mutual- Agda.TypeChecking.Monad.Open- Agda.TypeChecking.Monad.Options- Agda.TypeChecking.Monad.Signature- Agda.TypeChecking.Monad.SizedTypes- Agda.TypeChecking.Monad.State- Agda.TypeChecking.Monad.Statistics- Agda.TypeChecking.Monad.Trace- Agda.TypeChecking.Monad- Agda.TypeChecking.Patterns.Match- Agda.TypeChecking.Polarity- Agda.TypeChecking.Positivity- Agda.TypeChecking.Pretty- Agda.TypeChecking.Primitive- Agda.TypeChecking.Quote- Agda.TypeChecking.Rebind- Agda.TypeChecking.RecordPatterns- Agda.TypeChecking.Records- Agda.TypeChecking.Reduce- Agda.TypeChecking.Rules.Builtin- Agda.TypeChecking.Rules.Builtin.Coinduction- Agda.TypeChecking.Rules.Data- Agda.TypeChecking.Rules.Decl- Agda.TypeChecking.Rules.Def- Agda.TypeChecking.Rules.LHS- Agda.TypeChecking.Rules.LHS.Implicit- Agda.TypeChecking.Rules.LHS.Instantiate- Agda.TypeChecking.Rules.LHS.Problem- Agda.TypeChecking.Rules.LHS.Split- Agda.TypeChecking.Rules.LHS.Unify- Agda.TypeChecking.Rules.Record- Agda.TypeChecking.Rules.Term- Agda.TypeChecking.Serialise- Agda.TypeChecking.SizedTypes- Agda.TypeChecking.Substitute- Agda.TypeChecking.Telescope- Agda.TypeChecking.Test.Generators- Agda.TypeChecking.Tests- Agda.TypeChecking.UniversePolymorphism- Agda.TypeChecking.With- Agda.Utils.VarSet- Agda.Utils.Char- Agda.Utils.Either- Agda.Utils.FileName- Agda.Utils.Fresh- Agda.Utils.Function- Agda.Utils.Generics- Agda.Utils.Graph- Agda.Utils.Hash- Agda.Utils.Impossible- Agda.Utils.IO.Binary- Agda.Utils.IO.Locale- Agda.Utils.IO.UTF8- Agda.Utils.List- Agda.Utils.Map- Agda.Utils.Maybe- Agda.Utils.Monad- Agda.Utils.Permutation- Agda.Utils.Pointer- Agda.Utils.Pretty- Agda.Utils.QuickCheck- Agda.Utils.ReadP- Agda.Utils.SemiRing- Agda.Utils.Size- Agda.Utils.String- Agda.Utils.Suffix- Agda.Utils.TestHelpers- Agda.Utils.Trie- Agda.Utils.Tuple- Agda.Utils.Unicode- Agda.Utils.Warshall- Agda.Version- Agda.Auto.Auto- Agda.Auto.Convert- Agda.Auto.Typecheck- Agda.Auto.NarrowingSearch- Agda.Auto.Syntax- Agda.Auto.SearchControl- Agda.Auto.CaseSplit- other-modules: Paths_Agda- if true- ghc-options: -w- -fwarn-deprecated-flags- -fwarn-dodgy-foreign-imports- -fwarn-dodgy-imports- -fwarn-duplicate-exports- -fwarn-hi-shadowing- -fwarn-incomplete-patterns- -fwarn-missing-fields- -fwarn-missing-methods- -fwarn-overlapping-patterns- -fwarn-warnings-deprecations- -- The Cabal-generated module Paths_Agda triggers a warning under- -- GHC 7.2.1/7.2.2 (at least when certain versions of Cabal are- -- used).- if impl(ghc >= 6.12)- ghc-options: -fwarn-dodgy-exports- -fwarn-wrong-do-bind- if impl(ghc >= 7.2)- ghc-options: -fwarn-identities- ghc-prof-options: -auto-all--executable agda-mode- hs-source-dirs: src/agda-mode- main-is: Main.hs- other-modules: Paths_Agda- if flag(use-locale)- build-depends: base >= 4.2 && < 4.6- else- build-depends: base == 4.1.*,- utf8-string == 0.3.*- build-depends: filepath >= 1.1 && < 1.4,- process >= 1.0.1.0 && < 1.2,- directory >= 1.0 && < 1.2+cabal-version: 2.4+name: Agda+version: 2.9.0+build-type: Simple+license: MIT+license-file: LICENSE+copyright: (c) 2005-2026 The Agda Team.+author: The Agda Team, see https://agda.readthedocs.io/en/latest/team.html+maintainer: The Agda Team+homepage: https://wiki.portal.chalmers.se/agda/+bug-reports: https://github.com/agda/agda/issues+category: Dependent types+synopsis: A dependently typed functional programming language and proof assistant+description:+ Agda is a dependently typed functional programming language: It has+ inductive families, which are similar to Haskell's GADTs, but they+ can be indexed by values and not just types. It also has+ parameterised modules, mixfix operators, Unicode characters, and an+ interactive Emacs interface (the type checker can assist in the+ development of your code).+ .+ Agda is also a proof assistant: It is an interactive system for+ writing and checking proofs. Agda is based on intuitionistic type+ theory, a foundational system for constructive mathematics developed+ by the Swedish logician Per Martin-Löf. It has many+ similarities with other proof assistants based on dependent types,+ such as Rocq (formerly known as Coq), Idris, Lean and NuPRL.+ .+ This package includes both a command-line program (agda) and an+ Emacs mode.++tested-with:+ GHC == 9.14.1+ GHC == 9.12.4+ GHC == 9.10.3+ GHC == 9.8.4+ GHC == 9.6.7+ GHC == 9.4.8+ GHC == 9.2.8++extra-doc-files:+ CHANGELOG.md+ README.md+ doc/user-manual/agda.svg+ doc/release-notes/2.8.0.2.md+ doc/release-notes/2.8.0.1.md+ doc/release-notes/2.8.0.md+ doc/release-notes/2.7.0.1.md+ doc/release-notes/2.7.0.md+ doc/release-notes/2.6.4.3.md+ doc/release-notes/2.6.4.2.md+ doc/release-notes/2.6.4.1.md+ doc/release-notes/2.6.4.md+ doc/release-notes/2.6.3.md+ doc/release-notes/2.6.2.2.md+ doc/release-notes/2.6.2.1.md+ doc/release-notes/2.6.2.md+ doc/release-notes/2.6.1.3.md+ doc/release-notes/2.6.1.2.md+ doc/release-notes/2.6.1.1.md+ doc/release-notes/2.6.1.md+ doc/release-notes/2.6.0.1.md+ doc/release-notes/2.6.0.md+ doc/release-notes/2.5.4.2.md+ doc/release-notes/2.5.4.1.md+ doc/release-notes/2.5.4.md+ doc/release-notes/2.5.3.md+ doc/release-notes/2.5.2.md+ doc/release-notes/2.5.1.2.md+ doc/release-notes/2.5.1.1.md+ doc/release-notes/2.5.1.md+ doc/release-notes/2.4.2.5.md+ doc/release-notes/2.4.2.4.md+ doc/release-notes/2.4.2.3.md+ doc/release-notes/2.4.2.2.md+ doc/release-notes/2.4.2.1.md+ doc/release-notes/2.4.2.md+ doc/release-notes/2.4.0.2.md+ doc/release-notes/2.4.0.1.md+ doc/release-notes/2.4.0.md+ doc/release-notes/2.3.2.2.md+ doc/release-notes/2.3.2.1.md+ doc/release-notes/2.3.2.md+ doc/release-notes/2.3.0.md+ doc/release-notes/2.2.10.md+ doc/release-notes/2.2.8.md+ doc/release-notes/2.2.6.md+ doc/release-notes/2.2.2.md+ doc/release-notes/2.2.4.md+ doc/release-notes/2.2.0.md++extra-source-files:+ stack-9.14.1.yaml+ stack-9.12.4.yaml+ stack-9.10.3.yaml+ stack-9.8.4.yaml+ stack-9.6.7.yaml+ stack-9.4.8.yaml+ stack-9.2.8.yaml+ -- Agda's data files, embedded by module Agda.Setup.+ -- Keep in sync with the list in Agda.Setup.DataFiles and below.+ src/data/emacs-mode/agda-input.el+ src/data/emacs-mode/agda2-abbrevs.el+ src/data/emacs-mode/agda2-highlight.el+ src/data/emacs-mode/agda2-mode-pkg.el+ src/data/emacs-mode/agda2-mode.el+ src/data/emacs-mode/agda2-queue.el+ src/data/emacs-mode/agda2.el+ src/data/emacs-mode/annotation.el+ src/data/emacs-mode/eri.el+ src/data/html/Agda.css+ src/data/html/highlight-hover.js+ src/data/JS/agda-rts.mjs+ src/data/JS/agda-rts.js+ src/data/JS/agda-rts.amd.js+ src/data/latex/agda.sty+ src/data/latex/postprocess-latex.pl+ src/data/lib/prim/agda-builtins.agda-lib+ src/data/lib/prim/Agda/Builtin/Bool.agda+ src/data/lib/prim/Agda/Builtin/Char.agda+ src/data/lib/prim/Agda/Builtin/Char/Properties.agda+ src/data/lib/prim/Agda/Builtin/Coinduction.agda+ src/data/lib/prim/Agda/Builtin/Cubical/Path.agda+ src/data/lib/prim/Agda/Builtin/Cubical/Sub.agda+ src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda+ src/data/lib/prim/Agda/Builtin/Cubical/Equiv.agda+ src/data/lib/prim/Agda/Builtin/Cubical/HCompU.agda+ src/data/lib/prim/Agda/Builtin/Equality.agda+ src/data/lib/prim/Agda/Builtin/Equality/Erase.agda+ src/data/lib/prim/Agda/Builtin/Equality/Rewrite.agda+ src/data/lib/prim/Agda/Builtin/Erased/Box-cong.agda+ src/data/lib/prim/Agda/Builtin/Erased/Erased.agda+ src/data/lib/prim/Agda/Builtin/Erased/Funext.agda+ src/data/lib/prim/Agda/Builtin/Erased/Propext.agda+ src/data/lib/prim/Agda/Builtin/Erased/Quotient.agda+ src/data/lib/prim/Agda/Builtin/Float.agda+ src/data/lib/prim/Agda/Builtin/Float/Properties.agda+ src/data/lib/prim/Agda/Builtin/FromNat.agda+ src/data/lib/prim/Agda/Builtin/FromNeg.agda+ src/data/lib/prim/Agda/Builtin/FromString.agda+ src/data/lib/prim/Agda/Builtin/IO.agda+ src/data/lib/prim/Agda/Builtin/Int.agda+ src/data/lib/prim/Agda/Builtin/List.agda+ src/data/lib/prim/Agda/Builtin/Maybe.agda+ src/data/lib/prim/Agda/Builtin/Nat.agda+ src/data/lib/prim/Agda/Builtin/Reflection.agda+ src/data/lib/prim/Agda/Builtin/Reflection/External.agda+ src/data/lib/prim/Agda/Builtin/Reflection/Properties.agda+ src/data/lib/prim/Agda/Builtin/Sigma.agda+ src/data/lib/prim/Agda/Builtin/Size.agda+ src/data/lib/prim/Agda/Builtin/Strict.agda+ src/data/lib/prim/Agda/Builtin/String.agda+ src/data/lib/prim/Agda/Builtin/String/Properties.agda+ src/data/lib/prim/Agda/Builtin/TrustMe.agda+ src/data/lib/prim/Agda/Builtin/Unit.agda+ src/data/lib/prim/Agda/Builtin/Word.agda+ src/data/lib/prim/Agda/Builtin/Word/Properties.agda+ src/data/lib/prim/Agda/Primitive.agda+ src/data/lib/prim/Agda/Primitive/Cubical.agda+ src/data/MAlonzo/src/MAlonzo/RTE.hs+ src/data/MAlonzo/src/MAlonzo/RTE/Float.hs++data-dir: src/data+data-files:+ emacs-mode/agda-input.el+ emacs-mode/agda2-abbrevs.el+ emacs-mode/agda2-highlight.el+ emacs-mode/agda2-mode-pkg.el+ emacs-mode/agda2-mode.el+ emacs-mode/agda2-queue.el+ emacs-mode/agda2.el+ emacs-mode/annotation.el+ emacs-mode/eri.el+ html/Agda.css+ html/highlight-hover.js+ JS/agda-rts.mjs+ JS/agda-rts.js+ JS/agda-rts.amd.js+ latex/agda.sty+ latex/postprocess-latex.pl+ lib/prim/agda-builtins.agda-lib+ lib/prim/Agda/Builtin/Bool.agda+ lib/prim/Agda/Builtin/Char.agda+ lib/prim/Agda/Builtin/Char/Properties.agda+ lib/prim/Agda/Builtin/Coinduction.agda+ lib/prim/Agda/Builtin/Cubical/Path.agda+ lib/prim/Agda/Builtin/Cubical/Sub.agda+ lib/prim/Agda/Builtin/Cubical/Glue.agda+ lib/prim/Agda/Builtin/Cubical/Equiv.agda+ lib/prim/Agda/Builtin/Cubical/HCompU.agda+ lib/prim/Agda/Builtin/Equality.agda+ lib/prim/Agda/Builtin/Equality/Erase.agda+ lib/prim/Agda/Builtin/Equality/Rewrite.agda+ lib/prim/Agda/Builtin/Erased/Box-cong.agda+ lib/prim/Agda/Builtin/Erased/Erased.agda+ lib/prim/Agda/Builtin/Erased/Funext.agda+ lib/prim/Agda/Builtin/Erased/Propext.agda+ lib/prim/Agda/Builtin/Erased/Quotient.agda+ lib/prim/Agda/Builtin/Float.agda+ lib/prim/Agda/Builtin/Float/Properties.agda+ lib/prim/Agda/Builtin/FromNat.agda+ lib/prim/Agda/Builtin/FromNeg.agda+ lib/prim/Agda/Builtin/FromString.agda+ lib/prim/Agda/Builtin/IO.agda+ lib/prim/Agda/Builtin/Int.agda+ lib/prim/Agda/Builtin/List.agda+ lib/prim/Agda/Builtin/Maybe.agda+ lib/prim/Agda/Builtin/Nat.agda+ lib/prim/Agda/Builtin/Reflection.agda+ lib/prim/Agda/Builtin/Reflection/External.agda+ lib/prim/Agda/Builtin/Reflection/Properties.agda+ lib/prim/Agda/Builtin/Sigma.agda+ lib/prim/Agda/Builtin/Size.agda+ lib/prim/Agda/Builtin/Strict.agda+ lib/prim/Agda/Builtin/String.agda+ lib/prim/Agda/Builtin/String/Properties.agda+ lib/prim/Agda/Builtin/TrustMe.agda+ lib/prim/Agda/Builtin/Unit.agda+ lib/prim/Agda/Builtin/Word.agda+ lib/prim/Agda/Builtin/Word/Properties.agda+ lib/prim/Agda/Primitive.agda+ lib/prim/Agda/Primitive/Cubical.agda+ MAlonzo/src/MAlonzo/RTE.hs+ MAlonzo/src/MAlonzo/RTE/Float.hs++source-repository head+ type: git+ location: https://github.com/agda/agda.git++source-repository this+ type: git+ location: https://github.com/agda/agda.git+ tag: v2.9.0++-- Build flags+---------------------------------------------------------------------------++flag dump-core+ default: False+ manual: True+ description: Write GHC core output.++flag debug+ default: False+ manual: True+ description:+ Enable debug printing. This makes Agda slightly slower, and+ building Agda slower as well. The --verbose=N option only+ has an effect when Agda was built with this flag.++flag debug-serialisation+ default: False+ manual: True+ description:+ Enable debug mode in serialisation. This makes serialisation slower.++flag debug-parsing+ default: False+ manual: True+ description:+ Enable debug mode in parsing. This makes parsing slower.++flag enable-cluster-counting+ default: False+ manual: True+ description:+ Enable the --count-clusters flag. (If enable-cluster-counting is+ False, then the --count-clusters flag triggers an error message.)++flag optimise-heavily+ default: True+ manual: True+ description:+ Enable some expensive optimisations when compiling Agda.++flag use-xdg-data-home+ default: False+ manual: True+ description:+ Install data files under $XDG_DATA_HOME\/agda\/$AGDA_VERSION by default+ instead of the installation location defined by Cabal.+ This should not be enabled in declarative build environments like Nix or Guix.++flag version-with-git-hash+ default: False+ manual: True+ description:+ Suffix version information with the Git commit hash when available.++flag ignore-build-tool-depends+ default: False+ manual: True+ description:+ Ignore the build-tool-depends stanza, and trust user-provided tools on the PATH.+ This is intended to be used in declarative build environemnts like Nix or Guix,+ which will manage the installation of build tools like alex or happy.+ See github.com/NixOS/nixpkgs/issues/130556 and https://github.com/haskell/cabal/issues/8434+ for more details.++-- Common stanzas+---------------------------------------------------------------------------++common language++ if flag(optimise-heavily)+ cpp-options:+ -DOPTIMISE_HEAVILY+ ghc-options:+ -fexpose-all-unfoldings+ -fspecialise-aggressively+ -fstg-lift-lams++ if flag(use-xdg-data-home)+ cpp-options:+ -DUSE_XDG_DATA_HOME++ if flag(version-with-git-hash)+ cpp-options:+ -DVERSION_WITH_GIT_HASH++ if flag(dump-core)+ ghc-options:+ -dsuppress-coercions -ddump-simpl -dsuppress-idinfo+ -dsuppress-type-applications -dsuppress-uniques+ -dsuppress-module-prefixes -ddump-to-file++ ghc-options:+ -- ASR (2022-05-31). Workaround to Issue #5932.+ -Wcpp-undef+ -Wdeprecated-flags+ -Wderiving-defaults+ -Wderiving-typeable+ -Wdodgy-exports+ -Wdodgy-foreign-imports+ -Wdodgy-imports+ -Wduplicate-exports+ -Wempty-enumerations+ -Widentities+ -Winaccessible-code+ -Wincomplete-patterns+ -Wincomplete-record-updates+ -Winline-rule-shadowing+ -Winvalid-haddock+ -Wmissed-extra-shared-lib+ -Wmissing-fields+ -Wmissing-home-modules+ -Wmissing-methods+ -Wmissing-pattern-synonym-signatures+ -Wmissing-signatures+ -Wnoncanonical-monad-instances+ -Wnoncanonical-monoid-instances+ -Woperator-whitespace+ -Woverflowed-literals+ -Woverlapping-patterns+ -Woverlapping-patterns+ -Wredundant-bang-patterns+ -Wredundant-constraints+ -Wredundant-record-wildcards+ -Wsimplifiable-class-constraints+ -Wstar-binder+ -Wstar-is-type+ -Wtabs+ -Wtyped-holes+ -Wunbanged-strict-patterns+ -Wunrecognised-pragmas+ -Wunrecognised-warning-flags+ -Wunticked-promoted-constructors+ -Wunused-do-bind+ -Wunused-foralls+ -Wunused-packages+ -Wunused-record-wildcards+ -Wwarnings-deprecations+ -Wwrong-do-bind++ if impl(ghc < 9.10)+ ghc-options:+ -Wsemigroup+ -- The semigroup warning is deprecated in GHC 9.10++ -- ASR (2022-04-27). This warning was added in GHC 9.0.2, removed+ -- from 9.2.1 and added back in 9.2.2.+ if impl(ghc >= 9.2.2)+ ghc-options:+ -Wunicode-bidirectional-format-characters++ if impl(ghc >= 9.4)+ ghc-options:+ -Wtype-equality-out-of-scope++ if impl(ghc >= 9.4 && < 9.10)+ ghc-options:+ -Wforall-identifier+ -- The forall-identifier warning is deprecated in GHC 9.10++ if impl(ghc >= 9.8)+ ghc-options:+ -Wx-partial+ -- The x-partial warning was introduced in GHC 9.8 and is default in GHC 10++ default-language: Haskell2010++ -- NOTE: If adding or removing default extensions, also change:+ -- .hlint.yaml+ default-extensions:+ BangPatterns+ BlockArguments+ ConstraintKinds+ --L-T Chen (2019-07-15):+ -- Enabling DataKinds only locally makes the compile time+ -- slightly shorter, see PR #3920.+ -- DataKinds+ DefaultSignatures+ DeriveFoldable+ DeriveFunctor+ DeriveGeneric+ DeriveTraversable+ DerivingStrategies+ DerivingVia+ DisambiguateRecordFields+ ExistentialQuantification+ FlexibleContexts+ FlexibleInstances+ FunctionalDependencies+ GADTs+ GeneralizedNewtypeDeriving+ InstanceSigs+ LambdaCase+ MultiParamTypeClasses+ MultiWayIf+ NamedFieldPuns+ OverloadedStrings+ PatternSynonyms+ RankNTypes+ ScopedTypeVariables+ StandaloneDeriving+ TupleSections+ TypeFamilies+ TypeOperators+ TypeSynonymInstances+ ViewPatterns+ TypeApplications+ ImportQualifiedPost++ other-extensions:+ AllowAmbiguousTypes+ ApplicativeDo+ CPP+ DataKinds+ DeriveAnyClass+ ImplicitParams+ KindSignatures+ MagicHash+ NondecreasingIndentation+ OverloadedLists+ PartialTypeSignatures+ PolyKinds+ RebindableSyntax+ RecordWildCards+ TemplateHaskell+ UnboxedTuples+ UndecidableInstances+++-- Agda library+---------------------------------------------------------------------------++library+ import: language++ hs-source-dirs: src/full src/setup++ -- Andreas, 2021-03-10:+ -- All packages we depend upon should be mentioned in an unconditional+ -- build-depends field, but additional restrictions on their+ -- version for specific GHCs may be placed in conditionals.+ --+ -- The goal is to be able to make (e.g. when a new GHC comes out)+ -- revisions on hackage, e.g. relaxing upper bounds. This process+ -- currently does not support revising conditionals.+ --+ -- An exceptions are packages that are only needed for certain configurations,+ -- like for flags, Windows, etc.++ if flag(debug)+ cpp-options: -DDEBUG++ if flag(debug-serialisation)+ cpp-options: -DDEBUG_SERIALISATION++ if flag(debug-parsing)+ cpp-options: -DDEBUG_PARSING++ if flag(enable-cluster-counting)+ cpp-options: -DCOUNT_CLUSTERS+ build-depends:+ text-icu >= 0.7.1.0 && < 0.9++ if flag(version-with-git-hash)+ build-depends:+ gitrev >= 1.3.1 && < 2++ if os(windows)+ build-depends:+ Win32 >= 2.6.1.0 && < 2.15++ -- For libraries that come with GHC, we take the shipped version as default lower bound.+ -- For the other libraries, we take the lower bound from the oldest LTS we support.+ -- This is currently LTS 20.26 (last for GHC 9.2.8).+ build-depends:+ -- Please keep in alphabetical order!+ , aeson >= 2.0.3.0 && < 2.4+ , ansi-terminal >= 0.11.4 && < 1.2+ , array >= 0.5.4.0 && < 0.6+ , async >= 2.2.4 && < 2.3+ , base >= 4.16.4.0 && < 4.24+ , blaze-html >= 0.9.1.2 && < 0.10+ , blaze-markup >= 0.8 && < 0.9+ , boxes >= 0.1.5 && < 0.2+ , bytestring >= 0.11.4.0 && < 0.13+ , case-insensitive >= 1.2.1.0 && < 1.3+ , containers >= 0.6.5.1 && < 0.9+ , data-hash >= 0.2.0.1 && < 0.3+ , deepseq >= 1.4.6.1 && < 1.6+ , directory >= 1.3.6.2 && < 1.4+ , dlist >= 1.0 && < 1.1+ , edit-distance >= 0.2.2.1 && < 0.3+ , enummapset >= 0.6.0.3 && < 0.8+ , equivalence >= 0.4.1 && < 0.5+ , exceptions >= 0.10.4 && < 0.11+ , filepath >= 1.4.2.1 && < 1.6+ , filemanip >= 0.3.6.3 && < 0.4+ , generic-data >= 1.0.0.1 && < 1.2+ , ghc-bignum >= 1.2 && < 2+ , ghc-prim >= 0.8 && < 0.15+ , hashable >= 1.4.2.0 && < 1.6+ , haskeline >= 0.8.2 && < 0.9+ -- GHC 9.2 ships with haskeline-0.8.2.1, but 9.4 backslid to 0.8.2+ , infinite-list >= 0.1.2 && < 0.2+ , monad-control >= 1.0.3.1 && < 1.1+ , mtl >= 2.2.2 && < 2.4+ , murmur-hash >= 0.1.0.10 && < 0.2+ , nonempty-containers >= 0.3.4.4 && < 0.5+ , parallel >= 3.2.2.0 && < 3.4+ , peano >= 0.1.0.1 && < 0.2+ , pqueue >= 1.4.3.0 && < 1.8+ , primitive >= 0.7 && < 0.10+ , pretty >= 1.1.3.6 && < 1.2+ , process >= 1.6.16.0 && < 1.7+ , process-extras >= 0.7.4 && < 0.8+ , regex-tdfa >= 1.3.2.1 && < 1.4+ , split >= 0.2.3.5 && < 0.3+ , stm >= 2.5.0.2 && < 2.6+ , strict >= 0.4.0.1 && < 0.6+ , template-haskell >= 2.18.0.0 && < 2.26+ , text >= 1.2.5.0 && < 2.3+ , time >= 1.11.1.1 && < 1.17+ , transformers >= 0.5.6.2 && < 0.7+ , unordered-containers >= 0.2.19.1 && < 0.3+ , uri-encode >= 1.5.0.7 && < 1.6+ , vector >= 0.12.3.1 && < 0.14+ , vector-hashtables >= 0.1.2.0 && < 0.2+ -- vector-hashtables-0.1.2 introduces performance gains+ , zstd >= 0.1.3.0 && < 0.2++ if !arch(wasm32)+ build-depends:+ , filelock >= 0.1.1.6 && < 0.2++ -- We don't write upper bounds for Alex nor Happy because the+ -- `build-tool-depends` field can not be modified in Hackage.+ if !flag(ignore-build-tool-depends)+ build-tool-depends:+ , alex:alex >= 3.2.7.4+ , happy:happy >= 1.20.1.1++ exposed-modules:+ -- Keep in alphabetical order, please!+ Agda.Benchmarking+ Agda.Compiler.Backend+ Agda.Compiler.Backend.Base+ Agda.Compiler.Builtin+ Agda.Compiler.CallCompiler+ Agda.Compiler.Common+ Agda.Compiler.JS.Compiler+ Agda.Compiler.JS.Pretty+ Agda.Compiler.JS.Substitution+ Agda.Compiler.JS.Syntax+ Agda.Compiler.MAlonzo.Coerce+ Agda.Compiler.MAlonzo.Compiler+ Agda.Compiler.MAlonzo.Encode+ Agda.Compiler.MAlonzo.HaskellTypes+ Agda.Compiler.MAlonzo.Misc+ Agda.Compiler.MAlonzo.Pragmas+ Agda.Compiler.MAlonzo.Pretty+ Agda.Compiler.MAlonzo.Primitives+ Agda.Compiler.MAlonzo.Strict+ Agda.Compiler.ToTreeless+ Agda.Compiler.Treeless.AsPatterns+ Agda.Compiler.Treeless.Builtin+ Agda.Compiler.Treeless.Compare+ Agda.Compiler.Treeless.EliminateDefaults+ Agda.Compiler.Treeless.EliminateLiteralPatterns+ Agda.Compiler.Treeless.Erase+ Agda.Compiler.Treeless.GuardsToPrims+ Agda.Compiler.Treeless.Identity+ Agda.Compiler.Treeless.NormalizeNames+ Agda.Compiler.Treeless.Pretty+ Agda.Compiler.Treeless.Simplify+ Agda.Compiler.Treeless.Subst+ Agda.Compiler.Treeless.Uncase+ Agda.Compiler.Treeless.Unused+ Agda.ImpossibleTest+ Agda.Interaction.AgdaTop+ Agda.Interaction.Base+ Agda.Interaction.BasicOps+ Agda.Interaction.BuildLibrary+ Agda.Interaction.Command+ Agda.Interaction.CommandLine+ Agda.Interaction.Emacs.Lisp+ Agda.Interaction.EmacsCommand+ Agda.Interaction.EmacsTop+ Agda.Interaction.ExitCode+ Agda.Interaction.FindFile+ Agda.Interaction.Highlighting.Common+ Agda.Interaction.Highlighting.Dot+ Agda.Interaction.Highlighting.Dot.Backend+ Agda.Interaction.Highlighting.Dot.Base+ Agda.Interaction.Highlighting.Emacs+ Agda.Interaction.Highlighting.FromAbstract+ Agda.Interaction.Highlighting.Generate+ Agda.Interaction.Highlighting.HTML+ Agda.Interaction.Highlighting.HTML.Backend+ Agda.Interaction.Highlighting.HTML.Base+ Agda.Interaction.Highlighting.HTML.Forester+ Agda.Interaction.Highlighting.JSON+ Agda.Interaction.Highlighting.LaTeX+ Agda.Interaction.Highlighting.LaTeX.Backend+ Agda.Interaction.Highlighting.LaTeX.Base+ Agda.Interaction.Highlighting.Precise+ Agda.Interaction.Highlighting.Range+ Agda.Interaction.Highlighting.Vim+ Agda.Interaction.Imports+ Agda.Interaction.InteractionTop+ Agda.Interaction.JSON+ Agda.Interaction.JSONTop+ Agda.Interaction.Library+ Agda.Interaction.Library.Base+ Agda.Interaction.Library.Parse+ Agda.Interaction.MakeCase+ Agda.Interaction.Monad+ Agda.Interaction.Options+ Agda.Interaction.Options.Arguments+ Agda.Interaction.Options.BashCompletion+ Agda.Interaction.Options.Default+ Agda.Interaction.Options.Errors+ Agda.Interaction.Options.Help+ Agda.Interaction.Options.Lenses+ Agda.Interaction.Options.ProfileOptions+ Agda.Interaction.Options.Warnings+ Agda.Interaction.Output+ Agda.Interaction.Response+ Agda.Interaction.Response.Base+ Agda.Interaction.SearchAbout+ Agda.Main+ Agda.Mimer.Mimer+ Agda.Mimer.Monad+ Agda.Mimer.Options+ Agda.Mimer.Types+ Agda.Setup+ Agda.Setup.DataFiles+ Agda.Setup.EmacsMode+ Agda.Setup.LockFile+ Agda.Syntax.Abstract+ Agda.Syntax.Abstract.Name+ Agda.Syntax.Abstract.Pattern+ Agda.Syntax.Abstract.PatternSynonyms+ Agda.Syntax.Abstract.Pretty+ Agda.Syntax.Abstract.UsedNames+ Agda.Syntax.Abstract.Views+ Agda.Syntax.Builtin+ Agda.Syntax.Common+ Agda.Syntax.Common.Aspect+ Agda.Syntax.Common.KeywordRange+ Agda.Syntax.Common.Pretty+ Agda.Syntax.Common.Pretty.ANSI+ Agda.Syntax.Concrete+ Agda.Syntax.Concrete.Attribute+ Agda.Syntax.Concrete.Definitions+ Agda.Syntax.Concrete.Definitions.Errors+ Agda.Syntax.Concrete.Definitions.Monad+ Agda.Syntax.Concrete.Definitions.Types+ Agda.Syntax.Concrete.Fixity+ Agda.Syntax.Concrete.Generic+ Agda.Syntax.Concrete.Glyph+ Agda.Syntax.Concrete.Name+ Agda.Syntax.Concrete.Operators+ Agda.Syntax.Concrete.Operators.Parser+ Agda.Syntax.Concrete.Operators.Parser.Monad+ Agda.Syntax.Concrete.Pattern+ Agda.Syntax.Concrete.Pretty+ Agda.Syntax.DoNotation+ Agda.Syntax.Fixity+ Agda.Syntax.IdiomBrackets+ Agda.Syntax.Info+ Agda.Syntax.Internal+ Agda.Syntax.Internal.Blockers+ Agda.Syntax.Internal.Defs+ Agda.Syntax.Internal.Elim+ Agda.Syntax.Internal.Generic+ Agda.Syntax.Internal.MetaVars+ Agda.Syntax.Internal.Names+ Agda.Syntax.Internal.Pattern+ Agda.Syntax.Internal.SanityCheck+ Agda.Syntax.Internal.Univ+ Agda.Syntax.Literal+ Agda.Syntax.Notation+ Agda.Syntax.Parser+ Agda.Syntax.Parser.Alex+ Agda.Syntax.Parser.Comments+ Agda.Syntax.Parser.Helpers+ Agda.Syntax.Parser.Layout+ Agda.Syntax.Parser.LexActions+ Agda.Syntax.Parser.Lexer+ Agda.Syntax.Parser.Literate+ Agda.Syntax.Parser.LookAhead+ Agda.Syntax.Parser.Monad+ Agda.Syntax.Parser.Parser+ Agda.Syntax.Parser.StringLiterals+ Agda.Syntax.Parser.Tokens+ Agda.Syntax.Position+ Agda.Syntax.Reflected+ Agda.Syntax.Scope.Base+ Agda.Syntax.Scope.Monad+ Agda.Syntax.Scope.Operator+ Agda.Syntax.Scope.State+ Agda.Syntax.Scope.UnusedImports+ Agda.Syntax.TopLevelModuleName+ Agda.Syntax.TopLevelModuleName.Boot+ Agda.Syntax.Translation.AbstractToConcrete+ Agda.Syntax.Translation.ConcreteToAbstract+ Agda.Syntax.Translation.InternalToAbstract+ Agda.Syntax.Translation.ReflectedToAbstract+ Agda.Syntax.Treeless+ Agda.Termination.CallGraph+ Agda.Termination.CallMatrix+ Agda.Termination.CutOff+ Agda.Termination.Monad+ Agda.Termination.Order+ Agda.Termination.RecCheck+ Agda.Termination.Semiring+ Agda.Termination.SparseMatrix+ Agda.Termination.TermCheck+ Agda.Termination.Termination+ Agda.TheTypeChecker+ Agda.TypeChecking.Abstract+ Agda.TypeChecking.CheckInternal+ Agda.TypeChecking.CompiledClause+ Agda.TypeChecking.CompiledClause.Compile+ Agda.TypeChecking.CompiledClause.Match+ Agda.TypeChecking.Constraints+ Agda.TypeChecking.Conversion+ Agda.TypeChecking.Conversion.Errors+ Agda.TypeChecking.Conversion.Pure+ Agda.TypeChecking.Coverage+ Agda.TypeChecking.Coverage.Cubical+ Agda.TypeChecking.Coverage.Match+ Agda.TypeChecking.Coverage.SplitClause+ Agda.TypeChecking.Coverage.SplitPattern+ Agda.TypeChecking.Coverage.SplitTree+ Agda.TypeChecking.Datatypes+ Agda.TypeChecking.DeadCode+ Agda.TypeChecking.DiscrimTree+ Agda.TypeChecking.DiscrimTree.Types+ Agda.TypeChecking.DisplayForm+ Agda.TypeChecking.DropArgs+ Agda.TypeChecking.Empty+ Agda.TypeChecking.Errors+ Agda.TypeChecking.Errors.Names+ Agda.TypeChecking.EtaContract+ Agda.TypeChecking.Forcing+ Agda.TypeChecking.Free+ Agda.TypeChecking.Free.Base+ Agda.TypeChecking.Free.Generic+ Agda.TypeChecking.Free.Precompute+ Agda.TypeChecking.Free.Reduce+ Agda.TypeChecking.Functions+ Agda.TypeChecking.Generalize+ Agda.TypeChecking.IApplyConfluence+ Agda.TypeChecking.Implicit+ Agda.TypeChecking.Injectivity+ Agda.TypeChecking.Inlining+ Agda.TypeChecking.InstanceArguments+ Agda.TypeChecking.Irrelevance+ Agda.TypeChecking.Level+ Agda.TypeChecking.Level.Solve+ Agda.TypeChecking.LevelConstraints+ Agda.TypeChecking.Lock+ Agda.TypeChecking.MetaVars+ Agda.TypeChecking.MetaVars.Mention+ Agda.TypeChecking.MetaVars.Occurs+ Agda.TypeChecking.Modalities+ Agda.TypeChecking.Monad+ Agda.TypeChecking.Monad.Base+ Agda.TypeChecking.Monad.Base.Types+ Agda.TypeChecking.Monad.Base.Warning+ Agda.TypeChecking.Monad.Benchmark+ Agda.TypeChecking.Monad.Builtin+ Agda.TypeChecking.Monad.Caching+ Agda.TypeChecking.Monad.Closure+ Agda.TypeChecking.Monad.Constraints+ Agda.TypeChecking.Monad.Context+ Agda.TypeChecking.Monad.Debug+ Agda.TypeChecking.Monad.Env+ Agda.TypeChecking.Monad.Imports+ Agda.TypeChecking.Monad.MetaVars+ Agda.TypeChecking.Monad.Modality+ Agda.TypeChecking.Monad.Mutual+ Agda.TypeChecking.Monad.Open+ Agda.TypeChecking.Monad.Options+ Agda.TypeChecking.Monad.Pure+ Agda.TypeChecking.Monad.Signature+ Agda.TypeChecking.Monad.SizedTypes+ Agda.TypeChecking.Monad.State+ Agda.TypeChecking.Monad.Statistics+ Agda.TypeChecking.Monad.Trace+ Agda.TypeChecking.Names+ Agda.TypeChecking.Opacity+ Agda.TypeChecking.Patterns.Abstract+ Agda.TypeChecking.Patterns.Internal+ Agda.TypeChecking.Patterns.Match+ Agda.TypeChecking.Polarity+ Agda.TypeChecking.Positivity+ Agda.TypeChecking.Positivity.Occurrence+ Agda.TypeChecking.Positivity.OccurrenceAnalysis+ Agda.TypeChecking.Positivity.Warnings+ Agda.TypeChecking.Pretty+ Agda.TypeChecking.Pretty.Call+ Agda.TypeChecking.Pretty.Constraint+ Agda.TypeChecking.Pretty.Warning+ Agda.TypeChecking.Primitive+ Agda.TypeChecking.Primitive.Base+ Agda.TypeChecking.Primitive.Cubical+ Agda.TypeChecking.Primitive.Cubical.Base+ Agda.TypeChecking.Primitive.Cubical.Glue+ Agda.TypeChecking.Primitive.Cubical.HCompU+ Agda.TypeChecking.ProjectionLike+ Agda.TypeChecking.Quote+ Agda.TypeChecking.ReconstructParameters+ Agda.TypeChecking.RecordPatterns+ Agda.TypeChecking.Records+ Agda.TypeChecking.Reduce+ Agda.TypeChecking.Reduce.Fast+ Agda.TypeChecking.Reduce.Monad+ Agda.TypeChecking.Rewriting+ Agda.TypeChecking.Rewriting.Clause+ Agda.TypeChecking.Rewriting.Confluence+ Agda.TypeChecking.Rewriting.NonLinMatch+ Agda.TypeChecking.Rewriting.NonLinPattern+ Agda.TypeChecking.Rules.Application+ Agda.TypeChecking.Rules.Builtin+ Agda.TypeChecking.Rules.Builtin.Coinduction+ Agda.TypeChecking.Rules.Data+ Agda.TypeChecking.Rules.Decl+ Agda.TypeChecking.Rules.Def+ Agda.TypeChecking.Rules.Display+ Agda.TypeChecking.Rules.LHS+ Agda.TypeChecking.Rules.LHS.Implicit+ Agda.TypeChecking.Rules.LHS.Problem+ Agda.TypeChecking.Rules.LHS.ProblemRest+ Agda.TypeChecking.Rules.LHS.Unify+ Agda.TypeChecking.Rules.LHS.Unify.LeftInverse+ Agda.TypeChecking.Rules.LHS.Unify.Types+ Agda.TypeChecking.Rules.Record+ Agda.TypeChecking.Rules.Record.Cubical+ Agda.TypeChecking.Rules.Term+ Agda.TypeChecking.Serialise+ Agda.TypeChecking.Serialise.Base+ Agda.TypeChecking.Serialise.Instances+ Agda.TypeChecking.Serialise.Instances.Abstract+ Agda.TypeChecking.Serialise.Instances.Common+ Agda.TypeChecking.Serialise.Instances.Compilers+ Agda.TypeChecking.Serialise.Instances.Errors+ Agda.TypeChecking.Serialise.Instances.General+ Agda.TypeChecking.Serialise.Instances.Highlighting+ Agda.TypeChecking.Serialise.Instances.Internal+ Agda.TypeChecking.Serialise.Node+ Agda.TypeChecking.SizedTypes+ Agda.TypeChecking.SizedTypes.Pretty+ Agda.TypeChecking.SizedTypes.Solve+ Agda.TypeChecking.SizedTypes.Syntax+ Agda.TypeChecking.SizedTypes.Utils+ Agda.TypeChecking.SizedTypes.WarshallSolver+ Agda.TypeChecking.Sort+ Agda.TypeChecking.Substitute+ Agda.TypeChecking.Substitute.Class+ Agda.TypeChecking.Substitute.DeBruijn+ Agda.TypeChecking.SyntacticEquality+ Agda.TypeChecking.Telescope+ Agda.TypeChecking.Telescope.Path+ Agda.TypeChecking.Unquote+ Agda.TypeChecking.Warnings+ Agda.TypeChecking.With+ Agda.Utils.AffineHole+ Agda.Utils.Applicative+ Agda.Utils.AssocList+ Agda.Utils.Atomic+ Agda.Utils.Bag+ Agda.Utils.Benchmark+ Agda.Utils.BiMap+ Agda.Utils.BinTree+ Agda.Utils.BinTree1+ Agda.Utils.BoolSet+ Agda.Utils.Boolean+ Agda.Utils.ByteArray+ Agda.Utils.CallStack+ Agda.Utils.Char+ Agda.Utils.Cluster+ Agda.Utils.CompactRegion+ Agda.Utils.CompressedTrie+ Agda.Utils.DocTree+ Agda.Utils.Either+ Agda.Utils.Empty+ Agda.Utils.Environment+ Agda.Utils.ExpandCase+ Agda.Utils.Fail+ Agda.Utils.Favorites+ Agda.Utils.FileId+ Agda.Utils.FileName+ Agda.Utils.Float+ Agda.Utils.Function+ Agda.Utils.Functor+ Agda.Utils.GetOpt+ Agda.Utils.Graph.AdjacencyMap.Unidirectional+ Agda.Utils.Graph.TopSort+ Agda.Utils.Hash+ Agda.Utils.HashTable+ Agda.Utils.Haskell.Syntax+ Agda.Utils.IArray+ Agda.Utils.IO+ Agda.Utils.IO.Binary+ Agda.Utils.IO.Directory+ Agda.Utils.IO.TempFile+ Agda.Utils.IO.Terminal+ Agda.Utils.IO.UTF8+ Agda.Utils.IORef+ Agda.Utils.IORef.Strict+ Agda.Utils.Impossible+ Agda.Utils.IndexedList+ Agda.Utils.IndexMap+ Agda.Utils.IntMap+ Agda.Utils.IntSet.Infinite+ Agda.Utils.Lens+ Agda.Utils.Lens.Examples+ Agda.Utils.List+ Agda.Utils.List1+ Agda.Utils.List2+ Agda.Utils.ListInf+ Agda.Utils.ListT+ Agda.Utils.Map+ Agda.Utils.Map1+ Agda.Utils.Maybe+ Agda.Utils.Maybe.Strict+ Agda.Utils.Maybe.Unboxable+ Agda.Utils.Memo+ Agda.Utils.MinimalArray.Lifted+ Agda.Utils.MinimalArray.MutableLifted+ Agda.Utils.MinimalArray.MutablePrim+ Agda.Utils.MinimalArray.Prim+ Agda.Utils.Monad+ Agda.Utils.Monoid+ Agda.Utils.Null+ Agda.Utils.POMonoid+ Agda.Utils.Parser.MemoisedCPS+ Agda.Utils.PartialOrd+ Agda.Utils.Permutation+ Agda.Utils.Range+ Agda.Utils.RangeMap+ Agda.Utils.SemiRing+ Agda.Utils.Semigroup+ Agda.Utils.Serialize+ Agda.Utils.Set+ Agda.Utils.Set1+ Agda.Utils.Singleton+ Agda.Utils.Size+ Agda.Utils.SmallSet+ Agda.Utils.StrictEndo+ Agda.Utils.StrictFlipEndo+ Agda.Utils.StrictReader+ Agda.Utils.StrictState+ Agda.Utils.StrictState2+ Agda.Utils.StrictWriter+ Agda.Utils.String+ Agda.Utils.Suffix+ Agda.Utils.Three+ Agda.Utils.Time+ Agda.Utils.Trie+ Agda.Utils.Tuple+ Agda.Utils.Tuple.Strict+ Agda.Utils.TypeLevel+ Agda.Utils.TypeLits+ Agda.Utils.Unsafe+ Agda.Utils.Update+ Agda.Utils.VarSet+ Agda.Utils.WithDefault+ Agda.Utils.Word+ Agda.Utils.Zip+ Agda.Utils.Zipper+ Agda.Version+ Agda.VersionCommit++ autogen-modules:+ Paths_Agda++ other-modules:+ Paths_Agda+ -- Need not export submodules if parent module reexports them.+ Agda.Interaction.Options.Base+ Agda.Interaction.Options.HasOptions+ Agda.Interaction.Options.Types+ Agda.Utils.CallStack.Base+ Agda.Utils.CallStack.Pretty++-- Agda binary+---------------------------------------------------------------------------++executable agda+ hs-source-dirs: src/main+ main-is: Main.hs+ build-depends:+ , Agda+ -- Nothing is used from the following package,+ -- except for the Prelude.+ , base+ default-language: Haskell2010+ -- If someone installs Agda with the setuid bit set, then the+ -- presence of +RTS may be a security problem (see GHC bug #3910).+ -- However, we sometimes recommend people to use +RTS to control+ -- Agda's memory usage, so we want this functionality enabled by+ -- default.+ ghc-options:+ -rtsopts++ -- The threaded RTS by default starts a major GC after a program has+ -- been idle for 0.3 s. This feature turned out to be annoying, so+ -- the idle GC is now by default turned off (-I0).+ if !arch(wasm32)+ ghc-options:+ -threaded+ "-with-rtsopts=-I0 -N1 -qb0"+ else+ ghc-options: -with-rtsopts=-I0++-- agda-mode executable+---------------------------------------------------------------------------++executable agda-mode+ import: language++ hs-source-dirs: src/agda-mode src/setup+ main-is: Main.hs+ autogen-modules:+ Paths_Agda+ other-modules:+ Paths_Agda+ Agda.Setup+ Agda.Setup.DataFiles+ Agda.Setup.EmacsMode+ Agda.Setup.LockFile+ Agda.Version+ Agda.VersionCommit++ build-depends:+ , base >= 4.16.4.0 && < 4.24+ , bytestring >= 0.11.4.0 && < 0.13+ , directory >= 1.3.6.2 && < 1.4+ , filepath >= 1.4.2.2 && < 1.6+ , process >= 1.6.16.0 && < 1.7+ , template-haskell >= 2.18.0.0 && < 2.26++ if flag(version-with-git-hash)+ build-depends:+ gitrev >= 1.3.1 && < 2++ if !arch(wasm32)+ build-depends:+ , filelock >= 0.1.1.6 && < 0.2
@@ -0,0 +1,1378 @@+Release notes for Agda version 2.9.0+====================================++Highlights+----------++* Option `-j` to type check modules in parallel in batch mode (experimental; Amélia Liao).+* Substantial performance improvements (András Kovács, Amélia Liao, Reed Mullanix).+* Agda on WASM (Jonathan Coates, Andy Pan).+* Qualified `do` (Amélia Liao).+* Local rewrite rules (experimental; Nathaniel Burke, Jesper Cockx).+* Improved termination checker for copatterns (Nate Soares).+* Warning about unused imports (experimental; Andreas Abel).+* Emacs: Syntax highlighting in the Agda information buffer (Andreas Abel, Amélia Liao).+* Improvements to automatic term synthesis, "Mimer" (Andreas Abel, Jesper Cockx).+* Forester backend (Lîm Tsú-thuàn).+* Around 60 fixes of inconsistencies, internal errors, and regressions.+* Around 130 other issues fixed.++Installation+------------++* Dropped support for GHC 8.8, 8.10, and 9.0.++* Agda supports GHC versions 9.2.8 to 9.14.1.++* The new Cabal flag `version-with-git-hash` controls whether version information+ is suffixed with the Git commit hash. It is disabled by default for cabal+ but enabled by default when using the Makefile.++Pragmas and options+-------------------++* New option `--parallel` (`-j` for short, as in `make`) lets Agda+ type-check imported modules in parallel. For large libraries, this can+ result in a speedup of ~3x, at the cost of roughly doubling the+ maximum memory usage.+ This option does not yet work well with `--interaction`+ ([issue #8477](https://github.com/agda/agda/issues/8477)).++* New option `--print-options` to print a simple list of all options.+ This list can e.g. be used to implement bash completion.++* The flavor of Cubical Agda can now be chosen by an argument to the `--cubical` option:++ | Old | New |+ | ---------------------- | ------------------------------------------------- |+ | `--cubical` | `--cubical`, or `--cubical=full` |+ | `--erased-cubical` | `--erased-cubical`, or `--cubical=erased` |+ | `--cubical-compatible` | `--cubical-compatible`, or `--cubical=compatible` |+ | - | `--cubical=no-glue` |++ For compatibility between modules using different variants of Cubical Agda, see+ [the documentation](https://agda.readthedocs.io/en/v2.9.0/language/cubical.html#variants).++* New flag `--no-write-interfaces`.++* New command-line option `--literate-markdown-only-agda-blocks` (off by default).+ When enabled, only code blocks explicitly marked with ` ```agda ` are treated as+ Agda code in literate Markdown (`.lagda.md`) and Typst (`.lagda.typ`) files.+ Unmarked code blocks (` ``` `) are treated as verbatim text and not type-checked.+ This option must be set via command line since it affects parsing.+ (See [#7971](https://github.com/agda/agda/issues/7971).)++* The flag `--termination-depth=N` now means _maximum_ termination depth and+ the termination checker now performs iterative deepening,+ starting with depth `1` and increasing it up to the given `N`, stopping early+ as soon as the termination check succeeds.+ Increasing `N` can thus slow down things only for failing termination checks.++ The default value of `N` has been increased from `1` to `3`, yet not higher,+ because cases requiring a termination depth `> 1` are already very rare in practice.++ There is also an internal change to the termination checker.+ Dot patterns are now taken into account from the beginning and not only when+ the termination check fails without taking them into account.+ The overhead to also mine dot patterns for structural descent was already+ negligible so it made sense to simplify the termination checking algorithm.++* The new flag `--no-occurrence-analysis` can be used to turn off the+ automated occurrence analysis for functions.++ By default Agda analyses how functions use their arguments. For+ instance, Agda can tell that `D` in the following code is strictly+ positive, because `Vec` uses its `Set` argument in a strictly+ positive way:+ ```agda+ open import Agda.Builtin.Nat+ open import Agda.Builtin.Unit++ data _×_ (A B : Set) : Set where+ _,_ : A → B → A × B++ Vec : Set → Nat → Set+ Vec A zero = ⊤+ Vec A (suc n) = A × Vec A n++ data D : Set where+ c : ∀ n → Vec D n → D+ ```+ However, this analysis can be slow, especially for big mutual+ blocks. Now it is possible to turn it off.++ The analysis is also used to detect unused function arguments. The+ following code is by default accepted, but it is rejected if the+ occurrence analysis is turned off:+ ```agda+ open import Agda.Builtin.Bool+ open import Agda.Builtin.Equality+ open import Agda.Builtin.Unit++ F : Bool → Set → Set+ F true _ = Bool+ F false _ = ⊤++ _ : {b : Bool} → F b Bool ≡ F b ⊤+ _ = refl+ ```++ Note that an alternative to the analysis is to use polarities. The+ following code is accepted:+ ```agda+ {-# OPTIONS --polarity --no-occurrence-analysis #-}++ open import Agda.Builtin.Bool+ open import Agda.Builtin.Equality+ open import Agda.Builtin.Nat+ open import Agda.Builtin.Unit++ data _×_ (@++ A B : Set) : Set where+ _,_ : A → B → A × B++ Vec : @++ Set → Nat → Set+ Vec A zero = ⊤+ Vec A (suc n) = A × Vec A n++ data D : Set where+ c : ∀ n → Vec D n → D++ F : Bool → @unused Set → Set+ F true _ = Bool+ F false _ = ⊤++ _ : {b : Bool} → F b Bool ≡ F b ⊤+ _ = refl+ ```++* Setting environment variable `NO_COLOR` now turns off coloring in the default `--color=auto` mode.+ It can be overwritten by `--color=always`.+ See also https://no-color.org/ .++* New option `--quote-metas` to allow for `quoteTerm` constraints to+ be solved even when the quoted term contains unsolved metas.+ This allows for elaborating macro applications with quoted arguments+ that still have interactive holes in them.+ See the [quote metas documentation](https://agda.readthedocs.io/en/v2.9.0/language/reflection.html#quote-metas).++* `{-# NO_POSITIVITY_CHECK #-}` pragmas are now recognized in `record` declarations and `where` blocks,+ and pertain to the following `data` or `record` declaration or mutual block.++* New option `--local-rewriting` which enables parameterising over computation rules by annotating module parameters with `@rewrite` attributes. See the [local rewriting documentation](https://agda.readthedocs.io/en/v2.9.0/language/local-rewriting.html) for more info.++* New `primRewriteNoMatch` primitive in `Agda.Builtin.Equality.Rewrite` for controlling rewrite rule matching. See the section in the [rewriting documentation](https://agda.readthedocs.io/en/v2.9.0/language/rewriting.html#controlling-rewrite-rule-matching-with-primrewritenomatch) for more info.++* The `ETA` pragma has been removed.++* Eta-equality for record types is no longer inferred.+ Previously Agda would switch off eta for a recursive record type automatically+ if there was a risk that the type checker could loop due to infinite eta expansion.+ Now, Agda will only flag it with an `UnguardedEtaRecord` error, so one has to add+ a `no-eta-equality` directive manually.+ If one wants eta enabled nevertheless, one can use the new `ETA_EQUALITY` pragma.+ This pragma replaces the old `ETA` pragma and can also be used to turn on eta for+ `coinductive` record types.+ See the documentation on+ [unguarded records](https://agda.readthedocs.io/en/v2.9.0/language/record-types.html#unguarded-records)+ and [the `ETA_EQUALITY` pragma](https://agda.readthedocs.io/en/v2.9.0/language/coinduction.html#eta-pragma).++* New options `--irrelevance` (default on) and `--no-irrelevance` to allow or+ disallow the irrelevance modality.++* (**BREAKING**.) Now `--erased-matches` takes an optional argument:++ * `--erased-matches=none`: Do not enable any erased matches (this+ can be overridden).++ * `--erased-matches=empty`: Enable erased matches for empty types.++ * `--erased-matches=non-dependent`: Enable erased matches for+ non-indexed, single-constructor types.++ * `--erased-matches=restricted`: Make it possible to import the+ module `Agda.Builtin.Erased.Box-cong`, which contains an+ implementation of `[]-cong` (the type `Erased` can be found in+ `Agda.Builtin.Erased.Erased`):++ ```agda+ record Erased (@0 A : Set a) : Set a where+ no-eta-equality+ constructor [_]+ field+ @0 erased : A++ []-cong : @0 x ≡ y → [ x ] ≡ [ y ]+ []-cong refl = refl+ ```++ In the future `--erased-matches=restricted` might make it possible+ to implement `[]-cong` in user code, but that is currently not+ allowed.++ * `--erased-matches=unrestricted`: Enable unrestricted erased+ matches for single-constructor types. If `--safe` is active, then+ this option is not allowed together with `--without-K`.++ One can also use comma-separated lists of options, for instance+ `--erased-matches=empty,restricted`. This has the same effect as+ giving the options separately (`--erased-matches=empty+ --erased-matches=restricted`). There is no way to turn off something+ that has been enabled, so it does not matter in what order the+ options are given. As an example, `--erased-matches=empty,none`+ means the same thing as `--erased-matches=empty`.++ If none of these options are given, then Agda behaves++ * as if `--erased-matches=none` had been used if `--erasure` is not+ turned on (directly or indirectly), otherwise++ * as if `--erased-matches=empty` had been used if `--without-K` is+ active, and otherwise++ * as if `--erased-matches=empty,unrestricted` had been used.++ Note that these defaults can be overridden by, for instance,+ `--erased-matches=none`.++ The option `--erased-matches` means almost the same thing as+ `--erased-matches=empty,non-dependent` if `--without-K` is active,+ and otherwise it means almost the same thing as+ `--erased-matches=empty,unrestricted`. However, any use of+ `--erased-matches` with explicit arguments takes precedence over+ `--erased-matches` without arguments. For instance,+ `--erased-matches=none --erased-matches` means the same thing as+ `--erased-matches=none`.++ The option `--no-erased-matches` is now a synonym for+ `--erased-matches=none`.++ All variants of `--erased-matches` except for+ `--erased-matches=none` enable `--erasure`.++ This change can lead to some breakage:++ * Previously `--no-erased-matches --erased-matches` meant the same+ thing as `--erased-matches`, now it means the same thing as+ `--erased-matches=none`.++ * Before `--with-K` overrode a previously given+ `--no-erased-matches` and turned on erased matches. That is no+ longer the case.++ Note that the new optional argument to `--erased-matches` is+ experimental: the design might change in the future.++* The new (experimental and possibly unstable) options+ `--erased-funext`, `--erased-propext` and `--erased-quotients`+ enable use of `Agda.Builtin.Erased.Funext`,+ `Agda.Builtin.Erased.Propext` and `Agda.Builtin.Erased.Quotient`,+ respectively.++ All options imply `--erasure`, and `--erased-quotients` implies+ `--erased-funext`.++ These modules contain erased postulates. The idea is that it should+ be safe to use these postulates (under `--safe` and in the absence+ of any Agda bugs):++ * If `--erased-matches=X` is not used, where `X` is one of `empty`,+ `non-dependent`, `restricted` and `unrestricted`, then canonicity+ should hold for non-erased terms (if all opaque definitions are+ made transparent and the context only contains erased+ assumptions).++ * If `--erased-matches=empty` is used, then canonicity should still+ hold if the context plus the postulates are jointly consistent.++ * If `--erased-matches=X` is used, where `X` is one of+ `non-dependent`, `restricted` and `unrestricted`, then reduction+ might get stuck, but compiled programs should still run correctly.++ `Agda.Builtin.Erased.Funext` postulates function extensionality,+ `Agda.Builtin.Erased.Propext` postulates propositional+ extensionality, and `Agda.Builtin.Erased.Quotient` gives access to+ an implementation of set quotients with an eliminator that computes+ for the point constructor.++Errors+------++* Error `ClashingDefinition` now gives the lineage of the previous definition of the same name.+ This helps when it is unclear how this name was imported. Example:+ ```+ error: [ClashingDefinition]+ Multiple definitions of A. Previous definition+ A is in scope as+ * a postulate Imports.A.A brought into scope by+ - the opening of Imports.A at ...+ - its definition at ...+ ```++* Errors `GenericError` and `GenericDocError` have been replaced by more specific errors.+ (Issue [#7225](https://github.com/agda/agda/issues/7225).)++* New error `NamedWhereModuleUnderWith` for named `where`-modules in clauses+ using with-abstraction; see the entry under _Language_.+ (Issue [#8698](https://github.com/agda/agda/issues/8698).)++* Generalisation failures due to unresolvable dependencies between a+ generalized variable and unsolved metavariables have new, specific+ errors.+ * `GeneralizationPrepruneErrorRefinedContext`, reproduced by Amélia Liao+ (see Issue [#8161](https://github.com/agda/agda/issues/8161#issuecomment-3696949816)).+ * `GeneralizationPrepruneErrorCyclicDependencies`, reproduced by Nils Anders Danielsson+ (see Issue [#3672](https://github.com/agda/agda/issues/3672#issuecomment-482715807)).++* New error `WrongNamedArgumentInLHS` for a named hidden argument on a left hand side+ that does not exist, replacing `WrongHidingInLHS` in this case.+ Like `WrongNamedArgument` on the right hand side, it lists the possible argument names+ (see [#8739](https://github.com/agda/agda/issues/8739)).+ Likewise, error `NoParameterOfName` now lists the possible parameter names.++Warnings+--------++* New warning `UnusedImports` when `open` brings identifiers or modules into scope+ that are definitely not used subsequently.+ A module counts as used if it is referred to,+ e.g. in a qualified name `M.x`, in `open M`, or in `module N = M`.++ If `using` or `renaming` directives are given, or in flavor `-WUnusedImports=all`,+ Agda warns about each name and module that is unused,+ except for modules of data and record types that are not mentioned+ explicitly in the directive.+ If no directive or only a `hiding` directive is given,+ and unless the flavor is `all`,+ Agda only warns if none of the imported names are used.++ Agda also warns about instances brought into scope+ unless `--no-qualified-instances` is on+ (which requires bringing instances into scope if they should be found by instance search).++* `UselessImport` warning instead of parse error when an module is instantiated+ but not opened during `import`, for instance:+ ```agda+ import Structures.IsMonoid Carrier Eq+ ```+ This does not bring module `Structures.IsMonoid` into scope and+ neither any of its exports.+ It either needs an `open` or an `as`-clause such as `as MyMonoid`.++* `UselessPragma` warning instead of hard error `NeedOptionRewriting` when a+ `REWRITE` or `BUILTIN REWRITE` pragma is encountered but `--rewriting` is off.++* Error warning `IllegalDeclarationInDataDefinition` instead of hard error+ when `data` definition contains declarations other than type signatures of+ constructors.++* Error `RecursiveRecordNeedsInductivity` turned into a error warning.++* New warning `DivergentModalityInClause` when modality of a clause diverges+ from that of the function. Example:+ ```agda+ A : Set₁+ @0 A = Set+ ```++* New warning `InvalidDataOrRecDefParameter` for information (e.g. type, attributes)+ attached to parameters in a `data` or `record` definition (that is separate of its+ data or record signature).+ This replaces errors:+ - `UnexpectedModalityAnnotationInParameter`+ - `UnexpectedTypeSignatureForParameter`++* New warning `InvalidTacticAttribute` for misplaced `@(tactic ...)` attributes.+ This was silently accepted up to Agda 2.8.0 but raises now the new warning:+ ```agda+ postulate+ @(tactic not-in-scope) _ : Set+ ```++* New warning `RewriteVariablesBoundInSingleton` for rewrite rules which bind+ at least one variable exclusively in patterns which might become of singleton+ type after a substitution. Rewrite rules of this form endanger subject+ reduction.+ - Unlike the other warnings about problematic rewrite rules, Agda will still+ try its best to apply rewrites which trigger this warning.+ This is because some very useful rewrite rules unfortunately do not preserve+ subject reduction in the presence of definitional singletons.++* `UnknownNamesInFixityDecl` and `UnknownNamesInPolarityPragmas` are now error warnings.++* The new warning `DefinitionBeforeDeclaration` is emitted if in a classic+ `mutual` block a data/record signature appears *after* the respective+ definition. This can happen since the nicifier bubbles signatures up.+ (See [issue #8435](https://github.com/agda/agda/issues/8435).)++* New warning `ShouldBeEtaRecordPattern`, raised for+ matches on record constructors in _binders_ (`λ`, `let`, parameter telescopes etc.)+ when the respective record does not have eta.+ For example, this module parameter match triggers the warning:+ ```agda+ record Wrap (A : Set) : Set where+ constructor wrap; no-eta-equality; pattern+ field unwrap : A++ module _ {A} (w@(wrap a) : Wrap A) where+ ```+ Reason for the warning:+ Such a binding is interpreted here as `a = unwrap w`.+ The user expectation that `w` is definitionally equal to `wrap a` is only met if `Wrap` admits `eta-equality`.++ Pattern matching on left hand sides of function definitions does not trigger the warning.++* New warning `FixityDeclarationForNonOperator` when a fixity declaration is attached to a name+ that is neither a pre-, post-, nor infix operator and neither has a pre-, post- or infix `syntax`+ attached to it.+ ```agda+ infixl 10 plus -- warning+ plus : ℕ → ℕ → ℕ+ plus = ...++ infix 42 [_] -- warning+ [_] : A → List A+ [_] = ...++ infix 255 abs+ syntax abs x = | x | -- warning++ infix 314 neg -- no warning+ syntax neg x = ¬ x++ open import Agda.Builtin.Nat+ renaming (_+_ to infixl 10 add) -- warning+ ```++* New warning `LibraryVersionConflict` when a project uses different versions of one library+ (see [#8875](https://github.com/agda/agda/issues/8875)).+ The warning shows the dependency tree leading to the conflicting versions+ and the involved `.agda-lib` files:+ ```+ Different versions of the library 'standard-library' depended on:+ [my-project]+ ├─ [standard-library-2.3]+ └─ [my-lib]+ └─ standard-library-2.4 as [standard-library]+ Library files:+ [my-project]: /path/to/my-project/my-project.agda-lib:<line>.<col>-<col>+ [my-lib]: /path/to/my-lib/my-lib.agda-lib:<line>.<col>-<col>+ [standard-library-2.3]: /path/to/agda-stdlib-2.3/standard-library.agda-lib:1:1+ [standard-library]: /path/to/agda-stdlib-2.4/standard-library.agda-lib:1:1+ ```++Syntax+------++Changes to the Agda syntax.++* **Breaking:** The parser will reject ASCII opening delimiters which+ are closed by a Unicode delimiter, and vice-versa. Concretely, this+ means the mismatched pairs `⦃ ... }}`/`{{ ... ⦄` and+ `⦇ … |)`/`(| … ⦈` are now parse errors.++* Modality annotations in aliases and let-bindings are now supported+ (PR [#7990](https://github.com/agda/agda/pull/7990)).+ Example:+ ```agda+ split : {A B C : Set} (@0 p : A × B) (k : @0 A → @0 B → C) → C+ split p k = let @0 (x , y) = q in k x y+ where+ @0 q = p+ ```++* Postfix projections cannot be surrounded by parentheses anymore.+ E.g. these postfix projection applications are now illegal in expressions:+ ```agda+ r (.proj)+ r .(proj)+ ```++* Idiom brackets and `do` notation may now appear *qualified*, as in+ `M.do` or `M.(| f x y z |)`, in which case the functions needed for+ desugaring these are looked up in `M` rather than in the surrounding+ scope ([PR #8280](https://github.com/agda/agda/pull/8280)).++Language+--------++Changes to type checker and other components defining the Agda language.++* (**BREAKING**) Named `where`-modules (`module M where`) are no longer+ allowed in clauses that use with-abstraction, i.e. clauses with `with`,+ `rewrite`, or `with p ← e`. Such a clause is now rejected with the new+ error `NamedWhereModuleUnderWith`:+ ```agda+ f : Bool → Bool+ f x with x+ ... | true = local+ module M where -- rejected+ local = false+ ... | false = true+ ```+ With-abstraction can change the types of the module parameters that `M`+ inherits from its parent module, so the telescope of `M` lies about them.+ Since `M` is visible outside of the clause, it could then be instantiated+ with ill-typed arguments, which allowed a proof of `⊥`.++ Ordinary anonymous `where`-blocks are unaffected, and so is+ `using p ← e`, which does not with-abstract but introduces a let-binding.+ (Issue [#8698](https://github.com/agda/agda/issues/8698).)++* (**BREAKING**) The pseudo-name `R.constructor`, which refers to the+ constructor of record `R`, is now resolved by the ordinary scope lookup:+ `constructor` is a name bound in the record module `R`.+ (It can never be written unqualified, since `constructor` is a keyword;+ in particular, `open R` does not bring it into scope, and a module+ application `module M = R` does not provide `M.constructor`.)++ Consequently, the qualification `R` in `R.constructor` is now interpreted+ as the name of the record *module* rather than the name of the record+ *type*. Thus, this now succeeds:+ ```agda+ module M where+ record R : Set where++ open M using (module R)++ t = R.constructor -- used to fail+ ```+ while this now fails:+ ```agda+ module M where+ record R : Set where++ open M using (R) hiding (module R)++ t = R.constructor -- used to succeed+ ```++ This also fixes [Issue #8625](https://github.com/agda/agda/issues/8625):+ an internal error when referring to `R.constructor` from the interaction+ top level.++* (**BREAKING**): In the presence of `--erasure`, types of lambdas expressions+ are not inferred unless every lambda-bound variable has been given its erasure+ status (`@0` or `@ω`) explicitely.+ The reason is that otherwise Agda might infer the wrong erasure status, see, e.g.,+ [Issue #7001](https://github.com/agda/agda/issues/7001).++ Now we have the following behavior:+ ```agda+ fails = λ x → x + x+ succeeds = λ (@ω x) → x + x+ alsoOK = λ (@ω A : Set) (@0 B : Set) → A+ ```+ With that change `--erasure` gets more akin to Cubical Agda that categorically+ refuses to infer lambdas (since they could construct either functions or paths).++* (**BREAKING**): Instance search will no longer eta-expand non-instance+ (visible and hidden) variables of record type in the context to find+ instance fields ([PR #8367](https://github.com/agda/agda/pull/8367)).++ This change means that instance search can now happen even when the types of+ non-instance arguments are yet-unsolved metavariables. Specifically, instance+ search now works in functions with a type signature of the form `∀ x → ...`,+ where previously it would require the type of `x` to be annotated.++ It also means that instance search no longer requires head-normalising the+ types of non-instance function arguments, which may have a positive effect on+ type checking performance.++ Due to this change, code that relied on eta-expanding visible argument (like+ `r : R` in the example below) to find the instance field will no longer work.++ ```agda+ postulate+ T : Set+ use : ⦃ t : T ⦄ → Set++ record R : Set where+ field ⦃ inst ⦄ : T++ fails : R → Set+ fails r = use+ ```++ In this case the code can be repaired by explicitly eta-expanding the record+ pattern:++ ```agda+ succeeds : R → Set+ succeeds r@record{} = use -- or just record{}, if r is unused+ ```++ In other cases more substantial changes might be required. For example, in the+ code below the record values `Aa` and `Bb` are parameters so they cannot be+ eta-expanded directly:++ ```agda+ record IsPointed (A : Set) : Set where+ field+ point : A+ open IsPointed {{...}}++ record PointedSet : Set1 where+ field+ Carrier : Set+ {{IsPointed[Carrier]}} : IsPointed Carrier+ open PointedSet++ record PointedFunction (Aa Bb : PointedSet) : Set where+ field+ run : Aa .Carrier -> Bb .Carrier+ preserves-point : run point ≡ point+ ```++ Here it is possible to work around the problem by marking the projection+ `IsPointed[Carrier]` as an `instance` and then applying the record module+ `PointedSet` to the respective values `Aa` and `Bb`:++ ```agda+ record PointedSet : Set1 where+ field+ Carrier : Set+ instance+ {{IsPointed[Carrier]}} : IsPointed Carrier+ open PointedSet++ record PointedFunction (Aa Bb : PointedSet) : Set where+ open PointedSet Aa renaming (Carrier to AA)+ open PointedSet Bb renaming (Carrier to BB)+ field+ run : AA -> BB+ preserves-point : run point ≡ point+ ```++ In general, instance search is intended to work well with unbundled structures+ such as `IsPointed`, while using it with bundled structures such as+ `PointedSet` might require some more creative workarounds such as the one+ above.++* Instance search now finds instance fields in *functions* that produce+ eta records ([Issue #8337](github.com/agda/agda/issues/8337)), as+ long as these functions are in the context with instance visibility.++ In effect, this means that a family of instances of a "subclass" also+ provides a family of instances for the "superclass". For example, the+ following code is now accepted:++ ```agda+ record Eq (A : Set) : Set where+ field+ _==_ : A → A → Bool++ record Ord (A : Set) : Set where+ field+ ⦃ eq ⦄ : Eq A+ _<=_ : A → A → Bool++ open Ord ⦃ ... ⦄+ open Eq ⦃ ... ⦄++ test+ : {I : Set} {F : I → Set} ⦃ ordi : ∀ {i} → Ord (F i) ⦄+ → (i : I) → F i → F i → Bool+ test i x y = x == y+ ```++* Functions defined using with-abstraction equality (`with … in eq`) can now be+ reasoned about using the same with-abstraction equality: the equality proof+ is correctly generalised over. This should make most (if not all) uses of the+ old-style `inspect` idioms for the built-in equality type unnecessary.++* Added support for [Cubical Agda without Glue Types](https://agda.readthedocs.io/en/v2.9.0/language/cubical.html#cubical-agda-without-glue)+ by using the flag `--cubical=no-glue`,+ a variant of Cubical Agda which disables the Glue types.+ For compatibility with modules using `--cubical[=full]` and `--cubical=erased`, see+ [variants](https://agda.readthedocs.io/en/v2.9.0/language/cubical.html#variants).++* Added the [Sharp modality](https://agda.readthedocs.io/en/v2.9.0/language/flat.html#the-sharp-modality),+ which adds a right adjoint to the existing flat modality enabled via the+ `--cohesion` flag. This also enables the use of attributes in record+ fields for any cohesion modality which has a left adjoint (currently+ just sharp and continuous).++Builtins+--------++* (**BREAKING**): The fixity declarations for `Agda.Builtin.Int.pos` and for+ `primINeg`, `primIMin`, and `primIMax`, in `Agda.Primitive.Cubical` have been removed.+ Reason: they trigger the new warning `FixityDeclarationForNonOperator`.+ If you want to use these builtins as operators, supply a fixity in the `renaming` directive, e.g.:+ ```agda+ open import Agda.Builtin.Int renaming (pos to infix 8 +_)+ open import Agda.Primitive.Cubical renaming+ ( primINeg to infix 30 ~_+ ; primIMin to infixr 20 _∧_+ ; primIMax to infixr 20 _∨_+ )+ ```++Reflection+----------++* `tcTypeError` now throws `UserError` instead of `GenericDocError`.++* Tactic arguments (`@tactic`) are now supported in module telescopes.++* `unquoteDecl` and `unquoteDef` now check that the meta-program+ actually defines all the given identifiers+ (issue [#8851](https://github.com/agda/agda/issues/8851)).++Library management+------------------++* Suppport for version-specific `defaults` files: a file whose name is+ of the form `defaults-X.Y.Z` will take precedence over the standard+ `defaults` one for the `X.Y.Z` version of the compiler. This can be+ used to have default libraries that are only compatible with a given+ version of the compiler.++Interaction and emacs mode+--------------------------++* The JSON interaction protocol (`--interaction-json`) no longer loses+ information that the Emacs frontend displays:++ - `GoalAndHave` responses now include a `boundary` field with the+ boundary faces of the checked expression+ ("Boundary (actual)" in the Emacs mode).++ - `NormalForm` and `InferredType` responses now pretty-print the+ expression in the command state captured when the command ran, as+ the Emacs frontend does, instead of in the current state+ (fixes [Issue #5665](https://github.com/agda/agda/issues/5665)).++ - `Mimer` responses now include the `interactionPoint` the solution+ refers to.++* Proof search (Mimer, `C-c C-a` in Emacs) now also uses functions+ defined in the same `mutual` block as the function being defined,+ without having to give them as hints.+ As for recursive calls to the function itself, they are only applied+ to structurally smaller arguments+ (Issue [#8783](https://github.com/agda/agda/issues/8783)).++* Syntax highlighting and go-to-definition now also works in the Agda+ information and debug buffers in Emacs where goals etc. are displayed.+ This fixes long-standing [Issue #706](https://github.com/agda/agda/issues/706).++* By temporarily turning on printing of hidden arguments+ (`OPTION --show-implicit`, `C-c C-x C-h` in Emacs)+ and then splitting on result in a hole+ (`C-c C-c RET` in Emacs, the whole sequence being `C-c C-x C-h C-c C-c RET`),+ hidden arguments can be introduced in the left hand side of a clause.+ In the presence of generalized variables, this used to introduce unparsable names.+ For instance:+ ```agda+ variable+ l : Level+ A : Set l++ id : A → A+ id = {!!}+ ```+ Here, `id {A.l} {A} x = ?` was produced, triggering an error.+ Now, the correct `id {A = A} x = ?` is produced+ (Issue [#8153](https://github.com/agda/agda/issue/8153)).++* The implicit (hidden and instance) fields of a record pattern are+ no longer printed by default.+ They are only printed with option `--show-implicit`+ (`C-c C-x C-h` in Emacs), or if the user wrote them in the first place.+ For instance, case splitting on `x` in+ ```agda+ record R : Set where+ field+ {n} : Nat+ rf : n ≡ n++ f : R → Set+ f x = {!x!} -- C-c C-c x+ ```+ now produces `f record { rf = rf } = ?` instead of+ `f record { n = n ; rf = rf } = ?`.+ This conforms the treatment of record patterns to the+ situation where the record type has a constructor, in which case the+ hidden arguments were already omitted+ (Issue [#8787](https://github.com/agda/agda/issue/8787)).++* Catch-all copattern clauses are now tolerated as unreachable clauses+ rather than being outright rejected with a `CosplitCatchall` error.+ They can be used as jumpboard for further result splitting.+ (A scenario is a record type that got extended with new fields,+ and definitions producing record values need to be extended as well.)+ Example:+ ```agda+ test : Σ A B+ test .fst = a+ test = {!!} -- C-c C-c RET+ ```+ This split produces the clause `test .snd = ?`.+ (Issue [#8139](https://github.com/agda/agda/issue/8139)).+++* A normalization level can now also passed to command `Cmd_constraints`+ ("show constraints", `C-c C-=` in Emacs).+ In Emacs, the normalization level is given as usual by `C-u` prefixes.++ This interface change is **breaking** for frontends to `agda --interaction`+ such as the VSCode `agda-mode`, which need updating.++* Fixed an internal error in `Cmd_helper_function` (`C-c C-h` in Emacs)+ (Issue [#8103](https://github.com/agda/agda/issue/8103)).+ Changed the type of `Goal_HelperFunction` which might be **breaking**+ 3rd-party interaction frontends.++* `NON_TERMINATING` functions now only reduce in `IgnoreAbstract` mode of+ commands `Cmd_compute(_toplevel)` (`C-u C-c C-n` in Emacs)+ regardless of whether invoked at toplevel or in a hole+ (Issue [#2410](https://github.com/agda/agda/issue/2410)).++* _Go-to-definition_ (`M-.`) is now implemented using Emacs' built-in+ [Xref]. Basic usage stays the same (`M-.` or using the mouse), but+ now also includes searching for definitions by exact (`C-u M-.`) or+ approximate names (`C-M-.`) and listing references (`M-?`) in loaded+ files.++[Xref]: https://www.gnu.org/software/emacs/manual/html_node/emacs/Xref.html++Backends+--------++* `agda --html --html-highlight=code example.lagda.tree` now produces+ `html/example.tree`, which Forester can consume directly;+ no external tools needed.++* New option `--ghc-trace` for GHC Backend to instrument code+ such that the Agda name of the function is printed to `stderr`+ whenever a function is entered.++* The JS backend now explicitly lists all primitives that should compile+ to `undefined`. Primitives not in this list or the RTS trigger a new+ `UnknownJSPrimitive` warning+ (see [#8352](https://github.com/agda/agda/issues/8352)).++* The JS backend's CJS & AMD module styles are now deprecated.+ Please use ES6 module style instead (`--js-es6`).++* The JS backend now compiles constructors to string-tagged arrays.+ This change is **breaking** for hand-written JS code relying on the previous Scott-Encoding.+ Constructors for types with `COMPILE JS` pragmas are not affected.+ (see [#8720](https://github.com/agda/agda/pull/8720))++Issues closed+-------------++For 2.9.0, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.9.0+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++### Consistency issues++- [Issue #7892](https://github.com/agda/agda/issues/7892): The telescope of a projection need not be the telescope of the record type+- [Issue #8341](https://github.com/agda/agda/issues/8341): Postulates in safe mode (regression in 2.8.0)+- [Issue #8453](https://github.com/agda/agda/issues/8453): False because the `SIGMA` builtin accepts types that are not Σ-types+- [Issue #8557](https://github.com/agda/agda/issues/8557): Proof of global choice and of false+- [Issue #8564](https://github.com/agda/agda/issues/8564): Function call tricks positivity checker+- [Issue #8565](https://github.com/agda/agda/issues/8565): Positivity bug with builtins+- [Issue #8587](https://github.com/agda/agda/issues/8587): Endpoints of paths are not checked without `--cubical`+- [Issue #8683](https://github.com/agda/agda/issues/8683): Cubical primitive side conditions are not checked when an application is inferred+- [Issue #8686](https://github.com/agda/agda/issues/8686): Projection-likeness drops arguments the principal argument's type does not determine+- [Issue #8687](https://github.com/agda/agda/issues/8687): The coverage checker infers missing clauses under the wrong module-parameter substitution+- [Issue #8688](https://github.com/agda/agda/issues/8688): Occurrence analysis ignores sorts: a Level argument used only in Set l is Nonvariant, giving universe resizing+- [Issue #8694](https://github.com/agda/agda/issues/8694): The unifier's cycle check looks inside irrelevant and Prop-typed constructor arguments+- [Issue #8695](https://github.com/agda/agda/issues/8695): The unifier's cycle rule checks only the head constructor for higher inductive types+- [Issue #8696](https://github.com/agda/agda/issues/8696): Data/record types copied by a module application inside a block get their arguments marked unused+- [Issue #8697](https://github.com/agda/agda/issues/8697): Interface serialiser conflates the Float literals 0.0 and -0.0+- [Issue #8698](https://github.com/agda/agda/issues/8698): Inconsistency with named `where` modules under `with` (regression in 2.5.2)+- [Issue #8699](https://github.com/agda/agda/issues/8699): Termination checker descends into irrelevant constructor arguments of dot patterns+- [Issue #8700](https://github.com/agda/agda/issues/8700): Clause-based matcher treats a MissingClauses-stuck argument as a definite mismatch (regression in 2.6.3)+- [Issue #8703](https://github.com/agda/agda/issues/8703): Clause-based reduction skips underapplied clauses, reducing differently than after compilation to case-trees+- [Issue #8704](https://github.com/agda/agda/issues/8704): Clause-based reduction falls through on a stuck lazy (forced) match, disagreeing with the case tree (regression in 2.7.0)+- [Issue #8834](https://github.com/agda/agda/issues/8834): Escape from sharp modality / negativity++### Internal errors++- [Issue #3123](https://github.com/agda/agda/issues/3123): Malformed projection definition+- [Issue #6173](https://github.com/agda/agda/issues/6173): Internal error at Agda/Syntax/Abstract/Name.hs:150:44 (regression in 2.6.2)+- [Issue #6770](https://github.com/agda/agda/issues/6770): Incorrect substitution when opening parameterised module with a generalised variable.+- [Issue #7564](https://github.com/agda/agda/issues/7564): Internal error when giving the unit type in a function on HITs+- [Issue #7629](https://github.com/agda/agda/issues/7629): Internal error with src/full/Agda/TypeChecking/Substitute.hs:140:33 using Cubical Agda+- [Issue #7964](https://github.com/agda/agda/issues/7964): Synthesis fails when given hint from a module opened as an instance+- [Issue #8068](https://github.com/agda/agda/issues/8068): `__IMPOSSIBLE__` on dependent pattern match + unrelated holes+- [Issue #8097](https://github.com/agda/agda/issues/8097): Internal error when trying Automatic Proof Search (regression in 2.8.0)+- [Issue #8103](https://github.com/agda/agda/issues/8103): Internal error when trying C-c C-h (helper function)+- [Issue #8215](https://github.com/agda/agda/issues/8215): Internal error triggered by instance declaration within record (regression in 2.8.0)+- [Issue #8263](https://github.com/agda/agda/issues/8263): Internal error in ProjectionLike.hs (regression in 2.6.4)+- [Issue #8298](https://github.com/agda/agda/issues/8298): `__IMPOSSIBLE__` for incomplete mixfix copattern definition in let binding (regression in 2.8.0)+- [Issue #8325](https://github.com/agda/agda/issues/8325): An internal error during refining (src/full/Agda/TypeChecking/Monad/Context.hs:672:26) (regression in 2.8.0)+- [Issue #8336](https://github.com/agda/agda/issues/8336): Internal error in double checker with projection-like functions (Non-exhaustive patterns in Just n) (regression in 2.6.4)+- [Issue #8365](https://github.com/agda/agda/issues/8365): Crash with `--rewriting` flag+- [Issue #8514](https://github.com/agda/agda/issues/8514): `__IMPOSSIBLE__` involving local rewrite rule and a with abstraction+- [Issue #8521](https://github.com/agda/agda/issues/8521): `__IMPOSSIBLE__` when pattern matching against irrelevant instance argument? (regression in 2.6.2)+- [Issue #8532](https://github.com/agda/agda/issues/8532): Missing in reduce in anti-unification causes `__IMPOSSIBLE__` in `TypeChecking/Reduce/Fast.hs:1417:43` (regression in 2.5.3)+- [Issue #8545](https://github.com/agda/agda/issues/8545): Internal error with instance and open-public in record (regression in 2.5.2)+- [Issue #8554](https://github.com/agda/agda/issues/8554): `__IMPOSSIBLE__` in Agda.TypeChecking.MetaVars triggered interactively+- [Issue #8577](https://github.com/agda/agda/issues/8577): IMPOSSIBLE during pattern matching in the presence of a local rewrite rule+- [Issue #8580](https://github.com/agda/agda/issues/8580): Unused implicit parameter in pattern synonym `__IMPOSSIBLE__`+- [Issue #8581](https://github.com/agda/agda/issues/8581): Internal error in TypeChecking/Monad/Context.hs when trying to load/type-check a malformed lambda parameter pattern inside an interaction hole+- [Issue #8621](https://github.com/agda/agda/issues/8621): Internal error (maybe related to instance arguments?) (regression in 2.8.0)+- [Issue #8625](https://github.com/agda/agda/issues/8625): agda2-infer-type-maybe-toplevel on anonymous record constructor causes an internal error+- [Issue #8626](https://github.com/agda/agda/issues/8626): `__IMPOSSIBLE__` at `Agda/TypeChecking/CompiledClause/Compile.hs`:180:20+- [Issue #8634](https://github.com/agda/agda/issues/8634): In Emacs, unknown `.agda-lib` field triggers `__IMPOSSIBLE__` at `Agda.TypeChecking.Serialise.Instances.Common`:101:34 (regression in 2.8.0)+- [Issue #8636](https://github.com/agda/agda/issues/8636): Internal error when an instance value is used as an index+- [Issue #8649](https://github.com/agda/agda/issues/8649): Internal error in confluence checker with rewrite rule for coinductive record projection+- [Issue #8680](https://github.com/agda/agda/issues/8680): Impossible state when unused pattern argument is also a variable declaration+- [Issue #8777](https://github.com/agda/agda/issues/8777): Crash due to unsound call to `canonicalName`+- [Issue #8808](https://github.com/agda/agda/issues/8808): Internal error during cubical boundary recovery+- [Issue #8851](https://github.com/agda/agda/issues/8851): `unquoteDecl` panics when the macro does not `declareDef` at all+- [Issue #8853](https://github.com/agda/agda/issues/8853): Internal error when using `withReconstructed`+- [Issue #8888](https://github.com/agda/agda/issues/8888): `__IMPOSSIBLE__` reached with `--flat-split` and `--double-check`++### Other regressions++- [Issue #3054](https://github.com/agda/agda/issues/3054): Reduction missing during LHS checking (regression in 2.6.0)+- [Issue #4150](https://github.com/agda/agda/issues/4150): Not in scope error instead of missing type signature error (regression in 2.5.4)+- [Issue #7595](https://github.com/agda/agda/issues/7595): `with` compiles 40x slower than `case_of_` (regression in 2.6.4.2)+- [Issue #8094](https://github.com/agda/agda/issues/8094): Backends that are enabled by default can no longer print help (regression in 2.8.0)+- [Issue #8096](https://github.com/agda/agda/issues/8096): Performance regression for test/Succeed/Issue6097-5 (regression in 2.6.4)+- [Issue #8150](https://github.com/agda/agda/issues/8150): Generate helper function reorders arguments (regression in 2.6.1, regression in 2.6.4)+- [Issue #8168](https://github.com/agda/agda/issues/8168): Mimer triggers a ParseError (regression in 2.8.0)+- [Issue #8300](https://github.com/agda/agda/issues/8300): Instanceness of principal argument dropped by postfix projection (regression in 2.6.0)+- [Issue #8435](https://github.com/agda/agda/issues/8435): In `mutual` blocks `data`/`record` signatures can be given after their definition (regression in 2.6.0)+- [Issue #8559](https://github.com/agda/agda/issues/8559): Copattern definition gives UnequalTerms for equal terms (regression in 2.6.0)+- [Issue #8771](https://github.com/agda/agda/issues/8771): Regression in 2.6.4 with `--projection-like` (regression in 2.6.4)+- [Issue #8811](https://github.com/agda/agda/issues/8811): Can't give: `metaOccurs` check too strict with `--prop`, `--polarity`, or `--experimental-irrelevance` (regression in 2.6.2)++### Other issues++- [Issue #706](https://github.com/agda/agda/issues/706): syntax highlighting and definition location etc. for definitions in goal/error buffer+- [Issue #1120](https://github.com/agda/agda/issues/1120): Improve operator parsing performance+- [Issue #1680](https://github.com/agda/agda/issues/1680): Simple termination checking fails with --without-K+- [Issue #2369](https://github.com/agda/agda/issues/2369): “Module cannot be imported since it has open interaction points” should always point to module+- [Issue #2410](https://github.com/agda/agda/issues/2410): `C-c C-n` unfolds non-terminating functions+- [Issue #2503](https://github.com/agda/agda/issues/2503): On warning about redundant imports+- [Issue #2591](https://github.com/agda/agda/issues/2591): Operator parse error should be scope error+- [Issue #2636](https://github.com/agda/agda/issues/2636): The positivity checker complains when a new definition is added in the same where clause+- [Issue #3218](https://github.com/agda/agda/issues/3218): termination checking failure in copattern-style definition+- [Issue #3355](https://github.com/agda/agda/issues/3355): NO_POSITIVITY_CHECK pragma ignored in local `where` block+- [Issue #3677](https://github.com/agda/agda/issues/3677): Operator parse error should include "nullary operators"+- [Issue #4228](https://github.com/agda/agda/issues/4228): Wrong context for solved interaction point in generalized type+- [Issue #4271](https://github.com/agda/agda/issues/4271): Make module names into links in error messages+- [Issue #4339](https://github.com/agda/agda/issues/4339): Qualified `do` (Resolving the monad instance for `do` notation)+- [Issue #5305](https://github.com/agda/agda/issues/5305): Generalisation fails with --no-syntactic-equality+- [Issue #5411](https://github.com/agda/agda/issues/5411): `open` in module telescope goes wrong with generalization+- [Issue #5524](https://github.com/agda/agda/issues/5524): duplicate identifiers ignored in fixity declarations+- [Issue #5618](https://github.com/agda/agda/issues/5618): More precise wording of warning "Instance applies only to declarations that introduce new identifiers"+- [Issue #5665](https://github.com/agda/agda/issues/5665): agda --interaction-json gives unnecessarily qualified names after opening modules+- [Issue #5670](https://github.com/agda/agda/issues/5670): OperatorsExpr parsing blows up on large file+- [Issue #5791](https://github.com/agda/agda/issues/5791): Error message only mentions .agda and .lagda+- [Issue #5808](https://github.com/agda/agda/issues/5808): --interaction-json: interaction points with empty ranges after refine+- [Issue #5836](https://github.com/agda/agda/issues/5836): JSON interaction doesn't give ranges for newly refined goals+- [Issue #5839](https://github.com/agda/agda/issues/5839): Incorrect usage of underscore in names breaks parsing+- [Issue #6198](https://github.com/agda/agda/issues/6198): Canonicity failure with --cubical (?)+- [Issue #6240](https://github.com/agda/agda/issues/6240): Weird type generated for record field opened in telescope with generalized variable+- [Issue #6425](https://github.com/agda/agda/issues/6425): Not-in-scope constructors make patterns parse-failed+- [Issue #6825](https://github.com/agda/agda/issues/6825): Irrefutable matching in binders does not deliver expected results for non-eta patterns+- [Issue #6847](https://github.com/agda/agda/issues/6847): On dropping GHC versions 9.0 and lower+- [Issue #6861](https://github.com/agda/agda/issues/6861): Parallelize build+- [Issue #6939](https://github.com/agda/agda/issues/6939): Non-dependent tactic argument fails to run tactic+- [Issue #6940](https://github.com/agda/agda/issues/6940): Add flag to direct output of GHC backend+- [Issue #7001](https://github.com/agda/agda/issues/7001): Agda treats lambdas that are not annotated with `@ω` as non-erased+- [Issue #7139](https://github.com/agda/agda/issues/7139): Mangled trX/Con clause for indexed type with green slime+- [Issue #7225](https://github.com/agda/agda/issues/7225): Named errors instead of Generic[Doc]Error+- [Issue #7562](https://github.com/agda/agda/issues/7562): The script `install_agda_user.bat` for Windows uses the dangerous `setx` command+- [Issue #7664](https://github.com/agda/agda/issues/7664): Agda ignores constructor parameters but only if they're copied under a parameterised module+- [Issue #7691](https://github.com/agda/agda/issues/7691): Custom treeless pipeline is ignored for "recursive" calls+- [Issue #7805](https://github.com/agda/agda/issues/7805): Inscrutable error with `record where` + implicit arguments+- [Issue #7829](https://github.com/agda/agda/issues/7829): Fields with signature not highlighted in `record where`+- [Issue #7836](https://github.com/agda/agda/issues/7836): `record where` silently ignores postulated field values+- [Issue #7837](https://github.com/agda/agda/issues/7837): `record where` handles duplicate names in open directive in non-standard way+- [Issue #7838](https://github.com/agda/agda/issues/7838): `record where`'s interpretation of `open` is very syntactic+- [Issue #7876](https://github.com/agda/agda/issues/7876): Internal error with `--rewriting` and dependent identity type+- [Issue #7893](https://github.com/agda/agda/issues/7893): Confluence check misses critical pair+- [Issue #7906](https://github.com/agda/agda/issues/7906): Manually eta-expanding clause makes termination checking fail+- [Issue #7941](https://github.com/agda/agda/issues/7941): Denial of case split in the presence of known values+- [Issue #7968](https://github.com/agda/agda/issues/7968): Undefined `Char`-related primitives when compiled to JS+- [Issue #7972](https://github.com/agda/agda/issues/7972): Mimer has problems instantiating predicates+- [Issue #7976](https://github.com/agda/agda/issues/7976): Soft error for `{-# REWRITE ... #-}` without `--rewriting`+- [Issue #7987](https://github.com/agda/agda/issues/7987): Allow erased `let`s+- [Issue #7988](https://github.com/agda/agda/issues/7988): Declarations before top-level module in a library give wrong error message+- [Issue #7989](https://github.com/agda/agda/issues/7989): Weird error for irrelevant clause+- [Issue #7994](https://github.com/agda/agda/issues/7994): `tactic` attributes at declarations are parsed, then silently dropped+- [Issue #7998](https://github.com/agda/agda/issues/7998): `instance` silently dropped from `primitive` and `variable` blocks+- [Issue #8016](https://github.com/agda/agda/issues/8016): Nix build fails on aarch64-darwin+- [Issue #8033](https://github.com/agda/agda/issues/8033): Coloring lost in warnings+- [Issue #8035](https://github.com/agda/agda/issues/8035): Optimising module copying+- [Issue #8037](https://github.com/agda/agda/issues/8037): checkParameters is defeated by not copying the record+- [Issue #8048](https://github.com/agda/agda/issues/8048): Guarded Cubical: Using instance arguments for tick variables enables proving join+- [Issue #8074](https://github.com/agda/agda/issues/8074): GHC 9.14+- [Issue #8078](https://github.com/agda/agda/issues/8078): piSort case of documentation+- [Issue #8080](https://github.com/agda/agda/issues/8080): std-lib-test spends ~5% of runtime rendering warnings that are never displayed+- [Issue #8092](https://github.com/agda/agda/issues/8092): COMPILE pragmas on declared-but-not-yet-defined symbols are discarded+- [Issue #8098](https://github.com/agda/agda/issues/8098): Agda deletes read-only interface files+- [Issue #8100](https://github.com/agda/agda/issues/8100): Non-normalized level printed for interactive "show constraints" and "solve"+- [Issue #8105](https://github.com/agda/agda/issues/8105): For ClashingDefinition also highlight the first definition+- [Issue #8112](https://github.com/agda/agda/issues/8112): Can not eliminate [type blocked on meta] forces very silly extended lambdas+- [Issue #8126](https://github.com/agda/agda/issues/8126): Generalizable `variable`s presented as projections in error message+- [Issue #8128](https://github.com/agda/agda/issues/8128): Poor error for duplicate definition in mutual block+- [Issue #8132](https://github.com/agda/agda/issues/8132): Error SolvedButOpenHoles should provide means to jump to module with open goals+- [Issue #8134](https://github.com/agda/agda/issues/8134): Caching is broken+- [Issue #8139](https://github.com/agda/agda/issues/8139): Fail soft on catch-all for copatterns+- [Issue #8144](https://github.com/agda/agda/issues/8144): Improve error message when trying to open record in a mutual block+- [Issue #8153](https://github.com/agda/agda/issues/8153): Result splitting should not introduce indirectly generalized variables+- [Issue #8157](https://github.com/agda/agda/issues/8157): Case split makes instance clause vanish+- [Issue #8170](https://github.com/agda/agda/issues/8170): Increase `--termination-depth` to 2 or infinity+- [Issue #8171](https://github.com/agda/agda/issues/8171): "Failed to give" with `--polarity`+- [Issue #8191](https://github.com/agda/agda/issues/8191): [ question/bug ] are infix names allowed for parametrised modules?+- [Issue #8206](https://github.com/agda/agda/issues/8206): `interleaved mutual` does not check consistency of parameters (hiding / typing)+- [Issue #8218](https://github.com/agda/agda/issues/8218): Unequal terms despite rewrite rule (across modules)+- [Issue #8228](https://github.com/agda/agda/issues/8228): Parse Error with Display Pragma and Mixfix Operator+- [Issue #8231](https://github.com/agda/agda/issues/8231): Rewrite rule matching does not respect irrelevance+- [Issue #8249](https://github.com/agda/agda/issues/8249): Literate Markdown: Option to only treat `agda`-code blocks as agda code+- [Issue #8256](https://github.com/agda/agda/issues/8256): `M-.` does not work in the information buffer+- [Issue #8269](https://github.com/agda/agda/issues/8269): Documentation: Is ETA for Colists Safe?+- [Issue #8273](https://github.com/agda/agda/issues/8273): Confluence Checking Error After Reloading File/Importing+- [Issue #8281](https://github.com/agda/agda/issues/8281): Literate programming Forester potential improvement+- [Issue #8308](https://github.com/agda/agda/issues/8308): Support turning off colored output via `NO_COLOR` environment variable+- [Issue #8312](https://github.com/agda/agda/issues/8312): `with … in` functions cannot reason about themselves+- [Issue #8326](https://github.com/agda/agda/issues/8326): Importing file with --cubical reports error about --two-level+- [Issue #8327](https://github.com/agda/agda/issues/8327): Splitting on a prop in between record fields fails with `SplitInProp` error+- [Issue #8337](https://github.com/agda/agda/issues/8337): Agda instance search cannot find nested instances+- [Issue #8344](https://github.com/agda/agda/issues/8344): C-c C-, shows a binding that is not there+- [Issue #8352](https://github.com/agda/agda/issues/8352): JS backend: unknown primitives silently compiled to Undefined+- [Issue #8370](https://github.com/agda/agda/issues/8370): Putting a `pattern` `record` in an index kills canonicity for cubical+- [Issue #8374](https://github.com/agda/agda/issues/8374): Allow fixity decls for anonymous modules outside module+- [Issue #8380](https://github.com/agda/agda/issues/8380): Weird behavior with comment parsing+- [Issue #8388](https://github.com/agda/agda/issues/8388): `in` suggests to use no longer used {-# BUILTIN REFL name #-}+- [Issue #8398](https://github.com/agda/agda/issues/8398): JS backend: use tagged arrays instead of Scott encoding for data types+- [Issue #8400](https://github.com/agda/agda/issues/8400): No error highlighting for InstanceWithExplicitArg+- [Issue #8402](https://github.com/agda/agda/issues/8402): LaTeX backend uses unknown command`\AgdaDeadcode`+- [Issue #8420](https://github.com/agda/agda/issues/8420): Direct support for `[]-cong`+- [Issue #8431](https://github.com/agda/agda/issues/8431): Error RecursiveRecordNeedsInductivity switched off by NO_POSITIVITY_CHECK+- [Issue #8440](https://github.com/agda/agda/issues/8440): Cubical Agda prints `IsOne (A ∨ ~ A)` in an error where `A : Set`+- [Issue #8478](https://github.com/agda/agda/issues/8478): Lines/second in profiling output+- [Issue #8479](https://github.com/agda/agda/issues/8479): Agda.Interaction.InteractionTop highlights the fatal import in the wrong buffer+- [Issue #8494](https://github.com/agda/agda/issues/8494): Emacs mode gets confused on goal position with certain strings+- [Issue #8495](https://github.com/agda/agda/issues/8495): Emacs goals are non-interactive in literate forester files+- [Issue #8519](https://github.com/agda/agda/issues/8519): Rewrite rule does not apply after doing a path abstraction on LHS+- [Issue #8526](https://github.com/agda/agda/issues/8526): ETA pragma silently does nothing for imported (coinductive) records+- [Issue #8529](https://github.com/agda/agda/issues/8529): Bug (cut-and-paste error) allows NO_UNIVERSE_CHECK to attach to mutual blocks+- [Issue #8570](https://github.com/agda/agda/issues/8570): Meta-variable instantiated with ill-resourced type+- [Issue #8583](https://github.com/agda/agda/issues/8583): (Co)InfectiveImport error should provide jumpable link to imported module+- [Issue #8591](https://github.com/agda/agda/issues/8591): Quotient types, erased function and propositional extensionality+- [Issue #8596](https://github.com/agda/agda/issues/8596): Termination checker rejects program when field takes 2 or 4 (but not 0, 1, 3, 5, or 6) trivial ⊤ arguments+- [Issue #8599](https://github.com/agda/agda/issues/8599): [ with ] nested irrefutable `with`s cause a parse error!?+- [Issue #8638](https://github.com/agda/agda/issues/8638): GHC backend erases patterns on datatypes indexed by erased datatypes+- [Issue #8639](https://github.com/agda/agda/issues/8639): JS backend mis-compiles list cons (`_∷_`)+- [Issue #8647](https://github.com/agda/agda/issues/8647): FOREIGN GHC pragma changes lost by caching+- [Issue #8666](https://github.com/agda/agda/issues/8666): Make `--irrelevance` infective+- [Issue #8710](https://github.com/agda/agda/issues/8710): The second imported rewriting relation is ignored+- [Issue #8739](https://github.com/agda/agda/issues/8739): Error "unexpected implicit argument" should print the available implicit arguments+- [Issue #8759](https://github.com/agda/agda/issues/8759): Crashes due to missing cases in strict bindings+- [Issue #8767](https://github.com/agda/agda/issues/8767): The strict GHC backend generates slow code+- [Issue #8783](https://github.com/agda/agda/issues/8783): Mimer (C-c C-a) does not automatically use mutually defined functions+- [Issue #8787](https://github.com/agda/agda/issues/8787): Case splitting producing `record` patterns does not omit the implicit fields+- [Issue #8815](https://github.com/agda/agda/issues/8815): Mimer rejects candidate if it generates constraints it would solve in the next step+- [Issue #8828](https://github.com/agda/agda/issues/8828): Meta solutions leak from abstract and opaque blocks+- [Issue #8830](https://github.com/agda/agda/issues/8830): Instance resolution should not ignore available instances+- [Issue #8841](https://github.com/agda/agda/issues/8841): Support Emacs 31+- [Issue #8847](https://github.com/agda/agda/issues/8847): Instance search does not find unquoted definitions in instance blocks+- [Issue #8858](https://github.com/agda/agda/issues/8858): `Cmd_highlight` after Give/Refine emits stale disambiguated names from `stDisambiguatedNames`+- [Issue #8875](https://github.com/agda/agda/issues/8875): Warn if one includes several versions of the same library+- [Issue #8881](https://github.com/agda/agda/issues/8881): Regression in 2.9.0-rc1 and 2.9.0-rc2: level meta left with only inequalities after instance search under a λ+- [Issue #8898](https://github.com/agda/agda/issues/8898): `primFloatDecode` does not terminate on `0.0` and `-0.0` (type checker, GHC and JS backends)++Pull requests merged for 2.9.0+------------------------------++- [PR #6911](https://github.com/agda/agda/issues/6911): Reopen PR "Add `record where` syntax sugar (#6603)"+- [PR #7861](https://github.com/agda/agda/issues/7861): Implement a --cubical=no-glue option+- [PR #7877](https://github.com/agda/agda/issues/7877): `record where`, again, again (again?)+- [PR #7881](https://github.com/agda/agda/issues/7881): [ fix #7876 ] Check meta instantiation in constraintMetas+- [PR #7908](https://github.com/agda/agda/issues/7908): Drop GHC 9.0 and below and bump dependencies to LTS 20.26+- [PR #7909](https://github.com/agda/agda/issues/7909): Fix #7906: use compiled clause reducer in termination checker+- [PR #7922](https://github.com/agda/agda/issues/7922): Mimer refactor+- [PR #7951](https://github.com/agda/agda/issues/7951): Improve module checkpointing performance+- [PR #7974](https://github.com/agda/agda/issues/7974): [workflows] run agda after building it (cabal & stack)+- [PR #7985](https://github.com/agda/agda/issues/7985): Fix #7976: warning on REWRITE pragmas when --rewriting is off+- [PR #7986](https://github.com/agda/agda/issues/7986): New option --ghc-trace to instrument code with call trace+- [PR #7990](https://github.com/agda/agda/issues/7990): Modalities in aliases and let-bindings+- [PR #7995](https://github.com/agda/agda/issues/7995): Fix #7994: warn about @tactic attributes ignored in declarations+- [PR #8000](https://github.com/agda/agda/issues/8000): Fix #7998: `instance` silently dropped in `primitive`/`variable` blocks+- [PR #8003](https://github.com/agda/agda/issues/8003): hotfix: support 'record where' in contexts+- [PR #8004](https://github.com/agda/agda/issues/8004): Re #7954: disallow postfix projections in parentheses+- [PR #8008](https://github.com/agda/agda/issues/8008): flake: fix overlay+- [PR #8009](https://github.com/agda/agda/issues/8009): New option --print-options and --bash-complete+- [PR #8014](https://github.com/agda/agda/issues/8014): doc: use the correct format for short options+- [PR #8017](https://github.com/agda/agda/issues/8017): nix: fix build on aarch64-darwin+- [PR #8020](https://github.com/agda/agda/issues/8020): record where: Fix impossible with named module copy+- [PR #8022](https://github.com/agda/agda/issues/8022): fixup: eta for cubical primitives against neutrals+- [PR #8025](https://github.com/agda/agda/issues/8025): Re #1499 #5277 better formatting for error AmbiguousFunClauses+- [PR #8027](https://github.com/agda/agda/issues/8027): Fix #5524: report (with range) duplicate name in fixity declaration+- [PR #8028](https://github.com/agda/agda/issues/8028): [ opt ] Optimize free variable sets+- [PR #8029](https://github.com/agda/agda/issues/8029): Benchmarking and profiling for module application+- [PR #8030](https://github.com/agda/agda/issues/8030): fixup: range of InlineNoExactSplit warning+- [PR #8038](https://github.com/agda/agda/issues/8038): Only generate copies for used names+- [PR #8040](https://github.com/agda/agda/issues/8040): Fix #8033: color warnings by keeping Doc over rendering to String+- [PR #8041](https://github.com/agda/agda/issues/8041): deepseq-1.5.2.0 no longer derives NFData with embedded functions+- [PR #8044](https://github.com/agda/agda/issues/8044): Hyperlink warning names on OSC 8 terminals+- [PR #8047](https://github.com/agda/agda/issues/8047): Highlighting in Emacs Agda information buffer+- [PR #8049](https://github.com/agda/agda/issues/8049): Fix #8048 by generating lock constraints also for implicit arguments+- [PR #8050](https://github.com/agda/agda/issues/8050): MAlonzo: avoid emitting duplicate import statements+- [PR #8052](https://github.com/agda/agda/issues/8052): Re #8024: alert user that --build-library does not accept backends+- [PR #8055](https://github.com/agda/agda/issues/8055): Fix issue #7001: no longer infer lambdas that have no erasure status on their arguments+- [PR #8056](https://github.com/agda/agda/issues/8056): Fix #6939: warn when parser drops misplaced tactic in `Fun`+- [PR #8057](https://github.com/agda/agda/issues/8057): Emacs mode: clean `agda2-forget-all-goals`+- [PR #8058](https://github.com/agda/agda/issues/8058): Structured output of `--help`: options sorted into topics+- [PR #8063](https://github.com/agda/agda/issues/8063): fixup: caching with copy trimming+- [PR #8065](https://github.com/agda/agda/issues/8065): Medium-sized serialization optimizations+- [PR #8069](https://github.com/agda/agda/issues/8069): Bubble transpSysTel' failures upwards+- [PR #8071](https://github.com/agda/agda/issues/8071): Go-to-definition in information buffer+- [PR #8073](https://github.com/agda/agda/issues/8073): globally cache small Term variables+- [PR #8079](https://github.com/agda/agda/issues/8079): Fix operator parsing asymptotics+- [PR #8081](https://github.com/agda/agda/issues/8081): [ fix #8078 ] Fix documentation for piSort+- [PR #8084](https://github.com/agda/agda/issues/8084): Inverse scope optimization+- [PR #8085](https://github.com/agda/agda/issues/8085): containers 0.8+- [PR #8089](https://github.com/agda/agda/issues/8089): Simplify "Installation" documentation+- [PR #8093](https://github.com/agda/agda/issues/8093): [ fix #8092 ] Preserve compiler pragmas when overwriting a definition+- [PR #8095](https://github.com/agda/agda/issues/8095): Fix #8094: run getInteractor after executing `--help` (regression in 2.8.0)+- [PR #8099](https://github.com/agda/agda/issues/8099): Fix #8098: don't delete readonly .agdai files+- [PR #8101](https://github.com/agda/agda/issues/8101): [ fix #8096 ] Redo implementation of LevelUniv infrastructure+- [PR #8102](https://github.com/agda/agda/issues/8102): Normalization level for Cmd_constraints (C-c C-=)+- [PR #8104](https://github.com/agda/agda/issues/8104): Fix #8103 by removing the parsing hack in BasicOps.metaHelperType+- [PR #8107](https://github.com/agda/agda/issues/8107): Fix #2410: only reduce NON_TERMINATING functions with C-u prefix to C-c C-n+- [PR #8108](https://github.com/agda/agda/issues/8108): Fix #8105: highlight thing shadowed by a clashing definition+- [PR #8110](https://github.com/agda/agda/issues/8110): Remove unnecessary LHS.Unify.LeftInverse computation+- [PR #8115](https://github.com/agda/agda/issues/8115): Implement `{Char, Nat}` primitives for JS backend and add related tests+- [PR #8121](https://github.com/agda/agda/issues/8121): Fix #8119: Dotted expression not impossible+- [PR #8127](https://github.com/agda/agda/issues/8127): Fix #8126: don't error-report generalized variables as projections+- [PR #8129](https://github.com/agda/agda/issues/8129): Fix #8128: point to previous definition in DuplicateDefinition error+- [PR #8135](https://github.com/agda/agda/issues/8135): Fix #8132 by adding SourceFile to SolvedButOpenHoles error+- [PR #8137](https://github.com/agda/agda/issues/8137): Fix #7941: allow splitting on a refined variable+- [PR #8141](https://github.com/agda/agda/issues/8141): Fix for issue #8097+- [PR #8146](https://github.com/agda/agda/issues/8146): Fix #8144: NoSuchModule X gives hint if there is a data/record X+- [PR #8147](https://github.com/agda/agda/issues/8147): Fix #4271: print filenames with modules in errors+- [PR #8149](https://github.com/agda/agda/issues/8149): Print lineage (`WhyInScope`) in `ClashingDefinition` error+- [PR #8151](https://github.com/agda/agda/issues/8151): Add Datatypes of Datatypes to tutorial list+- [PR #8155](https://github.com/agda/agda/issues/8155): Serialize Range in WhyInScope for lineage+- [PR #8156](https://github.com/agda/agda/issues/8156): Fix #8139: tolerate catch-all copatterns+- [PR #8158](https://github.com/agda/agda/issues/8158): Fix #7646 by synching goal command range with interaction range+- [PR #8159](https://github.com/agda/agda/issues/8159): Fix issue #5791: list all possible file extensions in FileNotFound error+- [PR #8160](https://github.com/agda/agda/issues/8160): Re #7225: remove some GenericDocErrors+- [PR #8162](https://github.com/agda/agda/issues/8162): Rename GenericDocErrors in Generalize.hs+- [PR #8169](https://github.com/agda/agda/issues/8169): Fix #8168 by catching ParseErrors in expressions Mimer produces+- [PR #8173](https://github.com/agda/agda/issues/8173): Do not set default input method to "Agda" globally+- [PR #8174](https://github.com/agda/agda/issues/8174): Add .agdai files to 'completion-ignored-extensions'+- [PR #8175](https://github.com/agda/agda/issues/8175): Remove usages of deprecated 'window-system' variable+- [PR #8176](https://github.com/agda/agda/issues/8176): Add custom setter to 'agda2-mode-abbrevs-use-defaults'+- [PR #8177](https://github.com/agda/agda/issues/8177): Allow disabling resizing of minibuffer due to input method+- [PR #8178](https://github.com/agda/agda/issues/8178): Check responses of commands issued by Agda to Emacs+- [PR #8179](https://github.com/agda/agda/issues/8179): Add support for 'repeat-mode'+- [PR #8181](https://github.com/agda/agda/issues/8181): Xref support for Agda2-mode+- [PR #8184](https://github.com/agda/agda/issues/8184): Reinterpret --termination-depth as max depth and do iterative deepening+- [PR #8194](https://github.com/agda/agda/issues/8194): UselessImport warning instead of ParseError for `import M x y`+- [PR #8195](https://github.com/agda/agda/issues/8195): Close #7225: remove Generic[Doc]Error for good+- [PR #8198](https://github.com/agda/agda/issues/8198): PR #8194 ctd.: move desugaring of `open import M args` into scope checker+- [PR #8200](https://github.com/agda/agda/issues/8200): Fix #8197: correct Range for "refine"+- [PR #8204](https://github.com/agda/agda/issues/8204): Fix #3123: instantiation of projection-like functions+- [PR #8205](https://github.com/agda/agda/issues/8205): Running Agda on WASM (resolving merge conflicts of #7561)+- [PR #8207](https://github.com/agda/agda/issues/8207): Fix #8206; refactor scope checker for RecDef a bit+- [PR #8210](https://github.com/agda/agda/issues/8210): Fix #8037 by copying record type along with its projection in module app+- [PR #8217](https://github.com/agda/agda/issues/8217): App range fix for operator application+- [PR #8220](https://github.com/agda/agda/issues/8220): Fix #8218: Update signature for imported rewrite rules+- [PR #8221](https://github.com/agda/agda/issues/8221): Treeless: don't mix up pipelines (#7691)+- [PR #8222](https://github.com/agda/agda/issues/8222): Optimize rewrite rule matching+- [PR #8226](https://github.com/agda/agda/issues/8226): New warning UnusedImports+- [PR #8232](https://github.com/agda/agda/issues/8232): Fix 8228: Parse Error with Display Pragma and Mixfix Operator+- [PR #8234](https://github.com/agda/agda/issues/8234): Fix #8231: Check relevance in `PTerm` matching+- [PR #8235](https://github.com/agda/agda/issues/8235): new feature: quote metas+- [PR #8238](https://github.com/agda/agda/issues/8238): New Warning to Fix #5929+- [PR #8239](https://github.com/agda/agda/issues/8239): [ fix #5315 ] Compile erased types to () in the GHC backend+- [PR #8243](https://github.com/agda/agda/issues/8243): [ fix #2691 ] Add basic documentation for simplification+- [PR #8250](https://github.com/agda/agda/issues/8250): Add --literate-markdown-only-agda-blocks option+- [PR #8267](https://github.com/agda/agda/issues/8267): Fix #8263: turn `__IMPOSSIBLE__` into `patternViolation` (regression in 2.6.4)+- [PR #8270](https://github.com/agda/agda/issues/8270): Fix #8269: doc: remove claim that ETA is safe for colists+- [PR #8274](https://github.com/agda/agda/issues/8274): Fix #8273: Consider interface to merge imported whilst checking confluence+- [PR #8278](https://github.com/agda/agda/issues/8278): Improve caching for (large) opaque blocks+- [PR #8279](https://github.com/agda/agda/issues/8279): Library management: support `defaults-X.Y.Z` files+- [PR #8280](https://github.com/agda/agda/issues/8280): Qualified `do` and qualified idiom brackets+- [PR #8292](https://github.com/agda/agda/issues/8292): Separately benchmark Polarity from Positivity; restore forcing of argOccurrences+- [PR #8293](https://github.com/agda/agda/issues/8293): Fix #3677: print names clashing with operators when parsing failed+- [PR #8295](https://github.com/agda/agda/issues/8295): Made it possible to turn off the occurrence analysis for functions+- [PR #8297](https://github.com/agda/agda/issues/8297): Doc on polarities: Cite the associated abstract.+- [PR #8303](https://github.com/agda/agda/issues/8303): GHC 9.14 compatibility+- [PR #8306](https://github.com/agda/agda/issues/8306): Re #8161: Split GeneralizePrepruneError into its three variants+- [PR #8309](https://github.com/agda/agda/issues/8309): Turn off colored terminal output when `NO_COLOR` is set.+- [PR #8310](https://github.com/agda/agda/issues/8310): Fix #8300: appViewM produces correct hiding for postfix projection+- [PR #8313](https://github.com/agda/agda/issues/8313): nix: bump nixpkgs+- [PR #8314](https://github.com/agda/agda/issues/8314): doc/user-manual: render maths as SVG instead of PNG+- [PR #8315](https://github.com/agda/agda/issues/8315): Reify an amount of backtrace when conversion checking fails+- [PR #8317](https://github.com/agda/agda/issues/8317): fix #8242: don't copy records to within themselves+- [PR #8318](https://github.com/agda/agda/issues/8318): #5833: make `with … in` generalise over `refl`+- [PR #8328](https://github.com/agda/agda/issues/8328): Fix #8327: check early for record constructor in let-pattern+- [PR #8329](https://github.com/agda/agda/issues/8329): Fix #8325 by changing an `__IMPOSSIBLE__` to a `fail` (regression in 2.8.0)+- [PR #8330](https://github.com/agda/agda/issues/8330): Fix #8326: handle the implication two-level <= cubical in isTwoLevelEnabled+- [PR #8332](https://github.com/agda/agda/issues/8332): Type check in parallel+- [PR #8333](https://github.com/agda/agda/issues/8333): Add link to "Let's play Agda" to user manual+- [PR #8338](https://github.com/agda/agda/issues/8338): #8337: Look for instance fields in eta records under binders+- [PR #8340](https://github.com/agda/agda/issues/8340): don't allow postulates in --safe lets+- [PR #8342](https://github.com/agda/agda/issues/8342): fix #8215: reduce candidate in its own state+- [PR #8345](https://github.com/agda/agda/issues/8345): Fix #8344: remember whether a LetBinding came from a LetAxiom+- [PR #8348](https://github.com/agda/agda/issues/8348): Erased levels [cubical]+- [PR #8353](https://github.com/agda/agda/issues/8353): Fix #8352: explicitly list JS primitives that should compile to Undefined+- [PR #8364](https://github.com/agda/agda/issues/8364): Support `@tactic` Module Parameters+- [PR #8369](https://github.com/agda/agda/issues/8369): Fix #8365: reduce in wrong context+- [PR #8376](https://github.com/agda/agda/issues/8376): Fix #7139: LeftInverse: reorder context in Solution steps+- [PR #8378](https://github.com/agda/agda/issues/8378): nix: enable cluster counting+- [PR #8381](https://github.com/agda/agda/issues/8381): Fix #8380: move line comment rule above block comment rule in lexer+- [PR #8382](https://github.com/agda/agda/issues/8382): Stop eta-expanding module applications+- [PR #8383](https://github.com/agda/agda/issues/8383): Free variable computation optimization+- [PR #8392](https://github.com/agda/agda/issues/8392): Progress reporting when checking in parallel+- [PR #8394](https://github.com/agda/agda/issues/8394): Fix --help claiming --type-in-type is the default+- [PR #8397](https://github.com/agda/agda/issues/8397): Make UnknownNamesIn{FixityDecl,PolarityPragmas} error warnings+- [PR #8401](https://github.com/agda/agda/issues/8401): Fix #8400 by remembering the range of the instance keyword+- [PR #8405](https://github.com/agda/agda/issues/8405): [ fix #8393 ] Normalise codomain of piSort when needed+- [PR #8406](https://github.com/agda/agda/issues/8406): Fix #8402: missing OtherAspects in agda.sty+- [PR #8407](https://github.com/agda/agda/issues/8407): JSONTop: avoid needless parentheses around types+- [PR #8409](https://github.com/agda/agda/issues/8409): Adding Sharp modality+- [PR #8410](https://github.com/agda/agda/issues/8410): Fix #7988: smarter figureOutTopLevelModule, prioritizes qualified module+- [PR #8413](https://github.com/agda/agda/issues/8413): Fix #5618: better wording of UselessInstance warning+- [PR #8414](https://github.com/agda/agda/issues/8414): Fix #5839 by adding conPartNotations to the OperatorInformation+- [PR #8416](https://github.com/agda/agda/issues/8416): Retain lineage (`AbstractName`) in `AmbiguousQName` for error reporting+- [PR #8433](https://github.com/agda/agda/issues/8433): Fix #3355: NO_POSITIVITY_CHECK pragmas in where and record+- [PR #8437](https://github.com/agda/agda/issues/8437): Fix #8435 by new warning DeclarationBeforeDefinition+- [PR #8438](https://github.com/agda/agda/issues/8438): Fix #4150 by sorting lone definitions up in a `mutual` block+- [PR #8439](https://github.com/agda/agda/issues/8439): Fix #6173 by inserting missing checkModuleName+- [PR #8444](https://github.com/agda/agda/issues/8444): fixup: traverse telescope properly in checkFibrantSplit+- [PR #8445](https://github.com/agda/agda/issues/8445): Remove transitive closure from positivity checking+- [PR #8447](https://github.com/agda/agda/issues/8447): Deprecate non-ES6 JS module styles+- [PR #8450](https://github.com/agda/agda/issues/8450): Mark all non-delimiter characters as word constituents in `agda2-mode-syntax-table`+- [PR #8451](https://github.com/agda/agda/issues/8451): [ #8283 ] Fix highlighting race condition in agda2-mode+- [PR #8458](https://github.com/agda/agda/issues/8458): [ #8452 ] Make agda2-maybe-goto jump across files+- [PR #8460](https://github.com/agda/agda/issues/8460): re. #8457: only ask if meta is an IP if cubical+- [PR #8462](https://github.com/agda/agda/issues/8462): Fix #8454+- [PR #8463](https://github.com/agda/agda/issues/8463): New `primRewriteNoMatch` primitive for controlling rewrite rule matching+- [PR #8466](https://github.com/agda/agda/issues/8466): Fix #8564: take definition site into account when serializing (Q)Name+- [PR #8469](https://github.com/agda/agda/issues/8469): Bump TeX-Live/setup-texlive-action from 3 to 4+- [PR #8471](https://github.com/agda/agda/issues/8471): Reverted two commits that made certain level arguments erased+- [PR #8473](https://github.com/agda/agda/issues/8473): Make Agda go faster+- [PR #8486](https://github.com/agda/agda/issues/8486): [ fix #7964 ] Properly handle projection-likeness in Mimer+- [PR #8488](https://github.com/agda/agda/issues/8488): Fix #8453: check field types of BUILTIN SIGMA+- [PR #8491](https://github.com/agda/agda/issues/8491): Add lines-per-second information to --profile=modules+- [PR #8498](https://github.com/agda/agda/issues/8498): [ emacs ] Overhaul goal lexer in agda2-goals-action+- [PR #8501](https://github.com/agda/agda/issues/8501): Bump GHC 9.12.2 to 9.12.4+- [PR #8502](https://github.com/agda/agda/issues/8502): Highlighting and go-to-definition in the debug buffer+- [PR #8503](https://github.com/agda/agda/issues/8503): Restrict pattern matching in binding position to eta-equality records (#6845 reopened)+- [PR #8506](https://github.com/agda/agda/issues/8506): [ emacs ] Only jump to an error in the selected window+- [PR #8508](https://github.com/agda/agda/issues/8508): User-manual: versionadded info for warnings+- [PR #8509](https://github.com/agda/agda/issues/8509): Dependencies: allow pqueue-1.7+- [PR #8512](https://github.com/agda/agda/issues/8512): Docs: why is --injective-type-constructors anti-classical & anti-univalent+- [PR #8515](https://github.com/agda/agda/issues/8515): `stripWithClausePatterns` in the right context+- [PR #8518](https://github.com/agda/agda/issues/8518): Serialize fewer generalization records+- [PR #8520](https://github.com/agda/agda/issues/8520): Update context in checkIApplyConfluence+- [PR #8522](https://github.com/agda/agda/issues/8522): Fix #8521 by remembering PossiblyProjectionPattern in DotP parsing+- [PR #8523](https://github.com/agda/agda/issues/8523): Remove inaccurate claim in two-level.lagda.rst+- [PR #8527](https://github.com/agda/agda/issues/8527): Update inaccurate Agda example in record-types.lagda.rst+- [PR #8528](https://github.com/agda/agda/issues/8528): [ emacs ] Fix goal detection in pattern lambdas+- [PR #8530](https://github.com/agda/agda/issues/8530): Fix #8529+- [PR #8533](https://github.com/agda/agda/issues/8533): No longer infer eta for records+- [PR #8541](https://github.com/agda/agda/issues/8541): Fix #6670 #5411 #6240 generalizeTel with open+- [PR #8542](https://github.com/agda/agda/issues/8542): Fix #7629 by correction countPatternVars for HITs+- [PR #8547](https://github.com/agda/agda/issues/8547): Fix #2877: doc: literal overloading is not allowed in patterns+- [PR #8555](https://github.com/agda/agda/issues/8555): Add mathematical bold fraktur to agda-input+- [PR #8556](https://github.com/agda/agda/issues/8556): Fix #4228: also prune genTel from solved interaction metas+- [PR #8560](https://github.com/agda/agda/issues/8560): Fix #3054 by introducing MatchPrio for constructor patterns (regression in 2.6.0)+- [PR #8567](https://github.com/agda/agda/issues/8567): Simplify fix of #6770: remove section updating+- [PR #8569](https://github.com/agda/agda/issues/8569): Fix occurrences in over-applied args, primitives and postulates+- [PR #8575](https://github.com/agda/agda/issues/8575): Add flag for irrelevance+- [PR #8576](https://github.com/agda/agda/issues/8576): [ fix #8557 ] Only resurrect irrelevant variables once+- [PR #8578](https://github.com/agda/agda/issues/8578): Fix #8577: Normalise under varTel in Unify.hs+- [PR #8584](https://github.com/agda/agda/issues/8584): Fix #8583: (Co)InfectiveError: report imported module with range+- [PR #8585](https://github.com/agda/agda/issues/8585): Fix #8580: internal error with _ in pattern synonym definition+- [PR #8588](https://github.com/agda/agda/issues/8588): [ re #8552 ] Add workaround to the release notes + test suite+- [PR #8593](https://github.com/agda/agda/issues/8593): Added `--erased-funext`, `--erased-propext` and `--erased-quotients`+- [PR #8594](https://github.com/agda/agda/issues/8594): Added a missing option to a list in the documentation+- [PR #8601](https://github.com/agda/agda/issues/8601): Fix #8596: termination checker respects copatterns+- [PR #8602](https://github.com/agda/agda/issues/8602): Fix #1680: Stratify termination masks by copattern+- [PR #8604](https://github.com/agda/agda/issues/8604): Bump actions/checkout from 6 to 7+- [PR #8606](https://github.com/agda/agda/issues/8606): Bump actions/cache from 5 to 6+- [PR #8612](https://github.com/agda/agda/issues/8612): Fix #8610+- [PR #8615](https://github.com/agda/agda/issues/8615): Fix #8587+- [PR #8617](https://github.com/agda/agda/issues/8617): Place -WShouldBeEtaRecordPattern under --exact-split.+- [PR #8628](https://github.com/agda/agda/issues/8628): Fixes #8626: treat lazy split pattern as dot pattern when there is nothing left to split in `compile`+- [PR #8632](https://github.com/agda/agda/issues/8632): Remove case-of-case optimization in compiler+- [PR #8635](https://github.com/agda/agda/issues/8635): Repair `nix build`+- [PR #8637](https://github.com/agda/agda/issues/8637): Bump actions/setup-python from 6 to 7+- [PR #8640](https://github.com/agda/agda/issues/8640): Allow aeson-2.3+- [PR #8643](https://github.com/agda/agda/issues/8643): Allow deepseq-1.5.2.0 (warns about rnf for functions)+- [PR #8646](https://github.com/agda/agda/issues/8646): Fix `COMPILE JS _∷_`+- [PR #8648](https://github.com/agda/agda/issues/8648): Fix #8647: for the sake of caching handle FOREIGN pragmas in the tc+- [PR #8652](https://github.com/agda/agda/issues/8652): Fix for #8636+- [PR #8657](https://github.com/agda/agda/issues/8657): [ fix #8649 ] Don't eta-expand no-eta records in confluence checker+- [PR #8658](https://github.com/agda/agda/issues/8658): Fix #8634: internal error with --interaction when .agda-lib file contains bogus fields+- [PR #8661](https://github.com/agda/agda/issues/8661): Upstream emacs mode fixes+- [PR #8662](https://github.com/agda/agda/issues/8662): Highlight ShouldBeEtaRecordPattern the same way as exactSplitWarnings+- [PR #8663](https://github.com/agda/agda/issues/8663): [wasm] nix: Bump nix pkgs for ghc-wasm to include critical bug fix for ghc/ghc#27447+- [PR #8667](https://github.com/agda/agda/issues/8667): Add missing flags to builtin modules+- [PR #8669](https://github.com/agda/agda/issues/8669): Fix #8638+- [PR #8671](https://github.com/agda/agda/issues/8671): Fix #8627: make --build-library on builtin library work+- [PR #8675](https://github.com/agda/agda/issues/8675): Dead code elimination: don't traverse meta judgement types+- [PR #8677](https://github.com/agda/agda/issues/8677): Fix #8599: classifyPattern: projection patterns only in LHSs+- [PR #8678](https://github.com/agda/agda/issues/8678): [ fix #5665 ] Close information gaps in the JSON interaction protocol+- [PR #8679](https://github.com/agda/agda/issues/8679): Fix #7564: Do not crash when trying eta-contraction on over-applied constructor.+- [PR #8681](https://github.com/agda/agda/issues/8681): Change R.constructor so that R is the record module rather than the type+- [PR #8682](https://github.com/agda/agda/issues/8682): Fix #8680 (pattern syn) by removing spurious `__IMPOSSIBLE__`+- [PR #8685](https://github.com/agda/agda/issues/8685): Fix #8683: check cubical side conditions also in inference mode+- [PR #8690](https://github.com/agda/agda/issues/8690): Fix #8686: False via projection-like due to non-injective type of principal argument+- [PR #8691](https://github.com/agda/agda/issues/8691): Fix #8688: positivity checker now also descends into Sort+- [PR #8701](https://github.com/agda/agda/issues/8701): Alternative fix of #8687+- [PR #8702](https://github.com/agda/agda/issues/8702): [ fix #8694 ] Take relevance into account for cycle rule in LHS unifier+- [PR #8706](https://github.com/agda/agda/issues/8706): Fix for #8700+- [PR #8707](https://github.com/agda/agda/issues/8707): Fix #8699 by masking irrelevant/Prop-sorted subterms in dot patterns in the termination checker+- [PR #8708](https://github.com/agda/agda/issues/8708): Fix #8697 by indexing the memo map for Double by their Word64 representation+- [PR #8709](https://github.com/agda/agda/issues/8709): Fix #8696 by eta-expanding data/recClauses before positivity checking+- [PR #8711](https://github.com/agda/agda/issues/8711): [ fix #8710 ] merge builtin rewrites when adding import+- [PR #8719](https://github.com/agda/agda/issues/8719): Small bugfix for Cubical Glue/HCompU (fixes #6198)+- [PR #8720](https://github.com/agda/agda/issues/8720): Compile constructors to string-tagged JS arrays+- [PR #8723](https://github.com/agda/agda/issues/8723): Add Agda Web to the manual+- [PR #8729](https://github.com/agda/agda/issues/8729): Fix #8532 by ensuring projectTyped gets a reduced type in antiUnify (regression in 2.5.3)+- [PR #8732](https://github.com/agda/agda/issues/8732): Fix #8698 by disallowing named where modules under with+- [PR #8736](https://github.com/agda/agda/issues/8736): [ #8591 ] Added a test case+- [PR #8738](https://github.com/agda/agda/issues/8738): Fix #1438: new warning FixityDeclarationForNonOperator+- [PR #8740](https://github.com/agda/agda/issues/8740): Fix issue 8336 by turning projection-like functions back into Defs (regression in 2.6.4)+- [PR #8743](https://github.com/agda/agda/issues/8743): Tried to fix a bug related to PR #8593+- [PR #8745](https://github.com/agda/agda/issues/8745): Support for `[]-cong`+- [PR #8768](https://github.com/agda/agda/issues/8768): Strict lets+- [PR #8770](https://github.com/agda/agda/issues/8770): Build with GHC 10.0.0+- [PR #8772](https://github.com/agda/agda/issues/8772): Fix #8771 by unspining also the transformed term in checkInternal (regression in 2.6.4)+- [PR #8774](https://github.com/agda/agda/issues/8774): Fix #8545 by storing data/recClause as just Term+- [PR #8778](https://github.com/agda/agda/issues/8778): Fix #8777: replace call to canonicalName by reduce+- [PR #8779](https://github.com/agda/agda/issues/8779): Fix #7664 checkParameters (revisit #8722)+- [PR #8789](https://github.com/agda/agda/issues/8789): Fix issue #8788+- [PR #8790](https://github.com/agda/agda/issues/8790): [ fix #8703 ] Treat underapplied functions as stuck+- [PR #8791](https://github.com/agda/agda/issues/8791): Fix #8787: drop hidden fields in record pattern when introduced by case-split+- [PR #8800](https://github.com/agda/agda/issues/8800): agda-mode: Rebind mouse-2 to 'agda2-goto-definition-mouse'+- [PR #8802](https://github.com/agda/agda/issues/8802): Makefile: new goal `fast-forward-ecosystem`; update submodules [ecosystem]+- [PR #8804](https://github.com/agda/agda/issues/8804): Fix #8783: Mimer: use functions from mutual block as default hints+- [PR #8806](https://github.com/agda/agda/issues/8806): Fix #8171 by creating metas at the unitPolarity (@++)+- [PR #8810](https://github.com/agda/agda/issues/8810): Fix #8808 by removing shortcut creating unbound de Bruijn indices+- [PR #8812](https://github.com/agda/agda/issues/8812): Fix #8811 by relaxing the modallity in the occurs check of sort annotations+- [PR #8816](https://github.com/agda/agda/issues/8816): Fix #8815 and #7972 by postponing constraints in Mimer+- [PR #8817](https://github.com/agda/agda/issues/8817): [ fix #8695 ] Treat occurrences in constructors of HITs as weakly rigid+- [PR #8822](https://github.com/agda/agda/issues/8822): Safer fix of #7181 (regression in 2.7.0)+- [PR #8833](https://github.com/agda/agda/issues/8833): [ fix #8765 ] Add separate response for errors in other files+- [PR #8837](https://github.com/agda/agda/issues/8837): [ fix #8828 ] Don't solve metas from outside current abstract block+- [PR #8840](https://github.com/agda/agda/issues/8840): [ #8839 ] Improved the detection of error/warning locations+- [PR #8843](https://github.com/agda/agda/issues/8843): Fix #8834 by checking cohesion and polarity when abstracting telescopes+- [PR #8850](https://github.com/agda/agda/issues/8850): Fix #8847 by not propagating `instance` to `unquoteDecl`s+- [PR #8852](https://github.com/agda/agda/issues/8852): Fix #8851: check that unquoteDecl invocation actually defines names+- [PR #8856](https://github.com/agda/agda/issues/8856): Fix #8853 by adding a case for `IApply` to `reconstructParameters`+- [PR #8869](https://github.com/agda/agda/issues/8869): Fix #8739: wrong implicit argument in LHS: also mention possible args+- [PR #8870](https://github.com/agda/agda/issues/8870): Decide whether pi is large based on original codomain sort+- [PR #8876](https://github.com/agda/agda/issues/8876): Fix #8875: warning to show dependency version conflicts+- [PR #8880](https://github.com/agda/agda/issues/8880): Fix #8858 as suggested: don't persists DisambiguatedNames during give+- [PR #8884](https://github.com/agda/agda/issues/8884): Fix #8881 by strengthening simplifyLevelConstraint+- [PR #8890](https://github.com/agda/agda/issues/8890): Fix #8888: constructor patterns keep the modality of the constructor+- [PR #8907](https://github.com/agda/agda/issues/8907): Fix #8898 by remove termination blunder in decodeFloat
@@ -1,7 +1,35 @@-Copyright (c) 2005-2011 Ulf Norell, Nils Anders Danielsson, Catarina-Coquand, Makoto Takeyama, Andreas Abel, Karl Mehltretter, Marcin-Benke, Darin Morrison.+Copyright (c) 2005-2026 remains with the authors.+Agda 2 was originally written by Ulf Norell,+partially based on code from Agda 1 by Catarina Coquand and Makoto Takeyama,+and from Agdalight by Ulf Norell and Andreas Abel.+Cubical Agda was originally contributed by Andrea Vezzosi. +Agda 2 is currently actively developed mainly by Andreas Abel,+Nathaniel Burke, Lawrence Chonavel, Jesper Cockx,+Nils Anders Danielsson, and András Kovács.++Further, Agda 2 has received contributions by, amongst others,+Arthur Adjedj, Guillaume Allais, Malin Altenmüller, Stevan Andjelkovic,+Marcin Benke, Jean-Philippe Bernardy, Guillaume Brunerie,+James Chapman, Liang-Ting Chen, Joris Ceulemans, Jonathan Coates,+Matthew Daggitt, Dominique Devriese, Marko Dimjašević, Péter Diviánszky,+Lucas Escot, Robert Estelle,+Naïm Camille Favier, Kuen-Bang Hou (Favonia), Olle Fredriksson,+Paolo G. Giarrusso, Adam Gundry, Daniel Gustafsson,+Philipp Hausmann, Alex Haršáni,+Patrik Jansson, Alan Jeffrey, Phil de Joux,+Wolfram Kahl, Philip Kaludercic, Andre Knispel, Wen Kokke,+John Leo, Amélia Liao, Ziyang Liu, Fredrik Lindblad, Víctor López Juan, Ting-Gan Lua,+Francesco Mazzoli, Stefan Monnier, Guilhem Moulin, Reed Mullanix,+Konstantin Nisht, Fredrik Nordvall Forsberg, Ulf Norell, Andreas Nuyts,+Herminie Pagel, Josselin Poiret, Nicolas Pouillard, Jonathan Prieto,+Christian Sattler, Artem Shinkarov, Michael Shulman, Andrés Sicard-Ramírez, Nate Soares,+Makoto Takeyama, Andrea Vezzosi, Szumi Xie, Nobuo Yamashita,+Noam Zeilberger, and Tesla Ice Zhang.+The full list of contributors is available at+https://github.com/agda/agda/graphs/contributors or from the git+repository via ``git shortlog -sne``.+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including@@ -20,35 +48,3 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.------------------------------------------------------------------------------------The file src/full/Agda/Utils/ReadP.hs is Copyright (c) The University of-Glasgow 2002 and is licensed under a BSD-like license as follows:--Redistribution and use in source and binary forms, with or without-modification, are permitted provided that the following conditions are met:--- Redistributions of source code must retain the above copyright notice,-this list of conditions and the following disclaimer.--- Redistributions in binary form must reproduce the above copyright notice,-this list of conditions and the following disclaimer in the documentation-and/or other materials provided with the distribution.--- Neither name of the University nor the names of its contributors may be-used to endorse or promote products derived from this software without-specific prior written permission.--THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF-GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE-UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH-DAMAGE.
@@ -1,299 +0,0 @@-========================================================================-Agda 2-========================================================================--Table of contents:--* Installing Agda-* Configuring the Emacs mode-* Prerequisites-* Installing the Epic backend's dependencies-* Installing a suitable version of Emacs under Windows---------------------------------------------------------------------------Installing Agda--------------------------------------------------------------------------- Note that this README only discusses installation of Agda, not its- standard library. See the Agda Wiki for information about the- library.--There are several ways to install Agda:--* Using a binary package, prepared for your platform.-- Recommended if such a package exists. See the Agda Wiki.--* Using a released source package, available from Hackage.-- (Note that if you want to install the development version of Agda,- then you should use the next method.)-- Install the prerequisites mentioned below, then run the following- commands:-- cabal update- cabal install Agda-executable- agda-mode setup-- The last command tries to set up Emacs for use with Agda. As an- alternative you can copy the following text to your .emacs file:-- (load-file (let ((coding-system-for-read 'utf-8))- (shell-command-to-string "agda-mode locate")))--* Using the source tar balls available from the Agda Wiki, or the- development version of the code available from our darcs repository.-- 1) Install the prerequisites mentioned below.-- 2a) Run the following commands in the top-level directory of the- Agda source tree:-- cabal update- cabal install- agda-mode setup- cd src/main- cabal install-- The third command tries to set up Emacs for use with Agda. As an- alternative you can copy the following text to your .emacs file:-- (load-file (let ((coding-system-for-read 'utf-8))- (shell-command-to-string "agda-mode locate")))-- If you want to have more control over where files are installed- then you can give various flags to cabal install, see- cabal install --help.-- 2b) Instead of following 2a you can try to install Agda (including- batch-mode tool and Emacs mode) by running the following- command:-- make install---------------------------------------------------------------------------Configuring the Emacs mode---------------------------------------------------------------------------If you want to you can customise the Emacs mode. Just start Emacs and-type the following:-- M-x load-library RET agda2-mode RET- M-x customize-group RET agda2 RET--This is useful if you want to change the Agda search path, in which-case you should change the agda2-include-dirs variable.--If you want some specific settings for the Emacs mode you can add them-to agda2-mode-hook. For instance, if you do not want to use the Agda-input method (for writing various symbols like ∀≥ℕ→π⟦⟧) you can add-the following to your .emacs:--(add-hook 'agda2-mode-hook- '(lambda ()- ; If you do not want to use any input method:- (inactivate-input-method)- ; If you want to use the X input method:- (set-input-method "X")- ))--Note that, on some systems, the Emacs mode changes the default font of-the current frame in order to enable many Unicode symbols to be-displayed. This only works if the right fonts are available, though.-If you want to turn off this feature, then you should customise the-agda2-fontset-name variable.---------------------------------------------------------------------------Prerequisites---------------------------------------------------------------------------You need recent versions of the following programs/libraries:-- GHC: http://www.haskell.org/ghc/- cabal-install: http://www.haskell.org/cabal/- Alex: http://www.haskell.org/alex/- Happy: http://www.haskell.org/happy/- GNU Emacs: http://www.gnu.org/software/emacs/- haskell-mode: http://projects.haskell.org/haskellmode-emacs/--You should also make sure that programs installed by cabal-install are-on your shell's search path.--For instructions on installing a suitable version of Emacs under-Windows, see below.--Non-Windows users need to ensure that the development files for the C-libraries zlib and ncurses are installed (see http://zlib.net and-http://www.gnu.org/software/ncurses/). Your package manager may be-able to install these files for you. For instance, on Debian or Ubuntu-it should suffice to run-- apt-get install zlib1g-dev libncurses5-dev--as root to get the correct files installed.---------------------------------------------------------------------------Installing the Epic backend's dependencies---------------------------------------------------------------------------The Epic backend is experimental and requires that the Epic program is-installed. You can install this program by giving the epic flag to-cabal:--* When installing from Hackage:-- cabal update- cabal install Agda -fepic- cabal install Agda-executable- agda-mode setup--* When installing using a source tar ball, following the instructions- in 2a) above:-- cabal update- cabal install -fepic- agda-mode setup- cd src/main- cabal install--* When installing using a source tar ball, following the instructions- in 2b) above:-- make CABAL_OPTIONS=-fepic install--You can also install Epic directly:-- cabal install epic--Note that Epic depends on other software:-- The Boehm garbage collector:- http://www.hpl.hp.com/personal/Hans_Boehm/gc/- The GNU Multiple Precision Arithmetic Library:- http://gmplib.org/- GCC, the GNU Compiler Collection:- http://gcc.gnu.org/--For more information about Epic:-- http://www.cs.st-andrews.ac.uk/~eb/epic.php---------------------------------------------------------------------------Installing a suitable version of Emacs under Windows---------------------------------------------------------------------------Note that Agda code often uses mathematical and other symbols-available from the Unicode character set. In order to be able to-display these characters you may want to follow the procedure below-when installing Emacs under Windows.--1. Install NTEmacs 22.-- Download from- http://ntemacs.sourceforge.net/- the self-extracting executable- ntemacs22-bin-20070819.exe-- When executed, it asks where to extract itself. This can be- anywhere you like, but here we write the top directory for ntemacs as- c:/pkg/ntemacs- in the following.-- What follows is tested only on this version. Other versions may- work but you have to figure out yourself how to use Unicode fonts- on your version.--2. Install ucs-fonts and mule-fonts for emacs.-- Download from- http://www.cl.cam.ac.uk/~mgk25/ucs-fonts.html- the tar file- http://www.cl.cam.ac.uk/~mgk25/download/ucs-fonts.tar.gz- Let us write the top directory of extracted files as- c:/pkg/ucs-fonts- Next we create some derived fonts.- cd c:/pkg/ucs-fonts/submission- make all-bdfs- This gives an error message about missing fonts, but ignore it.-- Download from- http://www.meadowy.org/- the tar file- http://www.meadowy.org/meadow/dists/3.00/packages/mule-fonts-1.0-4-pkg.tar.bz2- The untarred top directory is named "packages", but we are only- interested in the subdirectory "packages/fonts". Let us assume- we moved this subdirectory to- c:/pkg/mule-fonts-- Add the following to your .emacs--;;;;;;;;; start of quoted elisp code--(setq bdf-directory-list- '(- "c:/pkg/ucs-fonts/submission"- "c:/pkg/mule-fonts/intlfonts"- "c:/pkg/mule-fonts/efonts"- "c:/pkg/mule-fonts/bitmap"- "c:/pkg/mule-fonts/CDAC"- "c:/pkg/mule-fonts/AkrutiFreeFonts"- ))--(setq w32-bdf-filename-alist- (w32-find-bdf-fonts bdf-directory-list))--(create-fontset-from-fontset-spec- "-*-fixed-Medium-r-Normal-*-15-*-*-*-c-*-fontset-bdf,- ascii:-Misc-Fixed-Medium-R-Normal--15-140-75-75-C-90-ISO8859-1,- latin-iso8859-2:-*-Fixed-*-r-*-*-15-*-*-*-c-*-iso8859-2,- latin-iso8859-3:-*-Fixed-*-r-*-*-15-*-*-*-c-*-iso8859-3,- latin-iso8859-4:-*-Fixed-*-r-*-*-15-*-*-*-c-*-iso8859-4,- cyrillic-iso8859-5:-*-Fixed-*-r-*-*-15-*-*-*-c-*-iso8859-5,- greek-iso8859-7:-*-Fixed-*-r-*-*-15-*-*-*-c-*-iso8859-7,- latin-iso8859-9:-*-Fixed-*-r-*-*-15-*-*-*-c-*-iso8859-9,- mule-unicode-0100-24ff:-Misc-Fixed-Medium-R-Normal--15-140-75-75-C-90-ISO10646-1,- mule-unicode-2500-33ff:-Misc-Fixed-Medium-R-Normal--15-140-75-75-C-90-ISO10646-1,- mule-unicode-e000-ffff:-Misc-Fixed-Medium-R-Normal--15-140-75-75-C-90-ISO10646-1,- japanese-jisx0208:-JIS-Fixed-Medium-R-Normal--16-150-75-75-C-160-JISX0208.1983-0,- japanese-jisx0208-1978:-Misc-Fixed-Medium-R-Normal--16-150-75-75-C-160-JISC6226.1978-0,- japanese-jisx0212:-Misc-Fixed-Medium-R-Normal--16-150-75-75-C-160-JISX0212.1990-0,- latin-jisx0201:-*-*-medium-r-normal-*-16-*-*-*-c-*-jisx0201*-*,- katakana-jisx0201:-Sony-Fixed-Medium-R-Normal--16-120-100-100-C-80-JISX0201.1976-0,- thai-tis620:-Misc-Fixed-Medium-R-Normal--24-240-72-72-C-120-TIS620.2529-1,- lao:-Misc-Fixed-Medium-R-Normal--24-240-72-72-C-120-MuleLao-1,- tibetan:-TibMdXA-fixed-medium-r-normal--16-160-72-72-m-160-MuleTibetan-0,- tibetan-1-column:-TibMdXA-fixed-medium-r-normal--16-160-72-72-m-80-MuleTibetan-1,- korean-ksc5601:-Daewoo-Mincho-Medium-R-Normal--16-120-100-100-C-160-KSC5601.1987-0,- chinese-gb2312:-ISAS-Fangsong ti-Medium-R-Normal--16-160-72-72-c-160-GB2312.1980-0,- chinese-cns11643-1:-HKU-Fixed-Medium-R-Normal--16-160-72-72-C-160-CNS11643.1992.1-0,- chinese-big5-1:-ETen-Fixed-Medium-R-Normal--16-150-75-75-C-160-Big5.ETen-0,- chinese-big5-2:-ETen-Fixed-Medium-R-Normal--16-150-75-75-C-160-Big5.ETen-0- " t)--(setq font-encoding-alist- (append '(- ("JISX0208" (japanese-jisx0208 . 0))- ("JISX0212" (japanese-jisx0212 . 0))- ("CNS11643.1992.1-0" (chinese-cns11643-1 . 0))- ("GB2312" (chinese-gb2312 . 0))- ("KSC5601" (korean-ksc5601 . 0))- ("VISCII" (vietnamese-viscii-lower . 0))- ("MuleArabic-0" (arabic-digit . 0))- ("MuleArabic-1" (arabic-1-column . 0))- ("MuleArabic-2" (arabic-2-column . 0))- ("muleindian-1" (indian-1-column . 0))- ("muleindian-2" (indian-2-column . 0))- ("MuleTibetan-0" (tibetan . 0))- ("MuleTibetan-1" (tibetan-1-column . 0))- ) font-encoding-alist))--;;;;;;; end of quoted elisp code-- To test the fonts, try-- M-x eval-expression RET- (set-default-font "fontset-bdf") RET- M-x view-hello-file-- You should see all the characters without white-boxes.
@@ -0,0 +1,37 @@+Agda 2+======++[](http://hackage.haskell.org/package/Agda)+[](https://www.stackage.org/package/Agda)+[](https://github.com/agda/agda/actions/workflows/test.yml)+[](http://agda.readthedocs.io/en/latest/?badge=latest)+[](https://agda.zulipchat.com)++++Note that this README is only about Agda, not its standard+library. See the [Agda Wiki][agdawiki] for information about the+library.++Documentation+-------------++* [User manual](http://agda.readthedocs.io)+ (per-commit pdf can be downloaded from the+ [github actions](https://github.com/agda/agda/actions/workflows/user_manual.yml) page)+* [CHANGELOG](https://github.com/agda/agda/blob/master/CHANGELOG.md)++Getting Started+----------------++* [Installation](https://agda.readthedocs.io/en/latest/getting-started/installation.html)+* [Quick guide to editing, type checking and compiling Agda+ code](https://agda.readthedocs.io/en/latest/getting-started/a-taste-of-agda.html)++Contributing to Agda+--------------------++* [Contributing to Agda](https://github.com/agda/agda/blob/master/CONTRIBUTING.md)+* [Haskell style-guide](https://github.com/andreasabel/haskell-style-guide/blob/master/haskell-style.md)++[agdawiki]: http://wiki.portal.chalmers.se/agda/pmwiki.php
@@ -1,12 +0,0 @@-import Distribution.Simple--main = defaultMain---- The following comment may be relevant for agda-pkg:------ Although this looks like the Simple build type, it is in fact vital that--- we use this Setup.hs because it'll get compiled against the local copy--- of the Cabal lib, thus enabling Cabal to bootstrap itself without relying--- on any previous installation. This also means we can use any new features--- immediately because we never have to worry about building Cabal with an--- older version of itself.
@@ -1,434 +0,0 @@-{-# LANGUAGE CPP,MagicHash #-}-{-# LINE 1 "src/full/Agda/Syntax/Parser/Lexer.x" #-}--{-# OPTIONS_GHC -fno-warn-deprecated-flags #-}-{-# LANGUAGE BangPatterns #-}-{-| The lexer is generated by Alex (<http://www.haskell.org/alex>) and is an- adaptation of GHC's lexer. The main lexing function 'lexer' is called by- the "Agda.Syntax.Parser.Parser" to get the next token from the input.--}-module Agda.Syntax.Parser.Lexer- ( -- * The main function- lexer- -- * Lex states- , normal, literate, code- , layout, empty_layout, bol, imp_dir- -- * Alex generated functions- , AlexReturn(..), alexScanUser- ) where--import Data.List--import Agda.Syntax.Parser.Alex-import Agda.Syntax.Parser.Comments-#ifndef __HADDOCK__-import {-# SOURCE #-} Agda.Syntax.Parser.Layout-import {-# SOURCE #-} Agda.Syntax.Parser.LexActions-#endif-import Agda.Syntax.Parser.Monad-import Agda.Syntax.Parser.StringLiterals-import Agda.Syntax.Parser.Tokens-import Agda.Syntax.Literal---#if __GLASGOW_HASKELL__ >= 603-#include "ghcconfig.h"-#elif defined(__GLASGOW_HASKELL__)-#include "config.h"-#endif-#if __GLASGOW_HASKELL__ >= 503-import Data.Array-import Data.Char (ord)-import Data.Array.Base (unsafeAt)-#else-import Array-import Char (ord)-#endif-#if __GLASGOW_HASKELL__ >= 503-import GHC.Exts-#else-import GlaExts-#endif-alex_base :: AlexAddr-alex_base = AlexA# "\xf7\xff\xff\xff\x6c\x00\x00\x00\xc8\x00\x00\x00\x3c\x01\x00\x00\x40\x01\x00\x00\x44\x01\x00\x00\x4b\x01\x00\x00\x41\x02\x00\x00\x88\xff\xff\xff\xd9\xff\xff\xff\xda\xff\xff\xff\x99\xff\xff\xff\x20\x03\x00\x00\x5e\x00\x00\x00\x7c\x03\x00\x00\x7b\x03\x00\x00\xfb\x03\x00\x00\xa4\xff\xff\xff\x7b\x04\x00\x00\xfb\x04\x00\x00\x7b\x05\x00\x00\xfb\x05\x00\x00\x7b\x06\x00\x00\xfb\x06\x00\x00\x9b\xff\xff\xff\xa8\xff\xff\xff\x91\xff\xff\xff\xa9\xff\xff\xff\x9f\xff\xff\xff\xab\xff\xff\xff\x00\x00\x00\x00\x6c\x07\x00\x00\x00\x00\x00\x00\xdd\x07\x00\x00\xac\xff\xff\xff\x00\x00\x00\x00\x4e\x08\x00\x00\x00\x00\x00\x00\xbf\x08\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x41\x09\x00\x00\x00\x00\x00\x00\x82\x09\x00\x00\x00\x00\x00\x00\xc3\x09\x00\x00\xa2\x0a\x00\x00\x21\x0b\x00\x00\xe1\x0a\x00\x00\x00\x00\x00\x00\xe1\x0b\x00\x00\xa1\x0b\x00\x00\x00\x00\x00\x00\xa1\x0c\x00\x00\x61\x0c\x00\x00\x00\x00\x00\x00\x61\x0d\x00\x00\x07\x00\x00\x00\xd7\x0d\x00\x00\x39\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x0e\x00\x00\xc3\x0f\x00\x00\xb9\x10\x00\x00\xaf\x11\x00\x00\xa5\x12\x00\x00\x9b\x13\x00\x00\x91\x14\x00\x00\x87\x15\x00\x00\x7d\x16\x00\x00\x73\x17\x00\x00\x69\x18\x00\x00\x5f\x19\x00\x00\x55\x1a\x00\x00\x4b\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x1c\x00\x00\x39\x1d\x00\x00\x30\x1e\x00\x00\x27\x1f\x00\x00\x1e\x20\x00\x00\x15\x21\x00\x00\x0c\x22\x00\x00\x03\x23\x00\x00\xfa\x23\x00\x00\xf1\x24\x00\x00\xe8\x25\x00\x00\xdf\x26\x00\x00\xd6\x27\x00\x00\xcd\x28\x00\x00\xc4\x29\x00\x00\xbb\x2a\x00\x00\xb2\x2b\x00\x00\xa9\x2c\x00\x00\xa0\x2d\x00\x00\x97\x2e\x00\x00\x8e\x2f\x00\x00\x85\x30\x00\x00\x7c\x31\x00\x00\x73\x32\x00\x00\x6a\x33\x00\x00\x61\x34\x00\x00\x58\x35\x00\x00\x4f\x36\x00\x00\x46\x37\x00\x00\x3d\x38\x00\x00\x34\x39\x00\x00\x2b\x3a\x00\x00\x22\x3b\x00\x00\x19\x3c\x00\x00\x10\x3d\x00\x00\x07\x3e\x00\x00\xfe\x3e\x00\x00\xf5\x3f\x00\x00\xec\x40\x00\x00\xe3\x41\x00\x00\xda\x42\x00\x00\xd1\x43\x00\x00\xc8\x44\x00\x00\xbf\x45\x00\x00\xb6\x46\x00\x00\xad\x47\x00\x00\xa4\x48\x00\x00\x9b\x49\x00\x00\x92\x4a\x00\x00\x89\x4b\x00\x00\x80\x4c\x00\x00\x77\x4d\x00\x00\x6e\x4e\x00\x00\x65\x4f\x00\x00\x5c\x50\x00\x00\x53\x51\x00\x00\x4a\x52\x00\x00\x41\x53\x00\x00\x38\x54\x00\x00\x2f\x55\x00\x00\x26\x56\x00\x00\x1d\x57\x00\x00\x14\x58\x00\x00\x0b\x59\x00\x00\x02\x5a\x00\x00\xf9\x5a\x00\x00\xf0\x5b\x00\x00\xe7\x5c\x00\x00\xde\x5d\x00\x00\xef\xff\xff\xff\x00\x00\x00\x00\xd4\x5e\x00\x00\xd4\x5f\x00\x00\xca\x60\x00\x00\xca\x61\x00\x00\xca\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x0e\x00\x00\xad\x0f\x00\x00\xa3\x10\x00\x00\x99\x11\x00\x00\x85\x13\x00\x00\x7b\x14\x00\x00\x71\x15\x00\x00\x67\x16\x00\x00\x5d\x17\x00\x00\x3f\x1a\x00\x00\x39\x1c\x00\x00\x30\x1d\x00\x00\x27\x1e\x00\x00\x1e\x1f\x00\x00\x15\x20\x00\x00\x0c\x21\x00\x00\xfa\x22\x00\x00\xf1\x23\x00\x00\xe8\x24\x00\x00\xdf\x25\x00\x00\xd6\x26\x00\x00\xcd\x27\x00\x00\xc4\x28\x00\x00\xc5\x29\x00\x00\xb2\x2a\x00\x00\xaa\x2c\x00\x00\x74\x32\x00\x00\x23\x3b\x00\x00\xed\x40\x00\x00\x9b\x48\x00\x00\xbe\x5e\x00\x00\xa9\x63\x00\x00\x05\x64\x00\x00\x61\x64\x00\x00\xbd\x64\x00\x00\x00\x00\x00\x00\x19\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\xff\xff\xff\xe6\xff\xff\xff\x00\x00\x00\x00\x75\x65\x00\x00\xd1\x65\x00\x00\x53\x34\x00\x00\x2d\x66\x00\x00\x89\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x66\x00\x00\x33\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x67\x00\x00\x9d\x67\x00\x00\xf9\x67\x00\x00\x55\x68\x00\x00\xb1\x68\x00\x00\x0d\x69\x00\x00\x69\x69\x00\x00\xc5\x69\x00\x00\x21\x6a\x00\x00\x7d\x6a\x00\x00\xd9\x6a\x00\x00\x35\x6b\x00\x00\x91\x6b\x00\x00\xed\x6b\x00\x00\x49\x6c\x00\x00\xa5\x6c\x00\x00\x01\x6d\x00\x00\x5d\x6d\x00\x00\xb9\x6d\x00\x00\x15\x6e\x00\x00\x71\x6e\x00\x00\xcd\x6e\x00\x00\x29\x6f\x00\x00\x85\x6f\x00\x00\xe1\x6f\x00\x00\x3d\x70\x00\x00\x99\x70\x00\x00\xf5\x70\x00\x00\x51\x71\x00\x00\xad\x71\x00\x00\x09\x72\x00\x00\x65\x72\x00\x00\xc1\x72\x00\x00\x1d\x73\x00\x00\x79\x73\x00\x00\xd5\x73\x00\x00\x31\x74\x00\x00\x8d\x74\x00\x00\xe9\x74\x00\x00\x45\x75\x00\x00\xa1\x75\x00\x00\xfd\x75\x00\x00\x59\x76\x00\x00\xb5\x76\x00\x00\x11\x77\x00\x00\x6d\x77\x00\x00\xc9\x77\x00\x00\x25\x78\x00\x00\x81\x78\x00\x00\xdd\x78\x00\x00\x39\x79\x00\x00\x95\x79\x00\x00\xf1\x79\x00\x00\x4d\x7a\x00\x00\xa9\x7a\x00\x00\x05\x7b\x00\x00\x61\x7b\x00\x00\xbd\x7b\x00\x00\x19\x7c\x00\x00\x75\x7c\x00\x00\xd1\x7c\x00\x00\x2d\x7d\x00\x00\x89\x7d\x00\x00\xe5\x7d\x00\x00\x41\x7e\x00\x00\x9d\x7e\x00\x00\xf9\x7e\x00\x00\x55\x7f\x00\x00\xb1\x7f\x00\x00\x0d\x80\x00\x00\x69\x80\x00\x00\xc5\x80\x00\x00\x21\x81\x00\x00\x7d\x81\x00\x00\xd9\x81\x00\x00\x35\x82\x00\x00\x91\x82\x00\x00\xed\x82\x00\x00\x49\x83\x00\x00\xa5\x83\x00\x00\x01\x84\x00\x00\x5d\x84\x00\x00\xb9\x84\x00\x00\x15\x85\x00\x00\x71\x85\x00\x00\xcd\x85\x00\x00\x29\x86\x00\x00\x85\x86\x00\x00\xe1\x86\x00\x00\x3d\x87\x00\x00\x99\x87\x00\x00\xf5\x87\x00\x00\x51\x88\x00\x00\xad\x88\x00\x00\x09\x89\x00\x00\x65\x89\x00\x00\xc1\x89\x00\x00\x1d\x8a\x00\x00\x79\x8a\x00\x00\xd5\x8a\x00\x00\x31\x8b\x00\x00\x8d\x8b\x00\x00\xe9\x8b\x00\x00\x45\x8c\x00\x00\xa1\x8c\x00\x00\xfd\x8c\x00\x00\x59\x8d\x00\x00\xb5\x8d\x00\x00\x11\x8e\x00\x00\x6d\x8e\x00\x00\xc9\x8e\x00\x00\x25\x8f\x00\x00\x81\x8f\x00\x00\xdd\x8f\x00\x00\x39\x90\x00\x00\x95\x90\x00\x00\xf1\x90\x00\x00\x4d\x91\x00\x00\xa9\x91\x00\x00\x05\x92\x00\x00\x61\x92\x00\x00\xbd\x92\x00\x00\x19\x93\x00\x00\x75\x93\x00\x00\xd1\x93\x00\x00\x2d\x94\x00\x00\x89\x94\x00\x00\xe5\x94\x00\x00\x41\x95\x00\x00\x9d\x95\x00\x00\xf9\x95\x00\x00\x55\x96\x00\x00\xb1\x96\x00\x00\x0d\x97\x00\x00\x69\x97\x00\x00\xc5\x97\x00\x00\x21\x98\x00\x00\x7d\x98\x00\x00\xd9\x98\x00\x00\x35\x99\x00\x00\x91\x99\x00\x00\xed\x99\x00\x00\x49\x9a\x00\x00\xa5\x9a\x00\x00\x01\x9b\x00\x00\x5d\x9b\x00\x00\xb9\x9b\x00\x00\x15\x9c\x00\x00\x71\x9c\x00\x00"#--alex_table :: AlexAddr-alex_table = AlexA# "\x00\x00\x9e\x00\x4f\x00\x4f\x00\x4f\x00\x4e\x00\x98\x00\x99\x00\xc4\x00\x08\x00\x22\x00\x18\x00\x19\x00\x1d\x00\x1c\x00\x1a\x00\x11\x00\x3e\x00\x51\x00\xc7\x00\xc8\x00\x00\x00\x00\x00\x4f\x00\x2e\x01\xd9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xd8\x00\xd0\x00\xd1\x00\x2e\x01\x2e\x01\x2e\x01\xe7\x00\xc9\x00\x2e\x01\xde\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xcb\x00\xca\x00\x2e\x01\xcc\x00\x2e\x01\xce\x00\xd4\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x43\x01\x2e\x01\x2e\x01\xfd\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xd3\x00\x2e\x01\x2e\x01\xcd\x00\x2e\x01\x2f\x01\x2e\x01\x22\x01\x0a\x01\x2e\x01\x18\x01\x2e\x01\x28\x01\x6d\x01\x2e\x01\x2e\x01\xf7\x00\x21\x01\x2e\x01\x45\x01\x2a\x01\x1b\x01\x23\x01\x27\x01\x2e\x01\x1d\x01\x2e\x01\x04\x01\x2e\x01\x2e\x01\x2e\x01\xd6\x00\xcf\x00\xd7\x00\x2e\x01\x9f\x00\x4f\x00\x4f\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4f\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0a\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4f\x00\x4f\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x4f\x00\x4f\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x4f\x00\x2e\x01\xd9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xd8\x00\xd0\x00\xd1\x00\x2e\x01\x2e\x01\x2e\x01\xe7\x00\xc9\x00\x2e\x01\xde\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xcb\x00\xca\x00\x2e\x01\xcc\x00\x2e\x01\xce\x00\xd4\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x43\x01\x2e\x01\x2e\x01\xfd\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xd3\x00\x2e\x01\x2e\x01\xcd\x00\x2e\x01\x2f\x01\x2e\x01\x22\x01\x0a\x01\x2e\x01\x18\x01\x2e\x01\x28\x01\x6d\x01\x2e\x01\x2e\x01\xf7\x00\x21\x01\x2e\x01\x45\x01\x2a\x01\x1b\x01\x23\x01\x27\x01\x2e\x01\x1d\x01\x2e\x01\x04\x01\x2e\x01\x2e\x01\x2e\x01\xd6\x00\xcf\x00\xd7\x00\x2e\x01\x4f\x00\x4f\x00\x4f\x00\x9e\x00\x4f\x00\x4f\x00\x4f\x00\xa0\x00\x4f\x00\x4f\x00\x4f\x00\xc6\x00\x00\x00\xff\xff\x50\x00\x50\x00\x50\x00\x50\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x97\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x50\x00\x00\x00\x0a\x00\x6c\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x00\x7f\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x49\x00\x49\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x49\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0d\x00\x2e\x01\x2e\x01\x0c\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x39\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x30\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x0f\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x13\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\xe5\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0d\x00\x2e\x01\x2e\x01\x0c\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3c\x00\x0f\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2e\x00\x14\x00\x25\x00\x25\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3f\x00\x3f\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x3f\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xfa\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x40\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x45\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x46\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x49\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x38\x00\x37\x00\x10\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2b\x00\x2c\x00\x15\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb2\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xbb\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x2e\x01\x52\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x56\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x60\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x60\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x92\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x88\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x11\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x13\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xff\xff\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x29\x00\x2a\x00\x16\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x31\x00\x13\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x17\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\xff\xff\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x99\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x99\x00\x00\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x31\x00\x13\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x17\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x00\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x9d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x31\x00\x13\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x17\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\xff\xff\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x99\x00\x00\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x31\x00\x13\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x17\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\xff\xff\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x99\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x99\x00\x00\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x31\x00\x13\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x17\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x5c\x01\x2e\x01\x5c\x01\x2f\x00\x2e\x01\xdc\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2f\x00\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2f\x00\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x59\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2f\x00\x2e\x01\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2f\x00\x2e\x01\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5d\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x5c\x01\x2e\x01\x5c\x01\x0e\x00\x2e\x01\xe2\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xdf\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xdf\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xdf\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xdf\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xdf\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xdf\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x59\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\xe3\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5a\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x59\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x9d\x00\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\xd2\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa3\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa6\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa7\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa8\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xab\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xac\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xad\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb5\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xbd\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xbe\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xbf\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xc1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xc2\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xc3\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xc5\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x6e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x6a\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x67\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x66\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x65\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x64\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x63\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x62\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5f\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x5e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf6\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x58\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x57\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x02\x01\x56\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x55\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x54\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x53\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x52\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x51\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x50\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4f\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xfb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xfc\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4d\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4c\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xff\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x4a\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x49\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x48\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x47\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x46\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x03\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x37\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0c\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x29\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x40\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x44\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x12\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x14\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x26\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x15\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x17\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x3f\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x3e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x3c\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x3a\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x3b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x19\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x1a\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x38\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x1c\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x36\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x35\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x1e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2c\x01\x2e\x01\x2e\x01\x25\x01\x2e\x01\x2e\x01\x34\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x33\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x32\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x30\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x31\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x24\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x1f\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x39\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x41\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x16\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x42\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x10\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x20\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0f\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0d\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2d\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x09\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x08\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x07\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x06\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x05\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x01\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xfe\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf8\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf5\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf4\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf3\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf2\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xf0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x61\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xef\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x68\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xee\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xed\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xec\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x69\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xeb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xea\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x6b\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x6c\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe8\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\xe1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\xe0\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x5c\x01\x2e\x01\x5c\x01\x0e\x00\x2e\x01\xe6\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xe6\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\xe4\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xc0\x00\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xbc\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb8\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb7\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb6\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb4\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb3\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xb0\x00\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xaf\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xae\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xaa\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa9\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa5\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa4\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x3d\x01\xa2\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x0e\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\xa1\x00\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x2e\x01\x00\x00\x2e\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--alex_check :: AlexAddr-alex_check = AlexA# "\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x7d\x00\x2d\x00\x2d\x00\x6f\x00\x65\x00\x6f\x00\x63\x00\x7b\x00\x6e\x00\x65\x00\x64\x00\x64\x00\x0a\x00\x23\x00\x2e\x00\x2e\x00\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x2d\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x21\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x2d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x20\x00\xff\xff\x2d\x00\x23\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x65\x00\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x67\x00\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x65\x00\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\x23\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x41\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x41\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x2d\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x41\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x41\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x7d\x00\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x7d\x00\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x7d\x00\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--alex_deflt :: AlexAddr-alex_deflt = AlexA# "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x27\x00\x29\x00\x29\x00\xff\xff\x2b\x00\x2b\x00\x2d\x00\x2d\x00\x32\x00\x32\x00\x35\x00\x35\x00\x38\x00\x38\x00\x3d\x00\x3d\x00\xff\xff\x99\x00\x99\x00\x99\x00\x80\x00\x80\x00\x80\x00\x48\x00\x48\x00\x48\x00\x3e\x00\xff\xff\x3e\x00\x3e\x00\x3e\x00\xff\xff\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\x80\x00\xff\xff\xff\xff\x99\x00\x9d\x00\x99\x00\x9d\x00\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--alex_accept = listArray (0::Int,366) [[],[(AlexAccPred (alex_action_29) ( not' eof ))],[],[(AlexAcc (alex_action_32))],[],[(AlexAcc (alex_action_31))],[],[(AlexAccPred (alex_action_4) ( eof ))],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[(AlexAccSkip)],[(AlexAccPred (alex_action_0) (alexRightContext 58)),(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccSkip)],[(AlexAccPred (alex_action_5) ( inState code ))],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_8))],[(AlexAcc (alex_action_9))],[(AlexAcc (alex_action_10))],[(AlexAcc (alex_action_11))],[(AlexAcc (alex_action_12))],[(AlexAcc (alex_action_13))],[(AlexAcc (alex_action_14))],[(AlexAcc (alex_action_15))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_17))],[(AlexAcc (alex_action_18))],[(AlexAcc (alex_action_19))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_21))],[(AlexAcc (alex_action_22))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAccPred (alex_action_24) ( not' (followedBy '#') ))],[(AlexAccPred (alex_action_24) ( not' (followedBy '#') ))],[(AlexAccPred (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred ( followedBy '\n' .||. eof ))],[(AlexAccPred (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred ( followedBy '\n' .||. eof ))],[(AlexAccPred (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred ( followedBy '\n' .||. eof ))],[(AlexAccPred (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred ( followedBy '\n' .||. eof ))],[(AlexAccPred (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_27))],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_33))],[(AlexAcc (alex_action_34))],[(AlexAcc (alex_action_35))],[(AlexAcc (alex_action_36))],[(AlexAcc (alex_action_37))],[(AlexAcc (alex_action_38))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_44))],[(AlexAcc (alex_action_45))],[(AlexAcc (alex_action_46))],[(AlexAcc (alex_action_47))],[(AlexAcc (alex_action_48))],[(AlexAcc (alex_action_49))],[(AlexAcc (alex_action_50))],[(AlexAcc (alex_action_51))],[(AlexAcc (alex_action_52))],[(AlexAcc (alex_action_53))],[(AlexAcc (alex_action_54))],[(AlexAcc (alex_action_55))],[(AlexAcc (alex_action_56))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_58))],[(AlexAcc (alex_action_59))],[(AlexAcc (alex_action_60))],[(AlexAcc (alex_action_61))],[(AlexAcc (alex_action_62))],[(AlexAcc (alex_action_63))],[(AlexAcc (alex_action_64))],[(AlexAcc (alex_action_65))],[(AlexAcc (alex_action_66))],[(AlexAcc (alex_action_67))],[(AlexAcc (alex_action_68))],[(AlexAcc (alex_action_69))],[(AlexAcc (alex_action_70))],[(AlexAcc (alex_action_71))],[(AlexAcc (alex_action_72))],[(AlexAcc (alex_action_73))],[(AlexAcc (alex_action_74))],[(AlexAcc (alex_action_75))],[(AlexAcc (alex_action_76))],[(AlexAcc (alex_action_77))],[(AlexAcc (alex_action_78))],[(AlexAcc (alex_action_79))],[(AlexAcc (alex_action_80))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_82))],[(AlexAccPred (alex_action_83) (alexRightContext 59))],[(AlexAcc (alex_action_84))],[(AlexAcc (alex_action_85))],[(AlexAcc (alex_action_86))],[(AlexAcc (alex_action_87))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))]]-{-# LINE 208 "src/full/Agda/Syntax/Parser/Lexer.x" #-}----- | This is the initial state for parsing a literate file. Code blocks--- should be enclosed in @\\begin{code}@ @\\end{code}@ pairs.-literate :: LexState-literate = tex----- | This is the initial state for parsing a regular, non-literate file.-normal :: LexState-normal = 0---{-| The layout state. Entered when we see a layout keyword ('withLayout') and- exited either when seeing an open brace ('openBrace') or at the next token- ('newLayoutContext').-- Update: we don't use braces for layout anymore.--}-layout :: LexState-layout = layout_---{-| The state inside a pragma.--}-pragma :: LexState-pragma = pragma_--{-| We enter this state from 'newLayoutContext' when the token following a- layout keyword is to the left of (or at the same column as) the current- layout context. Example:-- > data Empty : Set where- > foo : Empty -> Nat-- Here the second line is not part of the @where@ clause since it is has the- same indentation as the @data@ definition. What we have to do is insert an- empty layout block @{}@ after the @where@. The only thing that can happen- in this state is that 'emptyLayout' is executed, generating the closing- brace. The open brace is generated when entering by 'newLayoutContext'.--}-empty_layout :: LexState-empty_layout = empty_layout_----- | This state is entered at the beginning of each line. You can't lex--- anything in this state, and to exit you have to check the layout rule.--- Done with 'offsideRule'.-bol :: LexState-bol = bol_----- | This state can only be entered by the parser. In this state you can only--- lex the keywords @using@, @hiding@, @renaming@ and @to@. Moreover they are--- only keywords in this particular state. The lexer will never enter this--- state by itself, that has to be done in the parser.-imp_dir :: LexState-imp_dir = imp_dir_----- | Return the next token. This is the function used by Happy in the parser.------ @lexer k = 'lexToken' >>= k@-lexer :: (Token -> Parser a) -> Parser a-lexer k = lexToken >>= k---- | Do not use this function; it sets the 'ParseFlags' to--- 'undefined'.-alexScan :: AlexInput -> Int -> AlexReturn (LexAction Token)---- | This is the main lexing function generated by Alex.-alexScanUser :: ([LexState], ParseFlags) -> AlexInput -> Int -> AlexReturn (LexAction Token)----bol_,code,empty_layout_,imp_dir_,layout_,pragma_,tex :: Int-bol_ = 1-code = 2-empty_layout_ = 3-imp_dir_ = 4-layout_ = 5-pragma_ = 6-tex = 7-alex_action_0 = end_ -alex_action_1 = withInterval TokTeX -alex_action_4 = end_ -alex_action_5 = begin_ tex -alex_action_8 = begin pragma -alex_action_9 = symbol SymOpenPragma -alex_action_10 = endWith $ symbol SymClosePragma -alex_action_11 = keyword KwOPTIONS -alex_action_12 = keyword KwBUILTIN -alex_action_13 = keyword KwCOMPILED_DATA -alex_action_14 = keyword KwCOMPILED_TYPE -alex_action_15 = keyword KwCOMPILED -alex_action_16 = keyword KwCOMPILED_EPIC -alex_action_17 = keyword KwCOMPILED_JS -alex_action_18 = keyword KwSTATIC -alex_action_19 = keyword KwIMPORT -alex_action_20 = keyword KwIMPOSSIBLE -alex_action_21 = keyword KwETA -alex_action_22 = keyword KwLINE -alex_action_23 = withInterval $ TokString -alex_action_24 = nestedComment -alex_action_25 = withInterval TokComment -alex_action_27 = begin bol_ -alex_action_29 = offsideRule -alex_action_31 = endWith newLayoutContext -alex_action_32 = emptyLayout -alex_action_33 = keyword KwLet -alex_action_34 = keyword KwIn -alex_action_35 = keyword KwWhere -alex_action_36 = keyword KwField -alex_action_37 = keyword KwWith -alex_action_38 = keyword KwRewrite -alex_action_39 = keyword KwPostulate -alex_action_40 = keyword KwPrimitive -alex_action_41 = keyword KwOpen -alex_action_42 = keyword KwImport -alex_action_43 = keyword KwModule -alex_action_44 = keyword KwData -alex_action_45 = keyword KwCoData -alex_action_46 = keyword KwRecord -alex_action_47 = keyword KwConstructor -alex_action_48 = keyword KwInfix -alex_action_49 = keyword KwInfixL -alex_action_50 = keyword KwInfixR -alex_action_51 = keyword KwMutual -alex_action_52 = keyword KwAbstract -alex_action_53 = keyword KwPrivate -alex_action_54 = keyword KwSet -alex_action_55 = keyword KwProp -alex_action_56 = keyword KwForall -alex_action_57 = withInterval' (read . drop 3) TokSetN -alex_action_58 = keyword KwQuoteGoal -alex_action_59 = keyword KwQuote -alex_action_60 = keyword KwQuoteTerm -alex_action_61 = keyword KwUnquote -alex_action_62 = keyword KwSyntax -alex_action_63 = keyword KwUsing -alex_action_64 = keyword KwHiding -alex_action_65 = keyword KwRenaming -alex_action_66 = endWith $ keyword KwTo -alex_action_67 = keyword KwPublic -alex_action_68 = hole -alex_action_69 = symbol SymEllipsis -alex_action_70 = symbol SymDotDot -alex_action_71 = symbol SymDot -alex_action_72 = symbol SymSemi -alex_action_73 = symbol SymColon -alex_action_74 = symbol SymEqual -alex_action_75 = symbol SymUnderscore -alex_action_76 = symbol SymQuestionMark -alex_action_77 = symbol SymBar -alex_action_78 = symbol SymOpenParen -alex_action_79 = symbol SymCloseParen -alex_action_80 = symbol SymArrow -alex_action_81 = symbol SymLambda -alex_action_82 = symbol SymAs -alex_action_83 = symbol SymDoubleOpenBrace -alex_action_84 = symbol SymOpenBrace -alex_action_85 = symbol SymCloseBrace -alex_action_86 = litChar -alex_action_87 = litString -alex_action_88 = literal LitInt -alex_action_89 = literal LitFloat -alex_action_90 = identifier -{-# LINE 1 "templates/GenericTemplate.hs" #-}-{-# LINE 1 "templates/GenericTemplate.hs" #-}-{-# LINE 1 "<built-in>" #-}-{-# LINE 1 "<command-line>" #-}-{-# LINE 1 "templates/GenericTemplate.hs" #-}--- -------------------------------------------------------------------------------- ALEX TEMPLATE------ This code is in the PUBLIC DOMAIN; you may copy it freely and use--- it for any purpose whatsoever.---- -------------------------------------------------------------------------------- INTERNALS and main scanner engine--{-# LINE 37 "templates/GenericTemplate.hs" #-}--{-# LINE 47 "templates/GenericTemplate.hs" #-}---data AlexAddr = AlexA# Addr#--#if __GLASGOW_HASKELL__ < 503-uncheckedShiftL# = shiftL#-#endif--{-# INLINE alexIndexInt16OffAddr #-}-alexIndexInt16OffAddr (AlexA# arr) off =-#ifdef WORDS_BIGENDIAN- narrow16Int# i- where- i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)- high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))- low = int2Word# (ord# (indexCharOffAddr# arr off'))- off' = off *# 2#-#else- indexInt16OffAddr# arr off-#endif------{-# INLINE alexIndexInt32OffAddr #-}-alexIndexInt32OffAddr (AlexA# arr) off = -#ifdef WORDS_BIGENDIAN- narrow32Int# i- where- !i = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`- (b2 `uncheckedShiftL#` 16#) `or#`- (b1 `uncheckedShiftL#` 8#) `or#` b0)- !b3 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))- !b2 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))- !b1 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))- !b0 = int2Word# (ord# (indexCharOffAddr# arr off'))- !off' = off *# 4#-#else- indexInt32OffAddr# arr off-#endif------#if __GLASGOW_HASKELL__ < 503-quickIndex arr i = arr ! i-#else--- GHC >= 503, unsafeAt is available from Data.Array.Base.-quickIndex = unsafeAt-#endif------- -------------------------------------------------------------------------------- Main lexing routines--data AlexReturn a- = AlexEOF- | AlexError !AlexInput- | AlexSkip !AlexInput !Int- | AlexToken !AlexInput !Int a---- alexScan :: AlexInput -> StartCode -> AlexReturn a-alexScan input (I# (sc))- = alexScanUser undefined input (I# (sc))--alexScanUser user input (I# (sc))- = case alex_scan_tkn user input 0# input sc AlexNone of- (AlexNone, input') ->- case alexGetByte input of- Nothing -> ---- AlexEOF- Just _ ->---- AlexError input'-- (AlexLastSkip input'' len, _) ->---- AlexSkip input'' len-- (AlexLastAcc k input''' len, _) ->---- AlexToken input''' len k----- Push the input through the DFA, remembering the most recent accepting--- state it encountered.--alex_scan_tkn user orig_input len input s last_acc =- input `seq` -- strict in the input- let - new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))- in- new_acc `seq`- case alexGetByte input of- Nothing -> (new_acc, input)- Just (c, new_input) -> ---- let- (base) = alexIndexInt32OffAddr alex_base s- ((I# (ord_c))) = fromIntegral c- (offset) = (base +# ord_c)- (check) = alexIndexInt16OffAddr alex_check offset- - (new_s) = if (offset >=# 0#) && (check ==# ord_c)- then alexIndexInt16OffAddr alex_table offset- else alexIndexInt16OffAddr alex_deflt s- in- case new_s of - -1# -> (new_acc, input)- -- on an error, we want to keep the input *before* the- -- character that failed, not after.- _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)- -- note that the length is increased ONLY if this is the 1st byte in a char encoding)- new_input new_s new_acc-- where- check_accs [] = last_acc- check_accs (AlexAcc a : _) = AlexLastAcc a input (I# (len))- check_accs (AlexAccSkip : _) = AlexLastSkip input (I# (len))- check_accs (AlexAccPred a predx : rest)- | predx user orig_input (I# (len)) input- = AlexLastAcc a input (I# (len))- check_accs (AlexAccSkipPred predx : rest)- | predx user orig_input (I# (len)) input- = AlexLastSkip input (I# (len))- check_accs (_ : rest) = check_accs rest--data AlexLastAcc a- = AlexNone- | AlexLastAcc a !AlexInput !Int- | AlexLastSkip !AlexInput !Int--instance Functor AlexLastAcc where- fmap f AlexNone = AlexNone- fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z- fmap f (AlexLastSkip x y) = AlexLastSkip x y--data AlexAcc a user- = AlexAcc a- | AlexAccSkip- | AlexAccPred a (AlexAccPred user)- | AlexAccSkipPred (AlexAccPred user)--type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool---- -------------------------------------------------------------------------------- Predicates on a rule--alexAndPred p1 p2 user in1 len in2- = p1 user in1 len in2 && p2 user in1 len in2----alexPrevCharIsPred :: Char -> AlexAccPred _ -alexPrevCharIs c _ input _ _ = c == alexInputPrevChar input--alexPrevCharMatches f _ input _ _ = f (alexInputPrevChar input)----alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _ -alexPrevCharIsOneOf arr _ input _ _ = arr ! alexInputPrevChar input----alexRightContext :: Int -> AlexAccPred _-alexRightContext (I# (sc)) user _ _ input = - case alex_scan_tkn user input 0# input sc AlexNone of- (AlexNone, _) -> False- _ -> True- -- TODO: there's no need to find the longest- -- match when checking the right context, just- -- the first match will do.---- used by wrappers-iUnbox (I# (i)) = i
@@ -1,5040 +0,0 @@-{-# OPTIONS_GHC -w #-}-{-# OPTIONS -fglasgow-exts -cpp #-}-{-# OPTIONS_GHC -fno-warn-incomplete-patterns- -fno-warn-deprecated-flags #-}-{-# LANGUAGE BangPatterns #-}-{-| The parser is generated by Happy (<http://www.haskell.org/happy>).--}-module Agda.Syntax.Parser.Parser (- moduleParser- , exprParser- , tokensParser- , tests- ) where--import Control.Arrow-import Control.Monad-import Control.Monad.State-import Data.Char-import Data.List-import Data.Maybe-import qualified Data.Traversable as T--import Agda.Syntax.Position hiding (tests)-import Agda.Syntax.Parser.Monad-import Agda.Syntax.Parser.Lexer-import Agda.Syntax.Parser.Tokens-import Agda.Syntax.Concrete-import Agda.Syntax.Concrete.Name-import Agda.Syntax.Concrete.Pretty-import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Literal--import Agda.Utils.Monad-import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers-import qualified Data.Array as Happy_Data_Array-import qualified GHC.Exts as Happy_GHC_Exts---- parser produced by Happy Version 1.18.9--newtype HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70 = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = Happy_GHC_Exts.Any-#else-type HappyAny = forall a . a-#endif-happyIn6 :: ([Token]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn6 #-}-happyOut6 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Token])-happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut6 #-}-happyIn7 :: ([Token]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn7 #-}-happyOut7 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Token])-happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut7 #-}-happyIn8 :: (Token) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn8 #-}-happyOut8 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Token)-happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut8 #-}-happyIn9 :: (([Pragma], [Declaration])) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn9 #-}-happyOut9 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (([Pragma], [Declaration]))-happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut9 #-}-happyIn10 :: t10 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn10 #-}-happyOut10 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t10-happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut10 #-}-happyIn11 :: t11 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn11 #-}-happyOut11 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t11-happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut11 #-}-happyIn12 :: t12 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn12 #-}-happyOut12 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t12-happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut12 #-}-happyIn13 :: (()) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn13 #-}-happyOut13 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (())-happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut13 #-}-happyIn14 :: (Integer) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn14 #-}-happyOut14 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Integer)-happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut14 #-}-happyIn15 :: (Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn15 #-}-happyOut15 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Name)-happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut15 #-}-happyIn16 :: ([Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Name])-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut16 #-}-happyIn17 :: (Range) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Range)-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut17 #-}-happyIn18 :: (Arg Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Arg Name)-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut18 #-}-happyIn19 :: ([Arg Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg Name])-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut19 #-}-happyIn20 :: ([Arg Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg Name])-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut20 #-}-happyIn21 :: (QName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (QName)-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut21 #-}-happyIn22 :: (QName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (QName)-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut22 #-}-happyIn23 :: (Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Name)-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut23 #-}-happyIn24 :: ([Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Name])-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut24 #-}-happyIn25 :: ([Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Name])-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut25 #-}-happyIn26 :: (Either [Name] [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either [Name] [Expr])-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut26 #-}-happyIn27 :: ([String]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([String])-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut27 #-}-happyIn28 :: (QName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn28 #-}-happyOut28 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (QName)-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut28 #-}-happyIn29 :: (Expr) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn29 #-}-happyOut29 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Expr)-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut29 #-}-happyIn30 :: t30 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn30 #-}-happyOut30 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t30-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut30 #-}-happyIn31 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn31 #-}-happyOut31 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut31 #-}-happyIn32 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn32 #-}-happyOut32 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut32 #-}-happyIn33 :: t33 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn33 #-}-happyOut33 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t33-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut33 #-}-happyIn34 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn34 #-}-happyOut34 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut34 #-}-happyIn35 :: t35 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn35 #-}-happyOut35 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t35-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut35 #-}-happyIn36 :: t36 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn36 #-}-happyOut36 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t36-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut36 #-}-happyIn37 :: t37 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn37 #-}-happyOut37 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t37-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut37 #-}-happyIn38 :: ([(Name, Expr)]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn38 #-}-happyOut38 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([(Name, Expr)])-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut38 #-}-happyIn39 :: ([(Name, Expr)]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn39 #-}-happyOut39 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([(Name, Expr)])-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut39 #-}-happyIn40 :: ((Name, Expr)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn40 #-}-happyOut40 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((Name, Expr))-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut40 #-}-happyIn41 :: t41 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn41 #-}-happyOut41 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t41-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut41 #-}-happyIn42 :: t42 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn42 #-}-happyOut42 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t42-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut42 #-}-happyIn43 :: ([TypedBindings]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn43 #-}-happyOut43 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypedBindings])-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut43 #-}-happyIn44 :: (TypedBindings) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn44 #-}-happyOut44 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (TypedBindings)-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut44 #-}-happyIn45 :: (TypedBinding) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn45 #-}-happyOut45 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (TypedBinding)-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut45 #-}-happyIn46 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn46 #-}-happyOut46 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut46 #-}-happyIn47 :: (Either ([LamBinding], Hiding) [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn47 #-}-happyOut47 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either ([LamBinding], Hiding) [Expr])-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut47 #-}-happyIn48 :: ([Either Hiding LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn48 #-}-happyOut48 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Either Hiding LamBinding])-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut48 #-}-happyIn49 :: (Either [Either Hiding LamBinding] [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn49 #-}-happyOut49 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either [Either Hiding LamBinding] [Expr])-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut49 #-}-happyIn50 :: ((LHS,RHS,WhereClause)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn50 #-}-happyOut50 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((LHS,RHS,WhereClause))-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut50 #-}-happyIn51 :: ((LHS,RHS,WhereClause)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn51 #-}-happyOut51 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((LHS,RHS,WhereClause))-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut51 #-}-happyIn52 :: ((LHS,RHS,WhereClause)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn52 #-}-happyOut52 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((LHS,RHS,WhereClause))-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut52 #-}-happyIn53 :: ([(LHS,RHS,WhereClause)]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn53 #-}-happyOut53 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([(LHS,RHS,WhereClause)])-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut53 #-}-happyIn54 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn54 #-}-happyOut54 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut54 #-}-happyIn55 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn55 #-}-happyOut55 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut55 #-}-happyIn56 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn56 #-}-happyOut56 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut56 #-}-happyIn57 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn57 #-}-happyOut57 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut57 #-}-happyIn58 :: (Either [LamBinding] [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn58 #-}-happyOut58 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either [LamBinding] [Expr])-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut58 #-}-happyIn59 :: ((Maybe AsName, ImportDirective)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn59 #-}-happyOut59 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((Maybe AsName, ImportDirective))-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut59 #-}-happyIn60 :: (ImportDirective) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn60 #-}-happyOut60 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportDirective)-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut60 #-}-happyIn61 :: (ImportDirective) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn61 #-}-happyOut61 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportDirective)-happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut61 #-}-happyIn62 :: (ImportDirective) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn62 #-}-happyOut62 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportDirective)-happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut62 #-}-happyIn63 :: ((UsingOrHiding , Range)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn63 #-}-happyOut63 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((UsingOrHiding , Range))-happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut63 #-}-happyIn64 :: (([Renaming] , Range)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn64 #-}-happyOut64 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (([Renaming] , Range))-happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut64 #-}-happyIn65 :: ([Renaming]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn65 #-}-happyOut65 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Renaming])-happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut65 #-}-happyIn66 :: (Renaming) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn66 #-}-happyOut66 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Renaming)-happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut66 #-}-happyIn67 :: (ImportedName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn67 #-}-happyOut67 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportedName)-happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut67 #-}-happyIn68 :: (ImportedName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn68 #-}-happyOut68 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportedName)-happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut68 #-}-happyIn69 :: ([ImportedName]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn69 #-}-happyOut69 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([ImportedName])-happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut69 #-}-happyIn70 :: t70 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn70 #-}-happyOut70 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t70-happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut70 #-}-happyIn71 :: (LHS) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn71 #-}-happyOut71 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (LHS)-happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut71 #-}-happyIn72 :: ([Pattern]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn72 #-}-happyOut72 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Pattern])-happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut72 #-}-happyIn73 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn73 #-}-happyOut73 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])-happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut73 #-}-happyIn74 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn74 #-}-happyOut74 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])-happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut74 #-}-happyIn75 :: (WhereClause) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn75 #-}-happyOut75 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (WhereClause)-happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut75 #-}-happyIn76 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn76 #-}-happyOut76 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut76 #-}-happyIn77 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn77 #-}-happyOut77 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut77 #-}-happyIn78 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn78 #-}-happyOut78 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut78 #-}-happyIn79 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn79 #-}-happyOut79 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut79 #-}-happyIn80 :: ([Arg Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn80 #-}-happyOut80 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg Declaration])-happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut80 #-}-happyIn81 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn81 #-}-happyOut81 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut81 #-}-happyIn82 :: (RHS) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn82 #-}-happyOut82 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (RHS)-happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut82 #-}-happyIn83 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn83 #-}-happyOut83 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut83 #-}-happyIn84 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn84 #-}-happyOut84 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut84 #-}-happyIn85 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn85 #-}-happyOut85 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut85 #-}-happyIn86 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn86 #-}-happyOut86 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut86 #-}-happyIn87 :: (Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn87 #-}-happyOut87 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Name)-happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut87 #-}-happyIn88 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn88 #-}-happyOut88 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut88 #-}-happyIn89 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn89 #-}-happyOut89 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut89 #-}-happyIn90 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn90 #-}-happyOut90 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut90 #-}-happyIn91 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn91 #-}-happyOut91 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut91 #-}-happyIn92 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn92 #-}-happyOut92 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut92 #-}-happyIn93 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn93 #-}-happyOut93 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut93 #-}-happyIn94 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn94 #-}-happyOut94 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut94 #-}-happyIn95 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn95 #-}-happyOut95 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut95 #-}-happyIn96 :: ([String]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn96 #-}-happyOut96 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([String])-happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut96 #-}-happyIn97 :: ([HoleName]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn97 #-}-happyOut97 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([HoleName])-happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut97 #-}-happyIn98 :: (HoleName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn98 #-}-happyOut98 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (HoleName)-happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut98 #-}-happyIn99 :: (String) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn99 #-}-happyOut99 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (String)-happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut99 #-}-happyIn100 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn100 #-}-happyOut100 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut100 #-}-happyIn101 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn101 #-}-happyOut101 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])-happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut101 #-}-happyIn102 :: ([TypedBindings] -> Parser ModuleApplication) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn102 #-}-happyOut102 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypedBindings] -> Parser ModuleApplication)-happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut102 #-}-happyIn103 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn103 #-}-happyOut103 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut103 #-}-happyIn104 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn104 #-}-happyOut104 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut104 #-}-happyIn105 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn105 #-}-happyOut105 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut105 #-}-happyIn106 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn106 #-}-happyOut106 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut106 #-}-happyIn107 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn107 #-}-happyOut107 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut107 #-}-happyIn108 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn108 #-}-happyOut108 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)-happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut108 #-}-happyIn109 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn109 #-}-happyOut109 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut109 #-}-happyIn110 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn110 #-}-happyOut110 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut110 #-}-happyIn111 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn111 #-}-happyOut111 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut111 #-}-happyIn112 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn112 #-}-happyOut112 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut112 #-}-happyIn113 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn113 #-}-happyOut113 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut113 #-}-happyIn114 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn114 #-}-happyOut114 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut114 #-}-happyIn115 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn115 #-}-happyOut115 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut115 #-}-happyIn116 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn116 #-}-happyOut116 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut116 #-}-happyIn117 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn117 #-}-happyOut117 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut117 #-}-happyIn118 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn118 #-}-happyOut118 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut118 #-}-happyIn119 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn119 #-}-happyOut119 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut119 #-}-happyIn120 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn120 #-}-happyOut120 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut120 #-}-happyIn121 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn121 #-}-happyOut121 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)-happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut121 #-}-happyIn122 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn122 #-}-happyOut122 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])-happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut122 #-}-happyIn123 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn123 #-}-happyOut123 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])-happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut123 #-}-happyIn124 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn124 #-}-happyOut124 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])-happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut124 #-}-happyIn125 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn125 #-}-happyOut125 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])-happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut125 #-}-happyIn126 :: ([Arg TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn126 #-}-happyOut126 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg TypeSignature])-happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut126 #-}-happyIn127 :: ([Arg TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn127 #-}-happyOut127 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg TypeSignature])-happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut127 #-}-happyIn128 :: ([Constructor]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn128 #-}-happyOut128 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Constructor])-happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut128 #-}-happyIn129 :: ((Maybe Name, [Declaration])) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn129 #-}-happyOut129 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((Maybe Name, [Declaration]))-happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut129 #-}-happyIn130 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn130 #-}-happyOut130 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut130 #-}-happyIn131 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn131 #-}-happyOut131 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut131 #-}-happyIn132 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn132 #-}-happyOut132 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])-happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut132 #-}-happyInTok :: (Token) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Token)-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\x00\x00\xd9\x05\x1f\x00\x00\x00\xb8\x02\x34\x05\x00\x00\x4d\x02\x4d\x02\x00\x00\x00\x00\x1f\x00\x00\x00\x58\x00\xc7\x03\xc7\x03\x59\x05\x3a\x05\x00\x00\x2a\x05\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x00\x00\x00\x00\x00\xa8\x05\x81\x05\x35\x05\x00\x00\xff\x00\x2c\x05\x9a\x07\x00\x00\x00\x00\x66\x07\x2b\x05\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x02\x73\x07\x00\x00\x00\x00\x3f\x07\xaa\x04\x90\x03\x77\x04\x00\x00\x00\x00\x00\x00\x24\x05\xe5\x00\x38\x05\x00\x00\x27\x05\xd4\x01\x25\x05\x00\x00\xe1\x00\x00\x00\x69\x01\x69\x01\x00\x00\x23\x05\x26\x05\x1c\x05\x00\x00\x00\x00\x00\x00\xa4\x01\x81\x05\x00\x00\x20\x05\x00\x00\x18\x07\x39\x01\x6c\x02\x20\x02\x00\x00\x89\x06\x50\x05\x58\x06\x00\x00\x4c\x07\x50\x04\x90\x03\x1d\x04\xb0\x06\xb0\x06\xb0\x06\x4e\x05\xf1\x06\x29\x05\x1f\x05\xf1\x06\x00\x00\xb0\x06\xb0\x06\xb0\x06\x11\x05\xf6\x03\x90\x03\x06\x05\x4a\x05\x03\x03\x00\x00\x60\x01\xb0\x06\xb0\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x29\x05\xb0\x06\x4c\x07\x03\x05\x00\x00\x00\x00\xf1\x06\x35\x00\x25\x07\xc7\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\xfe\x06\x36\x02\x5d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x36\x05\x00\x00\x02\x05\x01\x05\xff\x04\x71\x03\xee\x04\xf1\x06\x31\x05\xf1\x06\xec\x04\xe7\x04\x00\x00\x00\x00\xed\x04\x00\x00\x00\x00\xb0\x06\xb0\x06\xb0\x06\xb0\x06\xd2\x01\x22\x05\xeb\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\xdc\x04\xda\x04\x9f\x00\xc9\x04\xc9\x04\xc9\x04\xd7\x06\xd8\x04\xcc\x04\xcc\x04\xcc\x04\xd2\x04\xd2\x04\xd2\x04\xc4\x04\xc6\x04\xa7\x01\xc7\x0c\x29\x05\xbe\x04\xb8\x04\x00\x00\xbc\x04\xb0\x04\xb4\x04\xcf\xff\x00\x00\x00\x00\x00\x00\x00\x00\x29\x05\xa8\x04\x69\x01\xb1\x04\xa4\x04\x69\x01\x9c\x04\xca\x00\xac\x04\x00\x00\x73\x00\xe8\xff\xa7\x04\xa6\x04\xa5\x04\x00\x00\xb0\x06\xb0\x06\x00\x00\xb0\x06\xb0\x06\xca\x06\xa2\x04\xca\x06\x31\x06\xf8\x04\x00\x06\x00\x00\x00\x00\xa0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x04\x00\x00\x00\x00\xd1\x04\xd1\x04\x91\x04\x00\x00\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\xcf\xff\x64\x00\xcf\xff\xb0\x06\x00\x00\x00\x00\x00\x00\xb0\x06\xd1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x04\x86\x04\x00\x00\xd1\x04\x00\x00\x7e\x04\x7a\x04\x7c\x04\x74\x04\x74\x04\x74\x04\x74\x04\x74\x04\x74\x04\x74\x04\xcc\x00\xb5\x04\xa7\x01\xc5\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x00\x00\xce\x04\xaa\x03\xaf\x06\xaf\x06\xaf\x06\x6d\x04\x00\x00\x6d\x04\x00\x00\xed\xff\x00\x00\x03\x03\x00\x00\x00\x00\xdf\x00\xd1\x04\xae\x04\xd1\x04\xd1\x04\x00\x00\x00\x00\x00\x00\x70\x04\x00\x00\x36\x02\x00\x00\xa1\x04\x14\x00\x14\x00\x00\x00\x69\x01\x00\x00\x00\x00\x00\x00\x36\x02\x00\x00\x6b\x04\x6f\x04\x00\x00\x5f\x04\x6e\x04\x5e\x04\x60\x04\x69\x04\x8d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x02\x00\x00\x00\x00\x00\x00\xd1\x04\x00\x00\x00\x00\x59\x04\x4f\x04\x00\x00\x00\x00\xed\xff\x61\x04\x00\x00\x59\x00\x4d\x04\x4d\x04\x5b\x04\x00\x00\x59\x00\xaf\x06\x7f\x00\xac\x00\x9c\x00\x09\x00\xce\x04\x57\x04\x00\x00\x59\x00\x0e\x01\xc9\x01\xed\xff\xed\xff\x6e\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x51\x04\x00\x00\x45\x04\xa7\x01\x6a\x04\xd1\x04\x39\x04\x00\x00\x20\x04\x20\x04\x20\x04\x1f\x04\x1a\x04\x38\x04\x00\x00\x32\x04\x16\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x04\x00\x00\x00\x00\x12\x04\x13\x04\x11\x04\x0f\x04\x0c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x04\x00\x00\x0a\x04\x00\x00\x0b\x04\x49\x01\x00\x00\x04\x04\x04\x04\x04\x04\x04\x04\x00\x00\xce\x04\xd1\x04\x00\x00\x02\x04\xd1\x04\x01\x04\xd1\x04\x01\x04\xd1\x04\x00\x04\xc7\x03\x06\x04\x00\x00\xf3\x03\xd1\x04\x00\x00\x00\x00\xed\xff\xd1\x04\x00\x00\x2f\x04\x00\x00\x00\x00\x00\x00\xe9\x03\xe9\x03\x27\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x03\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x03\x3c\x01\x36\x02\x00\x00\x24\x04\x00\x00\x00\x00\x13\x00\x23\x04\x00\x00\x22\x04\x00\x00\x21\x02\x00\x00\x00\x00\xdd\x03\x49\x01\xd2\x03\x49\x01\xce\x04\xce\x04\xc2\x03\x00\x00\xcd\x03\x00\x00\x00\x00\x00\x00\xbc\x03\x00\x00\x00\x00\x00\x00\xb7\x03\x00\x00\x00\x00\x00\x00\xce\x04\xce\x04\xce\x04\xce\x04\x00\x00\x59\x00\x59\x00\xab\x03\xb5\x03\xa5\x03\x00\x00\xa5\x03\x00\x00\x00\x00\x2a\x03\x36\x02\x00\x00\x00\x00\x49\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\xac\x03\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00"#--happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\xbf\x03\xc0\x0c\x1a\x00\xe5\x03\xd8\x03\x00\x00\x00\x00\x01\x03\xc2\x02\x00\x00\x00\x00\x2e\x00\x00\x00\x81\x02\x68\x02\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x03\xa8\x0c\x00\x00\x00\x00\x8b\x03\x5b\x03\xf4\x00\x00\x00\x00\x00\x17\x05\xcb\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x05\x00\x00\x00\x00\x1d\x02\x7d\x08\x19\x08\x64\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x03\xba\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x05\x90\x0c\x00\x00\x00\x00\x00\x00\x70\x05\x00\x00\x0d\x01\x22\x00\x00\x00\x51\x0a\xb3\x08\xdb\x07\x00\x00\x40\x05\x4b\x08\xfa\x07\x32\x08\x3a\x0a\x23\x0a\x0c\x0a\x00\x00\xb8\x07\x78\x0c\x00\x00\x76\x06\x00\x00\xf5\x09\xde\x09\xc7\x09\x00\x00\x60\x0c\x68\x0a\xf3\x00\x00\x00\x42\x01\x00\x00\x00\x00\xb0\x09\x99\x09\x00\x00\x00\x00\x00\x00\x00\x00\x48\x0c\x30\x0c\x65\x03\x0f\x05\xb9\x03\x00\x00\x00\x00\x1e\x06\x44\x0a\xdc\x00\xae\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x07\x8d\x00\x7b\x08\x68\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x03\xaf\x03\xc6\x05\x00\x00\x6e\x05\x00\x00\x86\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x04\x82\x09\x6b\x09\x54\x09\x00\x00\x5c\x03\x4d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x03\x1c\x03\xf4\x02\x43\x01\x57\x03\x4a\x03\x3f\x03\xda\x00\xc7\x02\x2f\x03\x24\x03\x22\x03\xac\x02\x9a\x02\x92\x02\xae\x02\x70\x02\xe8\x04\x00\x00\x18\x0c\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x9b\x02\x00\x00\x00\x00\x94\x02\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x02\x75\x02\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x09\x26\x09\x00\x00\x0f\x09\xf8\x08\xff\x02\x00\x00\x69\x02\xe1\x08\x9c\x08\xca\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x0b\x00\x00\x00\x00\xd0\x0b\xb8\x0b\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x02\x00\x00\x59\x02\x58\x04\x00\x00\x00\x00\x00\x00\xfe\x03\xa0\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x88\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x3d\x02\x28\x02\x19\x02\x17\x02\xf6\x01\xf3\x01\x00\x00\xba\x01\xb2\x01\xaa\x02\x00\x00\x00\x00\x00\x00\xd9\x01\x00\x00\x95\x01\x6e\x01\x00\x00\x16\x00\x97\x04\x3d\x04\xe3\x03\xb0\x03\xf0\x01\x00\x00\x1c\x00\x00\x00\xfd\xff\x00\x00\xad\x01\x00\x00\x00\x00\xaf\x01\x70\x0b\xb3\x01\x58\x0b\x40\x0b\x00\x00\x00\x00\x00\x00\x2d\x03\x00\x00\xba\x07\x00\x00\xce\x00\xc0\x00\xf9\xff\x00\x00\xd1\x01\x00\x00\x00\x00\x00\x00\x9f\x06\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x01\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\xc6\x01\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x28\x0b\x00\x00\x00\x00\x48\x01\xb6\x01\x00\x00\x00\x00\x64\x03\x00\x00\x00\x00\x9e\x03\xb1\x01\x6d\x03\x00\x00\x00\x00\x87\x03\x5a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x34\x04\x00\x00\x00\x00\x80\x03\x00\x00\xb1\x01\x2c\x03\x89\x02\x08\x01\x00\x00\x00\x00\x00\x00\xfd\x02\x00\x00\x00\x00\x00\x00\x00\x00\x76\x01\x47\x01\x3b\x01\x10\x0b\x00\x00\x00\x00\x7e\x01\x79\x01\x6d\x01\x00\x00\x67\x01\x00\x00\x00\x00\x00\x00\x5f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x14\x01\x00\x00\x00\x00\x4e\x01\x00\x00\x19\x03\xa6\x02\x98\x02\x66\x02\x00\x00\x28\x00\xf8\x0a\x00\x00\xd9\x00\xe0\x0a\x7d\x01\xc8\x0a\x73\x01\xb0\x0a\xcd\x01\x67\x00\x00\x00\x00\x00\x32\x00\x98\x0a\x00\x00\x00\x00\xbf\x00\x80\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x01\x1a\x01\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x85\x00\x75\x06\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xa8\x00\xf0\x03\xbd\x03\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\xff\x00\x00\x00\x00\x00\x00\x8a\x03\x41\x03\x35\x03\x04\x00\x00\x00\x1e\x02\xd3\x01\x31\x00\xb1\xff\x28\x01\x00\x00\x12\x01\x00\x00\x00\x00\x68\x0a\x1d\x06\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00"#--happyDefActions :: HappyAddr-happyDefActions = HappyA# "\xfa\xff\x00\x00\x00\x00\x00\x00\xfc\xff\x00\x00\xae\xff\x00\x00\x00\x00\xad\xff\xbb\xfe\x00\x00\xb6\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xff\x6e\xff\x00\x00\x7f\xff\x7e\xff\x7c\xff\x7b\xff\x00\x00\x5b\xff\x5a\xff\x75\xff\x00\x00\x00\x00\x53\xff\x51\xff\x00\x00\x00\x00\x6a\xff\x69\xff\x00\x00\x00\x00\x68\xff\x67\xff\x66\xff\x65\xff\x00\x00\x00\x00\x6b\xff\x6c\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa5\xff\x8e\xff\x6d\xff\x00\x00\x8d\xff\x00\x00\x87\xff\x00\x00\x86\xff\x00\x00\x6f\xff\x8d\xff\x60\xff\x00\x00\x00\x00\xa2\xff\x00\x00\x00\x00\x00\x00\x61\xff\x8b\xff\x26\xff\x3a\xff\x00\x00\x77\xff\x00\x00\x45\xff\x42\xff\x3b\xff\x00\x00\x00\x00\x8a\xff\x00\x00\x00\x00\x00\x00\x5e\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\xff\x00\x00\x00\x00\x2c\xff\x27\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\xff\x00\x00\x00\x00\x52\xff\x00\x00\x00\x00\x00\x00\x54\xff\x82\xff\x7a\xff\x72\xff\x00\x00\x00\x00\x00\x00\x00\x00\x85\xff\x8d\xff\x8c\xff\x28\xff\x15\xff\xc4\xfe\x00\x00\xac\xff\xba\xfe\xb9\xfe\xfb\xff\xf9\xff\xf8\xff\xf7\xff\xf6\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xf0\xff\xef\xff\xee\xff\xed\xff\xec\xff\xeb\xff\xea\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xde\xff\xdd\xff\xdc\xff\xdb\xff\xda\xff\xd9\xff\xd2\xff\xd1\xff\xd8\xff\xd7\xff\xd6\xff\xd5\xff\xd4\xff\xd3\xff\xd0\xff\xcf\xff\xce\xff\xcd\xff\xcc\xff\xcb\xff\xca\xff\xc9\xff\xc8\xff\xc7\xff\xc6\xff\xc5\xff\xc4\xff\xc3\xff\xc2\xff\xc1\xff\xc0\xff\xbf\xff\xbe\xff\xbd\xff\xbc\xff\xbb\xff\xba\xff\xb9\xff\xb8\xff\xb7\xff\xb6\xff\xb5\xff\xb4\xff\xb3\xff\xb2\xff\xb1\xff\xb0\xff\xaf\xff\x15\xff\xc4\xfe\x15\xff\x00\x00\xbe\xfe\x1d\xff\x1b\xff\x19\xff\x16\xff\x17\xff\x00\x00\x00\x00\x00\x00\x15\xff\x00\x00\x28\xff\x00\x00\x28\xff\x00\x00\x85\xff\x5f\xff\x7d\xff\x00\x00\x80\xff\x86\xff\x75\xff\x00\x00\x00\x00\x00\x00\x8d\xff\x00\xff\xe1\xfe\x8d\xfe\xfb\xfe\xf9\xfe\xf8\xfe\xf7\xfe\xf6\xfe\xf5\xfe\xf4\xfe\xfa\xfe\xf3\xfe\xf2\xfe\xf1\xfe\xf0\xfe\xef\xfe\xe9\xfe\xee\xfe\xec\xfe\xed\xfe\xeb\xfe\xea\xfe\xb7\xfe\xb5\xfe\xb4\xfe\xb2\xfe\xb3\xfe\xb1\xfe\xb0\xfe\xaf\xfe\xac\xfe\xae\xfe\xad\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\xff\x57\xff\x59\xff\x87\xff\x00\x00\x2e\xff\x2f\xff\x81\xff\x2d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\xff\x00\x00\x30\xff\x00\x00\x00\x00\x38\xff\x37\xff\x39\xff\x25\xff\x00\x00\x00\x00\x24\xff\x00\x00\x00\x00\x41\xff\x3d\xff\x42\xff\x00\x00\x00\x00\x00\x00\x46\xff\x79\xff\x3c\xff\x4a\xff\x62\xff\xa1\xff\x49\xff\x64\xff\x00\x00\x48\xff\x71\xff\x00\x00\x00\x00\x00\x00\x47\xff\x00\x00\x3f\xff\x3e\xff\x40\xff\x44\xff\x43\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\xff\x78\xff\xa8\xff\x00\x00\x00\x00\x50\xff\x4e\xff\x4f\xff\x4d\xff\x4b\xff\x4c\xff\x74\xff\x22\xff\x23\xff\x00\x00\x00\x00\x5d\xff\x00\x00\x76\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xff\x00\xff\x00\x00\x00\x00\xd1\xfe\xd2\xfe\xd3\xfe\x00\x00\xa6\xff\x00\x00\x00\x00\xd4\xfe\x00\x00\x28\xff\x28\xff\x28\xff\x28\xff\x00\x00\xcf\xfe\x00\x00\xd0\xfe\x00\x00\x91\xfe\x00\x00\xaa\xff\xab\xff\xfe\xfe\x00\x00\x02\xff\x00\x00\x00\x00\x84\xff\xab\xfe\x2a\xff\x00\x00\x29\xff\x15\xff\x1a\xff\xa7\xff\x00\x00\x0a\xff\x18\xff\x00\x00\xc6\xfe\xc3\xfe\xbd\xfe\x15\xff\x0c\xff\x08\xff\x00\x00\x09\xff\x00\x00\x00\x00\x00\x00\x00\x00\x10\xff\x00\x00\xa7\xff\x1c\xff\x8f\xfe\xb8\xfe\x00\x00\xe6\xfe\xff\xfe\x06\xff\x00\x00\xe2\xfe\xe3\xfe\x00\x00\x00\x00\x8e\xfe\x9f\xff\x9d\xff\x00\x00\x9b\xfe\x00\x00\x00\x00\xa3\xff\x00\x00\x9e\xfe\x00\x00\x28\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x98\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xff\xd7\xfe\xd6\xfe\xd5\xfe\x00\x00\xcb\xfe\xc9\xfe\x00\x00\xc7\xfe\x04\xff\x73\xff\x02\xff\x00\x00\x00\x00\x83\xff\x85\xff\x85\xff\x85\xff\x00\x00\x85\xff\x00\x00\xa1\xfe\x00\x00\x00\x00\x55\xff\x56\xff\x5c\xff\x36\xff\x35\xff\x34\xff\x33\xff\x31\xff\x32\xff\x20\xff\x21\xff\x1e\xff\x1f\xff\x63\xff\x70\xff\x00\x00\xa2\xfe\xa3\xfe\x00\x00\x85\xff\x00\x00\x00\x00\x00\x00\xa4\xfe\xe7\xfe\x05\xff\x03\xff\x00\x00\xca\xfe\x00\x00\x89\xff\x00\x00\x00\x00\xa0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9a\xfe\x00\x00\x00\x00\x9c\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\xfe\x00\x00\x00\x00\xa4\xff\x9d\xfe\x00\x00\x00\x00\x9e\xff\x00\x00\xfd\xfe\x01\xff\x90\xfe\x00\x00\x00\x00\xa7\xff\x12\xff\x0e\xff\x13\xff\x0b\xff\x14\xff\x00\x00\xc5\xfe\x07\xff\x11\xff\x0f\xff\x0d\xff\x00\x00\xe5\xfe\x9c\xfe\xe8\xfe\x9f\xfe\x00\x00\xc4\xfe\x15\xff\xbc\xfe\xdc\xfe\x96\xfe\xde\xfe\x00\x00\x00\x00\xdd\xfe\xd9\xfe\xda\xfe\x00\x00\xe4\xfe\x99\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x99\xff\x97\xff\xce\xfe\xcd\xfe\x00\x00\xa5\xfe\xa6\xfe\xa8\xfe\x00\x00\xa9\xfe\xaa\xfe\xa7\xfe\x00\x00\xcc\xfe\x98\xff\x9a\xff\x93\xff\x95\xff\x8f\xff\x91\xff\x95\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\xfe\x00\x00\xc0\xfe\xc1\xfe\x00\x00\x15\xff\xfc\xfe\xbf\xfe\x00\x00\xe0\xfe\xdf\xfe\xdb\xfe\xd8\xfe\x92\xfe\x94\xfe\x00\x00\x92\xff\x90\xff\x96\xff\x94\xff\x00\x00\xc8\xfe\x00\x00\xc2\xfe\x93\xfe"#--happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x05\x00\x09\x00\x05\x00\x35\x00\x09\x00\x09\x00\x09\x00\x0a\x00\x0c\x00\x0d\x00\x0f\x00\x03\x00\x09\x00\x0b\x00\x40\x00\x0c\x00\x42\x00\x0e\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x34\x00\x03\x00\x04\x00\x09\x00\x33\x00\x09\x00\x0c\x00\x0f\x00\x0e\x00\x09\x00\x0a\x00\x08\x00\x09\x00\x09\x00\x42\x00\x09\x00\x7b\x00\x45\x00\x0f\x00\x0f\x00\x10\x00\x09\x00\x04\x00\x11\x00\x0c\x00\x48\x00\x0e\x00\x3e\x00\x3f\x00\x40\x00\x09\x00\x09\x00\x0a\x00\x41\x00\x35\x00\x0a\x00\x0b\x00\x0c\x00\x46\x00\x0e\x00\x48\x00\x47\x00\x49\x00\x4b\x00\x5d\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x3e\x00\x44\x00\x40\x00\x00\x00\x5e\x00\x48\x00\x48\x00\x61\x00\x62\x00\x63\x00\x4a\x00\x09\x00\x66\x00\x47\x00\x68\x00\x46\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x05\x00\x4a\x00\x75\x00\x77\x00\x09\x00\x0f\x00\x10\x00\x5e\x00\x47\x00\x7e\x00\x0f\x00\x62\x00\x48\x00\x64\x00\x65\x00\x60\x00\x67\x00\x03\x00\x69\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x5e\x00\x34\x00\x09\x00\x79\x00\x62\x00\x75\x00\x64\x00\x65\x00\x0f\x00\x67\x00\x09\x00\x69\x00\x09\x00\x35\x00\x05\x00\x06\x00\x0f\x00\x44\x00\x45\x00\x03\x00\x48\x00\x49\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x42\x00\x34\x00\x09\x00\x5d\x00\x1d\x00\x1e\x00\x1f\x00\x41\x00\x0f\x00\x03\x00\x21\x00\x22\x00\x46\x00\x0b\x00\x48\x00\x36\x00\x48\x00\x4b\x00\x45\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x0b\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x35\x00\x60\x00\x09\x00\x09\x00\x5e\x00\x0c\x00\x0d\x00\x61\x00\x62\x00\x63\x00\x07\x00\x35\x00\x66\x00\x42\x00\x68\x00\x07\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x35\x00\x03\x00\x09\x00\x5f\x00\x09\x00\x0f\x00\x48\x00\x49\x00\x0f\x00\x7e\x00\x0f\x00\x5f\x00\x7c\x00\x0f\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x09\x00\x1e\x00\x1d\x00\x1e\x00\x1f\x00\x09\x00\x09\x00\x3e\x00\x35\x00\x40\x00\x35\x00\x3d\x00\x0f\x00\x3b\x00\x3c\x00\x3d\x00\x3b\x00\x49\x00\x3b\x00\x3c\x00\x3d\x00\x42\x00\x48\x00\x20\x00\x21\x00\x22\x00\x09\x00\x1e\x00\x20\x00\x21\x00\x22\x00\x09\x00\x36\x00\x41\x00\x11\x00\x12\x00\x36\x00\x3b\x00\x46\x00\x11\x00\x48\x00\x3b\x00\x36\x00\x4b\x00\x09\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x3d\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x32\x00\x33\x00\x48\x00\x39\x00\x5e\x00\x09\x00\x3c\x00\x61\x00\x62\x00\x63\x00\x5f\x00\x3d\x00\x66\x00\x3f\x00\x68\x00\x41\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x09\x00\x3f\x00\x12\x00\x41\x00\x09\x00\x0f\x00\x0f\x00\x10\x00\x7b\x00\x7e\x00\x0f\x00\x1b\x00\x1c\x00\x0b\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x5d\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x32\x00\x33\x00\x15\x00\x5a\x00\x33\x00\x37\x00\x5d\x00\x39\x00\x37\x00\x38\x00\x16\x00\x3d\x00\x09\x00\x3f\x00\x3d\x00\x41\x00\x3f\x00\x15\x00\x41\x00\x43\x00\x11\x00\x12\x00\x48\x00\x15\x00\x41\x00\x48\x00\x49\x00\x74\x00\x4b\x00\x46\x00\x40\x00\x48\x00\x42\x00\x7a\x00\x4b\x00\x15\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x15\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x74\x00\x3d\x00\x09\x00\x3f\x00\x5e\x00\x41\x00\x7a\x00\x61\x00\x62\x00\x63\x00\x11\x00\x12\x00\x66\x00\x40\x00\x68\x00\x42\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x09\x00\x42\x00\x12\x00\x09\x00\x09\x00\x0f\x00\x0f\x00\x10\x00\x09\x00\x7e\x00\x0f\x00\x1b\x00\x1c\x00\x7c\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x07\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x32\x00\x33\x00\x05\x00\x06\x00\x33\x00\x37\x00\x0b\x00\x39\x00\x37\x00\x38\x00\x09\x00\x3d\x00\x09\x00\x3f\x00\x3d\x00\x41\x00\x3f\x00\x74\x00\x41\x00\x09\x00\x11\x00\x12\x00\x48\x00\x7a\x00\x41\x00\x48\x00\x49\x00\x74\x00\x4b\x00\x46\x00\x45\x00\x48\x00\x43\x00\x7a\x00\x4b\x00\x09\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x44\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x35\x00\x3f\x00\x16\x00\x41\x00\x5e\x00\x16\x00\x3b\x00\x61\x00\x62\x00\x63\x00\x48\x00\x3e\x00\x66\x00\x40\x00\x68\x00\x42\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x00\x00\x01\x00\x05\x00\x06\x00\x09\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x16\x00\x11\x00\x16\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x16\x00\x1e\x00\x0a\x00\x0b\x00\x0c\x00\x26\x00\x0e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x7c\x00\x7d\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x33\x00\x34\x00\x31\x00\x16\x00\x33\x00\x08\x00\x09\x00\x37\x00\x37\x00\x38\x00\x16\x00\x3a\x00\x0f\x00\x3d\x00\x3d\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x09\x00\x0b\x00\x44\x00\x0b\x00\x46\x00\x48\x00\x48\x00\x49\x00\x11\x00\x4b\x00\x00\x00\x01\x00\x09\x00\x0a\x00\x09\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x0b\x00\x11\x00\x06\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x26\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x09\x00\x1e\x00\x32\x00\x33\x00\x34\x00\x26\x00\x0f\x00\x10\x00\x09\x00\x2a\x00\x06\x00\x0c\x00\x0d\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x33\x00\x34\x00\x31\x00\x0b\x00\x33\x00\x09\x00\x0a\x00\x37\x00\x37\x00\x38\x00\x0b\x00\x3a\x00\x0b\x00\x3d\x00\x3d\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x09\x00\x0a\x00\x44\x00\x42\x00\x46\x00\x48\x00\x48\x00\x49\x00\x09\x00\x4b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x01\x00\x5b\x00\x5c\x00\x5d\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x3d\x00\x7c\x00\x3f\x00\x11\x00\x41\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x7c\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x5e\x00\x1e\x00\x09\x00\x0a\x00\x62\x00\x26\x00\x64\x00\x65\x00\x7c\x00\x2a\x00\x08\x00\x01\x00\x08\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x33\x00\x34\x00\x31\x00\x09\x00\x33\x00\x08\x00\x0c\x00\x0d\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x09\x00\x78\x00\x3d\x00\x0c\x00\x3f\x00\x0e\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x09\x00\x46\x00\x09\x00\x48\x00\x49\x00\x0c\x00\x4b\x00\x0e\x00\x38\x00\x39\x00\x3a\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x5c\x00\x5d\x00\x31\x00\x32\x00\x33\x00\x01\x00\x5e\x00\x09\x00\x37\x00\x38\x00\x62\x00\x3a\x00\x64\x00\x65\x00\x3d\x00\x74\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x09\x00\x09\x00\x12\x00\x0c\x00\x0d\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x09\x00\x0a\x00\x1b\x00\x1c\x00\x1d\x00\x0a\x00\x0b\x00\x0c\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x05\x00\x06\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\x31\x00\x32\x00\x33\x00\x01\x00\x76\x00\x09\x00\x37\x00\x38\x00\x0c\x00\x3a\x00\x0e\x00\x4c\x00\x3d\x00\x15\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x44\x00\x09\x00\x12\x00\x05\x00\x06\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x7c\x00\x7d\x00\x1b\x00\x1c\x00\x1d\x00\x05\x00\x06\x00\x25\x00\x26\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x09\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x00\x00\x01\x00\x11\x00\x32\x00\x33\x00\x01\x00\x0b\x00\x09\x00\x37\x00\x38\x00\x0c\x00\x3a\x00\x0e\x00\x3a\x00\x3d\x00\x15\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x0b\x00\x09\x00\x12\x00\x26\x00\x7c\x00\x48\x00\x49\x00\x02\x00\x4b\x00\x32\x00\x33\x00\x1b\x00\x1c\x00\x1d\x00\x37\x00\x32\x00\x33\x00\x34\x00\x3b\x00\x01\x00\x3d\x00\x43\x00\x3f\x00\x3e\x00\x41\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x48\x00\x11\x00\x32\x00\x33\x00\x01\x00\x43\x00\x09\x00\x37\x00\x38\x00\x0c\x00\x3a\x00\x0e\x00\x48\x00\x3d\x00\x43\x00\x3f\x00\x47\x00\x41\x00\x42\x00\x39\x00\x09\x00\x12\x00\x26\x00\x48\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x48\x00\x49\x00\x1b\x00\x1c\x00\x1d\x00\x42\x00\x32\x00\x33\x00\x34\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x42\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x03\x00\x03\x00\x03\x00\x32\x00\x33\x00\x2c\x00\x2d\x00\x2e\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x48\x00\x03\x00\x3d\x00\x3e\x00\x3f\x00\x0f\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x48\x00\x36\x00\x09\x00\x48\x00\x49\x00\x0c\x00\x4b\x00\x0e\x00\x43\x00\x43\x00\x43\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x42\x00\x11\x00\x32\x00\x33\x00\x01\x00\x48\x00\x47\x00\x37\x00\x38\x00\x47\x00\x3a\x00\x47\x00\x47\x00\x3d\x00\x47\x00\x3f\x00\x4a\x00\x41\x00\x42\x00\x4a\x00\x09\x00\x12\x00\x26\x00\x4a\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x4a\x00\x4a\x00\x1b\x00\x1c\x00\x1d\x00\x04\x00\x32\x00\x33\x00\x34\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x47\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x47\x00\x47\x00\x3c\x00\x32\x00\x33\x00\x2c\x00\x2d\x00\x2e\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x3a\x00\x35\x00\x3d\x00\x3e\x00\x3f\x00\x35\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x48\x00\x35\x00\x48\x00\x48\x00\x49\x00\x0d\x00\x4b\x00\x43\x00\x34\x00\x3e\x00\x34\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x48\x00\x11\x00\x32\x00\x33\x00\x01\x00\x3e\x00\x3e\x00\x37\x00\x38\x00\x0f\x00\x3a\x00\x04\x00\x43\x00\x3d\x00\x48\x00\x3f\x00\x42\x00\x41\x00\x42\x00\x05\x00\x09\x00\x12\x00\x26\x00\x4a\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x47\x00\x4a\x00\x1b\x00\x1c\x00\x1d\x00\x4a\x00\x32\x00\x33\x00\x34\x00\x1a\x00\x1b\x00\x48\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x42\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x39\x00\x3e\x00\x39\x00\x32\x00\x33\x00\x39\x00\x39\x00\x39\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x39\x00\x42\x00\x3d\x00\x3e\x00\x3f\x00\x42\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x3e\x00\x34\x00\x09\x00\x48\x00\x49\x00\x36\x00\x4b\x00\x42\x00\x0f\x00\x48\x00\x01\x00\x42\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x32\x00\x33\x00\x3c\x00\x32\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x48\x00\x3f\x00\x3d\x00\x41\x00\x3f\x00\x48\x00\x41\x00\x1b\x00\x1c\x00\x43\x00\x48\x00\x4b\x00\x09\x00\x48\x00\x49\x00\x43\x00\x4b\x00\x43\x00\x0f\x00\x43\x00\x09\x00\x36\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x11\x00\x3c\x00\x01\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x38\x00\x4a\x00\x3a\x00\x47\x00\x03\x00\x3d\x00\x48\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x12\x00\x3d\x00\x26\x00\x3d\x00\x3d\x00\x48\x00\x49\x00\x0c\x00\x4b\x00\x1b\x00\x1c\x00\x1d\x00\x30\x00\x31\x00\x09\x00\x33\x00\x34\x00\x02\x00\x4a\x00\x48\x00\x0f\x00\x02\x00\x01\x00\x41\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x39\x00\x39\x00\x3e\x00\x32\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x3e\x00\x42\x00\x3d\x00\x42\x00\x3f\x00\x42\x00\x41\x00\x1b\x00\x1c\x00\x35\x00\x39\x00\x43\x00\x4c\x00\x48\x00\x49\x00\x48\x00\x4b\x00\x3b\x00\x4c\x00\x09\x00\x1f\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\x4c\x00\x11\x00\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\x40\x00\x41\x00\x42\x00\x12\x00\x26\x00\xff\xff\x26\x00\xff\xff\x48\x00\x49\x00\x2a\x00\x4b\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x32\x00\x33\x00\x34\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\x11\x00\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\x12\x00\x26\x00\xff\xff\x26\x00\xff\xff\x48\x00\x49\x00\x2a\x00\x4b\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x32\x00\x33\x00\x34\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\xff\xff\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x42\x00\x12\x00\x26\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\x32\x00\x33\x00\x34\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\xff\xff\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x42\x00\x12\x00\x26\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x1b\x00\x1c\x00\xff\xff\x31\x00\xff\xff\x33\x00\x34\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\x32\x00\x33\x00\x33\x00\xff\xff\xff\xff\x37\x00\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\x3d\x00\x3d\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\x48\x00\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x09\x00\x4b\x00\xff\xff\xff\xff\xff\xff\x31\x00\x0f\x00\x33\x00\x34\x00\xff\xff\x13\x00\x14\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x27\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x2c\x00\x2d\x00\x0f\x00\x2f\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\x6d\x02\xad\x01\x73\x02\x53\x01\xeb\x00\xc5\x01\xcb\x01\xcc\x01\xc6\x01\xc7\x01\x12\x00\x1f\x02\xc5\x01\x8a\x02\x42\x00\xd4\x01\x43\x00\x83\x02\x97\x01\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x62\x01\x05\x00\x06\x00\xc5\x01\xcb\x01\xad\x01\xd4\x01\xb2\x01\xd5\x01\xcb\x01\xcc\x01\x0e\x00\x0f\x00\x79\x00\x63\x01\x46\x00\x7e\x02\x64\x01\x10\x00\x7a\x00\x47\x02\xc5\x01\x7f\x00\x3b\x01\xd4\x01\x33\x00\xd5\x01\xae\x01\xaf\x01\xb0\x01\x7f\x02\xcb\x01\xcc\x01\xed\x00\x20\x02\xd9\x00\xda\x00\xdb\x00\xee\x00\xdc\x00\xef\x00\xcd\x01\xc8\x01\xf0\x00\x87\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x6e\x02\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xae\x01\x98\x01\x3d\x02\x97\x01\xfd\x00\x33\x00\x33\x00\xfe\x00\xff\x00\x00\x01\xd6\x01\x7f\x00\x01\x01\xcd\x01\x02\x01\x11\x00\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x79\x00\x32\x02\x54\x02\xce\x01\xc9\x01\xeb\x00\x7a\x00\x47\x02\x07\x00\x45\x02\x6f\x02\x12\x00\x08\x00\xdd\x00\x09\x00\x0a\x00\x78\x02\x0b\x00\x25\x02\x0c\x00\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x07\x00\x62\x01\x11\x00\xd7\x01\x08\x00\xce\x01\x09\x00\x0a\x00\x12\x00\x0b\x00\x11\x00\x0c\x00\x21\x01\x53\x01\x8b\x02\x95\x01\x12\x00\x98\x01\x64\x01\x21\x02\x33\x00\x34\x00\x19\x00\x1a\x00\xcf\x00\x52\x00\xff\x01\x62\x01\x7f\x00\x66\x02\x19\x00\x1a\x00\xcf\x00\xed\x00\x90\x01\x23\x02\xf5\x01\x24\x01\xee\x00\x69\x02\xef\x00\x26\x02\x33\x00\xf0\x00\x64\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x6b\x02\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x53\x01\x48\x02\xc5\x01\xad\x01\xfd\x00\xc6\x01\xc7\x01\xfe\x00\xff\x00\x00\x01\xb3\x01\x22\x02\x01\x01\x01\x02\x02\x01\xb3\x01\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\xeb\x00\x24\x02\xc3\x01\x8b\x01\x76\x02\x11\x00\x12\x00\x33\x00\x34\x00\x12\x00\x0d\x01\x12\x00\xaa\x01\x79\x02\xc4\x01\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x21\x01\x66\x00\x19\x00\x1a\x00\xcf\x00\x21\x01\x11\x00\xae\x01\x86\xff\xb2\x01\xe9\x01\xe4\x01\x12\x00\x3e\x02\xb5\x01\xb6\x01\x78\x00\x43\x02\xb4\x01\xb5\x01\xb6\x01\x86\xff\xe5\x01\x6f\x01\x23\x01\x24\x01\x46\x00\x66\x00\x22\x01\x23\x01\x24\x01\x46\x00\x50\x01\xed\x00\xdc\x01\x12\x02\x54\x01\x78\x00\xee\x00\x3e\x01\xef\x00\x78\x00\x12\x02\xf0\x00\x3f\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xe4\x01\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x2b\x00\x6e\x00\xe5\x01\x76\x00\xfd\x00\x40\x02\x77\x00\xfe\x00\xff\x00\x00\x01\xd0\x00\x64\x00\x01\x01\x6f\x00\x02\x01\x70\x00\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\xeb\x00\x79\x00\x19\x02\x22\x00\x1a\x02\x11\x00\x12\x00\x7a\x00\x7d\x00\x51\x02\x89\x02\x12\x00\x23\x00\x24\x00\x59\x02\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x5d\x02\x73\x00\x19\x00\x1a\x00\xe6\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x27\xff\x27\xff\x61\x02\x5b\x02\x57\x00\x27\xff\x5c\x02\x27\xff\x2d\x00\x2e\x00\x03\x02\x27\xff\x46\x00\x27\xff\x68\x00\x27\xff\x78\x02\x06\x02\x75\x00\x0d\x02\xdc\x01\xdd\x01\x27\xff\x08\x02\xed\x00\x33\x00\x34\x00\x4b\x02\x35\x00\xee\x00\x42\x00\xef\x00\x43\x00\x7c\x02\xf0\x00\x09\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x0a\x02\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x4b\x02\xe9\x00\x46\x00\xea\x00\xfd\x00\xeb\x00\x7d\x02\xfe\x00\xff\x00\x00\x01\xdc\x01\xde\x01\x01\x01\x42\x00\x02\x01\x43\x00\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\xeb\x00\x79\x00\x0e\x02\x22\x00\x15\x02\x11\x00\x12\x00\x7a\x00\xce\x00\x2f\x02\x0d\x01\x12\x00\x23\x00\x24\x00\x30\x02\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x33\x02\xe5\x01\x19\x00\x1a\x00\xe6\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x50\x00\x51\x00\x80\x02\x95\x01\x57\x00\x52\x00\xac\x01\x41\xff\x2d\x00\x2e\x00\x37\x02\x45\x01\x46\x00\x46\x01\x68\x00\x47\x01\x69\x00\x4b\x02\x75\x00\x39\x02\xdc\x01\xdf\x01\x33\x00\x4c\x02\xed\x00\x33\x00\x34\x00\x4b\x02\x35\x00\xc4\x01\xc1\x01\xef\x00\xbe\x01\x4f\x02\xf0\x00\xcf\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xe7\x01\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x9d\x01\x17\x02\xe9\x01\x18\x02\xfd\x00\xeb\x01\x78\x00\xfe\x00\xff\x00\x00\x01\x33\x00\x7c\xff\x01\x01\x7c\xff\x02\x01\x7c\xff\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x97\x01\x21\x00\x81\x02\x82\x02\x79\x00\x46\x00\x0f\x01\x10\x01\x11\x01\x0f\x00\x7a\x00\x7b\x00\xec\x01\x47\x00\xed\x01\x12\x01\x13\x01\x14\x01\x15\x01\x71\x02\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x23\x00\x24\x00\xee\x01\x1d\x01\xd9\x00\xda\x00\xdb\x00\x48\x00\xdc\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xb9\x01\x49\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x4d\x00\x4e\x00\x1e\x01\xef\x01\x1f\x01\x0e\x00\x0f\x00\x52\x00\x2d\x00\x2e\x00\xf0\x01\x2f\x00\x10\x00\xe9\x00\x68\x00\x3d\x01\x69\x00\x3e\x01\x75\x00\x46\x00\xfd\x01\x98\x01\xff\x01\x20\x01\x33\x00\x33\x00\x34\x00\x47\x00\x35\x00\x97\x01\x21\x00\xcb\x01\x55\x02\x79\x00\x46\x00\x0f\x01\x10\x01\x11\x01\x0f\x00\x7a\x00\x7c\x00\x01\x02\x47\x00\x60\x01\x12\x01\x13\x01\x14\x01\x15\x01\xdd\x00\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x23\x00\x24\x00\x79\x00\x1d\x01\x26\x02\xdf\x00\x62\x00\x41\x01\x7a\x00\x7d\x00\xc5\x01\x5a\x01\x64\x01\xc6\x01\x13\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x43\x01\x62\x00\x1e\x01\x67\x01\x1f\x01\xcb\x01\x56\x02\x52\x00\x2d\x00\x2e\x00\x6a\x01\x2f\x00\x6d\x01\x5b\x00\x68\x00\x40\x01\x69\x00\x41\x01\x75\x00\xcb\x01\x57\x02\x98\x01\x7f\x01\x20\x01\x33\x00\x33\x00\x34\x00\x81\x01\x35\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x21\x00\xe0\x01\xe1\x01\xe2\x01\x46\x00\x0f\x01\x10\x01\x11\x01\x0f\x00\x5b\x00\x82\x01\x5c\x00\x47\x00\x5d\x00\x12\x01\x13\x01\x14\x01\x15\x01\x83\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x23\x00\x24\x00\x07\x00\x1d\x01\xcb\x01\x58\x02\x08\x00\x41\x01\x80\x00\x0a\x00\x84\x01\x5b\x01\x85\x01\x21\x00\x87\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x43\x01\x62\x00\x1e\x01\xc5\x01\x1f\x01\x88\x01\xc6\x01\x14\x02\x2d\x00\x2e\x00\x22\x00\x2f\x00\xc5\x01\x89\x01\x68\x00\xd4\x01\x69\x00\x84\x02\x75\x00\x23\x00\x24\x00\x25\x00\x8c\x01\x20\x01\xc5\x01\x33\x00\x34\x00\xd4\x01\x35\x00\x85\x02\xa3\x01\xd6\x00\xd7\x00\x8d\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x10\x02\xe2\x01\x7c\x02\x2b\x00\x2c\x00\x21\x00\x07\x00\x8e\x01\x2d\x00\x2e\x00\x08\x00\x2f\x00\x81\x00\x0a\x00\x30\x00\x90\x01\x31\x00\x42\x00\x32\x00\x43\x00\xc5\x01\x11\x00\x22\x00\xc6\x01\x2e\x02\x33\x00\x34\x00\x12\x00\x35\x00\xcb\x01\x2a\x02\x23\x00\x24\x00\x25\x00\xd9\x00\xda\x00\xdb\x00\xe3\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x1a\x02\x1b\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x27\x02\x28\x02\xa9\x01\x2b\x00\x2c\x00\x21\x00\x92\x01\xc5\x01\x2d\x00\x2e\x00\xd4\x01\x2f\x00\x86\x02\x98\x01\x30\x00\x9d\x01\x31\x00\x42\x00\x32\x00\x43\x00\x9a\x01\x11\x00\x22\x00\x2b\x02\x2c\x02\x33\x00\x34\x00\x12\x00\x35\x00\xb9\x01\xba\x01\x23\x00\x24\x00\x25\x00\x94\x01\x95\x01\x6c\x00\x1f\x00\x72\x00\x17\x00\x73\x00\x19\x00\x1a\x00\x1b\x00\xa2\x01\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x35\x00\x04\x00\x47\x00\x2b\x00\x2c\x00\x21\x00\x4d\x01\xc5\x01\x2d\x00\x2e\x00\xd4\x01\x2f\x00\x67\x02\xa7\x01\x30\x00\xe0\x00\x31\x00\x42\x00\x32\x00\x43\x00\x4e\x01\x5d\x00\x22\x00\xdd\x00\x6a\x00\x33\x00\x34\x00\x82\x00\x35\x00\x50\x00\x51\x00\x23\x00\x24\x00\x25\x00\x52\x00\xd0\x01\xdf\x00\x62\x00\x78\x00\x04\x00\x64\x00\x4e\x02\x65\x00\x89\x02\x66\x00\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x33\x00\x33\x00\x47\x00\x2b\x00\x2c\x00\x21\x00\x53\x02\xc5\x01\x2d\x00\x2e\x00\xd4\x01\x2f\x00\x68\x02\xe5\x01\x30\x00\x6c\x00\x31\x00\x65\x02\x32\x00\x3d\x00\x66\x02\x11\x00\x22\x00\xdd\x00\xe5\x01\x33\x00\x34\x00\x12\x00\x35\x00\x33\x00\x34\x00\x23\x00\x24\x00\x25\x00\x6b\x02\xd1\x01\xdf\x00\x62\x00\xf8\x01\x17\x00\x34\x01\x19\x00\x1a\x00\x1b\x00\x21\x00\x6d\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x72\x02\x73\x02\x75\x02\x2b\x00\x2c\x00\xf9\x01\xfa\x01\xfb\x01\x2d\x00\x2e\x00\x22\x00\x2f\x00\x33\x00\x42\x02\x30\x00\x46\x00\x31\x00\xb8\x01\x32\x00\x23\x00\x24\x00\x25\x00\x33\x00\x47\x02\xc5\x01\x33\x00\x34\x00\xd4\x01\x35\x00\x1d\x02\xbc\x01\x4e\x02\x53\x02\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x33\x00\x5b\x02\x47\x00\x2b\x00\x2c\x00\x21\x00\xe5\x01\x5f\x02\x2d\x00\x2e\x00\x60\x02\x2f\x00\x61\x02\x63\x02\x30\x00\x64\x02\x31\x00\xe2\x00\x32\x00\x3d\x00\xeb\x01\x11\x00\x22\x00\xdd\x00\xe2\x00\x33\x00\x34\x00\x12\x00\x35\x00\x08\x02\xe2\x00\x23\x00\x24\x00\x25\x00\xc0\x01\xd2\x01\xdf\x00\x62\x00\xf8\x01\x17\x00\x34\x01\x19\x00\x1a\x00\x1b\x00\x21\x00\x05\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x06\x02\x0c\x02\x81\x01\x2b\x00\x2c\x00\xf9\x01\xfa\x01\xfc\x01\x2d\x00\x2e\x00\x22\x00\x2f\x00\x10\x02\x1d\x02\x30\x00\x46\x00\x31\x00\x2a\x02\x32\x00\x23\x00\x24\x00\x25\x00\x33\x00\x2e\x02\x33\x00\x33\x00\x34\x00\x35\x02\x35\x00\x6c\x00\x36\x02\x37\x02\x3c\x02\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x33\x00\x33\x00\x47\x00\x2b\x00\x2c\x00\x21\x00\x39\x02\x3b\x02\x2d\x00\x2e\x00\xb8\x01\x2f\x00\xc0\x01\xbc\x01\x30\x00\x33\x00\x31\x00\xf7\x01\x32\x00\x3d\x00\x9c\x01\x11\x00\x22\x00\xdd\x00\xeb\x01\x33\x00\x34\x00\x12\x00\x35\x00\xf2\x01\xf3\x01\x23\x00\x24\x00\x25\x00\xf4\x01\xd3\x01\xdf\x00\x62\x00\x72\x00\x17\x00\x33\x00\x19\x00\x1a\x00\xe7\x00\x21\x00\x03\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x43\xff\x67\x01\x44\xff\x2b\x00\x2c\x00\x40\xff\x3e\xff\x3f\xff\x2d\x00\x2e\x00\x22\x00\x2f\x00\x66\x01\x69\x01\x30\x00\x46\x00\x31\x00\x6c\x01\x32\x00\x23\x00\x24\x00\x25\x00\x6a\x01\x71\x01\x7e\x01\x33\x00\x34\x00\x73\x01\x35\x00\x6f\x01\x12\x00\x33\x00\x21\x00\x72\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd9\x01\xda\x01\x81\x01\x2b\x00\x2c\x00\x19\x00\x1a\x00\x55\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x33\x00\xdb\x01\x30\x00\xdc\x01\x31\x00\x33\x00\x32\x00\x23\x00\x24\x00\x6c\x00\x33\x00\x87\x01\x11\x00\x33\x00\x34\x00\x8b\x01\x35\x00\x92\x01\x12\x00\x94\x01\x46\x00\x9a\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x9c\x01\x47\x00\x77\x00\x21\x00\x57\x00\x19\x00\x1a\x00\xe2\x00\x2d\x00\x2e\x00\xe2\x00\x2f\x00\x9f\x01\xa1\x01\x68\x00\x33\x00\x69\x00\x42\x00\x75\x00\x43\x00\x22\x00\xa5\x01\x5e\x00\xa6\x01\xa7\x01\x33\x00\x34\x00\xdb\x00\x35\x00\x23\x00\x24\x00\x25\x00\x5f\x00\x60\x00\x11\x00\x61\x00\x62\x00\x21\x01\xe2\x00\x33\x00\x12\x00\x2d\x01\x21\x00\x26\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2a\x01\x48\x01\x4b\x01\x2b\x00\x2c\x00\x19\x00\x1a\x00\x55\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x4c\x01\x4d\x01\x30\x00\x51\x01\x31\x00\x52\x01\x32\x00\x23\x00\x24\x00\x53\x01\x71\x00\x6c\x00\xff\xff\x33\x00\x34\x00\x33\x00\x35\x00\x78\x00\xff\xff\x46\x00\x79\x00\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\xff\xff\x47\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x42\x00\x75\x00\x43\x00\x22\x00\xdd\x00\x00\x00\x41\x01\x00\x00\x33\x00\x34\x00\x42\x01\x35\x00\x23\x00\x24\x00\x25\x00\x00\x00\x9f\x01\xdf\x00\x62\x00\x43\x01\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x47\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x73\xff\x2f\x00\x00\x00\x73\xff\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x00\x00\x22\x00\xdd\x00\x00\x00\x41\x01\x00\x00\x33\x00\x34\x00\x49\x01\x35\x00\x23\x00\x24\x00\x25\x00\x00\x00\xa1\x01\xdf\x00\x62\x00\x43\x01\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x00\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x58\x01\x22\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x23\x00\x24\x00\x00\x00\x00\x00\xde\x00\xdf\x00\x62\x00\x7a\x02\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x5a\x01\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x00\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x39\x01\x22\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x23\x00\x24\x00\x00\x00\x28\x01\x00\x00\x61\x00\x62\x00\x75\x02\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x3b\x01\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x3c\x02\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x50\x00\x51\x00\x57\x00\x00\x00\x00\x00\x52\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x64\x00\x68\x00\x65\x00\x69\x00\x66\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x45\x01\x00\x00\x46\x01\x57\x00\x47\x01\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x64\x00\x00\x00\x65\x00\x57\x00\x66\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x45\x01\x00\x00\x46\x01\x57\x00\x47\x01\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\xd2\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x53\x00\x00\x00\x54\x00\x57\x00\x55\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x64\x00\x00\x00\x65\x00\x57\x00\x66\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x58\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x11\x00\x35\x00\x00\x00\x00\x00\x00\x00\x2b\x01\x12\x00\x61\x00\x62\x00\x00\x00\x37\x00\x26\x01\xb8\x01\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x33\x01\x17\x00\x34\x01\x19\x00\x1a\x00\x1b\x00\xab\x01\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x3b\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x35\x01\x36\x01\x12\x00\x37\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x3f\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x31\x01\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x3f\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x36\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x40\x00\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x39\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x11\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x30\x01\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x43\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x36\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x32\x01\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x39\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x11\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x3b\x00\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x43\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x44\x00\x11\x00\x00\x00\x58\x01\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x27\x01\x38\x00\xa9\x01\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x39\x01\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x27\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x37\x00\x26\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x3b\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x44\x00\x00\x00\x00\x00\x5c\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2d\x01\x00\x00\x00\x00\x5d\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2e\x01\x00\x00\x00\x00\x5e\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x30\x01\x00\x00\x00\x00\x5f\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x31\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x30\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x31\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x32\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x3b\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x37\x00\x26\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x3b\x00\x00\x00\x00\x00\x27\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x44\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2d\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2e\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2f\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x12\x00\x44\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x3f\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x36\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x75\x01\x76\x01\x77\x01\x78\x01\x79\x01\x7a\x01\x7b\x01\x7c\x01\x7d\x01\x7e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--happyReduceArr = Happy_Data_Array.array (3, 370) [- (3 , happyReduce_3),- (4 , happyReduce_4),- (5 , happyReduce_5),- (6 , happyReduce_6),- (7 , happyReduce_7),- (8 , happyReduce_8),- (9 , happyReduce_9),- (10 , happyReduce_10),- (11 , happyReduce_11),- (12 , happyReduce_12),- (13 , happyReduce_13),- (14 , happyReduce_14),- (15 , happyReduce_15),- (16 , happyReduce_16),- (17 , happyReduce_17),- (18 , happyReduce_18),- (19 , happyReduce_19),- (20 , happyReduce_20),- (21 , happyReduce_21),- (22 , happyReduce_22),- (23 , happyReduce_23),- (24 , happyReduce_24),- (25 , happyReduce_25),- (26 , happyReduce_26),- (27 , happyReduce_27),- (28 , happyReduce_28),- (29 , happyReduce_29),- (30 , happyReduce_30),- (31 , happyReduce_31),- (32 , happyReduce_32),- (33 , happyReduce_33),- (34 , happyReduce_34),- (35 , happyReduce_35),- (36 , happyReduce_36),- (37 , happyReduce_37),- (38 , happyReduce_38),- (39 , happyReduce_39),- (40 , happyReduce_40),- (41 , happyReduce_41),- (42 , happyReduce_42),- (43 , happyReduce_43),- (44 , happyReduce_44),- (45 , happyReduce_45),- (46 , happyReduce_46),- (47 , happyReduce_47),- (48 , happyReduce_48),- (49 , happyReduce_49),- (50 , happyReduce_50),- (51 , happyReduce_51),- (52 , happyReduce_52),- (53 , happyReduce_53),- (54 , happyReduce_54),- (55 , happyReduce_55),- (56 , happyReduce_56),- (57 , happyReduce_57),- (58 , happyReduce_58),- (59 , happyReduce_59),- (60 , happyReduce_60),- (61 , happyReduce_61),- (62 , happyReduce_62),- (63 , happyReduce_63),- (64 , happyReduce_64),- (65 , happyReduce_65),- (66 , happyReduce_66),- (67 , happyReduce_67),- (68 , happyReduce_68),- (69 , happyReduce_69),- (70 , happyReduce_70),- (71 , happyReduce_71),- (72 , happyReduce_72),- (73 , happyReduce_73),- (74 , happyReduce_74),- (75 , happyReduce_75),- (76 , happyReduce_76),- (77 , happyReduce_77),- (78 , happyReduce_78),- (79 , happyReduce_79),- (80 , happyReduce_80),- (81 , happyReduce_81),- (82 , happyReduce_82),- (83 , happyReduce_83),- (84 , happyReduce_84),- (85 , happyReduce_85),- (86 , happyReduce_86),- (87 , happyReduce_87),- (88 , happyReduce_88),- (89 , happyReduce_89),- (90 , happyReduce_90),- (91 , happyReduce_91),- (92 , happyReduce_92),- (93 , happyReduce_93),- (94 , happyReduce_94),- (95 , happyReduce_95),- (96 , happyReduce_96),- (97 , happyReduce_97),- (98 , happyReduce_98),- (99 , happyReduce_99),- (100 , happyReduce_100),- (101 , happyReduce_101),- (102 , happyReduce_102),- (103 , happyReduce_103),- (104 , happyReduce_104),- (105 , happyReduce_105),- (106 , happyReduce_106),- (107 , happyReduce_107),- (108 , happyReduce_108),- (109 , happyReduce_109),- (110 , happyReduce_110),- (111 , happyReduce_111),- (112 , happyReduce_112),- (113 , happyReduce_113),- (114 , happyReduce_114),- (115 , happyReduce_115),- (116 , happyReduce_116),- (117 , happyReduce_117),- (118 , happyReduce_118),- (119 , happyReduce_119),- (120 , happyReduce_120),- (121 , happyReduce_121),- (122 , happyReduce_122),- (123 , happyReduce_123),- (124 , happyReduce_124),- (125 , happyReduce_125),- (126 , happyReduce_126),- (127 , happyReduce_127),- (128 , happyReduce_128),- (129 , happyReduce_129),- (130 , happyReduce_130),- (131 , happyReduce_131),- (132 , happyReduce_132),- (133 , happyReduce_133),- (134 , happyReduce_134),- (135 , happyReduce_135),- (136 , happyReduce_136),- (137 , happyReduce_137),- (138 , happyReduce_138),- (139 , happyReduce_139),- (140 , happyReduce_140),- (141 , happyReduce_141),- (142 , happyReduce_142),- (143 , happyReduce_143),- (144 , happyReduce_144),- (145 , happyReduce_145),- (146 , happyReduce_146),- (147 , happyReduce_147),- (148 , happyReduce_148),- (149 , happyReduce_149),- (150 , happyReduce_150),- (151 , happyReduce_151),- (152 , happyReduce_152),- (153 , happyReduce_153),- (154 , happyReduce_154),- (155 , happyReduce_155),- (156 , happyReduce_156),- (157 , happyReduce_157),- (158 , happyReduce_158),- (159 , happyReduce_159),- (160 , happyReduce_160),- (161 , happyReduce_161),- (162 , happyReduce_162),- (163 , happyReduce_163),- (164 , happyReduce_164),- (165 , happyReduce_165),- (166 , happyReduce_166),- (167 , happyReduce_167),- (168 , happyReduce_168),- (169 , happyReduce_169),- (170 , happyReduce_170),- (171 , happyReduce_171),- (172 , happyReduce_172),- (173 , happyReduce_173),- (174 , happyReduce_174),- (175 , happyReduce_175),- (176 , happyReduce_176),- (177 , happyReduce_177),- (178 , happyReduce_178),- (179 , happyReduce_179),- (180 , happyReduce_180),- (181 , happyReduce_181),- (182 , happyReduce_182),- (183 , happyReduce_183),- (184 , happyReduce_184),- (185 , happyReduce_185),- (186 , happyReduce_186),- (187 , happyReduce_187),- (188 , happyReduce_188),- (189 , happyReduce_189),- (190 , happyReduce_190),- (191 , happyReduce_191),- (192 , happyReduce_192),- (193 , happyReduce_193),- (194 , happyReduce_194),- (195 , happyReduce_195),- (196 , happyReduce_196),- (197 , happyReduce_197),- (198 , happyReduce_198),- (199 , happyReduce_199),- (200 , happyReduce_200),- (201 , happyReduce_201),- (202 , happyReduce_202),- (203 , happyReduce_203),- (204 , happyReduce_204),- (205 , happyReduce_205),- (206 , happyReduce_206),- (207 , happyReduce_207),- (208 , happyReduce_208),- (209 , happyReduce_209),- (210 , happyReduce_210),- (211 , happyReduce_211),- (212 , happyReduce_212),- (213 , happyReduce_213),- (214 , happyReduce_214),- (215 , happyReduce_215),- (216 , happyReduce_216),- (217 , happyReduce_217),- (218 , happyReduce_218),- (219 , happyReduce_219),- (220 , happyReduce_220),- (221 , happyReduce_221),- (222 , happyReduce_222),- (223 , happyReduce_223),- (224 , happyReduce_224),- (225 , happyReduce_225),- (226 , happyReduce_226),- (227 , happyReduce_227),- (228 , happyReduce_228),- (229 , happyReduce_229),- (230 , happyReduce_230),- (231 , happyReduce_231),- (232 , happyReduce_232),- (233 , happyReduce_233),- (234 , happyReduce_234),- (235 , happyReduce_235),- (236 , happyReduce_236),- (237 , happyReduce_237),- (238 , happyReduce_238),- (239 , happyReduce_239),- (240 , happyReduce_240),- (241 , happyReduce_241),- (242 , happyReduce_242),- (243 , happyReduce_243),- (244 , happyReduce_244),- (245 , happyReduce_245),- (246 , happyReduce_246),- (247 , happyReduce_247),- (248 , happyReduce_248),- (249 , happyReduce_249),- (250 , happyReduce_250),- (251 , happyReduce_251),- (252 , happyReduce_252),- (253 , happyReduce_253),- (254 , happyReduce_254),- (255 , happyReduce_255),- (256 , happyReduce_256),- (257 , happyReduce_257),- (258 , happyReduce_258),- (259 , happyReduce_259),- (260 , happyReduce_260),- (261 , happyReduce_261),- (262 , happyReduce_262),- (263 , happyReduce_263),- (264 , happyReduce_264),- (265 , happyReduce_265),- (266 , happyReduce_266),- (267 , happyReduce_267),- (268 , happyReduce_268),- (269 , happyReduce_269),- (270 , happyReduce_270),- (271 , happyReduce_271),- (272 , happyReduce_272),- (273 , happyReduce_273),- (274 , happyReduce_274),- (275 , happyReduce_275),- (276 , happyReduce_276),- (277 , happyReduce_277),- (278 , happyReduce_278),- (279 , happyReduce_279),- (280 , happyReduce_280),- (281 , happyReduce_281),- (282 , happyReduce_282),- (283 , happyReduce_283),- (284 , happyReduce_284),- (285 , happyReduce_285),- (286 , happyReduce_286),- (287 , happyReduce_287),- (288 , happyReduce_288),- (289 , happyReduce_289),- (290 , happyReduce_290),- (291 , happyReduce_291),- (292 , happyReduce_292),- (293 , happyReduce_293),- (294 , happyReduce_294),- (295 , happyReduce_295),- (296 , happyReduce_296),- (297 , happyReduce_297),- (298 , happyReduce_298),- (299 , happyReduce_299),- (300 , happyReduce_300),- (301 , happyReduce_301),- (302 , happyReduce_302),- (303 , happyReduce_303),- (304 , happyReduce_304),- (305 , happyReduce_305),- (306 , happyReduce_306),- (307 , happyReduce_307),- (308 , happyReduce_308),- (309 , happyReduce_309),- (310 , happyReduce_310),- (311 , happyReduce_311),- (312 , happyReduce_312),- (313 , happyReduce_313),- (314 , happyReduce_314),- (315 , happyReduce_315),- (316 , happyReduce_316),- (317 , happyReduce_317),- (318 , happyReduce_318),- (319 , happyReduce_319),- (320 , happyReduce_320),- (321 , happyReduce_321),- (322 , happyReduce_322),- (323 , happyReduce_323),- (324 , happyReduce_324),- (325 , happyReduce_325),- (326 , happyReduce_326),- (327 , happyReduce_327),- (328 , happyReduce_328),- (329 , happyReduce_329),- (330 , happyReduce_330),- (331 , happyReduce_331),- (332 , happyReduce_332),- (333 , happyReduce_333),- (334 , happyReduce_334),- (335 , happyReduce_335),- (336 , happyReduce_336),- (337 , happyReduce_337),- (338 , happyReduce_338),- (339 , happyReduce_339),- (340 , happyReduce_340),- (341 , happyReduce_341),- (342 , happyReduce_342),- (343 , happyReduce_343),- (344 , happyReduce_344),- (345 , happyReduce_345),- (346 , happyReduce_346),- (347 , happyReduce_347),- (348 , happyReduce_348),- (349 , happyReduce_349),- (350 , happyReduce_350),- (351 , happyReduce_351),- (352 , happyReduce_352),- (353 , happyReduce_353),- (354 , happyReduce_354),- (355 , happyReduce_355),- (356 , happyReduce_356),- (357 , happyReduce_357),- (358 , happyReduce_358),- (359 , happyReduce_359),- (360 , happyReduce_360),- (361 , happyReduce_361),- (362 , happyReduce_362),- (363 , happyReduce_363),- (364 , happyReduce_364),- (365 , happyReduce_365),- (366 , happyReduce_366),- (367 , happyReduce_367),- (368 , happyReduce_368),- (369 , happyReduce_369),- (370 , happyReduce_370)- ]--happy_n_terms = 77 :: Int-happy_n_nonterms = 127 :: Int--happyReduce_3 = happySpecReduce_1 0# happyReduction_3-happyReduction_3 happy_x_1- = case happyOut7 happy_x_1 of { happy_var_1 -> - happyIn6- (reverse happy_var_1- )}--happyReduce_4 = happySpecReduce_2 1# happyReduction_4-happyReduction_4 happy_x_2- happy_x_1- = case happyOut7 happy_x_1 of { happy_var_1 -> - case happyOut8 happy_x_2 of { happy_var_2 -> - happyIn7- (happy_var_2 : happy_var_1- )}}--happyReduce_5 = happySpecReduce_0 1# happyReduction_5-happyReduction_5 = happyIn7- ([]- )--happyReduce_6 = happySpecReduce_1 2# happyReduction_6-happyReduction_6 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> - happyIn8- (TokKeyword KwLet happy_var_1- )}--happyReduce_7 = happySpecReduce_1 2# happyReduction_7-happyReduction_7 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwIn happy_var_1) -> - happyIn8- (TokKeyword KwIn happy_var_1- )}--happyReduce_8 = happySpecReduce_1 2# happyReduction_8-happyReduction_8 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwWhere happy_var_1) -> - happyIn8- (TokKeyword KwWhere happy_var_1- )}--happyReduce_9 = happySpecReduce_1 2# happyReduction_9-happyReduction_9 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwWith happy_var_1) -> - happyIn8- (TokKeyword KwWith happy_var_1- )}--happyReduce_10 = happySpecReduce_1 2# happyReduction_10-happyReduction_10 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwRewrite happy_var_1) -> - happyIn8- (TokKeyword KwRewrite happy_var_1- )}--happyReduce_11 = happySpecReduce_1 2# happyReduction_11-happyReduction_11 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> - happyIn8- (TokKeyword KwPostulate happy_var_1- )}--happyReduce_12 = happySpecReduce_1 2# happyReduction_12-happyReduction_12 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> - happyIn8- (TokKeyword KwPrimitive happy_var_1- )}--happyReduce_13 = happySpecReduce_1 2# happyReduction_13-happyReduction_13 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - happyIn8- (TokKeyword KwOpen happy_var_1- )}--happyReduce_14 = happySpecReduce_1 2# happyReduction_14-happyReduction_14 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> - happyIn8- (TokKeyword KwImport happy_var_1- )}--happyReduce_15 = happySpecReduce_1 2# happyReduction_15-happyReduction_15 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> - happyIn8- (TokKeyword KwUsing happy_var_1- )}--happyReduce_16 = happySpecReduce_1 2# happyReduction_16-happyReduction_16 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> - happyIn8- (TokKeyword KwHiding happy_var_1- )}--happyReduce_17 = happySpecReduce_1 2# happyReduction_17-happyReduction_17 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> - happyIn8- (TokKeyword KwRenaming happy_var_1- )}--happyReduce_18 = happySpecReduce_1 2# happyReduction_18-happyReduction_18 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwTo happy_var_1) -> - happyIn8- (TokKeyword KwTo happy_var_1- )}--happyReduce_19 = happySpecReduce_1 2# happyReduction_19-happyReduction_19 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> - happyIn8- (TokKeyword KwPublic happy_var_1- )}--happyReduce_20 = happySpecReduce_1 2# happyReduction_20-happyReduction_20 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> - happyIn8- (TokKeyword KwModule happy_var_1- )}--happyReduce_21 = happySpecReduce_1 2# happyReduction_21-happyReduction_21 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> - happyIn8- (TokKeyword KwData happy_var_1- )}--happyReduce_22 = happySpecReduce_1 2# happyReduction_22-happyReduction_22 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> - happyIn8- (TokKeyword KwCoData happy_var_1- )}--happyReduce_23 = happySpecReduce_1 2# happyReduction_23-happyReduction_23 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - happyIn8- (TokKeyword KwRecord happy_var_1- )}--happyReduce_24 = happySpecReduce_1 2# happyReduction_24-happyReduction_24 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwConstructor happy_var_1) -> - happyIn8- (TokKeyword KwConstructor happy_var_1- )}--happyReduce_25 = happySpecReduce_1 2# happyReduction_25-happyReduction_25 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwField happy_var_1) -> - happyIn8- (TokKeyword KwField happy_var_1- )}--happyReduce_26 = happySpecReduce_1 2# happyReduction_26-happyReduction_26 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> - happyIn8- (TokKeyword KwInfix happy_var_1- )}--happyReduce_27 = happySpecReduce_1 2# happyReduction_27-happyReduction_27 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> - happyIn8- (TokKeyword KwInfixL happy_var_1- )}--happyReduce_28 = happySpecReduce_1 2# happyReduction_28-happyReduction_28 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> - happyIn8- (TokKeyword KwInfixR happy_var_1- )}--happyReduce_29 = happySpecReduce_1 2# happyReduction_29-happyReduction_29 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> - happyIn8- (TokKeyword KwMutual happy_var_1- )}--happyReduce_30 = happySpecReduce_1 2# happyReduction_30-happyReduction_30 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> - happyIn8- (TokKeyword KwAbstract happy_var_1- )}--happyReduce_31 = happySpecReduce_1 2# happyReduction_31-happyReduction_31 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> - happyIn8- (TokKeyword KwPrivate happy_var_1- )}--happyReduce_32 = happySpecReduce_1 2# happyReduction_32-happyReduction_32 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> - happyIn8- (TokKeyword KwProp happy_var_1- )}--happyReduce_33 = happySpecReduce_1 2# happyReduction_33-happyReduction_33 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> - happyIn8- (TokKeyword KwSet happy_var_1- )}--happyReduce_34 = happySpecReduce_1 2# happyReduction_34-happyReduction_34 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwForall happy_var_1) -> - happyIn8- (TokKeyword KwForall happy_var_1- )}--happyReduce_35 = happySpecReduce_1 2# happyReduction_35-happyReduction_35 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwSyntax happy_var_1) -> - happyIn8- (TokKeyword KwSyntax happy_var_1- )}--happyReduce_36 = happySpecReduce_1 2# happyReduction_36-happyReduction_36 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwOPTIONS happy_var_1) -> - happyIn8- (TokKeyword KwOPTIONS happy_var_1- )}--happyReduce_37 = happySpecReduce_1 2# happyReduction_37-happyReduction_37 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwBUILTIN happy_var_1) -> - happyIn8- (TokKeyword KwBUILTIN happy_var_1- )}--happyReduce_38 = happySpecReduce_1 2# happyReduction_38-happyReduction_38 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwIMPORT happy_var_1) -> - happyIn8- (TokKeyword KwIMPORT happy_var_1- )}--happyReduce_39 = happySpecReduce_1 2# happyReduction_39-happyReduction_39 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED happy_var_1) -> - happyIn8- (TokKeyword KwCOMPILED happy_var_1- )}--happyReduce_40 = happySpecReduce_1 2# happyReduction_40-happyReduction_40 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_DATA happy_var_1) -> - happyIn8- (TokKeyword KwCOMPILED_DATA happy_var_1- )}--happyReduce_41 = happySpecReduce_1 2# happyReduction_41-happyReduction_41 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_TYPE happy_var_1) -> - happyIn8- (TokKeyword KwCOMPILED_TYPE happy_var_1- )}--happyReduce_42 = happySpecReduce_1 2# happyReduction_42-happyReduction_42 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_EPIC happy_var_1) -> - happyIn8- (TokKeyword KwCOMPILED_EPIC happy_var_1- )}--happyReduce_43 = happySpecReduce_1 2# happyReduction_43-happyReduction_43 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_JS happy_var_1) -> - happyIn8- (TokKeyword KwCOMPILED_JS happy_var_1- )}--happyReduce_44 = happySpecReduce_1 2# happyReduction_44-happyReduction_44 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwSTATIC happy_var_1) -> - happyIn8- (TokKeyword KwSTATIC happy_var_1- )}--happyReduce_45 = happySpecReduce_1 2# happyReduction_45-happyReduction_45 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwIMPOSSIBLE happy_var_1) -> - happyIn8- (TokKeyword KwIMPOSSIBLE happy_var_1- )}--happyReduce_46 = happySpecReduce_1 2# happyReduction_46-happyReduction_46 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwETA happy_var_1) -> - happyIn8- (TokKeyword KwETA happy_var_1- )}--happyReduce_47 = happySpecReduce_1 2# happyReduction_47-happyReduction_47 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> - happyIn8- (TokKeyword KwQuoteGoal happy_var_1- )}--happyReduce_48 = happySpecReduce_1 2# happyReduction_48-happyReduction_48 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> - happyIn8- (TokKeyword KwQuote happy_var_1- )}--happyReduce_49 = happySpecReduce_1 2# happyReduction_49-happyReduction_49 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> - happyIn8- (TokKeyword KwQuoteTerm happy_var_1- )}--happyReduce_50 = happySpecReduce_1 2# happyReduction_50-happyReduction_50 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> - happyIn8- (TokKeyword KwUnquote happy_var_1- )}--happyReduce_51 = happySpecReduce_1 2# happyReduction_51-happyReduction_51 happy_x_1- = case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> - happyIn8- (TokSetN happy_var_1- )}--happyReduce_52 = happySpecReduce_1 2# happyReduction_52-happyReduction_52 happy_x_1- = case happyOutTok happy_x_1 of { (TokTeX happy_var_1) -> - happyIn8- (TokTeX happy_var_1- )}--happyReduce_53 = happySpecReduce_1 2# happyReduction_53-happyReduction_53 happy_x_1- = case happyOutTok happy_x_1 of { (TokComment happy_var_1) -> - happyIn8- (TokComment happy_var_1- )}--happyReduce_54 = happySpecReduce_1 2# happyReduction_54-happyReduction_54 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> - happyIn8- (TokSymbol SymEllipsis happy_var_1- )}--happyReduce_55 = happySpecReduce_1 2# happyReduction_55-happyReduction_55 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> - happyIn8- (TokSymbol SymDotDot happy_var_1- )}--happyReduce_56 = happySpecReduce_1 2# happyReduction_56-happyReduction_56 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> - happyIn8- (TokSymbol SymDot happy_var_1- )}--happyReduce_57 = happySpecReduce_1 2# happyReduction_57-happyReduction_57 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> - happyIn8- (TokSymbol SymSemi happy_var_1- )}--happyReduce_58 = happySpecReduce_1 2# happyReduction_58-happyReduction_58 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymColon happy_var_1) -> - happyIn8- (TokSymbol SymColon happy_var_1- )}--happyReduce_59 = happySpecReduce_1 2# happyReduction_59-happyReduction_59 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymEqual happy_var_1) -> - happyIn8- (TokSymbol SymEqual happy_var_1- )}--happyReduce_60 = happySpecReduce_1 2# happyReduction_60-happyReduction_60 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn8- (TokSymbol SymUnderscore happy_var_1- )}--happyReduce_61 = happySpecReduce_1 2# happyReduction_61-happyReduction_61 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> - happyIn8- (TokSymbol SymQuestionMark happy_var_1- )}--happyReduce_62 = happySpecReduce_1 2# happyReduction_62-happyReduction_62 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymArrow happy_var_1) -> - happyIn8- (TokSymbol SymArrow happy_var_1- )}--happyReduce_63 = happySpecReduce_1 2# happyReduction_63-happyReduction_63 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - happyIn8- (TokSymbol SymLambda happy_var_1- )}--happyReduce_64 = happySpecReduce_1 2# happyReduction_64-happyReduction_64 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> - happyIn8- (TokSymbol SymAs happy_var_1- )}--happyReduce_65 = happySpecReduce_1 2# happyReduction_65-happyReduction_65 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymBar happy_var_1) -> - happyIn8- (TokSymbol SymBar happy_var_1- )}--happyReduce_66 = happySpecReduce_1 2# happyReduction_66-happyReduction_66 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - happyIn8- (TokSymbol SymOpenParen happy_var_1- )}--happyReduce_67 = happySpecReduce_1 2# happyReduction_67-happyReduction_67 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymCloseParen happy_var_1) -> - happyIn8- (TokSymbol SymCloseParen happy_var_1- )}--happyReduce_68 = happySpecReduce_1 2# happyReduction_68-happyReduction_68 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - happyIn8- (TokSymbol SymDoubleOpenBrace happy_var_1- )}--happyReduce_69 = happySpecReduce_1 2# happyReduction_69-happyReduction_69 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> - happyIn8- (TokSymbol SymDoubleCloseBrace happy_var_1- )}--happyReduce_70 = happySpecReduce_1 2# happyReduction_70-happyReduction_70 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - happyIn8- (TokSymbol SymOpenBrace happy_var_1- )}--happyReduce_71 = happySpecReduce_1 2# happyReduction_71-happyReduction_71 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> - happyIn8- (TokSymbol SymCloseBrace happy_var_1- )}--happyReduce_72 = happySpecReduce_1 2# happyReduction_72-happyReduction_72 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenVirtualBrace happy_var_1) -> - happyIn8- (TokSymbol SymOpenVirtualBrace happy_var_1- )}--happyReduce_73 = happySpecReduce_1 2# happyReduction_73-happyReduction_73 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymCloseVirtualBrace happy_var_1) -> - happyIn8- (TokSymbol SymCloseVirtualBrace happy_var_1- )}--happyReduce_74 = happySpecReduce_1 2# happyReduction_74-happyReduction_74 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> - happyIn8- (TokSymbol SymVirtualSemi happy_var_1- )}--happyReduce_75 = happySpecReduce_1 2# happyReduction_75-happyReduction_75 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - happyIn8- (TokSymbol SymOpenPragma happy_var_1- )}--happyReduce_76 = happySpecReduce_1 2# happyReduction_76-happyReduction_76 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymClosePragma happy_var_1) -> - happyIn8- (TokSymbol SymClosePragma happy_var_1- )}--happyReduce_77 = happySpecReduce_1 2# happyReduction_77-happyReduction_77 happy_x_1- = case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - happyIn8- (TokId happy_var_1- )}--happyReduce_78 = happySpecReduce_1 2# happyReduction_78-happyReduction_78 happy_x_1- = case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> - happyIn8- (TokQId happy_var_1- )}--happyReduce_79 = happySpecReduce_1 2# happyReduction_79-happyReduction_79 happy_x_1- = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - happyIn8- (TokString happy_var_1- )}--happyReduce_80 = happySpecReduce_1 2# happyReduction_80-happyReduction_80 happy_x_1- = case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> - happyIn8- (TokLiteral happy_var_1- )}--happyReduce_81 = happySpecReduce_1 3# happyReduction_81-happyReduction_81 happy_x_1- = case happyOut10 happy_x_1 of { happy_var_1 -> - happyIn9- (happy_var_1- )}--happyReduce_82 = happySpecReduce_1 4# happyReduction_82-happyReduction_82 happy_x_1- = case happyOut106 happy_x_1 of { happy_var_1 -> - happyIn10- (([], happy_var_1)- )}--happyReduce_83 = happySpecReduce_2 4# happyReduction_83-happyReduction_83 happy_x_2- happy_x_1- = case happyOut109 happy_x_1 of { happy_var_1 -> - case happyOut10 happy_x_2 of { happy_var_2 -> - happyIn10- (let (ps,m) = happy_var_2 in (happy_var_1 : ps, m)- )}}--happyReduce_84 = happySpecReduce_1 5# happyReduction_84-happyReduction_84 happy_x_1- = happyIn11- (()- )--happyReduce_85 = happyMonadReduce 1# 5# happyReduction_85-happyReduction_85 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (( popContext)- ) (\r -> happyReturn (happyIn11 r))--happyReduce_86 = happySpecReduce_1 6# happyReduction_86-happyReduction_86 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> - happyIn12- (happy_var_1- )}--happyReduce_87 = happySpecReduce_1 6# happyReduction_87-happyReduction_87 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> - happyIn12- (happy_var_1- )}--happyReduce_88 = happyMonadReduce 0# 7# happyReduction_88-happyReduction_88 (happyRest) tk- = happyThen (( pushLexState imp_dir)- ) (\r -> happyReturn (happyIn13 r))--happyReduce_89 = happyMonadReduce 1# 8# happyReduction_89-happyReduction_89 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> - ( case happy_var_1 of {- LitInt _ n -> return n;- _ -> fail $ "Expected integer"- })}- ) (\r -> happyReturn (happyIn14 r))--happyReduce_90 = happyMonadReduce 1# 9# happyReduction_90-happyReduction_90 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - ( mkName happy_var_1)}- ) (\r -> happyReturn (happyIn15 r))--happyReduce_91 = happySpecReduce_2 10# happyReduction_91-happyReduction_91 happy_x_2- happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - case happyOut16 happy_x_2 of { happy_var_2 -> - happyIn16- (happy_var_1 : happy_var_2- )}}--happyReduce_92 = happySpecReduce_1 10# happyReduction_92-happyReduction_92 happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn16- ([happy_var_1]- )}--happyReduce_93 = happySpecReduce_1 11# happyReduction_93-happyReduction_93 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> - happyIn17- (getRange happy_var_1- )}--happyReduce_94 = happyMonadReduce 2# 11# happyReduction_94-happyReduction_94 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> - (- if posPos (fromJust (rEnd (getRange happy_var_2))) -- posPos (fromJust (rStart (getRange happy_var_1))) > 2- then parseErrorAt (fromJust (rStart (getRange happy_var_2)))- "Expecting '}}', found separated '}'s."- else return $ fuseRange (getRange happy_var_1) (getRange (happy_var_2)))}}- ) (\r -> happyReturn (happyIn17 r))--happyReduce_95 = happySpecReduce_2 12# happyReduction_95-happyReduction_95 happy_x_2- happy_x_1- = case happyOut15 happy_x_2 of { happy_var_2 -> - happyIn18- (Arg NotHidden Irrelevant happy_var_2- )}--happyReduce_96 = happySpecReduce_1 12# happyReduction_96-happyReduction_96 happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn18- (defaultArg happy_var_1- )}--happyReduce_97 = happySpecReduce_2 13# happyReduction_97-happyReduction_97 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn19- (happy_var_1 : happy_var_2- )}}--happyReduce_98 = happySpecReduce_1 13# happyReduction_98-happyReduction_98 happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn19- ([happy_var_1]- )}--happyReduce_99 = happySpecReduce_2 14# happyReduction_99-happyReduction_99 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_2 of { happy_var_2 -> - happyIn20- (happy_var_1 : happy_var_2- )}}--happyReduce_100 = happySpecReduce_1 14# happyReduction_100-happyReduction_100 happy_x_1- = case happyOut18 happy_x_1 of { happy_var_1 -> - happyIn20- ([happy_var_1]- )}--happyReduce_101 = happyReduce 4# 14# happyReduction_101-happyReduction_101 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut20 happy_x_4 of { happy_var_4 -> - happyIn20- (map makeInstance happy_var_2 ++ happy_var_4- ) `HappyStk` happyRest}}--happyReduce_102 = happySpecReduce_3 14# happyReduction_102-happyReduction_102 happy_x_3- happy_x_2- happy_x_1- = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn20- (map makeInstance happy_var_2- )}--happyReduce_103 = happyReduce 4# 14# happyReduction_103-happyReduction_103 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut20 happy_x_4 of { happy_var_4 -> - happyIn20- (map hide happy_var_2 ++ happy_var_4- ) `HappyStk` happyRest}}--happyReduce_104 = happySpecReduce_3 14# happyReduction_104-happyReduction_104 happy_x_3- happy_x_2- happy_x_1- = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn20- (map hide happy_var_2- )}--happyReduce_105 = happyReduce 5# 14# happyReduction_105-happyReduction_105 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn20- (map (Arg Hidden Irrelevant) happy_var_3 ++ happy_var_5- ) `HappyStk` happyRest}}--happyReduce_106 = happyReduce 4# 14# happyReduction_106-happyReduction_106 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - happyIn20- (map (Arg Hidden Irrelevant) happy_var_3- ) `HappyStk` happyRest}--happyReduce_107 = happyReduce 5# 14# happyReduction_107-happyReduction_107 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn20- (map (Arg Instance Irrelevant) happy_var_3 ++ happy_var_5- ) `HappyStk` happyRest}}--happyReduce_108 = happyReduce 4# 14# happyReduction_108-happyReduction_108 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - happyIn20- (map (Arg Instance Irrelevant) happy_var_3- ) `HappyStk` happyRest}--happyReduce_109 = happyReduce 5# 14# happyReduction_109-happyReduction_109 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn20- (map (Arg Hidden NonStrict) happy_var_3 ++ happy_var_5- ) `HappyStk` happyRest}}--happyReduce_110 = happyReduce 4# 14# happyReduction_110-happyReduction_110 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - happyIn20- (map (Arg Hidden NonStrict) happy_var_3- ) `HappyStk` happyRest}--happyReduce_111 = happyReduce 5# 14# happyReduction_111-happyReduction_111 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - case happyOut20 happy_x_5 of { happy_var_5 -> - happyIn20- (map (Arg Instance NonStrict) happy_var_3 ++ happy_var_5- ) `HappyStk` happyRest}}--happyReduce_112 = happyReduce 4# 14# happyReduction_112-happyReduction_112 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut16 happy_x_3 of { happy_var_3 -> - happyIn20- (map (Arg Instance NonStrict) happy_var_3- ) `HappyStk` happyRest}--happyReduce_113 = happyMonadReduce 1# 15# happyReduction_113-happyReduction_113 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> - ( mkQName happy_var_1)}- ) (\r -> happyReturn (happyIn21 r))--happyReduce_114 = happySpecReduce_1 15# happyReduction_114-happyReduction_114 happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn21- (QName happy_var_1- )}--happyReduce_115 = happySpecReduce_1 16# happyReduction_115-happyReduction_115 happy_x_1- = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn22- (happy_var_1- )}--happyReduce_116 = happySpecReduce_1 17# happyReduction_116-happyReduction_116 happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn23- (happy_var_1- )}--happyReduce_117 = happySpecReduce_1 17# happyReduction_117-happyReduction_117 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn23- (Name (getRange happy_var_1) [Hole]- )}--happyReduce_118 = happySpecReduce_2 18# happyReduction_118-happyReduction_118 happy_x_2- happy_x_1- = case happyOut23 happy_x_1 of { happy_var_1 -> - case happyOut24 happy_x_2 of { happy_var_2 -> - happyIn24- (happy_var_1 : happy_var_2- )}}--happyReduce_119 = happySpecReduce_1 18# happyReduction_119-happyReduction_119 happy_x_1- = case happyOut23 happy_x_1 of { happy_var_1 -> - happyIn24- ([happy_var_1]- )}--happyReduce_120 = happySpecReduce_1 19# happyReduction_120-happyReduction_120 happy_x_1- = case happyOut26 happy_x_1 of { happy_var_1 -> - happyIn25- (case happy_var_1 of- Left ns -> ns- Right _ -> fail $ "expected sequence of bound identifiers, not absurd pattern"- )}--happyReduce_121 = happyMonadReduce 1# 20# happyReduction_121-happyReduction_121 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> - (- let getName (Ident (QName x)) = Just x- getName (Underscore r _) = Just (Name r [Hole])- getName _ = Nothing-- containsAbsurd (Absurd _) = True- containsAbsurd (HiddenArg _ (Named _ e)) = containsAbsurd e- containsAbsurd (InstanceArg _ (Named _ e)) = containsAbsurd e- containsAbsurd (Paren _ expr) = containsAbsurd expr- containsAbsurd (RawApp _ exprs) = any containsAbsurd exprs- containsAbsurd _ = False- in- if isJust $ find containsAbsurd happy_var_1 then return $ Right happy_var_1 else- case partition isJust $ map getName happy_var_1 of- (good, []) -> return $ Left $ map fromJust good- _ -> fail $ "expected sequence of bound identifiers")}- ) (\r -> happyReturn (happyIn26 r))--happyReduce_122 = happySpecReduce_0 21# happyReduction_122-happyReduction_122 = happyIn27- ([]- )--happyReduce_123 = happySpecReduce_2 21# happyReduction_123-happyReduction_123 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - case happyOut27 happy_x_2 of { happy_var_2 -> - happyIn27- (snd happy_var_1 : happy_var_2- )}}--happyReduce_124 = happyMonadReduce 1# 22# happyReduction_124-happyReduction_124 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - ( fmap QName (mkName happy_var_1))}- ) (\r -> happyReturn (happyIn28 r))--happyReduce_125 = happySpecReduce_2 23# happyReduction_125-happyReduction_125 happy_x_2- happy_x_1- = case happyOut41 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_2 of { happy_var_2 -> - happyIn29- (Pi happy_var_1 happy_var_2- )}}--happyReduce_126 = happySpecReduce_3 23# happyReduction_126-happyReduction_126 happy_x_3- happy_x_2- happy_x_1- = case happyOut54 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn29- (forallPi happy_var_2 happy_var_3- )}}--happyReduce_127 = happySpecReduce_3 23# happyReduction_127-happyReduction_127 happy_x_3- happy_x_2- happy_x_1- = case happyOut34 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn29- (Fun (fuseRange happy_var_1 happy_var_3) (RawApp (getRange happy_var_1) happy_var_1) happy_var_3- )}}--happyReduce_128 = happySpecReduce_1 23# happyReduction_128-happyReduction_128 happy_x_1- = case happyOut30 happy_x_1 of { happy_var_1 -> - happyIn29- (happy_var_1- )}--happyReduce_129 = happyMonadReduce 1# 24# happyReduction_129-happyReduction_129 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut31 happy_x_1 of { happy_var_1 -> - ( case happy_var_1 of- { [e] -> return e- ; e : es -> return $ WithApp (fuseRange e es) e es- ; [] -> fail "impossible: empty with expressions"- })}- ) (\r -> happyReturn (happyIn30 r))--happyReduce_130 = happySpecReduce_3 25# happyReduction_130-happyReduction_130 happy_x_3- happy_x_2- happy_x_1- = case happyOut34 happy_x_1 of { happy_var_1 -> - case happyOut31 happy_x_3 of { happy_var_3 -> - happyIn31- (RawApp (getRange happy_var_1) happy_var_1 : happy_var_3- )}}--happyReduce_131 = happySpecReduce_1 25# happyReduction_131-happyReduction_131 happy_x_1- = case happyOut32 happy_x_1 of { happy_var_1 -> - happyIn31- ([RawApp (getRange happy_var_1) happy_var_1]- )}--happyReduce_132 = happySpecReduce_1 26# happyReduction_132-happyReduction_132 happy_x_1- = case happyOut33 happy_x_1 of { happy_var_1 -> - happyIn32- ([happy_var_1]- )}--happyReduce_133 = happySpecReduce_2 26# happyReduction_133-happyReduction_133 happy_x_2- happy_x_1- = case happyOut37 happy_x_1 of { happy_var_1 -> - case happyOut32 happy_x_2 of { happy_var_2 -> - happyIn32- (happy_var_1 : happy_var_2- )}}--happyReduce_134 = happySpecReduce_3 27# happyReduction_134-happyReduction_134 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - case happyOut46 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn33- (Lam (fuseRange happy_var_1 happy_var_3) happy_var_2 happy_var_3- )}}}--happyReduce_135 = happyReduce 4# 27# happyReduction_135-happyReduction_135 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut53 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn33- (ExtendedLam (fuseRange happy_var_1 (fuseRange happy_var_2 happy_var_4)) (reverse happy_var_3)- ) `HappyStk` happyRest}}}}--happyReduce_136 = happyMonadReduce 2# 27# happyReduction_136-happyReduction_136 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - case happyOut47 happy_x_2 of { happy_var_2 -> - ( case happy_var_2 of- Left (bs, h) -> if null bs then return $ AbsurdLam r h else- return $ Lam r bs (AbsurdLam r h)- where r = fuseRange happy_var_1 bs- Right es -> do -- it is of the form @\ { p1 ... () }@- p <- exprToLHS (RawApp (getRange es) es);- return $ ExtendedLam (fuseRange happy_var_1 es)- [(p [] [], AbsurdRHS, NoWhere)])}}- ) (\r -> happyReturn (happyIn33 r))--happyReduce_137 = happyReduce 4# 27# happyReduction_137-happyReduction_137 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> - case happyOut130 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - happyIn33- (Let (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4- ) `HappyStk` happyRest}}}--happyReduce_138 = happySpecReduce_1 27# happyReduction_138-happyReduction_138 happy_x_1- = case happyOut37 happy_x_1 of { happy_var_1 -> - happyIn33- (happy_var_1- )}--happyReduce_139 = happyReduce 4# 27# happyReduction_139-happyReduction_139 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - happyIn33- (QuoteGoal (getRange (happy_var_1,happy_var_4)) happy_var_2 happy_var_4- ) `HappyStk` happyRest}}}--happyReduce_140 = happySpecReduce_1 28# happyReduction_140-happyReduction_140 happy_x_1- = case happyOut37 happy_x_1 of { happy_var_1 -> - happyIn34- ([happy_var_1]- )}--happyReduce_141 = happySpecReduce_2 28# happyReduction_141-happyReduction_141 happy_x_2- happy_x_1- = case happyOut37 happy_x_1 of { happy_var_1 -> - case happyOut34 happy_x_2 of { happy_var_2 -> - happyIn34- (happy_var_1 : happy_var_2- )}}--happyReduce_142 = happySpecReduce_3 29# happyReduction_142-happyReduction_142 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> - happyIn35- (HiddenArg (fuseRange happy_var_1 happy_var_3) (unnamed happy_var_2)- )}}}--happyReduce_143 = happyReduce 5# 29# happyReduction_143-happyReduction_143 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> - happyIn35- (HiddenArg (fuseRange happy_var_1 happy_var_5) (named (show happy_var_2) happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_144 = happySpecReduce_2 29# happyReduction_144-happyReduction_144 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> - happyIn35- (let r = fuseRange happy_var_1 happy_var_2 in HiddenArg r $ unnamed $ Absurd r- )}}--happyReduce_145 = happySpecReduce_1 30# happyReduction_145-happyReduction_145 happy_x_1- = case happyOut21 happy_x_1 of { happy_var_1 -> - happyIn36- (Ident happy_var_1- )}--happyReduce_146 = happySpecReduce_1 30# happyReduction_146-happyReduction_146 happy_x_1- = case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> - happyIn36- (Lit happy_var_1- )}--happyReduce_147 = happySpecReduce_1 30# happyReduction_147-happyReduction_147 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> - happyIn36- (QuestionMark (getRange happy_var_1) Nothing- )}--happyReduce_148 = happySpecReduce_1 30# happyReduction_148-happyReduction_148 happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn36- (Underscore (getRange happy_var_1) Nothing- )}--happyReduce_149 = happySpecReduce_1 30# happyReduction_149-happyReduction_149 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> - happyIn36- (Prop (getRange happy_var_1)- )}--happyReduce_150 = happySpecReduce_1 30# happyReduction_150-happyReduction_150 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> - happyIn36- (Set (getRange happy_var_1)- )}--happyReduce_151 = happySpecReduce_1 30# happyReduction_151-happyReduction_151 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> - happyIn36- (Quote (getRange happy_var_1)- )}--happyReduce_152 = happySpecReduce_1 30# happyReduction_152-happyReduction_152 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> - happyIn36- (QuoteTerm (getRange happy_var_1)- )}--happyReduce_153 = happySpecReduce_1 30# happyReduction_153-happyReduction_153 happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> - happyIn36- (Unquote (getRange happy_var_1)- )}--happyReduce_154 = happySpecReduce_1 30# happyReduction_154-happyReduction_154 happy_x_1- = case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> - happyIn36- (SetN (getRange (fst happy_var_1)) (snd happy_var_1)- )}--happyReduce_155 = happySpecReduce_3 30# happyReduction_155-happyReduction_155 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOut17 happy_x_3 of { happy_var_3 -> - happyIn36- (InstanceArg (fuseRange happy_var_1 happy_var_3) (unnamed happy_var_2)- )}}}--happyReduce_156 = happyReduce 5# 30# happyReduction_156-happyReduction_156 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - case happyOut17 happy_x_5 of { happy_var_5 -> - happyIn36- (InstanceArg (fuseRange happy_var_1 happy_var_5) (named (show happy_var_2) happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_157 = happySpecReduce_3 30# happyReduction_157-happyReduction_157 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut29 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn36- (Paren (fuseRange happy_var_1 happy_var_3) happy_var_2- )}}}--happyReduce_158 = happySpecReduce_2 30# happyReduction_158-happyReduction_158 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymCloseParen happy_var_2) -> - happyIn36- (Absurd (fuseRange happy_var_1 happy_var_2)- )}}--happyReduce_159 = happySpecReduce_2 30# happyReduction_159-happyReduction_159 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut17 happy_x_2 of { happy_var_2 -> - happyIn36- (let r = fuseRange happy_var_1 happy_var_2 in InstanceArg r $ unnamed $ Absurd r- )}}--happyReduce_160 = happySpecReduce_3 30# happyReduction_160-happyReduction_160 happy_x_3- happy_x_2- happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - case happyOut37 happy_x_3 of { happy_var_3 -> - happyIn36- (As (fuseRange happy_var_1 happy_var_3) happy_var_1 happy_var_3- )}}--happyReduce_161 = happySpecReduce_2 30# happyReduction_161-happyReduction_161 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> - case happyOut37 happy_x_2 of { happy_var_2 -> - happyIn36- (Dot (fuseRange happy_var_1 happy_var_2) happy_var_2- )}}--happyReduce_162 = happyReduce 4# 30# happyReduction_162-happyReduction_162 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - case happyOut38 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn36- (Rec (getRange (happy_var_1,happy_var_4)) happy_var_3- ) `HappyStk` happyRest}}}--happyReduce_163 = happyReduce 5# 30# happyReduction_163-happyReduction_163 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - case happyOut36 happy_x_2 of { happy_var_2 -> - case happyOut38 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> - happyIn36- (RecUpdate (getRange (happy_var_1,happy_var_5)) happy_var_2 happy_var_4- ) `HappyStk` happyRest}}}}--happyReduce_164 = happySpecReduce_1 31# happyReduction_164-happyReduction_164 happy_x_1- = case happyOut35 happy_x_1 of { happy_var_1 -> - happyIn37- (happy_var_1- )}--happyReduce_165 = happySpecReduce_1 31# happyReduction_165-happyReduction_165 happy_x_1- = case happyOut36 happy_x_1 of { happy_var_1 -> - happyIn37- (happy_var_1- )}--happyReduce_166 = happySpecReduce_0 32# happyReduction_166-happyReduction_166 = happyIn38- ([]- )--happyReduce_167 = happySpecReduce_1 32# happyReduction_167-happyReduction_167 happy_x_1- = case happyOut39 happy_x_1 of { happy_var_1 -> - happyIn38- (happy_var_1- )}--happyReduce_168 = happySpecReduce_1 33# happyReduction_168-happyReduction_168 happy_x_1- = case happyOut40 happy_x_1 of { happy_var_1 -> - happyIn39- ([happy_var_1]- )}--happyReduce_169 = happySpecReduce_3 33# happyReduction_169-happyReduction_169 happy_x_3- happy_x_2- happy_x_1- = case happyOut40 happy_x_1 of { happy_var_1 -> - case happyOut39 happy_x_3 of { happy_var_3 -> - happyIn39- (happy_var_1 : happy_var_3- )}}--happyReduce_170 = happySpecReduce_3 34# happyReduction_170-happyReduction_170 happy_x_3- happy_x_2- happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn40- ((happy_var_1, happy_var_3)- )}}--happyReduce_171 = happySpecReduce_2 35# happyReduction_171-happyReduction_171 happy_x_2- happy_x_1- = case happyOut42 happy_x_1 of { happy_var_1 -> - happyIn41- (happy_var_1- )}--happyReduce_172 = happySpecReduce_1 36# happyReduction_172-happyReduction_172 happy_x_1- = case happyOut43 happy_x_1 of { happy_var_1 -> - happyIn42- ({-TeleBind-} happy_var_1- )}--happyReduce_173 = happySpecReduce_2 37# happyReduction_173-happyReduction_173 happy_x_2- happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_2 of { happy_var_2 -> - happyIn43- (happy_var_1 : happy_var_2- )}}--happyReduce_174 = happySpecReduce_1 37# happyReduction_174-happyReduction_174 happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn43- ([happy_var_1]- )}--happyReduce_175 = happyReduce 4# 38# happyReduction_175-happyReduction_175 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut45 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn44- (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg NotHidden Irrelevant happy_var_3)- ) `HappyStk` happyRest}}}--happyReduce_176 = happyReduce 4# 38# happyReduction_176-happyReduction_176 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut45 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn44- (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg Hidden Irrelevant happy_var_3)- ) `HappyStk` happyRest}}}--happyReduce_177 = happyReduce 4# 38# happyReduction_177-happyReduction_177 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> - case happyOut45 happy_x_3 of { happy_var_3 -> - happyIn44- (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Instance Irrelevant happy_var_3)- ) `HappyStk` happyRest}}--happyReduce_178 = happyReduce 4# 38# happyReduction_178-happyReduction_178 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut45 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn44- (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg NotHidden NonStrict happy_var_3)- ) `HappyStk` happyRest}}}--happyReduce_179 = happyReduce 4# 38# happyReduction_179-happyReduction_179 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut45 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn44- (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg Hidden NonStrict happy_var_3)- ) `HappyStk` happyRest}}}--happyReduce_180 = happyReduce 4# 38# happyReduction_180-happyReduction_180 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> - case happyOut45 happy_x_3 of { happy_var_3 -> - happyIn44- (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Instance NonStrict happy_var_3)- ) `HappyStk` happyRest}}--happyReduce_181 = happySpecReduce_3 38# happyReduction_181-happyReduction_181 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut45 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn44- (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg NotHidden Relevant happy_var_2)- )}}}--happyReduce_182 = happySpecReduce_3 38# happyReduction_182-happyReduction_182 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut45 happy_x_2 of { happy_var_2 -> - case happyOut17 happy_x_3 of { happy_var_3 -> - happyIn44- (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Instance Relevant happy_var_2)- )}}}--happyReduce_183 = happySpecReduce_3 38# happyReduction_183-happyReduction_183 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOut45 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> - happyIn44- (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Hidden Relevant happy_var_2)- )}}}--happyReduce_184 = happySpecReduce_3 39# happyReduction_184-happyReduction_184 happy_x_3- happy_x_2- happy_x_1- = case happyOut25 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn45- (TBind (fuseRange happy_var_1 happy_var_3) (map mkBoundName_ happy_var_1) happy_var_3- )}}--happyReduce_185 = happyMonadReduce 2# 40# happyReduction_185-happyReduction_185 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> - (- case reverse happy_var_1 of- Left _ : _ -> parseError "Absurd lambda cannot have a body."- _ : _ -> return [ b | Right b <- happy_var_1 ]- [] -> parsePanic "Empty LamBinds")}- ) (\r -> happyReturn (happyIn46 r))--happyReduce_186 = happyMonadReduce 1# 41# happyReduction_186-happyReduction_186 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut49 happy_x_1 of { happy_var_1 -> - (- case happy_var_1 of- Left lb -> case reverse lb of- Right _ : _ -> parseError "Missing body for lambda"- Left h : _ -> return $ Left ([ b | Right b <- init lb], h)- _ -> parsePanic "Empty LamBindsAbsurd"- Right es -> return $ Right es)}- ) (\r -> happyReturn (happyIn47 r))--happyReduce_187 = happySpecReduce_2 42# happyReduction_187-happyReduction_187 happy_x_2- happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_2 of { happy_var_2 -> - happyIn48- (map Right happy_var_1 ++ happy_var_2- )}}--happyReduce_188 = happySpecReduce_2 42# happyReduction_188-happyReduction_188 happy_x_2- happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_2 of { happy_var_2 -> - happyIn48- (Right (DomainFull happy_var_1) : happy_var_2- )}}--happyReduce_189 = happySpecReduce_1 42# happyReduction_189-happyReduction_189 happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - happyIn48- (map Right happy_var_1- )}--happyReduce_190 = happySpecReduce_1 42# happyReduction_190-happyReduction_190 happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn48- ([Right $ DomainFull happy_var_1]- )}--happyReduce_191 = happySpecReduce_2 42# happyReduction_191-happyReduction_191 happy_x_2- happy_x_1- = happyIn48- ([Left NotHidden]- )--happyReduce_192 = happySpecReduce_2 42# happyReduction_192-happyReduction_192 happy_x_2- happy_x_1- = happyIn48- ([Left Hidden]- )--happyReduce_193 = happySpecReduce_2 42# happyReduction_193-happyReduction_193 happy_x_2- happy_x_1- = happyIn48- ([Left Instance]- )--happyReduce_194 = happySpecReduce_2 43# happyReduction_194-happyReduction_194 happy_x_2- happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_2 of { happy_var_2 -> - happyIn49- (Left $ map Right happy_var_1 ++ happy_var_2- )}}--happyReduce_195 = happySpecReduce_2 43# happyReduction_195-happyReduction_195 happy_x_2- happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOut48 happy_x_2 of { happy_var_2 -> - happyIn49- (Left $ Right (DomainFull happy_var_1) : happy_var_2- )}}--happyReduce_196 = happySpecReduce_1 43# happyReduction_196-happyReduction_196 happy_x_1- = case happyOut58 happy_x_1 of { happy_var_1 -> - happyIn49- (case happy_var_1 of- Left lb -> Left $ map Right lb- Right es -> Right es- )}--happyReduce_197 = happySpecReduce_1 43# happyReduction_197-happyReduction_197 happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn49- (Left [Right $ DomainFull happy_var_1]- )}--happyReduce_198 = happySpecReduce_2 43# happyReduction_198-happyReduction_198 happy_x_2- happy_x_1- = happyIn49- (Left [Left NotHidden]- )--happyReduce_199 = happySpecReduce_2 43# happyReduction_199-happyReduction_199 happy_x_2- happy_x_1- = happyIn49- (Left [Left Hidden]- )--happyReduce_200 = happySpecReduce_2 43# happyReduction_200-happyReduction_200 happy_x_2- happy_x_1- = happyIn49- (Left [Left Instance]- )--happyReduce_201 = happyMonadReduce 3# 44# happyReduction_201-happyReduction_201 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut34 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - ( do- p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1) ;- return (p [] [], RHS happy_var_3, NoWhere))}}- ) (\r -> happyReturn (happyIn50 r))--happyReduce_202 = happyMonadReduce 1# 45# happyReduction_202-happyReduction_202 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> - ( do- p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1);- return (p [] [], AbsurdRHS, NoWhere))}- ) (\r -> happyReturn (happyIn51 r))--happyReduce_203 = happySpecReduce_1 46# happyReduction_203-happyReduction_203 happy_x_1- = case happyOut50 happy_x_1 of { happy_var_1 -> - happyIn52- (happy_var_1- )}--happyReduce_204 = happySpecReduce_1 46# happyReduction_204-happyReduction_204 happy_x_1- = case happyOut51 happy_x_1 of { happy_var_1 -> - happyIn52- (happy_var_1- )}--happyReduce_205 = happySpecReduce_3 47# happyReduction_205-happyReduction_205 happy_x_3- happy_x_2- happy_x_1- = case happyOut53 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - happyIn53- (happy_var_3 : happy_var_1- )}}--happyReduce_206 = happySpecReduce_3 47# happyReduction_206-happyReduction_206 happy_x_3- happy_x_2- happy_x_1- = case happyOut51 happy_x_1 of { happy_var_1 -> - case happyOut52 happy_x_3 of { happy_var_3 -> - happyIn53- ([happy_var_3, happy_var_1]- )}}--happyReduce_207 = happySpecReduce_1 47# happyReduction_207-happyReduction_207 happy_x_1- = case happyOut50 happy_x_1 of { happy_var_1 -> - happyIn53- ([happy_var_1]- )}--happyReduce_208 = happySpecReduce_2 48# happyReduction_208-happyReduction_208 happy_x_2- happy_x_1- = case happyOut55 happy_x_1 of { happy_var_1 -> - happyIn54- (happy_var_1- )}--happyReduce_209 = happySpecReduce_2 49# happyReduction_209-happyReduction_209 happy_x_2- happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - case happyOut55 happy_x_2 of { happy_var_2 -> - happyIn55- (happy_var_1 ++ happy_var_2- )}}--happyReduce_210 = happySpecReduce_2 49# happyReduction_210-happyReduction_210 happy_x_2- happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOut55 happy_x_2 of { happy_var_2 -> - happyIn55- (DomainFull happy_var_1 : happy_var_2- )}}--happyReduce_211 = happySpecReduce_1 49# happyReduction_211-happyReduction_211 happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - happyIn55- (happy_var_1- )}--happyReduce_212 = happySpecReduce_1 49# happyReduction_212-happyReduction_212 happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn55- ([DomainFull happy_var_1]- )}--happyReduce_213 = happySpecReduce_2 50# happyReduction_213-happyReduction_213 happy_x_2- happy_x_1- = case happyOut57 happy_x_1 of { happy_var_1 -> - case happyOut56 happy_x_2 of { happy_var_2 -> - happyIn56- (happy_var_1 ++ happy_var_2- )}}--happyReduce_214 = happySpecReduce_2 50# happyReduction_214-happyReduction_214 happy_x_2- happy_x_1- = case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOut56 happy_x_2 of { happy_var_2 -> - happyIn56- (DomainFull happy_var_1 : happy_var_2- )}}--happyReduce_215 = happySpecReduce_0 50# happyReduction_215-happyReduction_215 = happyIn56- ([]- )--happyReduce_216 = happySpecReduce_1 51# happyReduction_216-happyReduction_216 happy_x_1- = case happyOut58 happy_x_1 of { happy_var_1 -> - happyIn57- (case happy_var_1 of- Left lbs -> lbs- Right _ -> fail "expected sequence of bound identifiers, not absurd pattern"- )}--happyReduce_217 = happySpecReduce_1 52# happyReduction_217-happyReduction_217 happy_x_1- = case happyOut23 happy_x_1 of { happy_var_1 -> - happyIn58- (Left [DomainFree NotHidden Relevant $ mkBoundName_ happy_var_1]- )}--happyReduce_218 = happySpecReduce_2 52# happyReduction_218-happyReduction_218 happy_x_2- happy_x_1- = case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn58- (Left [DomainFree NotHidden Irrelevant $ mkBoundName_ happy_var_2]- )}--happyReduce_219 = happySpecReduce_2 52# happyReduction_219-happyReduction_219 happy_x_2- happy_x_1- = case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn58- (Left [DomainFree NotHidden NonStrict $ mkBoundName_ happy_var_2]- )}--happyReduce_220 = happySpecReduce_3 52# happyReduction_220-happyReduction_220 happy_x_3- happy_x_2- happy_x_1- = case happyOut26 happy_x_2 of { happy_var_2 -> - happyIn58- (either (Left . map (DomainFree Hidden Relevant . mkBoundName_)) Right happy_var_2- )}--happyReduce_221 = happySpecReduce_3 52# happyReduction_221-happyReduction_221 happy_x_3- happy_x_2- happy_x_1- = case happyOut25 happy_x_2 of { happy_var_2 -> - happyIn58- (Left $ map (DomainFree Instance Relevant . mkBoundName_) happy_var_2- )}--happyReduce_222 = happyReduce 4# 52# happyReduction_222-happyReduction_222 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn58- (Left $ map (DomainFree Hidden Irrelevant . mkBoundName_) happy_var_3- ) `HappyStk` happyRest}--happyReduce_223 = happyReduce 4# 52# happyReduction_223-happyReduction_223 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn58- (Left $ map (DomainFree Instance Irrelevant . mkBoundName_) happy_var_3- ) `HappyStk` happyRest}--happyReduce_224 = happyReduce 4# 52# happyReduction_224-happyReduction_224 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn58- (Left $ map (DomainFree Hidden NonStrict . mkBoundName_) happy_var_3- ) `HappyStk` happyRest}--happyReduce_225 = happyReduce 4# 52# happyReduction_225-happyReduction_225 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut25 happy_x_3 of { happy_var_3 -> - happyIn58- (Left $ map (DomainFree Instance NonStrict . mkBoundName_) happy_var_3- ) `HappyStk` happyRest}--happyReduce_226 = happySpecReduce_1 53# happyReduction_226-happyReduction_226 happy_x_1- = case happyOut60 happy_x_1 of { happy_var_1 -> - happyIn59- ((Nothing, happy_var_1)- )}--happyReduce_227 = happyMonadReduce 3# 53# happyReduction_227-happyReduction_227 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut60 happy_x_3 of { happy_var_3 -> - ( isName "as" happy_var_1 >>- return (Just (AsName happy_var_2 (getRange (fst happy_var_1))), happy_var_3))}}}- ) (\r -> happyReturn (happyIn59 r))--happyReduce_228 = happyMonadReduce 1# 54# happyReduction_228-happyReduction_228 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut61 happy_x_1 of { happy_var_1 -> - ( verifyImportDirective happy_var_1)}- ) (\r -> happyReturn (happyIn60 r))--happyReduce_229 = happySpecReduce_2 55# happyReduction_229-happyReduction_229 happy_x_2- happy_x_1- = case happyOut62 happy_x_2 of { happy_var_2 -> - happyIn61- (happy_var_2 { publicOpen = True }- )}--happyReduce_230 = happySpecReduce_1 55# happyReduction_230-happyReduction_230 happy_x_1- = case happyOut62 happy_x_1 of { happy_var_1 -> - happyIn61- (happy_var_1- )}--happyReduce_231 = happySpecReduce_2 56# happyReduction_231-happyReduction_231 happy_x_2- happy_x_1- = case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_2 of { happy_var_2 -> - happyIn62- (ImportDirective (fuseRange (snd happy_var_1) (snd happy_var_2)) (fst happy_var_1) (fst happy_var_2) False- )}}--happyReduce_232 = happySpecReduce_1 56# happyReduction_232-happyReduction_232 happy_x_1- = case happyOut64 happy_x_1 of { happy_var_1 -> - happyIn62- (ImportDirective (getRange (snd happy_var_1)) (Hiding []) (fst happy_var_1) False- )}--happyReduce_233 = happySpecReduce_1 56# happyReduction_233-happyReduction_233 happy_x_1- = case happyOut63 happy_x_1 of { happy_var_1 -> - happyIn62- (ImportDirective (getRange (snd happy_var_1)) (fst happy_var_1) [] False- )}--happyReduce_234 = happySpecReduce_0 56# happyReduction_234-happyReduction_234 = happyIn62- (ImportDirective noRange (Hiding []) [] False- )--happyReduce_235 = happyReduce 4# 57# happyReduction_235-happyReduction_235 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> - case happyOut69 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn63- ((Using happy_var_3 , fuseRange happy_var_1 happy_var_4)- ) `HappyStk` happyRest}}}--happyReduce_236 = happyReduce 4# 57# happyReduction_236-happyReduction_236 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn63- ((Hiding happy_var_3 , fuseRange happy_var_1 happy_var_4)- ) `HappyStk` happyRest}}}--happyReduce_237 = happyReduce 4# 58# happyReduction_237-happyReduction_237 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> - case happyOut65 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn64- ((happy_var_3 , fuseRange happy_var_1 happy_var_4)- ) `HappyStk` happyRest}}}--happyReduce_238 = happySpecReduce_3 59# happyReduction_238-happyReduction_238 happy_x_3- happy_x_2- happy_x_1- = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_3 of { happy_var_3 -> - happyIn65- (happy_var_1 : happy_var_3- )}}--happyReduce_239 = happySpecReduce_1 59# happyReduction_239-happyReduction_239 happy_x_1- = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn65- ([happy_var_1]- )}--happyReduce_240 = happySpecReduce_3 60# happyReduction_240-happyReduction_240 happy_x_3- happy_x_2- happy_x_1- = case happyOut67 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokKeyword KwTo happy_var_2) -> - case happyOut15 happy_x_3 of { happy_var_3 -> - happyIn66- (Renaming happy_var_1 happy_var_3 (getRange happy_var_2)- )}}}--happyReduce_241 = happySpecReduce_2 61# happyReduction_241-happyReduction_241 happy_x_2- happy_x_1- = case happyOut15 happy_x_2 of { happy_var_2 -> - happyIn67- (ImportedName happy_var_2- )}--happyReduce_242 = happySpecReduce_3 61# happyReduction_242-happyReduction_242 happy_x_3- happy_x_2- happy_x_1- = case happyOut15 happy_x_3 of { happy_var_3 -> - happyIn67- (ImportedModule happy_var_3- )}--happyReduce_243 = happySpecReduce_1 62# happyReduction_243-happyReduction_243 happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - happyIn68- (ImportedName happy_var_1- )}--happyReduce_244 = happySpecReduce_2 62# happyReduction_244-happyReduction_244 happy_x_2- happy_x_1- = case happyOut15 happy_x_2 of { happy_var_2 -> - happyIn68- (ImportedModule happy_var_2- )}--happyReduce_245 = happySpecReduce_0 63# happyReduction_245-happyReduction_245 = happyIn69- ([]- )--happyReduce_246 = happySpecReduce_1 63# happyReduction_246-happyReduction_246 happy_x_1- = case happyOut70 happy_x_1 of { happy_var_1 -> - happyIn69- (happy_var_1- )}--happyReduce_247 = happySpecReduce_1 64# happyReduction_247-happyReduction_247 happy_x_1- = case happyOut68 happy_x_1 of { happy_var_1 -> - happyIn70- ([happy_var_1]- )}--happyReduce_248 = happySpecReduce_3 64# happyReduction_248-happyReduction_248 happy_x_3- happy_x_2- happy_x_1- = case happyOut68 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - happyIn70- (happy_var_1 : happy_var_3- )}}--happyReduce_249 = happyMonadReduce 3# 65# happyReduction_249-happyReduction_249 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut30 happy_x_1 of { happy_var_1 -> - case happyOut74 happy_x_2 of { happy_var_2 -> - case happyOut73 happy_x_3 of { happy_var_3 -> - ( exprToLHS happy_var_1 >>= \p -> return (p happy_var_2 happy_var_3))}}}- ) (\r -> happyReturn (happyIn71 r))--happyReduce_250 = happyReduce 4# 65# happyReduction_250-happyReduction_250 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> - case happyOut72 happy_x_2 of { happy_var_2 -> - case happyOut74 happy_x_3 of { happy_var_3 -> - case happyOut73 happy_x_4 of { happy_var_4 -> - happyIn71- (Ellipsis (fuseRange happy_var_1 happy_var_3) happy_var_2 happy_var_3 happy_var_4- ) `HappyStk` happyRest}}}}--happyReduce_251 = happySpecReduce_0 66# happyReduction_251-happyReduction_251 = happyIn72- ([]- )--happyReduce_252 = happyMonadReduce 3# 66# happyReduction_252-happyReduction_252 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut34 happy_x_2 of { happy_var_2 -> - case happyOut72 happy_x_3 of { happy_var_3 -> - ( exprToPattern (RawApp (getRange happy_var_2) happy_var_2) >>= \p ->- return (p : happy_var_3))}}- ) (\r -> happyReturn (happyIn72 r))--happyReduce_253 = happySpecReduce_0 67# happyReduction_253-happyReduction_253 = happyIn73- ([]- )--happyReduce_254 = happySpecReduce_2 67# happyReduction_254-happyReduction_254 happy_x_2- happy_x_1- = case happyOut29 happy_x_2 of { happy_var_2 -> - happyIn73- (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] }- )}--happyReduce_255 = happySpecReduce_0 68# happyReduction_255-happyReduction_255 = happyIn74- ([]- )--happyReduce_256 = happySpecReduce_2 68# happyReduction_256-happyReduction_256 happy_x_2- happy_x_1- = case happyOut29 happy_x_2 of { happy_var_2 -> - happyIn74- (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] }- )}--happyReduce_257 = happySpecReduce_0 69# happyReduction_257-happyReduction_257 = happyIn75- (NoWhere- )--happyReduce_258 = happySpecReduce_2 69# happyReduction_258-happyReduction_258 happy_x_2- happy_x_1- = case happyOut130 happy_x_2 of { happy_var_2 -> - happyIn75- (AnyWhere happy_var_2- )}--happyReduce_259 = happyReduce 4# 69# happyReduction_259-happyReduction_259 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut130 happy_x_4 of { happy_var_4 -> - happyIn75- (SomeWhere happy_var_2 happy_var_4- ) `HappyStk` happyRest}}--happyReduce_260 = happySpecReduce_1 70# happyReduction_260-happyReduction_260 happy_x_1- = case happyOut78 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_261 = happySpecReduce_1 70# happyReduction_261-happyReduction_261 happy_x_1- = case happyOut89 happy_x_1 of { happy_var_1 -> - happyIn76- (happy_var_1- )}--happyReduce_262 = happySpecReduce_1 70# happyReduction_262-happyReduction_262 happy_x_1- = case happyOut81 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_263 = happySpecReduce_1 70# happyReduction_263-happyReduction_263 happy_x_1- = case happyOut83 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_264 = happySpecReduce_1 70# happyReduction_264-happyReduction_264 happy_x_1- = case happyOut84 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_265 = happySpecReduce_1 70# happyReduction_265-happyReduction_265 happy_x_1- = case happyOut85 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_266 = happySpecReduce_1 70# happyReduction_266-happyReduction_266 happy_x_1- = case happyOut86 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_267 = happySpecReduce_1 70# happyReduction_267-happyReduction_267 happy_x_1- = case happyOut88 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_268 = happySpecReduce_1 70# happyReduction_268-happyReduction_268 happy_x_1- = case happyOut90 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_269 = happySpecReduce_1 70# happyReduction_269-happyReduction_269 happy_x_1- = case happyOut91 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_270 = happySpecReduce_1 70# happyReduction_270-happyReduction_270 happy_x_1- = case happyOut92 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_271 = happySpecReduce_1 70# happyReduction_271-happyReduction_271 happy_x_1- = case happyOut93 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_272 = happySpecReduce_1 70# happyReduction_272-happyReduction_272 happy_x_1- = case happyOut94 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_273 = happySpecReduce_1 70# happyReduction_273-happyReduction_273 happy_x_1- = case happyOut100 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_274 = happySpecReduce_1 70# happyReduction_274-happyReduction_274 happy_x_1- = case happyOut104 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_275 = happySpecReduce_1 70# happyReduction_275-happyReduction_275 happy_x_1- = case happyOut103 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_276 = happySpecReduce_1 70# happyReduction_276-happyReduction_276 happy_x_1- = case happyOut105 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_277 = happySpecReduce_1 70# happyReduction_277-happyReduction_277 happy_x_1- = case happyOut108 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_278 = happySpecReduce_1 70# happyReduction_278-happyReduction_278 happy_x_1- = case happyOut95 happy_x_1 of { happy_var_1 -> - happyIn76- ([happy_var_1]- )}--happyReduce_279 = happySpecReduce_3 71# happyReduction_279-happyReduction_279 happy_x_3- happy_x_2- happy_x_1- = case happyOut16 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn77- (map (flip (TypeSig Relevant) happy_var_3) happy_var_1- )}}--happyReduce_280 = happyReduce 4# 72# happyReduction_280-happyReduction_280 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut29 happy_x_4 of { happy_var_4 -> - happyIn78- (TypeSig Irrelevant happy_var_2 happy_var_4- ) `HappyStk` happyRest}}--happyReduce_281 = happySpecReduce_3 72# happyReduction_281-happyReduction_281 happy_x_3- happy_x_2- happy_x_1- = case happyOut15 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn78- (TypeSig Relevant happy_var_1 happy_var_3- )}}--happyReduce_282 = happySpecReduce_3 73# happyReduction_282-happyReduction_282 happy_x_3- happy_x_2- happy_x_1- = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn79- (map (\ (Arg _ rel x) -> TypeSig rel x happy_var_3) happy_var_1- )}}--happyReduce_283 = happySpecReduce_3 74# happyReduction_283-happyReduction_283 happy_x_3- happy_x_2- happy_x_1- = case happyOut20 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn80- (map (fmap (flip (TypeSig Relevant) happy_var_3)) happy_var_1- )}}--happyReduce_284 = happySpecReduce_3 75# happyReduction_284-happyReduction_284 happy_x_3- happy_x_2- happy_x_1- = case happyOut71 happy_x_1 of { happy_var_1 -> - case happyOut82 happy_x_2 of { happy_var_2 -> - case happyOut75 happy_x_3 of { happy_var_3 -> - happyIn81- (FunClause happy_var_1 happy_var_2 happy_var_3- )}}}--happyReduce_285 = happySpecReduce_2 76# happyReduction_285-happyReduction_285 happy_x_2- happy_x_1- = case happyOut29 happy_x_2 of { happy_var_2 -> - happyIn82- (RHS happy_var_2- )}--happyReduce_286 = happySpecReduce_0 76# happyReduction_286-happyReduction_286 = happyIn82- (AbsurdRHS- )--happyReduce_287 = happyReduce 7# 77# happyReduction_287-happyReduction_287 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut29 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> - case happyOut128 happy_x_7 of { happy_var_7 -> - happyIn83- (Data (getRange (happy_var_1, happy_var_6, happy_var_7)) Inductive happy_var_2 happy_var_3 (Just happy_var_5) happy_var_7- ) `HappyStk` happyRest}}}}}}--happyReduce_288 = happyReduce 7# 77# happyReduction_288-happyReduction_288 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut29 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> - case happyOut128 happy_x_7 of { happy_var_7 -> - happyIn83- (Data (getRange (happy_var_1, happy_var_6, happy_var_7)) CoInductive happy_var_2 happy_var_3 (Just happy_var_5) happy_var_7- ) `HappyStk` happyRest}}}}}}--happyReduce_289 = happyReduce 5# 77# happyReduction_289-happyReduction_289 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut128 happy_x_5 of { happy_var_5 -> - happyIn83- (Data (getRange (happy_var_1, happy_var_4, happy_var_5)) Inductive happy_var_2 happy_var_3 Nothing happy_var_5- ) `HappyStk` happyRest}}}}}--happyReduce_290 = happyReduce 5# 77# happyReduction_290-happyReduction_290 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut128 happy_x_5 of { happy_var_5 -> - happyIn83- (Data (getRange (happy_var_1, happy_var_4, happy_var_5)) CoInductive happy_var_2 happy_var_3 Nothing happy_var_5- ) `HappyStk` happyRest}}}}}--happyReduce_291 = happyReduce 5# 78# happyReduction_291-happyReduction_291 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut29 happy_x_5 of { happy_var_5 -> - happyIn84- (DataSig (fuseRange happy_var_1 happy_var_5) Inductive happy_var_2 happy_var_3 happy_var_5- ) `HappyStk` happyRest}}}}--happyReduce_292 = happyReduce 7# 79# happyReduction_292-happyReduction_292 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut29 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> - case happyOut129 happy_x_7 of { happy_var_7 -> - happyIn85- (Record (getRange (happy_var_1, happy_var_6, happy_var_7)) happy_var_2 (fst happy_var_7) happy_var_3 (Just happy_var_5) (snd happy_var_7)- ) `HappyStk` happyRest}}}}}}--happyReduce_293 = happyReduce 5# 79# happyReduction_293-happyReduction_293 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut129 happy_x_5 of { happy_var_5 -> - happyIn85- (Record (getRange (happy_var_1, happy_var_4, happy_var_5)) happy_var_2 (fst happy_var_5) happy_var_3 Nothing (snd happy_var_5)- ) `HappyStk` happyRest}}}}}--happyReduce_294 = happyReduce 5# 80# happyReduction_294-happyReduction_294 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut29 happy_x_5 of { happy_var_5 -> - happyIn86- (RecordSig (fuseRange happy_var_1 happy_var_5) happy_var_2 happy_var_3 happy_var_5- ) `HappyStk` happyRest}}}}--happyReduce_295 = happySpecReduce_2 81# happyReduction_295-happyReduction_295 happy_x_2- happy_x_1- = case happyOut15 happy_x_2 of { happy_var_2 -> - happyIn87- (happy_var_2- )}--happyReduce_296 = happySpecReduce_3 82# happyReduction_296-happyReduction_296 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> - case happyOut14 happy_x_2 of { happy_var_2 -> - case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn88- (Infix (NonAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3- )}}}--happyReduce_297 = happySpecReduce_3 82# happyReduction_297-happyReduction_297 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> - case happyOut14 happy_x_2 of { happy_var_2 -> - case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn88- (Infix (LeftAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3- )}}}--happyReduce_298 = happySpecReduce_3 82# happyReduction_298-happyReduction_298 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> - case happyOut14 happy_x_2 of { happy_var_2 -> - case happyOut24 happy_x_3 of { happy_var_3 -> - happyIn88- (Infix (RightAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3- )}}}--happyReduce_299 = happySpecReduce_2 83# happyReduction_299-happyReduction_299 happy_x_2- happy_x_1- = case happyOut126 happy_x_2 of { happy_var_2 -> - happyIn89- (let toField (Arg h rel (TypeSig _ x t)) = Field x (Arg h rel t) in map toField happy_var_2- )}--happyReduce_300 = happySpecReduce_2 84# happyReduction_300-happyReduction_300 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> - case happyOut130 happy_x_2 of { happy_var_2 -> - happyIn90- (Mutual (fuseRange happy_var_1 happy_var_2) happy_var_2- )}}--happyReduce_301 = happySpecReduce_2 85# happyReduction_301-happyReduction_301 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> - case happyOut130 happy_x_2 of { happy_var_2 -> - happyIn91- (Abstract (fuseRange happy_var_1 happy_var_2) happy_var_2- )}}--happyReduce_302 = happySpecReduce_2 86# happyReduction_302-happyReduction_302 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> - case happyOut130 happy_x_2 of { happy_var_2 -> - happyIn92- (Private (fuseRange happy_var_1 happy_var_2) happy_var_2- )}}--happyReduce_303 = happySpecReduce_2 87# happyReduction_303-happyReduction_303 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> - case happyOut124 happy_x_2 of { happy_var_2 -> - happyIn93- (Postulate (fuseRange happy_var_1 happy_var_2) happy_var_2- )}}--happyReduce_304 = happySpecReduce_2 88# happyReduction_304-happyReduction_304 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> - case happyOut122 happy_x_2 of { happy_var_2 -> - happyIn94- (Primitive (fuseRange happy_var_1 happy_var_2) happy_var_2- )}}--happyReduce_305 = happyMonadReduce 5# 89# happyReduction_305-happyReduction_305 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut97 happy_x_3 of { happy_var_3 -> - case happyOut96 happy_x_5 of { happy_var_5 -> - (- case happy_var_2 of- Name _ [_] -> case mkNotation happy_var_3 happy_var_5 of- Left err -> parseError $ "malformed syntax declaration: " ++ err- Right n -> return $ Syntax happy_var_2 n- _ -> parseError "syntax declarations are allowed only for simple names (without holes)")}}}- ) (\r -> happyReturn (happyIn95 r))--happyReduce_306 = happySpecReduce_1 90# happyReduction_306-happyReduction_306 happy_x_1- = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn96- ([happy_var_1]- )}--happyReduce_307 = happySpecReduce_2 90# happyReduction_307-happyReduction_307 happy_x_2- happy_x_1- = case happyOut96 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_2 of { happy_var_2 -> - happyIn96- (happy_var_1 ++ [happy_var_2]- )}}--happyReduce_308 = happySpecReduce_1 91# happyReduction_308-happyReduction_308 happy_x_1- = case happyOut98 happy_x_1 of { happy_var_1 -> - happyIn97- ([happy_var_1]- )}--happyReduce_309 = happySpecReduce_2 91# happyReduction_309-happyReduction_309 happy_x_2- happy_x_1- = case happyOut97 happy_x_1 of { happy_var_1 -> - case happyOut98 happy_x_2 of { happy_var_2 -> - happyIn97- (happy_var_1 ++ [happy_var_2]- )}}--happyReduce_310 = happySpecReduce_1 92# happyReduction_310-happyReduction_310 happy_x_1- = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn98- (ExprHole happy_var_1- )}--happyReduce_311 = happyReduce 6# 92# happyReduction_311-happyReduction_311 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut99 happy_x_3 of { happy_var_3 -> - case happyOut99 happy_x_5 of { happy_var_5 -> - happyIn98- (LambdaHole happy_var_3 happy_var_5- ) `HappyStk` happyRest}}--happyReduce_312 = happySpecReduce_1 93# happyReduction_312-happyReduction_312 happy_x_1- = case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - happyIn99- (snd happy_var_1- )}--happyReduce_313 = happyReduce 4# 94# happyReduction_313-happyReduction_313 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - case happyOut22 happy_x_2 of { happy_var_2 -> - case happyOut101 happy_x_3 of { happy_var_3 -> - case happyOut60 happy_x_4 of { happy_var_4 -> - happyIn100- (let- { m = happy_var_2- ; es = happy_var_3- ; dir = happy_var_4- ; r = getRange (happy_var_1, m, es, dir)- } in- case es of- { [] -> Open r m dir- ; _ -> Private r [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2)- (SectionApp (getRange (m , es)) [] (RawApp (fuseRange m es) (Ident m : es)))- DoOpen dir- ]- }- ) `HappyStk` happyRest}}}}--happyReduce_314 = happyReduce 6# 94# happyReduction_314-happyReduction_314 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - case happyOut22 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymDoubleOpenBrace happy_var_3) -> - case happyOutTok happy_x_4 of { (TokSymbol SymEllipsis happy_var_4) -> - case happyOut60 happy_x_6 of { happy_var_6 -> - happyIn100- (let r = getRange (happy_var_1, happy_var_2, happy_var_3, happy_var_4) in- Private r [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2)- (RecordModuleIFS r happy_var_2) DoOpen happy_var_6- ]- ) `HappyStk` happyRest}}}}}--happyReduce_315 = happySpecReduce_0 95# happyReduction_315-happyReduction_315 = happyIn101- ([]- )--happyReduce_316 = happySpecReduce_2 95# happyReduction_316-happyReduction_316 happy_x_2- happy_x_1- = case happyOut37 happy_x_1 of { happy_var_1 -> - case happyOut101 happy_x_2 of { happy_var_2 -> - happyIn101- (happy_var_1 : happy_var_2- )}}--happyReduce_317 = happyReduce 4# 96# happyReduction_317-happyReduction_317 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut22 happy_x_1 of { happy_var_1 -> - case happyOut17 happy_x_4 of { happy_var_4 -> - happyIn102- ((\ts ->- if null ts then return $ RecordModuleIFS (getRange (happy_var_1, happy_var_4)) happy_var_1- else parseError "No bindings allowed for record module with non-canonical implicits" )- ) `HappyStk` happyRest}}--happyReduce_318 = happySpecReduce_2 96# happyReduction_318-happyReduction_318 happy_x_2- happy_x_1- = case happyOut22 happy_x_1 of { happy_var_1 -> - case happyOut101 happy_x_2 of { happy_var_2 -> - happyIn102- ((\ts -> return $ SectionApp (getRange (happy_var_1, happy_var_2)) ts (RawApp (fuseRange happy_var_1 happy_var_2) (Ident happy_var_1 : happy_var_2)) )- )}}--happyReduce_319 = happyMonadReduce 6# 97# happyReduction_319-happyReduction_319 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut102 happy_x_5 of { happy_var_5 -> - case happyOut60 happy_x_6 of { happy_var_6 -> - ( do {ma <- happy_var_5 (map addType happy_var_3); return $ ModuleMacro (getRange (happy_var_1, ma, happy_var_6)) happy_var_2 ma DontOpen happy_var_6 })}}}}}- ) (\r -> happyReturn (happyIn103 r))--happyReduce_320 = happyMonadReduce 7# 97# happyReduction_320-happyReduction_320 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - case happyOut15 happy_x_3 of { happy_var_3 -> - case happyOut56 happy_x_4 of { happy_var_4 -> - case happyOut102 happy_x_6 of { happy_var_6 -> - case happyOut60 happy_x_7 of { happy_var_7 -> - ( do {ma <- happy_var_6 (map addType happy_var_4); return $ ModuleMacro (getRange (happy_var_1, ma, happy_var_7)) happy_var_3 ma DoOpen happy_var_7 })}}}}}- ) (\r -> happyReturn (happyIn103 r))--happyReduce_321 = happySpecReduce_3 98# happyReduction_321-happyReduction_321 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> - case happyOut22 happy_x_2 of { happy_var_2 -> - case happyOut59 happy_x_3 of { happy_var_3 -> - happyIn104- (Import (getRange (happy_var_1,happy_var_2,snd happy_var_3)) happy_var_2 (fst happy_var_3) DontOpen (snd happy_var_3)- )}}}--happyReduce_322 = happyReduce 4# 98# happyReduction_322-happyReduction_322 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - case happyOut22 happy_x_3 of { happy_var_3 -> - case happyOut59 happy_x_4 of { happy_var_4 -> - happyIn104- (Import (getRange (happy_var_1,happy_var_3,snd happy_var_4)) happy_var_3 (fst happy_var_4) DoOpen (snd happy_var_4)- ) `HappyStk` happyRest}}}--happyReduce_323 = happyReduce 5# 99# happyReduction_323-happyReduction_323 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> - case happyOut15 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut131 happy_x_5 of { happy_var_5 -> - happyIn105- (Module (getRange (happy_var_1,happy_var_4,happy_var_5)) (QName happy_var_2) (map addType happy_var_3) happy_var_5- ) `HappyStk` happyRest}}}}}--happyReduce_324 = happySpecReduce_1 100# happyReduction_324-happyReduction_324 happy_x_1- = case happyOut107 happy_x_1 of { happy_var_1 -> - happyIn106- ([happy_var_1]- )}--happyReduce_325 = happySpecReduce_2 100# happyReduction_325-happyReduction_325 happy_x_2- happy_x_1- = case happyOut104 happy_x_1 of { happy_var_1 -> - case happyOut106 happy_x_2 of { happy_var_2 -> - happyIn106- (happy_var_1 : happy_var_2- )}}--happyReduce_326 = happySpecReduce_2 100# happyReduction_326-happyReduction_326 happy_x_2- happy_x_1- = case happyOut100 happy_x_1 of { happy_var_1 -> - case happyOut106 happy_x_2 of { happy_var_2 -> - happyIn106- (happy_var_1 : happy_var_2- )}}--happyReduce_327 = happyReduce 5# 101# happyReduction_327-happyReduction_327 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> - case happyOut22 happy_x_2 of { happy_var_2 -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut131 happy_x_5 of { happy_var_5 -> - happyIn107- (Module (getRange (happy_var_1,happy_var_4,happy_var_5)) happy_var_2 (map addType happy_var_3) happy_var_5- ) `HappyStk` happyRest}}}}}--happyReduce_328 = happySpecReduce_1 102# happyReduction_328-happyReduction_328 happy_x_1- = case happyOut110 happy_x_1 of { happy_var_1 -> - happyIn108- (Pragma happy_var_1- )}--happyReduce_329 = happySpecReduce_1 103# happyReduction_329-happyReduction_329 happy_x_1- = case happyOut111 happy_x_1 of { happy_var_1 -> - happyIn109- (happy_var_1- )}--happyReduce_330 = happySpecReduce_1 104# happyReduction_330-happyReduction_330 happy_x_1- = case happyOut112 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_331 = happySpecReduce_1 104# happyReduction_331-happyReduction_331 happy_x_1- = case happyOut113 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_332 = happySpecReduce_1 104# happyReduction_332-happyReduction_332 happy_x_1- = case happyOut115 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_333 = happySpecReduce_1 104# happyReduction_333-happyReduction_333 happy_x_1- = case happyOut114 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_334 = happySpecReduce_1 104# happyReduction_334-happyReduction_334 happy_x_1- = case happyOut116 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_335 = happySpecReduce_1 104# happyReduction_335-happyReduction_335 happy_x_1- = case happyOut117 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_336 = happySpecReduce_1 104# happyReduction_336-happyReduction_336 happy_x_1- = case happyOut118 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_337 = happySpecReduce_1 104# happyReduction_337-happyReduction_337 happy_x_1- = case happyOut120 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_338 = happySpecReduce_1 104# happyReduction_338-happyReduction_338 happy_x_1- = case happyOut121 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_339 = happySpecReduce_1 104# happyReduction_339-happyReduction_339 happy_x_1- = case happyOut119 happy_x_1 of { happy_var_1 -> - happyIn110- (happy_var_1- )}--happyReduce_340 = happyReduce 4# 105# happyReduction_340-happyReduction_340 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut27 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn111- (OptionsPragma (fuseRange happy_var_1 happy_var_4) happy_var_3- ) `HappyStk` happyRest}}}--happyReduce_341 = happyReduce 5# 106# happyReduction_341-happyReduction_341 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_3 of { (TokString happy_var_3) -> - case happyOut28 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn112- (BuiltinPragma (fuseRange happy_var_1 happy_var_5) (snd happy_var_3) (Ident happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_342 = happyReduce 5# 107# happyReduction_342-happyReduction_342 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOut27 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn113- (CompiledPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_343 = happyReduce 5# 108# happyReduction_343-happyReduction_343 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOut27 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn114- (CompiledTypePragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_344 = happyReduce 6# 109# happyReduction_344-happyReduction_344 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokString happy_var_4) -> - case happyOut27 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokSymbol SymClosePragma happy_var_6) -> - happyIn115- (CompiledDataPragma (fuseRange happy_var_1 happy_var_6) happy_var_3 (snd happy_var_4) happy_var_5- ) `HappyStk` happyRest}}}}}--happyReduce_345 = happyReduce 5# 110# happyReduction_345-happyReduction_345 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOut27 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn116- (CompiledEpicPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_346 = happyReduce 5# 111# happyReduction_346-happyReduction_346 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOut27 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn117- (CompiledJSPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_347 = happyReduce 4# 112# happyReduction_347-happyReduction_347 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn118- (StaticPragma (fuseRange happy_var_1 happy_var_4) happy_var_3- ) `HappyStk` happyRest}}}--happyReduce_348 = happyReduce 4# 113# happyReduction_348-happyReduction_348 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut28 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn119- (EtaPragma (fuseRange happy_var_1 happy_var_4) happy_var_3- ) `HappyStk` happyRest}}}--happyReduce_349 = happyMonadReduce 4# 114# happyReduction_349-happyReduction_349 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_3 of { (TokString happy_var_3) -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - ( let s = snd happy_var_3 in- if validHaskellModuleName s- then return $ ImportPragma (fuseRange happy_var_1 happy_var_4) s- else parseError $ "Malformed module name: " ++ s ++ ".")}}}- ) (\r -> happyReturn (happyIn120 r))--happyReduce_350 = happySpecReduce_3 115# happyReduction_350-happyReduction_350 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn121- (ImpossiblePragma (fuseRange happy_var_1 happy_var_3)- )}}--happyReduce_351 = happySpecReduce_3 116# happyReduction_351-happyReduction_351 happy_x_3- happy_x_2- happy_x_1- = case happyOut123 happy_x_2 of { happy_var_2 -> - happyIn122- (reverse happy_var_2- )}--happyReduce_352 = happySpecReduce_3 117# happyReduction_352-happyReduction_352 happy_x_3- happy_x_2- happy_x_1- = case happyOut123 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_3 of { happy_var_3 -> - happyIn123- (reverse happy_var_3 ++ happy_var_1- )}}--happyReduce_353 = happySpecReduce_1 117# happyReduction_353-happyReduction_353 happy_x_1- = case happyOut77 happy_x_1 of { happy_var_1 -> - happyIn123- (reverse happy_var_1- )}--happyReduce_354 = happySpecReduce_3 118# happyReduction_354-happyReduction_354 happy_x_3- happy_x_2- happy_x_1- = case happyOut125 happy_x_2 of { happy_var_2 -> - happyIn124- (reverse happy_var_2- )}--happyReduce_355 = happySpecReduce_3 119# happyReduction_355-happyReduction_355 happy_x_3- happy_x_2- happy_x_1- = case happyOut125 happy_x_1 of { happy_var_1 -> - case happyOut79 happy_x_3 of { happy_var_3 -> - happyIn125- (reverse happy_var_3 ++ happy_var_1- )}}--happyReduce_356 = happySpecReduce_1 119# happyReduction_356-happyReduction_356 happy_x_1- = case happyOut79 happy_x_1 of { happy_var_1 -> - happyIn125- (reverse happy_var_1- )}--happyReduce_357 = happySpecReduce_3 120# happyReduction_357-happyReduction_357 happy_x_3- happy_x_2- happy_x_1- = case happyOut127 happy_x_2 of { happy_var_2 -> - happyIn126- (reverse happy_var_2- )}--happyReduce_358 = happySpecReduce_3 121# happyReduction_358-happyReduction_358 happy_x_3- happy_x_2- happy_x_1- = case happyOut127 happy_x_1 of { happy_var_1 -> - case happyOut80 happy_x_3 of { happy_var_3 -> - happyIn127- (reverse happy_var_3 ++ happy_var_1- )}}--happyReduce_359 = happySpecReduce_1 121# happyReduction_359-happyReduction_359 happy_x_1- = case happyOut80 happy_x_1 of { happy_var_1 -> - happyIn127- (reverse happy_var_1- )}--happyReduce_360 = happySpecReduce_2 122# happyReduction_360-happyReduction_360 happy_x_2- happy_x_1- = happyIn128- ([]- )--happyReduce_361 = happySpecReduce_1 122# happyReduction_361-happyReduction_361 happy_x_1- = case happyOut122 happy_x_1 of { happy_var_1 -> - happyIn128- (happy_var_1- )}--happyReduce_362 = happySpecReduce_2 123# happyReduction_362-happyReduction_362 happy_x_2- happy_x_1- = happyIn129- ((Nothing, [])- )--happyReduce_363 = happySpecReduce_3 123# happyReduction_363-happyReduction_363 happy_x_3- happy_x_2- happy_x_1- = case happyOut87 happy_x_2 of { happy_var_2 -> - happyIn129- ((Just happy_var_2, [])- )}--happyReduce_364 = happyReduce 5# 123# happyReduction_364-happyReduction_364 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut87 happy_x_2 of { happy_var_2 -> - case happyOut132 happy_x_4 of { happy_var_4 -> - happyIn129- ((Just happy_var_2, reverse happy_var_4)- ) `HappyStk` happyRest}}--happyReduce_365 = happySpecReduce_3 123# happyReduction_365-happyReduction_365 happy_x_3- happy_x_2- happy_x_1- = case happyOut132 happy_x_2 of { happy_var_2 -> - happyIn129- ((Nothing, reverse happy_var_2)- )}--happyReduce_366 = happySpecReduce_3 124# happyReduction_366-happyReduction_366 happy_x_3- happy_x_2- happy_x_1- = case happyOut132 happy_x_2 of { happy_var_2 -> - happyIn130- (reverse happy_var_2- )}--happyReduce_367 = happySpecReduce_2 125# happyReduction_367-happyReduction_367 happy_x_2- happy_x_1- = happyIn131- ([]- )--happyReduce_368 = happySpecReduce_1 125# happyReduction_368-happyReduction_368 happy_x_1- = case happyOut130 happy_x_1 of { happy_var_1 -> - happyIn131- (happy_var_1- )}--happyReduce_369 = happySpecReduce_3 126# happyReduction_369-happyReduction_369 happy_x_3- happy_x_2- happy_x_1- = case happyOut132 happy_x_1 of { happy_var_1 -> - case happyOut76 happy_x_3 of { happy_var_3 -> - happyIn132- (reverse happy_var_3 ++ happy_var_1- )}}--happyReduce_370 = happySpecReduce_1 126# happyReduction_370-happyReduction_370 happy_x_1- = case happyOut76 happy_x_1 of { happy_var_1 -> - happyIn132- (reverse happy_var_1- )}--happyNewToken action sts stk- = lexer(\tk -> - let cont i = happyDoAction i tk action sts stk in- case tk of {- TokEOF -> happyDoAction 76# tk action sts stk;- TokKeyword KwLet happy_dollar_dollar -> cont 1#;- TokKeyword KwIn happy_dollar_dollar -> cont 2#;- TokKeyword KwWhere happy_dollar_dollar -> cont 3#;- TokKeyword KwWith happy_dollar_dollar -> cont 4#;- TokKeyword KwRewrite happy_dollar_dollar -> cont 5#;- TokKeyword KwPostulate happy_dollar_dollar -> cont 6#;- TokKeyword KwPrimitive happy_dollar_dollar -> cont 7#;- TokKeyword KwOpen happy_dollar_dollar -> cont 8#;- TokKeyword KwImport happy_dollar_dollar -> cont 9#;- TokKeyword KwUsing happy_dollar_dollar -> cont 10#;- TokKeyword KwHiding happy_dollar_dollar -> cont 11#;- TokKeyword KwRenaming happy_dollar_dollar -> cont 12#;- TokKeyword KwTo happy_dollar_dollar -> cont 13#;- TokKeyword KwPublic happy_dollar_dollar -> cont 14#;- TokKeyword KwModule happy_dollar_dollar -> cont 15#;- TokKeyword KwData happy_dollar_dollar -> cont 16#;- TokKeyword KwCoData happy_dollar_dollar -> cont 17#;- TokKeyword KwRecord happy_dollar_dollar -> cont 18#;- TokKeyword KwConstructor happy_dollar_dollar -> cont 19#;- TokKeyword KwField happy_dollar_dollar -> cont 20#;- TokKeyword KwInfix happy_dollar_dollar -> cont 21#;- TokKeyword KwInfixL happy_dollar_dollar -> cont 22#;- TokKeyword KwInfixR happy_dollar_dollar -> cont 23#;- TokKeyword KwMutual happy_dollar_dollar -> cont 24#;- TokKeyword KwAbstract happy_dollar_dollar -> cont 25#;- TokKeyword KwPrivate happy_dollar_dollar -> cont 26#;- TokKeyword KwProp happy_dollar_dollar -> cont 27#;- TokKeyword KwSet happy_dollar_dollar -> cont 28#;- TokKeyword KwForall happy_dollar_dollar -> cont 29#;- TokKeyword KwSyntax happy_dollar_dollar -> cont 30#;- TokKeyword KwOPTIONS happy_dollar_dollar -> cont 31#;- TokKeyword KwBUILTIN happy_dollar_dollar -> cont 32#;- TokKeyword KwIMPORT happy_dollar_dollar -> cont 33#;- TokKeyword KwIMPOSSIBLE happy_dollar_dollar -> cont 34#;- TokKeyword KwETA happy_dollar_dollar -> cont 35#;- TokKeyword KwCOMPILED happy_dollar_dollar -> cont 36#;- TokKeyword KwCOMPILED_DATA happy_dollar_dollar -> cont 37#;- TokKeyword KwCOMPILED_TYPE happy_dollar_dollar -> cont 38#;- TokKeyword KwCOMPILED_EPIC happy_dollar_dollar -> cont 39#;- TokKeyword KwCOMPILED_JS happy_dollar_dollar -> cont 40#;- TokKeyword KwSTATIC happy_dollar_dollar -> cont 41#;- TokKeyword KwQuoteGoal happy_dollar_dollar -> cont 42#;- TokKeyword KwQuote happy_dollar_dollar -> cont 43#;- TokKeyword KwQuoteTerm happy_dollar_dollar -> cont 44#;- TokKeyword KwUnquote happy_dollar_dollar -> cont 45#;- TokSetN happy_dollar_dollar -> cont 46#;- TokTeX happy_dollar_dollar -> cont 47#;- TokComment happy_dollar_dollar -> cont 48#;- TokSymbol SymEllipsis happy_dollar_dollar -> cont 49#;- TokSymbol SymDotDot happy_dollar_dollar -> cont 50#;- TokSymbol SymDot happy_dollar_dollar -> cont 51#;- TokSymbol SymSemi happy_dollar_dollar -> cont 52#;- TokSymbol SymColon happy_dollar_dollar -> cont 53#;- TokSymbol SymEqual happy_dollar_dollar -> cont 54#;- TokSymbol SymUnderscore happy_dollar_dollar -> cont 55#;- TokSymbol SymQuestionMark happy_dollar_dollar -> cont 56#;- TokSymbol SymArrow happy_dollar_dollar -> cont 57#;- TokSymbol SymLambda happy_dollar_dollar -> cont 58#;- TokSymbol SymAs happy_dollar_dollar -> cont 59#;- TokSymbol SymBar happy_dollar_dollar -> cont 60#;- TokSymbol SymOpenParen happy_dollar_dollar -> cont 61#;- TokSymbol SymCloseParen happy_dollar_dollar -> cont 62#;- TokSymbol SymDoubleOpenBrace happy_dollar_dollar -> cont 63#;- TokSymbol SymDoubleCloseBrace happy_dollar_dollar -> cont 64#;- TokSymbol SymOpenBrace happy_dollar_dollar -> cont 65#;- TokSymbol SymCloseBrace happy_dollar_dollar -> cont 66#;- TokSymbol SymOpenVirtualBrace happy_dollar_dollar -> cont 67#;- TokSymbol SymCloseVirtualBrace happy_dollar_dollar -> cont 68#;- TokSymbol SymVirtualSemi happy_dollar_dollar -> cont 69#;- TokSymbol SymOpenPragma happy_dollar_dollar -> cont 70#;- TokSymbol SymClosePragma happy_dollar_dollar -> cont 71#;- TokId happy_dollar_dollar -> cont 72#;- TokQId happy_dollar_dollar -> cont 73#;- TokString happy_dollar_dollar -> cont 74#;- TokLiteral happy_dollar_dollar -> cont 75#;- _ -> happyError' tk- })--happyError_ 76# tk = happyError' tk-happyError_ _ tk = happyError' tk--happyThen :: () => Parser a -> (a -> Parser b) -> Parser b-happyThen = (>>=)-happyReturn :: () => a -> Parser a-happyReturn = (return)-happyThen1 = happyThen-happyReturn1 :: () => a -> Parser a-happyReturn1 = happyReturn-happyError' :: () => (Token) -> Parser a-happyError' tk = (\token -> happyError) tk--tokensParser = happySomeParser where- happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut6 x))--exprParser = happySomeParser where- happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut29 x))--moduleParser = happySomeParser where- happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut9 x))--happySeq = happyDontSeq---{--------------------------------------------------------------------------- Parsers- --------------------------------------------------------------------------}---- | Parse the token stream. Used by the TeX compiler.-tokensParser :: Parser [Token]---- | Parse an expression. Could be used in interactions.-exprParser :: Parser Expr---- | Parse a module.-moduleParser :: Parser Module---{--------------------------------------------------------------------------- Happy stuff- --------------------------------------------------------------------------}---- | Required by Happy.-happyError :: Parser a-happyError = parseError "Parse error"---{--------------------------------------------------------------------------- Utility functions- --------------------------------------------------------------------------}---- | Create a name from a string.--mkName :: (Interval, String) -> Parser Name-mkName (i, s) = do- let xs = parts s- mapM_ isValidId xs- unless (alternating xs) $ fail $ "a name cannot contain two consecutive underscores"- return $ Name (getRange i) xs- where- parts :: String -> [NamePart]- parts "" = []- parts ('_' : s) = Hole : parts s- parts s = Id x : parts s'- where (x, s') = break (== '_') s-- isValidId Hole = return ()- isValidId (Id x) = case parse defaultParseFlags [0] (lexer return) x of- ParseOk _ (TokId _) -> return ()- _ -> fail $ "in the name " ++ s ++ ", the part " ++ x ++ " is not valid"-- -- we know that there are no two Ids in a row- alternating (Hole : Hole : _) = False- alternating (_ : xs) = alternating xs- alternating [] = True---- | Create a qualified name from a list of strings-mkQName :: [(Interval, String)] -> Parser QName-mkQName ss = do- xs <- mapM mkName ss- return $ foldr Qual (QName $ last xs) (init xs)---- | Match a particular name.-isName :: String -> (Interval, String) -> Parser ()-isName s (_,s')- | s == s' = return ()- | otherwise = fail $ "expected " ++ s ++ ", found " ++ s'---- | Build a forall pi (forall x y z -> ...)-forallPi :: [LamBinding] -> Expr -> Expr-forallPi bs e = Pi (map addType bs) e---- | Converts lambda bindings to typed bindings.-addType :: LamBinding -> TypedBindings-addType (DomainFull b) = b-addType (DomainFree h rel x) = TypedBindings r $ Arg h rel $ TBind r [x] $ Underscore r Nothing- where r = getRange x---- | Check that an import directive doesn't contain repeated names-verifyImportDirective :: ImportDirective -> Parser ImportDirective-verifyImportDirective i =- case filter ((>1) . length)- $ group- $ sort xs- of- [] -> return i- yss -> let Just pos = rStart $ getRange $ head $ concat yss in- parseErrorAt pos $- "repeated name" ++ s ++ " in import directive: " ++- concat (intersperse ", " $ map (show . head) yss)- where- s = case yss of- [_] -> ""- _ -> "s"- where- xs = names (usingOrHiding i) ++ map renFrom (renaming i)- names (Using xs) = xs- names (Hiding xs) = xs---- | Breaks up a string into substrings. Returns every maximal--- subsequence of zero or more characters distinct from @'.'@.------ > splitOnDots "" == [""]--- > splitOnDots "foo.bar" == ["foo", "bar"]--- > splitOnDots ".foo.bar" == ["", "foo", "bar"]--- > splitOnDots "foo.bar." == ["foo", "bar", ""]--- > splitOnDots "foo..bar" == ["foo", "", "bar"]-splitOnDots :: String -> [String]-splitOnDots "" = [""]-splitOnDots ('.' : s) = [] : splitOnDots s-splitOnDots (c : s) = case splitOnDots s of- p : ps -> (c : p) : ps--prop_splitOnDots = and- [ splitOnDots "" == [""]- , splitOnDots "foo.bar" == ["foo", "bar"]- , splitOnDots ".foo.bar" == ["", "foo", "bar"]- , splitOnDots "foo.bar." == ["foo", "bar", ""]- , splitOnDots "foo..bar" == ["foo", "", "bar"]- ]---- | Returns 'True' iff the name is a valid Haskell (hierarchical)--- module name.-validHaskellModuleName :: String -> Bool-validHaskellModuleName = all ok . splitOnDots- where- -- Checks if a dot-less module name is well-formed.- ok :: String -> Bool- ok [] = False- ok (c : s) =- isUpper c &&- all (\c -> isLower c || c == '_' ||- isUpper c ||- generalCategory c == DecimalNumber ||- c == '\'')- s--{--------------------------------------------------------------------------- Patterns- --------------------------------------------------------------------------}---- | Turn an expression into a left hand side.-exprToLHS :: Expr -> Parser ([Expr] -> [Expr] -> LHS)-exprToLHS e = case e of- WithApp r e es -> LHS <$> exprToPattern e <*> mapM exprToPattern es- _ -> LHS <$> exprToPattern e <*> return []---- | Turn an expression into a pattern. Fails if the expression is not a--- valid pattern.-exprToPattern :: Expr -> Parser Pattern-exprToPattern e =- case e of- Ident x -> return $ IdentP x- App _ e1 e2 -> AppP <$> exprToPattern e1- <*> T.mapM (T.mapM exprToPattern) e2- Paren r e -> ParenP r- <$> exprToPattern e- Underscore r _ -> return $ WildP r- Absurd r -> return $ AbsurdP r- As r x e -> AsP r x <$> exprToPattern e- Dot r (HiddenArg _ e) -> return $ HiddenP r $ fmap (DotP r) e- Dot r e -> return $ DotP r e- Lit l -> return $ LitP l- HiddenArg r e -> HiddenP r <$> T.mapM exprToPattern e- InstanceArg r e -> InstanceP r <$> T.mapM exprToPattern e- RawApp r es -> RawAppP r <$> mapM exprToPattern es- OpApp r x es -> OpAppP r x <$> mapM opAppExprToPattern es- _ ->- let Just pos = rStart $ getRange e in- parseErrorAt pos $ "Not a valid pattern: " ++ show e--opAppExprToPattern :: OpApp Expr -> Parser Pattern-opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "syntax binding lambda cannot appear in a pattern"-opAppExprToPattern (Ordinary e) = exprToPattern e--parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug."--{--------------------------------------------------------------------------- Tests- --------------------------------------------------------------------------}---- | Test suite.-tests :: IO Bool-tests = runTests "Agda.Syntax.Parser.Parser"- [ quickCheck' prop_splitOnDots- ]-{-# LINE 1 "templates/GenericTemplate.hs" #-}-{-# LINE 1 "templates/GenericTemplate.hs" #-}-{-# LINE 1 "<built-in>" #-}-{-# LINE 1 "<command-line>" #-}-{-# LINE 1 "templates/GenericTemplate.hs" #-}--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp --{-# LINE 30 "templates/GenericTemplate.hs" #-}---data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList------{-# LINE 51 "templates/GenericTemplate.hs" #-}--{-# LINE 61 "templates/GenericTemplate.hs" #-}--{-# LINE 70 "templates/GenericTemplate.hs" #-}--infixr 9 `HappyStk`-data HappyStk a = HappyStk a (HappyStk a)---------------------------------------------------------------------------------- starting the parse--happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll---------------------------------------------------------------------------------- Accepting the parse---- If the current token is 0#, it means we've just accepted a partial--- parse (a %partial parser). We must ignore the saved token on the top of--- the stack in this case.-happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =- happyReturn1 ans-happyAccept j tk st sts (HappyStk ans _) = - (happyTcHack j (happyTcHack st)) (happyReturn1 ans)---------------------------------------------------------------------------------- Arrays only: do the next action----happyDoAction i tk st- = {- nothing -}--- case action of- 0# -> {- nothing -}- happyFail i tk st- -1# -> {- nothing -}- happyAccept i tk st- n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}-- (happyReduceArr Happy_Data_Array.! rule) i tk st- where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))- n -> {- nothing -}--- happyShift new_state i tk st- where (new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))- where (off) = indexShortOffAddr happyActOffsets st- (off_i) = (off Happy_GHC_Exts.+# i)- check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))- then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# i)- else False- (action)- | check = indexShortOffAddr happyTable off_i- | otherwise = indexShortOffAddr happyDefActions st--{-# LINE 130 "templates/GenericTemplate.hs" #-}---indexShortOffAddr (HappyA# arr) off =- Happy_GHC_Exts.narrow16Int# i- where- i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)- high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))- low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))- off' = off Happy_GHC_Exts.*# 2#------data HappyAddr = HappyA# Happy_GHC_Exts.Addr#------------------------------------------------------------------------------------- HappyState data type (not arrays)--{-# LINE 163 "templates/GenericTemplate.hs" #-}---------------------------------------------------------------------------------- Shifting a token--happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =- let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in--- trace "shifting the error token" $- happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)--happyShift new_state i tk st sts stk =- happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)---- happyReduce is specialised for the common cases.--happySpecReduce_0 i fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happySpecReduce_0 nt fn j tk st@((action)) sts stk- = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)--happySpecReduce_1 i fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')- = let r = fn v1 in- happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_2 i fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')- = let r = fn v1 v2 in- happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_3 i fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')- = let r = fn v1 v2 v3 in- happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happyReduce k i fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happyReduce k nt fn j tk st sts stk- = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of- sts1@((HappyCons (st1@(action)) (_))) ->- let r = fn stk in -- it doesn't hurt to always seq here...- happyDoSeq r (happyGoto nt j tk st1 sts1 r)--happyMonadReduce k nt fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happyMonadReduce k nt fn j tk st sts stk =- happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))- where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))- drop_stk = happyDropStk k stk--happyMonad2Reduce k nt fn 0# tk st sts stk- = happyFail 0# tk st sts stk-happyMonad2Reduce k nt fn j tk st sts stk =- happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))- where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))- drop_stk = happyDropStk k stk-- (off) = indexShortOffAddr happyGotoOffsets st1- (off_i) = (off Happy_GHC_Exts.+# nt)- (new_state) = indexShortOffAddr happyTable off_i-----happyDrop 0# l = l-happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t--happyDropStk 0# l = l-happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs---------------------------------------------------------------------------------- Moving to a new state after a reduction---happyGoto nt j tk st = - {- nothing -}- happyDoAction j tk new_state- where (off) = indexShortOffAddr happyGotoOffsets st- (off_i) = (off Happy_GHC_Exts.+# nt)- (new_state) = indexShortOffAddr happyTable off_i------------------------------------------------------------------------------------- Error recovery (0# is the error token)---- parse error if we are in recovery and we fail again-happyFail 0# tk old_st _ stk@(x `HappyStk` _) =- let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in--- trace "failing" $ - happyError_ i tk--{- We don't need state discarding for our restricted implementation of- "error". In fact, it can cause some bogus parses, so I've disabled it- for now --SDM---- discard a state-happyFail 0# tk old_st (HappyCons ((action)) (sts)) - (saved_tok `HappyStk` _ `HappyStk` stk) =--- trace ("discarding state, depth " ++ show (length stk)) $- happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))--}---- Enter error recovery: generate an error token,--- save the old token and carry on.-happyFail i tk (action) sts stk =--- trace "entering error recovery" $- happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)---- Internal happy errors:--notHappyAtAll :: a-notHappyAtAll = error "Internal Happy error\n"---------------------------------------------------------------------------------- Hack to get the typechecker to accept our action functions---happyTcHack :: Happy_GHC_Exts.Int# -> a -> a-happyTcHack x y = y-{-# INLINE happyTcHack #-}----------------------------------------------------------------------------------- Seq-ing. If the --strict flag is given, then Happy emits --- happySeq = happyDoSeq--- otherwise it emits--- happySeq = happyDontSeq--happyDoSeq, happyDontSeq :: a -> b -> b-happyDoSeq a b = a `seq` b-happyDontSeq a b = b---------------------------------------------------------------------------------- Don't inline any functions from the template. GHC has a nasty habit--- of deciding to inline happyGoto everywhere, which increases the size of--- the generated parser quite a bit.---{-# NOINLINE happyDoAction #-}-{-# NOINLINE happyTable #-}-{-# NOINLINE happyCheck #-}-{-# NOINLINE happyActOffsets #-}-{-# NOINLINE happyGotoOffsets #-}-{-# NOINLINE happyDefActions #-}--{-# NOINLINE happyShift #-}-{-# NOINLINE happySpecReduce_0 #-}-{-# NOINLINE happySpecReduce_1 #-}-{-# NOINLINE happySpecReduce_2 #-}-{-# NOINLINE happySpecReduce_3 #-}-{-# NOINLINE happyReduce #-}-{-# NOINLINE happyMonadReduce #-}-{-# NOINLINE happyGoto #-}-{-# NOINLINE happyFail #-}---- end of Happy Template.
@@ -1,102 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.2.0---------------------------------------------------------------------------Important changes since 2.1.2 (which was released 2007-08-16):--Language-----------* Exhaustive pattern checking. Agda complains if there are missing- clauses in a function definition.--* Coinductive types are supported. This feature is under- development/evaluation, and may change.-- http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Codatatypes--* Another experimental feature: Sized types, which can make it easier- to explain why your code is terminating.--* Improved constraint solving for functions with constructor headed- right hand sides.-- http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.FindingTheValuesOfImplicitArguments--* A simple, well-typed foreign function interface, which allows use of- Haskell functions in Agda code.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.FFI--* The tokens forall, -> and \ can be written as ∀, → and λ.--* Absurd lambdas: λ () and λ {}.-- http://thread.gmane.org/gmane.comp.lang.agda/440--* Record fields whose values can be inferred can be omitted.--* Agda complains if it spots an unreachable clause, or if a pattern- variable "shadows" a hidden constructor of matching type.-- http://thread.gmane.org/gmane.comp.lang.agda/720--Tools--------* Case-split: The user interface can replace a pattern variable with- the corresponding constructor patterns. You get one new left-hand- side for every possible constructor.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode--* The MAlonzo compiler.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.MAlonzo--* A new Emacs input method, which contains bindings for many Unicode- symbols, is by default activated in the Emacs mode.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.UnicodeInput--* Highlighted, hyperlinked HTML can be generated from Agda source- code.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.HowToGenerateWebPagesFromSourceCode--* The command-line interactive mode (agda -I) is no longer supported,- but should still work.-- http://thread.gmane.org/gmane.comp.lang.agda/245--* Reload times when working on large projects are now considerably- better.-- http://thread.gmane.org/gmane.comp.lang.agda/551--Libraries------------* A standard library is under development.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary--Documentation----------------* The Agda wiki is better organised. It should be easier for a- newcomer to find relevant information now.-- http://wiki.portal.chalmers.se/agda/--Infrastructure-----------------* Easy-to-install packages for Windows and Debian/Ubuntu have been- prepared.-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download--* Agda 2.2.0 is available from Hackage.-- http://hackage.haskell.org/
@@ -1,214 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.2.10---------------------------------------------------------------------------Important changes since 2.2.8:--Language-----------* New flag: --without-K.-- This flag makes pattern matching more restricted. If the flag is- activated, then Agda only accepts certain case-splits. If the type- of the variable to be split is D pars ixs, where D is a data (or- record) type, pars stands for the parameters, and ixs the indices,- then the following requirements must be satisfied:-- * The indices ixs must be applications of constructors to distinct- variables.-- * These variables must not be free in pars.-- The intended purpose of --without-K is to enable experiments with a- propositional equality without the K rule. Let us define- propositional equality as follows:-- data _≡_ {A : Set} : A → A → Set where- refl : ∀ x → x ≡ x-- Then the obvious implementation of the J rule is accepted:-- J : {A : Set} (P : {x y : A} → x ≡ y → Set) →- (∀ x → P (refl x)) →- ∀ {x y} (x≡y : x ≡ y) → P x≡y- J P p (refl x) = p x-- The same applies to Christine Paulin-Mohring's version of the J rule:-- J′ : {A : Set} {x : A} (P : {y : A} → x ≡ y → Set) →- P (refl x) →- ∀ {y} (x≡y : x ≡ y) → P x≡y- J′ P p (refl x) = p-- On the other hand, the obvious implementation of the K rule is not- accepted:-- K : {A : Set} (P : {x : A} → x ≡ x → Set) →- (∀ x → P (refl x)) →- ∀ {x} (x≡x : x ≡ x) → P x≡x- K P p (refl x) = p x-- However, we have /not/ proved that activation of --without-K ensures- that the K rule cannot be proved in some other way.--* Irrelevant declarations.-- Postulates and functions can be marked as irrelevant by prefixing- the name with a dot when the name is declared. Example:-- postulate- .irrelevant : {A : Set} → .A → A-- Irrelevant names may only be used in irrelevant positions or in- definitions of things which have been declared irrelevant.-- The axiom irrelevant above can be used to define a projection from- an irrelevant record field:-- data Subset (A : Set) (P : A → Set) : Set where- _#_ : (a : A) → .(P a) → Subset A P-- elem : ∀ {A P} → Subset A P → A- elem (a # p) = a-- .certificate : ∀ {A P} (x : Subset A P) → P (elem x)- certificate (a # p) = irrelevant p-- The right-hand side of certificate is relevant, so we cannot define-- certificate (a # p) = p-- (because p is irrelevant). However, certificate is declared to be- irrelevant, so it can use the axiom irrelevant. Furthermore the- first argument of the axiom is irrelevant, which means that- irrelevant p is well-formed.-- As shown above the axiom irrelevant justifies irrelevant- projections. Previously no projections were generated for irrelevant- record fields, such as the field certificate in the following- record type:-- record Subset (A : Set) (P : A → Set) : Set where- constructor _#_- field- elem : A- .certificate : P elem-- Now projections are generated automatically for irrelevant fields- (unless the flag --no-irrelevant-projections is used). Note that- irrelevant projections are highly experimental.--* Termination checker recognises projections.-- Projections now preserve sizes, both in patterns and expressions.- Example:-- record Wrap (A : Set) : Set where- constructor wrap- field- unwrap : A-- open Wrap public-- data WNat : Set where- zero : WNat- suc : Wrap WNat → WNat-- id : WNat → WNat- id zero = zero- id (suc w) = suc (wrap (id (unwrap w)))-- In the structural ordering unwrap w ≤ w. This means that-- unwrap w ≤ w < suc w,-- and hence the recursive call to id is accepted.-- Projections also preserve guardedness.--Tools--------* Hyperlinks for top-level module names now point to the start of the- module rather than to the declaration of the module name. This- applies both to the Emacs mode and to the output of agda --html.--* Most occurrences of record field names are now highlighted as- "fields". Previously many occurrences were highlighted as- "functions".--* Emacs mode: It is no longer possible to change the behaviour of the- TAB key by customising agda2-indentation.--* Epic compiler backend.-- A new compiler backend is being implemented. This backend makes use- of Edwin Brady's language Epic- (http://www.cs.st-andrews.ac.uk/~eb/epic.php) and its compiler. The- backend should handle most Agda code, but is still at an- experimental stage: more testing is needed, and some things written- below may not be entirely true.-- The Epic compiler can be invoked from the command line using the- flag --epic:-- agda --epic --epic-flag=<EPIC-FLAG> --compile-dir=<DIR> <FILE>.agda-- The --epic-flag flag can be given multiple times; each flag is given- verbatim to the Epic compiler (in the given order). The resulting- executable is named after the main module and placed in the- directory specified by the --compile-dir flag (default: the project- root). Intermediate files are placed in a subdirectory called Epic.-- The backend requires that there is a definition named main. This- definition should be a value of type IO Unit, but at the moment this- is not checked (so it is easy to produce a program which segfaults).- Currently the backend represents actions of type IO A as functions- from Unit to A, and main is applied to the unit value.-- The Epic compiler compiles via C, not Haskell, so the pragmas- related to the Haskell FFI (IMPORT, COMPILED_DATA and COMPILED) are- not used by the Epic backend. Instead there is a new pragma- COMPILED_EPIC. This pragma is used to give Epic code for postulated- definitions (Epic code can in turn call C code). The form of the- pragma is {-# COMPILED_EPIC def code #-}, where def is the name of- an Agda postulate and code is some Epic code which should include- the function arguments, return type and function body. As an example- the IO monad can be defined as follows:-- postulate- IO : Set → Set- return : ∀ {A} → A → IO A- _>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B-- {-# COMPILED_EPIC return (u : Unit, a : Any) -> Any =- ioreturn(a) #-}- {-# COMPILED_EPIC- _>>=_ (u1 : Unit, u2 : Unit, x : Any, f : Any) -> Any =- iobind(x,f) #-}-- Here ioreturn and iobind are Epic functions which are defined in the- file AgdaPrelude.e which is always included.-- By default the backend will remove so-called forced constructor- arguments (and case-splitting on forced variables will be- rewritten). This optimisation can be disabled by using the flag- --no-forcing.-- All data types which look like unary natural numbers after forced- constructor arguments have been removed (i.e. types with two- constructors, one nullary and one with a single recursive argument)- will be represented as "BigInts". This applies to the standard Fin- type, for instance.-- The backend supports Agda's primitive functions and the BUILTIN- pragmas. If the BUILTIN pragmas for unary natural numbers are used,- then some operations, like addition and multiplication, will use- more efficient "BigInt" operations.-- If you want to make use of the Epic backend you need to install some- dependencies, see the README.--* The Emacs mode can compile using either the MAlonzo or the Epic- backend. The variable agda2-backend controls which backend is used.
@@ -1,23 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.2.2---------------------------------------------------------------------------Important changes since 2.2.0:--Tools--------* The --malonzodir option has been renamed to --malonzo-dir.--* The output of agda --html is by default placed in a directory called- "html".--Infrastructure-----------------* The Emacs mode is included in the Agda Cabal package, and installed- by cabal install. The recommended way to enable the Emacs mode is to- include the following code in .emacs:-- (load-file (let ((coding-system-for-read 'utf-8))- (shell-command-to-string "agda-mode locate")))
@@ -1,47 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.2.4---------------------------------------------------------------------------Important changes since 2.2.2:--* Change to the semantics of "open import" and "open module". The- declaration-- open import M <using/hiding/renaming>-- now translates to-- import A- open A <using/hiding/renaming>-- instead of-- import A <using/hiding/renaming>- open A.-- The same translation is used for "open module M = E …". Declarations- involving the keywords as or public are changed in a corresponding- way ("as" always goes with import, and "public" always with open).-- This change means that import directives do not affect the qualified- names when open import/module is used. To get the old behaviour you- can use the expanded version above.--* Names opened publicly in parameterised modules no longer inherit the- module parameters. Example:-- module A where- postulate X : Set-- module B (Y : Set) where- open A public-- In Agda 2.2.2 B.X has type (Y : Set) → Set, whereas in Agda 2.2.4- B.X has type Set.--* Previously it was not possible to export a given constructor name- through two different "open public" statements in the same module.- This is now possible.--* Unicode subscript digits are now allowed for the hierarchy of- universes (Set₀, Set₁, …): Set₁ is equivalent to Set1.
@@ -1,257 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.2.6---------------------------------------------------------------------------Important changes since 2.2.4:--Language-----------* Universe polymorphism (experimental extension).-- To enable universe polymorphism give the flag- --universe-polymorphism on the command line or (recommended) as an- OPTIONS pragma.-- When universe polymorphism is enabled Set takes an argument which is- the universe level. For instance, the type of universe polymorphic- identity is-- id : {a : Level} {A : Set a} → A → A.-- The type Level is isomorphic to the unary natural numbers and should be- specified using the BUILTINs LEVEL, LEVELZERO, and LEVELSUC:-- data Level : Set where- zero : Level- suc : Level → Level-- {-# BUILTIN LEVEL Level #-}- {-# BUILTIN LEVELZERO zero #-}- {-# BUILTIN LEVELSUC suc #-}-- There is an additional BUILTIN LEVELMAX for taking the maximum of two- levels:-- max : Level → Level → Level- max zero m = m- max (suc n) zero = suc n- max (suc n) (suc m) = suc (max n m)-- {-# BUILTIN LEVELMAX max #-}-- The non-polymorphic universe levels Set, Set₁ and so on are sugar- for Set zero, Set (suc zero), etc.-- At present there is no automatic lifting of types from one level to- another. It can still be done (rather clumsily) by defining types- like the following one:-- data Lifted {a} (A : Set a) : Set (suc a) where- lift : A → Lifted A-- However, it is likely that automatic lifting is introduced at some- point in the future.--* Multiple constructors, record fields, postulates or primitives can- be declared using a single type signature:-- data Bool : Set where- false true : Bool-- postulate- A B : Set--* Record fields can be implicit:-- record R : Set₁ where- field- {A} : Set- f : A → A- {B C} D {E} : Set- g : B → C → E-- By default implicit fields are not printed.--* Record constructors can be defined:-- record Σ (A : Set) (B : A → Set) : Set where- constructor _,_- field- proj₁ : A- proj₂ : B proj₁-- In this example _,_ gets the type-- (proj₁ : A) → B proj₁ → Σ A B.-- For implicit fields the corresponding constructor arguments become- implicit.-- Note that the constructor is defined in the /outer/ scope, so any- fixity declaration has to be given outside the record definition.- The constructor is not in scope inside the record module.-- Note also that pattern matching for records has not been implemented- yet.--* BUILTIN hooks for equality.-- The data type-- data _≡_ {A : Set} (x : A) : A → Set where- refl : x ≡ x-- can be specified as the builtin equality type using the following- pragmas:-- {-# BUILTIN EQUALITY _≡_ #-}- {-# BUILTIN REFL refl #-}-- The builtin equality is used for the new rewrite construct and- the primTrustMe primitive described below.--* New rewrite construct.-- If eqn : a ≡ b, where _≡_ is the builtin equality (see above) you- can now write-- f ps rewrite eqn = rhs-- instead of-- f ps with a | eqn- ... | ._ | refl = rhs-- The rewrite construct has the effect of rewriting the goal and the- context by the given equation (left to right).-- You can rewrite using several equations (in sequence) by separating- them with vertical bars (|):-- f ps rewrite eqn₁ | eqn₂ | … = rhs-- It is also possible to add with clauses after rewriting:-- f ps rewrite eqns with e- ... | p = rhs-- Note that pattern matching happens before rewriting—if you want to- rewrite and then do pattern matching you can use a with after the- rewrite.-- See test/succeed/Rewrite.agda for some examples.--* A new primitive, primTrustMe, has been added:-- primTrustMe : {A : Set} {x y : A} → x ≡ y-- Here _≡_ is the builtin equality (see BUILTIN hooks for equality,- above).-- If x and y are definitionally equal, then- primTrustMe {x = x} {y = y} reduces to refl.-- Note that the compiler replaces all uses of primTrustMe with the- REFL builtin, without any check for definitional equality. Incorrect- uses of primTrustMe can potentially lead to segfaults or similar- problems.-- For an example of the use of primTrustMe, see Data.String in version- 0.3 of the standard library, where it is used to implement decidable- equality on strings using the primitive boolean equality.--* Changes to the syntax and semantics of IMPORT pragmas, which are- used by the Haskell FFI. Such pragmas must now have the following- form:-- {-# IMPORT <module name> #-}-- These pragmas are interpreted as /qualified/ imports, so Haskell- names need to be given qualified (unless they come from the Haskell- prelude).--* The horizontal tab character (U+0009) is no longer treated as white- space.--* Line pragmas are no longer supported.--* The --include-path flag can no longer be used as a pragma.--* The experimental and incomplete support for proof irrelevance has- been disabled.--Tools--------* New "intro" command in the Emacs mode. When there is a canonical way- of building something of the goal type (for instance, if the goal- type is a pair), the goal can be refined in this way. The command- works for the following goal types:-- - A data type where only one of its constructors can be used to- construct an element of the goal type. (For instance, if the- goal is a non-empty vector, a "cons" will be introduced.)-- - A record type. A record value will be introduced. Implicit- fields will not be included unless showing of implicit arguments- is switched on.-- - A function type. A lambda binding as many variables as possible- will be introduced. The variable names will be chosen from the- goal type if its normal form is a dependent function type,- otherwise they will be variations on "x". Implicit lambdas will- only be inserted if showing of implicit arguments is switched- on.-- This command can be invoked by using the refine command (C-c C-r)- when the goal is empty. (The old behaviour of the refine command in- this situation was to ask for an expression using the minibuffer.)--* The Emacs mode displays "Checked" in the mode line if the current- file type checked successfully without any warnings.--* If a file F is loaded, and this file defines the module M, it is an- error if F is not the file which defines M according to the include- path.-- Note that the command-line tool and the Emacs mode define the- meaning of relative include paths differently: the command-line tool- interprets them relative to the current working directory, whereas- the Emacs mode interprets them relative to the root directory of the- current project. (As an example, if the module A.B.C is loaded from- the file <some-path>/A/B/C.agda, then the root directory is- <some-path>.)--* It is an error if there are several files on the include path which- match a given module name.--* Interface files are relocatable. You can move around source trees as- long as the include path is updated in a corresponding way. Note- that a module M may be re-typechecked if its time stamp is strictly- newer than that of the corresponding interface file (M.agdai).--* Type-checking is no longer done when an up-to-date interface exists.- (Previously the initial module was always type-checked.)--* Syntax highlighting files for Emacs (.agda.el) are no longer used.- The --emacs flag has been removed. (Syntax highlighting information- is cached in the interface files.)--* The Agate and Alonzo compilers have been retired. The options- --agate, --alonzo and --malonzo have been removed.--* The default directory for MAlonzo output is the project's root- directory. The --malonzo-dir flag has been renamed to --compile-dir.--* Emacs mode: C-c C-x C-d no longer resets the type checking state.- C-c C-x C-r can be used for a more complete reset. C-c C-x C-s- (which used to reload the syntax highlighting information) has been- removed. C-c C-l can be used instead.--* The Emacs mode used to define some "abbrevs", unless the user- explicitly turned this feature off. The new default is /not/ to add- any abbrevs. The old default can be obtained by customising- agda2-mode-abbrevs-use-defaults (a customisation buffer can be- obtained by typing M-x customize-group agda2 RET after an Agda file- has been loaded).
@@ -1,564 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.2.8---------------------------------------------------------------------------Important changes since 2.2.6:--Language-----------* Record pattern matching.-- It is now possible to pattern match on named record constructors.- Example:-- record Σ (A : Set) (B : A → Set) : Set where- constructor _,_- field- proj₁ : A- proj₂ : B proj₁-- map : {A B : Set} {P : A → Set} {Q : B → Set}- (f : A → B) → (∀ {x} → P x → Q (f x)) →- Σ A P → Σ B Q- map f g (x , y) = (f x , g y)-- The clause above is internally translated into the following one:-- map f g p = (f (Σ.proj₁ p) , g (Σ.proj₂ p))-- Record patterns containing data type patterns are not translated.- Example:-- add : ℕ × ℕ → ℕ- add (zero , n) = n- add (suc m , n) = suc (add (m , n))-- Record patterns which do not contain data type patterns, but which- do contain dot patterns, are currently rejected. Example:-- Foo : {A : Set} (p₁ p₂ : A × A) → proj₁ p₁ ≡ proj₁ p₂ → Set₁- Foo (x , y) (.x , y′) refl = Set--* Proof irrelevant function types.-- Agda now supports irrelevant non-dependent function types:-- f : .A → B-- This type implies that f does not depend computationally on its- argument. One intended use case is data structures with embedded- proofs, like sorted lists:-- postulate- _≤_ : ℕ → ℕ → Set- p₁ : 0 ≤ 1- p₂ : 0 ≤ 1-- data SList (bound : ℕ) : Set where- [] : SList bound- scons : (head : ℕ) →- .(head ≤ bound) →- (tail : SList head) →- SList bound-- The effect of the irrelevant type in the signature of scons is that- scons's second argument is never inspected after Agda has ensured- that it has the right type. It is even thrown away, leading to- smaller term sizes and hopefully some gain in efficiency. The- type-checker ignores irrelevant arguments when checking equality, so- two lists can be equal even if they contain different proofs:-- l₁ : SList 1- l₁ = scons 0 p₁ []-- l₂ : SList 1- l₂ = scons 0 p₂ []-- l₁≡l₂ : l₁ ≡ l₂- l₁≡l₂ = refl-- Irrelevant arguments can only be used in irrelevant contexts.- Consider the following subset type:-- data Subset (A : Set) (P : A → Set) : Set where- _#_ : (elem : A) → .(P elem) → Subset A P-- The following two uses are fine:-- elimSubset : ∀ {A C : Set} {P} →- Subset A P → ((a : A) → .(P a) → C) → C- elimSubset (a # p) k = k a p-- elem : {A : Set} {P : A → Set} → Subset A P → A- elem (x # p) = x-- However, if we try to project out the proof component, then Agda- complains that "variable p is declared irrelevant, so it cannot be- used here":-- prjProof : ∀ {A P} (x : Subset A P) → P (elem x)- prjProof (a # p) = p-- Matching against irrelevant arguments is also forbidden, except in- the case of irrefutable matches (record constructor patterns which- have been translated away). For instance, the match against the- pattern (p , q) here is accepted:-- elim₂ : ∀ {A C : Set} {P Q : A → Set} →- Subset A (λ x → Σ (P x) (λ _ → Q x)) →- ((a : A) → .(P a) → .(Q a) → C) → C- elim₂ (a # (p , q)) k = k a p q-- Absurd matches () are also allowed.-- Note that record fields can also be irrelevant. Example:-- record Subset (A : Set) (P : A → Set) : Set where- constructor _#_- field- elem : A- .proof : P elem-- Irrelevant fields are never in scope, neither inside nor outside the- record. This means that no record field can depend on an irrelevant- field, and furthermore projections are not defined for such fields.- Irrelevant fields can only be accessed using pattern matching, as in- elimSubset above.-- Irrelevant function types were added very recently, and have not- been subjected to much experimentation yet, so do not be surprised- if something is changed before the next release. For instance,- dependent irrelevant function spaces (.(x : A) → B) might be added- in the future.--* Mixfix binders.-- It is now possible to declare user-defined syntax that binds- identifiers. Example:-- postulate- State : Set → Set → Set- put : ∀ {S} → S → State S ⊤- get : ∀ {S} → State S S- return : ∀ {A S} → A → State S A- bind : ∀ {A B S} → State S B → (B → State S A) → State S A-- syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂-- increment : State ℕ ⊤- increment = x ← get ,- put (1 + x)-- The syntax declaration for bind implies that x is in scope in e₂,- but not in e₁.-- You can give fixity declarations along with syntax declarations:-- infixr 40 bind- syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂-- The fixity applies to the syntax, not the name; syntax declarations- are also restricted to ordinary, non-operator names. The following- declaration is disallowed:-- syntax _==_ x y = x === y-- Syntax declarations must also be linear; the following declaration- is disallowed:-- syntax wrong x = x + x-- Syntax declarations were added very recently, and have not been- subjected to much experimentation yet, so do not be surprised if- something is changed before the next release.--* Prop has been removed from the language.-- The experimental sort Prop has been disabled. Any program using Prop- should typecheck if Prop is replaced by Set₀. Note that Prop is still- a keyword.--* Injective type constructors off by default.-- Automatic injectivity of type constructors has been disabled (by- default). To enable it, use the flag --injective-type-constructors,- either on the command line or in an OPTIONS pragma. Note that this- flag makes Agda anti-classical and possibly inconsistent:-- Agda with excluded middle is inconsistent- http://thread.gmane.org/gmane.comp.lang.agda/1367-- See test/succeed/InjectiveTypeConstructors.agda for an example.--* Termination checker can count.-- There is a new flag --termination-depth=N accepting values N >= 1- (with N = 1 being the default) which influences the behavior of the- termination checker. So far, the termination checker has only- distinguished three cases when comparing the argument of a recursive- call with the formal parameter of the callee.-- < : the argument is structurally smaller than the parameter- = : they are equal- ? : the argument is bigger or unrelated to the parameter-- This behavior, which is still the default (N = 1), will not- recognise the following functions as terminating.-- mutual-- f : ℕ → ℕ- f zero = zero- f (suc zero) = zero- f (suc (suc n)) = aux n-- aux : ℕ → ℕ- aux m = f (suc m)-- The call graph-- f --(<)--> aux --(?)--> f-- yields a recursive call from f to f via aux where the relation of- call argument to callee parameter is computed as "unrelated"- (composition of < and ?).-- Setting N >= 2 allows a finer analysis: n has two constructors less- than suc (suc n), and suc m has one more than m, so we get the call- graph:-- f --(-2)--> aux --(+1)--> f-- The indirect call f --> f is now labeled with (-1), and the- termination checker can recognise that the call argument is- decreasing on this path.-- Setting the termination depth to N means that the termination- checker counts decrease up to N and increase up to N-1. The default,- N=1, means that no increase is counted, every increase turns to- "unrelated".-- In practice, examples like the one above sometimes arise when "with"- is used. As an example, the program-- f : ℕ → ℕ- f zero = zero- f (suc zero) = zero- f (suc (suc n)) with zero- ... | _ = f (suc n)-- is internally represented as-- mutual-- f : ℕ → ℕ- f zero = zero- f (suc zero) = zero- f (suc (suc n)) = aux n zero-- aux : ℕ → ℕ → ℕ- aux m k = f (suc m)-- Thus, by default, the definition of f using "with" is not accepted- by the termination checker, even though it looks structural (suc n- is a subterm of suc suc n). Now, the termination checker is- satisfied if the option "--termination-depth=2" is used.-- Caveats:-- - This is an experimental feature, hopefully being replaced by- something smarter in the near future.-- - Increasing the termination depth will quickly lead to very long- termination checking times. So, use with care. Setting termination- depth to 100 by habit, just to be on the safe side, is not a good- idea!-- - Increasing termination depth only makes sense for linear data- types such as ℕ and Size. For other types, increase cannot be- recognised. For instance, consider a similar example with lists.-- data List : Set where- nil : List- cons : ℕ → List → List-- mutual- f : List → List- f nil = nil- f (cons x nil) = nil- f (cons x (cons y ys)) = aux y ys-- aux : ℕ → List → List- aux z zs = f (cons z zs)-- Here the termination checker compares cons z zs to z and also to- zs. In both cases, the result will be "unrelated", no matter how- high we set the termination depth. This is because when comparing- cons z zs to zs, for instance, z is unrelated to zs, thus,- cons z zs is also unrelated to zs. We cannot say it is just "one- larger" since z could be a very large term. Note that this points- to a weakness of untyped termination checking.-- To regain the benefit of increased termination depth, we need to- index our lists by a linear type such as ℕ or Size. With- termination depth 2, the above example is accepted for vectors- instead of lists.--* The codata keyword has been removed. To use coinduction, use the- following new builtins: INFINITY, SHARP and FLAT. Example:-- {-# OPTIONS --universe-polymorphism #-}-- module Coinduction where-- open import Level-- infix 1000 ♯_-- postulate- ∞ : ∀ {a} (A : Set a) → Set a- ♯_ : ∀ {a} {A : Set a} → A → ∞ A- ♭ : ∀ {a} {A : Set a} → ∞ A → A-- {-# BUILTIN INFINITY ∞ #-}- {-# BUILTIN SHARP ♯_ #-}- {-# BUILTIN FLAT ♭ #-}-- Note that (non-dependent) pattern matching on SHARP is no longer- allowed.-- Note also that strange things might happen if you try to combine the- pragmas above with COMPILED_TYPE, COMPILED_DATA or COMPILED pragmas,- or if the pragmas do not occur right after the postulates.-- The compiler compiles the INFINITY builtin to nothing (more or- less), so that the use of coinduction does not get in the way of FFI- declarations:-- data Colist (A : Set) : Set where- [] : Colist A- _∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A-- {-# COMPILED_DATA Colist [] [] (:) #-}--* Infinite types.-- If the new flag --guardedness-preserving-type-constructors is used,- then type constructors are treated as inductive constructors when we- check productivity (but only in parameters, and only if they are- used strictly positively or not at all). This makes examples such as- the following possible:-- data Rec (A : ∞ Set) : Set where- fold : ♭ A → Rec A-- -- Σ cannot be a record type below.-- data Σ (A : Set) (B : A → Set) : Set where- _,_ : (x : A) → B x → Σ A B-- syntax Σ A (λ x → B) = Σ[ x ∶ A ] B-- -- Corecursive definition of the W-type.-- W : (A : Set) → (A → Set) → Set- W A B = Rec (♯ (Σ[ x ∶ A ] (B x → W A B)))-- syntax W A (λ x → B) = W[ x ∶ A ] B-- sup : {A : Set} {B : A → Set} (x : A) (f : B x → W A B) → W A B- sup x f = fold (x , f)-- W-rec : {A : Set} {B : A → Set}- (P : W A B → Set) →- (∀ {x} {f : B x → W A B} → (∀ y → P (f y)) → P (sup x f)) →- ∀ x → P x- W-rec P h (fold (x , f)) = h (λ y → W-rec P h (f y))-- -- Induction-recursion encoded as corecursion-recursion.-- data Label : Set where- ′0 ′1 ′2 ′σ ′π ′w : Label-- mutual-- U : Set- U = Σ Label U′-- U′ : Label → Set- U′ ′0 = ⊤- U′ ′1 = ⊤- U′ ′2 = ⊤- U′ ′σ = Rec (♯ (Σ[ a ∶ U ] (El a → U)))- U′ ′π = Rec (♯ (Σ[ a ∶ U ] (El a → U)))- U′ ′w = Rec (♯ (Σ[ a ∶ U ] (El a → U)))-- El : U → Set- El (′0 , _) = ⊥- El (′1 , _) = ⊤- El (′2 , _) = Bool- El (′σ , fold (a , b)) = Σ[ x ∶ El a ] El (b x)- El (′π , fold (a , b)) = (x : El a) → El (b x)- El (′w , fold (a , b)) = W[ x ∶ El a ] El (b x)-- U-rec : (P : ∀ u → El u → Set) →- P (′1 , _) tt →- P (′2 , _) true →- P (′2 , _) false →- (∀ {a b x y} →- P a x → P (b x) y → P (′σ , fold (a , b)) (x , y)) →- (∀ {a b f} →- (∀ x → P (b x) (f x)) → P (′π , fold (a , b)) f) →- (∀ {a b x f} →- (∀ y → P (′w , fold (a , b)) (f y)) →- P (′w , fold (a , b)) (sup x f)) →- ∀ u (x : El u) → P u x- U-rec P P1 P2t P2f Pσ Pπ Pw = rec- where- rec : ∀ u (x : El u) → P u x- rec (′0 , _) ()- rec (′1 , _) _ = P1- rec (′2 , _) true = P2t- rec (′2 , _) false = P2f- rec (′σ , fold (a , b)) (x , y) = Pσ (rec _ x) (rec _ y)- rec (′π , fold (a , b)) f = Pπ (λ x → rec _ (f x))- rec (′w , fold (a , b)) (fold (x , f)) = Pw (λ y → rec _ (f y))-- The --guardedness-preserving-type-constructors extension is based on- a rather operational understanding of ∞/♯_; it's not yet clear if- this extension is consistent.--* Qualified constructors.-- Constructors can now be referred to qualified by their data type.- For instance, given-- data Nat : Set where- zero : Nat- suc : Nat → Nat-- data Fin : Nat → Set where- zero : ∀ {n} → Fin (suc n)- suc : ∀ {n} → Fin n → Fin (suc n)-- you can refer to the constructors unambiguously as Nat.zero,- Nat.suc, Fin.zero, and Fin.suc (Nat and Fin are modules containing- the respective constructors). Example:-- inj : (n m : Nat) → Nat.suc n ≡ suc m → n ≡ m- inj .m m refl = refl-- Previously you had to write something like-- inj : (n m : Nat) → _≡_ {Nat} (suc n) (suc m) → n ≡ m-- to make the type checker able to figure out that you wanted the- natural number suc in this case.--* Reflection.-- There are two new constructs for reflection:-- - quoteGoal x in e-- In e the value of x will be a representation of the goal type- (the type expected of the whole expression) as an element in a- datatype of Agda terms (see below). For instance,-- example : ℕ- example = quoteGoal x in {! at this point x = def (quote ℕ) [] !}-- - quote x : Name-- If x is the name of a definition (function, datatype, record, or- a constructor), quote x gives you the representation of x as a- value in the primitive type Name (see below).-- Quoted terms use the following BUILTINs and primitives (available- from the standard library module Reflection):-- -- The type of Agda names.-- postulate Name : Set-- {-# BUILTIN QNAME Name #-}-- primitive primQNameEquality : Name → Name → Bool-- -- Arguments.-- Explicit? = Bool-- data Arg A : Set where- arg : Explicit? → A → Arg A-- {-# BUILTIN ARG Arg #-}- {-# BUILTIN ARGARG arg #-}-- -- The type of Agda terms.-- data Term : Set where- var : ℕ → List (Arg Term) → Term- con : Name → List (Arg Term) → Term- def : Name → List (Arg Term) → Term- lam : Explicit? → Term → Term- pi : Arg Term → Term → Term- sort : Term- unknown : Term-- {-# BUILTIN AGDATERM Term #-}- {-# BUILTIN AGDATERMVAR var #-}- {-# BUILTIN AGDATERMCON con #-}- {-# BUILTIN AGDATERMDEF def #-}- {-# BUILTIN AGDATERMLAM lam #-}- {-# BUILTIN AGDATERMPI pi #-}- {-# BUILTIN AGDATERMSORT sort #-}- {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}-- Reflection may be useful when working with internal decision- procedures, such as the standard library's ring solver.--* Minor record definition improvement.-- The definition of a record type is now available when type checking- record module definitions. This means that you can define things- like the following:-- record Cat : Set₁ where- field- Obj : Set- _=>_ : Obj → Obj → Set- -- ...-- -- not possible before:- op : Cat- op = record { Obj = Obj; _=>_ = λ A B → B => A }--Tools--------* The "Goal type and context" command now shows the goal type before- the context, and the context is shown in reverse order. The "Goal- type, context and inferred type" command has been modified in a- similar way.--* Show module contents command.-- Given a module name M the Emacs mode can now display all the- top-level modules and names inside M, along with types for the- names. The command is activated using C-c C-o or the menus.--* Auto command.-- A command which searches for type inhabitants has been added. The- command is invoked by pressing C-C C-a (or using the goal menu).- There are several flags and parameters, e.g. '-c' which enables- case-splitting in the search. For further information, see the Agda- wiki:-- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Auto--* HTML generation is now possible for a module with unsolved- meta-variables, provided that the --allow-unsolved-metas flag is- used.
@@ -1,1005 +0,0 @@---------------------------------------------------------------------------- Release notes for Agda 2 version 2.3.0---------------------------------------------------------------------------Important changes since 2.2.10:--Language-========--* New more liberal syntax for mutually recursive definitions.-- It is no longer necessary to use the 'mutual' keyword to define- mutually recursive functions or datatypes. Instead, it is enough to- declare things before they are used. Instead of-- mutual- f : A- f = a[f, g]-- g : B[f]- g = b[f, g]-- you can now write-- f : A- g : B[f]- f = a[f, g]- g = b[f, g].-- With the new style you have more freedom in choosing the order in- which things are type checked (previously type signatures were- always checked before definitions). Furthermore you can mix- arbitrary declarations, such as modules and postulates, with- mutually recursive definitions.-- For data types and records the following new syntax is used to- separate the declaration from the definition:-- -- Declaration.- data Vec (A : Set) : Nat → Set -- Note the absence of 'where'.-- -- Definition.- data Vec A where- [] : Vec A zero- _::_ : {n : Nat} → A → Vec A n → Vec A (suc n)-- -- Declaration.- record Sigma (A : Set) (B : A → Set) : Set-- -- Definition.- record Sigma A B where- constructor _,_- field fst : A- snd : B fst-- When making separated declarations/definitions private or abstract- you should attach the 'private' keyword to the declaration and the- 'abstract' keyword to the definition. For instance, a private,- abstract function can be defined as-- private- f : A- abstract- f = e-- Finally it may be worth noting that the old style of mutually- recursive definitions is still supported (it basically desugars into- the new style).--* Pattern matching lambdas.-- Anonymous pattern matching functions can be defined using the syntax-- \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em }-- (where, as usual, \ and -> can be replaced by λ and →). Internally- this is translated into a function definition of the following form:-- .extlam p11 .. p1n = e1- ...- .extlam pm1 .. pmn = em-- This means that anonymous pattern matching functions are generative.- For instance, refl will not be accepted as an inhabitant of the type-- (λ { true → true ; false → false }) ≡- (λ { true → true ; false → false }),-- because this is equivalent to extlam1 ≡ extlam2 for some distinct- fresh names extlam1 and extlam2.-- Currently the 'where' and 'with' constructions are not allowed in- (the top-level clauses of) anonymous pattern matching functions.-- Examples:-- and : Bool → Bool → Bool- and = λ { true x → x ; false _ → false }-- xor : Bool → Bool → Bool- xor = λ { true true → false- ; false false → false- ; _ _ → true- }-- fst : {A : Set} {B : A → Set} → Σ A B → A- fst = λ { (a , b) → a }-- snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p)- snd = λ { (a , b) → b }--* Record update syntax.-- Assume that we have a record type and a corresponding value:-- record MyRecord : Set where- field- a b c : ℕ-- old : MyRecord- old = record { a = 1; b = 2; c = 3 }-- Then we can update (some of) the record value's fields in the- following way:-- new : MyRecord- new = record old { a = 0; c = 5 }-- Here new normalises to record { a = 0; b = 2; c = 5 }. Any- expression yielding a value of type MyRecord can be used instead of- old.-- Record updating is not allowed to change types: the resulting value- must have the same type as the original one, including the record- parameters. Thus, the type of a record update can be inferred if the type- of the original record can be inferred.-- The record update syntax is expanded before type checking. When the- expression-- record old { upd-fields }-- is checked against a record type R, it is expanded to-- let r = old in record { new-fields },-- where old is required to have type R and new-fields is defined as- follows: for each field x in R,-- - if x = e is contained in upd-fields then x = e is included in- new-fields, and otherwise- - if x is an explicit field then x = R.x r is included in- new-fields, and- - if x is an implicit or instance field, then it is omitted from- new-fields.-- (Instance arguments are explained below.) The reason for treating- implicit and instance fields specially is to allow code like the- following:-- record R : Set where- field- {length} : ℕ- vec : Vec ℕ length- -- More fields…-- xs : R- xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] }-- ys = record xs { vec = 0 ∷ [] }-- Without the special treatment the last expression would need to- include a new binding for length (for instance "length = _").--* Record patterns which do not contain data type patterns, but which- do contain dot patterns, are no longer rejected.--* When the --without-K flag is used literals are now treated as- constructors.--* Under-applied functions can now reduce.-- Consider the following definition:-- id : {A : Set} → A → A- id x = x-- Previously the expression id would not reduce. This has been changed- so that it now reduces to λ x → x. Usually this makes little- difference, but it can be important in conjunction with 'with'. See- issue 365 for an example.--* Unused AgdaLight legacy syntax (x y : A; z v : B) for telescopes has- been removed.--Universe polymorphism------------------------* Universe polymorphism is now enabled by default.- Use --no-universe-polymorphism to disable it.--* Universe levels are no longer defined as a data type.-- The basic level combinators can be introduced in the following way:-- postulate- Level : Set- zero : Level- suc : Level → Level- max : Level → Level → Level-- {-# BUILTIN LEVEL Level #-}- {-# BUILTIN LEVELZERO zero #-}- {-# BUILTIN LEVELSUC suc #-}- {-# BUILTIN LEVELMAX max #-}--* The BUILTIN equality is now required to be universe-polymorphic.--* trustMe is now universe-polymorphic.--Meta-variables and unification---------------------------------* Unsolved meta-variables are now frozen after every mutual block.- This means that they cannot be instantiated by subsequent code. For- instance,-- one : Nat- one = _-- bla : one ≡ suc zero- bla = refl-- leads to an error now, whereas previously it lead to the- instantiation of _ with "suc zero". If you want to make use of the- old behaviour, put the two definitions in a mutual block.-- All meta-variables are unfrozen during interactive editing, so that- the user can fill holes interactively. Note that type-checking of- interactively given terms is not perfect: Agda sometimes refuses to- load a file, even though no complaints were raised during the- interactive construction of the file. This is because certain checks- (for instance, positivity) are only invoked when a file is loaded.--* Record types can now be inferred.-- If there is a unique known record type with fields matching the- fields in a record expression, then the type of the expression will- be inferred to be the record type applied to unknown parameters.-- If there is no known record type with the given fields the type- checker will give an error instead of producing lots of unsolved- meta-variables.-- Note that "known record type" refers to any record type in any- imported module, not just types which are in scope.--* The occurrence checker distinguishes rigid and strongly rigid- occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011].-- The completeness checker now accepts the following code:-- h : (n : Nat) → n ≡ suc n → Nat- h n ()-- Internally this generates a constraint _n = suc _n where the- meta-variable _n occurs strongly rigidly, i.e. on a constructor path- from the root, in its own defining term tree. This is never- solvable.-- Weakly rigid recursive occurrences may have a solution [Jason Reed's- PhD thesis, page 106]:-- test : (k : Nat) →- let X : (Nat → Nat) → Nat- X = _- in- (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k)))- test k f = refl-- The constraint _X k f = suc (f (_X k (λ x → k))) has the solution- _X k f = suc (f (suc k)), despite the recursive occurrence of _X.- Here _X is not strongly rigid, because it occurs under the bound- variable f. Previously Agda rejected this code; now it instead- complains about an unsolved meta-variable.--* Equation constraints involving the same meta-variable in the head- now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA- 2011]. Example:-- same : let X : A → A → A → A × A- X = _- in {x y z : A} → X x y y ≡ (x , y)- × X x x y ≡ X x y y- same = refl , refl-- The second equation implies that X cannot depend on its second- argument. After pruning the first equation is linear and can be- solved.--* Instance arguments.-- A new type of hidden function arguments has been added: instance- arguments. This new feature is based on influences from Scala's- implicits and Agda's existing implicit arguments.-- Plain implicit arguments are marked by single braces: {…}. Instance- arguments are instead marked by double braces: {{…}}. Example:-- postulate- A : Set- B : A → Set- a : A- f : {{a : A}} → B a-- Instead of the double braces you can use the symbols ⦃ and ⦄, but- these symbols must in many cases be surrounded by whitespace. (If- you are using Emacs and the Agda input method, then you can conjure- up the symbols by typing "\{{" and "\}}", respectively.)-- Instance arguments behave as ordinary implicit arguments, except for- one important aspect: resolution of arguments which are not provided- explicitly. For instance, consider the following code:-- test = f-- Here Agda will notice that f's instance argument was not provided- explicitly, and try to infer it. All definitions in scope at f's- call site, as well as all variables in the context, are considered.- If exactly one of these names has the required type (A), then the- instance argument will be instantiated to this name.-- This feature can be used as an alternative to Haskell type classes.- If we define-- record Eq (A : Set) : Set where- field equal : A → A → Bool,-- then we can define the following projection:-- equal : {A : Set} {{eq : Eq A}} → A → A → Bool- equal {{eq}} = Eq.equal eq-- Now consider the following expression:-- equal false false ∨ equal 3 4-- If the following Eq "instances" for Bool and ℕ are in scope, and no- others, then the expression is accepted:-- eq-Bool : Eq Bool- eq-Bool = record { equal = … }-- eq-ℕ : Eq ℕ- eq-ℕ = record { equal = … }-- A shorthand notation is provided to avoid the need to define- projection functions manually:-- module Eq-with-implicits = Eq {{...}}-- This notation creates a variant of Eq's record module, where the- main Eq argument is an instance argument instead of an explicit one.- It is equivalent to the following definition:-- module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq-- Note that the short-hand notation allows you to avoid naming the- "-with-implicits" module:-- open Eq {{...}}--- Instance argument resolution is not recursive. As an example,- consider the following "parametrised instance":-- eq-List : {A : Set} → Eq A → Eq (List A)- eq-List {A} eq = record { equal = eq-List-A }- where- eq-List-A : List A → List A → Bool- eq-List-A [] [] = true- eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs- eq-List-A _ _ = false-- Assume that the only Eq instances in scope are eq-List and eq-ℕ.- Then the following code does not type-check:-- test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])-- However, we can make the code work by constructing a suitable- instance manually:-- test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])- where eq-List-ℕ = eq-List eq-ℕ-- By restricting the "instance search" to be non-recursive we avoid- introducing a new, compile-time-only evaluation model to Agda.-- For more information about instance arguments, see Devriese &- Piessens [ICFP 2011]. Some examples are also available in the- examples/instance-arguments subdirectory of the Agda distribution.--Irrelevance--------------* Dependent irrelevant function types.-- Some examples illustrating the syntax of dependent irrelevant- function types:-- .(x y : A) → B .{x y z : A} → B- ∀ x .y → B ∀ x .{y} {z} .v → B-- The declaration-- f : .(x : A) → B[x]- f x = t[x]-- requires that x is irrelevant both in t[x] and in B[x]. This is- possible if, for instance, B[x] = B′ x, with B′ : .A → Set.-- Dependent irrelevance allows us to define the eliminator for the- Squash type:-- record Squash (A : Set) : Set where- constructor squash- field- .proof : A-- elim-Squash : {A : Set} (P : Squash A → Set)- (ih : .(a : A) → P (squash a)) →- (a⁻ : Squash A) → P a⁻- elim-Squash P ih (squash a) = ih a-- Note that this would not type-check with- (ih : (a : A) -> P (squash a)).--* Records with only irrelevant fields.-- The following now works:-- record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where- field- .refl : Reflexive _≈_- .sym : Symmetric _≈_- .trans : Transitive _≈_-- record Setoid : Set₁ where- infix 4 _≈_- field- Carrier : Set- _≈_ : Carrier → Carrier → Set- .isEquivalence : IsEquivalence _≈_-- open IsEquivalence isEquivalence public-- Previously Agda complained about the application- IsEquivalence isEquivalence, because isEquivalence is irrelevant and- the IsEquivalence module expected a relevant argument. Now, when- record modules are generated for records consisting solely of- irrelevant arguments, the record parameter is made irrelevant:-- module IsEquivalence {A : Set} {_≈_ : A → A → Set}- .(r : IsEquivalence {A = A} _≈_) where- …--* Irrelevant things are no longer erased internally. This means that- they are printed as ordinary terms, not as "_" as before.--* The new flag --experimental-irrelevance enables irrelevant universe- levels and matching on irrelevant data when only one constructor is- available. These features are very experimental and likely to change- or disappear.--Reflection-------------* The reflection API has been extended to mirror features like- irrelevance, instance arguments and universe polymorphism, and to- give (limited) access to definitions. For completeness all the- builtins and primitives are listed below:-- -- Names.-- postulate Name : Set-- {-# BUILTIN QNAME Name #-}-- primitive- -- Equality of names.- primQNameEquality : Name → Name → Bool-- -- Is the argument visible (explicit), hidden (implicit), or an- -- instance argument?-- data Visibility : Set where- visible hidden instance : Visibility-- {-# BUILTIN HIDING Visibility #-}- {-# BUILTIN VISIBLE visible #-}- {-# BUILTIN HIDDEN hidden #-}- {-# BUILTIN INSTANCE instance #-}-- -- Arguments can be relevant or irrelevant.-- data Relevance : Set where- relevant irrelevant : Relevance-- {-# BUILTIN RELEVANCE Relevance #-}- {-# BUILTIN RELEVANT relevant #-}- {-# BUILTIN IRRELEVANT irrelevant #-}-- -- Arguments.-- data Arg A : Set where- arg : (v : Visibility) (r : Relevance) (x : A) → Arg A-- {-# BUILTIN ARG Arg #-}- {-# BUILTIN ARGARG arg #-}-- -- Terms.-- mutual- data Term : Set where- -- Variable applied to arguments.- var : (x : ℕ) (args : List (Arg Term)) → Term- -- Constructor applied to arguments.- con : (c : Name) (args : List (Arg Term)) → Term- -- Identifier applied to arguments.- def : (f : Name) (args : List (Arg Term)) → Term- -- Different kinds of λ-abstraction.- lam : (v : Visibility) (t : Term) → Term- -- Pi-type.- pi : (t₁ : Arg Type) (t₂ : Type) → Term- -- A sort.- sort : Sort → Term- -- Anything else.- unknown : Term-- data Type : Set where- el : (s : Sort) (t : Term) → Type-- data Sort : Set where- -- A Set of a given (possibly neutral) level.- set : (t : Term) → Sort- -- A Set of a given concrete level.- lit : (n : ℕ) → Sort- -- Anything else.- unknown : Sort-- {-# BUILTIN AGDASORT Sort #-}- {-# BUILTIN AGDATYPE Type #-}- {-# BUILTIN AGDATERM Term #-}- {-# BUILTIN AGDATERMVAR var #-}- {-# BUILTIN AGDATERMCON con #-}- {-# BUILTIN AGDATERMDEF def #-}- {-# BUILTIN AGDATERMLAM lam #-}- {-# BUILTIN AGDATERMPI pi #-}- {-# BUILTIN AGDATERMSORT sort #-}- {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}- {-# BUILTIN AGDATYPEEL el #-}- {-# BUILTIN AGDASORTSET set #-}- {-# BUILTIN AGDASORTLIT lit #-}- {-# BUILTIN AGDASORTUNSUPPORTED unknown #-}-- postulate- -- Function definition.- Function : Set- -- Data type definition.- Data-type : Set- -- Record type definition.- Record : Set-- {-# BUILTIN AGDAFUNDEF Function #-}- {-# BUILTIN AGDADATADEF Data-type #-}- {-# BUILTIN AGDARECORDDEF Record #-}-- -- Definitions.-- data Definition : Set where- function : Function → Definition- data-type : Data-type → Definition- record′ : Record → Definition- constructor′ : Definition- axiom : Definition- primitive′ : Definition-- {-# BUILTIN AGDADEFINITION Definition #-}- {-# BUILTIN AGDADEFINITIONFUNDEF function #-}- {-# BUILTIN AGDADEFINITIONDATADEF data-type #-}- {-# BUILTIN AGDADEFINITIONRECORDDEF record′ #-}- {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-}- {-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-}- {-# BUILTIN AGDADEFINITIONPRIMITIVE primitive′ #-}-- primitive- -- The type of the thing with the given name.- primQNameType : Name → Type- -- The definition of the thing with the given name.- primQNameDefinition : Name → Definition- -- The constructors of the given data type.- primDataConstructors : Data-type → List Name-- As an example the expression-- primQNameType (quote zero)-- is definitionally equal to-- el (lit 0) (def (quote ℕ) [])-- (if zero is a constructor of the data type ℕ).--* New keyword: unquote.-- The construction "unquote t" converts a representation of an Agda term- to actual Agda code in the following way:-- 1. The argument t must have type Term (see the reflection API above).-- 2. The argument is normalised.-- 3. The entire construction is replaced by the normal form, which is- treated as syntax written by the user and type-checked in the- usual way.-- Examples:-- test : unquote (def (quote ℕ) []) ≡ ℕ- test = refl-- id : (A : Set) → A → A- id = unquote (lam visible (lam visible (var 0 [])))-- id-ok : id ≡ (λ A (x : A) → x)- id-ok = refl--* New keyword: quoteTerm.-- The construction "quoteTerm t" is similar to "quote n", but whereas- quote is restricted to names n, quoteTerm accepts terms t. The- construction is handled in the following way:-- 1. The type of t is inferred. The term t must be type-correct.-- 2. The term t is normalised.-- 3. The construction is replaced by the Term representation (see the- reflection API above) of the normal form. Any unsolved metavariables- in the term are represented by the "unknown" term constructor.-- Examples:-- test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡- lam hidden (lam visible (var 0 []))- test₁ = refl-- -- Local variables are represented as de Bruijn indices.- test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 [])- test₂ = refl-- -- Terms are normalised before being quoted.- test₃ : quoteTerm (0 + 0) ≡ con (quote zero) []- test₃ = refl--Compiler backends-=================--MAlonzo----------* The MAlonzo backend's FFI now handles universe polymorphism in a- better way.-- The translation of Agda types and kinds into Haskell now supports- universe-polymorphic postulates. The core changes are that the- translation of function types has been changed from-- T[[ Pi (x : A) B ]] =- if A has a Haskell kind then- forall x. () -> T[[ B ]]- else if x in fv B then- undef- else- T[[ A ]] -> T[[ B ]]-- into-- T[[ Pi (x : A) B ]] =- if x in fv B then- forall x. T[[ A ]] -> T[[ B ]] -- Note: T[[A]] not Unit.- else- T[[ A ]] -> T[[ B ]],-- and that the translation of constants (postulates, constructors and- literals) has been changed from-- T[[ k As ]] =- if COMPILED_TYPE k T then- T T[[ As ]]- else- undef-- into-- T[[ k As ]] =- if COMPILED_TYPE k T then- T T[[ As ]]- else if COMPILED k E then- ()- else- undef.-- For instance, assuming a Haskell definition-- type AgdaIO a b = IO b,-- we can set up universe-polymorphic IO in the following way:-- postulate- IO : ∀ {ℓ} → Set ℓ → Set ℓ- return : ∀ {a} {A : Set a} → A → IO A- _>>=_ : ∀ {a b} {A : Set a} {B : Set b} →- IO A → (A → IO B) → IO B-- {-# COMPILED_TYPE IO AgdaIO #-}- {-# COMPILED return (\_ _ -> return) #-}- {-# COMPILED _>>=_ (\_ _ _ _ -> (>>=)) #-}-- This is accepted because (assuming that the universe level type is- translated to the Haskell unit type "()")-- (\_ _ -> return)- : forall a. () -> forall b. () -> b -> AgdaIO a b- = T [[ ∀ {a} {A : Set a} → A → IO A ]]-- and-- (\_ _ _ _ -> (>>=))- : forall a. () -> forall b. () ->- forall c. () -> forall d. () ->- AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d- = T [[ ∀ {a b} {A : Set a} {B : Set b} →- IO A → (A → IO B) → IO B ]].--Epic-------* New Epic backend pragma: STATIC.-- In the Epic backend, functions marked with the STATIC pragma will be- normalised before compilation. Example usage:-- {-# STATIC power #-}-- power : ℕ → ℕ → ℕ- power 0 x = 1- power 1 x = x- power (suc n) x = power n x * x-- Occurrences of "power 4 x" will be replaced by "((x * x) * x) * x".--* Some new optimisations have been implemented in the Epic backend:-- - Removal of unused arguments.-- A worker/wrapper transformation is performed so that unused- arguments can be removed by Epic's inliner. For instance, the map- function is transformed in the following way:-- map_wrap : (A B : Set) → (A → B) → List A → List B- map_wrap A B f xs = map_work f xs-- map_work f [] = []- map_work f (x ∷ xs) = f x ∷ map_work f xs-- If map_wrap is inlined (which it will be in any saturated call),- then A and B disappear in the generated code.-- Unused arguments are found using abstract interpretation. The bodies- of all functions in a module are inspected to decide which variables- are used. The behaviour of postulates is approximated based on their- types. Consider return, for instance:-- postulate return : {A : Set} → A → IO A-- The first argument of return can be removed, because it is of type- Set and thus cannot affect the outcome of a program at runtime.-- - Injection detection.-- At runtime many functions may turn out to be inefficient variants of- the identity function. This is especially true after forcing.- Injection detection replaces some of these functions with more- efficient versions. Example:-- inject : {n : ℕ} → Fin n → Fin (1 + n)- inject {suc n} zero = zero- inject {suc n} (suc i) = suc (inject {n} i)-- Forcing removes the Fin constructors' ℕ arguments, so this function- is an inefficient identity function that can be replaced by the- following one:-- inject {_} x = x-- To actually find this function, we make the induction hypothesis- that inject is an identity function in its second argument and look- at the branches of the function to decide if this holds.-- Injection detection also works over data type barriers. Example:-- forget : {A : Set} {n : ℕ} → Vec A n → List A- forget [] = []- forget (x ∷ xs) = x ∷ forget xs-- Given that the constructor tags (in the compiled Epic code) for- Vec.[] and List.[] are the same, and that the tags for Vec._∷_ and- List._∷_ are also the same, this is also an identity function. We- can hence replace the definition with the following one:-- forget {_} xs = xs-- To get this to apply as often as possible, constructor tags are- chosen /after/ injection detection has been run, in a way to make as- many functions as possible injections.-- Constructor tags are chosen once per source file, so it may be- advantageous to define conversion functions like forget in the same- module as one of the data types. For instance, if Vec.agda imports- List.agda, then the forget function should be put in Vec.agda to- ensure that vectors and lists get the same tags (unless some other- injection function, which puts different constraints on the tags, is- prioritised).-- - Smashing.-- This optimisation finds types whose values are inferable at runtime:-- * A data type with only one constructor where all fields are- inferable is itself inferable.- * Set ℓ is inferable (as it has no runtime representation).-- A function returning an inferable data type can be smashed, which- means that it is replaced by a function which simply returns the- inferred value.-- An important example of an inferable type is the usual propositional- equality type (_≡_). Any function returning a propositional equality- can simply return the reflexivity constructor directly without- computing anything.-- This optimisation makes more arguments unused. It also makes the- Epic code size smaller, which in turn speeds up compilation.--JavaScript-------------* ECMAScript compiler backend.-- A new compiler backend is being implemented, targetting ECMAScript- (also known as JavaScript), with the goal of allowing Agda programs- to be run in browsers or other ECMAScript environments.-- The backend is still at an experimental stage: the core language is- implemented, but many features are still missing.-- The ECMAScript compiler can be invoked from the command line using- the flag --js:-- agda --js --compile-dir=<DIR> <FILE>.agda-- Each source <FILE>.agda is compiled into an ECMAScript target- <DIR>/jAgda.<TOP-LEVEL MODULE NAME>.js. The compiler can also be- invoked using the Emacs mode (the variable agda2-backend controls- which backend is used).-- Note that ECMAScript is a strict rather than lazy language. Since- Agda programs are total, this should not impact program semantics,- but it may impact their space or time usage.-- ECMAScript does not support algebraic datatypes or pattern-matching.- These features are translated to a use of the visitor pattern. For- instance, the standard library's List data type and null function- are translated into the following code:-- exports["List"] = {};- exports["List"]["[]"] = function (x0) {- return x0["[]"]();- };- exports["List"]["_∷_"] = function (x0) {- return function (x1) {- return function (x2) {- return x2["_∷_"](x0, x1);- };- };- };-- exports["null"] = function (x0) {- return function (x1) {- return function (x2) {- return x2({- "[]": function () {- return jAgda_Data_Bool["Bool"]["true"];- },- "_∷_": function (x3, x4) {- return jAgda_Data_Bool["Bool"]["false"];- }- });- };- };- };-- Agda records are translated to ECMAScript objects, preserving field- names.-- Top-level Agda modules are translated to ECMAScript modules,- following the common.js module specification. A top-level Agda- module "Foo.Bar" is translated to an ECMAScript module- "jAgda.Foo.Bar".-- The ECMAScript compiler does not compile to Haskell, so the pragmas- related to the Haskell FFI (IMPORT, COMPILED_DATA and COMPILED) are- not used by the ECMAScript backend. Instead, there is a COMPILED_JS- pragma which may be applied to any declaration. For postulates,- primitives, functions and values, it gives the ECMAScript code to be- emitted by the compiler. For data types, it gives a function which- is applied to a value of that type, and a visitor object. For- instance, a binding of natural numbers to ECMAScript integers- (ignoring overflow errors) is:-- data ℕ : Set where- zero : ℕ- suc : ℕ → ℕ-- {-# COMPILED_JS ℕ function (x,v) {- if (x < 1) { return v.zero(); } else { return v.suc(x-1); }- } #-}- {-# COMPILED_JS zero 0 #-}- {-# COMPILED_JS suc function (x) { return x+1; } #-}-- _+_ : ℕ → ℕ → ℕ- zero + n = n- suc m + n = suc (m + n)-- {-# COMPILED_JS _+_ function (x) { return function (y) {- return x+y; };- } #-}-- To allow FFI code to be optimised, the ECMAScript in a COMPILED_JS- declaration is parsed, using a simple parser that recognises a pure- functional subset of ECMAScript, consisting of functions, function- applications, return, if-statements, if-expressions,- side-effect-free binary operators (no precedence, left associative),- side-effect-free prefix operators, objects (where all member names- are quoted), field accesses, and string and integer literals.- Modules may be imported using the require("<module-id>") syntax: any- impure code, or code outside the supported fragment, can be placed- in a module and imported.--Tools-=====--* New flag --safe, which can be used to type-check untrusted code.-- This flag disables postulates, primTrustMe, and "unsafe" OPTION- pragmas, some of which are known to make Agda inconsistent.-- Rejected pragmas:-- --allow-unsolved-metas- --experimental-irrelevance- --guardedness-preserving-type-construtors- --injective-type-constructors- --no-coverage-check- --no-positivity-check- --no-termination-check- --sized-types- --type-in-type-- Note that, at the moment, it is not possible to define the universe- level or coinduction primitives when --safe is used (because they- must be introduced as postulates). This can be worked around by- type-checking trusted files in a first pass, without using --safe,- and then using --safe in a second pass. Modules which have already- been type-checked are not re-type-checked just because --safe is- used.--* Dependency graphs.-- The new flag --dependency-graph=FILE can be used to generate a DOT- file containing a module dependency graph. The generated file (FILE)- can be rendered using a tool like dot.--* The --no-unreachable-check flag has been removed.--* Projection functions are highlighted as functions instead of as- fields. Field names (in record definitions and record values) are- still highlighted as fields.--* Support for jumping to positions mentioned in the information- buffer has been added.--* The "make install" command no longer installs Agda globally (by- default).
@@ -0,0 +1,102 @@+Release notes for Agda 2 version 2.2.0+======================================++Important changes since 2.1.2 (which was released 2007-08-16):++Language+--------++* Exhaustive pattern checking. Agda complains if there are missing+ clauses in a function definition.++* Coinductive types are supported. This feature is under+ development/evaluation, and may change.++ http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Codatatypes++* Another experimental feature: Sized types, which can make it easier+ to explain why your code is terminating.++* Improved constraint solving for functions with constructor headed+ right hand sides.++ http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.FindingTheValuesOfImplicitArguments++* A simple, well-typed foreign function interface, which allows use of+ Haskell functions in Agda code.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.FFI++* The tokens `forall`, `->` and `\` can be written as `∀`, `→` and+ `λ`.++* Absurd lambdas: `λ ()` and `λ {}`.++ http://thread.gmane.org/gmane.comp.lang.agda/440++* Record fields whose values can be inferred can be omitted.++* Agda complains if it spots an unreachable clause, or if a pattern+ variable "shadows" a hidden constructor of matching type.++ http://thread.gmane.org/gmane.comp.lang.agda/720++Tools+-----++* Case-split: The user interface can replace a pattern variable with+ the corresponding constructor patterns. You get one new left-hand+ side for every possible constructor.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode++* The MAlonzo compiler.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.MAlonzo++* A new Emacs input method, which contains bindings for many Unicode+ symbols, is by default activated in the Emacs mode.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.UnicodeInput++* Highlighted, hyperlinked HTML can be generated from Agda source+ code.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.HowToGenerateWebPagesFromSourceCode++* The command-line interactive mode (`agda -I`) is no longer+ supported, but should still work.++ http://thread.gmane.org/gmane.comp.lang.agda/245++* Reload times when working on large projects are now considerably+ better.++ http://thread.gmane.org/gmane.comp.lang.agda/551++Libraries+---------++* A standard library is under development.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary++Documentation+-------------++* The Agda wiki is better organised. It should be easier for a+ newcomer to find relevant information now.++ http://wiki.portal.chalmers.se/agda/++Infrastructure+--------------++* Easy-to-install packages for Windows and Debian/Ubuntu have been+ prepared.++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download++* Agda 2.2.0 is available from Hackage.++ http://hackage.haskell.org/
@@ -0,0 +1,238 @@+Release notes for Agda 2 version 2.2.10+=======================================++Language+--------++* New flag: `--without-K`.++ This flag makes pattern matching more restricted. If the flag is+ activated, then Agda only accepts certain case-splits. If the type+ of the variable to be split is `D pars ixs`, where `D` is a data (or+ record) type, pars stands for the parameters, and `ixs` the indices,+ then the following requirements must be satisfied:++ - The indices `ixs` must be applications of constructors to distinct+ variables.++ - These variables must not be free in pars.++ The intended purpose of `--without-K` is to enable experiments with+ a propositional equality without the K rule. Let us define+ propositional equality as follows:++ ```agda+ data _≡_ {A : Set} : A → A → Set where+ refl : ∀ x → x ≡ x+ ```++ Then the obvious implementation of the J rule is accepted:++ ```agda+ J : {A : Set} (P : {x y : A} → x ≡ y → Set) →+ (∀ x → P (refl x)) →+ ∀ {x y} (x≡y : x ≡ y) → P x≡y+ J P p (refl x) = p x+ ```++ The same applies to Christine Paulin-Mohring's version of the J rule:++ ```agda+ J′ : {A : Set} {x : A} (P : {y : A} → x ≡ y → Set) →+ P (refl x) →+ ∀ {y} (x≡y : x ≡ y) → P x≡y+ J′ P p (refl x) = p+ ```++ On the other hand, the obvious implementation of the K rule is not+ accepted:++ ```agda+ K : {A : Set} (P : {x : A} → x ≡ x → Set) →+ (∀ x → P (refl x)) →+ ∀ {x} (x≡x : x ≡ x) → P x≡x+ K P p (refl x) = p x+ ```++ However, we have *not* proved that activation of `--without-K`+ ensures that the K rule cannot be proved in some other way.++* Irrelevant declarations.++ Postulates and functions can be marked as irrelevant by prefixing+ the name with a dot when the name is declared. Example:++ ```agda+ postulate+ .irrelevant : {A : Set} → .A → A+ ```++ Irrelevant names may only be used in irrelevant positions or in+ definitions of things which have been declared irrelevant.++ The axiom irrelevant above can be used to define a projection from+ an irrelevant record field:++ ```agda+ data Subset (A : Set) (P : A → Set) : Set where+ _#_ : (a : A) → .(P a) → Subset A P++ elem : ∀ {A P} → Subset A P → A+ elem (a # p) = a++ .certificate : ∀ {A P} (x : Subset A P) → P (elem x)+ certificate (a # p) = irrelevant p+ ```++ The right-hand side of certificate is relevant, so we cannot define++ ```agda+ certificate (a # p) = p+ ```++ (because `p` is irrelevant). However, certificate is declared to be+ irrelevant, so it can use the axiom irrelevant. Furthermore the+ first argument of the axiom is irrelevant, which means that+ irrelevant `p` is well-formed.++ As shown above the axiom irrelevant justifies irrelevant+ projections. Previously no projections were generated for irrelevant+ record fields, such as the field certificate in the following+ record type:++ ```agda+ record Subset (A : Set) (P : A → Set) : Set where+ constructor _#_+ field+ elem : A+ .certificate : P elem+ ```++ Now projections are generated automatically for irrelevant fields+ (unless the flag `--no-irrelevant-projections` is used). Note that+ irrelevant projections are highly experimental.++* Termination checker recognises projections.++ Projections now preserve sizes, both in patterns and expressions.+ Example:++ ```agda+ record Wrap (A : Set) : Set where+ constructor wrap+ field+ unwrap : A++ open Wrap public++ data WNat : Set where+ zero : WNat+ suc : Wrap WNat → WNat++ id : WNat → WNat+ id zero = zero+ id (suc w) = suc (wrap (id (unwrap w)))+ ```++ In the structural ordering `unwrap w` ≤ `w`. This means that++ ```agda+ unwrap w ≤ w < suc w,+ ```++ and hence the recursive call to id is accepted.++ Projections also preserve guardedness.++Tools+-----++* Hyperlinks for top-level module names now point to the start of the+ module rather than to the declaration of the module name. This+ applies both to the Emacs mode and to the output of `agda --html`.++* Most occurrences of record field names are now highlighted as+ "fields". Previously many occurrences were highlighted as+ "functions".++* Emacs mode: It is no longer possible to change the behaviour of the+ `TAB` key by customising `agda2-indentation`.++* Epic compiler backend.++ A new compiler backend is being implemented. This backend makes use+ of Edwin Brady's language Epic+ (http://www.cs.st-andrews.ac.uk/~eb/epic.php) and its compiler. The+ backend should handle most Agda code, but is still at an+ experimental stage: more testing is needed, and some things written+ below may not be entirely true.++ The Epic compiler can be invoked from the command line using the+ flag `--epic`:++ ```+ agda --epic --epic-flag=<EPIC-FLAG> --compile-dir=<DIR> <FILE>.agda+ ```++ The `--epic-flag` flag can be given multiple times; each flag is+ given verbatim to the Epic compiler (in the given order). The+ resulting executable is named after the main module and placed in+ the directory specified by the `--compile-dir` flag (default: the+ project root). Intermediate files are placed in a subdirectory+ called `Epic`.++ The backend requires that there is a definition named main. This+ definition should be a value of type `IO Unit`, but at the moment+ this is not checked (so it is easy to produce a program which+ segfaults). Currently the backend represents actions of type `IO A`+ as functions from `Unit` to `A`, and main is applied to the unit+ value.++ The Epic compiler compiles via C, not Haskell, so the pragmas+ related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and+ `COMPILED`) are not used by the Epic backend. Instead there is a new+ pragma `COMPILED_EPIC`. This pragma is used to give Epic code for+ postulated definitions (Epic code can in turn call C code). The form+ of the pragma is `{-# COMPILED_EPIC def code #-}`, where `def` is+ the name of an Agda postulate and `code` is some Epic code which+ should include the function arguments, return type and function+ body. As an example the `IO` monad can be defined as follows:++ ```agda+ postulate+ IO : Set → Set+ return : ∀ {A} → A → IO A+ _>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B++ {-# COMPILED_EPIC return (u : Unit, a : Any) -> Any =+ ioreturn(a) #-}+ {-# COMPILED_EPIC+ _>>=_ (u1 : Unit, u2 : Unit, x : Any, f : Any) -> Any =+ iobind(x,f) #-}+ ```++ Here `ioreturn` and `iobind` are Epic functions which are defined in+ the file `AgdaPrelude.e` which is always included.++ By default the backend will remove so-called forced constructor+ arguments (and case-splitting on forced variables will be+ rewritten). This optimisation can be disabled by using the flag+ `--no-forcing`.++ All data types which look like unary natural numbers after forced+ constructor arguments have been removed (i.e. types with two+ constructors, one nullary and one with a single recursive argument)+ will be represented as "BigInts". This applies to the standard `Fin`+ type, for instance.++ The backend supports Agda's primitive functions and the BUILTIN+ pragmas. If the BUILTIN pragmas for unary natural numbers are used,+ then some operations, like addition and multiplication, will use+ more efficient "BigInt" operations.++ If you want to make use of the Epic backend you need to install some+ dependencies, see the README.++* The Emacs mode can compile using either the MAlonzo or the Epic+ backend. The variable `agda2-backend` controls which backend is+ used.
@@ -0,0 +1,22 @@+Release notes for Agda 2 version 2.2.2+======================================++Tools+-----++* The `--malonzodir` option has been renamed to `--malonzo-dir`.++* The output of `agda --html` is by default placed in a directory+ called `html`.++Infrastructure+--------------++* The Emacs mode is included in the Agda Cabal package, and installed+ by `cabal install`. The recommended way to enable the Emacs mode is+ to include the following code in `.emacs`:++ ```elisp+ (load-file (let ((coding-system-for-read 'utf-8))+ (shell-command-to-string "agda-mode locate")))+ ```
@@ -0,0 +1,54 @@+Release notes for Agda 2 version 2.2.4+======================================++Important changes since 2.2.2:++* Change to the semantics of `open import` and `open module`. The+ declaration++ ```agda+ open import M <using/hiding/renaming>+ ```++ now translates to++ ```agda+ import A+ open A <using/hiding/renaming>+ ```++ instead of++ ```agda+ import A <using/hiding/renaming>+ open A+ ```++ The same translation is used for `open module M = E …`. Declarations+ involving the keywords as or public are changed in a corresponding+ way (`as` always goes with import, and `public` always with open).++ This change means that import directives do not affect the qualified+ names when open import/module is used. To get the old behaviour you+ can use the expanded version above.++* Names opened publicly in parameterised modules no longer inherit the+ module parameters. Example:++ ```agda+ module A where+ postulate X : Set++ module B (Y : Set) where+ open A public+ ```++ In Agda 2.2.2 `B.X` has type `(Y : Set) → Set`, whereas in+ Agda 2.2.4 `B.X` has type Set.++* Previously it was not possible to export a given constructor name+ through two different `open public` statements in the same module.+ This is now possible.++* Unicode subscript digits are now allowed for the hierarchy of+ universes (`Set₀`, `Set₁`, …): `Set₁` is equivalent to `Set1`.
@@ -0,0 +1,290 @@+Release notes for Agda 2 version 2.2.6+======================================++Language+--------++* Universe polymorphism (experimental extension).++ To enable universe polymorphism give the flag+ `--universe-polymorphism` on the command line or (recommended) as an+ `OPTIONS` pragma.++ When universe polymorphism is enabled `Set` takes an argument which is+ the universe level. For instance, the type of universe polymorphic+ identity is++ ```agda+ id : {a : Level} {A : Set a} → A → A.+ ```++ The type Level is isomorphic to the unary natural numbers and should+ be specified using the BUILTINs `LEVEL`, `LEVELZERO`, and+ `LEVELSUC`:++ ```agda+ data Level : Set where+ zero : Level+ suc : Level → Level++ {-# BUILTIN LEVEL Level #-}+ {-# BUILTIN LEVELZERO zero #-}+ {-# BUILTIN LEVELSUC suc #-}+ ```++ There is an additional BUILTIN `LEVELMAX` for taking the maximum of two+ levels:++ ```agda+ max : Level → Level → Level+ max zero m = m+ max (suc n) zero = suc n+ max (suc n) (suc m) = suc (max n m)++ {-# BUILTIN LEVELMAX max #-}+ ```++ The non-polymorphic universe levels `Set`, `Set₁` and so on are+ sugar for `Set zero`, `Set (suc zero)`, etc.++ At present there is no automatic lifting of types from one level to+ another. It can still be done (rather clumsily) by defining types+ like the following one:++ ```agda+ data Lifted {a} (A : Set a) : Set (suc a) where+ lift : A → Lifted A+ ```++ However, it is likely that automatic lifting is introduced at some+ point in the future.++* Multiple constructors, record fields, postulates or primitives can+ be declared using a single type signature:++ ```agda+ data Bool : Set where+ false true : Bool++ postulate+ A B : Set+ ```++* Record fields can be implicit:++ ```agda+ record R : Set₁ where+ field+ {A} : Set+ f : A → A+ {B C} D {E} : Set+ g : B → C → E+ ```++ By default implicit fields are not printed.++* Record constructors can be defined:++ ```agda+ record Σ (A : Set) (B : A → Set) : Set where+ constructor _,_+ field+ proj₁ : A+ proj₂ : B proj₁+ ```++ In this example `_,_` gets the type++ ```agda+ (proj₁ : A) → B proj₁ → Σ A B.+ ```++ For implicit fields the corresponding constructor arguments become+ implicit.++ Note that the constructor is defined in the *outer* scope, so any+ fixity declaration has to be given outside the record definition.+ The constructor is not in scope inside the record module.++ Note also that pattern matching for records has not been implemented+ yet.++* BUILTIN hooks for equality.++ The data type++ ```agda+ data _≡_ {A : Set} (x : A) : A → Set where+ refl : x ≡ x+ ```++ can be specified as the builtin equality type using the following+ pragmas:++ ```agda+ {-# BUILTIN EQUALITY _≡_ #-}+ {-# BUILTIN REFL refl #-}+ ```++ The builtin equality is used for the new rewrite construct and+ the `primTrustMe` primitive described below.++* New `rewrite` construct.++ If `eqn : a ≡ b`, where `_≡_` is the builtin equality (see above) you+ can now write++ ```agda+ f ps rewrite eqn = rhs+ ```++ instead of++ ```agda+ f ps with a | eqn+ ... | ._ | refl = rhs+ ```++ The `rewrite` construct has the effect of rewriting the goal and the+ context by the given equation (left to right).++ You can rewrite using several equations (in sequence) by separating+ them with vertical bars (|):++ ```agda+ f ps rewrite eqn₁ | eqn₂ | … = rhs+ ```++ It is also possible to add `with`-clauses after rewriting:++ ```agda+ f ps rewrite eqns with e+ ... | p = rhs+ ```++ Note that pattern matching happens before rewriting—if you want to+ rewrite and then do pattern matching you can use a with after the+ rewrite.++ See `test/Succeed/Rewrite.agda` for some examples.++* A new primitive, `primTrustMe`, has been added:++ ```agda+ primTrustMe : {A : Set} {x y : A} → x ≡ y+ ```++ Here `_≡_` is the builtin equality (see BUILTIN hooks for equality,+ above).++ If `x` and `y` are definitionally equal, then+ `primTrustMe {x = x} {y = y}` reduces to `refl`.++ Note that the compiler replaces all uses of `primTrustMe` with the+ `REFL` builtin, without any check for definitional+ equality. Incorrect uses of `primTrustMe` can potentially lead to+ segfaults or similar problems.++ For an example of the use of `primTrustMe`, see `Data.String` in+ version 0.3 of the standard library, where it is used to implement+ decidable equality on strings using the primitive boolean equality.++* Changes to the syntax and semantics of IMPORT pragmas, which are+ used by the Haskell FFI. Such pragmas must now have the following+ form:++ ```agda+ {-# IMPORT <module name> #-}+ ```++ These pragmas are interpreted as *qualified* imports, so Haskell+ names need to be given qualified (unless they come from the Haskell+ prelude).++* The horizontal tab character (U+0009) is no longer treated as white+ space.++* Line pragmas are no longer supported.++* The `--include-path` flag can no longer be used as a pragma.++* The experimental and incomplete support for proof irrelevance has+ been disabled.++Tools+-----++* New `intro` command in the Emacs mode. When there is a canonical way+ of building something of the goal type (for instance, if the goal+ type is a pair), the goal can be refined in this way. The command+ works for the following goal types:++ - A data type where only one of its constructors can be used to+ construct an element of the goal type. (For instance, if the+ goal is a non-empty vector, a `cons` will be introduced.)++ - A record type. A record value will be introduced. Implicit+ fields will not be included unless showing of implicit arguments+ is switched on.++ - A function type. A lambda binding as many variables as possible+ will be introduced. The variable names will be chosen from the+ goal type if its normal form is a dependent function type,+ otherwise they will be variations on `x`. Implicit lambdas will+ only be inserted if showing of implicit arguments is switched+ on.++ This command can be invoked by using the `refine` command+ (`C-c C-r`) when the goal is empty. (The old behaviour of the refine+ command in this situation was to ask for an expression using the+ minibuffer.)++* The Emacs mode displays `Checked` in the mode line if the current+ file type checked successfully without any warnings.++* If a file `F` is loaded, and this file defines the module `M`, it is+ an error if `F` is not the file which defines `M` according to the+ include path.++ Note that the command-line tool and the Emacs mode define the+ meaning of relative include paths differently: the command-line tool+ interprets them relative to the current working directory, whereas+ the Emacs mode interprets them relative to the root directory of the+ current project. (As an example, if the module `A.B.C` is loaded+ from the file `<some-path>/A/B/C.agda`, then the root directory is+ `<some-path>`.)++* It is an error if there are several files on the include path which+ match a given module name.++* Interface files are relocatable. You can move around source trees as+ long as the include path is updated in a corresponding way. Note+ that a module `M` may be re-typechecked if its time stamp is+ strictly newer than that of the corresponding interface file+ (`M.agdai`).++* Type-checking is no longer done when an up-to-date interface exists.+ (Previously the initial module was always type-checked.)++* Syntax highlighting files for Emacs (`.agda.el`) are no longer used.+ The `--emacs` flag has been removed. (Syntax highlighting+ information is cached in the interface files.)++* The Agate and Alonzo compilers have been retired. The options+ `--agate`, `--alonzo` and `--malonzo` have been removed.++* The default directory for MAlonzo output is the project's root+ directory. The `--malonzo-dir` flag has been renamed to+ `--compile-dir`.++* Emacs mode: `C-c C-x C-d` no longer resets the type checking state.+ `C-c C-x C-r` can be used for a more complete reset. `C-c C-x C-s`+ (which used to reload the syntax highlighting information) has been+ removed. `C-c C-l` can be used instead.++* The Emacs mode used to define some "abbrevs", unless the user+ explicitly turned this feature off. The new default is *not* to add+ any abbrevs. The old default can be obtained by customising+ `agda2-mode-abbrevs-use-defaults` (a customisation buffer can be+ obtained by typing `M-x customize-group agda2 RET` after an Agda+ file has been loaded).
@@ -0,0 +1,626 @@+Release notes for Agda 2 version 2.2.8+======================================++Language+--------++* Record pattern matching.++ It is now possible to pattern match on named record constructors.+ Example:++ ```agda+ record Σ (A : Set) (B : A → Set) : Set where+ constructor _,_+ field+ proj₁ : A+ proj₂ : B proj₁++ map : {A B : Set} {P : A → Set} {Q : B → Set}+ (f : A → B) → (∀ {x} → P x → Q (f x)) →+ Σ A P → Σ B Q+ map f g (x , y) = (f x , g y)+ ```++ The clause above is internally translated into the following one:++ ```agda+ map f g p = (f (Σ.proj₁ p) , g (Σ.proj₂ p))+ ```++ Record patterns containing data type patterns are not translated.+ Example:++ ```agda+ add : ℕ × ℕ → ℕ+ add (zero , n) = n+ add (suc m , n) = suc (add (m , n))+ ```++ Record patterns which do not contain data type patterns, but which+ do contain dot patterns, are currently rejected. Example:++ ```agda+ Foo : {A : Set} (p₁ p₂ : A × A) → proj₁ p₁ ≡ proj₁ p₂ → Set₁+ Foo (x , y) (.x , y′) refl = Set+ ```++* Proof irrelevant function types.++ Agda now supports irrelevant non-dependent function types:++ ```agda+ f : .A → B+ ```++ This type implies that `f` does not depend computationally on its+ argument. One intended use case is data structures with embedded+ proofs, like sorted lists:++ ```agda+ postulate+ _≤_ : ℕ → ℕ → Set+ p₁ : 0 ≤ 1+ p₂ : 0 ≤ 1++ data SList (bound : ℕ) : Set where+ [] : SList bound+ scons : (head : ℕ) →+ .(head ≤ bound) →+ (tail : SList head) →+ SList bound+ ```++ The effect of the irrelevant type in the signature of `scons` is+ that `scons`'s second argument is never inspected after Agda has+ ensured that it has the right type. It is even thrown away, leading+ to smaller term sizes and hopefully some gain in efficiency. The+ type-checker ignores irrelevant arguments when checking equality, so+ two lists can be equal even if they contain different proofs:++ ```agda+ l₁ : SList 1+ l₁ = scons 0 p₁ []++ l₂ : SList 1+ l₂ = scons 0 p₂ []++ l₁≡l₂ : l₁ ≡ l₂+ l₁≡l₂ = refl+ ```++ Irrelevant arguments can only be used in irrelevant contexts.+ Consider the following subset type:++ ```agda+ data Subset (A : Set) (P : A → Set) : Set where+ _#_ : (elem : A) → .(P elem) → Subset A P+ ```++ The following two uses are fine:++ ```agda+ elimSubset : ∀ {A C : Set} {P} →+ Subset A P → ((a : A) → .(P a) → C) → C+ elimSubset (a # p) k = k a p++ elem : {A : Set} {P : A → Set} → Subset A P → A+ elem (x # p) = x+ ```++ However, if we try to project out the proof component, then Agda+ complains that `variable p is declared irrelevant, so it cannot be+ used here`:++ ```agda+ prjProof : ∀ {A P} (x : Subset A P) → P (elem x)+ prjProof (a # p) = p+ ```++ Matching against irrelevant arguments is also forbidden, except in+ the case of irrefutable matches (record constructor patterns which+ have been translated away). For instance, the match against the+ pattern `(p , q)` here is accepted:++ ```agda+ elim₂ : ∀ {A C : Set} {P Q : A → Set} →+ Subset A (λ x → Σ (P x) (λ _ → Q x)) →+ ((a : A) → .(P a) → .(Q a) → C) → C+ elim₂ (a # (p , q)) k = k a p q+ ```++ Absurd matches `()` are also allowed.++ Note that record fields can also be irrelevant. Example:++ ```agda+ record Subset (A : Set) (P : A → Set) : Set where+ constructor _#_+ field+ elem : A+ .proof : P elem+ ```++ Irrelevant fields are never in scope, neither inside nor outside the+ record. This means that no record field can depend on an irrelevant+ field, and furthermore projections are not defined for such fields.+ Irrelevant fields can only be accessed using pattern matching, as in+ `elimSubset` above.++ Irrelevant function types were added very recently, and have not+ been subjected to much experimentation yet, so do not be surprised+ if something is changed before the next release. For instance,+ dependent irrelevant function spaces (`.(x : A) → B`) might be added+ in the future.++* Mixfix binders.++ It is now possible to declare user-defined syntax that binds+ identifiers. Example:++ ```agda+ postulate+ State : Set → Set → Set+ put : ∀ {S} → S → State S ⊤+ get : ∀ {S} → State S S+ return : ∀ {A S} → A → State S A+ bind : ∀ {A B S} → State S B → (B → State S A) → State S A++ syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂++ increment : State ℕ ⊤+ increment = x ← get ,+ put (1 + x)+ ```++ The syntax declaration for `bind` implies that `x` is in scope in+ `e₂`, but not in `e₁`.++ You can give fixity declarations along with syntax declarations:++ ```agda+ infixr 40 bind+ syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂+ ```++ The fixity applies to the syntax, not the name; syntax declarations+ are also restricted to ordinary, non-operator names. The following+ declaration is disallowed:++ ```agda+ syntax _==_ x y = x === y+ ```agda++ Syntax declarations must also be linear; the following declaration+ is disallowed:++ ```agda+ syntax wrong x = x + x+ ```++ Syntax declarations were added very recently, and have not been+ subjected to much experimentation yet, so do not be surprised if+ something is changed before the next release.++* `Prop` has been removed from the language.++ The experimental sort `Prop` has been disabled. Any program using+ `Prop` should typecheck if `Prop` is replaced by `Set₀`. Note that+ `Prop` is still a keyword.++* Injective type constructors off by default.++ Automatic injectivity of type constructors has been disabled (by+ default). To enable it, use the flag+ `--injective-type-constructors`, either on the command line or in an+ `OPTIONS` pragma. Note that this flag makes Agda anti-classical and+ possibly inconsistent:++ Agda with excluded middle is inconsistent+ http://thread.gmane.org/gmane.comp.lang.agda/1367++ See `test/Succeed/InjectiveTypeConstructors.agda` for an example.++* Termination checker can count.++ There is a new flag `--termination-depth=N` accepting values `N >=+ 1` (with `N = 1` being the default) which influences the behavior of+ the termination checker. So far, the termination checker has only+ distinguished three cases when comparing the argument of a recursive+ call with the formal parameter of the callee.++ `<`: the argument is structurally smaller than the parameter++ `=`: they are equal++ `?`: the argument is bigger or unrelated to the parameter++ This behavior, which is still the default (`N = 1`), will not+ recognise the following functions as terminating.++ ```agda+ mutual++ f : ℕ → ℕ+ f zero = zero+ f (suc zero) = zero+ f (suc (suc n)) = aux n++ aux : ℕ → ℕ+ aux m = f (suc m)+ ```++ The call graph++ ```+ f --(<)--> aux --(?)--> f+ ```++ yields a recursive call from `f` to `f` via `aux` where the relation+ of call argument to callee parameter is computed as "unrelated"+ (composition of `<` and `?`).++ Setting `N >= 2` allows a finer analysis: `n` has two constructors+ less than `suc (suc n)`, and `suc m` has one more than `m`, so we get the+ call graph:++ ```+ f --(-2)--> aux --(+1)--> f+ ```++ The indirect call `f --> f` is now labeled with `(-1)`, and the+ termination checker can recognise that the call argument is+ decreasing on this path.++ Setting the termination depth to `N` means that the termination+ checker counts decrease up to `N` and increase up to `N-1`. The+ default, `N=1`, means that no increase is counted, every increase+ turns to "unrelated".++ In practice, examples like the one above sometimes arise when `with`+ is used. As an example, the program++ ```agda+ f : ℕ → ℕ+ f zero = zero+ f (suc zero) = zero+ f (suc (suc n)) with zero+ ... | _ = f (suc n)+ ```++ is internally represented as++ ```agda+ mutual++ f : ℕ → ℕ+ f zero = zero+ f (suc zero) = zero+ f (suc (suc n)) = aux n zero++ aux : ℕ → ℕ → ℕ+ aux m k = f (suc m)+ ```++ Thus, by default, the definition of `f` using `with` is not accepted+ by the termination checker, even though it looks structural (`suc n`+ is a subterm of `suc suc n`). Now, the termination checker is+ satisfied if the option `--termination-depth=2` is used.++ Caveats:++ - This is an experimental feature, hopefully being replaced by+ something smarter in the near future.++ - Increasing the termination depth will quickly lead to very long+ termination checking times. So, use with care. Setting termination+ depth to `100` by habit, just to be on the safe side, is not a good+ idea!++ - Increasing termination depth only makes sense for linear data+ types such as `ℕ` and `Size`. For other types, increase cannot be+ recognised. For instance, consider a similar example with lists.++ ```agda+ data List : Set where+ nil : List+ cons : ℕ → List → List++ mutual+ f : List → List+ f nil = nil+ f (cons x nil) = nil+ f (cons x (cons y ys)) = aux y ys++ aux : ℕ → List → List+ aux z zs = f (cons z zs)+ ```++ Here the termination checker compares `cons z zs` to `z` and also+ to `zs`. In both cases, the result will be "unrelated", no matter+ how high we set the termination depth. This is because when+ comparing `cons z zs` to `zs`, for instance, `z` is unrelated to+ `zs`, thus, `cons z zs` is also unrelated to `zs`. We cannot say+ it is just "one larger" since `z` could be a very large term. Note+ that this points to a weakness of untyped termination checking.++ To regain the benefit of increased termination depth, we need to+ index our lists by a linear type such as `ℕ` or `Size`. With+ termination depth `2`, the above example is accepted for vectors+ instead of lists.++* The `codata` keyword has been removed. To use coinduction, use the+ following new builtins: `INFINITY`, `SHARP` and `FLAT`. Example:++ ```agda+ {-# OPTIONS --universe-polymorphism #-}++ module Coinduction where++ open import Level++ infix 1000 ♯_++ postulate+ ∞ : ∀ {a} (A : Set a) → Set a+ ♯_ : ∀ {a} {A : Set a} → A → ∞ A+ ♭ : ∀ {a} {A : Set a} → ∞ A → A++ {-# BUILTIN INFINITY ∞ #-}+ {-# BUILTIN SHARP ♯_ #-}+ {-# BUILTIN FLAT ♭ #-}+ ```++ Note that (non-dependent) pattern matching on `SHARP` is no longer+ allowed.++ Note also that strange things might happen if you try to combine the+ pragmas above with `COMPILED_TYPE`, `COMPILED_DATA` or `COMPILED`+ pragmas, or if the pragmas do not occur right after the postulates.++ The compiler compiles the `INFINITY` builtin to nothing (more or+ less), so that the use of coinduction does not get in the way of FFI+ declarations:++ ```agda+ data Colist (A : Set) : Set where+ [] : Colist A+ _∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A++ {-# COMPILED_DATA Colist [] [] (:) #-}+ ```++* Infinite types.++ If the new flag `--guardedness-preserving-type-constructors` is+ used, then type constructors are treated as inductive constructors+ when we check productivity (but only in parameters, and only if they+ are used strictly positively or not at all). This makes examples+ such as the following possible:++ ```agda+ data Rec (A : ∞ Set) : Set where+ fold : ♭ A → Rec A++ -- Σ cannot be a record type below.++ data Σ (A : Set) (B : A → Set) : Set where+ _,_ : (x : A) → B x → Σ A B++ syntax Σ A (λ x → B) = Σ[ x ∶ A ] B++ -- Corecursive definition of the W-type.++ W : (A : Set) → (A → Set) → Set+ W A B = Rec (♯ (Σ[ x ∶ A ] (B x → W A B)))++ syntax W A (λ x → B) = W[ x ∶ A ] B++ sup : {A : Set} {B : A → Set} (x : A) (f : B x → W A B) → W A B+ sup x f = fold (x , f)++ W-rec : {A : Set} {B : A → Set}+ (P : W A B → Set) →+ (∀ {x} {f : B x → W A B} → (∀ y → P (f y)) → P (sup x f)) →+ ∀ x → P x+ W-rec P h (fold (x , f)) = h (λ y → W-rec P h (f y))++ -- Induction-recursion encoded as corecursion-recursion.++ data Label : Set where+ ′0 ′1 ′2 ′σ ′π ′w : Label++ mutual++ U : Set+ U = Σ Label U′++ U′ : Label → Set+ U′ ′0 = ⊤+ U′ ′1 = ⊤+ U′ ′2 = ⊤+ U′ ′σ = Rec (♯ (Σ[ a ∶ U ] (El a → U)))+ U′ ′π = Rec (♯ (Σ[ a ∶ U ] (El a → U)))+ U′ ′w = Rec (♯ (Σ[ a ∶ U ] (El a → U)))++ El : U → Set+ El (′0 , _) = ⊥+ El (′1 , _) = ⊤+ El (′2 , _) = Bool+ El (′σ , fold (a , b)) = Σ[ x ∶ El a ] El (b x)+ El (′π , fold (a , b)) = (x : El a) → El (b x)+ El (′w , fold (a , b)) = W[ x ∶ El a ] El (b x)++ U-rec : (P : ∀ u → El u → Set) →+ P (′1 , _) tt →+ P (′2 , _) true →+ P (′2 , _) false →+ (∀ {a b x y} →+ P a x → P (b x) y → P (′σ , fold (a , b)) (x , y)) →+ (∀ {a b f} →+ (∀ x → P (b x) (f x)) → P (′π , fold (a , b)) f) →+ (∀ {a b x f} →+ (∀ y → P (′w , fold (a , b)) (f y)) →+ P (′w , fold (a , b)) (sup x f)) →+ ∀ u (x : El u) → P u x+ U-rec P P1 P2t P2f Pσ Pπ Pw = rec+ where+ rec : ∀ u (x : El u) → P u x+ rec (′0 , _) ()+ rec (′1 , _) _ = P1+ rec (′2 , _) true = P2t+ rec (′2 , _) false = P2f+ rec (′σ , fold (a , b)) (x , y) = Pσ (rec _ x) (rec _ y)+ rec (′π , fold (a , b)) f = Pπ (λ x → rec _ (f x))+ rec (′w , fold (a , b)) (fold (x , f)) = Pw (λ y → rec _ (f y))+ ```++ The `--guardedness-preserving-type-constructors` extension is based+ on a rather operational understanding of `∞`/`♯_`; it's not yet+ clear if this extension is consistent.++* Qualified constructors.++ Constructors can now be referred to qualified by their data type.+ For instance, given++ ```agda+ data Nat : Set where+ zero : Nat+ suc : Nat → Nat++ data Fin : Nat → Set where+ zero : ∀ {n} → Fin (suc n)+ suc : ∀ {n} → Fin n → Fin (suc n)+ ```++ you can refer to the constructors unambiguously as `Nat.zero`,+ `Nat.suc`, `Fin.zero`, and `Fin.suc` (`Nat` and `Fin` are modules+ containing the respective constructors). Example:++ ```agda+ inj : (n m : Nat) → Nat.suc n ≡ suc m → n ≡ m+ inj .m m refl = refl+ ```++ Previously you had to write something like++ ```agda+ inj : (n m : Nat) → _≡_ {Nat} (suc n) (suc m) → n ≡ m+ ```++ to make the type checker able to figure out that you wanted the+ natural number suc in this case.++* Reflection.++ There are two new constructs for reflection:++ - `quoteGoal x in e`++ In `e` the value of `x` will be a representation of the goal type+ (the type expected of the whole expression) as an element in a+ datatype of Agda terms (see below). For instance,++ ```agda+ example : ℕ+ example = quoteGoal x in {! at this point x = def (quote ℕ) [] !}+ ```++ - `quote x : Name`++ If `x` is the name of a definition (function, datatype, record,+ or a constructor), `quote x` gives you the representation of `x`+ as a value in the primitive type `Name` (see below).++ Quoted terms use the following BUILTINs and primitives (available+ from the standard library module `Reflection`):++ ```agda+ -- The type of Agda names.++ postulate Name : Set++ {-# BUILTIN QNAME Name #-}++ primitive primQNameEquality : Name → Name → Bool++ -- Arguments.++ Explicit? = Bool++ data Arg A : Set where+ arg : Explicit? → A → Arg A++ {-# BUILTIN ARG Arg #-}+ {-# BUILTIN ARGARG arg #-}++ -- The type of Agda terms.++ data Term : Set where+ var : ℕ → List (Arg Term) → Term+ con : Name → List (Arg Term) → Term+ def : Name → List (Arg Term) → Term+ lam : Explicit? → Term → Term+ pi : Arg Term → Term → Term+ sort : Term+ unknown : Term++ {-# BUILTIN AGDATERM Term #-}+ {-# BUILTIN AGDATERMVAR var #-}+ {-# BUILTIN AGDATERMCON con #-}+ {-# BUILTIN AGDATERMDEF def #-}+ {-# BUILTIN AGDATERMLAM lam #-}+ {-# BUILTIN AGDATERMPI pi #-}+ {-# BUILTIN AGDATERMSORT sort #-}+ {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}+ ```++ Reflection may be useful when working with internal decision+ procedures, such as the standard library's ring solver.++* Minor record definition improvement.++ The definition of a record type is now available when type checking+ record module definitions. This means that you can define things+ like the following:++ ```agda+ record Cat : Set₁ where+ field+ Obj : Set+ _=>_ : Obj → Obj → Set+ -- ...++ -- not possible before:+ op : Cat+ op = record { Obj = Obj; _=>_ = λ A B → B => A }+ ```++Tools+-----++* The `Goal type and context` command now shows the goal type before+ the context, and the context is shown in reverse order. The `Goal+ type, context and inferred type` command has been modified in a+ similar way.++* Show module contents command.++ Given a module name `M` the Emacs mode can now display all the+ top-level modules and names inside `M`, along with types for the+ names. The command is activated using `C-c C-o` or the menus.++* Auto command.++ A command which searches for type inhabitants has been added. The+ command is invoked by pressing `C-C C-a` (or using the goal menu).+ There are several flags and parameters, e.g. `-c` which enables+ case-splitting in the search. For further information, see the Agda+ wiki:++ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Auto++* HTML generation is now possible for a module with unsolved+ meta-variables, provided that the `--allow-unsolved-metas` flag is+ used.
@@ -0,0 +1,1124 @@+Release notes for Agda 2 version 2.3.0+======================================++Language+--------++* New more liberal syntax for mutually recursive definitions.++ It is no longer necessary to use the `mutual` keyword to define+ mutually recursive functions or datatypes. Instead, it is enough to+ declare things before they are used. Instead of++ ```agda+ mutual+ f : A+ f = a[f, g]++ g : B[f]+ g = b[f, g]+ ```++ you can now write++ ```agda+ f : A+ g : B[f]+ f = a[f, g]+ g = b[f, g].+ ```++ With the new style you have more freedom in choosing the order in+ which things are type checked (previously type signatures were+ always checked before definitions). Furthermore you can mix+ arbitrary declarations, such as modules and postulates, with+ mutually recursive definitions.++ For data types and records the following new syntax is used to+ separate the declaration from the definition:++ ```agda+ -- Declaration.+ data Vec (A : Set) : Nat → Set -- Note the absence of 'where'.++ -- Definition.+ data Vec A where+ [] : Vec A zero+ _::_ : {n : Nat} → A → Vec A n → Vec A (suc n)++ -- Declaration.+ record Sigma (A : Set) (B : A → Set) : Set++ -- Definition.+ record Sigma A B where+ constructor _,_+ field fst : A+ snd : B fst+ ```++ When making separated declarations/definitions private or abstract+ you should attach the `private` keyword to the declaration and the+ `abstract` keyword to the definition. For instance, a private,+ abstract function can be defined as++ ```agda+ private+ f : A+ abstract+ f = e+ ```++ Finally it may be worth noting that the old style of mutually+ recursive definitions is still supported (it basically desugars into+ the new style).++* Pattern matching lambdas.++ Anonymous pattern matching functions can be defined using the syntax++ ```+ \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em }+ ```++ (where, as usual, `\` and `->` can be replaced by `λ` and+ `→`). Internally this is translated into a function definition of+ the following form:++ ```+ .extlam p11 .. p1n = e1+ ...+ .extlam pm1 .. pmn = em+ ```++ This means that anonymous pattern matching functions are generative.+ For instance, `refl` will not be accepted as an inhabitant of the type++ ```agda+ (λ { true → true ; false → false }) ≡+ (λ { true → true ; false → false }),+ ```++ because this is equivalent to `extlam1 ≡ extlam2` for some distinct+ fresh names `extlam1` and `extlam2`.++ Currently the `where` and `with` constructions are not allowed in+ (the top-level clauses of) anonymous pattern matching functions.++ Examples:++ ```agda+ and : Bool → Bool → Bool+ and = λ { true x → x ; false _ → false }++ xor : Bool → Bool → Bool+ xor = λ { true true → false+ ; false false → false+ ; _ _ → true+ }++ fst : {A : Set} {B : A → Set} → Σ A B → A+ fst = λ { (a , b) → a }++ snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p)+ snd = λ { (a , b) → b }+ ```++* Record update syntax.++ Assume that we have a record type and a corresponding value:++ ```agda+ record MyRecord : Set where+ field+ a b c : ℕ++ old : MyRecord+ old = record { a = 1; b = 2; c = 3 }+ ```++ Then we can update (some of) the record value's fields in the+ following way:++ ```agda+ new : MyRecord+ new = record old { a = 0; c = 5 }+ ```++ Here new normalises to `record { a = 0; b = 2; c = 5 }`. Any+ expression yielding a value of type `MyRecord` can be used instead of+ old.++ Record updating is not allowed to change types: the resulting value+ must have the same type as the original one, including the record+ parameters. Thus, the type of a record update can be inferred if the+ type of the original record can be inferred.++ The record update syntax is expanded before type checking. When the+ expression++ ```agda+ record old { upd-fields }+ ```++ is checked against a record type `R`, it is expanded to++ ```agda+ let r = old in record { new-fields },+ ```++ where old is required to have type `R` and new-fields is defined as+ follows: for each field `x` in `R`,++ - if `x = e` is contained in `upd-fields` then `x = e` is included in+ `new-fields`, and otherwise++ - if `x` is an explicit field then `x = R.x r` is included in+ `new-fields`, and++ - if `x` is an implicit or instance field, then it is omitted from+ `new-fields`.++ (Instance arguments are explained below.) The reason for treating+ implicit and instance fields specially is to allow code like the+ following:++ ```agda+ record R : Set where+ field+ {length} : ℕ+ vec : Vec ℕ length+ -- More fields…++ xs : R+ xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] }++ ys = record xs { vec = 0 ∷ [] }+ ```++ Without the special treatment the last expression would need to+ include a new binding for length (for instance `length = _`).++* Record patterns which do not contain data type patterns, but which+ do contain dot patterns, are no longer rejected.++* When the `--without-K` flag is used literals are now treated as+ constructors.++* Under-applied functions can now reduce.++ Consider the following definition:++ ```agda+ id : {A : Set} → A → A+ id x = x+ ```++ Previously the expression `id` would not reduce. This has been+ changed so that it now reduces to `λ x → x`. Usually this makes+ little difference, but it can be important in conjunction with+ `with`. See Issue [#365](https://github.com/agda/agda/issues/365)+ for an example.++* Unused AgdaLight legacy syntax `(x y : A; z v : B)` for telescopes+ has been removed.++### Universe polymorphism++* Universe polymorphism is now enabled by default. Use+ `--no-universe-polymorphism` to disable it.++* Universe levels are no longer defined as a data type.++ The basic level combinators can be introduced in the following way:++ ```agda+ postulate+ Level : Set+ zero : Level+ suc : Level → Level+ max : Level → Level → Level++ {-# BUILTIN LEVEL Level #-}+ {-# BUILTIN LEVELZERO zero #-}+ {-# BUILTIN LEVELSUC suc #-}+ {-# BUILTIN LEVELMAX max #-}+ ```++* The BUILTIN equality is now required to be universe-polymorphic.++* `trustMe` is now universe-polymorphic.++### Meta-variables and unification++* Unsolved meta-variables are now frozen after every mutual block.+ This means that they cannot be instantiated by subsequent code. For+ instance,++ ```agda+ one : Nat+ one = _++ bla : one ≡ suc zero+ bla = refl+ ```++ leads to an error now, whereas previously it lead to the+ instantiation of `_` with `suc zero`. If you want to make use of the+ old behaviour, put the two definitions in a mutual block.++ All meta-variables are unfrozen during interactive editing, so that+ the user can fill holes interactively. Note that type-checking of+ interactively given terms is not perfect: Agda sometimes refuses to+ load a file, even though no complaints were raised during the+ interactive construction of the file. This is because certain checks+ (for instance, positivity) are only invoked when a file is loaded.++* Record types can now be inferred.++ If there is a unique known record type with fields matching the+ fields in a record expression, then the type of the expression will+ be inferred to be the record type applied to unknown parameters.++ If there is no known record type with the given fields the type+ checker will give an error instead of producing lots of unsolved+ meta-variables.++ Note that "known record type" refers to any record type in any+ imported module, not just types which are in scope.++* The occurrence checker distinguishes rigid and strongly rigid+ occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011].++ The completeness checker now accepts the following code:++ ```agda+ h : (n : Nat) → n ≡ suc n → Nat+ h n ()+ ```++ Internally this generates a constraint `_n = suc _n` where the+ meta-variable `_n` occurs strongly rigidly, i.e. on a constructor+ path from the root, in its own defining term tree. This is never+ solvable.++ Weakly rigid recursive occurrences may have a solution [Jason Reed's+ PhD thesis, page 106]:++ ```agda+ test : (k : Nat) →+ let X : (Nat → Nat) → Nat+ X = _+ in+ (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k)))+ test k f = refl+ ```++ The constraint `_X k f = suc (f (_X k (λ x → k)))` has the solution+ `_X k f = suc (f (suc k))`, despite the recursive occurrence of+ `_X`. Here `_X` is not strongly rigid, because it occurs under the+ bound variable `f`. Previously Agda rejected this code; now it instead+ complains about an unsolved meta-variable.++* Equation constraints involving the same meta-variable in the head+ now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA+ 2011]. Example:++ ```agda+ same : let X : A → A → A → A × A+ X = _+ in {x y z : A} → X x y y ≡ (x , y)+ × X x x y ≡ X x y y+ same = refl , refl+ ```++ The second equation implies that `X` cannot depend on its second+ argument. After pruning the first equation is linear and can be+ solved.++* Instance arguments.++ A new type of hidden function arguments has been added: instance+ arguments. This new feature is based on influences from Scala's+ implicits and Agda's existing implicit arguments.++ Plain implicit arguments are marked by single braces: `{…}`. Instance+ arguments are instead marked by double braces: `{{…}}`. Example:++ ```agda+ postulate+ A : Set+ B : A → Set+ a : A+ f : {{a : A}} → B a+ ```++ Instead of the double braces you can use the symbols `⦃` and `⦄`,+ but these symbols must in many cases be surrounded by+ whitespace. (If you are using Emacs and the Agda input method, then+ you can conjure up the symbols by typing `\{{` and `\}}`,+ respectively.)++ Instance arguments behave as ordinary implicit arguments, except for+ one important aspect: resolution of arguments which are not provided+ explicitly. For instance, consider the following code:++ ```agda+ test = f+ ```++ Here Agda will notice that `f`'s instance argument was not provided+ explicitly, and try to infer it. All definitions in scope at `f`'s+ call site, as well as all variables in the context, are considered.+ If exactly one of these names has the required type `A`, then the+ instance argument will be instantiated to this name.++ This feature can be used as an alternative to Haskell type classes.+ If we define++ ```agda+ record Eq (A : Set) : Set where+ field equal : A → A → Bool,+ ```++ then we can define the following projection:++ ```agda+ equal : {A : Set} {{eq : Eq A}} → A → A → Bool+ equal {{eq}} = Eq.equal eq+ ```++ Now consider the following expression:++ ```agda+ equal false false ∨ equal 3 4+ ```++ If the following `Eq` "instances" for `Bool` and `ℕ` are in scope, and no+ others, then the expression is accepted:++ ```agda+ eq-Bool : Eq Bool+ eq-Bool = record { equal = … }++ eq-ℕ : Eq ℕ+ eq-ℕ = record { equal = … }+ ```++ A shorthand notation is provided to avoid the need to define+ projection functions manually:++ ```agda+ module Eq-with-implicits = Eq {{...}}+ ```++ This notation creates a variant of `Eq`'s record module, where the+ main `Eq` argument is an instance argument instead of an explicit one.+ It is equivalent to the following definition:++ ```agda+ module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq+ ```++ Note that the short-hand notation allows you to avoid naming the+ "-with-implicits" module:++ ```agda+ open Eq {{...}}+ ```++ Instance argument resolution is not recursive. As an example,+ consider the following "parametrised instance":++ ```agda+ eq-List : {A : Set} → Eq A → Eq (List A)+ eq-List {A} eq = record { equal = eq-List-A }+ where+ eq-List-A : List A → List A → Bool+ eq-List-A [] [] = true+ eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs+ eq-List-A _ _ = false+ ```++ Assume that the only `Eq` instances in scope are `eq-List` and+ `eq-ℕ`. Then the following code does not type-check:++ ```agda+ test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])+ ```++ However, we can make the code work by constructing a suitable+ instance manually:++ ```agda+ test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])+ where eq-List-ℕ = eq-List eq-ℕ+ ```++ By restricting the "instance search" to be non-recursive we avoid+ introducing a new, compile-time-only evaluation model to Agda.++ For more information about instance arguments, see Devriese &+ Piessens [ICFP 2011]. Some examples are also available in the+ examples/instance-arguments subdirectory of the Agda distribution.++### Irrelevance++* Dependent irrelevant function types.++ Some examples illustrating the syntax of dependent irrelevant+ function types:++ ```+ .(x y : A) → B .{x y z : A} → B+ ∀ x .y → B ∀ x .{y} {z} .v → B+ ```++ The declaration++ ```+ f : .(x : A) → B[x]+ f x = t[x]+ ```++ requires that `x` is irrelevant both in `t[x]` and in `B[x]`. This+ is possible if, for instance, `B[x] = B′ x`, with `B′ : .A → Set`.++ Dependent irrelevance allows us to define the eliminator for the+ `Squash` type:++ ```agda+ record Squash (A : Set) : Set where+ constructor squash+ field+ .proof : A++ elim-Squash : {A : Set} (P : Squash A → Set)+ (ih : .(a : A) → P (squash a)) →+ (a⁻ : Squash A) → P a⁻+ elim-Squash P ih (squash a) = ih a+ ```++ Note that this would not type-check with++ ```agda+ (ih : (a : A) -> P (squash a)).+ ```++* Records with only irrelevant fields.++ The following now works:++ ```agda+ record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where+ field+ .refl : Reflexive _≈_+ .sym : Symmetric _≈_+ .trans : Transitive _≈_++ record Setoid : Set₁ where+ infix 4 _≈_+ field+ Carrier : Set+ _≈_ : Carrier → Carrier → Set+ .isEquivalence : IsEquivalence _≈_++ open IsEquivalence isEquivalence public+ ```++ Previously Agda complained about the application+ `IsEquivalence isEquivalence`, because `isEquivalence` is irrelevant+ and the `IsEquivalence` module expected a relevant argument. Now,+ when record modules are generated for records consisting solely of+ irrelevant arguments, the record parameter is made irrelevant:++ ```agda+ module IsEquivalence {A : Set} {_≈_ : A → A → Set}+ .(r : IsEquivalence {A = A} _≈_) where+ …+ ```++* Irrelevant things are no longer erased internally. This means that+ they are printed as ordinary terms, not as `_` as before.++* The new flag `--experimental-irrelevance` enables irrelevant+ universe levels and matching on irrelevant data when only one+ constructor is available. These features are very experimental and+ likely to change or disappear.++### Reflection++* The reflection API has been extended to mirror features like+ irrelevance, instance arguments and universe polymorphism, and to+ give (limited) access to definitions. For completeness all the+ builtins and primitives are listed below:++ ```agda+ -- Names.++ postulate Name : Set++ {-# BUILTIN QNAME Name #-}++ primitive+ -- Equality of names.+ primQNameEquality : Name → Name → Bool++ -- Is the argument visible (explicit), hidden (implicit), or an+ -- instance argument?++ data Visibility : Set where+ visible hidden instance : Visibility++ {-# BUILTIN HIDING Visibility #-}+ {-# BUILTIN VISIBLE visible #-}+ {-# BUILTIN HIDDEN hidden #-}+ {-# BUILTIN INSTANCE instance #-}++ -- Arguments can be relevant or irrelevant.++ data Relevance : Set where+ relevant irrelevant : Relevance++ {-# BUILTIN RELEVANCE Relevance #-}+ {-# BUILTIN RELEVANT relevant #-}+ {-# BUILTIN IRRELEVANT irrelevant #-}++ -- Arguments.++ data Arg A : Set where+ arg : (v : Visibility) (r : Relevance) (x : A) → Arg A++ {-# BUILTIN ARG Arg #-}+ {-# BUILTIN ARGARG arg #-}++ -- Terms.++ mutual+ data Term : Set where+ -- Variable applied to arguments.+ var : (x : ℕ) (args : List (Arg Term)) → Term+ -- Constructor applied to arguments.+ con : (c : Name) (args : List (Arg Term)) → Term+ -- Identifier applied to arguments.+ def : (f : Name) (args : List (Arg Term)) → Term+ -- Different kinds of λ-abstraction.+ lam : (v : Visibility) (t : Term) → Term+ -- Pi-type.+ pi : (t₁ : Arg Type) (t₂ : Type) → Term+ -- A sort.+ sort : Sort → Term+ -- Anything else.+ unknown : Term++ data Type : Set where+ el : (s : Sort) (t : Term) → Type++ data Sort : Set where+ -- A Set of a given (possibly neutral) level.+ set : (t : Term) → Sort+ -- A Set of a given concrete level.+ lit : (n : ℕ) → Sort+ -- Anything else.+ unknown : Sort++ {-# BUILTIN AGDASORT Sort #-}+ {-# BUILTIN AGDATYPE Type #-}+ {-# BUILTIN AGDATERM Term #-}+ {-# BUILTIN AGDATERMVAR var #-}+ {-# BUILTIN AGDATERMCON con #-}+ {-# BUILTIN AGDATERMDEF def #-}+ {-# BUILTIN AGDATERMLAM lam #-}+ {-# BUILTIN AGDATERMPI pi #-}+ {-# BUILTIN AGDATERMSORT sort #-}+ {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}+ {-# BUILTIN AGDATYPEEL el #-}+ {-# BUILTIN AGDASORTSET set #-}+ {-# BUILTIN AGDASORTLIT lit #-}+ {-# BUILTIN AGDASORTUNSUPPORTED unknown #-}++ postulate+ -- Function definition.+ Function : Set+ -- Data type definition.+ Data-type : Set+ -- Record type definition.+ Record : Set++ {-# BUILTIN AGDAFUNDEF Function #-}+ {-# BUILTIN AGDADATADEF Data-type #-}+ {-# BUILTIN AGDARECORDDEF Record #-}++ -- Definitions.++ data Definition : Set where+ function : Function → Definition+ data-type : Data-type → Definition+ record′ : Record → Definition+ constructor′ : Definition+ axiom : Definition+ primitive′ : Definition++ {-# BUILTIN AGDADEFINITION Definition #-}+ {-# BUILTIN AGDADEFINITIONFUNDEF function #-}+ {-# BUILTIN AGDADEFINITIONDATADEF data-type #-}+ {-# BUILTIN AGDADEFINITIONRECORDDEF record′ #-}+ {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-}+ {-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-}+ {-# BUILTIN AGDADEFINITIONPRIMITIVE primitive′ #-}++ primitive+ -- The type of the thing with the given name.+ primQNameType : Name → Type+ -- The definition of the thing with the given name.+ primQNameDefinition : Name → Definition+ -- The constructors of the given data type.+ primDataConstructors : Data-type → List Name+ ```++ As an example the expression++ ```agda+ primQNameType (quote zero)+ ```++ is definitionally equal to++ ```agda+ el (lit 0) (def (quote ℕ) [])+ ```++ (if `zero` is a constructor of the data type `ℕ`).++* New keyword: `unquote`.++ The construction `unquote t` converts a representation of an Agda term+ to actual Agda code in the following way:++ 1. The argument `t` must have type `Term` (see the reflection API above).++ 2. The argument is normalised.++ 3. The entire construction is replaced by the normal form, which is+ treated as syntax written by the user and type-checked in the+ usual way.++ Examples:++ ```agda+ test : unquote (def (quote ℕ) []) ≡ ℕ+ test = refl++ id : (A : Set) → A → A+ id = unquote (lam visible (lam visible (var 0 [])))++ id-ok : id ≡ (λ A (x : A) → x)+ id-ok = refl+ ```++* New keyword: `quoteTerm`.++ The construction `quoteTerm t` is similar to `quote n`, but whereas+ `quote` is restricted to names `n`, `quoteTerm` accepts terms+ `t`. The construction is handled in the following way:++ 1. The type of `t` is inferred. The term `t` must be type-correct.++ 2. The term `t` is normalised.++ 3. The construction is replaced by the Term representation (see the+ reflection API above) of the normal form. Any unsolved metavariables+ in the term are represented by the `unknown` term constructor.++ Examples:++ ```agda+ test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡+ lam hidden (lam visible (var 0 []))+ test₁ = refl++ -- Local variables are represented as de Bruijn indices.+ test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 [])+ test₂ = refl++ -- Terms are normalised before being quoted.+ test₃ : quoteTerm (0 + 0) ≡ con (quote zero) []+ test₃ = refl+ ```++Compiler backends+-----------------++### MAlonzo++* The MAlonzo backend's FFI now handles universe polymorphism in a+ better way.++ The translation of Agda types and kinds into Haskell now supports+ universe-polymorphic postulates. The core changes are that the+ translation of function types has been changed from++ ```+ T[[ Pi (x : A) B ]] =+ if A has a Haskell kind then+ forall x. () -> T[[ B ]]+ else if x in fv B then+ undef+ else+ T[[ A ]] -> T[[ B ]]+ ```++ into++ ```+ T[[ Pi (x : A) B ]] =+ if x in fv B then+ forall x. T[[ A ]] -> T[[ B ]] -- Note: T[[A]] not Unit.+ else+ T[[ A ]] -> T[[ B ]],+ ```++ and that the translation of constants (postulates, constructors and+ literals) has been changed from++ ```+ T[[ k As ]] =+ if COMPILED_TYPE k T then+ T T[[ As ]]+ else+ undef+ ```++ into++ ```+ T[[ k As ]] =+ if COMPILED_TYPE k T then+ T T[[ As ]]+ else if COMPILED k E then+ ()+ else+ undef.+ ```++ For instance, assuming a Haskell definition++ ```haskell+ type AgdaIO a b = IO b,+ ```++ we can set up universe-polymorphic `IO` in the following way:++ ```agda+ postulate+ IO : ∀ {ℓ} → Set ℓ → Set ℓ+ return : ∀ {a} {A : Set a} → A → IO A+ _>>=_ : ∀ {a b} {A : Set a} {B : Set b} →+ IO A → (A → IO B) → IO B++ {-# COMPILED_TYPE IO AgdaIO #-}+ {-# COMPILED return (\_ _ -> return) #-}+ {-# COMPILED _>>=_ (\_ _ _ _ -> (>>=)) #-}+ ```++ This is accepted because (assuming that the universe level type is+ translated to the Haskell unit type `()`)++ ```haskell+ (\_ _ -> return)+ : forall a. () -> forall b. () -> b -> AgdaIO a b+ = T [[ ∀ {a} {A : Set a} → A → IO A ]]+ ```++ and++ ```haskell+ (\_ _ _ _ -> (>>=))+ : forall a. () -> forall b. () ->+ forall c. () -> forall d. () ->+ AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d+ = T [[ ∀ {a b} {A : Set a} {B : Set b} →+ IO A → (A → IO B) → IO B ]].+ ```++### Epic++* New Epic backend pragma: `STATIC`.++ In the Epic backend, functions marked with the `STATIC` pragma will be+ normalised before compilation. Example usage:++ ```+ {-# STATIC power #-}++ power : ℕ → ℕ → ℕ+ power 0 x = 1+ power 1 x = x+ power (suc n) x = power n x * x+ ```++ Occurrences of `power 4 x` will be replaced by `((x * x) * x) * x`.++* Some new optimisations have been implemented in the Epic backend:++ - Removal of unused arguments.++ A worker/wrapper transformation is performed so that unused+ arguments can be removed by Epic's inliner. For instance, the map+ function is transformed in the following way:++ ```agda+ map_wrap : (A B : Set) → (A → B) → List A → List B+ map_wrap A B f xs = map_work f xs++ map_work f [] = []+ map_work f (x ∷ xs) = f x ∷ map_work f xs+ ```++ If `map_wrap` is inlined (which it will be in any saturated call),+ then `A` and `B` disappear in the generated code.++ Unused arguments are found using abstract interpretation. The bodies+ of all functions in a module are inspected to decide which variables+ are used. The behaviour of postulates is approximated based on their+ types. Consider `return`, for instance:++ ```agda+ postulate return : {A : Set} → A → IO A+ ```++ The first argument of `return` can be removed, because it is of type+ Set and thus cannot affect the outcome of a program at runtime.++ - Injection detection.++ At runtime many functions may turn out to be inefficient variants of+ the identity function. This is especially true after forcing.+ Injection detection replaces some of these functions with more+ efficient versions. Example:++ ```agda+ inject : {n : ℕ} → Fin n → Fin (1 + n)+ inject {suc n} zero = zero+ inject {suc n} (suc i) = suc (inject {n} i)+ ```++ Forcing removes the `Fin` constructors' `ℕ` arguments, so this+ function is an inefficient identity function that can be replaced by+ the following one:++ ```agda+ inject {_} x = x+ ```++ To actually find this function, we make the induction hypothesis+ that inject is an identity function in its second argument and look+ at the branches of the function to decide if this holds.++ Injection detection also works over data type barriers. Example:++ ```agda+ forget : {A : Set} {n : ℕ} → Vec A n → List A+ forget [] = []+ forget (x ∷ xs) = x ∷ forget xs+ ```++ Given that the constructor tags (in the compiled Epic code) for+ `Vec.[]` and `List.[]` are the same, and that the tags for `Vec._∷_`+ and `List._∷_` are also the same, this is also an identity+ function. We can hence replace the definition with the following+ one:++ ```agda+ forget {_} xs = xs+ ```++ To get this to apply as often as possible, constructor tags are+ chosen *after* injection detection has been run, in a way to make as+ many functions as possible injections.++ Constructor tags are chosen once per source file, so it may be+ advantageous to define conversion functions like forget in the same+ module as one of the data types. For instance, if `Vec.agda` imports+ `List.agda`, then the forget function should be put in `Vec.agda` to+ ensure that vectors and lists get the same tags (unless some other+ injection function, which puts different constraints on the tags, is+ prioritised).++ - Smashing.++ This optimisation finds types whose values are inferable at runtime:++ * A data type with only one constructor where all fields are+ inferable is itself inferable.++ * `Set ℓ` is inferable (as it has no runtime representation).++ A function returning an inferable data type can be smashed, which+ means that it is replaced by a function which simply returns the+ inferred value.++ An important example of an inferable type is the usual propositional+ equality type (`_≡_`). Any function returning a propositional+ equality can simply return the reflexivity constructor directly+ without computing anything.++ This optimisation makes more arguments unused. It also makes the+ Epic code size smaller, which in turn speeds up compilation.++### JavaScript++* ECMAScript compiler backend.++ A new compiler backend is being implemented, targetting ECMAScript+ (also known as JavaScript), with the goal of allowing Agda programs+ to be run in browsers or other ECMAScript environments.++ The backend is still at an experimental stage: the core language is+ implemented, but many features are still missing.++ The ECMAScript compiler can be invoked from the command line using+ the flag `--js`:++ ```+ agda --js --compile-dir=<DIR> <FILE>.agda+ ```++ Each source `<FILE>.agda` is compiled into an ECMAScript target+ `<DIR>/jAgda.<TOP-LEVEL MODULE NAME>.js`. The compiler can also be+ invoked using the Emacs mode (the variable `agda2-backend` controls+ which backend is used).++ Note that ECMAScript is a strict rather than lazy language. Since+ Agda programs are total, this should not impact program semantics,+ but it may impact their space or time usage.++ ECMAScript does not support algebraic datatypes or pattern-matching.+ These features are translated to a use of the visitor pattern. For+ instance, the standard library's `List` data type and `null`+ function are translated into the following code:++ ```javascript+ exports["List"] = {};+ exports["List"]["[]"] = function (x0) {+ return x0["[]"]();+ };+ exports["List"]["_∷_"] = function (x0) {+ return function (x1) {+ return function (x2) {+ return x2["_∷_"](x0, x1);+ };+ };+ };++ exports["null"] = function (x0) {+ return function (x1) {+ return function (x2) {+ return x2({+ "[]": function () {+ return jAgda_Data_Bool["Bool"]["true"];+ },+ "_∷_": function (x3, x4) {+ return jAgda_Data_Bool["Bool"]["false"];+ }+ });+ };+ };+ };+ ```++ Agda records are translated to ECMAScript objects, preserving field+ names.++ Top-level Agda modules are translated to ECMAScript modules,+ following the `common.js` module specification. A top-level Agda+ module `Foo.Bar` is translated to an ECMAScript module+ `jAgda.Foo.Bar`.++ The ECMAScript compiler does not compile to Haskell, so the pragmas+ related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and+ `COMPILED`) are not used by the ECMAScript backend. Instead, there+ is a `COMPILED_JS` pragma which may be applied to any+ declaration. For postulates, primitives, functions and values, it+ gives the ECMAScript code to be emitted by the compiler. For data+ types, it gives a function which is applied to a value of that type,+ and a visitor object. For instance, a binding of natural numbers to+ ECMAScript integers (ignoring overflow errors) is:++ ```agda+ data ℕ : Set where+ zero : ℕ+ suc : ℕ → ℕ++ {-# COMPILED_JS ℕ function (x,v) {+ if (x < 1) { return v.zero(); } else { return v.suc(x-1); }+ } #-}+ {-# COMPILED_JS zero 0 #-}+ {-# COMPILED_JS suc function (x) { return x+1; } #-}++ _+_ : ℕ → ℕ → ℕ+ zero + n = n+ suc m + n = suc (m + n)++ {-# COMPILED_JS _+_ function (x) { return function (y) {+ return x+y; };+ } #-}+ ```++ To allow FFI code to be optimised, the ECMAScript in a `COMPILED_JS`+ declaration is parsed, using a simple parser that recognises a pure+ functional subset of ECMAScript, consisting of functions, function+ applications, return, if-statements, if-expressions,+ side-effect-free binary operators (no precedence, left associative),+ side-effect-free prefix operators, objects (where all member names+ are quoted), field accesses, and string and integer literals.+ Modules may be imported using the require (`<module-id>`) syntax: any+ impure code, or code outside the supported fragment, can be placed+ in a module and imported.++Tools+-----++* New flag `--safe`, which can be used to type-check untrusted code.++ This flag disables postulates, `primTrustMe`, and "unsafe" `OPTIONS`+ pragmas, some of which are known to make Agda inconsistent.++ Rejected pragmas:++ ```+ --allow-unsolved-metas+ --experimental-irrelevance+ --guardedness-preserving-type-construtors+ --injective-type-constructors+ --no-coverage-check+ --no-positivity-check+ --no-termination-check+ --sized-types+ --type-in-type+ ```++ Note that, at the moment, it is not possible to define the universe+ level or coinduction primitives when `--safe` is used (because they+ must be introduced as postulates). This can be worked around by+ type-checking trusted files in a first pass, without using `--safe`,+ and then using `--saf`e in a second pass. Modules which have already+ been type-checked are not re-type-checked just because `--safe` is+ used.++* Dependency graphs.++ The new flag `--dependency-graph=FILE` can be used to generate a DOT+ file containing a module dependency graph. The generated file (FILE)+ can be rendered using a tool like dot.++* The `--no-unreachable-check` flag has been removed.++* Projection functions are highlighted as functions instead of as+ fields. Field names (in record definitions and record values) are+ still highlighted as fields.++* Support for jumping to positions mentioned in the information+ buffer has been added.++* The `make install` command no longer installs Agda globally (by+ default).
@@ -0,0 +1,16 @@+Release notes for Agda 2 version 2.3.2.1+========================================++Installation+------------++* Made it possible to compile Agda with more recent versions of+ hashable, QuickCheck and Win32.++* Excluded mtl-2.1.++Type checking+-------------++* Fixed bug in the termination checker+ (Issue [#754](https://github.com/agda/agda/issues/754)).
@@ -0,0 +1,10 @@+Release notes for Agda 2 version 2.3.2.2+========================================++* Fixed a bug that sometimes made it tricky to use the Emacs mode on+ Windows [Issue [#757](https://github.com/agda/agda/issues/757)].++* Made Agda build with newer versions of some libraries.++* Fixed a bug that caused ambiguous parse error messages+ [Issue [#147](https://github.com/agda/agda/issues/147)].
@@ -0,0 +1,806 @@+Release notes for Agda 2 version 2.3.2+======================================++Installation+------------++* The Agda-executable package has been removed.++ The executable is now provided as part of the Agda package.++* The Emacs mode no longer depends on haskell-mode or GHCi.++* Compilation of Emacs mode Lisp files.++ You can now compile the Emacs mode Lisp files by running `agda-mode+ compile`. This command is run by `make install`.++ Compilation can, in some cases, give a noticeable speedup.++ WARNING: If you reinstall the Agda mode without recompiling the+ Emacs Lisp files, then Emacs may continue using the old, compiled+ files.++Pragmas and options+-------------------++* The `--without-K` check now reconstructs constructor parameters.++ New specification of `--without-K`:++ If the flag is activated, then Agda only accepts certain+ case-splits. If the type of the variable to be split is+ `D pars ixs`, where `D` is a data (or record) type, `pars` stands+ for the parameters, and `ixs` the indices, then the following+ requirements must be satisfied:++ - The indices `ixs` must be applications of constructors (or+ literals) to distinct variables. Constructors are usually not+ applied to parameters, but for the purposes of this check+ constructor parameters are treated as other arguments.++ - These distinct variables must not be free in pars.++* Irrelevant arguments are printed as `_` by default now. To turn on+ printing of irrelevant arguments, use option++ ```+ --show-irrelevant+ ```++* New: Pragma `NO_TERMINATION_CHECK` to switch off termination checker+ for individual function definitions and mutual blocks.++ The pragma must precede a function definition or a mutual block.+ Examples (see `test/Succeed/NoTerminationCheck.agda`):++ 1. Skipping a single definition: before type signature.++ ```agda+ {-# NO_TERMINATION_CHECK #-}+ a : A+ a = a+ ```++ 2. Skipping a single definition: before first clause.++ ```agda+ b : A+ {-# NO_TERMINATION_CHECK #-}+ b = b+ ```++ 3. Skipping an old-style mutual block: Before `mutual` keyword.++ ```agda+ {-# NO_TERMINATION_CHECK #-}+ mutual+ c : A+ c = d++ d : A+ d = c+ ```++ 4. Skipping a new-style mutual block: Anywhere before a type+ signature or first function clause in the block++ ```agda+ i : A+ j : A++ i = j+ {-# NO_TERMINATION_CHECK #-}+ j = i+ ```++ The pragma cannot be used in `--safe` mode.++Language+--------++* Let binding record patterns++ ```agda+ record _×_ (A B : Set) : Set where+ constructor _,_+ field+ fst : A+ snd : B+ open _×_++ let (x , (y , z)) = t+ in u+ ```++ will now be interpreted as++ ```agda+ let x = fst t+ y = fst (snd t)+ z = snd (snd t)+ in u+ ```++ Note that the type of `t` needs to be inferable. If you need to+ provide a type signature, you can write the following:++ ```agda+ let a : ...+ a = t+ (x , (y , z)) = a+ in u+ ```++* Pattern synonyms++ A pattern synonym is a declaration that can be used on the left hand+ side (when pattern matching) as well as the right hand side (in+ expressions). For example:++ ```agda+ pattern z = zero+ pattern ss x = suc (suc x)++ f : ℕ -> ℕ+ f z = z+ f (suc z) = ss z+ f (ss n) = n+ ```++ Pattern synonyms are implemented by substitution on the abstract+ syntax, so definitions are scope-checked but not type-checked. They+ are particularly useful for universe constructions.++* Qualified mixfix operators++ It is now possible to use a qualified mixfix operator by qualifying+ the first part of the name. For instance++ ```agda+ import Data.Nat as Nat+ import Data.Bool as Bool++ two = Bool.if true then 1 Nat.+ 1 else 0+ ```++* Sections [Issue [#735](https://github.com/agda/agda/issues/735)].+ Agda now parses anonymous modules as sections:++ ```agda+ module _ {a} (A : Set a) where++ data List : Set a where+ [] : List+ _∷_ : (x : A) (xs : List) → List++ module _ {a} {A : Set a} where++ _++_ : List A → List A → List A+ [] ++ ys = ys+ (x ∷ xs) ++ ys = x ∷ (xs ++ ys)++ test : List Nat+ test = (5 ∷ []) ++ (3 ∷ [])+ ```++ In general, now the syntax++ ```agda+ module _ parameters where+ declarations+ ```++ is accepted and has the same effect as++ ```agda+ private+ module M parameters where+ declarations+ open M public+ ```++ for a fresh name `M`.++* Instantiating a module in an open import statement+ [Issue [#481](https://github.com/agda/agda/issues/481)]. Now+ accepted:++ ```agda+ open import Path.Module args [using/hiding/renaming (...)]+ ```++ This only brings the imported identifiers from `Path.Module` into scope,+ not the module itself! Consequently, the following is pointless, and raises+ an error:++ ```agda+ import Path.Module args [using/hiding/renaming (...)]+ ```++ You can give a private name `M` to the instantiated module via++ ```agda+ import Path.Module args as M [using/hiding/renaming (...)]+ open import Path.Module args as M [using/hiding/renaming (...)]+ ```++ Try to avoid `as` as part of the arguments. `as` is not a keyword;+ the following can be legal, although slightly obfuscated Agda code:++ ```agda+ open import as as as as as as+ ```++* Implicit module parameters can be given by name. E.g.++ ```agda+ open M {namedArg = bla}+ ```++ This feature has been introduced in Agda 2.3.0 already.++* Multiple type signatures sharing a same type can now be written as a single+ type signature.++ ```agda+ one two : ℕ+ one = suc zero+ two = suc one+ ```++Goal and error display+----------------------++* Meta-variables that were introduced by hidden argument `arg` are now+ printed as `_arg_number` instead of just `_number`.+ [Issue [#526](https://github.com/agda/agda/issues/526)]++* Agda expands identifiers in anonymous modules when printing. Should+ make some goals nicer to read.+ [Issue [#721](https://github.com/agda/agda/issues/721)]++* When a module identifier is ambiguous, Agda tells you if one of them+ is a data type module.+ [Issues [#318](https://github.com/agda/agda/issues/318),+ [#705](https://github.com/agda/agda/issues/705)]++Type checking+-------------++* Improved coverage checker. The coverage checker splits on arguments+ that have constructor or literal pattern, committing to the+ left-most split that makes progress. Consider the lookup function+ for vectors:++ ```agda+ data Fin : Nat → Set where+ zero : {n : Nat} → Fin (suc n)+ suc : {n : Nat} → Fin n → Fin (suc n)++ data Vec (A : Set) : Nat → Set where+ [] : Vec A zero+ _∷_ : {n : Nat} → A → Vec A n → Vec A (suc n)++ _!!_ : {A : Set}{n : Nat} → Vec A n → Fin n → A+ (x ∷ xs) !! zero = x+ (x ∷ xs) !! suc i = xs !! i+ ```++ In Agda up to 2.3.0, this definition is rejected unless we add+ an absurd clause++ ```agda+ [] !! ()+ ```++ This is because the coverage checker committed on splitting on the+ vector argument, even though this inevitably lead to failed+ coverage, because a case for the empty vector `[]` is missing.++ The improvement to the coverage checker consists on committing only+ on splits that have a chance of covering, since all possible+ constructor patterns are present. Thus, Agda will now split first+ on the `Fin` argument, since cases for both `zero` and `suc` are+ present. Then, it can split on the `Vec` argument, since the empty+ vector is already ruled out by instantiating `n` to a `suc _`.++* Instance arguments resolution will now consider candidates which+ still expect hidden arguments. For example:++ ```agda+ record Eq (A : Set) : Set where+ field eq : A → A → Bool++ open Eq {{...}}++ eqFin : {n : ℕ} → Eq (Fin n)+ eqFin = record { eq = primEqFin }++ testFin : Bool+ testFin = eq fin1 fin2+ ```++ The type-checker will now resolve the instance argument of the `eq`+ function to `eqFin {_}`. This is only done for hidden arguments, not+ instance arguments, so that the instance search stays non-recursive.++* Constraint solving: Upgraded Miller patterns to record patterns.+ [Issue [#456](https://github.com/agda/agda/issues/456)]++ Agda now solves meta-variables that are applied to record patterns.+ A typical (but here, artificial) case is:++ ```agda+ record Sigma (A : Set)(B : A -> Set) : Set where+ constructor _,_+ field+ fst : A+ snd : B fst++ test : (A : Set)(B : A -> Set) ->+ let X : Sigma A B -> Sigma A B+ X = _+ in (x : A)(y : B x) -> X (x , y) ≡ (x , y)+ test A B x y = refl+ ```++ This yields a constraint of the form++ ```+ _X A B (x , y) := t[x,y]+ ```++ (with `t[x,y] = (x, y)`) which is not a Miller pattern.+ However, Agda now solves this as++ ```+ _X A B z := t[fst z,snd z].+ ```++* Changed: solving recursive constraints.+ [Issue [#585](https://github.com/agda/agda/issues/585)]++ Until 2.3.0, Agda sometimes inferred values that did not pass the+ termination checker later, or would even make Agda loop. To prevent+ this, the occurs check now also looks into the definitions of the+ current mutual block, to avoid constructing recursive solutions. As+ a consequence, also terminating recursive solutions are no longer+ found automatically.++ This effects a programming pattern where the recursively computed+ type of a recursive function is left to Agda to solve.++ ```agda+ mutual++ T : D -> Set+ T pattern1 = _+ T pattern2 = _++ f : (d : D) -> T d+ f pattern1 = rhs1+ f pattern2 = rhs2+ ```++ This might no longer work from now on. See examples+ `test/Fail/Issue585*.agda`.++* Less eager introduction of implicit parameters.+ [Issue [#679](https://github.com/agda/agda/issues/679)]++ Until Agda 2.3.0, trailing hidden parameters were introduced eagerly+ on the left hand side of a definition. For instance, one could not+ write++ ```agda+ test : {A : Set} -> Set+ test = \ {A} -> A+ ```++ because internally, the hidden argument `{A : Set}` was added to the+ left-hand side, yielding++ ```agda+ test {_} = \ {A} -> A+ ```++ which raised a type error. Now, Agda only introduces the trailing+ implicit parameters it has to, in order to maintain uniform function+ arity. For instance, in++ ```agda+ test : Bool -> {A B C : Set} -> Set+ test true {A} = A+ test false {B = B} = B+ ```++ Agda will introduce parameters `A` and `B` in all clauses, but not+ `C`, resulting in++ ```agda+ test : Bool -> {A B C : Set} -> Set+ test true {A} {_} = A+ test false {_} {B = B} = B+ ```++ Note that for checking `where`-clauses, still all hidden trailing+ parameters are in scope. For instance:++ ```agda+ id : {i : Level}{A : Set i} -> A -> A+ id = myId+ where myId : forall {A} -> A -> A+ myId x = x+ ```++ To be able to fill in the meta variable `_1` in++ ```agda+ myId : {A : Set _1} -> A -> A+ ```++ the hidden parameter `{i : Level}` needs to be in scope.++ As a result of this more lazy introduction of implicit parameters,+ the following code now passes.++ ```agda+ data Unit : Set where+ unit : Unit++ T : Unit → Set+ T unit = {u : Unit} → Unit++ test : (u : Unit) → T u+ test unit with unit+ ... | _ = λ {v} → v+ ```++ Before, Agda would eagerly introduce the hidden parameter `{v}` as+ unnamed left-hand side parameter, leaving no way to refer to it.++ The related Issue [#655](https://github.com/agda/agda/issues/655)+ has also been addressed. It is now possible to make `synonym'+ definitions++ ```+ name = expression+ ```++ even when the type of expression begins with a hidden quantifier.+ Simple example:++ ```+ id2 = id+ ```++ That resulted in unsolved metas until 2.3.0.++* Agda detects unused arguments and ignores them during equality+ checking. [Issue [#691](https://github.com/agda/agda/issues/691),+ solves also Issue [#44](https://github.com/agda/agda/issues/44)]++ Agda's polarity checker now assigns 'Nonvariant' to arguments that+ are not actually used (except for absurd matches). If `f`'s first+ argument is Nonvariant, then `f x` is definitionally equal to `f y`+ regardless of `x` and `y`. It is similar to irrelevance, but does+ not require user annotation.++ For instance, unused module parameters do no longer get in the way:++ ```agda+ module M (x : Bool) where++ not : Bool → Bool+ not true = false+ not false = true++ open M true+ open M false renaming (not to not′)++ test : (y : Bool) → not y ≡ not′ y+ test y = refl+ ```++ Matching against record or absurd patterns does not count as `use',+ so we get some form of proof irrelevance:++ ```agda+ data ⊥ : Set where+ record ⊤ : Set where+ constructor trivial++ data Bool : Set where+ true false : Bool++ True : Bool → Set+ True true = ⊤+ True false = ⊥++ fun : (b : Bool) → True b → Bool+ fun true trivial = true+ fun false ()++ test : (b : Bool) → (x y : True b) → fun b x ≡ fun b y+ test b x y = refl+ ```++ More examples in `test/Succeed/NonvariantPolarity.agda`.++ Phantom arguments: Parameters of record and data types are considered+ `used' even if they are not actually used. Consider:++ ```agda+ False : Nat → Set+ False zero = ⊥+ False (suc n) = False n++ module Invariant where+ record Bla (n : Nat)(p : False n) : Set where++ module Nonvariant where+ Bla : (n : Nat) → False n → Set+ Bla n p = ⊤+ ```++ Even though record `Bla` does not use its parameters `n` and `p`,+ they are considered as used, allowing "phantom type" techniques.++ In contrast, the arguments of function `Bla` are recognized as+ unused. The following code type-checks if we open `Invariant` but+ leaves unsolved metas if we open `Nonvariant`.++ ```agda+ drop-suc : {n : Nat}{p : False n} → Bla (suc n) p → Bla n p+ drop-suc _ = _++ bla : (n : Nat) → {p : False n} → Bla n p → ⊥+ bla zero {()} b+ bla (suc n) b = bla n (drop-suc b)+ ```++ If `Bla` is considered invariant, the hidden argument in the+ recursive call can be inferred to be `p`. If it is considered+ non-variant, then `Bla n X = Bla n p` does not entail `X = p` and+ the hidden argument remains unsolved. Since `bla` does not actually+ use its hidden argument, its value is not important and it could be+ searched for. Unfortunately, polarity analysis of `bla` happens+ only after type checking, thus, the information that `bla` is+ non-variant in `p` is not available yet when meta-variables are+ solved. (See+ `test/Fail/BrokenInferenceDueToNonvariantPolarity.agda`)++* Agda now expands simple definitions (one clause, terminating) to+ check whether a function is constructor+ headed. [Issue [#747](https://github.com/agda/agda/issues/747)] For+ instance, the following now also works:++ ```agda+ MyPair : Set -> Set -> Set+ MyPair A B = Pair A B++ Vec : Set -> Nat -> Set+ Vec A zero = Unit+ Vec A (suc n) = MyPair A (Vec A n)+ ```++ Here, `Unit` and `Pair` are data or record types.++Compiler backends+-----------------++* `-Werror` is now overridable.++ To enable compilation of Haskell modules containing warnings, the+ `-Werror` flag for the MAlonzo backend has been made+ overridable. If, for example, `--ghc-flag=-Wwarn` is passed when+ compiling, one can get away with things like:++ ```agda+ data PartialBool : Set where+ true : PartialBool++ {-# COMPILED_DATA PartialBool Bool True #-}+ ```++ The default behavior remains as it used to be and rejects the above+ program.++Tools+-----++### Emacs mode++* Asynchronous Emacs mode.++ One can now use Emacs while a buffer is type-checked. If the buffer+ is edited while the type-checker runs, then syntax highlighting will+ not be updated when type-checking is complete.++* Interactive syntax highlighting.++ The syntax highlighting is updated while a buffer is type-checked:++ - At first the buffer is highlighted in a somewhat crude way+ (without go-to-definition information for overloaded+ constructors).++ - If the highlighting level is "interactive", then the piece of code+ that is currently being type-checked is highlighted as such. (The+ default is "non-interactive".)++ - When a mutual block has been type-checked it is highlighted+ properly (this highlighting includes warnings for potential+ non-termination).++ The highlighting level can be controlled via the new configuration+ variable `agda2-highlight-level`.++* Multiple case-splits can now be performed in one go.++ Consider the following example:++ ```agda+ _==_ : Bool → Bool → Bool+ b₁ == b₂ = {!!}+ ```++ If you split on `b₁ b₂`, then you get the following code:++ ```agda+ _==_ : Bool → Bool → Bool+ true == true = {!!}+ true == false = {!!}+ false == true = {!!}+ false == false = {!!}+ ```++ The order of the variables matters. Consider the following code:++ ```agda+ lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A+ lookup xs i = {!!}+ ```++ If you split on `xs i`, then you get the following code:++ ```agda+ lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A+ lookup [] ()+ lookup (x ∷ xs) zero = {!!}+ lookup (x ∷ xs) (suc i) = {!!}+ ```++ However, if you split on `i xs`, then you get the following code+ instead:++ ```agda+ lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A+ lookup (x ∷ xs) zero = ?+ lookup (x ∷ xs) (suc i) = ?+ ```++ This code is rejected by Agda 2.3.0, but accepted by 2.3.2 thanks+ to improved coverage checking (see above).++* The Emacs mode now presents information about which module is+ currently being type-checked.++* New global menu entry: `Information about the character at point`.++ If this entry is selected, then information about the character at+ point is displayed, including (in many cases) information about how+ to type the character.++* Commenting/uncommenting the rest of the buffer.++ One can now comment or uncomment the rest of the buffer by typing+ `C-c C-x M-;` or by selecting the menu entry `Comment/uncomment` the+ rest of the buffer".++* The Emacs mode now uses the Agda executable instead of GHCi.++ The `*ghci*` buffer has been renamed to `*agda2*`.++ A new configuration variable has been introduced:+ `agda2-program-name`, the name of the Agda executable (by default+ `agda`).++ The variable `agda2-ghci-options` has been replaced by+ `agda2-program-args`: extra arguments given to the Agda executable+ (by default `none`).++ If you want to limit Agda's memory consumption you can add some+ arguments to `agda2-program-args`, for instance `+RTS -M1.5G -RTS`.++* The Emacs mode no longer depends on haskell-mode.++ Users who have customised certain haskell-mode variables (such as+ `haskell-ghci-program-args`) may want to update their configuration.++### LaTeX-backend++An experimental LaTeX-backend which does precise highlighting a la the+HTML-backend and code alignment a la lhs2TeX has been added.++Here is a sample input literate Agda file:++ ```latex+ \documentclass{article}++ \usepackage{agda}++ \begin{document}++ The following module declaration will be hidden in the output.++ \AgdaHide{+ \begin{code}+ module M where+ \end{code}+ }++ Two or more spaces can be used to make the backend align stuff.++ \begin{code}+ data ℕ : Set where+ zero : ℕ+ suc : ℕ → ℕ++ _+_ : ℕ → ℕ → ℕ+ zero + n = n+ suc m + n = suc (m + n)+ \end{code}++ \end{document}+ ```++To produce an output PDF issue the following commands:++ ```+ agda --latex -i . <file>.lagda+ pdflatex latex/<file>.tex+ ```++Only the top-most module is processed, like with lhs2tex and unlike+with the HTML-backend. If you want to process imported modules you+have to call `agda --latex` manually on each of those modules.++There are still issues related to formatting, see the bug tracker for+more information:++ https://code.google.com/p/agda/issues/detail?id=697++The default `agda.sty` might therefore change in backwards-incompatible+ways, as work proceeds in trying to resolve those problems.++Implemented features:++* Two or more spaces can be used to force alignment of things, like+ with lhs2tex. See example above.++* The highlighting information produced by the type checker is used to+ generate the output. For example, the data declaration in the+ example above, produces:++ ```agda+ \AgdaKeyword{data} \AgdaDatatype{ℕ} \AgdaSymbol{:}+ \AgdaPrimitiveType{Set} \AgdaKeyword{where}+ ```++ These LaTeX commands are defined in `agda.sty` (which is imported by+ `\usepackage{agda}`) and cause the highlighting.++* The LaTeX-backend checks if `agda.sty` is found by the LaTeX+ environment, if it isn't a default `agda.sty` is copied from Agda's+ `data-dir` into the working directory (and thus made available to+ the LaTeX environment).++ If the default `agda.sty` isn't satisfactory (colors, fonts,+ spacing, etc) then the user can modify it and make put it somewhere+ where the LaTeX environment can find it. Hopefully most aspects+ should be modifiable via `agda.sty` rather than having to tweak the+ implementation.++* `--latex-dir` can be used to change the default output directory.
@@ -0,0 +1,8 @@+Release notes for Agda 2 version 2.4.0.1+========================================++* The option `--compile-no-main` has been renamed to `--no-main`.++* `COMPILED_DATA` pragmas can now be given for records.++* Various bug fixes.
@@ -0,0 +1,90 @@+Release notes for Agda 2 version 2.4.0.2+========================================++* The Agda input mode now supports alphabetical super and subscripts,+ in addition to the numerical ones that were already present.+ [Issue [#1240](https://github.com/agda/agda/issues/1240)]++* New feature: Interactively split result.++ Make case (`C-c C-c`) with no variables given tries to split on the+ result to introduce projection patterns. The hole needs to be of+ record type, of course.++ ```agda+ test : {A B : Set} (a : A) (b : B) → A × B+ test a b = ?+ ```++ Result-splitting `?` will produce the new clauses:++ ```agda+ proj₁ (test a b) = ?+ proj₂ (test a b) = ?+ ```++ If hole is of function type ending in a record type, the necessary+ pattern variables will be introduced before the split. Thus, the+ same result can be obtained by starting from:++ ```agda+ test : {A B : Set} (a : A) (b : B) → A × B+ test = ?+ ```++* The so far undocumented `ETA` pragma now throws an error if applied to+ definitions that are not records.++ `ETA` can be used to force eta-equality at recursive record types,+ for which eta is not enabled automatically by Agda. Here is such an+ example:++ ```agda+ mutual+ data Colist (A : Set) : Set where+ [] : Colist A+ _∷_ : A → ∞Colist A → Colist A++ record ∞Colist (A : Set) : Set where+ coinductive+ constructor delay+ field force : Colist A++ open ∞Colist++ {-# ETA ∞Colist #-}++ test : {A : Set} (x : ∞Colist A) → x ≡ delay (force x)+ test x = refl+ ```++ Note: Unsafe use of `ETA` can make Agda loop, e.g. by triggering+ infinite eta expansion!++* Bugs fixed (see [bug tracker](https://github.com/agda/agda/issues)):++ [#1203](https://github.com/agda/agda/issues/1203)++ [#1205](https://github.com/agda/agda/issues/1205)++ [#1209](https://github.com/agda/agda/issues/1209)++ [#1213](https://github.com/agda/agda/issues/1213)++ [#1214](https://github.com/agda/agda/issues/1214)++ [#1216](https://github.com/agda/agda/issues/1216)++ [#1225](https://github.com/agda/agda/issues/1225)++ [#1226](https://github.com/agda/agda/issues/1226)++ [#1231](https://github.com/agda/agda/issues/1231)++ [#1233](https://github.com/agda/agda/issues/1233)++ [#1239](https://github.com/agda/agda/issues/1239)++ [#1241](https://github.com/agda/agda/issues/1241)++ [#1243](https://github.com/agda/agda/issues/1243)
@@ -0,0 +1,1211 @@+Release notes for Agda 2 version 2.4.0+======================================++Installation and infrastructure+-------------------------------++* A new module called `Agda.Primitive` has been introduced. This+ module is available to all users, even if the standard library is+ not used. Currently the module contains level primitives and their+ representation in Haskell when compiling with MAlonzo:++ ```agda+ infixl 6 _⊔_++ postulate+ Level : Set+ lzero : Level+ lsuc : (ℓ : Level) → Level+ _⊔_ : (ℓ₁ ℓ₂ : Level) → Level++ {-# COMPILED_TYPE Level () #-}+ {-# COMPILED lzero () #-}+ {-# COMPILED lsuc (\_ -> ()) #-}+ {-# COMPILED _⊔_ (\_ _ -> ()) #-}++ {-# BUILTIN LEVEL Level #-}+ {-# BUILTIN LEVELZERO lzero #-}+ {-# BUILTIN LEVELSUC lsuc #-}+ {-# BUILTIN LEVELMAX _⊔_ #-}+ ```++ To bring these declarations into scope you can use a declaration+ like the following one:++ ```agda+ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)+ ```++ The standard library reexports these primitives (using the names+ `zero` and `suc` instead of `lzero` and `lsuc`) from the `Level`+ module.++ Existing developments using universe polymorphism might now trigger+ the following error message:++ ```+ Duplicate binding for built-in thing LEVEL, previous binding to+ .Agda.Primitive.Level+ ```++ To fix this problem, please remove the duplicate bindings.++ Technical details (perhaps relevant to those who build Agda+ packages):++ The include path now always contains a directory+ `<DATADIR>/lib/prim`, and this directory is supposed to contain a+ subdirectory Agda containing a file `Primitive.agda`.++ The standard location of `<DATADIR>` is system- and+ installation-specific. E.g., in a Cabal `--user` installation of+ Agda-2.3.4 on a standard single-ghc Linux system it would be+ `$HOME/.cabal/share/Agda-2.3.4` or something similar.++ The location of the `<DATADIR>` directory can be configured at+ compile-time using Cabal flags (`--datadir` and `--datasubdir`).+ The location can also be set at run-time, using the `Agda_datadir`+ environment variable.++Pragmas and options+-------------------++* Pragma `NO_TERMINATION_CHECK` placed within a mutual block is now+ applied to the whole mutual block (rather than being discarded+ silently). Adding to the uses 1.-4. outlined in the release notes+ for 2.3.2 we allow:++ 3a. Skipping an old-style mutual block: Somewhere within `mutual`+ block before a type signature or first function clause.++ ```agda+ mutual+ {-# NO_TERMINATION_CHECK #-}+ c : A+ c = d++ d : A+ d = c+ ```++* New option `--no-pattern-matching`++ Disables all forms of pattern matching (for the current file).+ You can still import files that use pattern matching.++* New option `-v profile:7`++ Prints some stats on which phases Agda spends how much time.+ (Number might not be very reliable, due to garbage collection+ interruptions, and maybe due to laziness of Haskell.)++* New option `--no-sized-types`++ Option `--sized-types` is now default. `--no-sized-types` will turn+ off an extra (inexpensive) analysis on data types used for subtyping+ of sized types.++Language+--------++* Experimental feature: `quoteContext`++ There is a new keyword `quoteContext` that gives users access to the+ list of names in the current local context. For instance:++ ```agda+ open import Data.Nat+ open import Data.List+ open import Reflection++ foo : ℕ → ℕ → ℕ+ foo 0 m = 0+ foo (suc n) m = quoteContext xs in ?+ ```++ In the remaining goal, the list `xs` will consist of two names, `n`+ and `m`, corresponding to the two local variables. At the moment it+ is not possible to access let bound variables (this feature may be+ added in the future).++* Experimental feature: Varying arity.+ Function clauses may now have different arity, e.g.,++ ```agda+ Sum : ℕ → Set+ Sum 0 = ℕ+ Sum (suc n) = ℕ → Sum n++ sum : (n : ℕ) → ℕ → Sum n+ sum 0 acc = acc+ sum (suc n) acc m = sum n (m + acc)+ ```++ or,++ ```agda+ T : Bool → Set+ T true = Bool+ T false = Bool → Bool++ f : (b : Bool) → T b+ f false true = false+ f false false = true+ f true = true+ ```++ This feature is experimental. Yet unsupported:+ - Varying arity and `with`.++ - Compilation of functions with varying arity to Haskell, JS, or Epic.++* Experimental feature: copatterns. (Activated with option `--copatterns`)++ We can now define a record by explaining what happens if you project+ the record. For instance:++ ```agda+ {-# OPTIONS --copatterns #-}++ record _×_ (A B : Set) : Set where+ constructor _,_+ field+ fst : A+ snd : B+ open _×_++ pair : {A B : Set} → A → B → A × B+ fst (pair a b) = a+ snd (pair a b) = b++ swap : {A B : Set} → A × B → B × A+ fst (swap p) = snd p+ snd (swap p) = fst p++ swap3 : {A B C : Set} → A × (B × C) → C × (B × A)+ fst (swap3 t) = snd (snd t)+ fst (snd (swap3 t)) = fst (snd t)+ snd (snd (swap3 t)) = fst t+ ```++ Taking a projection on the left hand side (lhs) is called a+ projection pattern, applying to a pattern is called an application+ pattern. (Alternative terms: projection/application copattern.)++ In the first example, the symbol `pair`, if applied to variable+ patterns `a` and `b` and then projected via `fst`, reduces to+ `a`. `pair` by itself does not reduce.++ A typical application are coinductive records such as streams:++ ```agda+ record Stream (A : Set) : Set where+ coinductive+ field+ head : A+ tail : Stream A+ open Stream++ repeat : {A : Set} (a : A) -> Stream A+ head (repeat a) = a+ tail (repeat a) = repeat a+ ```++ Again, `repeat a` by itself will not reduce, but you can take a+ projection (head or tail) and then it will reduce to the respective+ rhs. This way, we get the lazy reduction behavior necessary to+ avoid looping corecursive programs.++ Application patterns do not need to be trivial (i.e., variable+ patterns), if we mix with projection patterns. E.g., we can have++ ```agda+ nats : Nat -> Stream Nat+ head (nats zero) = zero+ tail (nats zero) = nats zero+ head (nats (suc x)) = x+ tail (nats (suc x)) = nats x+ ```++ Here is an example (not involving coinduction) which demostrates+ records with fields of function type:++ ```agda+ -- The State monad++ record State (S A : Set) : Set where+ constructor state+ field+ runState : S → A × S+ open State++ -- The Monad type class++ record Monad (M : Set → Set) : Set1 where+ constructor monad+ field+ return : {A : Set} → A → M A+ _>>=_ : {A B : Set} → M A → (A → M B) → M B+++ -- State is an instance of Monad+ -- Demonstrates the interleaving of projection and application patterns++ stateMonad : {S : Set} → Monad (State S)+ runState (Monad.return stateMonad a ) s = a , s+ runState (Monad._>>=_ stateMonad m k) s₀ =+ let a , s₁ = runState m s₀+ in runState (k a) s₁++ module MonadLawsForState {S : Set} where++ open Monad (stateMonad {S})++ leftId : {A B : Set}(a : A)(k : A → State S B) →+ (return a >>= k) ≡ k a+ leftId a k = refl++ rightId : {A B : Set}(m : State S A) →+ (m >>= return) ≡ m+ rightId m = refl++ assoc : {A B C : Set}(m : State S A)(k : A → State S B)(l : B → State S C) →+ ((m >>= k) >>= l) ≡ (m >>= λ a → (k a >>= l))+ assoc m k l = refl+ ```++ Copatterns are yet experimental and the following does not work:++ - Copatterns and `with` clauses.++ - Compilation of copatterns to Haskell, JS, or Epic.++ - Projections generated by++ ```agda+ open R {{...}}+ ```++ are not handled properly on lhss yet.++ - Conversion checking is slower in the presence of copatterns, since+ stuck definitions of record type do no longer count as neutral,+ since they can become unstuck by applying a projection. Thus,+ comparing two neutrals currently requires comparing all they+ projections, which repeats a lot of work.++* Top-level module no longer required.++ The top-level module can be omitted from an Agda file. The module+ name is then inferred from the file name by dropping the path and+ the `.agda` extension. So, a module defined in `/A/B/C.agda` would get+ the name `C`.++ You can also suppress only the module name of the top-level module+ by writing++ ```agda+ module _ where+ ```++ This works also for parameterised modules.++* Module parameters are now always hidden arguments in projections.+ For instance:++ ```agda+ module M (A : Set) where++ record Prod (B : Set) : Set where+ constructor _,_+ field+ fst : A+ snd : B+ open Prod public++ open M+ ```++ Now, the types of `fst` and `snd` are++ ```agda+ fst : {A : Set}{B : Set} → Prod A B → A+ snd : {A : Set}{B : Set} → Prod A B → B+ ```++ Until 2.3.2, they were++ ```agda+ fst : (A : Set){B : Set} → Prod A B → A+ snd : (A : Set){B : Set} → Prod A B → B+ ```++ This change is a step towards symmetry of constructors and projections.+ (Constructors always took the module parameters as hidden arguments).++* Telescoping lets: Local bindings are now accepted in telescopes+ of modules, function types, and lambda-abstractions.++ The syntax of telescopes as been extended to support `let`:++ ```agda+ id : (let ★ = Set) (A : ★) → A → A+ id A x = x+ ```++ In particular one can now `open` modules inside telescopes:++ ```agda+ module Star where+ ★ : Set₁+ ★ = Set+++ module MEndo (let open Star) (A : ★) where+ Endo : ★+ Endo = A → A+ ```++ Finally a shortcut is provided for opening modules:++ ```agda+ module N (open Star) (A : ★) (open MEndo A) (f : Endo) where+ ...+ ```++ The semantics of the latter is++ ```agda+ module _ where+ open Star+ module _ (A : ★) where+ open MEndo A+ module N (f : Endo) where+ ...+ ```++ The semantics of telescoping lets in function types and lambda+ abstractions is just expanding them into ordinary lets.++* More liberal left-hand sides in lets+ [Issue [#1028](https://github.com/agda/agda/issues/1028)]:++ You can now write left-hand sides with arguments also for let+ bindings without a type signature. For instance,++ ```agda+ let f x = suc x in f zero+ ```++ Let bound functions still can't do pattern matching though.++* Ambiguous names in patterns are now optimistically resolved in favor+ of constructors. [Issue [#822](https://github.com/agda/agda/issues/822)]+ In particular, the following succeeds now:++ ```agda+ module M where++ data D : Set₁ where+ [_] : Set → D++ postulate [_] : Set → Set++ open M++ Foo : _ → Set+ Foo [ A ] = A+ ```++* Anonymous `where`-modules are opened+ public. [Issue [#848](https://github.com/agda/agda/issues/848)]++ ```+ <clauses>+ f args = rhs+ module _ telescope where+ body+ <more clauses>+ ```++ means the following (not proper Agda code, since you cannot put a+ module in-between clauses)++ ```+ <clauses>+ module _ {arg-telescope} telescope where+ body++ f args = rhs+ <more clauses>+ ```++ Example:++ ```agda+ A : Set1+ A = B module _ where+ B : Set1+ B = Set++ C : Set1+ C = B+ ```++* Builtin `ZERO` and `SUC` have been merged with `NATURAL`.++ When binding the `NATURAL` builtin, `ZERO` and `SUC` are bound to+ the appropriate constructors automatically. This means that instead+ of writing++ ```agda+ {-# BUILTIN NATURAL Nat #-}+ {-# BUILTIN ZERO zero #-}+ {-# BUILTIN SUC suc #-}+ ```++ you just write++ ```agda+ {-# BUILTIN NATURAL Nat #-}+ ```++* Pattern synonym can now have implicit+ arguments. [Issue [#860](https://github.com/agda/agda/issues/860)]++ For example,++ ```agda+ pattern tail=_ {x} xs = x ∷ xs++ len : ∀ {A} → List A → Nat+ len [] = 0+ len (tail= xs) = 1 + len xs+ ```++* Syntax declarations can now have implicit+ arguments. [Issue [#400](https://github.com/agda/agda/issues/400)]++ For example++ ```agda+ id : ∀ {a}{A : Set a} -> A -> A+ id x = x++ syntax id {A} x = x ∈ A+ ```++* Minor syntax changes++ - `-}` is now parsed as end-comment even if no comment was begun. As+ a consequence, the following definition gives a parse error++ ```agda+ f : {A- : Set} -> Set+ f {A-} = A-+ ```++ because Agda now sees `ID(f) LBRACE ID(A) END-COMMENT`, and no+ longer `ID(f) LBRACE ID(A-) RBRACE`.++ The rational is that the previous lexing was to context-sensitive,+ attempting to comment-out `f` using `{-` and `-}` lead to a parse+ error.++ - Fixities (binding strengths) can now be negative numbers as+ well. [Issue [#1109](https://github.com/agda/agda/issues/1109)]++ ```agda+ infix -1 _myop_+ ```++ - Postulates are now allowed in mutual+ blocks. [Issue [#977](https://github.com/agda/agda/issues/977)]++ - Empty where blocks are now+ allowed. [Issue [#947](https://github.com/agda/agda/issues/947)]++ - Pattern synonyms are now allowed in parameterised+ modules. [Issue [#941](https://github.com/agda/agda/issues/941)]++ - Empty hiding and renaming lists in module directives are now allowed.++ - Module directives `using`, `hiding`, `renaming` and `public` can+ now appear in arbitrary order. Multiple+ `using`/`hiding`/`renaming` directives are allowed, but you still+ cannot have both using and `hiding` (because that doesn't make+ sense). [Issue [#493](https://github.com/agda/agda/issues/493)]++Goal and error display+----------------------++* The error message `Refuse to construct infinite term` has been+ removed, instead one gets unsolved meta variables. Reason: the+ error was thrown over-eagerly.+ [Issue [#795](https://github.com/agda/agda/issues/795)]++* If an interactive case split fails with message++ ```+ Since goal is solved, further case distinction is not supported;+ try `Solve constraints' instead+ ```++ then the associated interaction meta is assigned to a solution.+ Press `C-c C-=` (Show constraints) to view the solution and `C-c+ C-s` (Solve constraints) to apply it.+ [Issue [#289](https://github.com/agda/agda/issues/289)]++Type checking+-------------++* [ Issue [#376](https://github.com/agda/agda/issues/376) ]+ Implemented expansion of bound record variables during meta+ assignment. Now Agda can solve for metas X that are applied to+ projected variables, e.g.:++ ```agda+ X (fst z) (snd z) = z++ X (fst z) = fst z+ ```++ Technically, this is realized by substituting `(x , y)` for `z` with fresh+ bound variables `x` and `y`. Here the full code for the examples:++ ```agda+ record Sigma (A : Set)(B : A -> Set) : Set where+ constructor _,_+ field+ fst : A+ snd : B fst+ open Sigma++ test : (A : Set) (B : A -> Set) ->+ let X : (x : A) (y : B x) -> Sigma A B+ X = _+ in (z : Sigma A B) -> X (fst z) (snd z) ≡ z+ test A B z = refl++ test' : (A : Set) (B : A -> Set) ->+ let X : A -> A+ X = _+ in (z : Sigma A B) -> X (fst z) ≡ fst z+ test' A B z = refl+ ```++ The fresh bound variables are named `fst(z)` and `snd(z)` and can appear+ in error messages, e.g.:++ ```agda+ fail : (A : Set) (B : A -> Set) ->+ let X : A -> Sigma A B+ X = _+ in (z : Sigma A B) -> X (fst z) ≡ z+ fail A B z = refl+ ```++ results in error:++ ```+ Cannot instantiate the metavariable _7 to solution fst(z) , snd(z)+ since it contains the variable snd(z) which is not in scope of the+ metavariable or irrelevant in the metavariable but relevant in the+ solution+ when checking that the expression refl has type _7 A B (fst z) ≡ z+ ```++* Dependent record types and definitions by copatterns require+ reduction with previous function clauses while checking the current+ clause. [Issue [#907](https://github.com/agda/agda/issues/907)]++ For a simple example, consider++ ```agda+ test : ∀ {A} → Σ Nat λ n → Vec A n+ proj₁ test = zero+ proj₂ test = []+ ```++ For the second clause, the lhs and rhs are typed as++ ```agda+ proj₂ test : Vec A (proj₁ test)+ [] : Vec A zero+ ```++ In order for these types to match, we have to reduce the lhs type+ with the first function clause.++ Note that termination checking comes after type checking, so be+ careful to avoid non-termination! Otherwise, the type checker+ might get into an infinite loop.++* The implementation of the primitive `primTrustMe` has changed. It+ now only reduces to `REFL` if the two arguments `x` and `y` have the+ same computational normal form. Before, it reduced when `x` and `y`+ were definitionally equal, which included type-directed equality+ laws such as eta-equality. Yet because reduction is untyped,+ calling conversion from reduction lead to Agda crashes+ [Issue [#882](https://github.com/agda/agda/issues/882)].++ The amended description of `primTrustMe` is (cf. release notes+ for 2.2.6):++ ```agda+ primTrustMe : {A : Set} {x y : A} → x ≡ y+ ```++ Here `_≡_` is the builtin equality (see BUILTIN hooks for equality,+ above).++ If `x` and `y` have the same computational normal form, then+ `primTrustMe {x = x} {y = y}` reduces to `refl`.++ A note on `primTrustMe`'s runtime behavior: The MAlonzo compiler+ replaces all uses of `primTrustMe` with the `REFL` builtin, without+ any check for definitional equality. Incorrect uses of `primTrustMe`+ can potentially lead to segfaults or similar problems of the+ compiled code.++* Implicit patterns of record type are now only eta-expanded if there+ is a record constructor.+ [Issues [#473](https://github.com/agda/agda/issues/473),+ [#635](https://github.com/agda/agda/issues/635)]++ ```agda+ data D : Set where+ d : D++ data P : D → Set where+ p : P d++ record Rc : Set where+ constructor c+ field f : D++ works : {r : Rc} → P (Rc.f r) → Set+ works p = D+ ```++ This works since the implicit pattern `r` is eta-expanded to `c x`+ which allows the type of `p` to reduce to `P x` and `x` to be+ unified with `d`. The corresponding explicit version is:++ ```agda+ works' : (r : Rc) → P (Rc.f r) → Set+ works' (c .d) p = D+ ```++ However, if the record constructor is removed, the same example will+ fail:++ ```agda+ record R : Set where+ field f : D++ fails : {r : R} → P (R.f r) → Set+ fails p = D++ -- d != R.f r of type D+ -- when checking that the pattern p has type P (R.f r)+ ```++ The error is justified since there is no pattern we could write down+ for `r`. It would have to look like++ ```agda+ record { f = .d }+ ```++ but anonymous record patterns are not part of the language.++* Absurd lambdas at different source locations are no longer+ different. [Issue [#857](https://github.com/agda/agda/issues/857)]+ In particular, the following code type-checks now:++ ```agda+ absurd-equality : _≡_ {A = ⊥ → ⊥} (λ()) λ()+ absurd-equality = refl+ ```++ Which is a good thing!++* Printing of named implicit function types.++ When printing terms in a context with bound variables Agda renames+ new bindings to avoid clashes with the previously bound names. For+ instance, if `A` is in scope, the type `(A : Set) → A` is printed as+ `(A₁ : Set) → A₁`. However, for implicit function types the name of+ the binding matters, since it can be used when giving implicit+ arguments.++ For this situation, the following new syntax has been introduced:+ `{x = y : A} → B` is an implicit function type whose bound variable+ (in scope in `B`) is `y`, but where the name of the argument is `x`+ for the purposes of giving it explicitly. For instance, with `A` in+ scope, the type `{A : Set} → A` is now printed as `{A = A₁ : Set} →+ A₁`.++ This syntax is only used when printing and is currently not being parsed.++* Changed the semantics of `--without-K`.+ [Issue [#712](https://github.com/agda/agda/issues/712),+ Issue [#865](https://github.com/agda/agda/issues/865),+ Issue [#1025](https://github.com/agda/agda/issues/1025)]++ New specification of `--without-K`:++ When `--without-K` is enabled, the unification of indices for+ pattern matching is restricted in two ways:++ 1. Reflexive equations of the form `x == x` are no longer solved,+ instead Agda gives an error when such an equation is encountered.++ 2. When unifying two same-headed constructor forms `c us` and `c vs`+ of type `D pars ixs`, the datatype indices `ixs` (but not the+ parameters) have to be *self-unifiable*, i.e. unification of+ `ixs` with itself should succeed positively. This is a nontrivial+ requirement because of point 1.++ Examples:++ - The J rule is accepted.++ ```agda+ J : {A : Set} (P : {x y : A} → x ≡ y → Set) →+ (∀ x → P (refl x)) →+ ∀ {x y} (x≡y : x ≡ y) → P x≡y+ J P p (refl x) = p x+ ```agda++ This definition is accepted since unification of `x` with `y`+ doesn't require deletion or injectivity.++ - The K rule is rejected.++ ```agda+ K : {A : Set} (P : {x : A} → x ≡ x → Set) →+ (∀ x → P (refl {x = x})) →+ ∀ {x} (x≡x : x ≡ x) → P x≡x+ K P p refl = p _+ ```++ Definition is rejected with the following error:++ ```+ Cannot eliminate reflexive equation x = x of type A because K has+ been disabled.+ when checking that the pattern refl has type x ≡ x+ ```++ - Symmetry of the new criterion.++ ```agda+ test₁ : {k l m : ℕ} → k + l ≡ m → ℕ+ test₁ refl = zero++ test₂ : {k l m : ℕ} → k ≡ l + m → ℕ+ test₂ refl = zero+ ```++ Both versions are now accepted (previously only the first one was).++ - Handling of parameters.++ ```agda+ cons-injective : {A : Set} (x y : A) → (x ∷ []) ≡ (y ∷ []) → x ≡ y+ cons-injective x .x refl = refl+ ```++ Parameters are not unified, so they are ignored by the new criterion.++ - A larger example: antisymmetry of ≤.++ ```agda+ data _≤_ : ℕ → ℕ → Set where+ lz : (n : ℕ) → zero ≤ n+ ls : (m n : ℕ) → m ≤ n → suc m ≤ suc n++ ≤-antisym : (m n : ℕ) → m ≤ n → n ≤ m → m ≡ n+ ≤-antisym .zero .zero (lz .zero) (lz .zero) = refl+ ≤-antisym .(suc m) .(suc n) (ls m n p) (ls .n .m q) =+ cong suc (≤-antisym m n p q)+ ```++ - [ Issue [#1025](https://github.com/agda/agda/issues/1025) ]++ ```agda+ postulate mySpace : Set+ postulate myPoint : mySpace++ data Foo : myPoint ≡ myPoint → Set where+ foo : Foo refl++ test : (i : foo ≡ foo) → i ≡ refl+ test refl = {!!}+ ```++ When applying injectivity to the equation `foo ≡ foo` of type `Foo+ refl`, it is checked that the index `refl` of type `myPoint ≡+ myPoint` is self-unifiable. The equation `refl ≡ refl` again+ requires injectivity, so now the index `myPoint` is checked for+ self-unifiability, hence the error:++ ```+ Cannot eliminate reflexive equation myPoint = myPoint of type+ mySpace because K has been disabled.+ when checking that the pattern refl has type foo ≡ foo+ ```++Termination checking+--------------------++* A buggy facility coined "matrix-shaped orders" that supported+ uncurried functions (which take tuples of arguments instead of one+ argument after another) has been removed from the termination+ checker. [Issue [#787](https://github.com/agda/agda/issues/787)]++* Definitions which fail the termination checker are not unfolded any+ longer to avoid loops or stack overflows in Agda. However, the+ termination checker for a mutual block is only invoked after+ type-checking, so there can still be loops if you define a+ non-terminating function. But termination checking now happens+ before the other supplementary checks: positivity, polarity,+ injectivity and projection-likeness. Note that with the pragma `{-#+ NO_TERMINATION_CHECK #-}` you can make Agda treat any function as+ terminating.++* Termination checking of functions defined by `with` has been improved.++ Cases which previously required `--termination-depth` to pass the+ termination checker (due to use of `with`) no longer need the+ flag. For example++ ```agda+ merge : List A → List A → List A+ merge [] ys = ys+ merge xs [] = xs+ merge (x ∷ xs) (y ∷ ys) with x ≤ y+ merge (x ∷ xs) (y ∷ ys) | false = y ∷ merge (x ∷ xs) ys+ merge (x ∷ xs) (y ∷ ys) | true = x ∷ merge xs (y ∷ ys)+ ```++ This failed to termination check previously, since the `with`+ expands to an auxiliary function `merge-aux`:++ ```agda+ merge-aux x y xs ys false = y ∷ merge (x ∷ xs) ys+ merge-aux x y xs ys true = x ∷ merge xs (y ∷ ys)+ ```++ This function makes a call to `merge` in which the size of one of+ the arguments is increasing. To make this pass the termination+ checker now inlines the definition of `merge-aux` before checking,+ thus effectively termination checking the original source program.++ As a result of this transformation doing `with` on a variable no longer+ preserves termination. For instance, this does not termination check:++ ```agda+ bad : Nat → Nat+ bad n with n+ ... | zero = zero+ ... | suc m = bad m+ ```++* The performance of the termination checker has been improved. For+ higher `--termination-depth` the improvement is significant. While+ the default `--termination-depth` is still 1, checking with higher+ `--termination-depth` should now be feasible.++Compiler backends+-----------------++* The MAlonzo compiler backend now has support for compiling modules+ that are not full programs (i.e. don't have a main function). The+ goal is that you can write part of a program in Agda and the rest in+ Haskell, and invoke the Agda functions from the Haskell code. The+ following features were added for this reason:++ - A new command-line option `--compile-no-main`: the command++ ```+ agda --compile-no-main Test.agda+ ```++ will compile `Test.agda` and all its dependencies to Haskell and+ compile the resulting Haskell files with `--make`, but (unlike+ `--compile`) not tell GHC to treat `Test.hs` as the main+ module. This type of compilation can be invoked from Emacs by+ customizing the `agda2-backend` variable to value `MAlonzoNoMain` and+ then calling `C-c C-x C-c` as before.++ - A new pragma `COMPILED_EXPORT` was added as part of the MAlonzo+ FFI. If we have an Agda file containing the following:++ ```agda+ module A.B where++ test : SomeType+ test = someImplementation++ {-# COMPILED_EXPORT test someHaskellId #-}+ ```++ then test will be compiled to a Haskell function called+ `someHaskellId` in module `MAlonzo.Code.A.B` that can be invoked+ from other Haskell code. Its type will be translated according to+ the normal MAlonzo rules.++Tools+-----++### Emacs mode++* A new goal command `Helper Function Type` (`C-c C-h`) has been added.++ If you write an application of an undefined function in a goal, the+ `Helper Function Type` command will print the type that the function+ needs to have in order for it to fit the goal. The type is also+ added to the Emacs kill-ring and can be pasted into the buffer using+ `C-y`.++ The application must be of the form `f args` where `f` is the name of the+ helper function you want to create. The arguments can use all the normal+ features like named implicits or instance arguments.++ Example:++ Here's a start on a naive reverse on vectors:++ ```agda+ reverse : ∀ {A n} → Vec A n → Vec A n+ reverse [] = []+ reverse (x ∷ xs) = {!snoc (reverse xs) x!}+ ```++ Calling `C-c C-h` in the goal prints++ ```agda+ snoc : ∀ {A} {n} → Vec A n → A → Vec A (suc n)+ ```++* A new command `Explain why a particular name is in scope` (`C-c+ C-w`) has been added.+ [Issue [#207](https://github.com/agda/agda/issues/207)]++ This command can be called from a goal or from the top-level and will as the+ name suggests explain why a particular name is in scope.++ For each definition or module that the given name can refer to a trace is+ printed of all open statements and module applications leading back to the+ original definition of the name.++ For example, given++ ```agda+ module A (X : Set₁) where+ data Foo : Set where+ mkFoo : Foo+ module B (Y : Set₁) where+ open A Y public+ module C = B Set+ open C+ ```++ Calling `C-c C-w` on `mkFoo` at the top-level prints++ ```+ mkFoo is in scope as+ * a constructor Issue207.C._.Foo.mkFoo brought into scope by+ - the opening of C at Issue207.agda:13,6-7+ - the application of B at Issue207.agda:11,12-13+ - the application of A at Issue207.agda:9,8-9+ - its definition at Issue207.agda:6,5-10+ ```++ This command is useful if Agda complains about an ambiguous name and+ you need to figure out how to hide the undesired interpretations.++* Improvements to the `make case` command (`C-c C-c`)++ - One can now also split on hidden variables, using the name+ (starting with `.`) with which they are printed. Use `C-c C-`, to+ see all variables in context.++ - Concerning the printing of generated clauses:++ * Uses named implicit arguments to improve readability.++ * Picks explicit occurrences over implicit ones when there is a+ choice of binding site for a variable.++ * Avoids binding variables in implicit positions by replacing dot+ patterns that uses them by wildcards (`._`).++* Key bindings for lots of "mathematical" characters (examples: 𝐴𝑨𝒜𝓐𝔄)+ have been added to the Agda input method. Example: type+ `\MiA\MIA\McA\MCA\MfA` to get 𝐴𝑨𝒜𝓐𝔄.++ Note: `\McB` does not exist in Unicode (as well as others in that style),+ but the `\MC` (bold) alphabet is complete.++* Key bindings for "blackboard bold" B (𝔹) and 0-9 (𝟘-𝟡) have been+ added to the Agda input method (`\bb` and `\b[0-9]`).++* Key bindings for controlling simplification/normalisation:++ Commands like `Goal type and context` (`C-c C-,`) could previously+ be invoked in two ways. By default the output was normalised, but if+ a prefix argument was used (for instance via `C-u C-c C-,`), then no+ explicit normalisation was performed. Now there are three options:++ - By default (`C-c C-,`) the output is simplified.++ - If `C-u` is used exactly once (`C-u C-c C-,`), then the result is+ neither (explicitly) normalised nor simplified.++ - If `C-u` is used twice (`C-u C-u C-c C-,`), then the result is+ normalised.++### LaTeX-backend++* Two new color scheme options were added to `agda.sty`:++ `\usepackage[bw]{agda}`, which highlights in black and white;+ `\usepackage[conor]{agda}`, which highlights using Conor's colors.++ The default (no options passed) is to use the standard colors.++* If `agda.sty` cannot be found by the LateX environment, it is now+ copied into the LateX output directory (`latex` by default) instead+ of the working directory. This means that the commands needed to+ produce a PDF now is++ ```+ agda --latex -i . <file>.lagda+ cd latex+ pdflatex <file>.tex+ ```++* The LaTeX-backend has been made more tool agnostic, in particular+ XeLaTeX and LuaLaTeX should now work. Here is a small example+ (`test/LaTeXAndHTML/succeed/UnicodeInput.lagda`):++ ```latex+ \documentclass{article}+ \usepackage{agda}+ \begin{document}++ \begin{code}+ data αβγδεζθικλμνξρστυφχψω : Set₁ where++ postulate+ →⇒⇛⇉⇄↦⇨↠⇀⇁ : Set+ \end{code}++ \[+ ∀X [ ∅ ∉ X ⇒ ∃f:X ⟶ ⋃ X\ ∀A ∈ X (f(A) ∈ A) ]+ \]+ \end{document}+ ```++ Compiled as follows, it should produce a nice looking PDF (tested with+ TeX Live 2012):++ ```+ agda --latex <file>.lagda+ cd latex+ xelatex <file>.tex (or lualatex <file>.tex)+ ```++ If symbols are missing or XeLaTeX/LuaLaTeX complains about the font+ missing, try setting a different font using:++ ```latex+ \setmathfont{<math-font>}+ ```++ Use the `fc-list` tool to list available fonts.++* Add experimental support for hyperlinks to identifiers++ If the `hyperref` LateX package is loaded before the Agda package+ and the links option is passed to the Agda package, then the Agda+ package provides a function called `\AgdaTarget`. Identifiers which+ have been declared targets, by the user, will become clickable+ hyperlinks in the rest of the document. Here is a small example+ (`test/LaTeXAndHTML/succeed/Links.lagda`):++ ```latex+ \documentclass{article}+ \usepackage{hyperref}+ \usepackage[links]{agda}+ \begin{document}++ \AgdaTarget{ℕ}+ \AgdaTarget{zero}+ \begin{code}+ data ℕ : Set where+ zero : ℕ+ suc : ℕ → ℕ+ \end{code}++ See next page for how to define \AgdaFunction{two} (doesn't turn into a+ link because the target hasn't been defined yet). We could do it+ manually though; \hyperlink{two}{\AgdaDatatype{two}}.++ \newpage++ \AgdaTarget{two}+ \hypertarget{two}{}+ \begin{code}+ two : ℕ+ two = suc (suc zero)+ \end{code}++ \AgdaInductiveConstructor{zero} is of type+ \AgdaDatatype{ℕ}. \AgdaInductiveConstructor{suc} has not been defined to+ be a target so it doesn't turn into a link.++ \newpage++ Now that the target for \AgdaFunction{two} has been defined the link+ works automatically.++ \begin{code}+ data Bool : Set where+ true false : Bool+ \end{code}++ The AgdaTarget command takes a list as input, enabling several+ targets to be specified as follows:++ \AgdaTarget{if, then, else, if\_then\_else\_}+ \begin{code}+ if_then_else_ : {A : Set} → Bool → A → A → A+ if true then t else f = t+ if false then t else f = f+ \end{code}++ \newpage++ Mixfix identifier need their underscores escaped:+ \AgdaFunction{if\_then\_else\_}.++ \end{document}+ ```++ The boarders around the links can be suppressed using hyperref's+ hidelinks option:++ ```latex+ \usepackage[hidelinks]{hyperref}+ ```++ Note that the current approach to links does not keep track of scoping+ or types, and hence overloaded names might create links which point to+ the wrong place. Therefore it is recommended to not overload names+ when using the links option at the moment, this might get fixed in the+ future.
@@ -0,0 +1,214 @@+Release notes for Agda version 2.4.2.1+======================================++Pragmas and options+-------------------++* New pragma `{-# TERMINATING #-}` replacing+ `{-# NO_TERMINATION_CHECK #-}`++ Complements the existing pragma `{-# NON_TERMINATING #-}`. Skips+ termination check for the associated definitions and marks them as+ terminating. Thus, it is a replacement for `{-#+ NO_TERMINATION_CHECK #-}` with the same semantics.++ You can no longer use pragma `{-# NO_TERMINATION_CHECK #-}` to skip+ the termination check, but must label your definitions as either+ `{-# TERMINATING #-}` or `{-# NON_TERMINATING #-}` instead.++ Note: `{-# OPTION --no-termination-check #-}` labels all your+ definitions as `{-# TERMINATING #-}`, putting you in the danger zone+ of a loop in the type checker.++Language+--------++* Referring to a local variable shadowed by module opening is now an+ error. Previous behavior was preferring the local over the imported+ definitions. [Issue [#1266](https://github.com/agda/agda/issues/1266)]++ Note that module parameters are locals as well as variables bound by+ λ, dependent function type, patterns, and let.++ Example:++ ```agda+ module M where+ A = Set1++ test : (A : Set) → let open M in A+ ```++ The last `A` produces an error, since it could refer to the local+ variable `A` or to the definition imported from module `M`.++* `with` on a variable bound by a module telescope or a pattern of a+ parent function is now forbidden.+ [Issue [#1342](https://github.com/agda/agda/issues/1342)]++ ```agda+ data Unit : Set where+ unit : Unit++ id : (A : Set) → A → A+ id A a = a++ module M (x : Unit) where++ dx : Unit → Unit+ dx unit = x++ g : ∀ u → x ≡ dx u+ g with x+ g | unit = id (∀ u → unit ≡ dx u) ?+ ```++ Even though this code looks right, Agda complains about the type+ expression `∀ u → unit ≡ dx u`. If you ask Agda what should go+ there instead, it happily tells you that it wants `∀ u → unit ≡ dx+ u`. In fact what you do not see and Agda will never show you is that+ the two expressions actually differ in the invisible first argument+ to `dx`, which is visible only outside module `M`. What Agda wants+ is an invisible `unit` after `dx`, but all you can write is an+ invisible `x` (which is inserted behind the scenes).++ To avoid those kinds of paradoxes, `with` is now outlawed on module+ parameters. This should ensure that the invisible arguments are+ always exactly the module parameters.++ Since a `where` block is desugared as module with pattern variables+ of the parent clause as module parameters, the same strikes you for+ uses of `with` on pattern variables of the parent function.++ ```agda+ f : Unit → Unit+ f x = unit+ where+ dx : Unit → Unit+ dx unit = x++ g : ∀ u → x ≡ dx u+ g with x+ g | unit = id ((u : Unit) → unit ≡ dx u) ?+ ```++ The `with` on pattern variable `x` of the parent clause `f x = unit`+ is outlawed now.++Type checking+-------------++* Termination check failure is now a proper error.++ We no longer continue type checking after termination check+ failures. Use pragmas `{-# NON_TERMINATING #-}` and `{-#+ NO_TERMINATION_CHECK #-}` near the offending definitions if you want+ to do so. Or switch off the termination checker altogether with+ `{-# OPTIONS --no-termination-check #-}` (at your own risk!).++* (Since Agda 2.4.2): Termination checking `--without-K` restricts+ structural descent to arguments ending in data types or `Size`.+ Likewise, guardedness is only tracked when result type is data or+ record type.++ ```agda+ mutual+ data WOne : Set where wrap : FOne → WOne+ FOne = ⊥ → WOne++ noo : (X : Set) → (WOne ≡ X) → X → ⊥+ noo .WOne refl (wrap f) = noo FOne iso f+ ```++ `noo` is rejected since at type `X` the structural descent+ `f < wrap f` is discounted `--without-K`.++ ```agda+ data Pandora : Set where+ C : ∞ ⊥ → Pandora++ loop : (A : Set) → A ≡ Pandora → A+ loop .Pandora refl = C (♯ (loop ⊥ foo))+ ```++ `loop` is rejected since guardedness is not tracked at type `A`+ `--without-K`.++ See issues [#1023](https://github.com/agda/agda/issues/1023),+ [#1264](https://github.com/agda/agda/issues/1264),+ [#1292](https://github.com/agda/agda/issues/1292).++Termination checking+--------------------++* The termination checker can now recognize simple subterms in dot+ patterns.++ ```agda+ data Subst : (d : Nat) → Set where+ c₁ : ∀ {d} → Subst d → Subst d+ c₂ : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (suc d₁ + d₂)++ postulate+ comp : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (d₁ + d₂)++ lookup : ∀ d → Nat → Subst d → Set₁+ lookup d zero (c₁ ρ) = Set+ lookup d (suc v) (c₁ ρ) = lookup d v ρ+ lookup .(suc d₁ + d₂) v (c₂ {d₁} {d₂} ρ σ) = lookup (d₁ + d₂) v (comp ρ σ)+ ```++ The dot pattern here is actually normalized, so it is++ ```agda+ suc (d₁ + d₂)+ ```++ and the corresponding recursive call argument is `(d₁ + d₂)`. In+ such simple cases, Agda can now recognize that the pattern is+ constructor applied to call argument, which is valid descent.++ Note however, that Agda only looks for syntactic equality when+ identifying subterms, since it is not allowed to normalize terms on+ the rhs during termination checking.++ Actually writing the dot pattern has no effect, this works as well,+ and looks pretty magical... ;-)++ ```agda+ hidden : ∀{d} → Nat → Subst d → Set₁+ hidden zero (c₁ ρ) = Set+ hidden (suc v) (c₁ ρ) = hidden v ρ+ hidden v (c₂ ρ σ) = hidden v (comp ρ σ)+ ```++Tools+-----++### LaTeX-backend++* Fixed the issue of identifiers containing operators being typeset with+ excessive math spacing.++Bug fixes+---------++* Issue [#1194](https://github.com/agda/agda/issues/1194)++* Issue [#836](https://github.com/agda/agda/issues/836): Fields and+ constructors can be qualified by the record/data *type* as well as+ by their record/data module. This now works also for record/data+ type imported from parametrized modules:++ ```agda+ module M (_ : Set₁) where++ record R : Set₁ where+ field+ X : Set++ open M Set using (R) -- rather than using (module R)++ X : R → Set+ X = R.X+ ```
@@ -0,0 +1,20 @@+Release notes for Agda version 2.4.2.2+======================================++Bug fixes+---------++* Compilation on Windows fixed.++* Other issues fixed (see+ [bug tracker](https://github.com/agda/agda/issues))++ [#1332](https://github.com/agda/agda/issues/1322)++ [#1353](https://github.com/agda/agda/issues/1353)++ [#1360](https://github.com/agda/agda/issues/1360)++ [#1366](https://github.com/agda/agda/issues/1366)++ [#1369](https://github.com/agda/agda/issues/1369)
@@ -0,0 +1,303 @@+Release notes for Agda version 2.4.2.3+======================================++Installation and infrastructure+-------------------------------++* Added support for GHC 7.10.1.++* Removed support for GHC 7.0.4.++Language+--------++* `_ `is no longer a valid name for a definition. The following fails+ now: [Issue [#1465](https://github.com/agda/agda/issues/1465)]++ ```agda+ postulate _ : Set+ ```++* Typed bindings can now contain hiding information+ [Issue [#1391](https://github.com/agda/agda/issues/1391)]. This+ means you can now write++ ```agda+ assoc : (xs {ys zs} : List A) → ((xs ++ ys) ++ zs) ≡ (xs ++ (ys ++ zs))+ ```++ instead of the longer++ ```agda+ assoc : (xs : List A) {ys zs : List A} → ...+ ```++ It also works with irrelevance++ ```agda+ .(xs {ys zs} : List A) → ...+ ```++ but of course does not make sense if there is hiding information already.+ Thus, this is (still) a parse error:++ ```agda+ {xs {ys zs} : List A} → ...+ ```++* The builtins for sized types no longer need accompanying postulates.+ The BUILTIN pragmas for size stuff now also declare the identifiers+ they bind to.++ ```agda+ {-# BUILTIN SIZEUNIV SizeUniv #-} -- SizeUniv : SizeUniv+ {-# BUILTIN SIZE Size #-} -- Size : SizeUniv+ {-# BUILTIN SIZELT Size<_ #-} -- Size<_ : ..Size → SizeUniv+ {-# BUILTIN SIZESUC ↑_ #-} -- ↑_ : Size → Size+ {-# BUILTIN SIZEINF ∞ #-} -- ∞ : Size+ ```++ `Size` and `Size<` now live in the new universe `SizeUniv`. It is+ forbidden to build function spaces in this universe, in order to+ prevent the malicious assumption of a size predecessor++ ```agda+ pred : (i : Size) → Size< i+ ```++ [Issue [#1428](https://github.com/agda/agda/issues/1428)].++* Unambiguous notations (coming from syntax declarations) that resolve+ to ambiguous names are now parsed unambiguously+ [Issue [#1194](https://github.com/agda/agda/issues/1194)].++* If only some instances of an overloaded name have a given associated+ notation (coming from syntax declarations), then this name can only+ be resolved to the given instances of the name, not to other+ instances [Issue [#1194](https://github.com/agda/agda/issues/1194)].++ Previously, if different instances of an overloaded name had+ *different* associated notations, then none of the notations could+ be used. Now all of them can be used.++ Note that notation identity does not only involve the right-hand+ side of the syntax declaration. For instance, the following+ notations are not seen as identical, because the implicit argument+ names are different:++ ```agda+ module A where++ data D : Set where+ c : {x y : D} → D++ syntax c {x = a} {y = b} = a ∙ b++ module B where++ data D : Set where+ c : {y x : D} → D++ syntax c {y = a} {x = b} = a ∙ b+ ```++* If an overloaded operator is in scope with at least two distinct+ fixities, then it gets the default fixity+ [Issue [#1436](https://github.com/agda/agda/issues/1436)].++ Similarly, if two or more identical notations for a given overloaded+ name are in scope, and these notations do not all have the+ same fixity, then they get the default fixity.++Type checking+-------------++* Functions of varying arity can now have with-clauses and use rewrite.++ Example:++ ```agda+ NPred : Nat → Set+ NPred 0 = Bool+ NPred (suc n) = Nat → NPred n++ const : Bool → ∀{n} → NPred n+ const b {0} = b+ const b {suc n} m = const b {n}++ allOdd : ∀ n → NPred n+ allOdd 0 = true+ allOdd (suc n) m with even m+ ... | true = const false+ ... | false = allOdd n+ ```++* Function defined by copattern matching can now have `with`-clauses+ and use `rewrite`.++ Example:++ ```agda+ {-# OPTIONS --copatterns #-}++ record Stream (A : Set) : Set where+ coinductive+ constructor delay+ field+ force : A × Stream A+ open Stream++ map : ∀{A B} → (A → B) → Stream A → Stream B+ force (map f s) with force s+ ... | a , as = f a , map f as++ record Bisim {A B} (R : A → B → Set) (s : Stream A) (t : Stream B) : Set where+ coinductive+ constructor ~delay+ field+ ~force : let a , as = force s+ b , bs = force t+ in R a b × Bisim R as bs+ open Bisim++ SEq : ∀{A} (s t : Stream A) → Set+ SEq = Bisim (_≡_)++ -- Slightly weird definition of symmetry to demonstrate rewrite.++ ~sym' : ∀{A} {s t : Stream A} → SEq s t → SEq t s+ ~force (~sym' {s = s} {t} p) with force s | force t | ~force p+ ... | a , as | b , bs | r , q rewrite r = refl , ~sym' q+ ```++* Instances can now be defined by copattern+ matching. [Issue [#1413](https://github.com/agda/agda/issues/1413)]+ The following example extends the one in+ [Abel, Pientka, Thibodeau, Setzer, POPL 2013, Section 2.2]:++ ```agda+ {-# OPTIONS --copatterns #-}++ -- The Monad type class++ record Monad (M : Set → Set) : Set1 where+ field+ return : {A : Set} → A → M A+ _>>=_ : {A B : Set} → M A → (A → M B) → M B+ open Monad {{...}}++ -- The State newtype++ record State (S A : Set) : Set where+ field+ runState : S → A × S+ open State++ -- State is an instance of Monad++ instance+ stateMonad : {S : Set} → Monad (State S)+ runState (return {{stateMonad}} a ) s = a , s -- NEW+ runState (_>>=_ {{stateMonad}} m k) s₀ = -- NEW+ let a , s₁ = runState m s₀+ in runState (k a) s₁++ -- stateMonad fulfills the monad laws++ leftId : {A B S : Set}(a : A)(k : A → State S B) →+ (return a >>= k) ≡ k a+ leftId a k = refl++ rightId : {A B S : Set}(m : State S A) →+ (m >>= return) ≡ m+ rightId m = refl++ assoc : {A B C S : Set}(m : State S A)(k : A → State S B)(l : B → State S C) →+ ((m >>= k) >>= l) ≡ (m >>= λ a → k a >>= l)+ assoc m k l = refl+ ```++Emacs mode+----------++* The new menu option `Switch to another version of Agda` tries to do+ what it says.++* Changed feature: Interactively split result.++ [ This is as before: ]+ Make-case (`C-c C-c`) with no variables given tries to split on the+ result to introduce projection patterns. The hole needs to be of+ record type, of course.++ ```agda+ test : {A B : Set} (a : A) (b : B) → A × B+ test a b = ?+ ```++ Result-splitting `?` will produce the new clauses:++ ```agda+ proj₁ (test a b) = ?+ proj₂ (test a b) = ?+ ```++ [ This has changed: ]+ If hole is of function type, `make-case` will introduce only pattern+ variables (as much as it can).++ ```agda+ testFun : {A B : Set} (a : A) (b : B) → A × B+ testFun = ?+ ```++ Result-splitting `?` will produce the new clause:++ ```agda+ testFun a b = ?+ ```++ A second invocation of `make-case` will then introduce projection+ patterns.++Error messages+--------------++* Agda now suggests corrections of misspelled options, e.g.++ ```agda+ {-# OPTIONS+ --dont-termination-check+ --without-k+ --senf-gurke+ #-}+ ```++ Unrecognized options:++ ```+ --dont-termination-check (did you mean --no-termination-check ?)+ --without-k (did you mean --without-K ?)+ --senf-gurke+ ```++ Nothing close to `--senf-gurke`, I am afraid.++Compiler backends+-----------------++* The Epic backend has been removed+ [Issue [#1481](https://github.com/agda/agda/issues/1481)].++Bug fixes+---------++* Fixed bug with `unquoteDecl` not working in instance blocks+ [Issue [#1491](https://github.com/agda/agda/issues/1491)].++* Other issues fixed (see+ [bug tracker](https://github.com/agda/agda/issues)++ [#1497](https://github.com/agda/agda/issues/1497)++ [#1500](https://github.com/agda/agda/issues/1500)
@@ -0,0 +1,295 @@+Release notes for Agda version 2.4.2.4+======================================++Installation and infrastructure+-------------------------------++* Removed support for GHC 7.4.2.++Pragmas and options+-------------------++* Option `--copatterns` is now on by default. To switch off+ parsing of copatterns, use:++ ```agda+ {-# OPTIONS --no-copatterns #-}+ ```++* Option `--rewriting` is now needed to use `REWRITE` pragmas and+ rewriting during reduction. Rewriting is not `--safe`.++ To use rewriting, first specify a relation symbol `R` that will+ later be used to add rewrite rules. A canonical candidate would be+ propositional equality++ ```agda+ {-# BUILTIN REWRITE _≡_ #-}+ ```++ but any symbol `R` of type `Δ → A → A → Set i` for some `A` and `i`+ is accepted. Then symbols `q` can be added to rewriting provided+ their type is of the form `Γ → R ds l r`. This will add a rewrite+ rule++ ```+ Γ ⊢ l ↦ r : A[ds/Δ]+ ```++ to the signature, which fires whenever a term is an instance of `l`.+ For example, if++ ```agda+ plus0 : ∀ x → x + 0 ≡ x+ ```++ (ideally, there is a proof for `plus0`, but it could be a+ postulate), then++ ```agda+ {-# REWRITE plus0 #-}+ ```++ will prompt Agda to rewrite any well-typed term of the form `t + 0`+ to `t`.++ Some caveats: Agda accepts and applies rewrite rules naively, it is+ very easy to break consistency and termination of type checking.+ Some examples of rewrite rules that should *not* be added:++ ```agda+ refl : ∀ x → x ≡ x -- Agda loops+ plus-sym : ∀ x y → x + y ≡ y + x -- Agda loops+ absurd : true ≡ false -- Breaks consistency+ ```++ Adding only proven equations should at least preserve consistency,+ but this is only a conjecture, so know what you are doing! Using+ rewriting, you are entering into the wilderness, where you are on+ your own!++Language+--------++* `forall` / `∀` now parses like `λ`, i.e., the following parses now+ [Issue [#1583](https://github.com/agda/agda/issues/1538)]:++ ```agda+ ⊤ × ∀ (B : Set) → B → B+ ```++* The underscore pattern `_` can now also stand for an inaccessible+ pattern (dot pattern). This alleviates the need for writing `._`.+ [Issue #[1605](https://github.com/agda/agda/issues/1605)] Instead of++ ```agda+ transVOld : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c+ transVOld _ ._ ._ refl refl = refl+ ```++ one can now write++ ```agda+ transVNew : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c+ transVNew _ _ _ refl refl = refl+ ```++ and let Agda decide where to put the dots. This was always possible+ by using hidden arguments++ ```agda+ transH : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c+ transH refl refl = refl+ ```++ which is now equivalent to++ ```agda+ transHNew : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c+ transHNew {a = _}{b = _}{c = _} refl refl = refl+ ```++ Before, underscore `_` stood for an unnamed variable that could not+ be instantiated by an inaccessible pattern. If one no wants to+ prevent Agda from instantiating, one needs to use a variable name+ other than underscore (however, in practice this situation seems+ unlikely).++Type checking+-------------++* Polarity of phantom arguments to data and record types has+ changed. [Issue [#1596](https://github.com/agda/agda/issues/1596)]+ Polarity of size arguments is Nonvariant (both monotone and+ antitone). Polarity of other arguments is Covariant (monotone).+ Both were Invariant before (neither monotone nor antitone).++ The following example type-checks now:++ ```agda+ open import Common.Size++ -- List should be monotone in both arguments+ -- (even when `cons' is missing).++ data List (i : Size) (A : Set) : Set where+ [] : List i A++ castLL : ∀{i A} → List i (List i A) → List ∞ (List ∞ A)+ castLL x = x++ -- Stream should be antitone in the first and monotone in the second argument+ -- (even with field `tail' missing).++ record Stream (i : Size) (A : Set) : Set where+ coinductive+ field+ head : A++ castSS : ∀{i A} → Stream ∞ (Stream ∞ A) → Stream i (Stream i A)+ castSS x = x+ ```++* `SIZELT` lambdas must be consistent+ [Issue [#1523](https://github.com/agda/agda/issues/1523), see Abel+ and Pientka, ICFP 2013]. When lambda-abstracting over type (`Size<+ size`) then `size` must be non-zero, for any valid instantiation of+ size variables.++ - The good:++ ```agda+ data Nat (i : Size) : Set where+ zero : ∀ (j : Size< i) → Nat i+ suc : ∀ (j : Size< i) → Nat j → Nat i++ {-# TERMINATING #-}+ -- This definition is fine, the termination checker is too strict at the moment.+ fix : ∀ {C : Size → Set}+ → (∀ i → (∀ (j : Size< i) → Nat j -> C j) → Nat i → C i)+ → ∀ i → Nat i → C i+ fix t i (zero j) = t i (λ (k : Size< i) → fix t k) (zero j)+ fix t i (suc j n) = t i (λ (k : Size< i) → fix t k) (suc j n)+ ```++ The `λ (k : Size< i)` is fine in both cases, as context++ ```agda+ i : Size, j : Size< i+ ```++ guarantees that `i` is non-zero.++ - The bad:++ ```agda+ record Stream {i : Size} (A : Set) : Set where+ coinductive+ constructor _∷ˢ_+ field+ head : A+ tail : ∀ {j : Size< i} → Stream {j} A+ open Stream public++ _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A+ [] ++ˢ s = s+ (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s)+ ```++ This fails, maybe unjustified, at++ ```agda+ i : Size, s : Stream {i} A+ ⊢+ a ∷ˢ (λ {j : Size< i} → as ++ˢ s)+ ```++ Fixed by defining the constructor by copattern matching:++ ```agda+ record Stream {i : Size} (A : Set) : Set where+ coinductive+ field+ head : A+ tail : ∀ {j : Size< i} → Stream {j} A+ open Stream public++ _∷ˢ_ : ∀ {i A} → A → Stream {i} A → Stream {↑ i} A+ head (a ∷ˢ as) = a+ tail (a ∷ˢ as) = as++ _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A+ [] ++ˢ s = s+ (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s)+ ```++ - The ugly:++ ```agda+ fix : ∀ {C : Size → Set}+ → (∀ i → (∀ (j : Size< i) → C j) → C i)+ → ∀ i → C i+ fix t i = t i λ (j : Size< i) → fix t j+ ```++ For `i=0`, there is no such `j` at runtime, leading to looping+ behavior.++Interaction+-----------++* Issue [#635](https://github.com/agda/agda/issues/635) has been+ fixed. Case splitting does not spit out implicit record patterns+ any more.++ ```agda+ record Cont : Set₁ where+ constructor _◃_+ field+ Sh : Set+ Pos : Sh → Set++ open Cont++ data W (C : Cont) : Set where+ sup : (s : Sh C) (k : Pos C s → W C) → W C++ bogus : {C : Cont} → W C → Set+ bogus w = {!w!}+ ```++ Case splitting on `w` yielded, since the fix of+ Issue [#473](https://github.com/agda/agda/issues/473),++ ```agda+ bogus {Sh ◃ Pos} (sup s k) = ?+ ```++ Now it gives, as expected,++ ```agda+ bogus (sup s k) = ?+ ```++Performance+-----------++* As one result of the 21st Agda Implementor's Meeting (AIM XXI),+ serialization of the standard library is 50% faster (time reduced by+ a third), without using additional disk space for the interface+ files.+++Bug fixes+---------++Issues fixed (see [bug tracker](https://github.com/agda/agda/issues)):++[#1546](https://github.com/agda/agda/issues/1546) (copattern matching+and with-clauses)++[#1560](https://github.com/agda/agda/issues/1560) (positivity checker+inefficiency)++[#1584](https://github.com/agda/agda/issues/1548) (let pattern with+trailing implicit)
@@ -0,0 +1,78 @@+Release notes for Agda version 2.4.2.5+======================================++Installation and infrastructure+-------------------------------++* Added support for GHC 7.10.3.++* Added `cpphs` Cabal flag++ Turn on/off this flag to choose cpphs/cpp as the C preprocessor.++ This flag is turn on by default.++ (This flag was added in Agda 2.4.2.1 but it was not documented)++Pragmas and options+-------------------++* Termination pragmas are no longer allowed inside `where` clauses+ [Issue [#1137](https://github.com/agda/agda/issues/1137)].++Type checking+-------------++* `with`-abstraction is more aggressive, abstracts also in types of+ variables that are used in the `with`-expressions, unless they are+ also used in the types of the+ `with`-expressions. [Issue [#1692](https://github.com/agda/agda/issues/1692)]++ Example:++ ```agda+ test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a+ test f b with a | f b+ test f b | .b | refl = f b+ ```++ Previously, `with` would not abstract in types of variables that+ appear in the `with`-expressions, in this case, both `f` and `b`,+ leaving their types unchanged. Now, it tries to abstract in `f`, as+ only `b` appears in the types of the `with`-expressions which are+ `A` (of `a`) and `a ≡ b` (of `f b`). As a result, the type of `f`+ changes to `(x : A) → b ≡ x` and the type of the goal to `b ≡ b` (as+ previously).++ This also affects `rewrite`, which is implemented in terms of+ `with`.++ ```agda+ test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a+ test f b rewrite f b = f b+ ```++ As the new `with` is not fully backwards-compatible, some parts of+ your Agda developments using `with` or `rewrite` might need+ maintenance.++Fixed issues+------------++See [bug tracker](https://github.com/agda/agda/issues)++[#1407](https://github.com/agda/agda/issues/1497)++[#1518](https://github.com/agda/agda/issues/1518)++[#1670](https://github.com/agda/agda/issues/1670)++[#1677](https://github.com/agda/agda/issues/1677)++[#1698](https://github.com/agda/agda/issues/1698)++[#1701](https://github.com/agda/agda/issues/1701)++[#1710](https://github.com/agda/agda/issues/1710)++[#1718](https://github.com/agda/agda/issues/1718)
@@ -0,0 +1,391 @@+Release notes for Agda version 2.4.2+====================================++Pragmas and options+-------------------++* New option: `--with-K`++ This can be used to override a global `--without-K` in a file, by+ adding a pragma `{-# OPTIONS --with-K #-}`.++* New pragma `{-# NON_TERMINATING #-}`++ This is a safer version of `NO_TERMINATION_CHECK` which doesn't+ treat the affected functions as terminating. This means that+ `NON_TERMINATING` functions do not reduce during type checking. They+ do reduce at run-time and when invoking `C-c C-n` at top-level (but+ not in a hole).++Language+--------++* Instance search is now more efficient and recursive (see+ Issue [#938](https://github.com/agda/agda/issues/938)) (but without+ termination check yet).++ A new keyword `instance` has been introduced (in the style of+ `abstract` and `private`) which must now be used for every+ definition/postulate that has to be taken into account during+ instance resolution. For example:++ ```agda+ record RawMonoid (A : Set) : Set where+ field+ nil : A+ _++_ : A -> A -> A++ open RawMonoid {{...}}++ instance+ rawMonoidList : {A : Set} -> RawMonoid (List A)+ rawMonoidList = record { nil = []; _++_ = List._++_ }++ rawMonoidMaybe : {A : Set} {{m : RawMonoid A}} -> RawMonoid (Maybe A)+ rawMonoidMaybe {A} = record { nil = nothing ; _++_ = catMaybe }+ where+ catMaybe : Maybe A -> Maybe A -> Maybe A+ catMaybe nothing mb = mb+ catMaybe ma nothing = ma+ catMaybe (just a) (just b) = just (a ++ b)+ ```++ Moreover, each type of an instance must end in (something that reduces+ to) a named type (e.g. a record, a datatype or a postulate). This+ allows us to build a simple index structure++ ```+ data/record name --> possible instances+ ```++ that speeds up instance search.++ Instance search takes into account all local bindings and all global+ `instance` bindings and the search is recursive. For instance,+ searching for++ ```agda+ ? : RawMonoid (Maybe (List A))+ ```++ will consider the candidates {`rawMonoidList`, `rawMonoidMaybe`}, fail to+ unify the first one, succeeding with the second one++ ```agda+ ? = rawMonoidMaybe {A = List A} {{m = ?m}} : RawMonoid (Maybe (List A))+ ```++ and continue with goal++ ```agda+ ?m : RawMonoid (List A)+ ```++ This will then find++ ```agda+ ?m = rawMonoidList {A = A}+ ```++ and putting together we have the solution.++ Be careful that there is no termination check for now, you can+ easily make Agda loop by declaring the identity function as an+ instance. But it shouldn’t be possible to make Agda loop by only+ declaring structurally recursive instances (whatever that means).++ Additionally:++ - Uniqueness of instances is up to definitional equality (see+ Issue [#899](https://github.com/agda/agda/issues/899)).++ - Instances of the following form are allowed:++ ```agda+ EqSigma : {A : Set} {B : A → Set} {{EqA : Eq A}}+ {{EqB : {a : A} → Eq (B a)}}+ → Eq (Σ A B)+ ```++ When searching recursively for an instance of type `{a : A} → Eq+ (B a)`, a lambda will automatically be introduced and instance+ search will search for something of type `Eq (B a)` in the context+ extended by `a : A`. When searching for an instance, the `a`+ argument does not have to be implicit, but in the definition of+ `EqSigma`, instance search will only be able to use `EqB` if `a`+ is implicit.++ - There is no longer any attempt to solve irrelevant metas by instance+ search.++ - Constructors of records and datatypes are automatically added to the+ instance table.++* You can now use `quote` in patterns.++ For instance, here is a function that unquotes a (closed) natural+ number term.++ ```agda+ unquoteNat : Term → Maybe Nat+ unquoteNat (con (quote Nat.zero) []) = just zero+ unquoteNat (con (quote Nat.suc) (arg _ n ∷ [])) = fmap suc (unquoteNat n)+ unquoteNat _ = nothing+ ```++* The builtin constructors `AGDATERMUNSUPPORTED` and+ `AGDASORTUNSUPPORTED` are now translated to meta variables when+ unquoting.++* New syntactic sugar `tactic e` and `tactic e | e1 | .. | en`.++ It desugars as follows and makes it less unwieldy to call+ reflection-based tactics.++ ```agda+ tactic e --> quoteGoal g in unquote (e g)+ tactic e | e1 | .. | en --> quoteGoal g in unquote (e g) e1 .. en+ ```++ Note that in the second form the tactic function should generate a+ function from a number of new subgoals to the original goal. The+ type of `e` should be `Term -> Term` in both cases.++* New reflection builtins for literals.++ The term data type `AGDATERM` now needs an additional constructor+ `AGDATERMLIT` taking a reflected literal defined as follows (with+ appropriate builtin bindings for the types `Nat`, `Float`, etc).++ ```agda+ data Literal : Set where+ nat : Nat → Literal+ float : Float → Literal+ char : Char → Literal+ string : String → Literal+ qname : QName → Literal++ {-# BUILTIN AGDALITERAL Literal #-}+ {-# BUILTIN AGDALITNAT nat #-}+ {-# BUILTIN AGDALITFLOAT float #-}+ {-# BUILTIN AGDALITCHAR char #-}+ {-# BUILTIN AGDALITSTRING string #-}+ {-# BUILTIN AGDALITQNAME qname #-}+ ```++ When quoting (`quoteGoal` or `quoteTerm`) literals will be mapped to+ the `AGDATERMLIT` constructor. Previously natural number literals+ were quoted to `suc`/`zero` application and other literals were+ quoted to `AGDATERMUNSUPPORTED`.++* New reflection builtins for function definitions.++ `AGDAFUNDEF` should now map to a data type defined as follows++ (with+ ```agda+ {-# BUILTIN QNAME QName #-}+ {-# BUILTIN ARG Arg #-}+ {-# BUILTIN AGDATERM Term #-}+ {-# BUILTIN AGDATYPE Type #-}+ {-# BUILTIN AGDALITERAL Literal #-}+ ```+ ).++ ```agda+ data Pattern : Set where+ con : QName → List (Arg Pattern) → Pattern+ dot : Pattern+ var : Pattern+ lit : Literal → Pattern+ proj : QName → Pattern+ absurd : Pattern++ {-# BUILTIN AGDAPATTERN Pattern #-}+ {-# BUILTIN AGDAPATCON con #-}+ {-# BUILTIN AGDAPATDOT dot #-}+ {-# BUILTIN AGDAPATVAR var #-}+ {-# BUILTIN AGDAPATLIT lit #-}+ {-# BUILTIN AGDAPATPROJ proj #-}+ {-# BUILTIN AGDAPATABSURD absurd #-}++ data Clause : Set where+ clause : List (Arg Pattern) → Term → Clause+ absurd-clause : List (Arg Pattern) → Clause++ {-# BUILTIN AGDACLAUSE Clause #-}+ {-# BUILTIN AGDACLAUSECLAUSE clause #-}+ {-# BUILTIN AGDACLAUSEABSURD absurd-clause #-}++ data FunDef : Set where+ fun-def : Type → List Clause → FunDef++ {-# BUILTIN AGDAFUNDEF FunDef #-}+ {-# BUILTIN AGDAFUNDEFCON fun-def #-}+ ```++* New reflection builtins for extended (pattern-matching) lambda.++ The `AGDATERM` data type has been augmented with a constructor++ ```agda+ AGDATERMEXTLAM : List AGDACLAUSE → List (ARG AGDATERM) → AGDATERM+ ```++ Absurd lambdas (`λ ()`) are quoted to extended lambdas with an+ absurd clause.++* Unquoting declarations.++ You can now define (recursive) functions by reflection using the new+ `unquoteDecl` declaration++ ```agda+ unquoteDecl x = e+ ```++ Here e should have type `AGDAFUNDEF` and evaluate to a closed+ value. This value is then spliced in as the definition of `x`. In+ the body `e`, `x` has type `QNAME` which lets you splice in+ recursive definitions.++ Standard modifiers, such as fixity declarations, can be applied to `x` as+ expected.++* Quoted levels++ Universe levels are now quoted properly instead of being quoted to+ `AGDASORTUNSUPPORTED`. `Setω` still gets an unsupported sort,+ however.++* Module applicants can now be operator applications.++ Example:++ ```agda+ postulate+ [_] : A -> B++ module M (b : B) where++ module N (a : A) = M [ a ]+ ```++ [See Issue [#1245](https://github.com/agda/agda/issues/1245)]++* Minor change in module application+ semantics. [Issue [#892](https://github.com/agda/agda/issues/892)]++ Previously re-exported functions were not redefined when+ instantiating a module. For instance++ ```agda+ module A where f = ...+ module B (X : Set) where+ open A public+ module C = B Nat+ ```++ In this example `C.f` would be an alias for `A.f`, so if both `A`+ and `C` were opened `f` would not be ambiguous. However, this+ behaviour is not correct when `A` and `B` share some module+ parameters+ (Issue [#892](https://github.com/agda/agda/issues/892)). To fix this+ `C` now defines its own copy of `f` (which evaluates to `A.f`),+ which means that opening `A` and `C` results in an ambiguous `f`.++Type checking+-------------++* Recursive records need to be declared as either `inductive` or+ `coinductive`. `inductive` is no longer default for recursive+ records. Examples:++ ```agda+ record _×_ (A B : Set) : Set where+ constructor _,_+ field+ fst : A+ snd : B++ record Tree (A : Set) : Set where+ inductive+ constructor tree+ field+ elem : A+ subtrees : List (Tree A)++ record Stream (A : Set) : Set where+ coinductive+ constructor _::_+ field+ head : A+ tail : Stream A+ ```++ If you are using old-style (musical) coinduction, a record may have+ to be declared as inductive, paradoxically.++ ```agda+ record Stream (A : Set) : Set where+ inductive -- YES, THIS IS INTENDED !+ constructor _∷_+ field+ head : A+ tail : ∞ (Stream A)+ ```++ This is because the "coinduction" happens in the use of `∞` and not+ in the use of `record`.++Tools+-----++### Emacs mode++* A new menu option `Display` can be used to display the version of+ the running Agda process.++### LaTeX-backend++* New experimental option `references` has been added. When specified,+ i.e.:++ ```latex+ \usepackage[references]{agda}+ ```++ a new command called `\AgdaRef` is provided, which lets you+ reference previously typeset commands, e.g.:++ Let us postulate `\AgdaRef{apa}`.++ ```agda+ \begin{code}+ postulate+ apa : Set+ \end{code}+ ```++ Above `apa` will be typeset (highlighted) the same in the text as in+ the code, provided that the LaTeX output is post-processed using+ `src/data/postprocess-latex.pl`, e.g.:++ ```+ cp $(dirname $(dirname $(agda-mode locate)))/postprocess-latex.pl .+ agda -i. --latex Example.lagda+ cd latex/+ perl ../postprocess-latex.pl Example.tex > Example.processed+ mv Example.processed Example.tex+ xelatex Example.tex+ ```++ Mix-fix and Unicode should work as expected (Unicode requires+ XeLaTeX/LuaLaTeX), but there are limitations:++ - Overloading identifiers should be avoided, if multiples exist+ `\AgdaRef` will typeset according to the first it finds.++ - Only the current module is used, should you need to reference+ identifiers in other modules then you need to specify which other+ module manually, i.e. `\AgdaRef[module]{identifier}`.
@@ -0,0 +1,79 @@+Release notes for Agda version 2.5.1.1+======================================++Installation and infrastructure+-------------------------------++* Added support for GHC 8.0.1.++* Documentation is now built with Python >=3.3, as done by+ [readthedocs.org](https://readthedocs.org/).++Bug fixes+---------++* Fixed a serious performance problem with instance search++ Issues [#1952](https://github.com/agda/agda/issues/1952) and+ [#1998](https://github.com/agda/agda/issues/1998). Also related:+ [#1955](https://github.com/agda/agda/issues/1955) and+ [#2025](https://github.com/agda/agda/issues/2025)++* Interactively splitting variable with `C-c C-c` no longer introduces+ new trailing patterns. This fixes+ Issue [#1950](https://github.com/agda/agda/issues/1950).++ ```agda+ data Ty : Set where+ _⇒_ : Ty → Ty → Ty++ ⟦_⟧ : Ty → Set+ ⟦ A ⇒ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧++ data Term : Ty → Set where+ K : (A B : Ty) → Term (A ⇒ (B ⇒ A))++ test : (A : Ty) (a : Term A) → ⟦ A ⟧+ test A a = {!a!}+ ```++ Before change, case splitting on `a` would give++ ```agda+ test .(A ⇒ (B ⇒ A)) (K A B) x x₁ = ?+ ```++ Now, it yields++ ```agda+ test .(A ⇒ (B ⇒ A)) (K A B) = ?+ ```++* In literate TeX files, `\begin{code}` and `\end{code}` can be+ preceded (resp. followed) by TeX code on the same line. This fixes+ Issue [#2077](https://github.com/agda/agda/issues/2077).++* Other issues fixed (see+ [bug tracker](https://github.com/agda/agda/issues)):++ [#1951](https://github.com/agda/agda/issues/1951) (mixfix binders+ not working in 'syntax')++ [#1967](https://github.com/agda/agda/issues/1967) (too eager+ insteance search error)++ [#1974](https://github.com/agda/agda/issues/1974) (lost constraint+ dependencies)++ [#1982](https://github.com/agda/agda/issues/1982) (internal error in+ unifier)++ [#2034](https://github.com/agda/agda/issues/2034) (function type+ instance goals)++Compiler backends+-----------------++* UHC compiler backend++ Added support for UHC 1.1.9.4.
@@ -0,0 +1,5 @@+Release notes for Agda version 2.5.1.2+======================================++* Fixed broken type signatures that were incorrectly accepted due to+ [GHC #12784](https://ghc.haskell.org/trac/ghc/ticket/12784).
@@ -0,0 +1,1600 @@+Release notes for Agda version 2.5.1+====================================++Documentation+-------------++* There is now an official Agda User Manual:+ https://agda.readthedocs.io/++Installation and infrastructure+-------------------------------++* Builtins and primitives are now defined in a new set of modules available to+ all users, independent of any particular library. The modules are++ ```agda+ Agda.Builtin.Bool+ Agda.Builtin.Char+ Agda.Builtin.Coinduction+ Agda.Builtin.Equality+ Agda.Builtin.Float+ Agda.Builtin.FromNat+ Agda.Builtin.FromNeg+ Agda.Builtin.FromString+ Agda.Builtin.IO+ Agda.Builtin.Int+ Agda.Builtin.List+ Agda.Builtin.Nat+ Agda.Builtin.Reflection+ Agda.Builtin.Size+ Agda.Builtin.Strict+ Agda.Builtin.String+ Agda.Builtin.TrustMe+ Agda.Builtin.Unit+ ```++ The standard library reexports the primitives from the new modules.++ The `Agda.Builtin` modules are installed in the same way as+ `Agda.Primitive`, but unlike `Agda.Primitive` they are not loaded+ automatically.++Pragmas and options+-------------------++* Library management++ There is a new 'library' concept for managing include paths. A library+ consists of+ - a name,+ - a set of libraries it depends on, and+ - a set of include paths.++ A library is defined in a `.agda-lib` file using the following+ format:++ ```+ name: LIBRARY-NAME -- Comment+ depend: LIB1 LIB2+ LIB3+ LIB4+ include: PATH1+ PATH2+ PATH3+ ```++ Dependencies are library names, not paths to `.agda-lib` files, and+ include paths are relative to the location of the library-file.++ To be useable, a library file has to be listed (with its full path)+ in `AGDA_DIR/libraries` (or `AGDA_DIR/libraries-VERSION`, for a+ given Agda version). `AGDA_DIR` defaults to `~/.agda` on Unix-like+ systems and `C:/Users/USERNAME/AppData/Roaming/agda` or similar on+ Windows, and can be overridden by setting the `AGDA_DIR` environment+ variable.++ Environment variables in the paths (of the form `$VAR` or `${VAR}`)+ are expanded. The location of the libraries file used can be+ overridden using the `--library-file=FILE` flag, although this is+ not expected to be very useful.++ You can find out the precise location of the 'libraries' file by+ calling `agda -l fjdsk Dummy.agda` and looking at the error message+ (assuming you don't have a library called fjdsk installed).++ There are three ways a library gets used:++ - You supply the `--library=LIB` (or `-l LIB`) option to+ Agda. This is equivalent to adding a `-iPATH` for each of the+ include paths of `LIB` and its (transitive) dependencies.++ - No explicit `--library` flag is given, and the current project+ root (of the Agda file that is being loaded) or one of its+ parent directories contains a `.agda-lib` file defining a+ library `LIB`. This library is used as if a `--librarary=LIB`+ option had been given, except that it is not necessary for the+ library to be listed in the `AGDA_DIR/libraries` file.++ - No explicit `--library` flag, and no `.agda-lib` file in the+ project root. In this case the file `AGDA_DIR/defaults` is read+ and all libraries listed are added to the path. The defaults+ file should contain a list of library names, each on a separate+ line. In this case the current directory is also added to the+ path.++ To disable default libraries, you can give the flag+ `--no-default-libraries`.++ Library names can end with a version number (for instance,+ `mylib-1.2.3`). When resolving a library name (given in a `--library`+ flag, or listed as a default library or library dependency) the+ following rules are followed:++ - If you don't give a version number, any version will do.++ - If you give a version number an exact match is required.++ - When there are multiple matches an exact match is preferred, and+ otherwise the latest matching version is chosen.++ For example, suppose you have the following libraries installed:+ `mylib`, `mylib-1.0`, `otherlib-2.1`, and `otherlib-2.3`. In this+ case, aside from the exact matches you can also say+ `--library=otherlib` to get `otherlib-2.3`.++* New Pragma `COMPILED_DECLARE_DATA` for binding recursively defined+ Haskell data types to recursively defined Agda data types.++ If you have a Haskell type like++ ```haskell+ {-# LANGUAGE GADTs #-}++ module Issue223 where++ data A where+ BA :: B -> A++ data B where+ AB :: A -> B+ BB :: B+ ```++ You can now bind it to corresponding mutual Agda inductive data+ types as follows:++ ```agda+ {-# IMPORT Issue223 #-}++ data A : Set+ {-# COMPILED_DECLARE_DATA A Issue223.A #-}+ data B : Set+ {-# COMPILED_DECLARE_DATA B Issue223.B #-}++ data A where+ BA : B → A++ {-# COMPILED_DATA A Issue223.A Issue223.BA #-}+ data B where+ AB : A → B+ BB : B++ {-# COMPILED_DATA B Issue223.B Issue223.AB Issue223.BB #-}+ ```++ This fixes Issue [#223](https://github.com/agda/agda/issues/223).++* New pragma `HASKELL` for adding inline Haskell code (GHC backend only)++ Arbitrary Haskell code can be added to a module using the `HASKELL`+ pragma. For instance,++ ```agda+ {-# HASKELL+ echo :: IO ()+ echo = getLine >>= putStrLn+ #-}++ postulate echo : IO ⊤+ {-# COMPILED echo echo #-}+ ```++* New option `--exact-split`.++ The `--exact-split` flag causes Agda to raise an error whenever a+ clause in a definition by pattern matching cannot be made to hold+ definitionally (i.e. as a reduction rule). Specific clauses can be+ excluded from this check by means of the `{-# CATCHALL #-}` pragma.++ For instance, the following definition will be rejected as the second clause+ cannot be made to hold definitionally:++ ```agda+ min : Nat → Nat → Nat+ min zero y = zero+ min x zero = zero+ min (suc x) (suc y) = suc (min x y+ ```++ Catchall clauses have to be marked as such, for instance:++ ```agda+ eq : Nat → Nat → Bool+ eq zero zero = true+ eq (suc m) (suc n) = eq m n+ {-# CATCHALL #-}+ eq _ _ = false+ ```++* New option: `--no-exact-split`.++ This option can be used to override a global `--exact-split` in a+ file, by adding a pragma `{-# OPTIONS --no-exact-split #-}`.++* New options: `--sharing` and `--no-sharing`.++ These options are used to enable/disable sharing and call-by-need+ evaluation. The default is `--no-sharing`.++ Note that they cannot appear in an `OPTIONS` pragma, but have to be+ given as command line arguments or added to the Agda Program Args+ from Emacs with `M-x customize-group agda2`.++* New pragma `DISPLAY`.++ ```agda+ {-# DISPLAY f e1 .. en = e #-}+ ```++ This causes `f e1 .. en` to be printed in the same way as `e`, where+ `ei` can bind variables used in `e`. The expressions `ei` and `e`+ are scope checked, but not type checked.++ For example this can be used to print overloaded (instance) functions with+ the overloaded name:++ ```agda+ instance+ NumNat : Num Nat+ NumNat = record { ..; _+_ = natPlus }++ {-# DISPLAY natPlus a b = a + b #-}+ ```++ Limitations++ - Left-hand sides are restricted to variables, constructors, defined+ functions or types, and literals. In particular, lambdas are not+ allowed in left-hand sides.++ - Since `DISPLAY` pragmas are not type checked implicit argument+ insertion may not work properly if the type of `f` computes to an+ implicit function space after pattern matching.++* Removed pragma `{-# ETA R #-}`++ The pragma `{-# ETA R #-}` is replaced by the `eta-equality` directive+ inside record declarations.++* New option `--no-eta-equality`.++ The `--no-eta-equality` flag disables eta rules for declared record+ types. It has the same effect as `no-eta-equality` inside each+ declaration of a record type `R`.++ If used with the `OPTIONS` pragma it will not affect records defined+ in other modules.++* The semantics of `{-# REWRITE r #-}` pragmas in parametrized modules+ has changed (see+ Issue [#1652](https://github.com/agda/agda/issues/1652)).++ Rewrite rules are no longer lifted to the top context. Instead, they+ now only apply to terms in (extensions of) the module context. If+ you want the old behaviour, you should put the `{-# REWRITE r #-}`+ pragma outside of the module (i.e. unindent it).++* New pragma `{-# INLINE f #-}` causes `f` to be inlined during+ compilation.++* The `STATIC` pragma is now taken into account during compilation.++ Calls to a function marked `STATIC` are normalised before+ compilation. The typical use case for this is to mark the+ interpreter of an embedded language as `STATIC`.++* Option `--type-in-type` no longer implies+ `--no-universe-polymorphism`, thus, it can be used with explicit+ universe+ levels. [Issue [#1764](https://github.com/agda/agda/issues/1764)] It+ simply turns off error reporting for any level mismatch now.+ Examples:++ ```agda+ {-# OPTIONS --type-in-type #-}++ Type : Set+ Type = Set++ data D {α} (A : Set α) : Set where+ d : A → D A++ data E α β : Set β where+ e : Set α → E α β+ ```++* New `NO_POSITIVITY_CHECK` pragma to switch off the positivity checker+ for data/record definitions and mutual blocks.++ The pragma must precede a data/record definition or a mutual block.++ The pragma cannot be used in `--safe` mode.++ Examples (see `Issue1614*.agda` and `Issue1760*.agda` in+ `test/Succeed/`):++ 1. Skipping a single data definition.++ ```agda+ {-# NO_POSITIVITY_CHECK #-}+ data D : Set where+ lam : (D → D) → D+ ```++ 2. Skipping a single record definition.++ ```agda+ {-# NO_POSITIVITY_CHECK #-}+ record U : Set where+ field ap : U → U+ ```++ 3. Skipping an old-style mutual block: Somewhere within a `mutual`+ block before a data/record definition.++ ```agda+ mutual+ data D : Set where+ lam : (D → D) → D++ {-# NO_POSITIVITY_CHECK #-}+ record U : Set where+ field ap : U → U+ ```++ 4. Skipping an old-style mutual block: Before the `mutual` keyword.++ ```agda+ {-# NO_POSITIVITY_CHECK #-}+ mutual+ data D : Set where+ lam : (D → D) → D++ record U : Set where+ field ap : U → U+ ```++ 5. Skipping a new-style mutual block: Anywhere before the+ declaration or the definition of data/record in the block.++ ```agda+ record U : Set+ data D : Set++ record U where+ field ap : U → U++ {-# NO_POSITIVITY_CHECK #-}+ data D where+ lam : (D → D) → D+ ```++* Removed `--no-coverage-check`+ option. [Issue [#1918](https://github.com/agda/agda/issues/1918)]++Language+--------++### Operator syntax++* The default fixity for syntax declarations has changed from -666 to 20.++* Sections.++ Operators can be sectioned by replacing arguments with underscores.+ There must not be any whitespace between these underscores and the+ adjacent nameparts. Examples:++ ```agda+ pred : ℕ → ℕ+ pred = _∸ 1++ T : Bool → Set+ T = if_then ⊤ else ⊥++ if : {A : Set} (b : Bool) → A → A → A+ if b = if b then_else_+ ```++ Sections are translated into lambda expressions. Examples:++ ```agda+ _∸ 1 ↦ λ section → section ∸ 1++ if_then ⊤ else ⊥ ↦ λ section → if section then ⊤ else ⊥++ if b then_else_ ↦ λ section section₁ →+ if b then section else section₁+ ```++ Operator sections have the same fixity as the underlying operator+ (except in cases like `if b then_else_`, in which the section is+ "closed", but the operator is not).++ Operator sections are not supported in patterns (with the exception+ of dot patterns), and notations coming from syntax declarations+ cannot be sectioned.++* A long-standing operator fixity bug has been fixed. As a consequence+ some programs that used to parse no longer do.++ Previously each precedence level was (incorrectly) split up into+ five separate ones, ordered as follows, with the earlier ones+ binding less tightly than the later ones:++ - Non-associative operators.++ - Left associative operators.++ - Right associative operators.++ - Prefix operators.++ - Postfix operators.++ Now this problem has been addressed. It is no longer possible to mix+ operators of a given precedence level but different associativity.+ However, prefix and right associative operators are seen as having+ the same associativity, and similarly for postfix and left+ associative operators.++ Examples+ --------++ The following code is no longer accepted:++ ```agda+ infixl 6 _+_+ infix 6 _∸_++ rejected : ℕ+ rejected = 1 + 0 ∸ 1+ ```++ However, the following previously rejected code is accepted:++ ```agda+ infixr 4 _,_+ infix 4 ,_++ ,_ : {A : Set} {B : A → Set} {x : A} → B x → Σ A B+ , y = _ , y++ accepted : Σ ℕ λ i → Σ ℕ λ j → Σ (i ≡ j) λ _ → Σ ℕ λ k → j ≡ k+ accepted = 5 , , refl , , refl+ ```++* The classification of notations with binders into the categories+ infix, prefix, postfix or closed has+ changed. [Issue [#1450](https://github.com/agda/agda/issues/1450)]++ The difference is that, when classifying the notation, only+ *regular* holes are taken into account, not *binding* ones.++ Example: The notation++ ```agda+ syntax m >>= (λ x → f) = x <- m , f+ ```++ was previously treated as infix, but is now treated as prefix.++* Notation can now include wildcard binders.++ Example: `syntax Σ A (λ _ → B) = A × B`++* If an overloaded operator is in scope with several distinct+ precedence levels, then several instances of this operator will be+ included in the operator grammar, possibly leading to ambiguity.+ Previously the operator was given the default fixity+ [Issue [#1436](https://github.com/agda/agda/issues/1436)].++ There is an exception to this rule: If there are multiple precedences,+ but at most one is explicitly declared, then only one instance will be+ included in the grammar. If there are no explicitly declared+ precedences, then this instance will get the default precedence, and+ otherwise it will get the declared precedence.++ If multiple occurrences of an operator are "merged" in the grammar,+ and they have distinct associativities, then they are treated as+ being non-associative.++ The three paragraphs above also apply to identical notations (coming+ from syntax declarations) for a given overloaded name.++ Examples:++ ```agda+ module A where++ infixr 5 _∷_+ infixr 5 _∙_+ infixl 3 _+_+ infix 1 bind++ syntax bind c (λ x → d) = x ← c , d++ module B where++ infix 5 _∷_+ infixr 4 _∙_+ -- No fixity declaration for _+_.+ infixl 2 bind++ syntax bind c d = c ∙ d++ module C where++ infixr 2 bind++ syntax bind c d = c ∙ d++ open A+ open B+ open C++ -- _∷_ is infix 5.+ -- _∙_ has two fixities: infixr 4 and infixr 5.+ -- _+_ is infixl 3.+ -- A.bind's notation is infix 1.+ -- B.bind and C.bind's notations are infix 2.++ -- There is one instance of "_ ∷ _" in the grammar, and one+ -- instance of "_ + _".++ -- There are three instances of "_ ∙ _" in the grammar, one+ -- corresponding to A._∙_, one corresponding to B._∙_, and one+ -- corresponding to both B.bind and C.bind.+ ```++### Reflection++* The reflection framework has received a massive overhaul.++ A new type of reflected type checking computations supplants most of+ the old reflection primitives. The `quoteGoal`, `quoteContext` and+ tactic primitives are deprecated and will be removed in the future,+ and the `unquoteDecl` and `unquote` primitives have changed+ behaviour. Furthermore the following primitive functions have been+ replaced by builtin type checking computations:++ ```agda+ - primQNameType --> AGDATCMGETTYPE+ - primQNameDefinition --> AGDATCMGETDEFINITION+ - primDataConstructors --> subsumed by AGDATCMGETDEFINITION+ - primDataNumberOfParameters --> subsumed by AGDATCMGETDEFINITION+ ```++ See below for details.++* Types are no longer packaged with a sort.++ The `AGDATYPE` and `AGDATYPEEL` built-ins have been+ removed. Reflected types are now simply terms.++* Reflected definitions have more information.++ The type for reflected definitions has changed to++ ```agda+ data Definition : Set where+ fun-def : List Clause → Definition+ data-type : Nat → List Name → Definition -- parameters and constructors+ record-type : Name → Definition -- name of the data/record type+ data-con : Name → Definition -- name of the constructor+ axiom : Definition+ prim-fun : Definition+ ```++ Correspondingly the built-ins for function, data and record+ definitions (`AGDAFUNDEF`, `AGDAFUNDEFCON`, `AGDADATADEF`,+ `AGDARECORDDEF`) have been removed.++* Reflected type checking computations.++ There is a primitive `TC` monad representing type checking+ computations. The `unquote`, `unquoteDecl`, and the new `unquoteDef`+ all expect computations in this monad (see below). The interface to+ the monad is the following++ ```agda+ -- Error messages can contain embedded names and terms.+ data ErrorPart : Set where+ strErr : String → ErrorPart+ termErr : Term → ErrorPart+ nameErr : Name → ErrorPart++ {-# BUILTIN AGDAERRORPART ErrorPart #-}+ {-# BUILTIN AGDAERRORPARTSTRING strErr #-}+ {-# BUILTIN AGDAERRORPARTTERM termErr #-}+ {-# BUILTIN AGDAERRORPARTNAME nameErr #-}++ postulate+ TC : ∀ {a} → Set a → Set a+ returnTC : ∀ {a} {A : Set a} → A → TC A+ bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B++ -- Unify two terms, potentially solving metavariables in the process.+ unify : Term → Term → TC ⊤++ -- Throw a type error. Can be caught by catchTC.+ typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A++ -- Block a type checking computation on a metavariable. This will abort+ -- the computation and restart it (from the beginning) when the+ -- metavariable is solved.+ blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A++ -- Backtrack and try the second argument if the first argument throws a+ -- type error.+ catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A++ -- Infer the type of a given term+ inferType : Term → TC Type++ -- Check a term against a given type. This may resolve implicit arguments+ -- in the term, so a new refined term is returned. Can be used to create+ -- new metavariables: newMeta t = checkType unknown t+ checkType : Term → Type → TC Term++ -- Compute the normal form of a term.+ normalise : Term → TC Term++ -- Get the current context.+ getContext : TC (List (Arg Type))++ -- Extend the current context with a variable of the given type.+ extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A++ -- Set the current context.+ inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A++ -- Quote a value, returning the corresponding Term.+ quoteTC : ∀ {a} {A : Set a} → A → TC Term++ -- Unquote a Term, returning the corresponding value.+ unquoteTC : ∀ {a} {A : Set a} → Term → TC A++ -- Create a fresh name.+ freshName : String → TC QName++ -- Declare a new function of the given type. The function must be defined+ -- later using 'defineFun'. Takes an Arg Name to allow declaring instances+ -- and irrelevant functions. The Visibility of the Arg must not be hidden.+ declareDef : Arg QName → Type → TC ⊤++ -- Define a declared function. The function may have been declared using+ -- 'declareDef' or with an explicit type signature in the program.+ defineFun : QName → List Clause → TC ⊤++ -- Get the type of a defined name. Replaces 'primQNameType'.+ getType : QName → TC Type++ -- Get the definition of a defined name. Replaces 'primQNameDefinition'.+ getDefinition : QName → TC Definition++ {-# BUILTIN AGDATCM TC #-}+ {-# BUILTIN AGDATCMRETURN returnTC #-}+ {-# BUILTIN AGDATCMBIND bindTC #-}+ {-# BUILTIN AGDATCMUNIFY unify #-}+ {-# BUILTIN AGDATCMNEWMETA newMeta #-}+ {-# BUILTIN AGDATCMTYPEERROR typeError #-}+ {-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-}+ {-# BUILTIN AGDATCMCATCHERROR catchTC #-}+ {-# BUILTIN AGDATCMINFERTYPE inferType #-}+ {-# BUILTIN AGDATCMCHECKTYPE checkType #-}+ {-# BUILTIN AGDATCMNORMALISE normalise #-}+ {-# BUILTIN AGDATCMGETCONTEXT getContext #-}+ {-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-}+ {-# BUILTIN AGDATCMINCONTEXT inContext #-}+ {-# BUILTIN AGDATCMQUOTETERM quoteTC #-}+ {-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-}+ {-# BUILTIN AGDATCMFRESHNAME freshName #-}+ {-# BUILTIN AGDATCMDECLAREDEF declareDef #-}+ {-# BUILTIN AGDATCMDEFINEFUN defineFun #-}+ {-# BUILTIN AGDATCMGETTYPE getType #-}+ {-# BUILTIN AGDATCMGETDEFINITION getDefinition #-}+ ```++* Builtin type for metavariables++ There is a new builtin type for metavariables used by the new reflection+ framework. It is declared as follows and comes with primitive equality,+ ordering and show.++ ```agda+ postulate Meta : Set+ {-# BUILTIN AGDAMETA Meta #-}+ primitive primMetaEquality : Meta → Meta → Bool+ primitive primMetaLess : Meta → Meta → Bool+ primitive primShowMeta : Meta → String+ ```++ There are corresponding new constructors in the `Term` and `Literal`+ data types:++ ```agda+ data Term : Set where+ ...+ meta : Meta → List (Arg Term) → Term++ {-# BUILTIN AGDATERMMETA meta #-}++ data Literal : Set where+ ...+ meta : Meta → Literal++ {-# BUILTIN AGDALITMETA meta #-}+ ```++* Builtin unit type++ The type checker needs to know about the unit type, which you can+ allow by++ ```agda+ record ⊤ : Set where+ {-# BUILTIN UNIT ⊤ #-}+ ```++* Changed behaviour of `unquote`++ The `unquote` primitive now expects a type checking computation+ instead of a pure term. In particular `unquote e` requires++ ```agda+ e : Term → TC ⊤+ ```++ where the argument is the representation of the hole in which the+ result should go. The old `unquote` behaviour (where `unquote`+ expected a `Term` argument) can be recovered by++ ```agda+ OLD: unquote v+ NEW: unquote λ hole → unify hole v+ ```++* Changed behaviour of `unquoteDecl`++ The `unquoteDecl` primitive now expects a type checking computation+ instead of a pure function definition. It is possible to define+ multiple (mutually recursive) functions at the same time. More+ specifically++ ```agda+ unquoteDecl x₁ .. xₙ = m+ ```++ requires `m : TC ⊤` and that `x₁ .. xₙ` are defined (using+ `declareDef` and `defineFun`) after executing `m`. As before `x₁+ .. xₙ : QName` in `m`, but have their declared types outside the+ `unquoteDecl`.++* New primitive `unquoteDef`++ There is a new declaration++ ```agda+ unquoteDef x₁ .. xₙ = m+ ```++ This works exactly as `unquoteDecl` (see above) with the exception+ that `x₁ .. xₙ` are required to already be declared.++ The main advantage of `unquoteDef` over `unquoteDecl` is that+ `unquoteDef` is allowed in mutual blocks, allowing mutually+ recursion between generated definitions and hand-written+ definitions.++* The reflection interface now exposes the name hint (as a string)+ for variables. As before, the actual binding structure is with+ de Bruijn indices. The String value is just a hint used as a prefix+ to help display the variable. The type `Abs` is a new builtin type used+ for the constructors `Term.lam`, `Term.pi`, `Pattern.var`+ (bultins `AGDATERMLAM`, `AGDATERMPI` and `AGDAPATVAR`).++ ```agda+ data Abs (A : Set) : Set where+ abs : (s : String) (x : A) → Abs A+ {-# BUILTIN ABS Abs #-}+ {-# BUILTIN ABSABS abs #-}+ ```++ Updated constructor types:++ ```agda+ Term.lam : Hiding → Abs Term → Term+ Term.pi : Arg Type → Abs Type → Term+ Pattern.var : String → Pattern+ ```++* Reflection-based macros++ Macros are functions of type `t1 → t2 → .. → Term → TC ⊤` that are+ defined in a `macro` block. Macro application is guided by the type+ of the macro, where `Term` arguments desugar into the `quoteTerm`+ syntax and `Name` arguments into the `quote` syntax. Arguments of+ any other type are preserved as-is. The last `Term` argument is the+ hole term given to `unquote` computation (see above).++ For example, the macro application `f u v w` where the macro `f` has+ the type `Term → Name → Bool → Term → TC ⊤` desugars into `unquote+ (f (quoteTerm u) (quote v) w)`++ Limitations:++ - Macros cannot be recursive. This can be worked around by defining the+ recursive function outside the macro block and have the macro call the+ recursive function.++ Silly example:++ ```agda+ macro+ plus-to-times : Term → Term → TC ⊤+ plus-to-times (def (quote _+_) (a ∷ b ∷ [])) hole = unify hole (def (quote _*_) (a ∷ b ∷ []))+ plus-to-times v hole = unify hole v++ thm : (a b : Nat) → plus-to-times (a + b) ≡ a * b+ thm a b = refl+ ```++ Macros are most useful when writing tactics, since they let you hide the+ reflection machinery. For instance, suppose you have a solver++ ```agda+ magic : Type → Term+ ```++ that takes a reflected goal and outputs a proof (when successful). You can+ then define the following macro++ ```agda+ macro+ by-magic : Term → TC ⊤+ by-magic hole =+ bindTC (inferType hole) λ goal →+ unify hole (magic goal)+ ```++ This lets you apply the magic tactic without any syntactic noise at all:++ ```agda+ thm : ¬ P ≡ NP+ thm = by-magic+ ```++### Literals and built-ins++* Overloaded number literals.++ You can now overload natural number literals using the new builtin+ `FROMNAT`:++ ```agda+ {-# BUILTIN FROMNAT fromNat #-}+ ```++ The target of the builtin should be a defined name. Typically you would do+ something like++ ```agda+ record Number (A : Set) : Set where+ field fromNat : Nat → A++ open Number {{...}} public++ {-# BUILTIN FROMNAT fromNat #-}+ ```++ This will cause number literals `n` to be desugared to `fromNat n`+ before type checking.++* Negative number literals.++ Number literals can now be negative. For floating point literals it+ works as expected. For integer literals there is a new builtin+ `FROMNEG` that enables negative integer literals:++ ```agda+ {-# BUILTIN FROMNEG fromNeg #-}+ ```++ This causes negative literals `-n` to be desugared to `fromNeg n`.++* Overloaded string literals.++ String literals can be overladed using the `FROMSTRING` builtin:++ ```agda+ {-# BUILTIN FROMSTRING fromString #-}+ ```++ The will cause string literals `s` to be desugared to `fromString s`+ before type checking.++* Change to builtin integers.++ The `INTEGER` builtin now needs to be bound to a datatype with two+ constructors that should be bound to the new builtins `INTEGERPOS`+ and `INTEGERNEGSUC` as follows:++ ```agda+ data Int : Set where+ pos : Nat -> Int+ negsuc : Nat -> Int+ {-# BUILTIN INTEGER Int #-}+ {-# BUILTIN INTEGERPOS pos #-}+ {-# BUILTIN INTEGERNEGSUC negsuc #-}+ ```++ where `negsuc n` represents the integer `-n - 1`. For instance, `-5`+ is represented as `negsuc 4`. All primitive functions on integers+ except `primShowInteger` have been removed, since these can be+ defined without too much trouble on the above representation using+ the corresponding functions on natural numbers.++ The primitives that have been removed are++ ```agda+ primIntegerPlus+ primIntegerMinus+ primIntegerTimes+ primIntegerDiv+ primIntegerMod+ primIntegerEquality+ primIntegerLess+ primIntegerAbs+ primNatToInteger+ ```++* New primitives for strict evaluation++ ```agda+ primitive+ primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x+ primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x+ ```++ `primForce x f` evaluates to `f x` if x is in weak head normal form,+ and `primForceLemma x f` evaluates to `refl` in the same+ situation. The following values are considered to be in weak head+ normal form:++ - constructor applications+ - literals+ - lambda abstractions+ - type constructor (data/record types) applications+ - function types+ - Set a++### Modules++* Modules in import directives++ When you use `using`/`hiding`/`renaming` on a name it now+ automatically applies to any module of the same name, unless you+ explicitly mention the module. For instance,++ ```agda+ open M using (D)+ ```++ is equivalent to++ ```agda+ open M using (D; module D)+ ```++ if `M` defines a module `D`. This is most useful for record and data+ types where you always get a module of the same name as the type.++ With this feature there is no longer useful to be able to qualify a+ constructor (or field) by the name of the data type even when it+ differs from the name of the corresponding module. The follow+ (weird) code used to work, but doesn't work anymore:++ ```agda+ module M where+ data D where+ c : D+ open M using (D) renaming (module D to MD)+ foo : D+ foo = D.c+ ```++ If you want to import only the type name and not the module you have to hide+ it explicitly:++ ```agda+ open M using (D) hiding (module D)+ ```++ See discussion on+ Issue [#836](https://github.com/agda/agda/issues/836).++* Private definitions of a module are no longer in scope at the Emacs+ mode top-level.++ The reason for this change is that `.agdai-files` are stripped of+ unused private definitions (which can yield significant performance+ improvements for module-heavy code).++ To test private definitions you can create a hole at the bottom of+ the module, in which private definitions will be visible.++### Records++* New record directives `eta-equality`/`no-eta-equality`++ The keywords `eta-equality`/`no-eta-equality` enable/disable eta+ rules for the (inductive) record type being declared.++ ```agda+ record Σ (A : Set) (B : A -> Set) : Set where+ no-eta-equality+ constructor _,_+ field+ fst : A+ snd : B fst+ open Σ++ -- fail : ∀ {A : Set}{B : A -> Set} → (x : Σ A B) → x ≡ (fst x , snd x)+ -- fail x = refl+ --+ -- x != fst x , snd x of type Σ .A .B+ -- when checking that the expression refl has type x ≡ (fst x , snd x)+ ```++* Building records from modules.++ The `record { <fields> }` syntax is now extended to accept module+ names as well. Fields are thus defined using the corresponding+ definitions from the given module.++ For instance assuming this record type `R` and module `M`:++ ```agda+ record R : Set where+ field+ x : X+ y : Y+ z : Z++ module M where+ x = {! ... !}+ y = {! ... !}++ r : R+ r = record { M; z = {! ... !} }+ ```++ Previously one had to write `record { x = M.x; y = M.y; z = {! ... !} }`.++ More precisely this construction now supports any combination of explicit+ field definitions and applied modules.++ If a field is both given explicitly and available in one of the modules,+ then the explicit one takes precedence.++ If a field is available in more than one module then this is ambiguous+ and therefore rejected. As a consequence the order of assignments does+ not matter.++ The modules can be both applied to arguments and have import directives+ such as `hiding`, `using`, and `renaming`. In particular this construct+ subsumes the record update construction.++ Here is an example of record update:++ ```agda+ -- Record update. Same as: record r { y = {! ... !} }+ r2 : R+ r2 = record { R r; y = {! ... !} }+ ```++ A contrived example showing the use of `hiding`/`renaming`:++ ```agda+ module M2 (a : A) where+ w = {! ... !}+ z = {! ... !}++ r3 : A → R+ r3 a = record { M hiding (y); M2 a renaming (w to y) }+ ```++* Record patterns are now accepted.++ Examples:++ ```agda+ swap : {A B : Set} (p : A × B) → B × A+ swap record{ proj₁ = a; proj₂ = b } = record{ proj₁ = b; proj₂ = a }++ thd3 : ...+ thd3 record{ proj₂ = record { proj₂ = c }} = c+ ```++* Record modules now properly hide all their parameters+ [Issue [#1759](https://github.com/agda/agda/issues/1759)]++ Previously parameters to parent modules were not hidden in the record+ module, resulting in different behaviour between++ ```agda+ module M (A : Set) where+ record R (B : Set) : Set where+ ```++ and++ ```agda+ module M where+ record R (A B : Set) : Set where+ ```++ where in the former case, `A` would be an explicit argument to the module+ `M.R`, but implicit in the latter case. Now `A` is implicit in both cases.++### Instance search++* Performance has been improved, recursive instance search which was+ previously exponential in the depth is now only quadratic.++* Constructors of records and datatypes are not anymore automatically+ considered as instances, you have to do so explicitely, for+ instance:++ ```agda+ -- only [b] is an instance of D+ data D : Set where+ a : D+ instance+ b : D+ c : D++ -- the constructor is now an instance+ record tt : Set where+ instance constructor tt+ ```++* Lambda-bound variables are no longer automatically considered+ instances.++ Lambda-bound variables need to be bound as instance arguments to be+ considered for instance search. For example,++ ```agda+ _==_ : {A : Set} {{_ : Eq A}} → A → A → Bool++ fails : {A : Set} → Eq A → A → Bool+ fails eqA x = x == x++ works : {A : Set} {{_ : Eq A}} → A → Bool+ works x = x == x+ ```++* Let-bound variables are no longer automatically considered+ instances.++ To make a let-bound variable available as an instance it needs to be+ declared with the `instance` keyword, just like top-level+ instances. For example,++ ```agda+ mkEq : {A : Set} → (A → A → Bool) → Eq A++ fails : {A : Set} → (A → A → Bool) → A → Bool+ fails eq x = let eqA = mkEq eq in x == x++ works : {A : Set} → (A → A → Bool) → A → Bool+ works eq x = let instance eqA = mkEq eq in x == x+ ```++* Record fields can be declared instances.++ For example,++ ```agda+ record EqSet : Set₁ where+ field+ set : Set+ instance eq : Eq set+ ```++ This causes the projection function `eq : (E : EqSet) → Eq (set E)`+ to be considered for instance search.++* Instance search can now find arguments in variable types (but such+ candidates can only be lambda-bound variables, they can’t be+ declared as instances)++ ```agda+ module _ {A : Set} (P : A → Set) where++ postulate+ bla : {x : A} {{_ : P x}} → Set → Set++ -- Works, the instance argument is found in the context+ test : {x : A} {{_ : P x}} → Set → Set+ test B = bla B++ -- Still forbidden, because [P] could be instantiated later to anything+ instance+ postulate+ forbidden : {x : A} → P x+ ```++* Instance search now refuses to solve constraints with unconstrained+ metavariables, since this can lead to non-termination.++ See [Issue [#1532](https://github.com/agda/agda/issues/1523)] for an+ example.++* Top-level instances are now only considered if they are in+ scope. [Issue [#1913](https://github.com/agda/agda/issues/1913)]++ Note that lambda-bound instances need not be in scope.++### Other changes++* Unicode ellipsis character is allowed for the ellipsis token `...`+ in `with` expressions.++* `Prop` is no longer a reserved word.++Type checking+-------------++* Large indices.++ Force constructor arguments no longer count towards the size of a datatype.+ For instance, the definition of equality below is accepted.++ ```agda+ data _≡_ {a} {A : Set a} : A → A → Set where+ refl : ∀ x → x ≡ x+ ```++ This gets rid of the asymmetry that the version of equality which indexes+ only on the second argument could be small, but not the version above which+ indexes on both arguments.++* Detection of datatypes that satisfy K (i.e. sets)++ Agda will now try to detect datatypes that satisfy K when+ `--without-K` is enabled. A datatype satisfies K when it follows+ these three rules:++ - The types of all non-recursive constructor arguments should satisfy K.++ - All recursive constructor arguments should be first-order.++ - The types of all indices should satisfy K.++ For example, the types `Nat`, `List Nat`, and `x ≡ x` (where `x :+ Nat`) are all recognized by Agda as satisfying K.++* New unifier for case splitting++ The unifier used by Agda for case splitting has been completely+ rewritten. The new unifier takes a much more type-directed approach+ in order to avoid the problems in issues+ [#1406](https://github.com/agda/agda/issues/1406),+ [#1408](https://github.com/agda/agda/issues/1408),+ [#1427](https://github.com/agda/agda/issues/1427), and+ [#1435](https://github.com/agda/agda/issues/1435).++ The new unifier also has eta-equality for record types+ built-in. This should avoid unnecessary case splitting on record+ constructors and improve the performance of Agda on code that+ contains deeply nested record patterns (see issues+ [#473](https://github.com/agda/agda/issues/473),+ [#635](https://github.com/agda/agda/issues/635),+ [#1575](https://github.com/agda/agda/issues/1575),+ [#1603](https://github.com/agda/agda/issues/1603),+ [#1613](https://github.com/agda/agda/issues/1613), and+ [#1645](https://github.com/agda/agda/issues/1645)).++ In some cases, the locations of the dot patterns computed by the+ unifier did not correspond to the locations given by the user (see+ Issue [#1608](https://github.com/agda/agda/issues/1608)). This has+ now been fixed by adding an extra step after case splitting that+ checks whether the user-written patterns are compatible with the+ computed ones.++ In some rare cases, the new unifier is still too restrictive when+ `--without-K` is enabled because it cannot generalize over the+ datatype indices (yet). For example, the following code is rejected:++ ```agda+ data Bar : Set₁ where+ bar : Bar+ baz : (A : Set) → Bar++ data Foo : Bar → Set where+ foo : Foo bar++ test : foo ≡ foo → Set₁+ test refl = Set+ ```++* The aggressive behaviour of `with` introduced in 2.4.2.5 has been+ rolled back+ [Issue [#1692](https://github.com/agda/agda/issues/1692)]. With no+ longer abstracts in the types of variables appearing in the+ with-expressions. [Issue [#745](https://github.com/agda/agda/issues/745)]++ This means that the following example no longer works:++ ```agda+ fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a+ fails f b with a | f b+ fails f b | .b | refl = f b+ ```++ The `with` no longer abstracts the type of `f` over `a`, since `f`+ appears in the second with-expression `f b`. You can use a nested+ `with` to make this example work.++ This example does work again:++ ```agda+ test : ∀{A : Set}{a : A}{f : A → A} (p : f a ≡ a) → f (f a) ≡ a+ test p rewrite p = p+ ```++ After `rewrite p` the goal has changed to `f a ≡ a`, but the type+ of `p` has not been rewritten, thus, the final `p` solves the goal.++ The following, which worked in 2.4.2.5, no longer works:++ ```agda+ fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a+ fails f b rewrite f b = f b+ ```++ The rewrite with `f b : a ≡ b` is not applied to `f` as+ the latter is part of the rewrite expression `f b`. Thus,+ the type of `f` remains untouched, and the changed goal+ `b ≡ b` is not solved by `f b`.++* When using `rewrite` on a term `eq` of type `lhs ≡ rhs`, the `lhs`+ is no longer abstracted in `rhs`+ [Issue [#520](https://github.com/agda/agda/issues/520)]. This means+ that++ ```agda+ f pats rewrite eq = body+ ```++ is more than syntactic sugar for++ ```agda+ f pats with lhs | eq+ f pats | _ | refl = body+ ```++ In particular, the following application of `rewrite` is now+ possible++ ```agda+ id : Bool → Bool+ id true = true+ id false = false++ is-id : ∀ x → x ≡ id x+ is-id true = refl+ is-id false = refl++ postulate+ P : Bool → Set+ b : Bool+ p : P (id b)++ proof : P b+ proof rewrite is-id b = p+ ```++ Previously, this was desugared to++ ```agda+ proof with b | is-id b+ proof | _ | refl = p+ ```++ which did not type check as `refl` does not have type `b ≡ id b`.+ Now, Agda gets the task of checking `refl : _ ≡ id b` leading to+ instantiation of `_` to `id b`.++Compiler backends+-----------------++* Major Bug Fixes:++ - Function clauses with different arities are now always compiled+ correctly by the GHC/UHC+ backends. (Issue [#727](https://github.com/agda/agda/issues/727))++* Co-patterns++ - The GHC/UHC backends now support co-patterns. (Issues+ [#1567](https://github.com/agda/agda/issues/1567),+ [#1632](https://github.com/agda/agda/issues/1632))++* Optimizations++ - Builtin naturals are now represented as arbitrary-precision+ Integers. See the user manual, section+ "Agda Compilers -> Optimizations" for details.++* GHC Haskell backend (MAlonzo)++ - Pragmas++ Since builtin naturals are compiled to `Integer` you can no longer+ give a `{-# COMPILED_DATA #-}` pragma for `Nat`. The same goes for+ builtin booleans, integers, floats, characters and strings which+ are now hard-wired to appropriate Haskell types.++* UHC compiler backend++ A new backend targeting the Utrecht Haskell Compiler (UHC) is+ available. It targets the UHC Core language, and it's design is+ inspired by the Epic backend. See the user manual, section "Agda+ Compilers -> UHC Backend" for installation instructions.++ - FFI++ The UHC backend has a FFI to Haskell similar to MAlonzo's. The+ target Haskell code also needs to be compilable using UHC, which+ does not support the Haskell base library version 4.*.++ FFI pragmas for the UHC backend are not checked in any way. If the+ pragmas are wrong, bad things will happen.++ - Imports++ Additional Haskell modules can be brought into scope with the+ `IMPORT_UHC` pragma:++ ```agda+ {-# IMPORT_UHC Data.Char #-}+ ```++ The Haskell modules `UHC.Base` and `UHC.Agda.Builtins` are always in+ scope and don't need to be imported explicitly.++ - Datatypes++ Agda datatypes can be bound to Haskell datatypes as follows:++ Haskell:+ ```haskell+ data HsData a = HsCon1 | HsCon2 (HsData a)+ ```++ Agda:+ ```agda+ data AgdaData (A : Set) : Set where+ AgdaCon1 : AgdaData A+ AgdaCon2 : AgdaData A -> AgdaData A+ {-# COMPILED_DATA_UHC AgdaData HsData HsCon1 HsCon2 #-}+ ```++ The mapping has to cover all constructors of the used Haskell+ datatype, else runtime behavior is undefined!++ There are special reserved names to bind Agda datatypes to certain+ Haskell datatypes. For example, this binds an Agda datatype to+ Haskell's list datatype:++ Agda:+ ```agda+ data AgdaList (A : Set) : Set where+ Nil : AgdaList A+ Cons : A -> AgdaList A -> AgdaList A+ {-# COMPILED_DATA_UHC AgdaList __LIST__ __NIL__ __CONS__ #-}+ ```++ The following "magic" datatypes are available:++ ```+ HS Datatype | Datatype Pragma | HS Constructor | Constructor Pragma+ () __UNIT__ () __UNIT__+ List __LIST__ (:) __CONS__+ [] __NIL__+ Bool __BOOL__ True __TRUE__+ False __FALSE__+ ```++ - Functions++ Agda postulates can be bound to Haskell functions. Similar as in+ MAlonzo, all arguments of type `Set` need to be dropped before+ calling Haskell functions. An example calling the return function:++ Agda:+ ```agda+ postulate hs-return : {A : Set} -> A -> IO A+ {-# COMPILED_UHC hs-return (\_ -> UHC.Agda.Builtins.primReturn) #-}+ ```++Emacs mode and interaction+--------------------------++* Module contents (`C-c C-o`) now also works for+ records. [See Issue [#1926](https://github.com/agda/agda/issues/1926) ]+ If you have an inferable expression of record type in an interaction+ point, you can invoke `C-c C-o` to see its fields and types.+ Example++ ```agda+ record R : Set where+ field f : A++ test : R → R+ test r = {!r!} -- C-c C-o here+ ```++* Less aggressive error notification.++ Previously Emacs could jump to the position of an error even if the+ type-checking process was not initiated in the current buffer. Now+ this no longer happens: If the type-checking process was initiated+ in another buffer, then the cursor is moved to the position of the+ error in the buffer visiting the file (if any) and in every window+ displaying the file, but focus should not change from one file to+ another.++ In the cases where focus does change from one file to another, one+ can now use the go-back functionality to return to the previous+ position.++* Removed the `agda-include-dirs` customization parameter.++ Use `agda-program-args` with `-iDIR` or `-lLIB` instead, or add+ libraries to `~/.agda/defaults`+ (`C:/Users/USERNAME/AppData/Roaming/agda/defaults` or similar on+ Windows). See Library management, above, for more information.++Tools+-----++### LaTeX-backend++* The default font has been changed to XITS (which is part of TeX Live):++ http://www.ctan.org/tex-archive/fonts/xits/++ This font is more complete with respect to Unicode.++### agda-ghc-names++* New tool: The command++ ```+ agda-ghc-names fixprof <compile-dir> <ProgName>.prof+ ```++ converts `*.prof` files obtained from profiling runs of+ MAlonzo-compiled code to `*.agdaIdents.prof`, with the original Agda+ identifiers replacing the MAlonzo-generated Haskell identifiers.++ For usage and more details, see `src/agda-ghc-names/README.txt`.++Highlighting and textual backends+---------------------------------++* Names in import directives are now highlighted and are clickable.+ [Issue [#1714](https://github.com/agda/agda/issues/1714)] This leads+ also to nicer printing in the LaTeX and html backends.++Fixed issues+------------++See+[bug tracker (milestone 2.5.1)](https://github.com/agda/agda/issues?q=milestone%3A2.5.1+is%3Aclosed)
@@ -0,0 +1,1184 @@+Release notes for Agda version 2.5.2+====================================++Installation and infrastructure+-------------------------------++* Modular support for literate programming++ Literate programming support has been moved out of the lexer and into the+ `Agda.Syntax.Parser.Literate` module.++ Files ending in `.lagda` are still interpreted as literate TeX.+ The extension `.lagda.tex` may now also be used for literate TeX files.++ Support for more literate code formats and extensions can be added+ modularly.++ By default, `.lagda.*` files are opened in the Emacs mode+ corresponding to their last extension. One may switch to and from+ Agda mode manually.++* reStructuredText++ Literate Agda code can now be written in reStructuredText format, using+ the `.lagda.rst` extension.++ As a general rule, Agda will parse code following a line ending in `::`,+ as long as that line does not start with `..`. The module name must+ match the path of the file in the documentation, and must be given+ explicitly. Several files have been converted already, for instance:++ - `language/mixfix-operators.lagda.rst`+ - `tools/compilers.lagda.rst`++ Note that:++ - Code blocks inside an rST comment block will be type-checked by Agda,+ but not rendered in the documentation.+ - Code blocks delimited by `.. code-block:: agda` will be rendered in+ the final documenation, but not type-checked by Agda.+ - All lines inside a codeblock must be further indented than the first line+ of the code block.+ - Indentation must be consistent between code blocks. In other+ words, the file as a whole must be a valid Agda file if all the+ literate text is replaced by white space.++* Documentation testing++ All documentation files in the `doc/user-manual` directory that end+ in `.lagda.rst` can be typechecked by running `make+ user-manual-test`, and also as part of the general test suite.++* Support installation through Stack++ The Agda sources now also include a configuration for the stack install tool+ (tested through continuous integration).++ It should hence be possible to repeatably build any future Agda version+ (including unreleased commits) from source by checking out that version and+ running `stack install` from the checkout directory.+ By using repeatable builds, this should keep selecting the same dependencies+ in the face of new releases on Hackage.++ For further motivation, see+ Issue [#2005](https://github.com/agda/agda/issues/2005).++* Removed the `--test` command-line option++ This option ran the internal test-suite. This test-suite was+ implemented using Cabal supports for+ test-suites. [Issue [#2083](https://github.com/agda/agda/issues/2083)].++* The `--no-default-libraries` flag has been split into two flags+ [Issue [#1937](https://github.com/agda/agda/issues/1937)]++ - `--no-default-libraries`: Ignore the defaults file but still look for local+ `.agda-lib` files+ - `--no-libraries`: Don't use any `.agda-lib` files (the previous behaviour+ of `--no-default-libraries`).++* If `agda` was built inside `git` repository, then the `--version` flag+ will display the hash of the commit used, and whether the tree was+ `-dirty` (i.e. there were uncommited changes in the working directory).+ Otherwise, only the version number is shown.++Language+--------++* Dot patterns are now optional++ Consider the following program++ ```agda+ data Vec (A : Set) : Nat → Set where+ [] : Vec A zero+ cons : ∀ n → A → Vec A n → Vec A (suc n)++ vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n+ vmap .zero f [] = []+ vmap .(suc m) f (cons m x xs) = cons m (f x) (vmap m f xs)+ ```++ If we don't care about the dot patterns they can (and could previously) be+ replaced by wildcards:++ ```agda+ vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n+ vmap _ f [] = []+ vmap _ f (cons m x xs) = cons m (f x) (vmap m f xs)+ ```++ Now it is also allowed to give a variable pattern in place of the dot+ pattern. In this case the variable will be bound to the value of the dot+ pattern. For our example:++ ```agda+ vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n+ vmap n f [] = []+ vmap n f (cons m x xs) = cons m (f x) (vmap m f xs)+ ```++ In the first clause `n` reduces to `zero` and in the second clause+ `n` reduces to `suc m`.++* Module parameters can now be refined by pattern matching++ Previously, pattern matches that would refine a variable outside the+ current left-hand side was disallowed. For instance, the following+ would give an error, since matching on the vector would+ instantiate `n`.++ ```agda+ module _ {A : Set} {n : Nat} where+ f : Vec A n → Vec A n+ f [] = []+ f (x ∷ xs) = x ∷ xs+ ```++ Now this is no longer disallowed. Instead `n` is bound to the+ appropriate value in each clause.++* With-abstraction now abstracts also in module parameters++ The change that allows pattern matching to refine module parameters also+ allows with-abstraction to abstract in them. For instance,++ ```agda+ module _ (n : Nat) (xs : Vec Nat (n + n)) where+ f : Nat+ f with n + n+ f | nn = ? -- xs : Vec Nat nn+ ```++ Note: Any function argument or lambda-bound variable bound outside a given+ function counts as a module parameter.++ To prevent abstraction in a parameter you can hide it inside a definition. In+ the above example,++ ```agda+ module _ (n : Nat) (xs : Vec Nat (n + n)) where++ ys : Vec Nat (n + n)+ ys = xs++ f : Nat+ f with n + n+ f | nn = ? -- xs : Vec Nat nn, ys : Vec Nat (n + n)+ ```++* As-patterns [Issue [#78](https://github.com/agda/agda/issues/78)].++ As-patterns (`@`-patterns) are finally working and can be used to name a+ pattern. The name has the same scope as normal pattern variables (i.e. the+ right-hand side, where clause, and dot patterns). The name reduces to the+ value of the named pattern. For example::++ ```agda+ module _ {A : Set} (_<_ : A → A → Bool) where+ merge : List A → List A → List A+ merge xs [] = xs+ merge [] ys = ys+ merge xs@(x ∷ xs₁) ys@(y ∷ ys₁) =+ if x < y then x ∷ merge xs₁ ys+ else y ∷ merge xs ys₁+ ```++* Idiom brackets.++ There is new syntactic sugar for idiom brackets:++ `(| e a1 .. an |)` expands to++ `pure e <*> a1 <*> .. <*> an`++ The desugaring takes place before scope checking and only requires names+ `pure` and `_<*>_` in scope. Idiom brackets work well with operators, for+ instance++ `(| if a then b else c |)` desugars to++ `pure if_then_else_ <*> a <*> b <*> c`++ Limitations:++ - The top-level application inside idiom brackets cannot include+ implicit applications, so `(| foo {x = e} a b |)` is illegal. In+ the case `e` is pure you can write `(| (foo {x = e}) a b |)`+ which desugars to++ `pure (foo {x = e}) <*> a <*> b`++ - Binding syntax and operator sections cannot appear immediately inside+ idiom brackets.++* Layout for pattern matching lambdas.++ You can now write pattern matching lambdas using the syntax++ ```agda+ λ where false → true+ true → false+ ```++ avoiding the need for explicit curly braces and semicolons.++* Overloaded projections+ [Issue [#1944](https://github.com/agda/agda/issues/1944)].++ Ambiguous projections are no longer a scope error. Instead they get+ resolved based on the type of the record value they are+ eliminating. This corresponds to constructors, which can be+ overloaded and get disambiguated based on the type they are+ introducing. Example:++ ```agda+ module _ (A : Set) (a : A) where++ record R B : Set where+ field f : B+ open R public++ record S B : Set where+ field f : B+ open S public+ ```++ Exporting `f` twice from both `R` and `S` is now allowed. Then,++ ```agda+ r : R A+ f r = a++ s : S A+ f s = f r+ ```++ disambiguates to:++ ```agda+ r : R A+ R.f r = a++ s : S A+ S.f s = R.f r+ ```++ If the type of the projection is known, it can also be disambiguated+ unapplied.++ ```agda+ unapplied : R A -> A+ unapplied = f+ ```++* Postfix projections+ [Issue [#1963](https://github.com/agda/agda/issues/1963)].++ Agda now supports a postfix syntax for projection application.+ This style is more in harmony with copatterns. For example:++ ```agda+ record Stream (A : Set) : Set where+ coinductive+ field head : A+ tail : Stream A++ open Stream++ repeat : ∀{A} (a : A) → Stream A+ repeat a .head = a+ repeat a .tail = repeat a++ zipWith : ∀{A B C} (f : A → B → C) (s : Stream A) (t : Stream B) → Stream C+ zipWith f s t .head = f (s .head) (t .head)+ zipWith f s t .tail = zipWith f (s .tail) (t .tail)++ module Fib (Nat : Set) (zero one : Nat) (plus : Nat → Nat → Nat) where++ {-# TERMINATING #-}+ fib : Stream Nat+ fib .head = zero+ fib .tail .head = one+ fib .tail .tail = zipWith plus fib (fib .tail)+ ```++ The thing we eliminate with projection now is visibly the head,+ i.e., the left-most expression of the sequence (e.g. `repeat` in+ `repeat a .tail`).++ The syntax overlaps with dot patterns, but for type correct left+ hand sides there is no confusion: Dot patterns eliminate function+ types, while (postfix) projection patterns eliminate record types.++ By default, Agda prints system-generated projections (such as by+ eta-expansion or case splitting) prefix. This can be changed with+ the new option:++ ```agda+ {-# OPTIONS --postfix-projections #-}+ ```++ Result splitting in extended lambdas (aka pattern lambdas) always+ produces postfix projections, as prefix projection pattern do not+ work here: a prefix projection needs to go left of the head, but the+ head is omitted in extended lambdas.++ ```agda+ dup : ∀{A : Set}(a : A) → A × A+ dup = λ{ a → ? }+ ```++ Result splitting (`C-c C-c RET`) here will yield:++ ```agda+ dup = λ{ a .proj₁ → ? ; a .proj₂ → ? }+ ```++* Projection parameters+ [Issue [#1954](https://github.com/agda/agda/issues/1954)].++ When copying a module, projection parameters will now stay hidden+ arguments, even if the module parameters are visible.+ This matches the situation we had for constructors since long.+ Example:++ ```agda+ module P (A : Set) where+ record R : Set where+ field f : A++ open module Q A = P A+ ```++ Parameter `A` is now hidden in `R.f`:++ ```agda+ test : ∀{A} → R A → A+ test r = R.f r+ ```++ Note that a module parameter that corresponds to the record value+ argument of a projection will not be hidden.++ ```agda+ module M (A : Set) (r : R A) where+ open R A r public++ test' : ∀{A} → R A → A+ test' r = M.f r+ ```++* Eager insertion of implicit arguments+ [Issue [#2001](https://github.com/agda/agda/issues/2001)]++ Implicit arguments are now (again) eagerly inserted in left-hand sides. The+ previous behaviour of inserting implicits for where blocks, but not+ right-hand sides was not type safe.++* Module applications can now be eta expanded/contracted without+ changing their behaviour+ [Issue #[1985](https://github.com/agda/agda/issues/1985)]++ Previously definitions exported using `open public` got the+ incorrect type for underapplied module applications.++ Example:++ ```agda+ module A where+ postulate A : Set++ module B (X : Set) where+ open A public++ module C₁ = B+ module C₂ (X : Set) = B X+ ```++ Here both `C₁.A` and `C₂.A` have type `(X : Set) → Set`.++* Polarity pragmas.++ Polarity pragmas can be attached to postulates. The polarities express+ how the postulate's arguments are used. The following polarities+ are available:++ `_`: Unused.++ `++`: Strictly positive.++ `+`: Positive.++ `-`: Negative.++ `*`: Unknown/mixed.++ Polarity pragmas have the form++ ```+ {-# POLARITY name <zero or more polarities> #-}+ ```++ and can be given wherever fixity declarations can be given. The+ listed polarities apply to the given postulate's arguments+ (explicit/implicit/instance), from left to right. Polarities+ currently cannot be given for module parameters. If the postulate+ takes n arguments (excluding module parameters), then the number of+ polarities given must be between 0 and n (inclusive).++ Polarity pragmas make it possible to use postulated type formers in+ recursive types in the following way:++ ```agda+ postulate+ ∥_∥ : Set → Set++ {-# POLARITY ∥_∥ ++ #-}++ data D : Set where+ c : ∥ D ∥ → D+ ```++ Note that one can use postulates that may seem benign, together with+ polarity pragmas, to prove that the empty type is inhabited:++ ```agda+ postulate+ _⇒_ : Set → Set → Set+ lambda : {A B : Set} → (A → B) → A ⇒ B+ apply : {A B : Set} → A ⇒ B → A → B++ {-# POLARITY _⇒_ ++ #-}++ data ⊥ : Set where++ data D : Set where+ c : D ⇒ ⊥ → D++ not-inhabited : D → ⊥+ not-inhabited (c f) = apply f (c f)++ inhabited : D+ inhabited = c (lambda not-inhabited)++ bad : ⊥+ bad = not-inhabited inhabited+ ```++ Polarity pragmas are not allowed in safe mode.++* Declarations in a `where`-block are now+ private. [Issue [#2101](https://github.com/agda/agda/issues/2101)]+ This means that++ ```agda+ f ps = body where+ decls+ ```++ is now equivalent to++ ```agda+ f ps = body where+ private+ decls+ ```++ This changes little, since the `decls` were anyway not in scope+ outside `body`. However, it makes a difference for abstract+ definitions, because private type signatures can see through+ abstract definitions. Consider:++ ```agda+ record Wrap (A : Set) : Set where+ field unwrap : A++ postulate+ P : ∀{A : Set} → A → Set++ abstract++ unnamedWhere : (A : Set) → Set+ unnamedWhere A = A+ where -- the following definitions are private!+ B : Set+ B = Wrap A++ postulate+ b : B+ test : P (Wrap.unwrap b) -- succeeds+ ```++ The `abstract` is inherited in `where`-blocks from the parent (here:+ function `unnamedWhere`). Thus, the definition of `B` is opaque and+ the type equation `B = Wrap A` cannot be used to check type+ signatures, not even of abstract definitions. Thus, checking the+ type `P (Wrap.unwrap b)` would fail. However, if `test` is+ private, abstract definitions are translucent in its type, and+ checking succeeds. With the implemented change, all+ `where`-definitions are private, in this case `B`, `b`, and `test`,+ and the example succeeds.++ Nothing changes for the named forms of `where`,++ ```agda+ module M where+ module _ where+ ```++ For instance, this still fails:++ ```agda+ abstract++ unnamedWhere : (A : Set) → Set+ unnamedWhere A = A+ module M where+ B : Set+ B = Wrap A++ postulate+ b : B+ test : P (Wrap.unwrap b) -- fails+ ```++* Private anonymous modules now work as expected+ [Issue [#2199](https://github.com/agda/agda/issues/2199)]++ Previously the `private` was ignored for anonymous modules causing+ its definitions to be visible outside the module containing the+ anonymous module. This is no longer the case. For instance,++ ```agda+ module M where+ private+ module _ (A : Set) where+ Id : Set+ Id = A++ foo : Set → Set+ foo = Id++ open M++ bar : Set → Set+ bar = Id -- Id is no longer in scope here+ ```++* Pattern synonyms are now expanded on left hand sides of DISPLAY+ pragmas [Issue [#2132](https://github.com/agda/agda/issues/2132)].+ Example:++ ```agda+ data D : Set where+ C c : D+ g : D → D++ pattern C′ = C++ {-# DISPLAY C′ = C′ #-}+ {-# DISPLAY g C′ = c #-}+ ```++ This now behaves as:++ ```agda+ {-# DISPLAY C = C′ #-}+ {-# DISPLAY g C = c #-}+ ```++ Expected error for++ ```agda+ test : C ≡ g C+ test = refl+ ```++ is thus:++ ```+ C′ != c of type D+ ```++* The built-in floats have new semantics to fix inconsistencies+ and to improve cross-platform portability.++ - Float equality has been split into two primitives.+ ``primFloatEquality`` is designed to establish+ decidable propositional equality while+ ``primFloatNumericalEquality`` is intended for numerical+ computations. They behave as follows:++ ```+ primFloatEquality NaN NaN = True+ primFloatEquality 0.0 -0.0 = False++ primFloatNumericalEquality NaN NaN = False+ primFloatNumericalEquality 0.0 -0.0 = True+ ```++ This change fixes an inconsistency, see [Issue [#2169](https://github.com/agda/agda/issues/2169)].+ For further detail see the [user manual](http://agda.readthedocs.io/en/v2.5.2/language/built-ins.html#floats).++ - Floats now have only one `NaN` value. This is necessary+ for proper Float support in the JavaScript backend,+ as JavaScript (and some other platforms) only support+ one `NaN` value.++ - The primitive function `primFloatLess` was renamed+ `primFloatNumericalLess`.++* Added new primitives to built-in floats:++ - `primFloatNegate : Float → Float`+ [Issue [#2194](https://github.com/agda/agda/issues/2194)]++ - Trigonometric primitives+ [Issue [#2200](https://github.com/agda/agda/issues/2200)]:++ ```agda+ primCos : Float → Float+ primTan : Float → Float+ primASin : Float → Float+ primACos : Float → Float+ primATan : Float → Float+ primATan2 : Float → Float → Float+ ```++* Anonymous declarations+ [Issue [#1465](https://github.com/agda/agda/issues/1465)].++ A module can contain an arbitrary number of declarations+ named `_` which will scoped-checked and type-checked but+ won't be made available in the scope (nor exported). They+ cannot introduce arguments on the LHS (but one can use+ lambda-abstractions on the RHS) and they cannot be defined+ by recursion.++ ```agda+ _ : Set → Set+ _ = λ x → x+ ```++### Rewriting++* The REWRITE pragma can now handle several names. E.g.:+ ```agda+ {-# REWRITE eq1 eq2 #-}+ ```++### Reflection++* You can now use macros in reflected terms+ [Issue [#2130](https://github.com/agda/agda/issues/2130)].++ For instance, given a macro++ ```agda+ macro+ some-tactic : Term → TC ⊤+ some-tactic = ...+ ```++ the term `def (quote some-tactic) []` represents a call to the+ macro. This makes it a lot easier to compose tactics.++* The reflection machinery now uses normalisation less often:++ * Macros no longer normalise the (automatically quoted) term+ arguments.++ * The TC primitives `inferType`, `checkType` and `quoteTC` no longer+ normalise their arguments.++ * The following deprecated constructions may also have been changed:+ `quoteGoal`, `quoteTerm`, `quoteContext` and `tactic`.++* New TC primitive: `withNormalisation`.++ To recover the old normalising behaviour of `inferType`, `checkType`,+ `quoteTC` and `getContext`, you can wrap them inside a call to+ `withNormalisation true`:++ ```agda+ withNormalisation : ∀ {a} {A : Set a} → Bool → TC A → TC A+ ```++* New TC primitive: `reduce`.++ ```agda+ reduce : Term → TC Term+ ```++ Reduces its argument to weak head normal form.++* Added new TC primitive: `isMacro`+ [Issue [#2182](https://github.com/agda/agda/issues/2182)]++ ```agda+ isMacro : Name → TC Bool+ ```++ Returns `true` if the name refers to a macro, otherwise `false`.++* The `record-type` constructor now has an extra argument containing+ information about the record type's fields:+ ```agda+ data Definition : Set where+ …+ record-type : (c : Name) (fs : List (Arg Name)) → Definition+ …+ ```++Type checking+-------------++* Files with open metas can be imported now+ [Issue [#964](https://github.com/agda/agda/issues/964)]. This+ should make simultaneous interactive development on several modules+ more pleasant.++ Requires option: `--allow-unsolved-metas`++ Internally, before serialization, open metas are turned into postulates named++ ```+ unsolved#meta.<nnn>+ ```++ where `<nnn>` is the internal meta variable number.++* The performance of the compile-time evaluator has been greatly improved.++ - Fixed a memory leak in evaluator+ (Issue [#2147](https://github.com/agda/agda/issues/2147)).++ - Reduction speed improved by an order of magnitude and is now+ comparable to the performance of GHCi. Still call-by-name though.++* The detection of types that satisfy K added in Agda 2.5.1 has been+ rolled back (see+ Issue [#2003](https://github.com/agda/agda/issues/2003)).++* Eta-equality for record types is now only on after the positivity+ checker has confirmed it is safe to have it. Eta-equality for+ unguarded inductive records previously lead to looping of the type+ checker.+ [See Issue [#2197](https://github.com/agda/agda/issues/2197)]++ ```agda+ record R : Set where+ inductive+ field r : R++ loops : R+ loops = ?+ ```++ As a consequence of this change, the following example does not+ type-check any more:++ ```agda+ mutual+ record ⊤ : Set where++ test : ∀ {x y : ⊤} → x ≡ y+ test = refl+ ```++ It fails because the positivity checker is only run after the mutual+ block, thus, eta-equality for `⊤` is not available when checking+ test.++ One can declare eta-equality explicitly, though, to make this+ example work.++ ```agda+ mutual+ record ⊤ : Set where+ eta-equality++ test : ∀ {x y : ⊤} → x ≡ y+ test = refl+ ```++* Records with instance fields are now eta expanded before instance search.++ For instance, assuming `Eq` and `Ord` with boolean functions `_==_` and `_<_`+ respectively,++ ```agda+ record EqAndOrd (A : Set) : Set where+ field {{eq}} : Eq A+ {{ord}} : Ord A+++ leq : {A : Set} {{_ : EqAndOrd A}} → A → A → Bool+ leq x y = x == y || x < y+ ```++ Here the `EqAndOrd` record is automatically unpacked before instance search,+ revealing the component `Eq` and `Ord` instances.++ This can be used to simulate superclass dependencies.++* Overlappable record instance fields.++ Instance fields in records can be marked as overlappable using the new+ `overlap` keyword:++ ```agda+ record Ord (A : Set) : Set where+ field+ _<_ : A → A → Bool+ overlap {{eqA}} : Eq A+ ```++ When instance search finds multiple candidates for a given instance goal and+ they are **all** overlappable it will pick the left-most candidate instead of+ refusing to solve the instance goal.++ This can be use to solve the problem arising from shared "superclass"+ dependencies. For instance, if you have, in addition to `Ord` above, a `Num`+ record that also has an `Eq` field and want to write a function requiring+ both `Ord` and `Num`, any `Eq` constraint will be solved by the `Eq` instance+ from whichever argument that comes first.++ ```agda+ record Num (A : Set) : Set where+ field+ fromNat : Nat → A+ overlap {{eqA}} : Eq A++ lessOrEqualFive : {A : Set} {{NumA : Num A}} {{OrdA : Ord A}} → A → Bool+ lessOrEqualFive x = x == fromNat 5 || x < fromNat 5+ ```++ In this example the call to `_==_` will use the `eqA` field from `NumA`+ rather than the one from `OrdA`. Note that these may well be different.++* Instance fields can be left out of copattern matches+ [Issue [#2288](https://github.com/agda/agda/issues/2288)]++ Missing cases for instance fields (marked `{{` `}}`) in copattern matches+ will be solved using instance search. This makes defining instances with+ superclass fields much nicer. For instance, we can define `Nat` instances of+ `Eq`, `Ord` and `Num` from above as follows:++ ```agda+ instance+ EqNat : Eq Nat+ _==_ {{EqNat}} n m = eqNat n m++ OrdNat : Ord Nat+ _<_ {{OrdNat}} n m = lessNat n m++ NumNat : Num Nat+ fromNat {{NumNat}} n = n+ ```++ The `eqA` fields of `Ord` and `Num` are filled in using instance search (with+ `EqNat` in this case).++* Limited instance search depth+ [Issue [#2269](https://github.com/agda/agda/issues/2269)]++ To prevent instance search from looping on bad instances+ (see [Issue #1743](https://github.com/agda/agda/issues/1743)) the search+ depth of instance search is now limited. The maximum depth can be set with+ the `--instance-search-depth` flag and the default value is `500`.++Emacs mode+----------++* New command `C-u C-u C-c C-n`: Use `show` to display the result of+ normalisation.++ Calling `C-u C-u C-c C-n` on an expression `e` (in a hole or at top level)+ normalises `show e` and prints the resulting string, or an error message if+ the expression does not normalise to a literal string.++ This is useful when working with complex data structures for which you have+ defined a nice `Show` instance.++ Note that the name `show` is hardwired into the command.++* Changed feature: Interactively split result.++ Make-case (`C-c C-c`) with no variables will now *either* introduce+ function arguments *or* do a copattern split (or fail).++ This is as before:++ ```agda+ test : {A B : Set} (a : A) (b : B) → A × B+ test a b = ?++ -- expected:+ -- proj₁ (test a b) = {!!}+ -- proj₂ (test a b) = {!!}++ testFun : {A B : Set} (a : A) (b : B) → A × B+ testFun = ?++ -- expected:+ -- testFun a b = {!!}+ ```++ This is has changed:++ ```agda+ record FunRec A : Set where+ field funField : A → A+ open FunRec++ testFunRec : ∀{A} → FunRec A+ testFunRec = ?++ -- expected (since 2016-05-03):+ -- funField testFunRec = {!!}++ -- used to be:+ -- funField testFunRec x = {!!}+ ```++* Changed feature: Split on hidden variables.++ Make-case (`C-c C-c`) will no longer split on the given hidden+ variables, but only make them visible. (Splitting can then be+ performed in a second go.)++ ```agda+ test : ∀{N M : Nat} → Nat → Nat → Nat+ test N M = {!.N N .M!}+ ```++ Invoking splitting will result in:++ ```agda+ test {N} {M} zero M₁ = ?+ test {N} {M} (suc N₁) M₁ = ?+ ```++ The hidden `.N` and `.M` have been brought into scope, the+ visible `N` has been split upon.++* Non-fatal errors/warnings.++ Non-fatal errors and warnings are now displayed in the info buffer+ and do not interrupt the typechecking of the file.++ Currently termination errors, unsolved metavariables, unsolved+ constraints, positivity errors, deprecated BUILTINs, and empty+ REWRITING pragmas are non-fatal errors.++* Highlighting for positivity check failures++ Negative occurences of a datatype in its definition are now+ highlighted in a way similar to termination errors.++* The abbrev for codata was replaced by an abbrev for code+ environments.++ If you type `c C-x '` (on a suitably standard setup), then Emacs+ will insert the following text:++ ```agda+ \begin{code}<newline> <cursor><newline>\end{code}<newline>.+ ```++* The LaTeX backend can now be invoked from the Emacs mode.++ Using the compilation command (`C-c C-x C-c`).++ The flag `--latex-dir` can be used to set the output directory (by+ default: `latex`). Note that if this directory is a relative path,+ then it is interpreted relative to the "project root". (When the+ LaTeX backend is invoked from the command line the path is+ interpreted relative to the current working directory.) Example: If+ the module `A.B.C` is located in the file `/foo/A/B/C.agda`, then+ the project root is `/foo/`, and the default output directory is+ `/foo/latex/`.++* The compilation command (`C-c C-x C-c`) now by default asks for a+ backend.++ To avoid this question, set the customisation variable+ `agda2-backend` to an appropriate value.++* The command `agda2-measure-load-time` no longer "touches" the file,+ and the optional argument `DONT-TOUCH` has been removed.++* New command `C-u (C-u) C-c C-s`: Simplify or normalise the solution `C-c C-s` produces++ When writing examples, it is nice to have the hole filled in with+ a normalised version of the solution. Calling `C-c C-s` on++ ```agda+ _ : reverse (0 ∷ 1 ∷ []) ≡ ?+ _ = refl+ ```++ used to yield the non informative `reverse (0 ∷ 1 ∷ [])` when we would+ have hopped to get `1 ∷ 0 ∷ []` instead. We can now control finely the+ degree to which the solution is simplified.++* Changed feature: Solving the hole at point++ Calling `C-c C-s` inside a specific goal does not solve *all* the goals+ already instantiated internally anymore: it only solves the one at hand+ (if possible).++* New bindings: All the blackboard bold letters are now available+ [Pull Request [#2305](https://github.com/agda/agda/pull/2305)]++ The Agda input method only bound a handful of the blackboard bold letters+ but programmers were actually using more than these. They are now all+ available: lowercase and uppercase. Some previous bindings had to be+ modified for consistency. The naming scheme is as follows:++ * `\bx` for lowercase blackboard bold+ * `\bX` for uppercase blackboard bold+ * `\bGx` for lowercase greek blackboard bold (similar to `\Gx` for+ greeks)+ * `\bGX` for uppercase greek blackboard bold (similar to `\GX` for+ uppercase greeks)++* Replaced binding for go back++ Use `M-,` (instead of `M-*`) for go back in Emacs ≥ 25.1 (and+ continue using `M-*` with previous versions of Emacs).++Compiler backends+-----------------++* JS compiler backend++ The JavaScript backend has been (partially) rewritten. The+ JavaScript backend now supports most Agda features, notably+ copatterns can now be compiled to JavaScript. Furthermore, the+ existing optimizations from the other backends now apply to the+ JavaScript backend as well.++* GHC, JS and UHC compiler backends++ Added new primitives to built-in floats+ [Issues [#2194](https://github.com/agda/agda/issues/2194) and+ [#2200](https://github.com/agda/agda/issues/2200)]:++ ```agda+ primFloatNegate : Float → Float+ primCos : Float → Float+ primTan : Float → Float+ primASin : Float → Float+ primACos : Float → Float+ primATan : Float → Float+ primATan2 : Float → Float → Float+ ```++LaTeX backend+-------------++* Code blocks are now (by default) surrounded by vertical space.+ [Issue [#2198](https://github.com/agda/agda/issues/2198)]++ Use `\AgdaNoSpaceAroundCode{}` to avoid this vertical space, and+ `\AgdaSpaceAroundCode{}` to reenable it.++ Note that, if `\AgdaNoSpaceAroundCode{}` is used, then empty lines+ before or after a code block will not necessarily lead to empty+ lines in the generated document. However, empty lines *inside* the+ code block do (by default) lead to empty lines in the output.++ If you prefer the previous behaviour, then you can use the `agda.sty`+ file that came with the previous version of Agda.++* `\AgdaHide{...}` now eats trailing spaces (using `\ignorespaces`).++* New environments: `AgdaAlign`, `AgdaSuppressSpace` and+ `AgdaMultiCode`.++ Sometimes one might want to break up a code block into multiple+ pieces, but keep code in different blocks aligned with respect to+ each other. Then one can use the `AgdaAlign` environment. Example+ usage:+ ```latex+ \begin{AgdaAlign}+ \begin{code}+ code+ code (more code)+ \end{code}+ Explanation...+ \begin{code}+ aligned with "code"+ code (aligned with (more code))+ \end{code}+ \end{AgdaAlign}+ ```+ Note that `AgdaAlign` environments should not be nested.++ Sometimes one might also want to hide code in the middle of a code+ block. This can be accomplished in the following way:+ ```latex+ \begin{AgdaAlign}+ \begin{code}+ visible+ \end{code}+ \AgdaHide{+ \begin{code}+ hidden+ \end{code}}+ \begin{code}+ visible+ \end{code}+ \end{AgdaAlign}+ ```+ However, the result may be ugly: extra space is perhaps inserted+ around the code blocks.++ The `AgdaSuppressSpace` environment ensures that extra space is only+ inserted before the first code block, and after the last one (but+ not if `\AgdaNoSpaceAroundCode{}` is used).++ The environment takes one argument, the number of wrapped code+ blocks (excluding hidden ones). Example usage:+ ```latex+ \begin{AgdaAlign}+ \begin{code}+ code+ more code+ \end{code}+ Explanation...+ \begin{AgdaSuppressSpace}{2}+ \begin{code}+ aligned with "code"+ aligned with "more code"+ \end{code}+ \AgdaHide{+ \begin{code}+ hidden code+ \end{code}}+ \begin{code}+ also aligned with "more code"+ \end{code}+ \end{AgdaSuppressSpace}+ \end{AgdaAlign}+ ```++ Note that `AgdaSuppressSpace` environments should not be nested.++ There is also a combined environment, `AgdaMultiCode`, that combines+ the effects of `AgdaAlign` and `AgdaSuppressSpace`.++Tools+-----++### agda-ghc-names++The `agda-ghc-names` now has its own repository at++ https://github.com/agda/agda-ghc-names++and is no longer distributed with Agda.
@@ -0,0 +1,822 @@+Release notes for Agda version 2.5.3+====================================++Installation and infrastructure+-------------------------------++* Added support for GHC 8.0.2 and 8.2.1.++* Removed support for GHC 7.6.3.++* Markdown support for literate Agda+ \[PR [#2357](https://github.com/agda/agda/pull/2357)].++ Files ending in `.lagda.md` will be parsed as literate Markdown files.++ + Code blocks start with ```` ``` ```` or ```` ```agda ```` in its own line, and end with+ ```` ``` ````, also in its own line.+ + Code blocks which should be type-checked by Agda but should not be visible+ when the Markdown is rendered may be enclosed in HTML comment delimiters+ (`<!--` and `-->`).+ + Code blocks which should be ignored by Agda, but rendered in the final+ document may be indented by four spaces.+ + Note that inline code fragments are not supported due to the difficulty of+ interpreting their indentation level with respect to the rest of the file.++Language+--------++### Pattern matching++* Dot patterns.++ The dot in front of an inaccessible pattern can now be skipped if the+ pattern consists entirely of constructors or literals. For example:+ ```agda+ open import Agda.Builtin.Bool++ data D : Bool → Set where+ c : D true++ f : (x : Bool) → D x → Bool+ f true c = true++ ```+ Before this change, you had to write `f .true c = true`.++* With-clause patterns can be replaced by _+ [Issue [#2363](https://github.com/agda/agda/issues/2363)].+ Example:+ ```agda+ test : Nat → Set+ test zero with zero+ test _ | _ = Nat+ test (suc x) with zero+ test _ | _ = Nat+ ```+ We do not have to spell out the pattern of the parent clause+ (`zero` / `suc x`) in the with-clause if we do not need the+ pattern variables. Note that `x` is not in scope in the+ with-clause!++ A more elaborate example, which cannot be reduced to+ an ellipsis `...`:+ ```agda+ record R : Set where+ coinductive -- disallow matching+ field f : Bool+ n : Nat++ data P (r : R) : Nat → Set where+ fTrue : R.f r ≡ true → P r zero+ nSuc : P r (suc (R.n r))++ data Q : (b : Bool) (n : Nat) → Set where+ true! : Q true zero+ suc! : ∀{b n} → Q b (suc n)++ test : (r : R) {n : Nat} (p : P r n) → Q (R.f r) n+ test r nSuc = suc!+ test r (fTrue p) with R.f r+ test _ (fTrue ()) | false+ test _ _ | true = true! -- underscore instead of (isTrue _)+ ```++* Pattern matching lambdas (also known as extended lambdas) can now be+ nullary, mirroring the behaviour for ordinary function definitions.+ [Issue [#2671](https://github.com/agda/agda/issues/2671)]++ This is useful for case splitting on the result inside an+ expression: given+ ```agda+ record _×_ (A B : Set) : Set where+ field+ π₁ : A+ π₂ : B+ open _×_+ ```+ one may case split on the result (C-c C-c RET) in a hole+ ```agda+ λ { → {!!}}+ ```+ of type A × B to produce+ ```agda+ λ { .π₁ → {!!} ; .π₂ → {!!}}+ ```++* Records with a field of an empty type are now recognized as empty by Agda.+ In particular, they can be matched against with an absurd pattern ().+ For example:+ ```agda+ data ⊥ : Set where++ record Empty : Set where+ field absurdity : ⊥++ magic : Empty → ⊥+ magic ()+ ```++* Injective pragmas.++ Injective pragmas can be used to mark a definition as injective for the+ pattern matching unifier. This can be used as a version of+ `--injective-type-constructors` that only applies to specific datatypes.+ For example:+ ```agda+ open import Agda.Builtin.Equality+ data Fin : Nat → Set where+ zero : {n : Nat} → Fin (suc n)+ suc : {n : Nat} → Fin n → Fin (suc n)++ {-# INJECTIVE Fin #-}++ Fin-injective : {m n : Nat} → Fin m ≡ Fin n → m ≡ n+ Fin-injective refl = refl+ ```+ Aside from datatypes, this pragma can also be used to mark other definitions+ as being injective (for example postulates).++* Metavariables can no longer be instantiated during case splitting. This means+ Agda will refuse to split instead of taking the first constructor it finds.+ For example:+ ```agda+ open import Agda.Builtin.Nat++ data Vec (A : Set) : Nat → Set where+ nil : Vec A 0+ cons : {n : Nat} → A → Vec A n → Vec A (suc n)++ foo : Vec Nat _ → Nat+ foo x = {!x!}+ ```+ In Agda 2.5.2, case splitting on `x` produced the single clause+ `foo nil = {!!}`, but now Agda refuses to split.++### Reflection++* New TC primitive: `debugPrint`.++ ```agda+ debugPrint : String → Nat → List ErrorPart → TC ⊤+ ```++ This maps to the internal function `reportSDoc`. Debug output is enabled with+ the `-v` flag at the command line, or in an `OPTIONS` pragma. For instance,+ giving `-v a.b.c:10` enables printing from `debugPrint "a.b.c.d" 10 msg`. In the+ Emacs mode, debug output ends up in the `*Agda debug*` buffer.++### Built-ins++* BUILTIN REFL is now superfluous, subsumed by BUILTIN EQUALITY+ [Issue [#2389](https://github.com/agda/agda/issues/2389)].++* BUILTIN EQUALITY is now more liberal+ [Issue [#2386](https://github.com/agda/agda/issues/2386)].+ It accepts, among others, the following new definitions of equality:+ ```agda+ -- Non-universe polymorphic:+ data _≡_ {A : Set} (x : A) : A → Set where+ refl : x ≡ x++ -- ... with explicit argument to refl;+ data _≡_ {A : Set} : (x y : A) → Set where+ refl : {x : A} → x ≡ x++ -- ... even visible+ data _≡_ {A : Set} : (x y : A) → Set where+ refl : (x : A) → x ≡ x++ -- Equality in a different universe than domain:+ -- (also with explicit argument to refl)+ data _≡_ {a} {A : Set a} (x : A) : A → Set where+ refl : x ≡ x++ ```+ The standard definition is still:+ ```agda+ -- Equality in same universe as domain:+ data _≡_ {a} {A : Set a} (x : A) : A → Set a where+ refl : x ≡ x+ ```++### Miscellaneous++* Rule change for omitted top-level module headers.+ [Issue [#1077](https://github.com/agda/agda/issues/1077)]++ If your file is named `Bla.agda`, then the following content+ is rejected.+ ```agda+ foo = Set+ module Bla where+ bar = Set+ ```+ Before the fix of this issue, Agda would add the missing module+ header `module Bla where` at the top of the file.+ However, in this particular case it is more likely the user+ put the declaration `foo = Set` before the module start in error.+ Now you get the error+ ```+ Illegal declaration(s) before top-level module+ ```+ if the following conditions are met:++ 1. There is at least one non-import declaration or non-toplevel pragma+ before the start of the first module.++ 2. The module has the same name as the file.++ 3. The module is the only module at this level+ (may have submodules, of course).++ If you should see this error, insert a top-level module+ before the illegal declarations, or move them inside the+ existing module.++Emacs mode+----------++* New warnings:++ - Unreachable clauses give rise to a simple warning. They are+ highlighted in gray.++ - Incomplete patterns are non-fatal warnings: it is possible+ to keep interacting with the file (the reduction will simply+ be stuck on arguments not matching any pattern).+ The definition with incomplete patterns are highlighted in+ wheat.++* Clauses which do not hold definitionally are now highlighted in white smoke.++* Fewer commands have the side effect that the buffer is saved.++* Aborting commands.++ Now one can (try to) abort an Agda command by using `C-c C-x C-a` or+ a menu entry. The effect is similar to that of restarting Agda (`C-c+ C-x C-r`), but some state is preserved, which could mean that it+ takes less time to reload the module.++ Warning: If a command is aborted while it is writing data to disk+ (for instance `.agdai` files or Haskell files generated by the GHC+ backend), then the resulting files may be corrupted. Note also that+ external commands (like GHC) are not aborted, and their output may+ continue to be sent to the Emacs mode.++* New bindings for the Agda input method:++ - All the bold digits are now available. The naming scheme is `\Bx` for digit `x`.++ - Typing `\:` you can now get a whole slew of colons.++ (The Agda input method originally only bound the standard unicode colon,+ which looks deceptively like the normal colon.)++* Case splitting now preserves underscores.+ [Issue [#819](https://github.com/agda/agda/issues/819)]+ ```agda+ data ⊥ : Set where++ test : {A B : Set} → A → ⊥ → B+ test _ x = {! x !}+ ```+ Splitting on `x` yields+ ```agda+ test _ ()+ ```++* Interactively expanding ellipsis.+ [Issue [#2589](https://github.com/agda/agda/issues/2589)]+ An ellipsis in a with-clause can be expanded by splitting on "variable" "." (dot).+ ```agda+ test0 : Nat → Nat+ test0 x with zero+ ... | q = {! . !} -- C-c C-c+ ```+ Splitting on dot here yields:+ ```agda+ test0 x | q = ?+ ```++* New command to check an expression against the type of the hole+ it is in and see what it elaborates to.+ [Issue [#2700](https://github.com/agda/agda/issues/2700)]+ This is useful to determine e.g. what solution typeclass resolution yields.+ The command is bound to `C-c C-;` and respects the `C-u` modifier.++ ```agda+ record Pointed (A : Set) : Set where+ field point : A++ it : ∀ {A : Set} {{x : A}} → A+ it {{x}} = x++ instance _ = record { point = 3 - 4 }++ _ : Pointed Nat+ _ = {! it !} -- C-u C-u C-c C-;+ ```+ yields+ ```agda+ Goal: Pointed Nat+ Elaborates to: record { point = 0 }+ ```++* If `agda2-give` is called with a prefix, then giving is forced,+ i.e., the safety checks are skipped,+ including positivity, termination, and double type-checking.+ [Issue [#2730](https://github.com/agda/agda/issues/2730)]++ Invoke forced giving with key sequence `C-u C-c C-SPC`.+++Library management+------------------++* The `name` field in an `.agda-lib` file is now optional.+ [Issue [#2708](https://github.com/agda/agda/issues/2708)]++ This feature is convenient if you just want to specify the dependencies+ and include pathes for your local project in an `.agda-lib` file.++ Naturally, libraries without names cannot be depended on.+++Compiler backends+-----------------++* Unified compiler pragmas++ The compiler pragmas (`COMPILED`, `COMPILED_DATA`, etc.) have been unified across+ backends into two new pragmas:++ ```+ {-# COMPILE <Backend> <Name> <Text> #-}+ {-# FOREIGN <Backend> <Text> #-}+ ```++ The old pragmas still work, but will emit a warning if used. They will be+ removed completely in Agda 2.6.++ The translation of old pragmas into new ones is as follows:++ Old | New+ --- | ---+ `{-# COMPILED f e #-}` | `{-# COMPILE GHC f = e #-}`+ `{-# COMPILED_TYPE A T #-}` | `{-# COMPILE GHC A = type T #-}`+ `{-# COMPILED_DATA A D C1 .. CN #-}` | `{-# COMPILE GHC A = data D (C1 \| .. \| CN) #-}`+ `{-# COMPILED_DECLARE_DATA #-}` | obsolete, removed+ `{-# COMPILED_EXPORT f g #-}` | `{-# COMPILE GHC f as g #-}`+ `{-# IMPORT M #-}` | `{-# FOREIGN GHC import qualified M #-}`+ `{-# HASKELL code #-}` | `{-# FOREIGN GHC code #-}`+ `{-# COMPILED_UHC f e #-}` | `{-# COMPILE UHC f = e #-}`+ `{-# COMPILED_DATA_UHC A D C1 .. CN #-}` | `{-# COMPILE UHC A = data D (C1 \| .. \| CN) #-}`+ `{-# IMPORT_UHC M #-}` | `{-# FOREIGN UHC __IMPORT__ M #-}`+ `{-# COMPILED_JS f e #-}` | `{-# COMPILE JS f = e #-}`++* GHC Haskell backend++ The COMPILED pragma (and the corresponding COMPILE GHC pragma) is now also+ allowed for functions. This makes it possible to have both an Agda+ implementation and a native Haskell runtime implementation.++ The GHC file header pragmas `LANGUAGE`, `OPTIONS_GHC`, and `INCLUDE`+ inside a `FOREIGN GHC` pragma are recognized and printed correctly+ at the top of the generated Haskell file.+ [Issue [#2712](https://github.com/agda/agda/issues/2712)]+++* UHC compiler backend++ The UHC backend has been moved to its own repository+ [https://github.com/agda/agda-uhc] and is no longer part of the Agda+ distribution.++* Haskell imports are no longer transitively inherited from imported modules.++ The (now deprecated) IMPORT and IMPORT_UHC pragmas no longer cause import+ statements in modules importing the module containing the pragma.++ The same is true for the corresponding FOREIGN pragmas.++* Support for stand-alone backends.++ There is a new API in `Agda.Compiler.Backend` for creating stand-alone+ backends using Agda as a library. This allows prospective backend writers to+ experiment with new backends without having to change the Agda code base.++HTML backend+------------++* Anchors for identifiers (excluding bound variables) are now the+ identifiers themselves rather than just the file position+ [Issue [#2604](https://github.com/agda/agda/issues/2604)].++ Symbolic anchors look like+ ```html+ <a id="test1">+ <a id="M.bla">+ ```+ while other anchors just give the character position in the file:+ ```html+ <a id="42">+ ```++ Top-level module names do not get a symbolic anchor, since the position of+ a top-level module is defined to be the beginning of the file.++ Example:++ ```agda+ module Issue2604 where -- Character position anchor++ test1 : Set₁ -- Issue2604.html#test1+ test1 = bla+ where+ bla = Set -- Character position anchor++ test2 : Set₁ -- Issue2604.html#test2+ test2 = bla+ where+ bla = Set -- Character position anchor++ test3 : Set₁ -- Issue2604.html#test3+ test3 = bla+ module M where -- Issue2604.html#M+ bla = Set -- Issue2604.html#M.bla++ module NamedModule where -- Issue2604.html#NamedModule+ test4 : Set₁ -- Issue2604.html#NamedModule.test4+ test4 = M.bla++ module _ where -- Character position anchor+ test5 : Set₁ -- Character position anchor+ test5 = M.bla+ ```++* Some generated HTML files now have different file names [Issue+ [#2725](https://github.com/agda/agda/issues/2725)].++ Agda now uses an encoding that amounts to first converting the+ module names to UTF-8, and then percent-encoding the resulting+ bytes. For instance, HTML for the module `Σ` is placed in+ `%CE%A3.html`.++LaTeX backend+-------------++* The LaTeX backend now handles indentation in a different way [Issue+ [#1832](https://github.com/agda/agda/issues/1832)].++ A constraint on the indentation of the first token *t* on a line is+ determined as follows:+ * Let *T* be the set containing every previous token (in any code+ block) that is either the initial token on its line or preceded by+ at least one whitespace character.+ * Let *S* be the set containing all tokens in *T* that are not+ *shadowed* by other tokens in *T*. A token *t₁* is shadowed by+ *t₂* if *t₂* is further down than *t₁* and does not start to the+ right of *t₁*.+ * Let *L* be the set containing all tokens in *S* that start to the+ left of *t*, and *E* be the set containing all tokens in *S* that+ start in the same column as *t*.+ * The constraint is that *t* must be indented further than every+ token in *L*, and aligned with every token in *E*.++ Note that if any token in *L* or *E* belongs to a previous code+ block, then the constraint may not be satisfied unless (say) the+ `AgdaAlign` environment is used in an appropriate way.++ If custom settings are used, for instance if `\AgdaIndent` is+ redefined, then the constraint discussed above may not be satisfied.+ (Note that the meaning of the `\AgdaIndent` command's argument has+ changed, and that the command is now used in a different way in the+ generated LaTeX files.)++ Examples:+ * Here `C` is indented further than `B`:++ ```agda+ postulate+ A B+ C : Set+ ```++ * Here `C` is not (necessarily) indented further than `B`, because+ `X` shadows `B`:++ ```agda+ postulate+ A B : Set+ X+ C : Set+ ```++ The new rule is inspired by, but not identical to, the one used by+ lhs2TeX's poly mode (see Section 8.4 of the [manual for lhs2TeX+ version 1.17](https://www.andres-loeh.de/lhs2tex/Guide2-1.17.pdf)).++* Some spacing issues+ [[#2353](https://github.com/agda/agda/issues/2353),+ [#2441](https://github.com/agda/agda/issues/2441),+ [#2733](https://github.com/agda/agda/issues/2733),+ [#2740](https://github.com/agda/agda/issues/2740)] have been fixed.++* The user can now control the typesetting of (certain) individual tokens+ by redefining the `\AgdaFormat` command. Example:+ ```latex+ \usepackage{ifthen}++ % Insert extra space before some tokens.+ \DeclareRobustCommand{\AgdaFormat}[2]{%+ \ifthenelse{+ \equal{#1}{≡⟨} \OR+ \equal{#1}{≡⟨⟩} \OR+ \equal{#1}{∎}+ }{\ }{}#2}+ ```+ Note the use of `\DeclareRobustCommand`. The first argument to+ `\AgdaFormat` is the token, and the second argument the thing to+ be typeset.++* One can now instruct the agda package not to select any fonts.++ If the `nofontsetup` option is used, then some font packages are+ loaded, but specific fonts are not selected:+ ```latex+ \usepackage[nofontsetup]{agda}+ ```++* The height of empty lines is now configurable+ [[#2734](https://github.com/agda/agda/issues/2734)].++ The height is controlled by the length `\AgdaEmptySkip`, which by+ default is `\baselineskip`.++* The alignment feature regards the string `+̲`, containing `+` and a+ combining character, as having length two. However, it seems more+ reasonable to treat it as having length one, as it occupies a single+ column, if displayed "properly" using a monospace font. The new flag+ `--count-clusters` is an attempt at fixing this. When this flag is+ enabled the backend counts ["extended grapheme+ clusters"](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries)+ rather than code points.++ Note that this fix is not perfect: a single extended grapheme+ cluster might be displayed in different ways by different programs,+ and might, in some cases, occupy more than one column. Here are some+ examples of extended grapheme clusters, all of which are treated as+ a single character by the alignment algorithm:+ ```+ │ │+ │+̲│+ │Ö̂│+ │நி│+ │ᄀힰᇹ│+ │ᄀᄀᄀᄀᄀᄀힰᇹᇹᇹᇹᇹᇹ│+ │ │+ ```++ Note also that the layout machinery does not count extended grapheme+ clusters, but code points. The following code is syntactically+ correct, but if `--count-clusters` is used, then the LaTeX backend+ does not align the two `field` keywords:+ ```agda+ record +̲ : Set₁ where field A : Set+ field B : Set+ ```++ The `--count-clusters` flag is not enabled in all builds of Agda,+ because the implementation depends on the+ [ICU](http://site.icu-project.org) library, the installation of+ which could cause extra trouble for some users. The presence of this+ flag is controlled by the Cabal flag `enable-cluster-counting`.++* A faster variant of the LaTeX backend: QuickLaTeX.++ When this variant of the backend is used the top-level module is not+ type-checked, only scope-checked. This implies that some+ highlighting information is not available. For instance, overloaded+ constructors are not resolved.++ QuickLaTeX can be invoked from the Emacs mode, or using `agda+ --latex --only-scope-checking`. If the module has already been+ type-checked successfully, then this information is reused; in this+ case QuickLaTeX behaves like the regular LaTeX backend.++ The `--only-scope-checking` flag can also be used independently, but+ it is perhaps unclear what purpose that would serve. (The flag can+ currently not be combined with `--html`, `--dependency-graph` or+ `--vim`.) The flag is not allowed in safe mode.++Pragmas and options+-------------------++* The `--safe` option is now a valid pragma.++ This makes it possible to declare a module as being part of the safe+ subset of the language by stating `{-# OPTIONS --safe #-}` at the top+ of the corresponding file. Incompatibilities between the `--safe` option+ and other options or language constructs are non-fatal errors.++* The `--no-main` option is now a valid pragma.++ One can now suppress the compiler warning about a missing main function by+ putting+ ```agda+ {-# OPTIONS --no-main #-}+ ```+ on top of the file.++* New command-line option and pragma `--warning=MODE` (or `-W MODE`) for+ setting the warning mode. Current options are+ - `warn` for displaying warnings (default)+ - `error` for turning warnings into errors+ - `ignore` for not displaying warnings++List of fixed issues+--------------------++For 2.5.3, the following issues have been fixed+(see [bug tracker](https://github.com/agda/agda/issues)):++ - [#142](https://github.com/agda/agda/issues/142): Inherited dot patterns in with functions are not checked+ - [#623](https://github.com/agda/agda/issues/623): Error message points to importing module rather than imported module+ - [#657](https://github.com/agda/agda/issues/657): Yet another display form problem+ - [#668](https://github.com/agda/agda/issues/668): Ability to stop, or restart, typechecking somehow+ - [#705](https://github.com/agda/agda/issues/705): confusing error message for ambiguous datatype module name+ - [#719](https://github.com/agda/agda/issues/719): Error message for duplicate module definition points to external module instead of internal module+ - [#776](https://github.com/agda/agda/issues/776): Unsolvable constraints should give error+ - [#819](https://github.com/agda/agda/issues/819): Case-splitting doesn't preserve underscores+ - [#883](https://github.com/agda/agda/issues/883): Rewrite loses type information+ - [#899](https://github.com/agda/agda/issues/899): Instance search fails if there are several definitionally equal values in scope+ - [#1077](https://github.com/agda/agda/issues/1077): problem with module syntax, with parametric module import+ - [#1126](https://github.com/agda/agda/issues/1126): Port optimizations from the Epic backend+ - [#1175](https://github.com/agda/agda/issues/1175): Internal Error in Auto+ - [#1544](https://github.com/agda/agda/issues/1544): Positivity polymorphism needed for compositional positivity analysis+ - [#1611](https://github.com/agda/agda/issues/1611): Interactive splitting instantiates meta+ - [#1664](https://github.com/agda/agda/issues/1664): Add Reflection primitives to expose precedence and fixity+ - [#1817](https://github.com/agda/agda/issues/1817): Solvable size constraints reported as unsolvable+ - [#1832](https://github.com/agda/agda/issues/1832): Insufficient indentation in LaTeX-rendered Agda code+ - [#1834](https://github.com/agda/agda/issues/1834): Copattern matching: order of clauses should not matter here+ - [#1886](https://github.com/agda/agda/issues/1886): Second copies of telescopes not checked?+ - [#1899](https://github.com/agda/agda/issues/1899): Positivity checker does not treat datatypes and record types in the same way+ - [#1975](https://github.com/agda/agda/issues/1975): Type-incorrect instantiated overloaded constructor accepted in pattern+ - [#1976](https://github.com/agda/agda/issues/1976): Type-incorrect instantiated projection accepted in pattern+ - [#2035](https://github.com/agda/agda/issues/2035): Matching on string causes solver to fail with internal error+ - [#2146](https://github.com/agda/agda/issues/2146): Unicode syntax for instance arguments+ - [#2217](https://github.com/agda/agda/issues/2217): Abort Agda without losing state+ - [#2229](https://github.com/agda/agda/issues/2229): Absence or presence of top-level module header affects scope+ - [#2253](https://github.com/agda/agda/issues/2253): Wrong scope error for abstract constructors+ - [#2261](https://github.com/agda/agda/issues/2261): Internal error in Auto/CaseSplit.hs:284+ - [#2270](https://github.com/agda/agda/issues/2270): Printer does not use sections.+ - [#2329](https://github.com/agda/agda/issues/2329): Size solver does not use type `Size< i` to gain the necessary information+ - [#2354](https://github.com/agda/agda/issues/2354): Interaction between instance search, size solver, and ordinary constraint solver.+ - [#2355](https://github.com/agda/agda/issues/2355): Literate Agda parser does not recognize TeX comments+ - [#2360](https://github.com/agda/agda/issues/2360): With clause stripping chokes on ambiguous projection+ - [#2362](https://github.com/agda/agda/issues/2362): Printing of parent patterns when with-clause does not match+ - [#2363](https://github.com/agda/agda/issues/2363): Allow underscore in with-clause patterns+ - [#2366](https://github.com/agda/agda/issues/2366): With-clause patterns renamed in error message+ - [#2368](https://github.com/agda/agda/issues/2368): Internal error after refining a tactic @ MetaVars.hs:267+ - [#2371](https://github.com/agda/agda/issues/2371): Shadowed module parameter crashes interaction+ - [#2372](https://github.com/agda/agda/issues/2372): problems when instances are declared with inferred types+ - [#2374](https://github.com/agda/agda/issues/2374): Ambiguous projection pattern could be disambiguated by visibility+ - [#2376](https://github.com/agda/agda/issues/2376): Termination checking interacts badly with eta-contraction+ - [#2377](https://github.com/agda/agda/issues/2377): open public is useless before module header+ - [#2381](https://github.com/agda/agda/issues/2381): Search (`C-c C-z`) panics on pattern synonyms+ - [#2386](https://github.com/agda/agda/issues/2386): Relax requirements of BUILTIN EQUALITY+ - [#2389](https://github.com/agda/agda/issues/2389): BUILTIN REFL not needed+ - [#2400](https://github.com/agda/agda/issues/2400): LaTeX backend error on LaTeX comments+ - [#2402](https://github.com/agda/agda/issues/2402): Parameters not dropped when reporting incomplete patterns+ - [#2403](https://github.com/agda/agda/issues/2403): Termination checker should reduce arguments in structural order check+ - [#2405](https://github.com/agda/agda/issues/2405): instance search failing in parameterized module+ - [#2408](https://github.com/agda/agda/issues/2408): DLub sorts are not serialized+ - [#2412](https://github.com/agda/agda/issues/2412): Problem with checking with sized types+ - [#2413](https://github.com/agda/agda/issues/2413): Agda crashes on x@y pattern+ - [#2415](https://github.com/agda/agda/issues/2415): Size solver reports "inconsistent upper bound" even though there is a solution+ - [#2416](https://github.com/agda/agda/issues/2416): Cannot give size as computed by solver+ - [#2422](https://github.com/agda/agda/issues/2422): Overloaded inherited projections don't resolve+ - [#2423](https://github.com/agda/agda/issues/2423): Inherited projection on lhs+ - [#2426](https://github.com/agda/agda/issues/2426): On just warning about missing cases+ - [#2429](https://github.com/agda/agda/issues/2429): Irrelevant lambda should be accepted when relevant lambda is expected+ - [#2430](https://github.com/agda/agda/issues/2430): Another regression related to parameter refinement?+ - [#2433](https://github.com/agda/agda/issues/2433): rebindLocalRewriteRules re-adds global rewrite rules+ - [#2434](https://github.com/agda/agda/issues/2434): Exact split analysis is too strict when matching on eta record constructor+ - [#2441](https://github.com/agda/agda/issues/2441): Incorrect alignement in latex using the new ACM format+ - [#2444](https://github.com/agda/agda/issues/2444): Generalising compiler pragmas+ - [#2445](https://github.com/agda/agda/issues/2445): The LaTeX backend is slow+ - [#2447](https://github.com/agda/agda/issues/2447): Cache loaded interfaces even if a type error is encountered+ - [#2449](https://github.com/agda/agda/issues/2449): Agda depends on additional C library icu+ - [#2451](https://github.com/agda/agda/issues/2451): Agda panics when attempting to rewrite a typeclass Eq+ - [#2456](https://github.com/agda/agda/issues/2456): Internal error when postulating instance+ - [#2458](https://github.com/agda/agda/issues/2458): Regression: Agda-2.5.3 loops where Agda-2.5.2 passes+ - [#2462](https://github.com/agda/agda/issues/2462): Overloaded postfix projection does not resolve+ - [#2464](https://github.com/agda/agda/issues/2464): Eta contraction for irrelevant functions breaks subject reduction+ - [#2466](https://github.com/agda/agda/issues/2466): Case split to make hidden variable visible does not work+ - [#2467](https://github.com/agda/agda/issues/2467): REWRITE without BUILTIN REWRITE crashes+ - [#2469](https://github.com/agda/agda/issues/2469): "Partial" pattern match causes segfault at runtime+ - [#2472](https://github.com/agda/agda/issues/2472): Regression related to the auto command+ - [#2477](https://github.com/agda/agda/issues/2477): Sized data type analysis brittle, does not reduce size+ - [#2478](https://github.com/agda/agda/issues/2478): Multiply defined labels on the user manual (pdf)+ - [#2479](https://github.com/agda/agda/issues/2479): "Occurs check" error in generated Haskell code+ - [#2480](https://github.com/agda/agda/issues/2480): Agda accepts incorrect (?) code, subject reduction broken+ - [#2482](https://github.com/agda/agda/issues/2482): Wrong counting of data parameters with new-style mutual blocks+ - [#2483](https://github.com/agda/agda/issues/2483): Files are sometimes truncated to a size of 201 bytes+ - [#2486](https://github.com/agda/agda/issues/2486): Imports via FOREIGN are not transitively inherited anymore+ - [#2488](https://github.com/agda/agda/issues/2488): Instance search inhibits holes for instance fields+ - [#2493](https://github.com/agda/agda/issues/2493): Regression: Agda seems to loop when expression is given+ - [#2494](https://github.com/agda/agda/issues/2494): Instance fields sometimes have incorrect goal types+ - [#2495](https://github.com/agda/agda/issues/2495): Regression: termination checker of Agda-2.5.3 seemingly loops where Agda-2.5.2 passes+ - [#2500](https://github.com/agda/agda/issues/2500): Adding fields to a record can cause Agda to reject previous definitions+ - [#2510](https://github.com/agda/agda/issues/2510): Wrong error with --no-pattern-matching+ - [#2517](https://github.com/agda/agda/issues/2517): "Not a variable error"+ - [#2518](https://github.com/agda/agda/issues/2518): CopatternReductions in TreeLess+ - [#2523](https://github.com/agda/agda/issues/2523): The documentation of `--without-K` is outdated+ - [#2529](https://github.com/agda/agda/issues/2529): Unable to install Agda on Windows.+ - [#2537](https://github.com/agda/agda/issues/2537): case splitting with 'with' creates {_} instead of replicating the arguments it found.+ - [#2538](https://github.com/agda/agda/issues/2538): Internal error when parsing as-pattern+ - [#2543](https://github.com/agda/agda/issues/2543): Case splitting with ellipsis produces spurious parentheses+ - [#2545](https://github.com/agda/agda/issues/2545): Race condition in api tests+ - [#2549](https://github.com/agda/agda/issues/2549): Rewrite rule for higher path constructor does not fire+ - [#2550](https://github.com/agda/agda/issues/2550): Internal error in Agda.TypeChecking.Substitute+ - [#2552](https://github.com/agda/agda/issues/2552): Let bindings in module telescopes crash Agda.Interaction.BasicOps+ - [#2553](https://github.com/agda/agda/issues/2553): Internal error in Agda.TypeChecking.CheckInternal+ - [#2554](https://github.com/agda/agda/issues/2554): More flexible size-assignment in successor style+ - [#2555](https://github.com/agda/agda/issues/2555): Why does the positivity checker care about non-recursive occurrences?+ - [#2558](https://github.com/agda/agda/issues/2558): Internal error in Warshall Solver+ - [#2560](https://github.com/agda/agda/issues/2560): Internal Error in Reduce.Fast+ - [#2564](https://github.com/agda/agda/issues/2564): Non-exact-split highlighting makes other highlighting disappear+ - [#2568](https://github.com/agda/agda/issues/2568): agda2-infer-type-maybe-toplevel (in hole) does not respect "single-solution" requirement of instance resolution+ - [#2571](https://github.com/agda/agda/issues/2571): Record pattern translation does not eta contract+ - [#2573](https://github.com/agda/agda/issues/2573): Rewrite rules fail depending on unrelated changes+ - [#2574](https://github.com/agda/agda/issues/2574): No link attached to module without toplevel name+ - [#2575](https://github.com/agda/agda/issues/2575): Internal error, related to caching+ - [#2577](https://github.com/agda/agda/issues/2577): deBruijn fail for higher order instance problem+ - [#2578](https://github.com/agda/agda/issues/2578): Catch-all clause face used incorrectly for parent with pattern+ - [#2579](https://github.com/agda/agda/issues/2579): Import statements with module instantiation should not trigger an error message+ - [#2580](https://github.com/agda/agda/issues/2580): Implicit absurd match is NonVariant, explicit not+ - [#2583](https://github.com/agda/agda/issues/2583): Wrong de Bruijn index introduced by absurd pattern+ - [#2584](https://github.com/agda/agda/issues/2584): Duplicate warning printing+ - [#2585](https://github.com/agda/agda/issues/2585): Definition by copatterns not modulo eta+ - [#2586](https://github.com/agda/agda/issues/2586): "λ where" with single absurd clause not parsed+ - [#2588](https://github.com/agda/agda/issues/2588): `agda --latex` produces invalid LaTeX when there are block comments+ - [#2592](https://github.com/agda/agda/issues/2592): Internal Error in Agda/TypeChecking/Serialise/Instances/Common.hs+ - [#2597](https://github.com/agda/agda/issues/2597): Inline record definitions confuse the reflection API+ - [#2602](https://github.com/agda/agda/issues/2602): Debug output messes up AgdaInfo buffer+ - [#2603](https://github.com/agda/agda/issues/2603): Internal error in MetaVars.hs+ - [#2604](https://github.com/agda/agda/issues/2604): Use QNames as anchors in generated HTML+ - [#2605](https://github.com/agda/agda/issues/2605): HTML backend generates anchors for whitespace+ - [#2606](https://github.com/agda/agda/issues/2606): Check that LHS of a rewrite rule doesn't reduce is too strict+ - [#2612](https://github.com/agda/agda/issues/2612): `exact-split` documentation is outdated and incomplete+ - [#2613](https://github.com/agda/agda/issues/2613): Parametrised modules, with-abstraction and termination+ - [#2620](https://github.com/agda/agda/issues/2620): Internal error in auto.+ - [#2621](https://github.com/agda/agda/issues/2621): Case splitting instantiates meta+ - [#2626](https://github.com/agda/agda/issues/2626): triggered internal error with sized types in MetaVars module+ - [#2629](https://github.com/agda/agda/issues/2629): Exact splitting should not complain about absurd clauses+ - [#2631](https://github.com/agda/agda/issues/2631): docs for auto aren't clear on how to use flags/options+ - [#2632](https://github.com/agda/agda/issues/2632): some flags to auto dont seem to work in current agda 2.5.2+ - [#2637](https://github.com/agda/agda/issues/2637): Internal error in Agda.TypeChecking.Pretty, possibly related to sized types+ - [#2639](https://github.com/agda/agda/issues/2639): Performance regression, possibly related to the size solver+ - [#2641](https://github.com/agda/agda/issues/2641): Required instance of FromNat when compiling imported files+ - [#2642](https://github.com/agda/agda/issues/2642): Records with duplicate fields+ - [#2644](https://github.com/agda/agda/issues/2644): Wrong substitution in expandRecordVar+ - [#2645](https://github.com/agda/agda/issues/2645): Agda accepts postulated fields in a record+ - [#2646](https://github.com/agda/agda/issues/2646): Only warn if fixities for undefined symbols are given+ - [#2649](https://github.com/agda/agda/issues/2649): Empty list of "previous definition" in duplicate definition error+ - [#2652](https://github.com/agda/agda/issues/2652): Added a new variant of the colon to the Agda input method+ - [#2653](https://github.com/agda/agda/issues/2653): agda-mode: "cannot refine" inside instance argument even though term to be refined typechecks there+ - [#2654](https://github.com/agda/agda/issues/2654): Internal error on result splitting without --postfix-projections+ - [#2664](https://github.com/agda/agda/issues/2664): Segmentation fault with compiled programs using mutual record+ - [#2665](https://github.com/agda/agda/issues/2665): Documentation: Record update syntax in wrong location+ - [#2666](https://github.com/agda/agda/issues/2666): Internal error at Agda/Syntax/Abstract/Name.hs:113+ - [#2667](https://github.com/agda/agda/issues/2667): Panic error on unbound variable.+ - [#2669](https://github.com/agda/agda/issues/2669): Interaction: incorrect field variable name generation+ - [#2671](https://github.com/agda/agda/issues/2671): Feature request: nullary pattern matching lambdas+ - [#2679](https://github.com/agda/agda/issues/2679): Internal error at "Typechecking/Abstract.hs:133" and "TypeChecking/Telescope.hs:68"+ - [#2682](https://github.com/agda/agda/issues/2682): What are the rules for projections of abstract records?+ - [#2684](https://github.com/agda/agda/issues/2684): Bad error message for abstract constructor+ - [#2686](https://github.com/agda/agda/issues/2686): Abstract constructors should be ignored when resolving overloading+ - [#2690](https://github.com/agda/agda/issues/2690): [regression?] Agda engages in deep search instead of immediately failing+ - [#2700](https://github.com/agda/agda/issues/2700): Add a command to check against goal type (and normalise)+ - [#2703](https://github.com/agda/agda/issues/2703): Regression: Internal error for underapplied indexed constructor+ - [#2705](https://github.com/agda/agda/issues/2705): The GHC backend might diverge in infinite file creation+ - [#2708](https://github.com/agda/agda/issues/2708): Why is the `name` field in .agda-lib files mandatory?+ - [#2710](https://github.com/agda/agda/issues/2710): Type checker hangs+ - [#2712](https://github.com/agda/agda/issues/2712): Compiler Pragma for headers+ - [#2714](https://github.com/agda/agda/issues/2714): Option --no-main should be allowed as file-local option+ - [#2717](https://github.com/agda/agda/issues/2717): internal error at DisplayForm.hs:197+ - [#2718](https://github.com/agda/agda/issues/2718): Interactive 'give' doesn't insert enough parenthesis+ - [#2721](https://github.com/agda/agda/issues/2721): Without-K doesn't prevent heterogeneous conflict between literals+ - [#2723](https://github.com/agda/agda/issues/2723): Unreachable clauses in definition by copattern matching trip clause compiler+ - [#2725](https://github.com/agda/agda/issues/2725): File names for generated HTML files+ - [#2726](https://github.com/agda/agda/issues/2726): Old regression related to with+ - [#2727](https://github.com/agda/agda/issues/2727): Internal errors related to rewrite+ - [#2729](https://github.com/agda/agda/issues/2729): Regression: case splitting uses variable name variants instead of the unused original names+ - [#2730](https://github.com/agda/agda/issues/2730): Command to give in spite of termination errors+ - [#2731](https://github.com/agda/agda/issues/2731): Agda fails to build with happy 1.19.6+ - [#2733](https://github.com/agda/agda/issues/2733): Avoid some uses of \AgdaIndent?+ - [#2734](https://github.com/agda/agda/issues/2734): Make height of empty lines configurable+ - [#2736](https://github.com/agda/agda/issues/2736): Segfault using Alex 3.2.2 and cpphs+ - [#2740](https://github.com/agda/agda/issues/2740): Indenting every line of code should be a no-op
@@ -0,0 +1,16 @@+Release notes for Agda version 2.5.4.1+======================================++Installation and infrastructure+-------------------------------++* Generated the interface file for the `Sigma.agda` built-in when+ installing Agda+ [Issue [#3128](https://github.com/agda/agda/issues/3128)].++Emacs mode+----------++* Light highlighting is no longer applied continuously, but only when+ the file is saved [Issue+ [#3119](https://github.com/agda/agda/issues/3119)].
@@ -0,0 +1,23 @@+Release notes for Agda version 2.5.4.2+======================================++Installation and infrastructure+-------------------------------++* Fixed installation with some old versions of `cabal-install`+ [Issue [#3225](https://github.com/agda/agda/issues/3225)].++* Using `cpp` instead of `cpphs` as the default preprocessor+ [Issue [#3223](https://github.com/agda/agda/issues/3223)].++* Added support for GHC 8.4.4.++Other closed issues+--------------------++For 2.5.4.2 the following issues have also been closed+(see [bug tracker](https://github.com/agda/agda/issues)):++ - [#3177](https://github.com/agda/agda/issues/3177): Slow typechecking with unsolved instance constraint+ - [#3199](https://github.com/agda/agda/issues/3199): Panics when serialising absolute paths+ - [#3312](https://github.com/agda/agda/issues/3312): Crash in Substitute.hs
@@ -0,0 +1,859 @@+Release notes for Agda version 2.5.4+====================================++Installation and infrastructure+-------------------------------++* Added support for GHC 8.2.2 and GHC 8.4.3.++ Note that GHC 8.4.* requires `cabal-install` ≥ 2.2.0.0.++* Removed support for GHC 7.8.4.++* Included user manual in PDF format in `doc/user-manual.pdf`.++Language+--------++* Call-by-need reduction.++ Compile-time weak-head evaluation is now call-by-need, but each weak-head+ reduction has a local heap, so sharing is not maintained between different+ reductions.++ The reduction machine has been rewritten from scratch and should be faster+ than the old one in all cases, even those not exploiting laziness.++* Compile-time inlining.++ Simple definitions (that don't do any pattern matching) marked as INLINE are+ now also inlined at compile time, whereas before they were only inlined by+ the compiler backends. Inlining only triggers in function bodies and not in+ type signatures, to preserve goal types as far as possible.++* Automatic inlining.++ Definitions satisfying the following criteria are now automatically inlined+ (can be disabled using the new NOINLINE pragma):++ - No pattern matching.+ - Uses each argument at most once.+ - Does not use all its arguments.++ Automatic inlining can be turned off using the flag `--no-auto-inline`. This+ can be useful when debugging tactics that may be affected by whether or not+ a particular definition is being inlined.++### Syntax++* Do-notation.++ There is now builtin do-notation syntax. This means that `do` is a reserved+ keyword and cannot be used as an identifier.++ Do-blocks support lets and pattern matching binds. If the pattern in a bind+ is non-exhaustive the other patterns need to be handled in a `where`-clause+ (see example below).++ Example:++ ```agda+ filter : {A : Set} → (A → Bool) → List A → List A+ filter p xs = do+ x ← xs+ true ← return (p x)+ where false → []+ return x+ ```++ Do-blocks desugar to `_>>=_` and `_>>_` before scope checking, so whatever+ definitions of these two functions are in scope of the do-block will be used.++ More precisely:++ - Simple bind++ ```agda+ do x ← m+ m'+ ```+ desugars to `m >>= λ x → m'`.++ - Pattern bind++ ```agda+ do p ← m where pᵢ → mᵢ+ m'+ ```+ desugars to `m >>= λ { p → m'; pᵢ → mᵢ }`, where `pᵢ → mᵢ` is an arbitrary+ sequence of clauses and follows the usual layout rules for `where`. If `p`+ is exhaustive the `where` clause can be omitted.++ - Non-binding operation++ ```agda+ do m+ m'+ ```+ desugars to `m >> m'`.++ - Let++ ```agda+ do let ds+ m+ ```+ desugars to `let ds in m`, where `ds` is an arbitrary sequence of valid let-declarations.++ - The last statement in the do block must be a plain expression (no let or bind).++ Bind statements can use either `←` or `<-`. Neither of these are reserved, so+ code outside do-blocks can use identifiers with these names, but inside a+ do-block they would need to be used qualified or under different names.++* Infix let declarations. [Issue [#917](https://github.com/agda/agda/issues/917)]++ Let declarations can now be defined in infix (or mixfix) style. For instance:++ ```agda+ f : Nat → Nat+ f n = let _!_ : Nat → Nat → Nat+ x ! y = 2 * x + y+ in n ! n+ ```++* Overloaded pattern synonyms. [Issue [#2787](https://github.com/agda/agda/issues/2787)]++ Pattern synonyms can now be overloaded if all candidates have the same+ *shape*. Two pattern synonym definitions have the same shape if they are+ equal up to variable and constructor names. Shapes are checked at resolution+ time.++ For instance, the following is accepted:++ ```agda+ open import Agda.Builtin.Nat++ data List (A : Set) : Set where+ lnil : List A+ lcons : A → List A → List A++ data Vec (A : Set) : Nat → Set where+ vnil : Vec A 0+ vcons : ∀ {n} → A → Vec A n → Vec A (suc n)++ pattern [] = lnil+ pattern [] = vnil++ pattern _∷_ x xs = lcons x xs+ pattern _∷_ y ys = vcons y ys++ lmap : ∀ {A B} → (A → B) → List A → List B+ lmap f [] = []+ lmap f (x ∷ xs) = f x ∷ lmap f xs++ vmap : ∀ {A B n} → (A → B) → Vec A n → Vec B n+ vmap f [] = []+ vmap f (x ∷ xs) = f x ∷ vmap f xs+ ```++* If the file has no top-level module header, the first module+ cannot have the same name as the file.+ [Issues [#2808](https://github.com/agda/agda/issues/2808)+ and [#1077](https://github.com/agda/agda/issues/1077)]++ This means that the following file `File.agda` is rejected:+ ```agda+ -- no module header+ postulate A : Set+ module File where -- inner module with the same name as the file+ ```+ Agda reports `Illegal declarations(s) before top-level module`+ at the `postulate`.+ This is to avoid confusing scope errors in similar situations.++ If a top-level module header is inserted manually, the file is accepted:++ ```agda+ module _ where -- user written module header+ postulate A : Set+ module File where -- inner module with the same name as the file, ok+ ```++### Pattern matching++* Forced constructor patterns.++ Constructor patterns can now be dotted to indicate that Agda should not case+ split on them but rather their value is forced by the type of the other+ patterns. The difference between this and a regular dot pattern is that+ forced constructor patterns can still bind variables in their arguments.+ For example,++ ```agda+ open import Agda.Builtin.Nat++ data Vec (A : Set) : Nat → Set where+ nil : Vec A zero+ cons : (n : Nat) → A → Vec A n → Vec A (suc n)++ append : {A : Set} (m n : Nat) → Vec A m → Vec A n → Vec A (m + n)+ append .zero n nil ys = ys+ append (.suc m) n (cons .m x xs) ys = cons (m + n) x (append m n xs ys)+ ```++* Inferring the type of a function based on its patterns++ Agda no longer infers the type of a function based on the patterns used in+ its definition. [Issue [#2834](https://github.com/agda/agda/issues/2834)]++ This means that the following Agda program is no longer accepted:+ ```agda+ open import Agda.Builtin.Nat++ f : _ → _+ f zero = zero+ f (suc n) = n+ ```+ Agda now requires the type of the argument of `f` to be given explicitly.++* Improved constraint solving for pattern matching functions++ Constraint solving for functions where each right-hand side has a distinct+ rigid head has been extended to also cover the case where some clauses return+ an argument of the function. A typical example is append on lists:++ ```agda+ _++_ : {A : Set} → List A → List A → List A+ [] ++ ys = ys+ (x ∷ xs) ++ ys = x ∷ (xs ++ ys)+ ```++ Agda can now solve constraints like `?X ++ ys == 1 ∷ ys` when `ys` is a+ neutral term.++* Record expressions translated to copatterns++ Definitions of the form++ ```agda+ f ps = record { f₁ = e₁; ..; fₙ = eₙ }+ ```++ are translated internally to use copatterns:++ ```agda+ f ps .f₁ = e₁+ ...+ f ps .fₙ = eₙ+ ```++ This means that `f ps` does not reduce, but thanks to η-equality the two+ definitions are equivalent.++ The change should lead to fewer big record expressions showing up in goal+ types, and potentially significant performance improvement in some cases.++ This may have a minor impact on with-abstraction and code using `--rewriting`+ since η-equality is not used in these cases.++* When using `with`, it is now allowed to replace any pattern from the parent+ clause by a variable in the with clause. For example:++ ```agda+ f : List ℕ → List ℕ+ f [] = []+ f (x ∷ xs) with x ≤? 10+ f xs | p = {!!}+ ```++ In the with clause, `xs` is treated as a let-bound variable with value+ `.x ∷ .xs` (where `.x : ℕ` and `.xs : List ℕ` are out of scope) and+ `p : Dec (.x ≤ 10)`.++ Since with-abstraction may change the type of variables, instantiations+ of variables in the with clause are type checked again after with-abstraction.++### Builtins++* Added support for built-in 64-bit machine words.++ These are defined in `Agda.Builtin.Word` and come with two primitive+ operations to convert to and from natural numbers.++ ```agda+ Word64 : Set+ primWord64ToNat : Word64 → Nat+ primWord64FromNat : Nat → Word64+ ```++ Converting to a natural number is the trivial embedding, and converting from a natural number+ gives you the remainder modulo 2^64. The proofs of these theorems are not+ primitive, but can be defined in a library using `primTrustMe`.++ Basic arithmetic operations can be defined on `Word64` by converting to+ natural numbers, peforming the corresponding operation, and then converting+ back. The compiler will optimise these to use 64-bit arithmetic. For+ instance,++ ```agda+ addWord : Word64 → Word64 → Word64+ addWord a b = primWord64FromNat (primWord64ToNat a + primWord64ToNat b)++ subWord : Word64 → Word64 → Word64+ subWord a b = primWord64FromNat (primWord64ToNat a + 18446744073709551616 - primWord64ToNat b)+ ```++ These compiles (in the GHC backend) to addition and subtraction on+ `Data.Word.Word64`.++* New primitive primFloatLess and changed semantics of primFloatNumericalLess.++ `primFloatNumericalLess` now uses standard IEEE `<`, so for instance+ `NaN < x = x < NaN = false`.++ On the other hand `primFloatLess` provides a total order on `Float`, with+ `-Inf < NaN < -1.0 < -0.0 < 0.0 < 1.0 < Inf`.++* The `SIZEINF` builtin is now given the name `∞` in+ `Agda.Builtin.Size` [Issue+ [#2931](https://github.com/agda/agda/issues/2931)].++ Previously it was given the name `ω`.++### Reflection++* New TC primitive: `declarePostulate`. [Issue+ [#2782](https://github.com/agda/agda/issues/2782)]++ ```agda+ declarePostulate : Arg Name → Type → TC ⊤+ ```++ This can be used to declare new postulates. The Visibility of the+ Arg must not be hidden. This feature fails when executed with+ `--safe` flag from command-line.++Pragmas and options+-------------------++* The `--caching` option is ON by default and is also a valid pragma.+ Caching can (sometimes) speed up re-typechecking in `--interaction`+ mode by reusing the result of the previous typechecking for the+ prefix of the file that has not changed (with a granularity at the+ level of declarations/mutual blocks).++ It can be turned off by passing ```--no-caching``` to ```agda``` or+ with the following at the top of your file.++ ```agda+ {-# OPTIONS --no-caching #-}+ ```++* The `--sharing` and `--no-sharing` options have been deprecated and do+ nothing.++ Compile-time evaluation is now always call-by-need.++* BUILTIN pragmas can now appear before the top-level module header+ and in parametrized modules.+ [Issue [#2824](https://github.com/agda/agda/issues/2824)]+ ```agda+ {-# OPTIONS --rewriting #-}+ open import Agda.Builtin.Equality+ {-# BUILTIN REWRITE _≡_ #-} -- here+ module TopLevel (A : Set) where+ {-# BUILTIN REWRITE _≡_ #-} -- or here+ ```+ Note that it is still the case that built-ins cannot be bound if+ they depend on module parameters from an enclosing module. For+ instance, the following is illegal:+ ```agda+ module _ {a} {A : Set a} where+ data _≡_ (x : A) : A → Set a where+ refl : x ≡ x+ {-# BUILTIN EQUALITY _≡_ #-}+ ```++* Builtin `NIL` and `CONS` have been merged with `LIST`.++ When binding the `LIST` builtin, `NIL` and `CONS` are bound to+ the appropriate constructors automatically. This means that instead+ of writing++ ```agda+ {-# BUILTIN LIST List #-}+ {-# BUILTIN NIL [] #-}+ {-# BUILTIN CONS _∷_ #-}+ ```++ you just write++ ```agda+ {-# BUILTIN LIST List #-}+ ```++ Attempting to bind `NIL` or `CONS` results in a warning and has otherwise no+ effect.++* The `--no-unicode` pragma prevents Agda from introducing unicode characters+ when pretty printing a term. Lambda, Arrows and Forall quantifiers are all+ replaced by their ascii only version. Instead of resorting to subscript+ suffixes, Agda uses ascii digit characters.++* New option `--inversion-max-depth=N`.++ The depth is used to avoid looping due to inverting pattern matching for+ unsatisfiable constraints [Issue [#431](https://github.com/agda/agda/issues/431)].+ This option is only expected to be necessary in pathological cases.++* New option `--no-print-pattern-synonyms`.++ This disables the use of pattern synonyms in output from Agda.+ See [Issue [#2902](https://github.com/agda/agda/issues/2902)] for situations+ where this might be desirable.++* New fine-grained control over the warning machinery: ability to (en/dis)able+ warnings on a one-by-one basis.++* The command line option `--help` now takes an optional argument which+ allows the user to request more specific usage information about particular+ topics. The only one added so far is `warning`.++* New pragma NOINLINE.++ ```agda+ {-# NOINLINE f #-}+ ```++ Disables automatic inlining of `f`.++* New pragma WARNING_ON_USAGE++ ```+ {-# WARNING_ON_USAGE QName Message #}+ ```++ Prints Message whenever QName is used.++Emacs mode+----------++* Banana brackets have been added to the Agda input method.+ ```+ \(( #x2985 LEFT WHITE PARENTHESIS+ \)) #x2986 RIGHT WHITE PARENTHESIS+ ```++* Result splitting will introduce the trailing hidden arguments,+ if there is nothing else todo+ [Issue [#2871](https://github.com/agda/agda/issues/2871)].+ Example:+ ```agda+ data Fun (A : Set) : Set where+ mkFun : (A → A) → Fun A++ test : {A : Set} → Fun A+ test = ?++ ```+ Splitting on the result here (`C-c C-c RET`) will append+ `{A}` to the left hand side.+ ```agda+ test {A} = ?+ ```++* Light highlighting is performed dynamically, even if the file is not+ loaded [Issue [#2794](https://github.com/agda/agda/issues/2794)].++ This light highlighting is based on the token stream generated by+ Agda's lexer: the code is only highlighted if the file is lexically+ correct. If the Agda backend is not busy with something else, then+ the code is highlighted automatically in certain situations:++ * When the file is saved.++ * When Emacs has been idle, continuously, for a certain period of+ time (by default 0.2 s) after the last modification of the file,+ and the file has not been saved (or marked as being unmodified).+ This functionality can be turned off, and the time period can be+ customised.++* Highlighting of comments is no longer handled by Font Lock mode+ [Issue [#2794](https://github.com/agda/agda/issues/2794)].++* The Emacs mode's syntax table has been changed.++ Previously `_` was treated as punctuation. Now it is treated in the+ same way as most other characters: if the standard syntax table+ assigns it the syntax class "whitespace", "open parenthesis" or+ "close parenthesis", then it gets that syntax class, and otherwise+ it gets the syntax class "word constituent".++Compiler backends+-----------------++* The GHC backend now automatically compiles BUILTIN LIST to Haskell lists.++ This means that it's no longer necessary to give a COMPILE GHC pragma for the+ builtin list type. Indeed, doing so has no effect on the compilation and+ results in a warning.++* The GHC backend performance improvements.++ Generated Haskell code now contains approximate type signatures, which lets+ GHC get rid of many of the `unsafeCoerce`s. This leads to performance+ improvements of up to 50% of compiled code.++* The GHC backend now compiles the `INFINITY`, `SHARP` and `FLAT`+ builtins in a different way [Issue+ [#2909](https://github.com/agda/agda/issues/2909)].++ Previously these were compiled to (basically) nothing. Now the+ `INFINITY` builtin is compiled to `Infinity`, available from+ `MAlonzo.RTE`:++ ```haskell+ data Inf a = Sharp { flat :: a }+ type Infinity level a = Inf a+ ```++ The `SHARP` builtin is compiled to `Sharp`, and the `FLAT` builtin+ is (by default) compiled to a corresponding destructor.++ Note that code that interacts with Haskell libraries may have to be+ updated. As an example, here is one way to print colists of+ characters using the Haskell function `putStr`:++ ```agda+ open import Agda.Builtin.Char+ open import Agda.Builtin.Coinduction+ open import Agda.Builtin.IO+ open import Agda.Builtin.Unit++ data Colist {a} (A : Set a) : Set a where+ [] : Colist A+ _∷_ : A → ∞ (Colist A) → Colist A++ {-# FOREIGN GHC+ data Colist a = Nil | Cons a (MAlonzo.RTE.Inf (Colist a))+ type Colist' l a = Colist a++ fromColist :: Colist a -> [a]+ fromColist Nil = []+ fromColist (Cons x xs) = x : fromColist (MAlonzo.RTE.flat xs)+ #-}++ {-# COMPILE GHC Colist = data Colist' (Nil | Cons) #-}++ postulate+ putStr : Colist Char → IO ⊤++ {-# COMPILE GHC putStr = putStr . fromColist #-}+ ```++* `COMPILE GHC` pragmas have been included for the size primitives+ [Issue [#2879](https://github.com/agda/agda/issues/2879)].++LaTeX backend+-------------++* The `code` environment can now take arguments [Issues+ [#2744](https://github.com/agda/agda/issues/2744) and+ [#2453](https://github.com/agda/agda/issues/2453)].++ Everything from \begin{code} to the end of the line is preserved in+ the generated LaTeX code, and not treated as Agda code.++ The default implementation of the `code` environment recognises one+ optional argument, `hide`, which can be used for code that should be+ type-checked, but not typeset:+ ```latex+ \begin{code}[hide]+ open import Module+ \end{code}+ ```++ The `AgdaHide` macro has not been removed, but has been deprecated+ in favour of `[hide]`.++* The `AgdaSuppressSpace` and `AgdaMultiCode` environments no longer+ take an argument.++ Instead some documents need to be compiled multiple times.++* The `--count-clusters` flag can now be given in `OPTIONS` pragmas.++* The `nofontsetup` option to the LaTeX package `agda` was broken, and+ has (hopefully) been fixed+ [Issue [#2773](https://github.com/agda/agda/issues/2773)].++ Fewer packages than before are loaded when `nofontsetup` is used,+ see `agda.sty` for details. Furthermore, if LuaLaTeX or XeLaTeX are+ not used, then the font encoding is no longer changed.++* The new option `noinputencodingsetup` instructs the LaTeX package+ `agda` to not change the input encoding, and to not load the `ucs`+ package.++* Underscores are now typeset using `\AgdaUnderscore{}`.++ The default implementation is `\_` (the command that was previously+ generated for underscores). Note that it is possible to override+ this implementation.++* OtherAspects (unsolved meta variables, catchall clauses, etc.) are+ now correctly highlighted in the LaTeX backend (and the HTML one).+ [Issue [#2474](https://github.com/agda/agda/issues/2474)]++* `postprocess-latex.pl` does not add extra spaces around tagged `\Agda*{}`+ commands anymore.++HTML backend+------------++* An identifier (excluding bound variables),+ gets the identifier itself as an anchor,+ _in addition_ to the file position+ [Issue [#2756](https://github.com/agda/agda/issues/2756)].+ In Agda 2.5.3, the identifier anchor would _replace_ the file position anchor+ [Issue [#2604](https://github.com/agda/agda/issues/2604)].++ Symbolic anchors look like+ ```html+ <a id="test1">+ <a id="M.bla">+ ```+ while file position anchors just give the character position in the file:+ ```html+ <a id="42">+ ```++ Top-level module names do not get a symbolic anchor, since the position of+ a top-level module is defined to be the beginning of the file.++ Example:++ ```agda+ module Issue2604 where -- Character position anchor++ test1 : Set₁ -- Issue2604.html#test1+ test1 = bla+ where+ bla = Set -- Only character position anchor++ test2 : Set₁ -- Issue2604.html#test2+ test2 = bla+ where+ bla = Set -- Only character position anchor++ test3 : Set₁ -- Issue2604.html#test3+ test3 = bla+ module M where -- Issue2604.html#M+ bla = Set -- Issue2604.html#M.bla++ module NamedModule where -- Issue2604.html#NamedModule+ test4 : Set₁ -- Issue2604.html#NamedModule.test4+ test4 = M.bla++ module _ where -- Only character position anchor+ test5 : Set₁ -- Only character position anchor+ test5 = M.bla+ ```++List of closed issues+---------------------++For 2.5.4, the following issues have been closed+(see [bug tracker](https://github.com/agda/agda/issues)):++ - [#351](https://github.com/agda/agda/issues/351): Constraint solving for irrelevant metas+ - [#421](https://github.com/agda/agda/issues/421): Higher order positivity+ - [#431](https://github.com/agda/agda/issues/431): Constructor-headed function makes type-checker diverge+ - [#437](https://github.com/agda/agda/issues/437): Detect when something cannot be a function type+ - [#488](https://github.com/agda/agda/issues/488): Refining on user defined syntax mixes up the order of the subgoals+ - [#681](https://github.com/agda/agda/issues/681): Lack of visual state indicators in new Emacs mode+ - [#689](https://github.com/agda/agda/issues/689): Contradictory constraints should yield error+ - [#708](https://github.com/agda/agda/issues/708): Coverage checker not taking literal patterns into account properly+ - [#875](https://github.com/agda/agda/issues/875): Nonstrict irrelevance violated by implicit inference+ - [#964](https://github.com/agda/agda/issues/964): Allow unsolved metas in imported files+ - [#987](https://github.com/agda/agda/issues/987): --html anchors could be more informative+ - [#1054](https://github.com/agda/agda/issues/1054): Inlined Agda code in LaTeX backend+ - [#1131](https://github.com/agda/agda/issues/1131): Infix definitions not allowed in let definitions+ - [#1169](https://github.com/agda/agda/issues/1169): Auto fails with non-terminating function+ - [#1268](https://github.com/agda/agda/issues/1268): Hard to print type of variable if the type starts with an instance argument+ - [#1384](https://github.com/agda/agda/issues/1384): Order of constructor arguments matters for coverage checker+ - [#1425](https://github.com/agda/agda/issues/1425): Instances with relevant recursive instance arguments are not considered in irrelevant positions+ - [#1548](https://github.com/agda/agda/issues/1548): Confusing error about ambiguous definition with parametrized modules+ - [#1884](https://github.com/agda/agda/issues/1884): what is the format of the libraries and defaults files+ - [#1906](https://github.com/agda/agda/issues/1906): Possible performance problem+ - [#2056](https://github.com/agda/agda/issues/2056): Cannot instantiate meta to solution...: Pattern checking done too early in where block+ - [#2067](https://github.com/agda/agda/issues/2067): Display forms in parameterised module too general+ - [#2183](https://github.com/agda/agda/issues/2183): Allow splitting on dotted variables+ - [#2226](https://github.com/agda/agda/issues/2226): open {{...}} gets hiding wrong+ - [#2255](https://github.com/agda/agda/issues/2255): Performance issue with deeply-nested lambdas+ - [#2306](https://github.com/agda/agda/issues/2306): Commands in the emacs-mode get confused if we add question marks to the file+ - [#2384](https://github.com/agda/agda/issues/2384): More fine-grained blocking in constraint solver+ - [#2401](https://github.com/agda/agda/issues/2401): LaTeX backend error+ - [#2404](https://github.com/agda/agda/issues/2404): checkType doesn't accept a type-checking definition checked with the same type+ - [#2420](https://github.com/agda/agda/issues/2420): Failed to solve level constraints in record type with hole+ - [#2421](https://github.com/agda/agda/issues/2421): After emacs starts up, Agda does not process file without restart of Agda+ - [#2436](https://github.com/agda/agda/issues/2436): Agda allows coinductive records with eta-equality+ - [#2450](https://github.com/agda/agda/issues/2450): Irrelevant variables are pruned too eagerly+ - [#2474](https://github.com/agda/agda/issues/2474): The LaTeX and HTML backends do not highlight (all) unsolved metas+ - [#2484](https://github.com/agda/agda/issues/2484): Regression related to sized types+ - [#2526](https://github.com/agda/agda/issues/2526): Better documentation of record modules+ - [#2536](https://github.com/agda/agda/issues/2536): UTF8 parsed incorrectly for literate agda files+ - [#2565](https://github.com/agda/agda/issues/2565): Options for the interaction action give to keep the overloaded literals and sections?+ - [#2576](https://github.com/agda/agda/issues/2576): Shadowing data decl by data sig produces Missing type signature error+ - [#2594](https://github.com/agda/agda/issues/2594): Valid partial cover rejected: "Cannot split on argument of non-datatype"+ - [#2600](https://github.com/agda/agda/issues/2600): Stack complains about Agda.cabal+ - [#2607](https://github.com/agda/agda/issues/2607): Instance search confused when an instance argument is sourced from a record+ - [#2617](https://github.com/agda/agda/issues/2617): Installation instructions+ - [#2623](https://github.com/agda/agda/issues/2623): Incorrect indentation when \AgdaHide is used+ - [#2634](https://github.com/agda/agda/issues/2634): Fixity declaration ignored in definitions in record+ - [#2636](https://github.com/agda/agda/issues/2636): The positivity checker complains when a new definition is added in the same where clause+ - [#2640](https://github.com/agda/agda/issues/2640): Unifier dots the relevant pattern variables when it should dot the irrelevant ones+ - [#2668](https://github.com/agda/agda/issues/2668): Changing the visibility of a module parameter breaks `with`+ - [#2728](https://github.com/agda/agda/issues/2728): Bad interaction between caching and the warning machinery+ - [#2738](https://github.com/agda/agda/issues/2738): Update Stackage LTS from 9.1 to version supporting Alex 3.2.3+ - [#2744](https://github.com/agda/agda/issues/2744): It should be possible to give arguments to the code environment+ - [#2745](https://github.com/agda/agda/issues/2745): Broken build with GHC 7.8.4 due to (new) version 1.2.2.0 of hashtables+ - [#2749](https://github.com/agda/agda/issues/2749): Add --no-unicode cli option to Agda+ - [#2751](https://github.com/agda/agda/issues/2751): Unsolved constraints, but no highlighting+ - [#2752](https://github.com/agda/agda/issues/2752): Mutual blocks inside instance blocks+ - [#2753](https://github.com/agda/agda/issues/2753): Unsolved constraint, related to instance arguments and sized types+ - [#2756](https://github.com/agda/agda/issues/2756): HTML backend generates broken links+ - [#2758](https://github.com/agda/agda/issues/2758): Relevant meta is instantiated with irrelevant solution+ - [#2759](https://github.com/agda/agda/issues/2759): Empty mutual blocks should be warning rather than error+ - [#2762](https://github.com/agda/agda/issues/2762): Automatically generate DISPLAY pragmas to fold pattern synonyms+ - [#2763](https://github.com/agda/agda/issues/2763): Internal Error at "src/full/Agda/TypeChecking/Abstract.hs:138"+ - [#2765](https://github.com/agda/agda/issues/2765): Inferred level expressions are often "reversed"+ - [#2769](https://github.com/agda/agda/issues/2769): Agda prints ill-formed expression, record argument dropped+ - [#2771](https://github.com/agda/agda/issues/2771): Erroneous 'with' error message+ - [#2773](https://github.com/agda/agda/issues/2773): The nofontsetup option does not work as advertised+ - [#2775](https://github.com/agda/agda/issues/2775): Irrelevance to be taken into account in 'with' abstraction.+ - [#2776](https://github.com/agda/agda/issues/2776): Dotted variable in inferred type+ - [#2780](https://github.com/agda/agda/issues/2780): Improve level constraint solving for groups of inequality constraints+ - [#2782](https://github.com/agda/agda/issues/2782): Extending Agda reflection to introduce postulates+ - [#2785](https://github.com/agda/agda/issues/2785): internal error @ ConcreteToAbstract.hs:721+ - [#2787](https://github.com/agda/agda/issues/2787): Overloaded pattern synonyms+ - [#2792](https://github.com/agda/agda/issues/2792): Safe modules can sometimes not be imported from unsafe modules+ - [#2794](https://github.com/agda/agda/issues/2794): Using \texttt{-} destroys code coloring in literate file+ - [#2796](https://github.com/agda/agda/issues/2796): Overloaded (inherited) projection resolution fails with parametrized record+ - [#2798](https://github.com/agda/agda/issues/2798): The LaTeX backend ignores the "operator" aspect+ - [#2802](https://github.com/agda/agda/issues/2802): Printing of overloaded functions broken due to eager normalization of projections+ - [#2803](https://github.com/agda/agda/issues/2803): Case splitting loses names of hidden arguments+ - [#2808](https://github.com/agda/agda/issues/2808): Confusing error when inserting declaration before top-level module+ - [#2810](https://github.com/agda/agda/issues/2810): Make `--caching` a pragma option+ - [#2811](https://github.com/agda/agda/issues/2811): OPTION --caching allowed in file (Issue #2810)+ - [#2819](https://github.com/agda/agda/issues/2819): Forcing analysis doesn't consider relevance+ - [#2821](https://github.com/agda/agda/issues/2821): BUILTIN BOOL gremlin+ - [#2824](https://github.com/agda/agda/issues/2824): Allow {-# BUILTIN #-} in preamble and in parametrized modules+ - [#2826](https://github.com/agda/agda/issues/2826): Case splitting on earlier variable uses duplicate variable name+ - [#2827](https://github.com/agda/agda/issues/2827): Variables off in with-clauses. Parameter refinement?+ - [#2831](https://github.com/agda/agda/issues/2831): NO_POSITIVITY_CHECK pragma can be written before a mutual block without data or record types+ - [#2832](https://github.com/agda/agda/issues/2832): BUILTIN NIL and CONS are not needed+ - [#2834](https://github.com/agda/agda/issues/2834): Disambiguation of type based on pattern leads to non-unique meta solution+ - [#2836](https://github.com/agda/agda/issues/2836): The Emacs mode does not handle .lagda.tex files+ - [#2840](https://github.com/agda/agda/issues/2840): Internal error in positivity with modules/datatype definitions+ - [#2841](https://github.com/agda/agda/issues/2841): Opting out of idiom brackets+ - [#2844](https://github.com/agda/agda/issues/2844): Root documentation URL redirects to version 2.5.2+ - [#2849](https://github.com/agda/agda/issues/2849): Internal error at absurd pattern followed by `rewrite`+ - [#2854](https://github.com/agda/agda/issues/2854): Agda worries about possibly empty type of sizes even when no builtins for size are active+ - [#2855](https://github.com/agda/agda/issues/2855): Single-clause definition is both unreachable and incomplete+ - [#2856](https://github.com/agda/agda/issues/2856): Panic: unbound variable+ - [#2859](https://github.com/agda/agda/issues/2859): Error "pattern variable shadows constructor" caused by parameter refinement+ - [#2862](https://github.com/agda/agda/issues/2862): inconsistency from a mutual datatype declaration and module definition+ - [#2867](https://github.com/agda/agda/issues/2867): Give does not insert parenthesis for module parameters+ - [#2868](https://github.com/agda/agda/issues/2868): With --postfix-projections, record fields are printed preceded by a dot when working within the record+ - [#2870](https://github.com/agda/agda/issues/2870): Lexical error for \- (hyphen)+ - [#2871](https://github.com/agda/agda/issues/2871): Introduce just trailing hidden arguments by result splitting+ - [#2873](https://github.com/agda/agda/issues/2873): Refinement problem in presence of overloaded constructors+ - [#2874](https://github.com/agda/agda/issues/2874): Internal error in src/full/Agda/TypeChecking/Coverage/Match.hs:312+ - [#2878](https://github.com/agda/agda/issues/2878): Support for GHC 8.4.1+ - [#2879](https://github.com/agda/agda/issues/2879): Include COMPILE GHC pragmas for size primitives+ - [#2881](https://github.com/agda/agda/issues/2881): Internal error in BasicOps+ - [#2883](https://github.com/agda/agda/issues/2883): "internal error in TypeChecking/Substitute.hs:379"+ - [#2884](https://github.com/agda/agda/issues/2884): Missing PDF user manual in the tarball+ - [#2888](https://github.com/agda/agda/issues/2888): Internal error caused by new forcing translation+ - [#2894](https://github.com/agda/agda/issues/2894): Unifier tries to eta expand non-eta record+ - [#2896](https://github.com/agda/agda/issues/2896): Unifier throws away pattern+ - [#2897](https://github.com/agda/agda/issues/2897): Internal error for local modules with refined parameters+ - [#2904](https://github.com/agda/agda/issues/2904): No tab completion for GHCNoMain+ - [#2906](https://github.com/agda/agda/issues/2906): Confusing "cannot be translated to a Haskell type" error message+ - [#2908](https://github.com/agda/agda/issues/2908): primForce is compiled away+ - [#2909](https://github.com/agda/agda/issues/2909): Agda uses newtypes incorrectly, causing wellformed programs to loop+ - [#2911](https://github.com/agda/agda/issues/2911): Inferring missing instance clause panics in refined context+ - [#2912](https://github.com/agda/agda/issues/2912): Add fine-grained control over the displayed warnings+ - [#2914](https://github.com/agda/agda/issues/2914): Slicing ignores as pragma?+ - [#2916](https://github.com/agda/agda/issues/2916): The GHC backend generates code with an incorrect number of constructor arguments+ - [#2917](https://github.com/agda/agda/issues/2917): Very slow due to unsolved size?+ - [#2919](https://github.com/agda/agda/issues/2919): Internal error in Agda.TypeChecking.Forcing+ - [#2921](https://github.com/agda/agda/issues/2921): COMPILE data for data types with erased constructor arguments+ - [#2923](https://github.com/agda/agda/issues/2923): Word.agda not included as builtin+ - [#2925](https://github.com/agda/agda/issues/2925): Allow adding the same rewrite rules multiple times+ - [#2927](https://github.com/agda/agda/issues/2927): Panic related to sized types+ - [#2928](https://github.com/agda/agda/issues/2928): Internal error in Agda.TypeChecking.Rules.LHS+ - [#2931](https://github.com/agda/agda/issues/2931): Rename Agda.Builtin.Size.ω to ∞?+ - [#2941](https://github.com/agda/agda/issues/2941): "coinductive" record inconsistent+ - [#2944](https://github.com/agda/agda/issues/2944): Regression, seemingly related to record expressions+ - [#2945](https://github.com/agda/agda/issues/2945): Inversion warning in code that used to be accepted+ - [#2947](https://github.com/agda/agda/issues/2947): Internal error in Agda.TypeChecking.Forcing+ - [#2952](https://github.com/agda/agda/issues/2952): Wrong compilation of pattern matching to Haskell+ - [#2953](https://github.com/agda/agda/issues/2953): Generated Haskell code does not typecheck+ - [#2954](https://github.com/agda/agda/issues/2954): Pattern matching on string gives unexpected unreachable clause+ - [#2957](https://github.com/agda/agda/issues/2957): Support for async 2.2.1+ - [#2958](https://github.com/agda/agda/issues/2958): `as` names being duplicated in buffer after `with`+ - [#2959](https://github.com/agda/agda/issues/2959): Repeating a successful command after revert + reload fails with caching enabled+ - [#2960](https://github.com/agda/agda/issues/2960): Uncommenting indented lines doesn't work+ - [#2963](https://github.com/agda/agda/issues/2963): Extended lambdas bypass positivity checking in records+ - [#2966](https://github.com/agda/agda/issues/2966): Internal error in Auto+ - [#2968](https://github.com/agda/agda/issues/2968): Bad Interaction with copatterns and eta?, leads to ill-typed terms in error messages.+ - [#2971](https://github.com/agda/agda/issues/2971): Copattern split with `--no-irrelevant-projections` panics+ - [#2974](https://github.com/agda/agda/issues/2974): Copatterns break canonicity+ - [#2975](https://github.com/agda/agda/issues/2975): Termination checker runs too early for definitions inside record (or: positivity checker runs too late)+ - [#2976](https://github.com/agda/agda/issues/2976): Emacs mode reports errors in connection with highlighting comments+ - [#2978](https://github.com/agda/agda/issues/2978): Double solving of meta+ - [#2985](https://github.com/agda/agda/issues/2985): The termination checker accepts non-terminating code+ - [#2989](https://github.com/agda/agda/issues/2989): Internal error when checking record match in let expr+ - [#2990](https://github.com/agda/agda/issues/2990): Performance regression related to the abstract machine+ - [#2994](https://github.com/agda/agda/issues/2994): Solution accepted in hole is subsequently rejected on reload+ - [#2996](https://github.com/agda/agda/issues/2996): Internal error with -v tc.cover:20+ - [#2997](https://github.com/agda/agda/issues/2997): Internal error in Agda.TypeChecking.Rules.LHS+ - [#2998](https://github.com/agda/agda/issues/2998): Regression: With clause pattern x is not an instance of its parent pattern "eta expansion of x"+ - [#3002](https://github.com/agda/agda/issues/3002): Spurious 1 after simplification+ - [#3004](https://github.com/agda/agda/issues/3004): Agda hangs on extended lambda+ - [#3007](https://github.com/agda/agda/issues/3007): Internal error in Parser+ - [#3012](https://github.com/agda/agda/issues/3012): Internal Error at : "src/full/Agda/TypeChecking/Reduce/Fast.hs:1030"+ - [#3014](https://github.com/agda/agda/issues/3014): Internal error in Rules.LHS+ - [#3020](https://github.com/agda/agda/issues/3020): Missing highlighting in record modules+ - [#3023](https://github.com/agda/agda/issues/3023): Support for GHC 8.4.2+ - [#3024](https://github.com/agda/agda/issues/3024): Postfix projection patterns not highlighted correctly with agda --latex+ - [#3030](https://github.com/agda/agda/issues/3030): [ warning ] user defined warnings+ - [#3031](https://github.com/agda/agda/issues/3031): Eta failure for record meta with irrelevant fields+ - [#3033](https://github.com/agda/agda/issues/3033): Giving and solving don't insert parenthesis for applications in dot pattern+ - [#3044](https://github.com/agda/agda/issues/3044): Internal error in src/full/Agda/TypeChecking/Substitute/Class.hs:209+ - [#3045](https://github.com/agda/agda/issues/3045): GHC backend generates type without enough arguments+ - [#3046](https://github.com/agda/agda/issues/3046): do-notation causes parse errors in subsequent where clauses+ - [#3049](https://github.com/agda/agda/issues/3049): Positivity unsoundness+ - [#3050](https://github.com/agda/agda/issues/3050): We revert back to call-by-name during positivity checking+ - [#3051](https://github.com/agda/agda/issues/3051): Pattern synonyms should be allowed in mutual blocks+ - [#3052](https://github.com/agda/agda/issues/3052): Another recent inference change+ - [#3062](https://github.com/agda/agda/issues/3062): Literal match does not respect first-match semantics+ - [#3063](https://github.com/agda/agda/issues/3063): Internal error in Agda.TypeChecking.Forcing+ - [#3064](https://github.com/agda/agda/issues/3064): Coverage checker bogus on literals combined with copatterns+ - [#3065](https://github.com/agda/agda/issues/3065): Internal error in coverage checker triggered by literal dot pattern+ - [#3067](https://github.com/agda/agda/issues/3067): checking hangs on invalid program+ - [#3072](https://github.com/agda/agda/issues/3072): invalid section printing+ - [#3074](https://github.com/agda/agda/issues/3074): Wrong hiding causes internal error in LHS checker+ - [#3075](https://github.com/agda/agda/issues/3075): Automatic inlining and tactics+ - [#3078](https://github.com/agda/agda/issues/3078): Error building with GHC 7.10.2: Missing transformers library+ - [#3079](https://github.com/agda/agda/issues/3079): Wrong parameter hiding for instance open+ - [#3080](https://github.com/agda/agda/issues/3080): Case splitting prints out-of-scope pattern synonyms+ - [#3082](https://github.com/agda/agda/issues/3082): Emacs mode regression: a ? inserted before existing hole hijacks its interaction point+ - [#3083](https://github.com/agda/agda/issues/3083): Wrong hiding in module application+ - [#3084](https://github.com/agda/agda/issues/3084): Changes to mode line do not take effect immediately+ - [#3085](https://github.com/agda/agda/issues/3085): Postpone checking a pattern let binding when type is blocked+ - [#3090](https://github.com/agda/agda/issues/3090): Internal error in parser when using parentheses in BUILTIN pragma+ - [#3096](https://github.com/agda/agda/issues/3096): Support GHC 8.4.3
@@ -0,0 +1,22 @@+Release notes for Agda version 2.6.0.1+======================================++Installation and infrastructure+-------------------------------++* Added support for GHC 8.6.5.++List of all closed issues+-------------------------++For 2.6.0.1, the following issues have been closed+(see [bug tracker](https://github.com/agda/agda/issues)):++ - [#3685](https://github.com/agda/agda/issues/3685): Support GHC 8.6.5+ - [#3692](https://github.com/agda/agda/issues/3692): Omission of absurd patterns in automatically added absurd clauses causes too optimistic polarity.+ - [#3694](https://github.com/agda/agda/issues/3694): Importing Agda.Builtin.Size in one module affects another module+ - [#3696](https://github.com/agda/agda/issues/3696): Make `AgdaAny` polykinded?+ - [#3697](https://github.com/agda/agda/issues/3697): Panic when checking non-Setω data definitions with --type-in-type+ - [#3701](https://github.com/agda/agda/issues/3701): [ re agda/agda-stdlib#710 ] toNat for machine words is injective+ - [#3731](https://github.com/agda/agda/issues/3731): GHC backend thinks that a constructor called 'main' is the main program+ - [#3742](https://github.com/agda/agda/issues/3742): Strange error message for code that combines mutual and abstract
@@ -0,0 +1,849 @@+Release notes for Agda version 2.6.0+====================================++Highlights+----------++* Added support for [Cubical+ Agda](https://agda.readthedocs.io/en/v2.6.0/language/cubical.html)+ which adds new features such as univalence and higher inductive+ types to Agda.++* Added support for ML-style [automatic generalization of+ variables](https://agda.readthedocs.io/en/v2.6.0/language/generalization-of-declared-variables.html).++* Added a new sort ``Prop`` of [definitionally proof-irrelevant+ propositions](https://agda.readthedocs.io/en/v2.6.0/language/prop.html).++* The implementation of [instance+ search](https://agda.readthedocs.io/en/v2.6.0/language/instance-arguments.html)+ got a major overhaul and no longer supports overlapping instances+ (unless enabled by a flag).++Installation and infrastructure+-------------------------------++* Added support for GHC 8.6.4.++* Interface files for all builtin and primitive files are now+ re-generated each time Agda is installed.++Syntax+------++* Agda now supports implicit generalization of declared+ variables. Variables to be generalized can declared with the new+ keyword `variable`. For example:++ ```agda+ postulate+ Con : Set++ variable+ Γ Δ θ : Con+ ```++ Declared variables are automatically generalized in type signatures,+ module telescopes and data type and record parameters and indices:++ ```agda+ postulate+ Sub : Con → Con → Set++ id : Sub Γ Γ+ -- -- equivalent to+ -- id : {Γ : Con} → Sub Γ Γ++ _∘_ : Sub Θ Δ → Sub Γ Θ → Sub Γ Δ+ -- -- equivalent to+ -- _∘_ : {Γ Δ Θ : Con} → Sub Θ Δ → Sub Γ Θ → Sub Γ Δ+ ```++ See the [user manual](https://agda.readthedocs.io/en/v2.6.0/language/generalization-of-declared-variables.html)+ for more details.++* Data type and record definitions separated from their type signatures can no+ longer repeat the types of the parameters, but can bind implicit parameters+ by name [Issue [#1886](https://github.com/agda/agda/issues/1886)].++ This is now allowed+ ```agda+ data D {a b} (A : Set a) (B : Set b) : Set (a ⊔ lsuc b)+ data D {b = b} A B where+ mkD : (A → Set b) → D A B+ ```+ but this is not+ ```agda+ data I (A : Set) : Set+ data I (A : Set) where+ ```++* The label used for named implicit arguments can now be different from the+ name of the bound variable [Issue [#952](https://github.com/agda/agda/issues/952)].++ Example,+ ```agda+ id₁ : {A = X : Set} → X → X+ id₁ x = x++ id₂ : ∀ {B = X} → X → X+ id₂ {B = X} x = id₁ {A = X} x++ test : Nat+ test = id₁ {A = Nat} 5 + id₂ {B = Nat} 6+ ```+ Only implicit and instance arguments can have a label and either or both of+ the label and bound variable can be `_`. Labeled bindings with a type+ signature can only bind a single variable. For instance, the type `Set` has+ to be repeated here:+ ```agda+ const : {A = X : Set} {B = Y : Set} → X → Y → X+ const x _ = x+ ```++* The rules for parsing of patterns have changed slightly [Issue+ [#3400](https://github.com/agda/agda/issues/3400)].++ Now projections are treated similarly to constructors: In a pattern+ name parts coming from projections can only be used as part of+ projections, constructors or pattern synonyms. They cannot be used+ as variables, or as part of the name of the defined value.++ Examples:++ * The following code used to be syntactically ambiguous, but is now+ parsed, because A can no longer be used as a variable:+ ```agda+ record R : Set₂ where+ field+ _A : Set₁++ open R++ r : R+ r A = Set+ ```++ * On the other hand the following code is no longer parsed:+ ```agda+ record R : Set₁ where+ field+ ⟨_+_⟩ : Set++ open R++ + : Set → Set+ + A = A+ ```+++Type checking+-------------++* Agda now supports a cubical mode which adds new features from+ [Cubical Type Theory](https://arxiv.org/abs/1611.02108), including+ univalence and higher inductive types. Option `--cubical` enables+ the cubical mode, and cubical primitives are defined in the module+ `Agda.Primitive.Cubical`. See the [user+ manual](https://agda.readthedocs.io/en/v2.6.0/language/cubical.html)+ for more info.++* Agda now supports the new sort ``Prop`` of [definitionally+ proof-irrelevant propositions](https://hal.inria.fr/hal-01859964).+ Option `--prop` enables the `Prop` universe but is off by default.+ Option `--no-prop` disables the `Prop` universe. See the [user+ manual](https://agda.readthedocs.io/en/v2.6.0/language/prop.html)+ for more details.++ In the absense of `Prop`, the sort `Set` is the lowest sort, thus,+ the sort annotation `: Set` can be ommitted if the sort is+ constrained to be weakly below `Set`. For instance:++ ```agda+ {-# OPTIONS --no-prop #-}++ data Wrap A : Set where+ wrap : A → Wrap A+ ```++ In contrast, when `--prop` is enabled the sort of `A` could be+ either `Set` or `Prop` so this code no longer typechecks.++* Agda now allows omitting absurd clauses in case one of the pattern+ variable inhabits an obviously empty type+ [Issue [#1086](https://github.com/agda/agda/issues/1086)].+ For example:+ ```agda+ f : Fin 1 → Nat+ f zero = 0+ -- f (suc ()) -- this clause is no longer required+ ```+ Absurd clauses are still required in case deep pattern matching is+ needed to expose the absurd variable, or if there are no non-absurd+ clauses.++ Due to the changes to the coverage checker required for this new+ feature, Agda will now sometimes construct a different case tree when+ there are multiple valid splitting orders. In some cases this may+ impact the constraints that Agda is able to solve (for example, see+ [#673](https://github.com/agda/agda-stdlib/pull/673) on the+ standard library).++* Since Agda 2.5.3, the hiding is considered part of the name in the+ insertion of implicit arguments. Until Agda 2.5.2, the following+ code was rejected:+ ```agda+ test : {{X : Set}} {X : Set} → Set+ test {X = X} = X+ ```+ The rationale was that named argument `X` is given with the wrong hiding.+ The new rationale is that the hiding is considered part of the name,+ distinguishing `{{X}}` from `{X}`.+ This language change was accidential and has not been documented in+ the 2.5.3 release notes.++* Agda no longer allows case splitting on irrelevant arguments of+ record types (see Issue+ [#3056](https://github.com/agda/agda/issues/3056)).++* Metavariables in module telescopes are now sometimes frozen later+ [Issue [#1063](https://github.com/agda/agda/issues/1063)].++ Metavariables created in the types of module parameters used to be+ frozen right after the module's first mutual block had been+ type-checked (unless, perhaps, if the module itself was contained in+ a mutual block). Now they are instead frozen at the end of the+ module (with a similar caveat regarding an outer mutual block).++* When `--without-K` is enabled, Agda no longer allows datatypes with+ large indices. For example, the following definition of equality is+ now forbidden when `--without-K` is enabled:+ ```agda+ data _≡₀_ {ℓ} {A : Set ℓ} (x : A) : A → Set where+ refl : x ≡₀ x+ ```++* The termination checker now also looks for recursive calls in the type of definitions.+ This fixes an issue where Agda allowed very dependent types+ [Issue [#1556](https://github.com/agda/agda/issues/1556)].++ This change affects induction-induction, e.g.+ ```agda+ mutual+ data Cxt : Set where+ ε : Cxt+ _,_ : (Γ : Cxt) (A : Ty Γ) → Cxt++ data Ty : (Γ : Cxt) → Set where+ u : ∀ Γ → Ty Γ+ Π : ∀ Γ (A : Ty Γ) (B : Ty (Γ , A)) → Ty Γ++ mutual+ f : Cxt → Cxt+ f ε = ε+ f (Γ , T) = (f Γ , g Γ T)++ g : ∀ Γ → Ty Γ → Ty (f Γ)+ g Γ (u .Γ) = u (f Γ)+ g Γ (Π .Γ A B) = Π (f Γ) (g Γ A) (g (Γ , A) B)++ ```+ The type of `g` contains a call `g Γ _ --> f Γ` which is now taken+ into account during termination checking.++Instance search+---------------++* Instance argument resolution now also applies when there are+ unconstrained metavariables in the type of the argument. For+ example, if there is a single instance `eqBool : Eq Bool` in scope,+ then an instance argument `{{eq : Eq _}}` will be solved to+ `eqBool`, setting the value of the metavariable `_` to `Bool` in the+ process.++* By default, Agda no longer allows overlapping instances. Two+ instances are defined to overlap if they could both solve the+ instance goal when given appropriate solutions for their recursive+ (instance) arguments. Agda used to choose between undecidable+ instances based on the result of recursive instance search, but this+ lead to an exponential slowdown in instance resolution. Overlapping+ instances can be enabled with the flag `--overlapping-instances`.++* Explicit arguments are no longer automatically turned into instance+ arguments for the purpose of recursive instance search. Instead,+ explicit arguments are left unresolved and will thus never be used+ for instance search.++ If an instance is declared which has explicit arguments, Agda will+ raise a warning that this instance will never be considered by+ instance search.++* Instance arguments that are already solved by conversion checking+ are no longer ignored by instance search. Thus the constructor of+ the unit type must now be explicitly be declared as an instance in+ order to be considered by instance search:+ ```agda+ record ⊤ : Set where+ instance constructor tt+ ```++* Instances are now (correctly) required to be in scope to be eligible+ (see Issue [#1913](https://github.com/agda/agda/issues/1913)+ and Issue [#2489](https://github.com/agda/agda/issues/2489)+ ).+ This means that you can no longer import instances from parameterised modules by+ ```agda+ import Some.Module Arg₁ Arg2+ ```+ without opening or naming the module.++Reflection+----------++* New TC primitive `noConstraints` [Issue+ [#2351](https://github.com/agda/agda/issues/2351)]:++ ```agda+ noConstraints : ∀ {a} {A : Set a} → TC A → TC A+ ```++ The computation `noConstraints m` fails if `m` gives rise to new,+ unsolved+ ["blocking"](https://github.com/agda/agda/blob/4900ef5fc61776381f3a5e9c94ef776375e9e1f1/src/full/Agda/TypeChecking/Monad/Constraints.hs#L160-L174)+ constraints.++* New TC primitive `runSpeculative` [Issue+ [#3346](https://github.com/agda/agda/issues/3346)]:++ ```+ runSpeculative : ∀ {a} {A : Set a} → TC (Σ A λ _ → Bool) → TC A+ ```++ The computation `runSpeculative m` runs `m` and either keeps the new+ TC state (if the second component is `true`) or resets to the old TC+ state (if it is `false`).+++Interaction and error reporting+-------------------------------++* A new command `agda2-elaborate-give` (C-c C-m) normalizes a goal input+ (it respects the C-u prefixes), type checks, and inserts the normalized+ term into the goal.++* 'Solve constraints' (C-c C-s) now turns unsolved metavariables into new+ interaction holes (see Issue [#2273](https://github.com/agda/agda/issues/2273)).++* Out-of-scope identifiers are no longer prefixed by a '.' dot [Issue+ [#3127](https://github.com/agda/agda/issues/3127)]. This notation+ could be confused with dot patterns, postfix projections, and+ irrelevance. Now Agda will do its best to make up fresh names for+ out-of-scope identifiers that do not conflict with any existing+ names. In addition, these names are marked as "(out of scope)" when+ printing the context.++ The change affects the printing of terms, e.g. in error messages and+ interaction, and the parsing of out-of-scope variables for+ case splitting (`C-c C-c` in emacs).++* Shadowed local variables are now assigned fresh names in error+ messages and interactive goals [Issue+ [#572](https://github.com/agda/agda/issues/572)]. For example,+ consider the following piece of code:+ ```agda+ postulate P : Set -> Set++ test : (B : Set) -> P B -> P B+ test = λ p p -> {!!}+ ```+ When asking for the goal type, Agda will now print the following:+ ```+ Goal: P p₁+ ————————————————————————————————————————————————————————————+ p : P p₁+ p = p₁ : Set (not in scope)+ ```+ Shadowed top-level identifiers are printed using the qualified name,+ for example in+ ```agda+ module M where++ postulate A : Set++ test : Set → A+ test A = {!!}+ ```+ Agda will now show the goal type as+ ```+ Goal: M.A+ ————————————————————————————————————————————————————————————+ A : Set+ ```++* When case splitting (`C-c C-c` in emacs), Agda will now filter out+ impossible cases (i.e. ones where at least one of the variables+ could be replaced by an absurd pattern `()`). If all the clauses+ produced by a case split are impossible, Agda will not filter out+ any of them.++Pragmas and options+-------------------++* Consistency checking of options used.++ Agda now checks that options used in imported modules are consistent+ with each other, e.g. a module using `--safe`, `--without-K`,+ `--no-universe-polymorphism` or `--no-sized-types` may only import+ modules with the same option, and modules using `--cubical` or+ `--prop` must in turn use the same option. If an interface file has+ been generated using different options compared to the current ones,+ Agda will now re-typecheck the file.+ [Issue [#2487](https://github.com/agda/agda/issues/2487)].++* New option `--cubical` to enable Cubical Agda.++* New option `--prop` to enable the ``Prop`` sort, and `--no-prop` to+ disable it (default).++* New options `--guardedness` and `--no-guardedness` [Issue+ [#1209](https://github.com/agda/agda/issues/1209)].++ Constructor-based guarded corecursion is now only (meant to be)+ allowed if the `--guardedness` option is active. This option is+ active by default. The combination of constructor-based guarded+ corecursion and sized types is not allowed if `--safe` is used,+ and activating `--safe` turns off both `--guardedness` and+ `--sized-types` (because this combination is known to be+ inconsistent in the current implementation). If you want to use+ either constructor-based guarded corecursion or sized types in+ safe mode, then you can use `--safe --guardedness` or `--safe+ --sized-types` respectively (in this order).++ The option `--no-guardedness` turns off constructor-based guarded+ corecursion.++* Option `--irrelevant-projections` is now off by default and+ not considered `--safe` any longer.+ Reason: There are consistency issues that may be systemic+ [Issue [#2170](https://github.com/agda/agda/issues/2170)].++* New option `--no-syntactic-equality` disables the syntactic equality+ shortcut used by the conversion checker. This will slow down+ typechecking in most cases, but makes the performance more+ predictable and stable under minor changes.++* New option `--overlapping-instances` enables overlapping instances+ by performing recursive instance search during pruning of instance+ candidates (this used to be the default behaviour). Overlapping+ instances can be disabled with `--no-overlapping-instances`+ (default).++* Option (and experimental feature)+ `--guardedness-preserving-type-constructors`+ has been removed.+ [Issue [#3180](https://github.com/agda/agda/issues/3180)].++* Deprecated options `--sharing` and `--no-sharing` now raise an error.++* New primitive `primErase`. It takes a proof of equality and returns a proof of+ the same equality. `primErase eq` reduces to `refl` on the diagonal. `trustMe`+ is not a primitive anymore, it is implemented using `primErase`.++ The primitive is declared in `Agda.Builtin.Equality.Erase`.++* The `REWRITE` builtin is now bound to the builtin equality type from+ `Agda.Builtin.Equality` in `Agda.Builtin.Equality.Rewrite` [Issue+ [#3318](https://github.com/agda/agda/issues/3318)].++* New primitives `primCharToNatInjective` and `primStringToListInjective`+ internalising the fact that `primCharToNat` and `primStringtoList` are+ injective functions. They are respectively bound in `Agda.Builtin.Char.Properties`+ and `Agda.Builtin.String.Properties`.++* The option `--only-scope-checking` is now allowed together with `--safe`.++* The option `--ignore-interfaces` no longer ignores the interfaces of+ builtin and primitive modules. For experts, there is the option+ `--ignore-all-interfaces` which also rechecks builtin and primitive+ files.++* The following deprecated compiler pragmas have been removed:++ ```+ {-# COMPILED f e #-}+ {-# COMPILED_TYPE A T #-}+ {-# COMPILED_DATA A D C1 .. CN #-}+ {-# COMPILED_DECLARE_DATA #-}+ {-# COMPILED_EXPORT f g #-}+ {-# IMPORT M #-}+ {-# HASKELL code #-}+ {-# COMPILED_UHC f e #-}+ {-# COMPILED_DATA_UHC A D C1 .. CN #-}+ {-# IMPORT_UHC M #-}+ {-# COMPILED_JS f e #-}+ ```++ See the [user manual](https://agda.readthedocs.io/en/v2.6.0/language/foreign-function-interface.html)+ for how to use the `COMPILE` and `FOREIGN` pragmas that replaced these in Agda 2.5.++### New warnings++* A declaration of the form `f : A` without an accompanying definition+ is no longer an error, but instead raises a warning.++* A clause that has both an absurd pattern and a right-hand side is no+ longer an error, but instead raises a warning.++* An import statement for `M` that mentions names not exported by `M`+ (in either `using`, `hiding`, or `renaming`) is no longer an+ error. Instead, Agda will raise a warning and ignore the names.++* Pragma, primitive, module or import statements in a mutual block+ are no longer errors. Instead, Agda will raise a warning and ignore+ these statements.++### Pragmas and options concerning universes++* New pragma `{-# NO_UNIVERSE_CHECK #-}`.++ The pragma `{-# NO_UNIVERSE_CHECK #-}` can be put in front of a data+ or record type to disable universe consistency checking locally.+ Example:+ ```agda+ {-# NO_UNIVERSE_CHECK #-}+ data U : Set where+ el : Set → U+ ```+ Like the similar pragmas for disabling termination and positivity+ checking, `{-# NO_UNIVERSE_CHECK #-}` cannot be used with `--safe`.++* New builtin `SETOMEGA`.++ Agda's top sort `Setω` is now defined as a builtin in `Agda.Primitive`+ and can be renamed when importing that module.++* New option `--omega-in-omega`.++ The option `--omega-in-omega` enables the typing rule `Setω : Setω`.+ Example:+ ```agda+ {-# OPTIONS --omega-in-omega #-}+ open import Agda.Primitive++ data Type : Setω where+ el : ∀ {ℓ} → Set ℓ → Type+ ```+ Like `--type-in-type`, this makes Agda inconsistent. However, code+ written using `--omega-in-omega` is still compatible with normal+ universe-polymorphic code and can be used in such files.++Emacs mode+----------++* Jump-to-definition now works for record field names in record expressions+ and patterns. [Issue [#3120](https://github.com/agda/agda/issues/3120)]+ ```agda+ record R : Set₂ where+ field f : Set₁++ exp : R+ exp = record { f = Set }++ pat : R → R+ pat r@record { f = X } = record r { f = X }+ ```+ Jump-to-definition (`M-.` or middle-click) on any of these `f`s+ now jumps to the field declaration.++* Commas "ʻ،⸲⸴⹁⹉、︐︑﹐﹑,、" and semi-colons "؛⁏፤꛶;︔﹔⍮⸵;" added+ to the input mode.++* It is now possible to customise the highlighting of more text in+ pragmas [Issue [#2452](https://github.com/agda/agda/issues/2452)].++ Some text was already highlighted. Now there is a specific face for+ the remaining text (`agda2-highlight-pragma-face`).++LaTeX backend+-------------++* The code environment has two new options, `inline` and `inline*`.++ These options are for typesetting inline code. The implementation of+ these options is a bit of a hack. Only use these options for+ typesetting a single line of code without multiple consecutive+ whitespace characters (except at the beginning of the line).++ When the option `inline*` is used space (`\AgdaSpace{}`) is added at+ the end of the code, and when `inline` is used space is not added.++* Now highlighting commands for things like "this is an unsolved+ meta-variable" are applied on the outside of highlighting commands+ for things like "this is a postulate" [Issue+ [#2474](https://github.com/agda/agda/issues/2474)].++ Example: Instead of generating+ `\AgdaPostulate{\AgdaUnsolvedMeta{F}}` Agda now generates+ `\AgdaUnsolvedMeta{\AgdaPostulate{F}}`.++* The package `agda.sty` no longer selects any fonts, and no longer+ changes the input or font encodings [Issue+ [#3224](https://github.com/agda/agda/issues/3224)].++ The new behaviour is the same as the old behaviour with the options+ `nofontsetup` and `noinputencodingsetup`. These options have been+ removed.++ One reason for this change is that several persons have received+ complaints from reviewers because they have unwittingly used+ non-standard fonts in submitted papers. Another is that the `utf8x`+ option to `inputenc` is now deprecated.++ Note that Agda code is now less likely to typeset properly out of+ the box. See the documentation for some hints about what to do if+ this affects you.++* Some text was by default typeset in math mode when LuaLaTeX or+ XeLaTeX were used, and in text mode when pdfLaTeX was used. Now text+ mode is the default for all of these engines.++* Typesetting of pragmas should now work better [Issue+ [#2452](https://github.com/agda/agda/issues/2452)].++ The `\AgdaOption` command and `AgdaOption` colour have been replaced+ by `\AgdaPragma` and `AgdaPragma`. The `\AgdaPragma` command is used+ where `\AgdaOption` used to be used (for certain options), but also+ in other cases (for other options and certain other text in+ pragmas).++* There is no longer any special treatment of the character `-` [Issue+ [#2452](https://github.com/agda/agda/issues/2452)].++ This might, depending on things like what font your are using, mean+ that the token `--` is typeset like an en dash (–). However, this is+ not the case for at least one common monospace font (in at least one+ setting).++* The default value of `\AgdaEmptySkip` has been changed from+ `\baselineskip` to `\abovedisplayskip`. This could mean that less+ vertical space is used to render empty lines in code blocks.++HTML backend+------------++* New option `--html-highlight=[code,all,auto]`.++ The option `--html-highlight=code` makes the HTML-backend generate+ files with:++ 0. No HTML footer/header+ 1. Agda codes highlighted+ 2. Non-Agda code parts as-is+ 3. Output file extension as-is (i.e. `.lagda.md` becomes `.md`)+ 4. For ReStructuredText, a `.. raw:: html\n` will be inserted+ before every code blocks++ This makes it possible to use an ordinary Markdown/ReStructuredText+ processor to render the generated HTML.++ This will affect all the files involved in one compilation, making+ pure Agda code files rendered without HTML footer/header as well.+ To use `code` with literate Agda files and `all` with pure Agda+ files, use `--html-highlight=auto`, which means auto-detection.++ The old and default behaviour is still `--html-highlight=all`.++List of all closed issues+-------------------------++For 2.6.0, the following issues have been closed+(see [bug tracker](https://github.com/agda/agda/issues)):++ - [#572](https://github.com/agda/agda/issues/572): Shadowed identifiers should be preceded by a dot when printed+ - [#723](https://github.com/agda/agda/issues/723): Instance search needs to know whether a meta must be a function type+ - [#758](https://github.com/agda/agda/issues/758): No highlighting for syntax declarations+ - [#887](https://github.com/agda/agda/issues/887): Case-split causes problems for coverage checker+ - [#952](https://github.com/agda/agda/issues/952): Parse named implicit pi {x = y : A} -> B+ - [#1003](https://github.com/agda/agda/issues/1003): No highlighting for ambiguous instance argument+ - [#1063](https://github.com/agda/agda/issues/1063): Freeze metas in module telescope after checking the module?+ - [#1086](https://github.com/agda/agda/issues/1086): Make absurd patterns not needed at toplevel+ - [#1209](https://github.com/agda/agda/issues/1209): Guardedness checker inconsistency with copatterns+ - [#1581](https://github.com/agda/agda/issues/1581): Fields of opened records sometimes highlighted, sometimes not+ - [#1602](https://github.com/agda/agda/issues/1602): NonStrict arguments should be allowed to occur relevantly in the type+ - [#1706](https://github.com/agda/agda/issues/1706): Feature request: ML-style forall-generalization+ - [#1764](https://github.com/agda/agda/issues/1764): Type in type and universe polymorphism+ - [#1886](https://github.com/agda/agda/issues/1886): Second copies of telescopes not checked?+ - [#1909](https://github.com/agda/agda/issues/1909): parameters are not dropped from reflected pattern lambda+ - [#1913](https://github.com/agda/agda/issues/1913): Names that are not in scope can sometimes be candidates for instance resolution+ - [#1995](https://github.com/agda/agda/issues/1995): Correct names in goal types after multiple renaming imports.+ - [#2044](https://github.com/agda/agda/issues/2044): Better diagnosis for failed instance search+ - [#2089](https://github.com/agda/agda/issues/2089): ''No such module'' is a rude error message for private modules+ - [#2153](https://github.com/agda/agda/issues/2153): PDF version of Language Documentation on readthedocs lacks most Unicode characters+ - [#2273](https://github.com/agda/agda/issues/2273): C-c C-s should put new goals instead of underscores for unknown subterms+ - [#2351](https://github.com/agda/agda/issues/2351): expose noConstraints to reflection framework+ - [#2452](https://github.com/agda/agda/issues/2452): The LaTeX backend does not handle options very well+ - [#2473](https://github.com/agda/agda/issues/2473): Don't reread the source code without checking that it is unchanged+ - [#2487](https://github.com/agda/agda/issues/2487): Options used for different modules must be consistent with each other, and options used when loading an interface must be consistent with those used when the interface was created+ - [#2489](https://github.com/agda/agda/issues/2489): Where clauses in functions leak instances to global instance search+ - [#2490](https://github.com/agda/agda/issues/2490): possible non-terminating inference of instance arguments?+ - [#2513](https://github.com/agda/agda/issues/2513): Extensible syntax for function space annotations+ - [#2548](https://github.com/agda/agda/issues/2548): Move the "Old Reference Manual" to the current documentation+ - [#2563](https://github.com/agda/agda/issues/2563): Improve documentation and error reporting related to instance resolution (especially unconstrained metavariables)+ - [#2579](https://github.com/agda/agda/issues/2579): Import statements with module instantiation should not trigger an error message+ - [#2618](https://github.com/agda/agda/issues/2618): Reflection and pattern-matching lambdas+ - [#2670](https://github.com/agda/agda/issues/2670): Instance arguments and multi-sorted algebras+ - [#2757](https://github.com/agda/agda/issues/2757): Proposal: split non-strict relevance into shape-irrelevance, parametricity, and runtime-irrelevance+ - [#2760](https://github.com/agda/agda/issues/2760): Relax instance search restriction on unconstrained metas+ - [#2774](https://github.com/agda/agda/issues/2774): Internal error with sized types+ - [#2783](https://github.com/agda/agda/issues/2783): Make more primitive/builtin modules safe?+ - [#2789](https://github.com/agda/agda/issues/2789): Narrow and broad options+ - [#2791](https://github.com/agda/agda/issues/2791): More illtyped meta solutions+ - [#2797](https://github.com/agda/agda/issues/2797): Relevance check missed for overloaded projection+ - [#2833](https://github.com/agda/agda/issues/2833): Coverage checker splits on result too eagerly+ - [#2837](https://github.com/agda/agda/issues/2837): The Emacs mode only handles LaTeX-based literate Agda+ - [#2872](https://github.com/agda/agda/issues/2872): Case splitting adds a dot in front of pattern matches on Chars+ - [#2880](https://github.com/agda/agda/issues/2880): Disallow FFI binding for defined functions when --safe is used+ - [#2892](https://github.com/agda/agda/issues/2892): 'With' should also abstract over the type of stripped dot patterns+ - [#2893](https://github.com/agda/agda/issues/2893): Display warnings also when an error is encountered+ - [#2899](https://github.com/agda/agda/issues/2899): Add a warning for infix notations without corresponding fixity declaration+ - [#2929](https://github.com/agda/agda/issues/2929): Turn "missing definition" into a warning+ - [#2936](https://github.com/agda/agda/issues/2936): Sort warning flags alphabetically in user manual+ - [#2939](https://github.com/agda/agda/issues/2939): make install-bin on a Mac can fail to install text-icu+ - [#2964](https://github.com/agda/agda/issues/2964): Mismatch between order of matching in clauses and case tree; subject reduction broken+ - [#2969](https://github.com/agda/agda/issues/2969): Module parameter is erased from dot pattern+ - [#2979](https://github.com/agda/agda/issues/2979): Rewriting matching does not respect eta rules+ - [#2993](https://github.com/agda/agda/issues/2993): Quadratic (failing) instance search+ - [#3010](https://github.com/agda/agda/issues/3010): Field of opened record does not get highlighted+ - [#3032](https://github.com/agda/agda/issues/3032): spurious meta in dot pattern+ - [#3056](https://github.com/agda/agda/issues/3056): Matching on irrelevant variable of dependent record type should not be allowed+ - [#3057](https://github.com/agda/agda/issues/3057): A module can export two definitions with the same name+ - [#3068](https://github.com/agda/agda/issues/3068): Add option to turn off syntactic equality check+ - [#3095](https://github.com/agda/agda/issues/3095): Would like to make hidden variable visible but it is created ambiguous+ - [#3102](https://github.com/agda/agda/issues/3102): Performance regression: very slow reduction in the presence of many module parameters+ - [#3114](https://github.com/agda/agda/issues/3114): Missing alpha-renaming when printing constraints+ - [#3120](https://github.com/agda/agda/issues/3120): No tooltips for record field names in record expressions+ - [#3122](https://github.com/agda/agda/issues/3122): Hidden record fields are not picked up from module in record expression+ - [#3124](https://github.com/agda/agda/issues/3124): De Bruijn index in lhs checking error message+ - [#3125](https://github.com/agda/agda/issues/3125): Internal error in InstanceArguments.hs:292+ - [#3127](https://github.com/agda/agda/issues/3127): Notation for out-of-scope variables conflicts with notation for irrelevance+ - [#3128](https://github.com/agda/agda/issues/3128): Sigma builtin not added to setup, agdai file missing.+ - [#3130](https://github.com/agda/agda/issues/3130): Conflict between dot pattern and postfix projection+ - [#3137](https://github.com/agda/agda/issues/3137): Preserve Markdown as-is when outputting HTML+ - [#3138](https://github.com/agda/agda/issues/3138): Result splitter introduces pattern variable that conflicts with constructor+ - [#3139](https://github.com/agda/agda/issues/3139): Internal error in parser+ - [#3147](https://github.com/agda/agda/issues/3147): Non-linear as-patterns+ - [#3152](https://github.com/agda/agda/issues/3152): `give` in a do-block inserts spurious parentheses+ - [#3153](https://github.com/agda/agda/issues/3153): Type checker fails to infer missing signature of module parameter.+ - [#3161](https://github.com/agda/agda/issues/3161): Case splitter produces end-of-comment+ - [#3169](https://github.com/agda/agda/issues/3169): Doc for rewriting+ - [#3170](https://github.com/agda/agda/issues/3170): UnicodeDeclare fails with pdflatex from TeX Live 2018+ - [#3175](https://github.com/agda/agda/issues/3175): Instance resolution fails with defined method+ - [#3176](https://github.com/agda/agda/issues/3176): Empty lambdas are sometimes considered definitionally equal, other times not+ - [#3180](https://github.com/agda/agda/issues/3180): Remove feature `--guardedness-preserving-type-constructors`+ - [#3188](https://github.com/agda/agda/issues/3188): Warnings disappear when fatal error is encountered+ - [#3195](https://github.com/agda/agda/issues/3195): Internal error at Auto/Typecheck.hs:373+ - [#3196](https://github.com/agda/agda/issues/3196): Turning MissingDefinition into a warning+ - [#3200](https://github.com/agda/agda/issues/3200): Function marked as irrelevant when it isn't+ - [#3201](https://github.com/agda/agda/issues/3201): [ warning ] AbsurdPatternRequiresNoRHS+ - [#3205](https://github.com/agda/agda/issues/3205): [ cleanup + warning ] ModuleDoesntExport can be recovered from+ - [#3224](https://github.com/agda/agda/issues/3224): Switch from utf8x to utf8? Make agda.sty easier to maintain?+ - [#3235](https://github.com/agda/agda/issues/3235): Cannot pass backend flags via emacs variable `agda2-program-args`+ - [#3247](https://github.com/agda/agda/issues/3247): Support cabal-install >= 2.4.1.0 in the Makefile+ - [#3248](https://github.com/agda/agda/issues/3248): Max of two sizes less than i+ - [#3253](https://github.com/agda/agda/issues/3253): [ fix ] ignore duplicate declarations of libraries+ - [#3254](https://github.com/agda/agda/issues/3254): `cpphs` doesn't build with GHC 8.6.*+ - [#3256](https://github.com/agda/agda/issues/3256): Internal error at src/full/Agda/TypeChecking/Reduce.hs:148+ - [#3257](https://github.com/agda/agda/issues/3257): Anonymous top-level modules can have names with multiple components+ - [#3258](https://github.com/agda/agda/issues/3258): Ordering the constructor names at Definition.+ - [#3262](https://github.com/agda/agda/issues/3262): Suboptimal placement of "missing with-clauses" error+ - [#3264](https://github.com/agda/agda/issues/3264): When refine leads to a termination error it should say so rather than "cannot refine"+ - [#3268](https://github.com/agda/agda/issues/3268): [ haddock ] Fix haddock formatting+ - [#3285](https://github.com/agda/agda/issues/3285): Internal error for syntax declaration+ - [#3302](https://github.com/agda/agda/issues/3302): Multiple definitions called _ are sometimes allowed, sometimes not+ - [#3307](https://github.com/agda/agda/issues/3307): `--no-unicode` bug: case splitting inside a pattern matching lambda still produces unicode arrows+ - [#3309](https://github.com/agda/agda/issues/3309): Use of irrelevant arguments with copatterns and irrelevant fields+ - [#3313](https://github.com/agda/agda/issues/3313): Add --html-highlight support for the HTML backend+ - [#3315](https://github.com/agda/agda/issues/3315): The primErase primitive is not safe+ - [#3318](https://github.com/agda/agda/issues/3318): Lots of primitives and builtins are not declared in the primitive/builtin modules+ - [#3320](https://github.com/agda/agda/issues/3320): Extra indentation when code is hidden+ - [#3323](https://github.com/agda/agda/issues/3323): Internal error with inconsistent irrelevance info between declaration and definition of data type+ - [#3338](https://github.com/agda/agda/issues/3338): Missing Definitions not recognised in instance search+ - [#3342](https://github.com/agda/agda/issues/3342): GHC panic on stack and GHC 7.10.3+ - [#3344](https://github.com/agda/agda/issues/3344): Disable compilation with GHC 8.6.1+ - [#3356](https://github.com/agda/agda/issues/3356): C-c C-s prints postfix projections by default+ - [#3363](https://github.com/agda/agda/issues/3363): The wiki should support HTTPS+ - [#3364](https://github.com/agda/agda/issues/3364): Funny scope error when trying to import as qualified+ - [#3366](https://github.com/agda/agda/issues/3366): Add a command line flag to change the extension of the files generated by the HTML backend+ - [#3368](https://github.com/agda/agda/issues/3368): Support GHC 8.6.2+ - [#3370](https://github.com/agda/agda/issues/3370): [ fix ] < and > need to be in math mode in latex+ - [#3371](https://github.com/agda/agda/issues/3371): Document common LaTeX backend pitfalls+ - [#3372](https://github.com/agda/agda/issues/3372): Provide some simple LaTeX backend templates+ - [#3373](https://github.com/agda/agda/issues/3373): Wrap HTML in `raw` directive when working with ReStructuredText+ - [#3379](https://github.com/agda/agda/issues/3379): Adding a tutorial set in the readthedocs frontpage+ - [#3380](https://github.com/agda/agda/issues/3380): Too much erasure in strict backends+ - [#3394](https://github.com/agda/agda/issues/3394): Internal error in mutual block with unsolved implicit argument in termination checker+ - [#3400](https://github.com/agda/agda/issues/3400): Obscure parse error with copattern and infix field+ - [#3403](https://github.com/agda/agda/issues/3403): Internal error in Agda.TypeChecking.Rules.Term+ - [#3404](https://github.com/agda/agda/issues/3404): Positivity checker marks postulates as constant in mutual block+ - [#3407](https://github.com/agda/agda/issues/3407): Internal error at "src/full/Agda/TypeChecking/Reduce/Fast.hs:1338"+ - [#3409](https://github.com/agda/agda/issues/3409): No error if mapping the empty type to non-empty Haskell type+ - [#3410](https://github.com/agda/agda/issues/3410): ghc backend generates program that segfaults+ - [#3419](https://github.com/agda/agda/issues/3419): Allow unconstrained instances & disallow overlapping instances+ - [#3420](https://github.com/agda/agda/issues/3420): Inductive definitions live in a larger set --without-K+ - [#3425](https://github.com/agda/agda/issues/3425): Internal error at src/full/Agda/Termination/Monad.hs:177+ - [#3426](https://github.com/agda/agda/issues/3426): Termination checking false positive when using "where"+ - [#3428](https://github.com/agda/agda/issues/3428): Another interal error in Substitute:72 when filling a hole+ - [#3431](https://github.com/agda/agda/issues/3431): Rewrite rule doesn't fire during conversion checking+ - [#3434](https://github.com/agda/agda/issues/3434): Regression related to instance resolution+ - [#3435](https://github.com/agda/agda/issues/3435): Performance regression+ - [#3439](https://github.com/agda/agda/issues/3439): Setω doesn’t respect --type-in-type+ - [#3441](https://github.com/agda/agda/issues/3441): Generate Level expressions with fewer parentheses+ - [#3442](https://github.com/agda/agda/issues/3442): Support GHC 8.6.3+ - [#3443](https://github.com/agda/agda/issues/3443): "internal error" in Agda of December 7, 2018+ - [#3444](https://github.com/agda/agda/issues/3444): `Setup.hs` is not generating the interface files+ - [#3445](https://github.com/agda/agda/issues/3445): case splitting attempts to shadow constructor+ - [#3451](https://github.com/agda/agda/issues/3451): The --no-sized-types option is broken+ - [#3452](https://github.com/agda/agda/issues/3452): Case split on irrelevant argument goes through but is later rejected+ - [#3454](https://github.com/agda/agda/issues/3454): Highlighting for incomplete pattern matching should be above highliting for non-exact split+ - [#3456](https://github.com/agda/agda/issues/3456): [ new ] Injectivity of prim(NatToChar/StringToList)+ - [#3461](https://github.com/agda/agda/issues/3461): Macro loop+ - [#3463](https://github.com/agda/agda/issues/3463): Impossible to give certain instance arguments by name?+ - [#3466](https://github.com/agda/agda/issues/3466): two definitionally equal terms are not equal+ - [#3471](https://github.com/agda/agda/issues/3471): Can't install via cabal-install on current Haskell Platform+ - [#3480](https://github.com/agda/agda/issues/3480): Parse error at EOF should be reported before EOF (especially if there is a long comment before EOF)+ - [#3483](https://github.com/agda/agda/issues/3483): Internal error at TypeChecking/Monad/Signature.hs:732+ - [#3485](https://github.com/agda/agda/issues/3485): [ warnings ] for empty primitive blocks+ - [#3491](https://github.com/agda/agda/issues/3491): Internal error src/full/Agda/TypeChecking/Rules/LHS.hs:294 after pattern matching+ - [#3498](https://github.com/agda/agda/issues/3498): Internal error in activateLoadedFileCache+ - [#3501](https://github.com/agda/agda/issues/3501): Case split in let clause causes internal error+ - [#3503](https://github.com/agda/agda/issues/3503): Internal error in BasicOps+ - [#3514](https://github.com/agda/agda/issues/3514): Accidential language change in 2.5.3: hiding is now part of name when resolving hidden argument insertion+ - [#3517](https://github.com/agda/agda/issues/3517): Option consistency checking bug+ - [#3518](https://github.com/agda/agda/issues/3518): Performance regression+ - [#3521](https://github.com/agda/agda/issues/3521): Documentation: fixes a plural issue in copatterns+ - [#3526](https://github.com/agda/agda/issues/3526): Do not generate trivially impossible clause when case-splitting+ - [#3533](https://github.com/agda/agda/issues/3533): [ fix #3526 ] Remove trivially impossible clauses from case-split+ - [#3534](https://github.com/agda/agda/issues/3534): Problem finding higher-order instances+ - [#3536](https://github.com/agda/agda/issues/3536): Patternmatching on coinductive record fields breaks+ - [#3544](https://github.com/agda/agda/issues/3544): internal error @ TypeChecking/Forcing.hs:227+ - [#3548](https://github.com/agda/agda/issues/3548): [ new ] Add support for compiling literate Org documents+ - [#3554](https://github.com/agda/agda/issues/3554): Type checker explosion+ - [#3561](https://github.com/agda/agda/issues/3561): fix typo: "FreBSD" => "FreeBSD"+ - [#3566](https://github.com/agda/agda/issues/3566): Missing name when printing type of definition of a record+ - [#3578](https://github.com/agda/agda/issues/3578): Pattern matching unifier normalizes too much+ - [#3586](https://github.com/agda/agda/issues/3586): Internal error in ConcreteToAbstract.hs:2217+ - [#3590](https://github.com/agda/agda/issues/3590): Superlinear time required for simple code+ - [#3597](https://github.com/agda/agda/issues/3597): Agda loops on simple code with a record and a hole+ - [#3600](https://github.com/agda/agda/issues/3600): Size solver complains, explicit sizes work+ - [#3610](https://github.com/agda/agda/issues/3610): Support GHC 8.6.4+ - [#3621](https://github.com/agda/agda/issues/3621): performance problem+ - [#3631](https://github.com/agda/agda/issues/3631): Performance with --no-universe-polymorphism+ - [#3638](https://github.com/agda/agda/issues/3638): Rewrite rules do not fire in goal normalization in parametrized module+ - [#3639](https://github.com/agda/agda/issues/3639): Argument to function created by tactic is lost+ - [#3640](https://github.com/agda/agda/issues/3640): Polarity: Size index check crashes due to wrong parameter number calculation+ - [#3641](https://github.com/agda/agda/issues/3641): Remove old compiler pragmas+ - [#3648](https://github.com/agda/agda/issues/3648): Agda could fail to build if a .agda-lib file exists in a parent directory+ - [#3651](https://github.com/agda/agda/issues/3651): internal error ghc backend+ - [#3657](https://github.com/agda/agda/issues/3657): Disable compilation with Windows and GHC 8.6.3+ - [#3678](https://github.com/agda/agda/issues/3678): Two out-of-scope variables are given the same name+ - [#3687](https://github.com/agda/agda/issues/3687): Show module contents (C-c C-o) prints garbled names in clause
@@ -0,0 +1,4 @@+Release notes for Agda version 2.6.1.1+======================================++* Added support for GHC 8.8.4 and GHC 8.10.2
@@ -0,0 +1,8 @@+Release notes for Agda version 2.6.1.2+======================================++* Build with latest versions of hackage packages:+ - aeson (1.5.3), [issue #4838](https://github.com/agda/agda/issues/4838)+ - strict (0.4), [commit 0497ec9](https://github.com/agda/agda/commit/0497ec9fdde159a56ee42821e500b52d66374201)++* Build with dynamic linking, [issue #4569](https://github.com/agda/agda/issues/4569)
@@ -0,0 +1,4 @@+Release notes for Agda version 2.6.1.3+======================================++* Added support for GHC 8.10.3.
@@ -0,0 +1,850 @@+Release notes for Agda version 2.6.1+====================================++General+-------++* Agda now has an official logo: [](https://github.com/agda/agda/blob/master/doc/user-manual/agda.svg). The+ logo was chosen by the Agda community from a list of candidates. The+ winning design was submitted by Miëtek Bak. The list of candidates+ and the outcome of the poll can be consulted+ [here](https://civs.cs.cornell.edu/cgi-bin/results.pl?id=E_ce6fe5e2a518ac98).+++Installation and infrastructure+-------------------------------++* Added support for GHC 8.8.2+ [Issue [#4285](https://github.com/agda/agda/issues/4285)].++* Removed support for GHC 7.10.3.++* Interface files are now written in directory `_build/VERSION/agda/` at+ the project root (the closest enclosing directory where an `.agda-lib`+ file is present). If there is no project root then the interface file+ is written alongside the module it corresponds to.+ The flag `--local-interfaces` forces Agda to revert back to storing+ interface files alongside module files no matter what.++* Agda now uses the default RTS options `-M3.5G -I0`. If+ you run Agda on a 32-bit system or a system with less than 8GB of+ RAM, it is recommended to set the RTS options explicitly to a lower+ value by running `agda` with option `+RTS -M1.2G -RTS`+ (for example) or by setting the GHCRTS enviroment variable. See the+ [GHC User's Guide](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/runtime_control.html#setting-rts-options)+ for more information.++* If Agda is compiled using GHC 8.4 or later, then one can expect to+ see substantially lower memory consumption+ [Issues [#4457](https://github.com/agda/agda/issues/4457)+ and [#4316](https://github.com/agda/agda/issues/4316)].++ This is due to the use of ["compact+ regions"](https://hackage.haskell.org/package/ghc-compact-0.1.0.0/docs/GHC-Compact.html).++* The `CHANGELOG.md` was split. Changes to previous versions of Agda+ are in the directory `doc/release-notes`.++Pragmas and options+-------------------++* New pragma `WARNING_ON_IMPORT` to let module authors raise a warning+ when a module is imported. This can be use to tell users deprecations.++* New option `--confluence-check` (off by default) enables confluence+ checking of user-defined rewrite rules (this only has an effect when+ `--rewriting` is also enabled).++* New option `--no-projection-like` to turn off the analysis whether a+ type signature likens that of a projection.+ Projection-likeness is an optimization that reduces the size of+ terms by dropping parameter-like reconstructible function arguments.+ Thus, it is advisable to leave this optimization on, the flag is+ meant for debugging Agda.++* Option `--no-forcing` is now a pragma option, i.e., the forcing analysis+ can be switched off on a per-file basis via++ ```agda+ {-# OPTIONS --no-forcing #-}+ ```++ at the beginning of the file+ [Issue [#3872](https://github.com/agda/agda/issues/3872)].++* New pragma option `--no-flat-split` disables pattern matching on `@♭` arguments.++* New pragma option `--allow-incomplete-matches`. It is similar to+ `--allow-unsolved-metas`: modules containing partial function definitions+ can be imported. Its local equivalent is the `NON_COVERING` pragma to+ be placed before the function (or the block of mutually defined functions)+ which the user knows to be partial.++* Option `--interaction-json` now brings more information about goals,+ unsolved metas, warnings, errors.+ It also displays pretty-printed terms.++* New pragma option `--keep-pattern-variables` to prevent case+ splitting from replacing variables with dot patterns.++* Pragma `{-# ETA <record name> #-}` is no longer considered `--safe`.+ See [Issue [#4450](https://github.com/agda/agda/issues/4450)].++* New pragma options `--subtyping` and `--no-subtyping` (default) to+ turn on/off subtyping rules globally [see+ Issue_[#4474](https://github.com/agda/agda/issues/4474)]. Currently,+ this includes subtyping for irrelevance, erasure, and flat+ modalities. Additionally, `--subtyping` is implied by+ `--cumulativity` (see below). `--subtyping` is currently NOT implied+ by `--sized-types`, and subtyping for sized types is used even when+ `--subtyping` is not enabled.++* New profiling options to measure time spent per module or top-level+ definition.++ - `-v profile.modules:10` prints a breakdown per top-level module+ - `-v profile.definitions:10` prints a breakdown per top-level+ definition++Language+--------++### Syntax++* Fractional precedence levels are now supported, see+ Issue [#3991](https://github.com/agda/agda/issues/3991). Example:++ ```agda+ infix 3.14 _<_+ ```+ Note that this includes a respective change in the reflected Agda syntax.++* Fixities can now be changed during import in a `renaming` directive,+ see+ Issue [#1346](https://github.com/agda/agda/issues/1346). Example:++ ```agda+ open M using (_∙_)+ open M renaming (_∙_ to infixl 10 _*_)+ ```+ After this, `_∙_` is in scope with its original fixity, and as `_*_` as left+ associative operator of precedence 10.++* Implicit non-dependent function spaces `{A} → B` and `{{A}} → B` are now supported.++* Idiom brackets++ Idiom brackets can accommodate none or multiple applications separated by a vertical bar `|`+ if there are two additional operations+ ```agda+ empty : ∀ {A} → F A+ _<|>_ : ∀ {A} → F A → F A → F A+ ```+ i.e. an Alternative type class in Haskell.+ As usual, the new idiom brackets desugar before scope checking.++ Idiom brackets with multiple applications+ ```agda+ (| e₁ a₁ .. aₙ | e₂ a₁ .. aₘ | .. | eₖ a₁ .. aₗ |)+ ```+ expand to (assuming right associative `_<|>_`)+ ```agda+ (pure e₁ <*> a₁ <*> .. <*> aₙ) <|> ((pure e₂ <*> a₁ <*> .. <*> aₘ) <|> (pure eₖ <*> a₁ <*> .. <*> aₗ))+ ```+ Idiom brackets with no application `(|)` or `⦇⦈` are equivalent to `empty`.+++* Irrefutable With++ Users can now match on irrefutable patterns on the LHS using a+ pattern-matching `with`. An expression of the form:++ ```agda+ f xs with p1 <- e1 | ... | pn <- en+ with q1 <- f1 | ... | qm <- fm = rhs+ ```++ is translated to nested `with` clauses, essentially equivalent to:++ ```agda+ f xs with e1 | ... | en+ ... | p1 | ... | pn+ with f1 | ... | fm+ ... | q1 | ... | qm = rhs+ ```++* Record patterns in telescopes++ Users can now use record patterns in telescope and lambda abstractions.+ The type of the second projection from a dependent pair is the prototypical+ example It can be defined as follows:++ ```agda+ snd : ((a , _) : Σ A B) → B a+ ```++ And this second projection can be implemented with a lamba-abstraction using+ one of these irrefutable patterns:++ ```agda+ snd = λ (a , b) → b+ ```++ Using an as-pattern, users can get a name for the value as well as for its+ subparts. We can for instance prove that any pair is equal to the pairing+ of its first and second projections:++ ```agda+ eta : (p@(a , b) : Σ A B) → p ≡ (a , b)+ eta p = refl+ ```++* Absurd match in a do block+ The last expression in a do block can now also be an absurd match `() <- f`.++* Named `where` modules are now in scope in the rhs of the clause (see+ Issue [#4050](https://github.com/agda/agda/issues/4050)). Example:++ ```agda+ record Wrap : Set₂ where+ field wrapped : Set₁++ test : Wrap+ test = record { M }+ module M where+ wrapped : Set₁+ wrapped = Set+ ```++* `{{-` is now lexed as `{ {-` rather than `{{ -`,+ see Issue [#3962](https://github.com/agda/agda/issues/3962).++* Syntax for large numbers: you can now separate groups of 3 digits using `_`.+ e.g. write `1_000_000` instead of `1000000`.++* `quoteGoal` and `quoteContext` are no longer keywords.++* Record constructors can no longer be qualified by the record module.+ (See Issue [#4189](https://github.com/agda/agda/issues/4189).)++ ```agda+ record Foo : Set where+ constructor foo++ works = foo+ fails = Foo.foo+ ```++* `codata` definitions have been removed from the concrete syntax+ Previously they got accepted syntactically, but resulted in errors.++* Imports can now be anonymous.+ (See Issue_[#3727](https://github.com/agda/agda/issues/3727).)+ For example, the following will **not** bring `Agda.Builtin.Unit` into scope:+ ```agda+ open import Agda.Builtin.Unit as _+ blah :: ⊤+ blah = tt+ ```++### Type checking++* Type inference for record expressions no longer considers record types from+ modules that have not been imported (Issue [#4267](https://github.com/agda/agda/issues/4267)).++ For instance,+ ```agda+ -- A.agda+ module A where+ record R : Set₁ where+ field f : Set+ ```+ ```agda+ -- B.agda+ module B where+ import A+ ```+ ```agda+ -- C.agda+ module C where+ import B+ fails : Set → _+ fails X = record {f = X} -- import A required to infer record type R+ ```++* The fix of issue [#3903](https://github.com/agda/agda/issues/3903) changes+ the algorithm computing the order of case splits, which in some cases may+ lead to unsolved metavariables in previously working code. See issue+ [#4353](https://github.com/agda/agda/issues/4353).++### Modalities++* New Flat Modality++ New modality `@♭/@flat` (previously only available in the branch "flat").+ An idempotent comonadic modality modeled after spatial/crisp type theory.+ See [Flat Modality](https://agda.readthedocs.io/en/v2.6.1/language/flat.html)+ in the documentation for more.++* New run-time erasure modality (`@0` / `@erased`).+ Terms marked as erased cannot influence computations and are erased+ at run time+ [Issue [#3855](https://github.com/agda/agda/issues/3855)]. See+ [Run-time+ Irrelevance](https://agda.readthedocs.io/en/v2.6.1/language/runtime-irrelevance.html)+ in the documentation for more information.++ Note that this feature can cause previously solved metavariables to become+ unsolved even in code that doesn't use run-time erasure (see issue+ [#4174](https://github.com/agda/agda/issues/4174)).++* Subtyping rules for modalities are by default no longer used (see+ Issue_[#4390](https://github.com/agda/agda/issues/4390)). For+ example, if `f : .A → A`, Agda no longer accepts `f` at type `A →+ A`. Instead, Agda accepts `λ x → f x : A → A`. The same holds for+ erasure (`@0`) and flat (`@♭`) modalities. Consequently, it may be+ required to eta-expand certain functions in order to make old code+ work with Agda 2.6.1. Alternatively, enabling the new `--subtyping`+ flag will restore the old behaviour but might negatively impact+ typechecking performance.++### Universe levels++* New (experimental) option `--cumulativity`++ When the ``--cumulativity`` flag is enabled, Agda uses the subtyping+ rule ``Set i =< Set j`` whenever ``i =< j``. For example, in+ addition to its usual type ``Set``, ``Nat`` also has the type+ ``Set₁`` and even ``Set i`` for any ``i : Level``. More information+ about this new option can be found in section+ [Cumulativity](https://agda.readthedocs.io/en/v2.6.1/language/cumulativity.html)+ of the user manual.++### Termination checking++* The "with inlining" feature of the termination checker has been+ removed. As a consequence, some functions defined using `with` are+ no longer accepted as terminating. See+ Issue [#59](https://github.com/agda/agda/issues/59) for why this+ feature was originally introduced and+ [#3604](https://github.com/agda/agda/issues/3604) for why it had to+ be removed.++ The easiest way to fix termination problems caused by `with` is to abstract+ over the offending recursive call before any other `with`s. For example++ ```agda+ data D : Set where+ [_] : Nat → D++ fails : D → Nat+ fails [ zero ] = zero+ fails [ suc n ] with some-stuff+ ... | _ = fails [ n ]+ ```++ This fails termination because the relation between `[ suc n ]` and `[ n ]`+ is lost since the generated with-function only gets passed `n`. To fix it we+ can abstract over the recursive call:++ ```agda+ fixed : D → Nat+ fixed [ zero ] = zero+ fixed [ suc n ] with fixed [ n ] | some-stuff+ ... | rec | _ = rec+ ```++ If the function takes more arguments you might need to abstract over a+ partial application to just the structurally recursive argument. For instance,++ ```agda+ fails : Nat → D → Nat+ fails _ [ zero ] = zero+ fails _ [ suc n ] with some-stuff+ ... | m = fails m [ n ]++ fixed : Nat → D → Nat+ fixed _ [ zero ] = zero+ fixed _ [ suc n ] with (λ m → fixed m [ n ]) | some-stuff+ ... | rec | m = rec m+ ```++ A possible complication is that later `with`-abstractions might change the+ type of the abstracted recursive call:++ ```agda+ T : D → Set+ suc-T : ∀ {n} → T [ n ] → T [ suc n ]+ zero-T : T [ zero ]++ fails : (d : D) → T d+ fails [ zero ] = zero-T+ fails [ suc n ] with some-stuff+ ... | _ with [ n ]+ ... | z = suc-T (fails [ n ])++ still-fails : (d : D) → T d+ still-fails [ zero ] = zero-T+ still-fails [ suc n ] with still-fails [ n ] | some-stuff+ ... | rec | _ with [ n ]+ ... | z = suc-T rec -- Type error because rec : T z+ ```++ To solve this problem you can add `rec` to the with-abstraction messing up+ its type. This will prevent it from having its type changed:++ ```agda+ fixed : (d : D) → T d+ fixed [ zero ] = zero-T+ fixed [ suc n ] with fixed [ n ] | some-stuff+ ... | rec | _ with rec | [ n ]+ ... | _ | z = suc-T rec+ ```++* The termination checker will now try to dispose of recursive calls+ by reducing with the non-recursive function clauses.+ This eliminates false positives common for definitions by copatterns+ using dependent types,+ see Issue [#906](https://github.com/agda/agda/issues/906).++ For example, consider the following example using a dependent+ coinductive record `Tree`:+ ```agda+ data Fin : Nat → Set where+ fzero : ∀ n → Fin (suc n)+ fsuc : ∀ n (i : Fin n) → Fin (suc n)++ toNat : ∀ n → Fin n → Nat+ toNat .(suc n) (fzero n) = zero+ toNat .(suc n) (fsuc n i) = suc (toNat n i)++ record Tree : Set where+ coinductive+ field label : Nat+ child : Fin label → Tree+ open Tree++ tree : Nat → Tree+ tree n .label = n+ tree n .child i = tree (n + toNat _ i)+ ```+ Agda solves the underscore by `tree n .label`, which is a corecursive+ call in a non-guarded position, violating the guardedness criterion.+ This lead to a complaint of the termination checker.+ Now this call is reduced to `n` first using the non-recursive clause+ `tree n .label = n`, which leaves us only with the guarded call+ `tree (n + toNat n i)`, and the termination checker is happy.++ Note: Similar false positives arose already for non-recursive dependent+ records, e.g., when trying to define an inhabitant of the Σ-type by+ copattern matching on the projects.+ See Issue_[#2068](https://github.com/agda/agda/issues/2068) for a+ non-recursive example.++### Irrelevance and Prop++* Agda will no longer reduce irrelevant definitions and definitions+ with a type in `Prop`. This does not have an effect on the+ semantics, but should lead to improved performance (see Issues+ [#4115](https://github.com/agda/agda/issues/4115),+ [#4118](https://github.com/agda/agda/issues/4118),+ [#4120](https://github.com/agda/agda/issues/4120),+ [#4122](https://github.com/agda/agda/issues/4122)).++* Terms of a type in `Prop` are now printed as `_`. To show the actual+ term, you can use the `--show-irrelevant` flag (see+ Issue [#3337](https://github.com/agda/agda/issues/3337).++### Rewrite rules++* Rewrite rules (option `--rewriting`) with data or record types as+ the head symbol are no longer allowed (see+ Issue [#3846](https://github.com/agda/agda/issues/3846)).++### Tactics & Reflection++* Implicit arguments solved by user-defined tactics++ You can declare tactics to be used to solve a particular implicit argument+ using the following syntax:++ ```agda+ example : {@(tactic f) x : A} → B+ ```++ where `f : Term → TC ⊤`. At calls to `example`, `f` is called on the+ metavariable inserted for `x`. `f` can be an arbitrary term and may depend on+ previous arguments to the function. For instance,++ ```agda+ example₂ : (depth : Nat) {@(tactic search depth) x : A} → B+ ```++ Record fields can also be annotated with a tactic, allowing them to be+ omitted in constructor applications, record constructions and co-pattern+ matches:++ ```agda+ record Example : Set where+ constructor mkExample+ field x : A+ @(tactic solveP x) {y} : P x+ ```++ where `solveP : (x : A) → Term → TC ⊤` is a tactic that tries to+ prove `P x`+ [Issue [#4124](https://github.com/agda/agda/issues/4124)].++* The legacy reflection framework using `quoteGoal` and `quoteContext` has been+ removed.++### Builtins++* New primitives++ ```agda+ primWord64ToNatInjective : ∀ a b → primWord64ToNat a ≡ primWord64ToNat b → a ≡ b++ primFloatToWord64 : Float → Word64+ primFloatToWord64Injective : ∀ a b → primFloatToWord64 a ≡ primFloatToWord64 b → a ≡ b++ primMetaToNat : Meta → Nat+ primMetaToNatInjective : ∀ a b → primMetaToNat a ≡ primMetaToNat b → a ≡ b++ primQNameToWord64s : Name → Word64 × Word64+ primQNameToWord64sInjective : ∀ a b → primQNameToWord64s a ≡ primQNameToWord64s b → a ≡ b+ ```++ These can be used to define safe decidable propositional equality, see Issue [agda-stdlib#698](https://github.com/agda/agda-stdlib/issues/698).++* New Primitive for showing Natural numbers:++ ```agda+ primShowNat : Nat → String+ ```++ placed in Agda.Builtin.String.++* The builtin `IO` has been declared strictly positive in both its+ level and type argument.++### Warnings++* New warning for a variable shadowing another in a telescope. If the two+ variables are introduced in different telescopes then the warning is not+ raised.++ ```agda+ f : {a : Level} {A : Set a} (a : A) → A -- warning raised: repeated a+ g : {a : Level} {A : Set a} → (a : A) → A -- warning not raised: two distinct telescopes+ ```++ Note that this warning is turned off by default (you can use+ `-WShadowingInTelescope` or `--warning ShadowingInTelescope` to turn+ it on, `-Wall` would also naturally work).+++Emacs mode+----------++* Agda input method: new key bindings `\ G h` and `\ G H` for `η` and+ `H` (capital η)+ [Issue [#3856](https://github.com/agda/agda/issues/3856)].++* Syntax highlighting: in literate modes, the pure texts+ (other than Agda code and the code-text separators) are no longer highlighted+ (it was highlighted as comments before).+ This somehow provides more information about how Agda lexes literate files.++* Agda now also displays the values of let-bound variables in the+ context instead of just their types+ [Issue [#4199](https://github.com/agda/agda/issues/4199)].++* Agda will now try to preserve the ellipsis (`...`) during case+ splitting when possible. To manually expand the ellipsis, you may+ ask Agda to case split on the special identifier `.`.+ [Issue [#2589](https://github.com/agda/agda/issues/2589)]++* Agda will now also show variables named `_` in the context if they+ are instance arguments (see+ [#4307](https://github.com/agda/agda/issues/4307)). Instance+ arguments are now also marked as `(instance)` in the context. Example:++ ```agda+ f : {{_ : A}} → A+ f = ?+ ```++ Agda will now display the goal as follows:++ ```+ Goal: A+ ————————————————————————————————————————————————————————————+ _ : A (instance)+ ```++* It is now possible to ask Agda to terminate itself after any+ previously invoked commands have completed, by giving a prefix+ argument to `agda2-term`.++* The command `agda2-measure-load-time` has been removed.++GHC Backend+-----------++* Types which have a COMPILE GHC pragma are no longer erased+ [Issue [#3732](https://github.com/agda/agda/issues/3732)].++ ```agda+ data I : Set where+ bar : I++ {-# FOREIGN GHC data I = Bar #-}+ {-# COMPILE GHC I = data I (Bar) #-}++ data S : Set where+ foo : I → S++ {-# FOREIGN GHC data S = Foo I #-}+ {-# COMPILE GHC S = data S (Foo) #-}+ ```+ Previously [Issue [#2921](https://github.com/agda/agda/issues/2921)],+ the last binding was incorrect, since the argument of+ singleton type `I` was erased from the constructor `foo` during+ compilation. The required shape of `S` was previously+ ```+ {-# FOREIGN GHC data S = Foo #-}+ ```+ i.e., constructor `Foo` had to have no arguments.++ For the sake of transparency, Haskell constructors bound to+ Agda constructors now take the same arguments.+ This is especially important if Haskell bindings are to be+ produced automatically by third party tool.++LaTeX backend+-------------++* Now the code environment complains if it is given unrecognised options.++ It is also possible to write, say, `hide=true` instead of `hide`,+ and `hide=false` means that the `hide` option should not be used.+ Furthermore the same option can be given multiple times, in which+ case later choices take precedence over earlier ones.++* The code environment has a new option, `number`.++ When the option `number` is used an equation number is generated for+ the code listing. The number is set to the right, centered+ vertically. By default the number is set in parentheses, but this+ can be changed by redefining `\AgdaFormatCodeNumber`.++ The option can optionally be given an argument: when `number=l` is+ used a label `l`, referring to the code listing, is generated. It is+ possible to use this option several times with different labels.++ The option has no effect if used together with `hide`, `inline` or+ `inline*`.++API+----+* Removed module `Agda.Utils.HashMap`. It only re-exported `Data.HashMap.Strict`+ from the package `unordered-containers`. Use `Data.HashMap.Strict` instead.++* Removed module `Agda.Utils.Char`. It used to provide functions converting a+ `Char` in base 8, 10, and 16 to the corresponding `Int`. Use `digitToInt` in+ `Data.Char` instead. The rest of module was about Unicode test which was not+ used.++* `Agda.Utils.List` no longer provides `headMaybe`.+ Use `listToMaybe` in `Data.Maybe` instead.++* `Agda.Utils.Either` no longer provides `mapEither`. Use `bimap` in+ `Data.Bifunctor` instead.++* `Agda.Utils.Map` no longer provides `unionWithM`, `insertWithKeyM`,+ `allWithKey`, `unzip`, and `unzip3`.++Other issues+------------++For 2.6.1, the following issues were also closed (see [bug+tracker](https://github.com/agda/agda/issues)):++ - [#470](https://github.com/agda/agda/issues/470): Constraint solving in heterogenous situations+ - [#471](https://github.com/agda/agda/issues/471): Emacs command to show goal with constraints on it+ - [#500](https://github.com/agda/agda/issues/500): Allow creation of implicit parameters in with blocks+ - [#543](https://github.com/agda/agda/issues/543): Irrelevant projections are inconsistent+ - [#760](https://github.com/agda/agda/issues/760): Warning for open public in an abstract block+ - [#1073](https://github.com/agda/agda/issues/1073): Solve C-c C-s inserts variables that are not in scope+ - [#1097](https://github.com/agda/agda/issues/1097): Allow record patterns in lambda-bound positions+ - [#1182](https://github.com/agda/agda/issues/1182): Request: allowing the use of patterns in syntax-bound variables+ - [#1381](https://github.com/agda/agda/issues/1381): Termination checker rejects function with with-clause+ - [#1445](https://github.com/agda/agda/issues/1445): Lack of subject reduction with REWRITE+ - [#1820](https://github.com/agda/agda/issues/1820): Case splitting should preserve existing names+ - [#2068](https://github.com/agda/agda/issues/2068): Copattern matching: Hyvernat termination would succeed+ - [#2148](https://github.com/agda/agda/issues/2148): Option to use use `stack exec` for GHC backend+ - [#2170](https://github.com/agda/agda/issues/2170): Two equal irrelevant definitions: one is type checked, the other is not+ - [#2284](https://github.com/agda/agda/issues/2284): Disallow duplicate bound variable in lambda and pi+ - [#2414](https://github.com/agda/agda/issues/2414): Case splitting loses as-patterns+ - [#2498](https://github.com/agda/agda/issues/2498): Resolution of unnamed instances+ - [#2512](https://github.com/agda/agda/issues/2512): Propose: Split the changelog+ - [#2530](https://github.com/agda/agda/issues/2530): --ignore-interfaces should not recompile Primitive.agda+ - [#2535](https://github.com/agda/agda/issues/2535): Expose name id in reflection API+ - [#2589](https://github.com/agda/agda/issues/2589): Preserve the ellipsis (dots) when case splitting "with" arguments+ - [#2610](https://github.com/agda/agda/issues/2610): Avoid rechecking by storing interfaces in separate directories?+ - [#2619](https://github.com/agda/agda/issues/2619): Feature request: link to `renaming` clause+ - [#2902](https://github.com/agda/agda/issues/2902): Case-splitting should not generate patterns containing pattern synonyms+ - [#3034](https://github.com/agda/agda/issues/3034): Pattern matching without K seemingly illogical for the inductive family of squares+ - [#3073](https://github.com/agda/agda/issues/3073): type-in-type and spurious levels+ - [#3081](https://github.com/agda/agda/issues/3081): Termination problem: copatterns and without-K+ - [#3089](https://github.com/agda/agda/issues/3089): Nicer syntax for implicit @-patterns+ - [#3095](https://github.com/agda/agda/issues/3095): Would like to make hidden variable visible but it is created ambiguous+ - [#3136](https://github.com/agda/agda/issues/3136): Spurious module parameters printed in extended lambda in termination error+ - [#3189](https://github.com/agda/agda/issues/3189): No information about which warnings are enabled by default+ - [#3233](https://github.com/agda/agda/issues/3233): Type declarations not accompanied by a definition should be highlighted in the emacs mode+ - [#3238](https://github.com/agda/agda/issues/3238): Printing of inserted hidden lambdas+ - [#3293](https://github.com/agda/agda/issues/3293): Absurd match in a do block+ - [#3295](https://github.com/agda/agda/issues/3295): Allow import of files with incomplete pattern matching+ - [#3353](https://github.com/agda/agda/issues/3353): Case splitting turns named arguments into positional arguments+ - [#3383](https://github.com/agda/agda/issues/3383): Document the DISPLAY pragma+ - [#3417](https://github.com/agda/agda/issues/3417): No highlighting for code that fails termination checking when an error is encountered+ - [#3423](https://github.com/agda/agda/issues/3423): Implicit arguments with custom macro for resolution+ - [#3432](https://github.com/agda/agda/issues/3432): Highlighting does not work for pattern synonyms in import lists+ - [#3493](https://github.com/agda/agda/issues/3493): Impossible to normalize elements in a proposition+ - [#3525](https://github.com/agda/agda/issues/3525): Rewrite rules with non-linear patterns do not work in presence of Prop+ - [#3545](https://github.com/agda/agda/issues/3545): JavaScript backend: mapping a function that returns Set fails+ - [#3574](https://github.com/agda/agda/issues/3574): Support precedent rebind / changing the precedents in builtin library+ - [#3582](https://github.com/agda/agda/issues/3582): Error message referring to Set instead of Prop+ - [#3594](https://github.com/agda/agda/issues/3594): Occurs check throws error when a solution is possible by eta expansion+ - [#3599](https://github.com/agda/agda/issues/3599): Bad performance on pathToEquiv+ - [#3606](https://github.com/agda/agda/issues/3606): Do not create/display superfluous metas and show constraints in a readable way+ - [#3654](https://github.com/agda/agda/issues/3654): Show non-blocked constraints first in list of unsolved constraints+ - [#3695](https://github.com/agda/agda/issues/3695): Generalisation introduces multiple explicit arguments for one generalisable variable+ - [#3698](https://github.com/agda/agda/issues/3698): Remove primComp?+ - [#3712](https://github.com/agda/agda/issues/3712): Sigma not listed in Built-ins documentation+ - [#3724](https://github.com/agda/agda/issues/3724): Internal error with Prop and inductive-inductive type+ - [#3725](https://github.com/agda/agda/issues/3725): Support GHC 8.8.1+ - [#3730](https://github.com/agda/agda/issues/3730): Internal error resulting from unused implicit argument+ - [#3735](https://github.com/agda/agda/issues/3735): Incorrect context when generalisable variable is used+ - [#3736](https://github.com/agda/agda/issues/3736): Safe decidability equality support for Name and Meta+ - [#3745](https://github.com/agda/agda/issues/3745): Update user manual on built-ins+ - [#3749](https://github.com/agda/agda/issues/3749): Inconsistency: Rounding op differentiates NaNs+ - [#3759](https://github.com/agda/agda/issues/3759): Change the default RTS options?+ - [#3774](https://github.com/agda/agda/issues/3774): de Bruijn index out of scope with rewrite rules+ - [#3776](https://github.com/agda/agda/issues/3776): Conversion check fails too quickly when type could be eta unit type+ - [#3779](https://github.com/agda/agda/issues/3779): Incorrectly ordered generalised variables+ - [#3785](https://github.com/agda/agda/issues/3785): Comparison of blocked terms doesn't respect eta+ - [#3791](https://github.com/agda/agda/issues/3791): Asking Agda to solve a constraint inside a macro+ - [#3803](https://github.com/agda/agda/issues/3803): Parse empty field lists+ - [#3805](https://github.com/agda/agda/issues/3805): Agda prelude: Internal error at src/full/Agda/TypeChecking/Reduce/Fast.hs:1347+ - [#3807](https://github.com/agda/agda/issues/3807): Internal error related to generalisable variables+ - [#3812](https://github.com/agda/agda/issues/3812): Rewriting projected symbols leads to loss of subject reduction+ - [#3813](https://github.com/agda/agda/issues/3813): Destructuring leads to invalid premises+ - [#3818](https://github.com/agda/agda/issues/3818): For open import M, Agda should remember that M is an external module+ - [#3824](https://github.com/agda/agda/issues/3824): rewrite drops named where module+ - [#3825](https://github.com/agda/agda/issues/3825): record{M} syntax reports unsolved metas in module M instead of in record expression+ - [#3828](https://github.com/agda/agda/issues/3828): Internal error in Agda/TypeChecking/Coverage.hs:467+ - [#3829](https://github.com/agda/agda/issues/3829): Case-split: don't generate pattern covered by unreachable clause+ - [#3830](https://github.com/agda/agda/issues/3830): primShow(Char/String) display spurious square brackets+ - [#3831](https://github.com/agda/agda/issues/3831): Wrong de Bruijn indices for reflected variables inside an extended context+ - [#3843](https://github.com/agda/agda/issues/3843): Internal error with-clause and unification+ - [#3851](https://github.com/agda/agda/issues/3851): C-c C-h should default to AsIs rather than Simplified+ - [#3866](https://github.com/agda/agda/issues/3866): `--no-unicode` option producing unicode variable names+ - [#3878](https://github.com/agda/agda/issues/3878): Case splitting should respect existing input+ - [#3879](https://github.com/agda/agda/issues/3879): Only unqualified pattern synonyms should be used for resugaring+ - [#3882](https://github.com/agda/agda/issues/3882): de Bruijn index out of scope+ - [#3892](https://github.com/agda/agda/issues/3892): Internal error with `data .. where` definitions+ - [#3898](https://github.com/agda/agda/issues/3898): Forcing analysis sensitive to normalization+ - [#3900](https://github.com/agda/agda/issues/3900): Abstract constructor not usable in function definition involving "with"+ - [#3901](https://github.com/agda/agda/issues/3901): Unnamed implicit non-dependent function space {A} -> B and {{A}} -> B+ - [#3912](https://github.com/agda/agda/issues/3912): Generalisable variables generate unknown and explicit parameters+ - [#3919](https://github.com/agda/agda/issues/3919): Case splitting fails in parameterized module+ - [#3927](https://github.com/agda/agda/issues/3927): `import … hiding …` should be documented+ - [#3928](https://github.com/agda/agda/issues/3928): The error message `Hiding … has no effect` should be improved+ - [#3930](https://github.com/agda/agda/issues/3930): BUILTIN NATURAL internal error at Forcing.hs:232+ - [#3932](https://github.com/agda/agda/issues/3932): Internal error when mixing implicit and explicit mutual blocks+ - [#3937](https://github.com/agda/agda/issues/3937): Internal error at "ConcreteToAbstract:1372"+ - [#3940](https://github.com/agda/agda/issues/3940): Weird error with piSort and generalization+ - [#3943](https://github.com/agda/agda/issues/3943): Print also hidden problematic unification terms+ - [#3955](https://github.com/agda/agda/issues/3955): Document module keyword in using/hiding/renaming+ - [#3956](https://github.com/agda/agda/issues/3956): Duplicate name in environment buffer with @-pattern+ - [#3964](https://github.com/agda/agda/issues/3964): Agda overwrites user-written dotted pattern+ - [#3965](https://github.com/agda/agda/issues/3965): Wrong indication of unreachable clauses+ - [#3966](https://github.com/agda/agda/issues/3966): All clauses marked when one clause has unification error+ - [#3972](https://github.com/agda/agda/issues/3972): Unreachable clause leads to internal error at Serialise/Instances/Internal.hs:94 (MetaV)+ - [#3974](https://github.com/agda/agda/issues/3974): Range for unexpected implicit argument on lhs too big+ - [#3983](https://github.com/agda/agda/issues/3983): TERMINATING accepted with --safe if hidden in a block+ - [#3989](https://github.com/agda/agda/issues/3989): Warn about duplicate bindings in a single telescope+ - [#4000](https://github.com/agda/agda/issues/4000): How to get Agda to ignore `~/.agda`?+ - [#4006](https://github.com/agda/agda/issues/4006): Internal error related to abstract and variable+ - [#4007](https://github.com/agda/agda/issues/4007): Cannot give pattern-matching lambda in abstract setting+ - [#4010](https://github.com/agda/agda/issues/4010): unquoteDef fails in abstract block+ - [#4012](https://github.com/agda/agda/issues/4012): Internal error when accessing abstract definitions created by unquoteDef/Decl+ - [#4020](https://github.com/agda/agda/issues/4020): Rewriting incorrectly considers level variables under lambdas as unbound in the LHS+ - [#4032](https://github.com/agda/agda/issues/4032): Loss of subject reduction involving --rewriting even when --confluence-check is on and everything passes the confluence checker+ - [#4038](https://github.com/agda/agda/issues/4038): Rewriting sometimes fails to rewrite in the presence of unsolved metas+ - [#4044](https://github.com/agda/agda/issues/4044): Equality checking uses too much memory in 2.6.0 (compared to 2.5.4)+ - [#4046](https://github.com/agda/agda/issues/4046): Remove (deprecated) codata keyword+ - [#4048](https://github.com/agda/agda/issues/4048): Rewriting rule fails to trigger+ - [#4049](https://github.com/agda/agda/issues/4049): Internal error with sized types if the target type of a constructor is an alias+ - [#4051](https://github.com/agda/agda/issues/4051): Internal error when importing a module with a hole in a type+ - [#4053](https://github.com/agda/agda/issues/4053): Emacs-mode: Case split leaves part of old line behind+ - [#4059](https://github.com/agda/agda/issues/4059): Two variants of irrefutable with?+ - [#4066](https://github.com/agda/agda/issues/4066): Regression related to instance resolution+ - [#4116](https://github.com/agda/agda/issues/4116): Internal error Forcing.hs:232+ - [#4121](https://github.com/agda/agda/issues/4121): Pattern synonyms cannot be made private+ - [#4125](https://github.com/agda/agda/issues/4125): Type checker normalizes too much+ - [#4134](https://github.com/agda/agda/issues/4134): Internal error triggered by missing check for irrelevant meta dependencies+ - [#4136](https://github.com/agda/agda/issues/4136): Overzealous pruning of metavariable with irrelevant argument+ - [#4141](https://github.com/agda/agda/issues/4141): Printing of DontCare should not use dot syntax+ - [#4142](https://github.com/agda/agda/issues/4142): defCopatternLHS needs to be set when record expression were translated to copatterns+ - [#4148](https://github.com/agda/agda/issues/4148): Internal error related to records and type-level indices+ - [#4152](https://github.com/agda/agda/issues/4152): Variables in Prop position should not raise hard error in occurs check+ - [#4154](https://github.com/agda/agda/issues/4154): Renaming declarations within a module may cause name clash+ - [#4158](https://github.com/agda/agda/issues/4158): Double check failure (unaware of rewrite rule)+ - [#4163](https://github.com/agda/agda/issues/4163): pattern matching in parametrized module leads to ill-typed definitions in where modules.+ - [#4170](https://github.com/agda/agda/issues/4170): Tactic causes Agda to enter into an infinite loop+ - [#4179](https://github.com/agda/agda/issues/4179): Coverage check false positive+ - [#4185](https://github.com/agda/agda/issues/4185): Agda uses η-equality for record types defined with no-eta-equality+ - [#4205](https://github.com/agda/agda/issues/4205): Internal error in connection with with, copatterns, and open record+ - [#4211](https://github.com/agda/agda/issues/4211): Cannot add as-pattern on literal pattern+ - [#4214](https://github.com/agda/agda/issues/4214): `with` abstraction fails with HIT constructors in the goal+ - [#4215](https://github.com/agda/agda/issues/4215): Case splitting should respect Nat literals+ - [#4255](https://github.com/agda/agda/issues/4255): Hole filler accepted, but type check error on reload+ - [#4261](https://github.com/agda/agda/issues/4261): Order of arguments affects lambda pattern matching+ - [#4268](https://github.com/agda/agda/issues/4268): Give failure with large quantification+ - [#4269](https://github.com/agda/agda/issues/4269): Universe levels are not solved+ - [#4283](https://github.com/agda/agda/issues/4283): DeBruijn issue(?) in standard library tests+ - [#4289](https://github.com/agda/agda/issues/4289): datatype scope and import guidelines+ - [#4297](https://github.com/agda/agda/issues/4297): Missing documentation: NO_UNIVERSE_CHECK pragma+ - [#4310](https://github.com/agda/agda/issues/4310): Anonymous .. binder should not lead to a parse error+ - [#4314](https://github.com/agda/agda/issues/4314): Internal error with generalize+ - [#4320](https://github.com/agda/agda/issues/4320): Path constructor overloading+ - [#4323](https://github.com/agda/agda/issues/4323): Internal error (Rewriting.hs:395) with generalize and rewrite rules+ - [#4330](https://github.com/agda/agda/issues/4330): Equations for cubical subtypes+ - [#4348](https://github.com/agda/agda/issues/4348): Seemingly needless repetition of highlighting of warnings+ - [#4360](https://github.com/agda/agda/issues/4360): Missing warning for declaring constructor instances for records with explicit fields+ - [#4361](https://github.com/agda/agda/issues/4361): Inconsistent highlighting of BUILTING EQUALITY/REWRITE+ - [#4371](https://github.com/agda/agda/issues/4371): Inconsistency with rewrite rules and assumptions in Prop+ - [#4373](https://github.com/agda/agda/issues/4373): Non-imported instances are used for instance resolution+ - [#4375](https://github.com/agda/agda/issues/4375): Internal error in Agda/TypeChecking/Monad/Context.hs:120+ - [#4380](https://github.com/agda/agda/issues/4380): Parse error with instance constructor and end of file+ - [#4382](https://github.com/agda/agda/issues/4382): Rewriting and records with eta+ - [#4387](https://github.com/agda/agda/issues/4387): Less responsive Emacs mode in v2.6.1 release candidate 1+ - [#4390](https://github.com/agda/agda/issues/4390): Unification finds solution with bound variable used at wrong modality+ - [#4391](https://github.com/agda/agda/issues/4391): Termination checking failed with guardedness+ - [#4399](https://github.com/agda/agda/issues/4399): Case split on unnamed argument produces non-sensical code+ - [#4401](https://github.com/agda/agda/issues/4401): Missing check on context variables leads to Set:Set with --cumulativity+ - [#4404](https://github.com/agda/agda/issues/4404): Disambiguation fails in Cubical Agda+ - [#4410](https://github.com/agda/agda/issues/4410): Rewrite rule matching does not respect Prop+ - [#4447](https://github.com/agda/agda/issues/4447): Positivity: internal error with projection in constructor type+ - [#4451](https://github.com/agda/agda/issues/4451): Highlighting: use several lookups rather than merging hash-maps?+ - [#4452](https://github.com/agda/agda/issues/4452): Compiler error when using REWRITE+ - [#4469](https://github.com/agda/agda/issues/4469): The warning machinery does not work correctly when interface files are involved+++The following previously closed issues were reopened:++ - [#1556](https://github.com/agda/agda/issues/1556): Agda allows "very dependent" types
@@ -0,0 +1,149 @@+Release notes for Agda version 2.6.2.1+======================================++Highlights+----------++* Agda 2.6.2.1 catches up to changes in the Haskell ecosystem+ (GHC 9.2.1, `aeson-2.0`, `hashable-1.4.`).++* Fixes some regressions introduced in 2.6.1:+ [#5283](https://github.com/agda/agda/issues/5283)+ [#5506](https://github.com/agda/agda/issues/5506)+ [#5610](https://github.com/agda/agda/issues/5610)++* Fixes some regressions introduced in 2.6.2:+ [#5508](https://github.com/agda/agda/issues/5508)+ [#5544](https://github.com/agda/agda/issues/5544)+ [#5565](https://github.com/agda/agda/issues/5565)+ [#5584](https://github.com/agda/agda/issues/5584)+ [#5620](https://github.com/agda/agda/issues/5620)+ [#5638](https://github.com/agda/agda/issues/5638)+ [#5657](https://github.com/agda/agda/issues/5657)++* Improvements to the compiler backends (see below).++* Feature preview: `--ghc-strict`.++Installation and infrastructure+-------------------------------++Agda 2.6.2.1 is expected to build with GHC versions 8.0 to 9.2.+It has been tested with the latest minor version releases of GHC for+each of these major versions:++ - 8.0.2+ - 8.2.2+ - 8.4.4+ - 8.6.5+ - 8.8.4+ - 8.10.7: Issue [#5539](https://github.com/agda/agda/issues/5539).+ - 9.0.1+ - 9.2.1:+ Issue [#5442](https://github.com/agda/agda/issues/5442),+ stackage issue [#6318](https://github.com/commercialhaskell/stackage/pull/6318).++Agda 2.6.2.1 has been adapted to recent changes in the Haskell ecosystem, including:++ - `Cabal-3.6.2`+ - `aeson-2.0`:+ Issue [#5593](https://github.com/agda/agda/issues/5593),+ stackage issue [#6217](https://github.com/commercialhaskell/stackage/issues/6217).+ - `hashable-1.4`:+ Stackage issue [#6268](https://github.com/commercialhaskell/stackage/issues/6268).+ - `transformers-0.6`++Compiler backends+-----------------++* Both the GHC and JS backends now refuse to compile code that uses+ `--cubical`.++* The new option `--ghc-strict-data`, which is inspired by the GHC+ language extension `StrictData`, makes the GHC backend compile+ inductive data and record constructors to constructors with strict+ arguments.++ This does not apply to certain builtin types—lists, the maybe type,+ and some types related to reflection—and might not apply to types+ with `COMPILE GHC … = data …` pragmas.++ This feature is experimental.++* The new option `--ghc-strict`, which is inspired by the GHC language+ extension `Strict`, makes the GHC backend generate mostly strict+ code.++ Functions might not be strict in unused arguments.++ Function definitions coming from `COMPILE GHC` pragmas are not+ affected.++ This flag implies `--ghc-strict-data`, and the exceptions of that+ flag applies to this flag as well.++ Note that this option requires the use of GHC 9 or later.++ This feature is experimental.++* JS backend now uses the native `BigInt` instead of the+ [biginteger.js](https://github.com/silentmatt/javascript-biginteger).+ Fixes [#4878](https://github.com/agda/agda/issues/4878).++LaTeX backend+-------------++* Files `agda.sty` and `postprocess-latex.pl` are now found in the `latex/`+ subdirectory of the Agda data directory (`agda --print-agda-dir`).++* `agda.sty` is now versioned (printed to the `.log` file by `latex`)+ (see [#5473](https://github.com/agda/agda/issues/5473)).++* Italics correction (inserted by `\textit` e.g. in `\AgdaBound`) now works,+ thanks to moving the `\textcolor` wrapping to the outside in `agda.sty`+ (see [#5471](https://github.com/agda/agda/issues/5471)).++List of closed issues+---------------------++For 2.6.2.1, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.6.2.1+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++ - [#4878](https://github.com/agda/agda/issues/4878): Replace biginteger.js with native BigInt+ - [#5283](https://github.com/agda/agda/issues/5283): Tactic command runs forever+ - [#5291](https://github.com/agda/agda/issues/5291): `match` doesn't work for non-prefix-free cases+ - [#5302](https://github.com/agda/agda/issues/5302): building tests with cabal+ - [#5396](https://github.com/agda/agda/issues/5396): Internal error for rewriting without --confluence-check+ - [#5398](https://github.com/agda/agda/issues/5398): Problem with LaTeX code for multi-line comments with blank lines+ - [#5420](https://github.com/agda/agda/issues/5420): The JS backend generates incorrect code for Agda code that uses reflection+ - [#5421](https://github.com/agda/agda/issues/5421): The GHC backend generates incorrect code for Agda code that uses reflection+ - [#5431](https://github.com/agda/agda/issues/5431): --ghc-strict-data and --ghc-strict+ - [#5433](https://github.com/agda/agda/issues/5433): The JS backend "installs" highlight-hover.js+ - [#5440](https://github.com/agda/agda/issues/5440): (Re)Documenting `catchfilebetweentags` method of building latex files with Agda+ - [#5442](https://github.com/agda/agda/issues/5442): Support GHC 9.2+ - [#5463](https://github.com/agda/agda/issues/5463): Hole in the middle of a record is malformed+ - [#5465](https://github.com/agda/agda/issues/5465): Compilation of Parser.y depends on the locale on Debian too+ - [#5469](https://github.com/agda/agda/issues/5469): `onlyReduceDefs` should not prevent evaluation of macros+ - [#5470](https://github.com/agda/agda/issues/5470): Internal error when using `REWRITE` in `private` block+ - [#5471](https://github.com/agda/agda/issues/5471): LaTeX backend: italics correction+ - [#5473](https://github.com/agda/agda/issues/5473): agda.sty has no version+ - [#5478](https://github.com/agda/agda/issues/5478): Open goal inside record causes internal error (eta-contraction)+ - [#5481](https://github.com/agda/agda/issues/5481): Pattern-matching on records in Prop allows eliminating into Set+ - [#5489](https://github.com/agda/agda/issues/5489): C-c C-x C-a (abort) does not communicate well+ - [#5490](https://github.com/agda/agda/issues/5490): Why does abort (C-c C-x C-a) remove highlighting from the buffer?+ - [#5506](https://github.com/agda/agda/issues/5506): Agda panic: Pattern match failure+ - [#5508](https://github.com/agda/agda/issues/5508): Internal error typechecking non-terminating function on case-insensitive filesystem+ - [#5514](https://github.com/agda/agda/issues/5514): Support GHC 8.10.6+ - [#5531](https://github.com/agda/agda/issues/5531): Internal bug: TypeChecking/Sort+ - [#5532](https://github.com/agda/agda/issues/5532): "The module was successfully compiled" should mention with which backend+ - [#5539](https://github.com/agda/agda/issues/5539): Support GHC 8.10.7+ - [#5544](https://github.com/agda/agda/issues/5544): Internal error caused by addition of `Checkpoints` to `OpenThing`+ - [#5557](https://github.com/agda/agda/issues/5557): Allow Agda to output data files+ - [#5565](https://github.com/agda/agda/issues/5565): Internal error in Agda.TypeChecking.MetaVars+ - [#5593](https://github.com/agda/agda/issues/5593): Compilation failure with `aeson-2`+ - [#5602](https://github.com/agda/agda/issues/5602): The JS backend does not reduce constructor type signatures+ - [#5610](https://github.com/agda/agda/issues/5610): Panic when checking pragma BUILTIN SHARP+ - [#5620](https://github.com/agda/agda/issues/5620): Seemingly incorrect warning for abstract definition without type signature+ - [#5633](https://github.com/agda/agda/issues/5633): Case splitting inserts one with pattern too much (regression in 2.6.2)+ - [#5657](https://github.com/agda/agda/issues/5657): Internal error with postfix projection
@@ -0,0 +1,109 @@+Release notes for Agda version 2.6.2.2+======================================++Highlights+----------++* Agda 2.6.2.2 catches up to changes in the Haskell ecosystem+ (`bytestring-0.11.2.0`, `mtl-2.3-rc3/4`, `text-icu-0.8.0.1`,+ stackage `lts-19.0` and `nightly`).++* Fixes inconsistency [#5838](https://github.com/agda/agda/issues/5838)+ in `--cubical`.++* Fixes some regressions introduced in 2.6.1:++ - [#5809](https://github.com/agda/agda/issues/5809):+ internal error with `--irrelevant-projections`.++* Fixes some regressions introduced in 2.6.2:++ - [#5705](https://github.com/agda/agda/issues/5705) and+ [#5706](https://github.com/agda/agda/issues/5706):+ inconsistency from universe level `Int` overflow.++ - [#5784](https://github.com/agda/agda/issues/5784):+ `primEraseEquality` does not compute.++ - [#5805](https://github.com/agda/agda/issues/5805):+ internal error involving holes and `with`.++ - [#5819](https://github.com/agda/agda/issues/5819):+ internal error when reducing in termination checker.++* Other+ [fixes](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.6.2.2+is%3Aclosed)+ and improvements (see below).++Installation and infrastructure+-------------------------------++Agda supports GHC versions 8.0.2 to 9.2.2.++* UTF-8 encoding is now used for the `libraries` and `executables`+ configuration files (issue+ [#5741](https://github.com/agda/agda/issues/5741)).++Language+--------++* `macro` definitions can now be used even when they are declared as erased+ (PR [#5744](https://github.com/agda/agda/pull/5744)).+ For example, this is now accepted:+ ```agda+ macro+ @0 trivial : Term → TC ⊤+ trivial = unify (con (quote refl) [])++ test : 42 ≡ 42+ test = trivial+ ```++* Fixed inconsistent `--cubical` reductions for `transp`:+ issue [#5838](https://github.com/agda/agda/issues/5838).++* Fixed issues with reflection:++ - [#5762](https://github.com/agda/agda/issues/5762):+ do not eagerly check existence of commands in `executables` file.++ - [#5695](https://github.com/agda/agda/issues/5695):+ fix `elaborate-and-give` interaction command.++ - [#5700](https://github.com/agda/agda/issues/5700):+ scope of metas created during macro expansion.++ - [#5712](https://github.com/agda/agda/issues/5712):+ internal error with tactics on record fields of function type.++* Fixed issues with instance search:++ - [#5583](https://github.com/agda/agda/issues/5583):+ constructor instances from parameterized modules.++ - [#5787](https://github.com/agda/agda/issues/5787):+ erased instance arguments.++* Fixed issue [#5683](https://github.com/agda/agda/issues/5683) with+ generalization in `let`.++Compiler backends+-----------------++* `.hs` files generated by the GHC backend now switch off the+ `warn-overlapping-patterns` warning (issue+ [#5758](https://github.com/agda/agda/issues/5758)).++* The GHC backend now calls `ghc` with environment setting+ `GHC_CHARENC=UTF-8` (issue+ [#5742](https://github.com/agda/agda/issues/5742)).++Performance+-----------++* Better caching of interfaces+ (issue [#2767](https://github.com/agda/agda/issues/2767)).++* Various performance improvements concerning meta-variables:+ issue [#5388](https://github.com/agda/agda/issues/5388)+ and PR [#5733](https://github.com/agda/agda/pull/5733).
@@ -0,0 +1,1250 @@+Release notes for Agda version 2.6.2+====================================++Highlights+----------++* Several improvements and bug-fixes related to [Run-time+ Irrelevance](https://agda.readthedocs.io/en/v2.6.2/language/runtime-irrelevance.html).++* Several improvements and bug-fixes related to the [JavaScript+ Backend](https://agda.readthedocs.io/en/v2.6.2/tools/compilers.html#javascript-backend).++* Added experimental support for [Guarded Cubical+ Agda](https://agda.readthedocs.io/en/v2.6.2/language/guarded-cubical.html).++* The [Primitive+ Sorts](https://agda.readthedocs.io/en/v2.6.2/language/built-ins.html#sorts)+ of Agda (`Set` and `Prop`) are no longer keywords and can be renamed+ when importing `Agda.Primitive`.++* Added native support for the [Inspect+ Idiom](https://agda.readthedocs.io/en/v2.6.2/language/with-abstraction.html#with-abstraction-equality).++* Added support for making [System+ Calls](https://agda.readthedocs.io/en/v2.6.2/language/reflection.html#system-calls)+ from the reflection API.++Installation and infrastructure+-------------------------------++* Added support for GHC 8.10.5 and 9.0.1.++* Some expensive optimisations are now off by default+ (see [#4521](https://github.com/agda/agda/issues/4521)).++ These optimisations can in some cases make Agda substantially+ faster, but they can also make the compilation of the Agda program+ take more time and space.++ The optimisations can be turned on manually (Cabal:+ `-foptimise-heavily`, Stack: `--flag Agda:optimise-heavily`). They+ are turned on (by default) when Agda is installed using `make+ install`.++ If the optimisations are turned on it might make sense to limit+ GHC's memory usage (using something like `--ghc-options="+RTS -M6G+ -RTS"`).++Pragmas and options+-------------------++* New option `--auto-inline` turns on automatic compile-time inlining+ of simple functions. This was previously enabled by default.++ Note that the absence of automatic inlining can make typechecking+ substantially slower.++ The new default has repercussions on termination checking, for instance+ (see [#4702](https://github.com/agda/agda/issues/4702)).+ The following formulation of `plus` termination checks with `--auto-inline`+ but not without:+ ```agda+ open import Agda.Builtin.Nat++ case_of_ : {A B : Set} → A → (A → B) → B+ case x of f = f x++ plus : Nat → Nat → Nat+ plus m n = case m of λ+ { zero → n+ ; (suc m) → suc (plus m n)+ }+ ```+ In this particular case, we can work around the limitation of the+ termination checker with pragma `{-# INLINE case_of_ #-}`.++* New options `--qualified-instances` (default) and+ `--no-qualified-instances`. When `--no-qualified-instances` is+ enabled, Agda will only consider candidates for instance search that+ are in scope under an unqualified name (see+ [#4522](https://github.com/agda/agda/pull/4522)).++* New option `--call-by-name` turns off call-by-need evaluation at type+ checking time.++* New option `--highlight-occurrences` (off by default) enables the HTML+ backend to include a JavaScript file that highlights all occurrences of+ the mouse-hovered symbol (see+ [#4535](https://github.com/agda/agda/pull/4535)).++* New option `--no-import-sorts` disables the implicit `open+ import Agda.Primitive using (Set; Prop)` at the top of each file+ (see below).++* New option `--local-confluence-check` to restore the old behaviour+ of the `--confluence-check` flag (see below for the new behaviour).++* New primitive `primStringFromListInjective` internalising the fact that+ `primStringFromList` is an injective function. It is bound in+ `Agda.Builtin.String.Properties`.++* New option `--allow-exec` enables the use of system calls during+ type checking using the `AGDATCMEXECTC` builtin.++* New option `--show-identity-substitutions` shows all arguments of+ metavariables when pretty-printing a term, even if they amount to+ just applying all the variables in the context.++* The option `--rewriting` is now considered infective: if a module has+ `--rewriting` enabled, then all modules importing it must also have+ `--rewriting` enabled.++* New option `--no-double-check` (default), opposite of the existing+ `--double-check`.++* Due to several known soundness issues with sized types (see+ [#1201](https://github.com/agda/agda/issues/1201),+ [#1946](https://github.com/agda/agda/issues/1946),+ [#2820](https://github.com/agda/agda/issues/2820),+ [#3026](https://github.com/agda/agda/issues/3026)), the+ `--sized-types` flag can no longer be used while `--safe` is active.++* New option `--guarded` turns on the Guarded Cubical extension of Agda.++ See [Guarded Cubical](https://agda.readthedocs.io/en/v2.6.2/language/guarded-cubical.html)+ in the documentation for more.++* The flags `--guardedness` and `--sized-types` are no longer enabled+ by default.++Command-line interaction+------------------------++* In the previous release, Agda exited with either status 0 when the+ program type checks successfully, or status 1 when encountering any+ kind of error. Now Agda exits with status 42 for type errors, 71+ for errors in the commandline arguments, and 154 for impossible+ errors. Exit status 1 may be returned under other circumstances; for+ instance, an incomplete pattern matching, or an error generated by+ the Haskell runtime. See PR+ [#4540](https://github.com/agda/agda/pull/4540).++Lexical syntax+--------------++* Layout handling has been improved so that block starters can be+ stacked on the same line+ [#1145](https://github.com/agda/agda/issues/1145).++ If several layout blocks are started by layout keywords without line+ break in between (where line breaks inside block comments do not+ count), then those blocks indented *more* than the last block go+ passive, meaning they cannot be further extended by new statements.+ ```agda+ private module M where postulate+ A : Set -- module-block goes passive+ B : Set -- postulate-block can still be extended+ module N where -- private-block can still be extended+ ```+ Previously, this was a parse error.++Language+--------++* Inductive records without η-equality no longer support both matching+ on the record constructor and construction of record elements by+ copattern matching. It has been discovered that the combination of+ both leads to loss of subject reduction, i.e., reduction does not+ preserve typing. See issue+ [#4560](https://github.com/agda/agda/issues/4560).++ η-equality for a record can be turned off manually with directive+ `no-eta-equality` or command-line option `--no-eta-equality`, but it+ is also automatically turned off for some recursive records. For+ records without η, matching on the record constructor is now off by+ default and construction by copattern matching is on. If you want+ the converse, you can add the new record directive `pattern`.++ Example with record pattern:+ ```agda+ record N : Set where+ inductive+ no-eta-equality+ pattern+ field out : Maybe N++ pred : N → Maybe N+ pred record{ out = m } = m+ ```+ Example with record constructor and use of `;` instead of newline:+ ```agda+ record N : Set where+ inductive; no-eta-equality+ pattern; constructor inn+ field out : Maybe N++ pred : N → Maybe N+ pred (inn m) = m+ ```++* `Set` and `Prop` are no longer keywords but are now primitives+ defined in the module `Agda.Primitive`. They can be renamed when+ importing this module, for example:++ ```agda+ open import Agda.Primitive renaming (Set to Type)++ test : Type₁+ test = Type+ ```++ To preserve backwards compatibility, each top-level Agda module now+ starts with an implicit statement:++ ```agda+ open import Agda.Primitive using (Set; Prop)+ ```++ This implicit import can be disabled with the+ `--no-import-sorts` flag.++* Agda now has support for sorts `Setωᵢ` (alternative syntax: `Setωi`)+ for natural numbers `i`, where `Setω₀ = Setω`. These sorts form a+ second hierarchy `Setωᵢ : Setωᵢ₊₁` similar to the standard hierarchy+ of `Setᵢ`, but do not support universe polymorphism. It should not+ be necessary to refer to these sorts during normal usage of Agda,+ but they might be useful for defining reflection-based macros (see+ [#2119](https://github.com/agda/agda/issues/2119) and+ [#4585](https://github.com/agda/agda/issues/4585)).++* Changed the internal representation of literal strings: instead of using a+ linked list of characters (`String`), we are now using `Data.Text`. This+ should be a transparent change from the user's point of view: the backend+ was already packing these strings as text.++ Used this opportunity to introduce a `primStringUncons` primitive in+ `Agda.Builtin.String` (and to correspondingly add the+ `Agda.Builtin.Maybe` it needs).++* The option `--confluence-check` for rewrite rules has been given a+ new implementation that checks global confluence instead of local+ confluence. Concretely, it does so by enforcing two properties:++ 1. For any two left-hand sides of the rewrite rules that overlap+ (either at the root position or at a subterm), the most general+ unifier of the two left-hand sides is again a left-hand side of a+ rewrite rule. For example, if there are two rules `suc m + n =+ suc (m + n)` and `m + suc n = suc (m + n)`, then there should+ also be a rule `suc m + suc n = suc (suc (m + n))`.++ 2. Each rewrite rule should satisfy the *triangle property*: For any+ rewrite rule `u = w` and any single-step parallel unfolding `u =>+ v`, we should have another single-step parallel unfolding `v =>+ w`.++ The previous behaviour of the confluence checker that only ensures+ local confluence can be restored by using the+ `--local-confluence-check` flag.++* Binary integer literals with prefix `0b` (for instance,+ `0b11001001`) are now supported.++* Overloaded literals now require the conversion function (`fromNat`,+ `fromNeg`, or `fromString`) to be in scope *unqualified* to take+ effect.++ Previously, it was enough for the function to be in scope at all,+ which meant you couldn't import the corresponding builtin module+ without having overloaded literals turned on.++* Added `interleaved mutual` blocks where users can forward-declare+ function, record, and data types and interleave their+ definitions. These blocks are elaborated to more traditional mutual+ blocks by:++ - leaving the signatures where they are+ - grouping the clauses for a function together with the first of them+ - grouping the constructors for a datatype together with the first of them++ Example: two interleaved function definitions++ ```agda++ interleaved mutual++ -- Declarations:+ even : Nat → Bool+ odd : Nat → Bool++ -- zero is even, not odd+ even zero = true+ odd zero = false++ -- suc case: switch evenness on the predecessor+ even (suc n) = odd n+ odd (suc n) = even n+ ```++ Other example: the definition of universe of types closed under the+ natural numbers and pairing:++ ```agda++ interleaved mutual++ -- Declaration of a product record, a universe of codes, and a decoding function+ record _×_ (A B : Set) : Set+ data U : Set+ El : U → Set++ -- We have a code for the type of natural numbers in our universe+ constructor `Nat : U+ El `Nat = Nat++ -- Btw we know how to pair values in a record+ record _×_ A B where+ constructor _,_+ inductive+ field fst : A; snd : B++ -- And we have a code for pairs in our universe+ constructor _`×_ : (A B : U) → U+ El (A `× B) = El A × El B+ ```++* Erased constructors (see+ [#4638](https://github.com/agda/agda/issues/4638)).++ Constructors can be marked as erased. Example:+ ```agda+ {-# OPTIONS --cubical --safe #-}++ open import Agda.Builtin.Cubical.Path+ open import Agda.Primitive++ private+ variable+ a : Level+ A B : Set a++ Is-proposition : Set a → Set a+ Is-proposition A = (x y : A) → x ≡ y++ data ∥_∥ (A : Set a) : Set a where+ ∣_∣ : A → ∥ A ∥+ @0 trivial : Is-proposition ∥ A ∥++ rec : @0 Is-proposition B → (A → B) → ∥ A ∥ → B+ rec p f ∣ x ∣ = f x+ rec p f (trivial x y i) = p (rec p f x) (rec p f y) i+ ```+ In the code above the constructor `trivial` is only available at+ compile-time, whereas `∣_∣` is also available at run-time. Erased+ names can be used in bodies of clauses that match on `trivial`, if+ the match is done in a non-erased position, like in the final clause+ of `rec`. (Note that Cubical Agda programs still cannot be+ compiled.)++* Erased pattern-matching lambdas (see+ [#4525](https://github.com/agda/agda/issues/4525)).++ Regular pattern-matching lambdas are treated as non-erased+ function definitions. One can make a pattern-matching lambda erased+ by writing `@0` or `@erased` after the lambda:+ ```agda+ @0 _ : @0 Set → Set+ _ = λ @0 { A → A }++ @0 _ : @0 Set → Set+ _ = λ @erased where+ A → A+ ```++ The reflection machinery currently does not support erased+ pattern-matching lambdas (they are quoted as regular+ pattern-matching lambdas).++* New (?) rule for modalities of generalised variables+ (see [#5058](https://github.com/agda/agda/issues/5058)).++ The new rule is that generalisable variables get the modality that+ they are declared with, whereas other variables always get the+ default modality. (It is unclear what the old rule was, perhaps+ nothing was changed.)++* Private abstract type signatures can no longer see through abstract+ (see [#418](https://github.com/agda/agda/issues/418)).++ This means that abstract definitions no longer evaluate in *any*+ type signatures in the same module. Previously they evaluated in+ type signatures of definitions that were both private and abstract.++ It also means that metavariables in type signatures have to be+ solved locally, and cannot make use of information in the definition+ body, and that constructors of abstract datatypes are not in scope+ in type signatures.++* Type inference is disabled for abstract definitions (see+ [#418](https://github.com/agda/agda/issues/418)).++ This means that abstract definitions (inluding functions defined in+ `where` blocks of abstract definitions) need complete type+ signatures.++* One can now declare syntax with two name parts without any hole in+ between, and syntax without any holes.++ Examples:+ ```agda+ syntax Σ A (λ x → B) = [ x ∶ A ] × B+ syntax [] = [ ]+ ```++* Internalised the *inspect idiom* that allows users to abstract over+ an expression in a ``with`` clause while, at the same time,+ remembering the origin of the abstracted pattern via an equation.++ In the following example, abstracting over and then matching on the+ result of ``p x`` allows the first call to ``filter p (x ∷ xs)`` to+ reduce.++ In case the element ``x`` is kept, the second call to ``filter`` on+ the LHS then performs the same ``p x`` test. Because we have+ retained the proof that ``p x ≡ true`` in ``eq``, we are able to+ rewrite by this equality and get it to reduce too.++ This leads to just enough computation that we can finish the proof+ with an appeal to congruence and the induction hypothesis.++ ```agda+ filter-filter : ∀ p xs → filter p (filter p xs) ≡ filter p xs+ filter-filter p [] = refl+ filter-filter p (x ∷ xs) with p x in eq+ ... | false = filter-filter p xs -- easy+ ... | true -- second filter stuck on `p x`: rewrite by `eq`!+ rewrite eq = cong (x ∷_) (filter-filter p xs)+ ```++* As a consequence of the above extensions to `with`, lambdas and lets+ now need parentheses when appearing in a `with`. For instance,++ ```agda+ with-on-fun : Nat → Nat+ with-on-fun n with (λ m → m + n) -- parentheses required!+ ... | f = f n+ ```++* It is now possible to add hiding and relevance annotations to `with`+ expressions. For example:++ ```agda+ module _ (A B : Set) (recompute : .B → .{{A}} → B) where++ _$_ : .(A → B) → .A → B+ f $ x with .{f} | .(f x) | .{{x}}+ ... | y = recompute y+ ```++Builtins+--------++- Primitive operations for floating-point numbers changed. The equalities now+ follow IEEE 754 equality, after unifying all NaNs. Primitive inequality was+ added:+ ```agda+ primFloatEquality : Float -> Float -> Bool -- from primFloatNumericEquality+ primFloatLess : Float -> Float -> Bool -- from primFloatNumericLess+ primFloatInequality : Float -> Float -> Bool -- new+ ```+ The “numeric” relations are now deprecated.++ There are several new predicates on floating-point numbers:+ ```agda+ primFloatIsInfinite : Float -> Bool -- new+ primFloatIsNaN : Float -> Bool -- new+ primFloatIsSafeInteger : Float -> Bool -- new+ ```+ The `primFloatIsSafeInteger` function determines whether the value is a number+ that is a safe integer, i.e., is within the range where the arithmetic+ operations do not lose precision.++ The operations for conversion to integers (`primRound`, `primFloor`,+ and `primCeiling`) were renamed for consistency, and return a value+ of type `Maybe Int`, returning `nothing` for NaN and the infinities:+ ```agda+ primFloatRound : Float → Maybe Int -- from primRound+ primFloatFloor : Float → Maybe Int -- from primFloor+ primFloatCeiling : Float → Maybe Int -- from primCeiling+ ```++ There are several new conversions:+ ```agda+ primIntToFloat : Int -> Float -- new+ primFloatToRatio : Float -> (Int × Nat) -- new+ primRatioToFloat : Int -> Nat -> Float -- new+ primFloatDecode : Float -> Maybe (Int × Int) -- new+ primFloatEncode : Int -> Int -> Maybe Float -- new+ ```+ The `primFloatDecode` function decodes a floating-point number f to a mantissa+ and exponent, such that `f = mantissa * 2 ^ exponent`, normalised such that+ the mantissa is the smallest possible number. The `primFloatEncode` function+ encodes a pair of a mantissa and exponent to a floating-point number.++ There are several new operations:+ ```agda+ primFloatPow : Float -> Float -> Float -- new+ primFloatATan2 : Float -> Float -> Float -- from primATan2+ primFloatSinh : Float -> Float -- new+ primFloatCosh : Float -> Float -- new+ primFloatTanh : Float -> Float -- new+ primFloatASinh : Float -> Float -- new+ primFloatACosh : Float -> Float -- new+ primFloatATanh : Float -> Float -- new+ ```+ Furthermore, the following operations were renamed for consistency:+ ```agda+ primFloatExp : Float -> Float -- from primExp+ primFloatSin : Float -> Float -- from primSin+ primFloatLog : Float -> Float -- from primLog+ primFloatCos : Float -> Float -- from primCos+ primFloatTan : Float -> Float -- from primTan+ primFloatASin : Float -> Float -- from primASin+ primFloatACos : Float -> Float -- from primACos+ primFloatATan : Float -> Float -- from primATan+ ```++ All of these operations are implemented on the JavaScript backend.++- `primNatToChar` maps surrogate code points to the replacement character+ `'U+FFFD` and surrogate code points are disallowed in character literals++ [Surrogate code points](https://www.unicode.org/glossary/#surrogate_code_point)+ are characters in the range `U+D800` to `U+DFFF` and are reserved for use by+ UTF-16.++ The reason for this change is that strings are represented (at type-checking+ time and in the GHC backend) by Data.Text byte strings, which cannot+ represent surrogate code points and replaces them by `U+FFFD`. By doing the+ same for characters we can have `primStringFromList` be injective (witnessed+ by `Agda.Builtin.String.Properties.primStringFromListInjective`).+++Reflection+----------++- New operation in `TC` monad, similar to `quoteTC` but operating on+ types in `Setω`+ ```agda+ quoteωTC : ∀ {A : Setω} → A → TC Term+ ```+- `typeError` and `debugPrint` no longer inserts spaces around `termErr` and+ `nameErr` parts. They also do a better job of respecting line breaks in+ `strErr` parts.++- The reflection machinery now supports quantities in `Arg` (see+ [#5317](https://github.com/agda/agda/issues/5317)). The `ArgInfo`+ type has changed, and there are new types `Modality` and `Quantity`:+ ```agda+ data Quantity : Set where+ quantity-0 quantity-ω : Quantity++ {-# BUILTIN QUANTITY Quantity #-}+ {-# BUILTIN QUANTITY-0 quantity-0 #-}+ {-# BUILTIN QUANTITY-ω quantity-ω #-}++ data Modality : Set where+ modality : (r : Relevance) (q : Quantity) → Modality++ {-# BUILTIN MODALITY Modality #-}+ {-# BUILTIN MODALITY-CONSTRUCTOR modality #-}++ data ArgInfo : Set where+ arg-info : (v : Visibility) (m : Modality) → ArgInfo+ ```++- The representation of reflected patterns and clauses has+ changed. Each clause now includes a telescope with the names and+ types of the pattern variables.++ ```agda+ data Clause where+ clause : (tel : List (Σ String λ _ → Arg Type)) (ps : List (Arg Pattern)) (t : Term) → Clause+ absurd-clause : (tel : List (Σ String λ _ → Arg Type)) (ps : List (Arg Pattern)) → Clause+ ```++ These telescopes provide additional information on the types of+ pattern variables that was previously hard to reconstruct (see+ [#2151](https://github.com/agda/agda/issues/2151)). When unquoting a+ clause, the types in the clause telescope are currently ignored (but+ this is subject to change in the future).++ Three constructors of the `Pattern` datatype were also changed:++ * pattern variables now refer to a de Bruijn index (relative to the+ clause telescope) rather than a string,+ * absurd patterns take a de Bruijn index and are expected to be bound by the+ clause telescope,+ * dot patterns now include the actual dotted term.++ ```agda+ data Pattern where+ con : (c : Name) (ps : List (Arg Pattern)) → Pattern+ dot : (t : Term) → Pattern -- previously: dot : Pattern+ var : (x : Nat) → Pattern -- previously: var : (x : String) → Pattern+ lit : (l : Literal) → Pattern+ proj : (f : Name) → Pattern+ absurd : (x : Nat) → Pattern+ ```++ It is likely that this change to the reflected syntax requires you+ to update reflection code written for previous versions of+ Agda. Here are some tips for updating your code:++ * When quoting a clause, you can recover the name of a pattern+ variable by looking up the given index in the clause+ telescope. The contents of dot patterns can safely be ignored+ (unless you have a use for them).++ * When creating a new clause for unquoting, you need to create a+ telescope for the types of the pattern variables. To get back the+ old behaviour of Agda, it is sufficient to set all the types of+ the pattern variables to `unknown`. So you can construct the+ telescope by listing the names of all pattern variables and absurd+ patterns together with their `ArgInfo`. Meanwhile, the pattern+ variables should be numbered in order to update them to the new+ representation. As for the telescope types, the contents of a+ `dot` pattern can safely be set to `unknown`.++- New operation in `TC` monad, `execTC`, which calls an external executable+ ```agda+ execTC : (exe : String) (args : List String) (stdIn : String)+ → TC (Σ Nat (λ _ → Σ String (λ _ → String)))+ ```+ The `execTC` builtin takes three arguments: the basename of the+ executable (e.g., `"echo"`), a list of arguments, and the contents+ of the standard input. It returns a triple, consisting of the exit+ code (as a natural number), the contents of the standard output, and+ the contents of the standard error.++ The builtin is only available when `--allow-exec` is passed. (Note+ that `--allow-exec` is incompatible with ``--safe``.) To make an+ executable available to Agda, add the absolute path on a new line in+ `~/.agda/executables`.++- Two new operations in the `TC` monad, `onlyReduceDefs` and+ `dontReduceDefs`:+ ```agda+ onlyReduceDefs : ∀ {a} {A : Set a} → List Name → TC A → TC A+ dontReduceDefs : ∀ {a} {A : Set a} → List Name → TC A → TC A+ ```+ These functions allow picking a specific set of functions that+ should (resp. should not) be reduced while executing the given `TC`+ computation.++ For example, the following macro unifies the current hole with the+ term `3 - 3`:+ ```agda+ macro₁ : Term -> TC ⊤+ macro₁ goal = do+ u ← quoteTC ((1 + 2) - 3)+ u' ← onlyReduceDefs (quote _+_ ∷ []) (normalise u)+ unify u' goal+ ```+- New operation in the `TC` monad, `withReconstructed`:+ ```agda+ withReconstructed : ∀ {a} {A : Set a} → TC A → TC A+ ```++ This function ensures reconstruction of hidden parameters+ after performing the `TC` computation. For example, consider the+ following type and function:+ ```agda+ record RVec {a} (X : Set a) (n : Nat) : Set a where+ constructor vec+ field sel : Fin n → X++ test-rvec : Nat → RVec Nat 5+ test-rvec x = vec λ _ → x+ ```++ In the reflected syntax the body of the `test-rvec` would be represented+ as `con vec (unknown ∷ unknown ∷ unknown ∷ (lam _ x)`. The use of+ `withReconstructed` replaces `unknown`s with the actual values:+ ```agda+ macro₂ : Name → Term → TC ⊤+ macro₂ n hole = do+ (function (clause tel ps t ∷ [])) ←+ withReconstructed (getDefinition n)+ where _ → quoteTC "ERROR" >>= unify hole+ quoteTC t >>= unify hole+ ```++- Three new constructors in the `Sort` datatype, `prop : Level →+ Sort`, `propLit : Nat → Sort`, and `inf : Nat → Sort`, representing+ the sorts `Prop ℓ`, `Propᵢ`, and `Setωᵢ`.++- Terms that belong to a type in `Prop` are no longer unquoted to+ `unknown` but to a proper `Term`. (See+ [#3553](https://github.com/agda/agda/issues/3553).)++Library management+------------------++- `.agda-lib` files can now contain an extra field `flags:` with+ default flags for the library. Flags can be any flags that are+ accepted as part of an `{-# OPTIONS ... #-}` pragma. For example,+ file `my-library.agda-lib` with++ ```+ flags: --without-K+ ```++ will apply the `--without-K` flag to all Agda files in the current+ directory and (recursive) subdirectories that do not themselves+ contain an `.agda-lib` file.+++Emacs mode+----------++* New command prefix `C-u C-u C-u` for weak-head normalization. For instance,+ given++ ```agda+ downFrom : Nat → List Nat+ downFrom 0 = []+ downFrom (suc n) = n ∷ downFrom n+ ```++ `C-u C-u C-u C-c C-n downFrom 5` returns `4 ∷ downFrom 4`.++* New keyboard shortcut `C-c C-x C-i` for toggling display of+ irrelevant arguments.++* One can no longer use commands like `M-;` (`comment-dwim`) to+ uncomment block comments. In return one can use `M-;` to comment out+ pragmas. (See [#3329](https://github.com/agda/agda/issues/3329).)++JSON Interaction mode+---------------------++Changes have been made to the structure of error and warning+messages. The changes are summarized below. See+[#5052](https://github.com/agda/agda/issues/5052) for additional+details.++* The format of an error or warning was previously a bare string. Now, errors+ and warnings are represented by an object with a `"message"` key.++ This means that responses _previously_ structured like:++ ```json+ {"…": "…", "error": "Foo bar baz"}+ ```++ will now be structured:++ ```json+ {"…": "…", "error": {"message": "Foo bar baz"}}+ ```++ This applies directly to the `PostPonedCheckFunDef` response kind+ and `Error` info kind of the `DisplayInfo` response kind.++* The format of collections of errors or warnings, which previously were each+ represented by a single newline-joined string, has been updated to represent+ each warning or error individually in a list.++ That means that responses _previously_ structured like:++ ```json+ { "…": "…"+ , "errors": "Postulates overcooked\nAxioms too wiggly"+ , "warnings": "Something wrong\nSomething else\nwrong"+ }+ ```++ will now be structured:++ ```json+ { "…": "…"+ , "errors":+ [ { "message": "Postulates overcooked" }+ , { "message": "Axioms too wiggly" }+ ]+ , "warnings":+ [ { "message": "Something wrong" }+ , { "message": "Something else\nwrong" }+ ]+ }+ ```++ This applies to `CompilationOk`, `AllGoalsWarning`, and `Error` info+ kinds of the `DisplayInfo` response kind.++* The `Error` info kind of the `DisplayInfo` response kind has+ additionally been updated to distinguish warnings and errors.++ An example of the _previous_ format of a `DisplayInfo` response with+ an `Error` info kind was:+ ```json+ {+ "kind": "DisplayInfo",+ "info": {+ "kind": "Error",+ "message": "———— Error —————————————————————————————————————————————————\n/data/code/agda-test/Test.agda:2,1-9\nFailed to find source of module M in any of the following\nlocations:\n /data/code/agda-test/M.agda\n /data/code/agda-test/M.lagda\nwhen scope checking the declaration\n import M\n\n———— Warning(s) ————————————————————————————————————————————\n/data/code/agda-test/Test.agda:3,1-10\nEmpty postulate block."+ }+ }+ ```++ The updated format is:+ ```json+ {+ "kind": "DisplayInfo",+ "info": {+ "kind": "Error",+ "error": {+ "message": "/data/code/agda-test/Test.agda:2,1-9\nFailed to find source of module M in any of the following\nlocations:\n /data/code/agda-test/M.agda\n /data/code/agda-test/M.lagda\nwhen scope checking the declaration\n import M"+ },+ "warnings": [+ {+ "message": "/data/code/agda-test/Test.agda:3,1-10\nEmpty postulate block."+ }+ ]+ }+ }+ ```++Compiler backends -----------------++- With option `--allow-unsolved-metas`, code with holes can be compiled.+ If a hole is reached at runtime, the compiled program crashes.+ See issue [#5103](https://github.com/agda/agda/issues/5103)++- Previously the GHC backend compiled at least one instance of Hinze's+ memoisation technique from ["Memo functions,+ polytypically!"](http://www.cs.ox.ac.uk/ralf.hinze/publications/index.html#P11)+ to reasonably efficient code. That is no longer the case (at least+ for that particular instance, see+ [#5153](https://github.com/agda/agda/issues/5153)).++LaTeX backend+-------------++- The spacing in comments is now preserved when generating LaTex files+ from literate Agda. See+ [#5320](https://github.com/agda/agda/pull/5320) for more details.++HTML backend+------------++- The named `id` attributes for local modules inside local modules are+ now different (see [#5335](https://github.com/agda/agda/pull/5320)).++ For instance, consider the following Agda file:+ ```agda+ module Top-level where++ module Inner where++ module Inside-inner where+ ```+ Previously one could link to the module `Inside-inner` using a URL+ that ended with `#Inside-inner`. Now one can use+ `#Inner.Inside-inner` instead.++JS backend+----------++- Smaller local variable names in the generated JS code.++ Previously: `x0`, `x1`, `x2`, ...++ Now: `a`, `b`, `c`, ..., `z`, `a0`, `b0`, ..., `z0`, `a1`, `b1`, ...++- Improved indentation of generated JS code.++- More compact rendering of generated JS functions.++ Previously:+ ```js+ exports["N"]["suc"] = function (x0) {+ return function (x1) {+ return x1["suc"](x0);+ };+ };+ ```++ Now:+ ```js+ exports["N"]["suc"] = a => b => b["suc"](a);+ ```++- Irrelevant arguments are now erased in the generated JS code.++ Example Agda code:+ ```agda+ flip : {A B C : Set} -> (B -> A -> C) -> A -> B -> C+ flip f a b = f b a+ ```++ Previously generated JS code:+ ```js+ exports["flip"] = function (x0) {+ return function (x1) {+ return function (x2) {+ return function (x3) {+ return function (x4) {+ return function (x5) {+ return x3(x5)(x4);+ };+ };+ };+ };+ };+ };+ ```++ JS code generated now:+ ```js+ exports["flip"] = a => b => c => a(c)(b);+ ```++- Record fields are not stored separately (the fields are stored only+ in the constructor) in the generated JS code.++ Example Agda code:+ ```agda+ record Sigma (A : Set) (B : A -> Set) : Set where+ field+ fst : A+ snd : B fst+ ```++ Previously generated JS code (look at the `"fst"` and `"snd"` fields in the+ return value of `exports["Sigma"]["record"]`:+ ```js+ exports["Sigma"] = {};+ exports["Sigma"]["fst"] = function (x0) {+ return x0["record"]({+ "record": function (x1, x2) {+ return x1;+ }+ });+ };+ exports["Sigma"]["snd"] = function (x0) {+ return x0["record"]({+ "record": function (x1, x2) {+ return x2;+ }+ });+ };+ exports["Sigma"]["record"] = function (x0) {+ return function (x1) {+ return {+ "fst": x0,+ "record": function (x2) {+ return x2["record"](x0, x1);+ },+ "snd": x1+ };+ };+ };+ ```++ JS code generated now:+ ```js+ exports["Sigma"] = {};+ exports["Sigma"]["fst"] = a => a["record"]({"record": (b,c) => b});+ exports["Sigma"]["snd"] = a => a["record"]({"record": (b,c) => c});+ exports["Sigma"]["record"] = a => b => ({"record": c => c["record"](a,b)});+ ```++- `--js-optimize` flag has been added to the `agda` compiler.++ With `--js-optimize`, `agda` does not wrap records in JS objects.++ Example Agda code:+ ```agda+ record Sigma (A : Set) (B : A -> Set) : Set where+ field+ fst : A+ snd : B fst+ ```++ JS code generated without the `--js-optimize` flag:+ ```js+ exports["Sigma"] = {};+ exports["Sigma"]["fst"] = a => a["record"]({"record": (b,c) => b});+ exports["Sigma"]["snd"] = a => a["record"]({"record": (b,c) => c});+ exports["Sigma"]["record"] = a => b => ({"record": c => c["record"](a,b)});+ ```++ JS code generated with the `--js-optimize` flag:+ ```js+ exports["Sigma"] = {};+ exports["Sigma"]["fst"] = a => a((b,c) => b);+ exports["Sigma"]["snd"] = a => a((b,c) => c);+ exports["Sigma"]["record"] = a => b => c => c(a,b);+ ```++ With `--js-optimize`, `agda` uses JS arrays instead of JS objects.+ This is possible because constructor names are not relevant during the evaluation.++ Example Agda code:+ ```agda+ data Bool : Set where+ false : Bool+ true : Bool++ not : Bool -> Bool+ not false = true+ not true = false+ ```++ JS code generated without the `--js-optimize` flag:+ ```js+ exports["Bool"] = {};+ exports["Bool"]["false"] = a => a["false"]();+ exports["Bool"]["true"] = a => a["true"]();+ exports["not"] = a => a({+ "false": () => exports["Bool"]["true"],+ "true": () => exports["Bool"]["false"]+ });+ ```++ JS code generated with the `--js-optimize` flag:+ ```js+ exports["Bool"] = {};+ exports["Bool"]["false"] = a => a[0/* false */]();+ exports["Bool"]["true"] = a => a[1/* true */]();+ exports["not"] = a => a([+ /* false */() => exports["Bool"]["true"],+ /* true */() => exports["Bool"]["false"]+ ]);+ ```++ Note that comments are added to generated JS code to help human readers.++ Erased branches are replaced by `null` in the generated array. If+ more than the half of branches are erased, the array is compressed+ to be a object like `{3: ..., 13: ...}`.++- `--js-minify` flag has been added to the `agda` compiler.++ With `--js-minify`, `agda` discards comments and whitespace in the+ generated JS code.+++Agda as a library (API)+-----------------------++* The `SourceInfo` record has been renamed to `Source`, and the+ `sourceInfo` function to `parseSource`.++Other issues+------------++For 2.6.2, the following issues were also closed (see [bug+tracker](https://github.com/agda/agda/issues)):++ - [#418](https://github.com/agda/agda/issues/418): Unifier ignores presence of abstract keyword+ - [#958](https://github.com/agda/agda/issues/958): Module application display forms in parameterised modules+ - [#1145](https://github.com/agda/agda/issues/1145): Allow multiple layout keywords on the same line+ - [#2151](https://github.com/agda/agda/issues/2151): Add TC primitive to check left-hand side+ - [#2461](https://github.com/agda/agda/issues/2461): Support with in the presence of IApply patterns+ - [#2858](https://github.com/agda/agda/issues/2858): Feature request: Interleaving mutually-defined functions & datatypes+ - [#3000](https://github.com/agda/agda/issues/3000): Interaction: iterated give encounters internal error+ - [#3118](https://github.com/agda/agda/issues/3118): Feature request: default flags in .agda-lib file+ - [#3289](https://github.com/agda/agda/issues/3289): Postfix projections should not have hiding information+ - [#3360](https://github.com/agda/agda/issues/3360): Make Emacs mode available as a normal package via MELPA+ - [#3365](https://github.com/agda/agda/issues/3365): Update GitHub linguist syntax highlight file+ - [#3398](https://github.com/agda/agda/issues/3398): With the option --allow-unsolved-metas, the unsolved metas are not shown, only yellow+ - [#3422](https://github.com/agda/agda/issues/3422): Show names of instance candidates in error message+ - [#3486](https://github.com/agda/agda/issues/3486): Elaborate-and-give shouldn't reduce solution+ - [#3532](https://github.com/agda/agda/issues/3532): Refine does not work for functions with 10 arguments or more+ - [#3538](https://github.com/agda/agda/issues/3538): Regression: Rewrite rule involving constructors rejected in parametrized module+ - [#3588](https://github.com/agda/agda/issues/3588): Refine suggests overloaded constructor which is not in scope+ - [#3627](https://github.com/agda/agda/issues/3627): Where-blocks of clauses with irrelevant projections can use irrelevant variables+ - [#3644](https://github.com/agda/agda/issues/3644): Error message without position+ - [#3672](https://github.com/agda/agda/issues/3672): Better error messages for generalize easter eggs+ - [#3684](https://github.com/agda/agda/issues/3684): Make error about non-existent record field a warning?+ - [#3734](https://github.com/agda/agda/issues/3734): WARNING_ON_USAGE is not raised for constructors+ - [#3744](https://github.com/agda/agda/issues/3744): Internal error related to abstract+ - [#3870](https://github.com/agda/agda/issues/3870): Internal error during instance search+ - [#3926](https://github.com/agda/agda/issues/3926): Document the effect of `mutual` to the order of type checking+ - [#3933](https://github.com/agda/agda/issues/3933): `import` can remove definitions from scope+ - [#3961](https://github.com/agda/agda/issues/3961): Missing documentation for coverage checking+ - [#4071](https://github.com/agda/agda/issues/4071): Ill-scoped code in error message+ - [#4088](https://github.com/agda/agda/issues/4088): Strange scoping rules for irrefutable with, part 2+ - [#4093](https://github.com/agda/agda/issues/4093): Make it possible to rename Set?+ - [#4109](https://github.com/agda/agda/issues/4109): cannot declare data types in Setω+ - [#4131](https://github.com/agda/agda/issues/4131): Record definition doesn't compile without a specific `let` binding+ - [#4132](https://github.com/agda/agda/issues/4132): The regular expression for floats in the lexer is too liberal+ - [#4135](https://github.com/agda/agda/issues/4135): Constructor disambiguation picks non-unique solution+ - [#4157](https://github.com/agda/agda/issues/4157): Agda gets confused by multiple anonymous definitions in a single mutual block+ - [#4160](https://github.com/agda/agda/issues/4160): Printing implicit lambdas with --show-implicit+ - [#4161](https://github.com/agda/agda/issues/4161): An alternative solution for hGetContent error on Windows when non-English+ - [#4166](https://github.com/agda/agda/issues/4166): Instances that are not in scope are candidates for instance resolution+ - [#4208](https://github.com/agda/agda/issues/4208): Field named `_` in `genTel` record+ - [#4252](https://github.com/agda/agda/issues/4252): Interaction ids get conflated after iterated give+ - [#4265](https://github.com/agda/agda/issues/4265): Unsolved constraints when --no-syntactic-equality is used+ - [#4280](https://github.com/agda/agda/issues/4280): Test case for #4169 fails in JS backend+ - [#4291](https://github.com/agda/agda/issues/4291): Incorrect names can be generated for generalised variables+ - [#4341](https://github.com/agda/agda/issues/4341): The documentation of inContext seems wrong.+ - [#4350](https://github.com/agda/agda/issues/4350): Scoping bug with let open in telescope+ - [#4365](https://github.com/agda/agda/issues/4365): Module fails to type check after parametrising it by postulates+ - [#4400](https://github.com/agda/agda/issues/4400): TERMINATING pragma in where clause+ - [#4425](https://github.com/agda/agda/issues/4425): [doc] What are .agdai files?+ - [#4456](https://github.com/agda/agda/issues/4456): No error highlighting for error warnings?+ - [#4458](https://github.com/agda/agda/issues/4458): The command agda2-measure-load-time is broken+ - [#4481](https://github.com/agda/agda/issues/4481): Named implicit arguments do not behave the same in anonymous lambdas & definitions+ - [#4482](https://github.com/agda/agda/issues/4482): "Unexpected implicit argument" should pinpoint exactly where the error starts+ - [#4486](https://github.com/agda/agda/issues/4486): "did you mean" hint also for failing imports+ - [#4491](https://github.com/agda/agda/issues/4491): Add a primitive for Data.Text's uncons+ - [#4516](https://github.com/agda/agda/issues/4516): Internal error if files cannot be written to the directory for temporary files+ - [#4518](https://github.com/agda/agda/issues/4518): Confusing error message if missing import+ - [#4520](https://github.com/agda/agda/issues/4520): Better error for ambiguous BUILTIN [FROMNAT no longer working]+ - [#4521](https://github.com/agda/agda/issues/4521): Massive increase in memory required to install Agda 2.6.1+ - [#4526](https://github.com/agda/agda/issues/4526): Agda 2.6.1 bad performance: findProjectConfig slow in big directories+ - [#4528](https://github.com/agda/agda/issues/4528): Internal error due to new forcing translation+ - [#4530](https://github.com/agda/agda/issues/4530): Less normalization of goal types for instance search+ - [#4534](https://github.com/agda/agda/issues/4534): [reflection] quote is not a defined name+ - [#4536](https://github.com/agda/agda/issues/4536): co-pattern matching on empty record type removes body+ - [#4538](https://github.com/agda/agda/issues/4538): changing the predefined precedence of an operator+ - [#4543](https://github.com/agda/agda/issues/4543): Access violation on Windows on GHC 8.8.3, 8.8.4, 8.10.1 and 8.10.2+ - [#4550](https://github.com/agda/agda/issues/4550): Documentation build: malformed code-block+ - [#4556](https://github.com/agda/agda/issues/4556): [documentation] update hello world+ - [#4557](https://github.com/agda/agda/issues/4557): activate github's discussions beta+ - [#4560](https://github.com/agda/agda/issues/4560): Loss of canonicity with no-eta record and copatterns.+ - [#4572](https://github.com/agda/agda/issues/4572): add PiSort and UnivSort to the documentation+ - [#4576](https://github.com/agda/agda/issues/4576): quoteTC for Setω+ - [#4580](https://github.com/agda/agda/issues/4580): No highlighting for pragmas FROMNAT, FROMNEG, FROMSTRING+ - [#4583](https://github.com/agda/agda/issues/4583): QuickLaTeX backend does not highlight coinductive constructors as such+ - [#4586](https://github.com/agda/agda/issues/4586): Better error message for "Not a valid let declaration"+ - [#4593](https://github.com/agda/agda/issues/4593): The blocking machinery seems to be broken+ - [#4595](https://github.com/agda/agda/issues/4595): Should Setω be a type?+ - [#4596](https://github.com/agda/agda/issues/4596): Improve pattern matching on records in telescopes+ - [#4606](https://github.com/agda/agda/issues/4606): The combination of Cubical Agda with inductive families is logically inconsistent+ - [#4610](https://github.com/agda/agda/issues/4610): Support Emacs 27.1+ - [#4615](https://github.com/agda/agda/issues/4615): Enable --no-sort-comparison by default?+ - [#4621](https://github.com/agda/agda/issues/4621): Make --rewriting infective+ - [#4623](https://github.com/agda/agda/issues/4623): Empty where blocks should get dead code warnings+ - [#4631](https://github.com/agda/agda/issues/4631): Non-linear patterns handled in a buggy way+ - [#4637](https://github.com/agda/agda/issues/4637): recCon-NOT-PRINTED in termination error in connection to with+ - [#4638](https://github.com/agda/agda/issues/4638): Erased constructors+ - [#4649](https://github.com/agda/agda/issues/4649): Repair Agda's REPL (agda -I) to work with --safe flag+ - [#4656](https://github.com/agda/agda/issues/4656): Function name not wrapped in `\AgdaFunction` in generated LaTeX+ - [#4662](https://github.com/agda/agda/issues/4662): Current module contents+ - [#4665](https://github.com/agda/agda/issues/4665): Documentation: add install instructions for stack+ - [#4671](https://github.com/agda/agda/issues/4671): Weird error message on case-insensitive file systems+ - [#4679](https://github.com/agda/agda/issues/4679): Cubical: giving seems to skip the boundary condition check for extended lambdas+ - [#4681](https://github.com/agda/agda/issues/4681): Get rid of auto-inlining?+ - [#4684](https://github.com/agda/agda/issues/4684): Type error due to --no-syntactic-equality+ - [#4687](https://github.com/agda/agda/issues/4687): Instance search fails with two equal candidates+ - [#4704](https://github.com/agda/agda/issues/4704): Case-split generates invalid code+ - [#4707](https://github.com/agda/agda/issues/4707): Just warn when `using` directive has repetitions+ - [#4721](https://github.com/agda/agda/issues/4721): de Bruijn index out of scope when using rewriting+ - [#4727](https://github.com/agda/agda/issues/4727): Meta-variable solutions contain subterms with the wrong modality+ - [#4735](https://github.com/agda/agda/issues/4735): primShowQName creates not-in-scope names+ - [#4737](https://github.com/agda/agda/issues/4737): Turn error `Hiding ... has no effect` into a warning+ - [#4750](https://github.com/agda/agda/issues/4750): Unification failure in 2.6.1 and the master branch+ - [#4752](https://github.com/agda/agda/issues/4752): Panic on unbound variable with pattern synonym+ - [#4768](https://github.com/agda/agda/issues/4768): De Bruijn index @0 in error "Not a finite domain"+ - [#4769](https://github.com/agda/agda/issues/4769): mergeEqualPs ignores Name and ArgInfo of merged-in patterns+ - [#4772](https://github.com/agda/agda/issues/4772): C-u C-u C-c C-? should show all goals normalized (Cmd_metas)+ - [#4773](https://github.com/agda/agda/issues/4773): Missing does-not-export warning for `open` directive for parametrised module+ - [#4775](https://github.com/agda/agda/issues/4775): Internal error when trying to use incorrect lambda syntax to pattern match+ - [#4784](https://github.com/agda/agda/issues/4784): Make erasure compatible with univalence+ - [#4795](https://github.com/agda/agda/issues/4795): Build "agda-tests" fails using dynamic linking+ - [#4815](https://github.com/agda/agda/issues/4815): Current master fails compilation: binding for 'error' shadows the existing binding+ - [#4828](https://github.com/agda/agda/issues/4828): Symlinks are incorrectly followed during compilation+ - [#4833](https://github.com/agda/agda/issues/4833): Internal error: cannot type-check file+ - [#4851](https://github.com/agda/agda/issues/4851): BUILTIN SIGMA and --type-in-type+ - [#4852](https://github.com/agda/agda/issues/4852): First load the file+ - [#4857](https://github.com/agda/agda/issues/4857): Instance argument is printed as explicit argument+ - [#4869](https://github.com/agda/agda/issues/4869): Internal error at src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs:147+ - [#4880](https://github.com/agda/agda/issues/4880): Non-dependent, irrelevant, nameless arguments aren't accepted in arrows+ - [#4882](https://github.com/agda/agda/issues/4882): Missing `reduce` in `literalStrategy`+ - [#4888](https://github.com/agda/agda/issues/4888): "Illegal declaration(s) before top-level module" in Agda 2.6.1+ - [#4909](https://github.com/agda/agda/issues/4909): Rewrite rule not accepted with --no-fast-reduce+ - [#4924](https://github.com/agda/agda/issues/4924): Instance resolution loops infinitely even when an instance is available+ - [#4925](https://github.com/agda/agda/issues/4925): Too aggressive literal overloading+ - [#4928](https://github.com/agda/agda/issues/4928): Internal error checking cubical library+ - [#4929](https://github.com/agda/agda/issues/4929): Regression in 2.6.1 connected to forcing translation (internal error)+ - [#4944](https://github.com/agda/agda/issues/4944): Generalize: stuck on constraint ↑ i =< ↑ (↑ i) : Size+ - [#4946](https://github.com/agda/agda/issues/4946): Size polarity brittle with generalization+ - [#4949](https://github.com/agda/agda/issues/4949): Cubical: internal error in eta-expansion under constraints+ - [#4950](https://github.com/agda/agda/issues/4950): Range too large in complaint about missing definitions+ - [#4951](https://github.com/agda/agda/issues/4951): Data types in Setω are treated as non-fibrant+ - [#4952](https://github.com/agda/agda/issues/4952): Incorrect HTML generated for renaming clause+ - [#4962](https://github.com/agda/agda/issues/4962): JS backend: bugs involving "null"+ - [#4967](https://github.com/agda/agda/issues/4967): Crazy bug when defining Ord instances for Int+ - [#4970](https://github.com/agda/agda/issues/4970): `variable` use adds explicit argument+ - [#4975](https://github.com/agda/agda/issues/4975): "no such meta variable" when calling `C-u C-c C-;`+ - [#4982](https://github.com/agda/agda/issues/4982): Internal error related to Cubical Agda+ - [#4986](https://github.com/agda/agda/issues/4986): Pattern matching allows you to turn `(x y : A) -> A` into `(@0 x y : A) -> A`+ - [#4995](https://github.com/agda/agda/issues/4995): No Cycle should not look under lambdas.+ - [#4998](https://github.com/agda/agda/issues/4998): Make case in clause with instance projection does not work+ - [#4999](https://github.com/agda/agda/issues/4999): `primStringFromList` is not injective because of surrogate code points+ - [#5002](https://github.com/agda/agda/issues/5002): Bad JavaScript generated+ - [#5005](https://github.com/agda/agda/issues/5005): Add flag to print AGDA_DIR and exit+ - [#5029](https://github.com/agda/agda/issues/5029): One can override --safe+ - [#5033](https://github.com/agda/agda/issues/5033): Internal error related to @tick+ - [#5048](https://github.com/agda/agda/issues/5048): Disturbing names in normalised reflected type+ - [#5064](https://github.com/agda/agda/issues/5064): Give more information in error "Pattern matching on no-eta record types is by default not allowed"+ - [#5065](https://github.com/agda/agda/issues/5065): The termination checker is too liberal+ - [#5079](https://github.com/agda/agda/issues/5079): Deep pattern-matching is sometimes allowed for erased arguments+ - [#5093](https://github.com/agda/agda/issues/5093): Weird instance propagation between parameterised modules+ - [#5112](https://github.com/agda/agda/issues/5112): `make install-fix-whitespace` shouldn't use the `stack-X.Y.Z.yaml` files used for Agda+ - [#5128](https://github.com/agda/agda/issues/5128): getDefinition sometimes loses patterns+ - [#5133](https://github.com/agda/agda/issues/5133): Current master fails LaTeX-related tests+ - [#5140](https://github.com/agda/agda/issues/5140): test/LaTeXAndHTML/succeed contains failing tests+ - [#5146](https://github.com/agda/agda/issues/5146): v2.6.1.2 does not contain MAlonzo/RTE/Float.hs+ - [#5161](https://github.com/agda/agda/issues/5161): No error location for error in imported module when .agdai file exists+ - [#5167](https://github.com/agda/agda/issues/5167): Fix broken compatibility with agda-bench+ - [#5168](https://github.com/agda/agda/issues/5168): User manual: Missing instructions for installing Agda from Hackage using stack+ - [#5176](https://github.com/agda/agda/issues/5176): `mutual` is deprecated in doc+ - [#5204](https://github.com/agda/agda/issues/5204): Investigate highlighting failures+ - [#5205](https://github.com/agda/agda/issues/5205): acmart examples in (user-manual) fail to build with latest TeXLive+ - [#5207](https://github.com/agda/agda/issues/5207): Agda generated code does not type-check with GHC 9.0+ - [#5210](https://github.com/agda/agda/issues/5210): Internal error+ - [#5230](https://github.com/agda/agda/issues/5230): When `stack.yaml` exists, `make` calls `stack`, even on `make debug`+ - [#5231](https://github.com/agda/agda/issues/5231): Problems compiling hello-world.agda+ - [#5237](https://github.com/agda/agda/issues/5237): `__IMPOSSIBLE__` from Agda.TypeChecking.Substitute+ - [#5238](https://github.com/agda/agda/issues/5238): Rewrites are conjuring elements out of thin air+ - [#5245](https://github.com/agda/agda/issues/5245): An infinite loop?+ - [#5250](https://github.com/agda/agda/issues/5250): Change of warning options ignored+ - [#5251](https://github.com/agda/agda/issues/5251): @0 annotation on lambda ignored+ - [#5252](https://github.com/agda/agda/issues/5252): Internal error when case splitting pattern-lambda with higher rank type+ - [#5286](https://github.com/agda/agda/issues/5286): Wrong error location with do notation and parse error in lhs+ - [#5288](https://github.com/agda/agda/issues/5288): Very weird behaviour with compiled Data.Nat.Show.readMaybe+ - [#5313](https://github.com/agda/agda/issues/5313): Documentation for internal level properties+ - [#5314](https://github.com/agda/agda/issues/5314): Warn about abstract definitions without type signatures+ - [#5317](https://github.com/agda/agda/issues/5317): The reflection machinery should support quantities+ - [#5326](https://github.com/agda/agda/issues/5326): The highlighting code should be optimised+ - [#5334](https://github.com/agda/agda/issues/5334): Meta-variable in constructor type busts interleaved mutual+ - [#5335](https://github.com/agda/agda/issues/5335): Incorrect id attributes for local modules inside local modules+ - [#5336](https://github.com/agda/agda/issues/5336): `data Foo constructor {cs : ts}` notation in `interleaved mutual`+ - [#5339](https://github.com/agda/agda/issues/5339): `constructor` blocks do not tolerate overloading in same block+ - [#5341](https://github.com/agda/agda/issues/5341): Do not make context variables non-erased+ - [#5356](https://github.com/agda/agda/issues/5356): `interleaved mutual`: `data _ where` instead of `constructor`+ - [#5358](https://github.com/agda/agda/issues/5358): tactic annotation on record field of function type drops domain in copattern definition+ - [#5367](https://github.com/agda/agda/issues/5367): Parser regression involving `with` and `let`+ - [#5370](https://github.com/agda/agda/issues/5370): Inconsistency in agda --help+ - [#5375](https://github.com/agda/agda/issues/5375): Efficient conversion between interaction points and meta-variables+ - [#5410](https://github.com/agda/agda/issues/5410): Module applications in where clauses of erased definitions yield non-erased code+ - [#5419](https://github.com/agda/agda/issues/5419): Missing licences?+ - [#5424](https://github.com/agda/agda/issues/5424): Internal error in v2.6.2 release candidate 1+ - [#5434](https://github.com/agda/agda/issues/5434): The user manual's explanation of how erasure is checked for constructors does not match the implementation
@@ -0,0 +1,522 @@+Release notes for Agda version 2.6.3+====================================++Highlights+----------++* Added support for [Erased Cubical+ Agda](https://agda.readthedocs.io/en/v2.6.3/language/cubical.html#cubical-agda-with-erased-glue),+ a variant of Cubical Agda that is supported by the GHC backend,+ under the flag `--erased-cubical`.++* Added a new flag `--cubical-compatible` to turn on generation of+ Cubical Agda-specific support code (previously this behaviour was+ part of `--without-K`).++ Since `--cubical-compatible` mode implies that functions should work+ with the preliminary support for [indexed inductive types in Cubical+ Agda](https://agda.readthedocs.io/en/v2.6.3/language/cubical.html#indexed-inductive-types),+ many pattern matching functions will now emit an+ `UnsupportedIndexedMatch` warning, indicating that the function will+ not compute when applied to transports (from `--cubical` code).++ This warning can be disabled with `-WnoUnsupportedIndexedMatch`, which+ can be used either in an `OPTIONS` pragma or in your `agda-lib` file.+ The latter is recommended if your project is only+ `--cubical-compatible`, or if it is already making extensive use of+ indexed types.++ Note that code that uses (only) `--without-K` can no longer be+ imported from code that uses `--cubical`. Thus it may make sense to+ replace `--without-K` with `--cubical-compatible` in library code,+ if possible.++ Note also that Agda tends to be quite a bit faster if `--without-K`+ is used instead of `--cubical-compatible`.++* Agda 2.6.3 seems to type-check one variant of the standard library+ about [30%+ faster](https://github.com/agda/agda/issues/6049#issuecomment-1329163727)+ than Agda 2.6.2.2 (on one system; the library was changed in a small+ way between the tests to accommodate changes to Agda). In that test+ the standard library did not use the new flag+ `--cubical-compatible`. With that flag enabled in all the files that+ used to use `--without-K` (and the warning `UnsupportedIndexedMatch`+ turned off) Agda 2.6.3 was still about 10% faster.++* New primitives `declareData`, `defineData`, and `unquoteDecl data`+ for generating new data types have been added to the [reflection+ API](https://agda.readthedocs.io/en/v2.6.3/language/reflection.html#metaprogramming).++Installation and infrastructure+-------------------------------++Agda supports GHC versions 8.0.2 to 9.4.4.++Erasure+-------++* The new option `--erased-cubical` turns on a variant of Cubical Agda+ (see [#4701](https://github.com/agda/agda/issues/4701)).++ When this variant of Cubical Agda is used glue (and some related+ builtins) may only be used in erased settings. One can import+ regular Cubical Agda code from this variant of Cubical Agda, but+ names defined using Cubical Agda are (mostly) treated as if they had+ been marked as erased. See the [reference+ manual](https://agda.readthedocs.io/en/v2.6.3/language/cubical.html#cubical-agda-with-erased-glue-and-erased-higher-constructors)+ for more details.++ The GHC backend can compile code that uses `--erased-cubical` if the+ top-level module uses this flag.++ This feature is experimental.++* Added an option `--erase-record-parameters` that marks parameters to+ record fields and definitions in a record module as erased (see+ [#4786](https://github.com/agda/agda/issues/4786) and+ [#5770](https://github.com/agda/agda/issues/5770)). For example:++ ```agda+ {-# OPTIONS --erase-record-parameters #-}++ record R (A : Set) : Set where+ field+ f : A++ test : {@0 A : Set} → R A → A+ test = R.f+ ```++Cubical Agda+------------++* [**Breaking**] The generation of Cubical Agda-specific support code was removed+ from `--without-K` and transferred to its own flag,+ `--cubical-compatible` (see+ [#5843](https://github.com/agda/agda/issues/5843) and+ [#6049](https://github.com/agda/agda/issues/6049) for the+ rationale).++* Cubical Agda now has experimental support for indexed inductive types+ ([#3733](https://github.com/agda/agda/issues/3733)).+ See the [user guide](https://agda.readthedocs.io/en/v2.6.3/language/cubical.html#indexed-inductive-types)+ for caveats.++* The cubical interval `I` now belongs to its own sort, `IUniv`, rather+ than `SSet`. For `J : IUniv` and `A : J → Set l`, we have+ `(j : J) → A j : Set l`, that is, the type of functions from a type in `IUniv`+ to a fibrant type is fibrant.++* The option `--experimental-irrelevance` is now perhaps incompatible+ with Cubical Agda and perhaps also postulated univalence (see+ [#5611](https://github.com/agda/agda/issues/5611) and+ [#5861](https://github.com/agda/agda/pull/5861)).++ This is not meant to imply that the option was not already+ incompatible with those things. Note that+ `--experimental-irrelevance` cannot be used together with `--safe`.++* A new built-in constructor `REFLID` was added to the cubical identity+ types. This is definitionally equal to the reflexivity identification+ built with `conid`, with the difference being that matching on+ `REFLID` is allowed.++ ```agda+ symId : ∀ {a} {A : Set a} {x y : A} → Id x y → Id y x+ symId reflId = reflId+ ```++* Definitions which pattern match on higher-inductive types are no+ longer considered for injectivity analysis.+ ([#6219](https://github.com/agda/agda/pull/6219))++* [**Breaking**] Higher constructors are no longer considered as guarding in the productivity check.+ ([#6108](https://github.com/agda/agda/issues/6108))++* Rewrite rules with interval arguments are now supported.+ ([#4384](https://github.com/agda/agda/issues/4384))++The flat modality+-----------------++* [**Breaking**] The `@flat`/`@♭` modality is now by default disabled (see+ [#4927](https://github.com/agda/agda/issues/4927)).++ It can be enabled using the infective flag `--cohesion`.++* [**Breaking**] Matching on `@flat` arguments is now disabled by default, the flag+ `--no-flat-split` has been removed, and the flag `--flat-split` is+ now infective (see [#6238](https://github.com/agda/agda/issues/6238)+ and [#6263](https://github.com/agda/agda/issues/6263)).++ Matching can be enabled using the `--flat-split` flag. Note that in+ Cubical Agda functions that match on an argument marked with `@flat`+ trigger the `UnsupportedIndexedMatch` warning, and the code might+ not compute properly.++Reflection+----------++* Two new reflection primitives++ ```agda+ declareData : Name → Nat → Type → TC ⊤+ defineData : Name → List (Σ Name (λ _ → Type)) → TC ⊤+ ```++ are added for declaring and defining datatypes, similar to+ `declareDef` and `defineDef`.++* The construct `unquoteDecl` is extended with the ability of bringing+ a datatype `d` and its constructors `c₁ ... cₙ` given by a `TC`+ computation `m` into scope by the following syntax:++ ```agda+ unquoteDecl data x constructor c₁ .. cₙ = m+ ```++* A new reflection primitive `getInstances : Meta → TC (List Term)`+ was added to `Agda.Builtin.Reflection`. This operation returns the+ list of all possibly valid instance candidates for a given+ metavariable. For example, the following macro instantiates the goal+ with the first instance candidate, even if there are several:+ ```agda+ macro+ pickWhatever : Term → TC ⊤+ pickWhatever hole@(meta m _) = do+ (cand ∷ _) ← getInstances m+ where [] -> typeError (strErr "No candidates!" ∷ [])+ unify hole cand+ pickWhatever _ = typeError (strErr "Already solved!" ∷ [])+ ```++* [**Breaking**] The reflection primitives `getContext` and `inContext` use a nominal context+ `List (Σ String λ _ → Arg Type)` instead of `List (Arg Type)` for printing+ type information better. Similarly, `extendContext` takes an extra argument+ of type `String`.++* `macro` definitions can now be used even when they are declared as erased.+ For example, this is now accepted:+ ```agda+ macro+ @0 trivial : Term → TC ⊤+ trivial = unify (con (quote refl) [])++ test : 42 ≡ 42+ test = trivial+ ```++* A new reflection primitive `formatErrorParts : List ErrorPart → TC String`+ is added. It takes a list of `ErrorPart` and return its formatted string.++* [**Breaking**] A new constructor `pattErr : Pattern → ErrorPart` of `ErrorPart` for reflection+ is added.++* [**Breaking**] The reflection primitives `getType` and+ `getDefinition` respect the module context they are invoked from+ instead of returning information that would be expected in the top+ context.++* [**Breaking**] The reflection primitive `inContext` cannot step+ outside of the context that the `TC` computation is invoked from+ anymore. The telescope is now relative to that context instead.++Syntax+------++* It is now OK to put lambda-bound variables anywhere in the+ right-hand side of a syntax declaration. However, there must always+ be at least one "identifier" between any two regular "holes". For+ instance, the following syntax declaration is accepted because `-`+ is between the holes `B` and `D`.++ ```agda+ postulate+ F : (Set → Set) → (Set → Set) → Set++ syntax F (λ A → B) (λ C → D) = B A C - D+ ```++* Syntax can now use lambdas with multiple arguments+ ([#394](https://github.com/agda/agda/issues/394)).++ Example:++ ```agda+ postulate+ Σ₂ : (A : Set) → (A → A → Set) → Set++ syntax Σ₂ A (λ x₁ x₂ → P) = [ x₁ x₂ ⦂ A ] × P+ ```++Builtins+--------++* [**Breaking**] Change `primFloatToWord64` to return `Maybe Word64`.+ (See [#6093](https://github.com/agda/agda/issues/6093).)++ The new type is+ ```agda+ primFloatToWord64 : Float → Maybe Word64+ ```+ and it returns `nothing` for `NaN`.++* [**Breaking**] The type expected by the builtin `EQUIVPROOF` has been changed to+ properly encode the condition that `EQUVIFUN` is an equivalence.+ ([#5661](https://github.com/agda/agda/issues/5661),+ [#6032](https://github.com/agda/agda/pull/6032))++* [**Breaking**] The primitive `primIdJ` has been removed+ ([#6032](https://github.com/agda/agda/pull/6032)) in favour of+ matching on the cubical identity type.++* [**Breaking**] The builtin `SUBIN` is now exported from `Agda.Builtin.Cubical.Sub` as+ **`inS`** rather than `inc`. Similarly, the internal modules refer to+ `primSubOut` as `outS`. ([#6032](https://github.com/agda/agda/pull/6032))++Pragmas and options+-------------------++* It is now possible to declare several `BUILTIN REWRITE` relations.+ Example:+ ```agda+ {-# OPTIONS --rewriting #-}++ open import Agda.Builtin.Equality+ open import Agda.Builtin.Equality.Rewrite -- 1st rewrite relation++ postulate+ R : (A : Set) → A → A → Set+ A : Set+ a b c : A+ foo : R A a b -- using 2nd rewrite relation+ bar : b ≡ c -- using 1st rewrite relation++ {-# BUILTIN REWRITE R #-} -- 2nd rewrite relation+ {-# REWRITE foo bar #-}++ test : a ≡ c+ test = refl+ ```++* [**Breaking**] The option `--experimental-lossy-unification` that+ makes Agda sometimes use first-order unification has been renamed to+ `--lossy-unification`+ ([#1625](https://github.com/agda/agda/issues/1625)).++ Note that use of this option is associated with some potential+ [drawbacks](https://agda.readthedocs.io/en/v2.6.3/language/lossy-unification.html#drawbacks).++* The new option `--no-load-primitives` complements `--no-import-sorts`+ by foregoing loading of the primitive modules altogether. This option+ leaves Agda in a very fragile state, as the built-in sorts are used+ extensively throughout the implementation. It is intended to be used+ by Literate Agda projects which want to bind `BUILTIN TYPE` (and+ other primitives) in their own literate files.++* If `--interaction-exit-on-error` is used, then Agda exits with a+ non-zero exit code if `--interaction` or `--interaction-json` are+ used and a type error is encountered. The option also makes Agda+ exit with exit code 113 if Agda fails to parse a command.++ This option might for instance be used if Agda is controlled from a+ script.++* Add a `NOT_PROJECTION_LIKE` pragma, which marks a function as not+ suitable for projection-likeness. Projection-like functions have some of+ their arguments erased, which can cause confusing behaviour when they+ are printed instantiated (see [#6203](https://github.com/agda/agda/issues/6203)).++* [**Breaking**] The options `--subtyping` and `--no-subtyping` have been removed+ (see [#5427](https://github.com/agda/agda/issues/5427)).++Profiling and performance+-------------------------++* New verbosity `-v debug.time:100` adds time stamps to debugging output.++* [**Breaking**] Profiling options are now turned on with a new `--profile` flag+ instead of abusing the debug verbosity option. (See+ [#5781](https://github.com/agda/agda/issues/5781).)++* The new profiling option `--profile=conversion` collects statistics+ on how often various steps of the conversion algorithm are used+ (reduction, eta-expansion, syntactic equality, etc).++* Meta-variables can now be saved in `.agdai` files, instead+ of being expanded. This can affect performance. (See+ [#5731](https://github.com/agda/agda/issues/5731).)++ Meta-variables are saved if the pragma option `--save-metas` is+ used. This option can be overridden by `--no-save-metas`.++* The new option `--syntactic-equality[=FUEL]` can be used to limit+ how many times the syntactic equality shortcut is allowed to fail+ (see [#5801](https://github.com/agda/agda/issues/5801)).++ If `FUEL` is omitted, then the syntactic equality shortcut is+ enabled without any restrictions.++ If `FUEL` is given, then the syntactic equality shortcut is given+ `FUEL` units of fuel. The exact meaning of this is+ implementation-dependent, but successful uses of the shortcut do not+ affect the amount of fuel. Currently the fuel is decreased in the+ failure continuations of the implementation of the syntactic+ equality shortcut. When a failure continuation completes the fuel is+ restored to its previous amount.++ The idea for this option comes from András Kovács'+ [smalltt](https://github.com/AndrasKovacs/smalltt/blob/989b020309686e04374f1ab7844f468386d2eb2f/README.md#approximate-conversion-checking).++ Note that this option is experimental and subject to change.++Library management+------------------++* Library files below the "project root" are now ignored+ (see [#5644](https://github.com/agda/agda/issues/5644)).++ For instance, if you have a module called `A.B.C` in the directory+ `Root/A/B`, then `.agda-lib` files in `Root/A` or `Root/A/B` do not+ affect what options are used to type-check `A.B.C`: `.agda-lib`+ files for `A.B.C` have to reside in `Root`, or further up the+ directory hierarchy.++Interaction+-----------++* Agsy ([automatic proof search](https://agda.readthedocs.io/en/v2.6.3/tools/auto.html)) can+ now be invoked in the right-hand-sides of copattern matching clauses.+ ([#5827](https://github.com/agda/agda/pull/5827))++Compiler backends+-----------------++* [**Breaking**] Both the GHC and JS backends now refuse to compile code that uses+ `--cubical`.++ Note that support for compiling code that uses `--erased-cubical`+ has been added to the GHC backend (see above).++* If the GHC backend is invoked when `--interaction` or+ `--interaction-json` is active (for instance when the Emacs mode is+ used), then GHC is now invoked from the directory containing the+ `MAlonzo` directory (see+ [#6194](https://github.com/agda/agda/issues/6194)).++ Before GHC was invoked from the Agda process's current working+ directory, and that is still the case if `--interaction` and+ `--interaction-json` are not used.++DOT backend+-----------++* The new option `--dependency-graph-include=LIBRARY` can be used to+ restrict the dependency graph to modules from one or more libraries+ (see [#5634](https://github.com/agda/agda/issues/5634)).++ Note that the module given on the command line might not be+ included.++* The generated graphs no longer contain "redundant" edges: if a+ module is imported both directly and indirectly, then the edge+ corresponding to the direct import is omitted.++JSON API+--------++* [**Breaking**] The JSON API now represents meta-variables differently, using+ objects containing two keys, `id` and `module`, both with values+ that are (natural) numbers. See+ [#5731](https://github.com/agda/agda/issues/5731).+++Other issues closed+--------------------++For 2.6.3, the following issues were also closed (see [bug+tracker](https://github.com/agda/agda/issues)):++ - [#3660](https://github.com/agda/agda/issues/3660): Wrong variable name in constraints for higher constructor+ - [#3986](https://github.com/agda/agda/issues/3986): Subtyping `.A -> B <= A -> B` leads to wrong `ArgInfo`+ - [#4103](https://github.com/agda/agda/issues/4103): Rewrite rule rejected because of projection likeness+ - [#4506](https://github.com/agda/agda/issues/4506): Lack of unicode support in locale may result in uncaught `IOException`+ - [#4725](https://github.com/agda/agda/issues/4725): Cubical Agda: Program rejected by termination checker due to moved dot pattern+ - [#4755](https://github.com/agda/agda/issues/4755): Rewrite rule on constructor uses wrong type for matching+ - [#4763](https://github.com/agda/agda/issues/4763): Cubical Agda: Unquote anonymous copattern involving path+ - [#5191](https://github.com/agda/agda/issues/5191): Unifier can use erased variables in non-erased data parameters+ - [#5257](https://github.com/agda/agda/issues/5257): Internal error when matching on user syntax with binding+ - [#5378](https://github.com/agda/agda/issues/5378): Internal error with tactic on record field+ - [#5448](https://github.com/agda/agda/issues/5448): Should the predicate be erasable in the subst rule (without-K)+ - [#5462](https://github.com/agda/agda/issues/5462): Internal error caused by a REWRITE on a projection-like function+ - [#5468](https://github.com/agda/agda/issues/5468): Disallow certain forms of pattern matching when an index is erased+ - [#5525](https://github.com/agda/agda/issues/5525): Duplicate entries in `executables` file lead to undefined behavior+ - [#5548](https://github.com/agda/agda/issues/5548): Agda infers an incorrect type with subtyping on+ - [#5551](https://github.com/agda/agda/issues/5551): Panic when showing module contents with pattern synonym+ - [#5563](https://github.com/agda/agda/issues/5563): Allow erased names in the type signatures of let-bound definitions+ - [#5577](https://github.com/agda/agda/issues/5577): The "Could not generate equivalence" warning is not always emitted+ - [#5581](https://github.com/agda/agda/issues/5581): Lexical error with tab character in literate Agda text+ - [#5589](https://github.com/agda/agda/issues/5589): Internal error with REWRITE of function from path+ - [#5681](https://github.com/agda/agda/issues/5681): Panic on record declaration with unknown sort+ - [#5702](https://github.com/agda/agda/issues/5702): Can't case split an `HitInt` with some already existing cases+ - [#5715](https://github.com/agda/agda/issues/5715): Reflection: Use `Telescope` for `getContext`, `inContext`, and `extendContext`+ - [#5727](https://github.com/agda/agda/issues/5727): Reducing universe levels before checking is not sufficient+ - [#5728](https://github.com/agda/agda/issues/5728): Internal error when pattern matching on `...` in with statement without providing a pattern match+ - [#5734](https://github.com/agda/agda/issues/5734): Relevance check in reflection+ - [#5751](https://github.com/agda/agda/issues/5751): json interaction produces Haskell output for `SolveAll`+ - [#5754](https://github.com/agda/agda/issues/5754): Internal error when compiling program with quoted metavariable+ - [#5760](https://github.com/agda/agda/issues/5760): Some code related to Cubical Agda runs also when the K rule is on+ - [#5763](https://github.com/agda/agda/issues/5763): Internal parser error using syntax rules+ - [#5765](https://github.com/agda/agda/issues/5765): Erasure check failure when pattern matching on refl in erased definition+ - [#5775](https://github.com/agda/agda/issues/5775): JSON interaction produces fully qualified terms+ - [#5794](https://github.com/agda/agda/issues/5794): Agsy/Auto crashes with `Prelude.!!: index too large`+ - [#5823](https://github.com/agda/agda/issues/5823): Singleton check loops on recursive eta record+ - [#5828](https://github.com/agda/agda/issues/5828): Agsy/Auto panics with `-r` in the presence of a pattern synonym+ - [#5845](https://github.com/agda/agda/issues/5845): Internal error caused by abstracting `variables`+ - [#5848](https://github.com/agda/agda/issues/5848): Internal error with `--confluence-check`+ - [#5850](https://github.com/agda/agda/issues/5850): Warn about useless hiding in `variable` declaration+ - [#5856](https://github.com/agda/agda/issues/5856): Lambda with irrefutable pattern is not rejected when used on Path+ - [#5868](https://github.com/agda/agda/issues/5868): Document `--two-level`+ - [#5875](https://github.com/agda/agda/issues/5875): Instance Search breaks Termination Highlighting+ - [#5891](https://github.com/agda/agda/issues/5891): `SizeUniv : SizeUniv` is inconsistent+ - [#5901](https://github.com/agda/agda/issues/5901): Use `emacs --batch` mode in `agda-mode` setup+ - [#5920](https://github.com/agda/agda/issues/5920): Erased constructors skipped in modality check+ - [#5922](https://github.com/agda/agda/issues/5922): Failure of termination checking for reflection-generated code due to data projections+ - [#5923](https://github.com/agda/agda/issues/5923): Internal error in rewriting+ - [#5944](https://github.com/agda/agda/issues/5944): Internal error in rewriting with `--two-level`+ - [#5953](https://github.com/agda/agda/issues/5953): Recursor of inductive-inductive type does not pass termination check in Cubical Agda+ - [#5955](https://github.com/agda/agda/issues/5955): Composition of Glue Type Causes Infinite Loop+ - [#5956](https://github.com/agda/agda/issues/5956): Cubical Agda crashes when printing empty system+ - [#5966](https://github.com/agda/agda/issues/5966): Improved performance by switching to `vector-hashtables`+ - [#5989](https://github.com/agda/agda/issues/5989): Dead-code elimination crashes function with private tactic argument+ - [#6003](https://github.com/agda/agda/issues/6003): de Bruijn index out of scope when rewriting+ - [#6006](https://github.com/agda/agda/issues/6006): Internal error rewriting with holes+ - [#6015](https://github.com/agda/agda/issues/6015): Pi types and Partial types should not be considered inter-convertible+ - [#6022](https://github.com/agda/agda/issues/6022): Private bindings in imported modules defeat check for binding of primIdFace/primIdPath+ - [#6042](https://github.com/agda/agda/issues/6042): De Bruijn index out of scope when rewriting without-K+ - [#6043](https://github.com/agda/agda/issues/6043): de Bruijn error on unexpected implicit argument+ - [#6059](https://github.com/agda/agda/issues/6059): Non-terminating function over tuples passed with `--termination-depth=2`+ - [#6066](https://github.com/agda/agda/issues/6066): Document the meaning of `pattern` without `no-eta-equality`+ - [#6067](https://github.com/agda/agda/issues/6067): Another de Bruijn error in rewriting+ - [#6073](https://github.com/agda/agda/issues/6073): Constraint solving does not honour singleton types+ - [#6074](https://github.com/agda/agda/issues/6074): `piSort`/`funSort` of `IUniv` should be blocked on the codomain+ - [#6076](https://github.com/agda/agda/issues/6076): Agda input mode (emacs): Minibuffer display for `\;` is strange+ - [#6080](https://github.com/agda/agda/issues/6080): A space leak due to `absName`+ - [#6082](https://github.com/agda/agda/issues/6082): Elaborate-and-give does not respect `--postfix-projections`+ - [#6095](https://github.com/agda/agda/issues/6095): Ambiguous pattern synonyms broken with anonymous module+ - [#6112](https://github.com/agda/agda/issues/6112): Internal error: non-confluent rewriting to singletons+ - [#6200](https://github.com/agda/agda/issues/6200): The reflection machinery does not treat the module telescope consistently+ - [#6203](https://github.com/agda/agda/issues/6203): Projection-likeness and instance arguments+ - [#6205](https://github.com/agda/agda/issues/6205): Internal error with `withReconstructed`+ - [#6244](https://github.com/agda/agda/issues/6244): Make `--no-load-primitives` not `--safe`+ - [#6250](https://github.com/agda/agda/issues/6250): Documentation says `--sized-types` is the default when it isn't+ - [#6257](https://github.com/agda/agda/issues/6257): Document options `--prop`, `--guarded`, and `--two-level`.+ - [#6265](https://github.com/agda/agda/issues/6265): Some options should be listed in `restartOptions`+ - [#6273](https://github.com/agda/agda/issues/6273): Missing highlighting when interleaved mutual is used+ - [#6276](https://github.com/agda/agda/issues/6276): LaTeX/HTML generation doesn't properly render parameters of pre-declared records+ - [#6281](https://github.com/agda/agda/issues/6281): Special treatment of attribute followed by underscore in pretty-printer+ - [#6337](https://github.com/agda/agda/issues/6337): `--lossy-unification` in Agda 2.6.3+ - [#6338](https://github.com/agda/agda/issues/6338): internal error in Agda, perhaps related to `--rewriting`+ - [#6377](https://github.com/agda/agda/issues/6377): Fix installation docs concerning icu libraries+ - [#6379](https://github.com/agda/agda/issues/6379): Weird warning for instance declarations of bad type
@@ -0,0 +1,75 @@+Release notes for Agda version 2.6.4.1+======================================++This is a minor release of Agda 2.6.4 featuring a few changes:++- Make recursion on proofs legal again.+- Improve performance, e.g. by removing debug printing unless built with cabal flag `debug`.+- Switch to XDG directory convention.+- Reflection: change to order of results returned by `getInstances`.+- Fix some internal errors.++Installation+------------++* Agda supports GHC versions 8.6.5 to 9.8.1.++* Verbose output printing via `-v` or `--verbose` is now only active if Agda is built with the `debug` cabal flag.+ Without `debug`, no code is generated for verbose printing, which makes building Agda faster and Agda itself+ faster as well. (PR [#6863](https://github.com/agda/agda/pull/6863))++Language+--------++* A [change](https://github.com/agda/agda/pull/6639) in 2.6.4 that prevented all recursion on proofs,+ i.e., members of a type `A : Prop ℓ`, has been [reverted](https://github.com/agda/agda/pull/6936).+ It is possible again to use proofs as termination arguments.+ (See [issue #6930](https://github.com/agda/agda/issues/6930).)++Reflection+----------++Changes to the meta-programming facilities.++* The reflection primitive `getInstances` will now return instance+ candidates ordered by _specificity_, rather than in unspecified order:+ If a candidate `c1 : T` has a type which is a substitution instance of+ that of another candidate `c2 : S`, `c1` will appear earlier in the+ list.++ As a concrete example, if you have instances `F (Nat → Nat)`, `F (Nat+ → a)`, and `F (a → b)`, they will be returned in this order. See+ [issue #6944](https://github.com/agda/agda/issues/6944) for further+ motivation.++Library management+------------------++* Agda now follows the XDG base directory standard on Unix-like systems,+ see [PR #6858](https://github.com/agda/agda/pull/6858).+ This means, it will look for configuration files in `~/.config/agda` rather than `~/.agda`.++ For backward compatibility, if you still have an `~/.agda` directory, it will look there first.++ No change on Windows, it will continue to use `%APPDATA%` (e.g. `C:/Users/USERNAME/AppData/Roaming/agda`).+++Other issues closed+-------------------++For 2.6.4.1, the following issues were also+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.6.4.1+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++- [#6745](https://github.com/agda/agda/issues/6745): Strange interaction between `opaque` and `let open`+- [#6746](https://github.com/agda/agda/issues/6746): Support GHC 9.8+- [#6852](https://github.com/agda/agda/issues/6852): Follow XDG Base Directory Specification+- [#6913](https://github.com/agda/agda/issues/6913): Internal error on `primLockUniv`-sorted functions+- [#6930](https://github.com/agda/agda/issues/6930): Termination checking with --prop: change in 2.6.4 compared with 2.6.3+- [#6931](https://github.com/agda/agda/issues/6931): Internal error with an empty parametrized module from a different file+- [#6941](https://github.com/agda/agda/issues/6941): Interaction between opaque and instance arguments+- [#6944](https://github.com/agda/agda/issues/6944): Order instances by specificity for reflection+- [#6953](https://github.com/agda/agda/issues/6953): Emacs 30 breaks agda mode+- [#6957](https://github.com/agda/agda/issues/6957): Agda stdlib installation instructions broken link+- [#6959](https://github.com/agda/agda/issues/6959): Warn about opaque `unquoteDecl`/`unquoteDef`+- [#6983](https://github.com/agda/agda/issues/6983): Refine command does not work on Emacs 30
@@ -0,0 +1,47 @@+Release notes for Agda version 2.6.4.2+======================================++This is a bug-fix release. It aims to be API-compatible with 2.6.4.1.+Agda 2.6.4.2 supports GHC versions 8.6.5 to 9.8.1.++Highlights+----------++- Fix an inconsistency in Cubical Agda related to catch-all clauses: [Issue #7033](https://github.com/agda/agda/issues/7033)+- Fix a regression in instance search introduced in 2.6.4.2: [Issue #7113](https://github.com/agda/agda/issues/7113)+- Fix a bug related to `opaque`: [Issue #6972](https://github.com/agda/agda/issues/6972)+- Fix some internal errors:+ * [Issue #7029](https://github.com/agda/agda/issues/7029)+ * [Issue #7034](https://github.com/agda/agda/issues/7034)+ * [Issue #7044](https://github.com/agda/agda/issues/7044)+- Fix building with cabal flag `-f debug-serialisation`: [Issue #7081](https://github.com/agda/agda/issues/7081)++List of closed issues+---------------------++For 2.6.4.2, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.6.4.2+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++- [Issue #6972](https://github.com/agda/agda/issues/6972): Unfolding fails when code is split up into multiple files+- [Issue #6999](https://github.com/agda/agda/issues/6999): Unification failure for function type with erased argument+- [Issue #7020](https://github.com/agda/agda/issues/7020): question: haskell backend extraction of `Data.Nat.DivMod.DivMod`?+- [Issue #7029](https://github.com/agda/agda/issues/7029): Internal error on confluence check when rewriting a defined symbol with a hole+- [Issue #7033](https://github.com/agda/agda/issues/7033): transpX clauses can be beat out by user-written _ clauses, leading to proof of ⊥+- [Issue #7034](https://github.com/agda/agda/issues/7034): Internal error with --two-level due to blocking on solved meta+- [Issue #7044](https://github.com/agda/agda/issues/7044): Serializer crashes on blocked definitions when using --allow-unsolved-metas+- [Issue #7048](https://github.com/agda/agda/issues/7048): hcomp symbols in interface not hidden under --cubical-compatible+- [Issue #7059](https://github.com/agda/agda/issues/7059): Don't recompile if --keep-pattern-variables option changes+- [Issue #7070](https://github.com/agda/agda/issues/7070): Don't set a default maximum heapsize for Agda runs+- [Issue #7081](https://github.com/agda/agda/issues/7081): Missing `IsString` instance with debug flags enabled+- [Issue #7095](https://github.com/agda/agda/issues/7095): Agda build flags appear as "automatic", but they are all "manual"+- [Issue #7104](https://github.com/agda/agda/issues/7104): Warning "there are two interface files" should not be serialized+- [Issue #7105](https://github.com/agda/agda/issues/7105): Internal error in generate-helper (C-c C-h)+- [Issue #7113](https://github.com/agda/agda/issues/7113): Instance resolution runs too late, leads to `with`-abstraction failure++These PRs not corresponding to issues were merged:++- [PR #6988](https://github.com/agda/agda/issues/6988): Provide a `.agda-lib` for Agda builtins+- [PR #7065](https://github.com/agda/agda/issues/7065): Some documentation fixes+- [PR #7072](https://github.com/agda/agda/issues/7072): Add 'Inference in Agda' to the list of tutorials+- [PR #7091](https://github.com/agda/agda/issues/7091): Add course to “Courses using Agda”
@@ -0,0 +1,17 @@+Release notes for Agda version 2.6.4.3+======================================++This release fixes a regression in 2.6.4.2 and one in 2.6.4.+It aims to be API-compatible with 2.6.4.1 and 2.6.4.2.++Agda 2.6.4.3 supports GHC versions 8.6.5 to 9.8.1.++Closed issues+-------------++For 2.6.4.3, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.6.4.3+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++- [Issue #7148](https://github.com/agda/agda/issues/7148): Regression in 2.6.4.2 concerning `with`+- [Issue #7150](https://github.com/agda/agda/issues/7150): Regression in 2.6.4 in `rewrite` with instances
@@ -0,0 +1,588 @@+Release notes for Agda version 2.6.4+====================================++Highlights+----------++* Cubical Agda now displays boundary conditions in interactive mode+ (PR [#6529](https://github.com/agda/agda/pull/6529)).++* An inconsistency in the treatment of large indices has been fixed+ (Issue [#6654](https://github.com/agda/agda/issues/6654)).++* Unfolding of definitions can now be fine-controlled via `opaque` definitions.++* Additions to the sort system: `LevelUniv` and `Propω`.++* New flag `--erasure` with several improvements to erasure (declared run-time irrelevance).++* New reflection primitives for meta-programming.++Installation+------------++* Removed the cabal flag `cpphs` that enabled building Agda with `cpphs` instead of the default C preprocessor.++* Agda supports GHC versions 8.6.5 to 9.6.3.++Pragmas and options+-------------------++* New command-line option `--numeric-version` to just print the version number of Agda.++* Option `--version` now also prints the cabal flags active in this build of Agda+ (e.g. whether Agda was built with `-f enable-cluster-counting`).++* New command-line option `--trace-imports` to switch on notification messages+ on the end of compilation of an imported module+ or on access to an interface file during the type-checking.++ See [--trace-imports](https://agda.readthedocs.io/en/v2.6.4/tools/command-line-options.html#cmdoption-trace-imports)+ in the documentation for more.++* New option `--no-infer-absurd-clauses` to simplify coverage checking and case splitting:+ Agda will then no longer attempt to automatically eliminate absurd clauses which can be a costly operation.+ This means that these absurd clauses have to be written out in the Agda text.+ Try this option if you experience type checking performance degradation with omitted absurd clauses.++ Opposite: `--infer-absurd-clauses`.++* Benign warnings are now printed together with their warning name, to give a hint how they can be disabled+ (see [#6229](https://github.com/agda/agda/issues/6229)).++* New option `--level-universe` to make `Level` inhabit its own universe `LevelUniv`:+ When this option is turned on, `Level` can now only depend on terms of type `Level`.++ Note: While compatible with the `--cubical` option, this option is currently not compatible with cubical builtin files, and an error will be raised when trying to import them in a file using `--level-universe`.++ Opposite: `--no-level-universe`.++* Most boolean options now have their opposite, e.g., `--allow-unsolved-metas` is complemented by `--no-allow-unsolved-metas`.+ With the opposite one can override a previously given option.+ Options given on the command line are overwritten by options given in the `.agda-lib` file,+ which in turn get overwritten by options given in the individual `.agda` file.++ New options (all on by default):+ - `--no-allow-exec`+ - `--no-allow-incomplete-matches`+ - `--no-allow-unsolved-metas`+ - `--no-call-by-name`+ - `--no-cohesion`+ - `--no-count-clusters`+ - `--no-erased-matches`+ - `--no-erasure`+ - `--no-experimental-irrelevance`+ - `--no-flat-split`+ - `--no-guarded`+ - `--no-injective-type-constructors`+ - `--no-keep-covering-clauses`+ - `--no-lossy-unification`+ - `--no-keep-pattern-variables`+ - `--no-omega-in-omega`+ - `--no-postfix-projections`+ - `--no-rewriting`+ - `--no-show-identity-substitutions`+ - `--no-show-implicit`+ - `--no-show-irrelevant`+ - `--no-two-level`+ - `--no-type-in-type`+ - `--eta-equality`+ - `--fast-reduce`+ - `--forcing`+ - `--import-sorts`+ - `--load-primitives`+ - `--main`+ - `--pattern-matching`+ - `--positivity-check`+ - `--print-pattern-synonyms`+ - `--projection-like`+ - `--termination-check`+ - `--unicode`++* Option `--flat-split` again implies `--cohesion`.+ Reverts change introduced in Agda 2.6.3 where `--cohesion` was a prerequisite for `--flat-split`.++* Pragma `INLINE` may now be applied to constructors of types supporting co-pattern matching.+ It enables translation of right-hand-side constructor applications to left-hand-side co-pattern splits (see [PR #6682](https://github.com/agda/agda/pull/6682)).+ For example, this translation allows the `nats` function to pass termination checking:+ ```agda+ record Stream (A : Set) : Set where+ coinductive; constructor _∷_+ field head : A+ tail : Stream A+ open Stream+ {-# INLINE _∷_ #-}++ nats : Nat → Stream Nat+ nats n = n ∷ nats (1 + n)+ ```+ Inlining transforms the definition of `nats` to the following definition by copattern matching:+ ```agda+ nats n .head = n+ nats n .tail = nats (1 + n)+ ```+ This form is accepted by the termination checker;+ unlike the form before inlining, it does not admit any infinite reduction sequences.++ If option `--exact-split` is on, the inlining will trigger a `InlineNoExactSplit` warning for `nats`.+ This warning can be disabled as usual, with `-WnoInlineNoExactSplit`.++* New option `--large-indices`, controlling whether constructors of+ indexed data types are allowed to refer to data that would be "too+ large" to fit in their declared sort. Large indices are disallowed by+ default; see the [language changes](#language) for details.++* New option `--forced-argument-recursion`, on by default, controlling+ whether forced constructor arguments are usable for termination+ checking. This flag may be necessary for Agda to accept nontrivial+ uses of induction-induction.++* The suffix `Warning` has been dropped from the warning names+ `DuplicateFieldsWarning` and `TooManyFieldsWarning`.++* The warning `GenericUseless` has been split into the three warnings+ `UselessPragma`, `FaceConstraintCannotBeHidden` and `FaceConstraintCannotBeNamed`.++* New warning `PatternShadowsConstructor` which used to be an error.++Library management+------------------++* [**Breaking**] One can no longer have `.agda-lib` files that are+ located below the "project root", on the path to the file that is+ being type-checked (see+ [#6465](https://github.com/agda/agda/issues/6465)).++ For instance, if you have a module called `A.B.C` in the directory+ `Root/A/B`, then an error is raised if there are `.agda-lib` files+ in `Root/A` or `Root/A/B`.++ Previously such `.agda-lib` files were ignored.++Interaction and emacs mode+--------------------------++* Agda now supports reading files with extension `.lagda.typ`, and use the parser for+ markdown files to parse them.+ To edit such files in Emacs with Agda support, one needs to add the line+ ```elisp+ (add-to-list 'auto-mode-alist '("\\.lagda.typ\\'" . agda2-mode))+ ```+ to `.emacs`.++ Generation for highlighted code like HTML is unsupported for Typst.+ One may generate HTML with typst input, but that makes little sense,+ and markdown is recommended instead when HTML export is desired.++* Helper function (`C-c C-h`) does not abstract over module parameters anymore+ (see [#2271](https://github.com/agda/agda/issues/2271))+ and neither over generalized `variable`s+ (see [#6689](https://github.com/agda/agda/pull/6689)).++* New Agda input mode prefix `box` for APL boxed operators, e.g. `\box=` for ⌸;+ see PR [#6510](https://github.com/agda/agda/pull/6510/files) for full list of bindings.++* Cubical Agda will now report boundary information for interaction+ points which are not at the top-level of their respective clauses.+ This includes bodies of `Path`-typed values, the faces of a partial+ element, arguments to functions returning paths, etc.++ Since this information is available in a structured way _during+ interaction_, the "goal type, context, and inferred type" command will+ also display the value of the expression at each relevant face.++ See also [PR #6529](https://github.com/agda/agda/pull/6529) for a+ deeper explanation and a demo video.++Syntax+------++* Agda now skips the UTF8 byte order mark (BOM) at beginning of files+ (see [#6524](https://github.com/agda/agda/issues/6524)).+ Previously, the BOM caused a parse error.++* If the new option `--hidden-argument-puns` is used, then the pattern+ `{x}` is interpreted as `{x = x}`, and the pattern `⦃ x ⦄` is+ interpreted as `⦃ x = x ⦄` (see+ [#6325](https://github.com/agda/agda/issues/6325)). Here `x` must be+ an unqualified name that does not refer to a constructor that is in+ scope: if `x` is qualified, then the pattern is not interpreted as a+ pun, and if `x` is unqualified and refers to a constructor that is+ in scope, then the code is rejected.++ This feature can be turned off using `--no-hidden-argument-puns`.++ Note that `{(x)}` and `⦃ (x) ⦄` are not interpreted as puns.++ Note also that `{x}` is not interpreted as a pun in `λ {x} → …` or+ `syntax f {x} = …`. However, `{x}` is interpreted as a pun in+ `λ (c {x}) → …`.++* `postulate` blocks may now contain `private` declarations+ (see [#1702](https://github.com/agda/agda/issues/1702)).++Language+--------++* [**Breaking**] Constructor arguments are no longer allowed to store+ values of a type larger than their own sort, even when these values+ are forced by the indices of a constructor.++ This fixes a particular instance of the incompatibility between+ structural recursion and impredicativity, which could previously be+ exploited through the use of large data-type indices.+ (see [#6654](https://github.com/agda/agda/issues/6654)).++ This behaviour can be controlled with the flag `--large-indices`. Note+ that, when `--large-indices` is enabled, forced constructor arguments+ should not be used for termination checking. The flag+ `--[no-]forced-argument-recursion` makes the termination checker skip+ these arguments entirely. When `--safe` is given, `--large-indices` is+ incompatible with `--without-K` _and_ incompatible with+ `--forced-argument-recursion`.++* Added [`opaque` definitions](https://agda.readthedocs.io/en/v2.6.4/language/opaque-definitions.html),+ a mechanism for finer-grained control of unfolding. Unlike `abstract`+ definitions, which can never be unfolded outside of (a child module+ of) the defining module, opacity can be toggled at use-sites:++ ```agda+ opaque+ foo : Set+ foo = Nat++ opaque+ unfolding foo++ _ : foo+ _ = 123+ ```++* Unless `--no-import-sorts` is given, `Set` is in scope as before,+ but `Prop` is only in scope when `--prop` is active.+ Additionally `SSet` is now in scope when `--two-level` is active+ (see [#6634](https://github.com/agda/agda/pull/6634)).++* New sorts `Propω`, `Propω₁`, etc., in analogy to `Setω`, `Setω₁` etc.+ Requires option `--prop`.++ Example:+ ```agda+ {-# OPTIONS --prop --large-indices #-}++ open Agda.Primitive++ variable+ ℓ : Level+ A : Set ℓ++ -- Lists of elements of types at any finite level.++ data HList : Setω where+ [] : HList+ _∷_ : A → HList → HList++ variable+ x : A+ xs : HList++ -- Predicate stating that all elements satisfy a given property.++ data All (P : ∀{ℓ} {A : Set ℓ} → A → Prop ℓ) : HList → Propω where+ [] : All P []+ _∷_ : P x → All P xs → All P (x ∷ xs)+ ```++* [**Breaking**] The algorithm for resolution of instance arguments+ has been simplified. It will now only rely on the type of instances+ to determine which candidate it should use, and no longer on their+ values.++Erasure+-------++* [**Breaking**] The new flag `--erasure` turns on support for erasure+ ([#6349](https://github.com/agda/agda/issues/6349)).++ This flag is infective.+ It is implied by `--erase-record-parameters` and `--erased-matches`.++ Unless this flag is active the following things are prohibited:+ * Use of the annotations `@0` and `@erased`.+ * Use of names defined in Cubical Agda in Erased Cubical Agda.++ When `--erasure` is used the parameter arguments of constructors and+ projections are marked as erased+ ([#4786](https://github.com/agda/agda/issues/4786)), with one+ exception: for indexed data types this only happens if the+ `--with-K` flag is active+ ([#6297](https://github.com/agda/agda/issues/6297)).++ For instance, the type of the constructor `c` below is `{@0 A :+ Set} → D A`, and the type of the projection `R.f` is `{@0 A : Set}+ → R A → A`:+ ```agda+ {-# OPTIONS --erasure #-}++ data D (A : Set) : Set where+ c : D A++ record R (A : Set) : Set where+ field+ f : A+ ```++* [**Breaking**] Unless the new flag `--erased-matches` is used+ matching is not allowed in erased positions for single-constructor+ data types or record types without η-equality+ ([#6349](https://github.com/agda/agda/issues/6349)).++ This flag is infective and implied by `--with-K`.+ If it is given explicitly, it implies `--erasure`.++* [**Breaking**] Added a hard compile-time mode (see+ [#4743](https://github.com/agda/agda/issues/4743)).++ When the hard compile-time mode is used all definitions are treated+ as erased. The hard compile-time mode is entered when an erased+ definition is checked (including an erased data or record type or+ module), but not when (for instance) a type-signature is checked.++ Previously the following code was rejected:+ ```agda+ open import Agda.Builtin.Bool++ @0 f : @0 Bool → Bool+ f = λ where+ true → false+ false → true+ ```+ Now this code is accepted (if `--erasure` is used). On the other+ hand, the following code which used to be accepted is now rejected+ (if `--erasure` is used), because the pattern-matching lambda is+ treated as erased:+ ```agda+ open import Agda.Builtin.Equality++ data Unit : Set where+ unit : Unit++ mutual++ f : Unit → Unit+ f = _++ @0 f≡ : f ≡ λ { unit → unit }+ f≡ = refl+ ```++* One can now mark data and record types and modules as erased (see+ [#4743](https://github.com/agda/agda/issues/4743)).++ If a data type is marked as erased, then it can only be used in+ erased settings, and its constructors are erased. A data type is+ marked as erased by writing `@0` or `@erased` right after the `data`+ keyword of the data type's declaration:+ ```agda+ data @0 D₁ : Set where+ c : D₁++ data @0 D₂ : Set++ data D₂ where+ c : D₁ → D₂++ interleaved mutual++ data @0 D₃ : Set where++ data D₃ where+ c : D₃+ ```++ If a record type is marked as erased, then it can only be used in+ erased settings, its constructors and fields are erased, and+ definitions in the record module are erased. A record type is marked+ as erased by writing `@0` or `@erased` right after the `record`+ keyword of the record type's declaration:+ ```agda+ record @0 R₁ : Set where+ field+ x : D₁++ record @0 R₂ : Set++ record R₂ where+ field+ x : R₁+ ```++ If a module is marked as erased, then all definitions inside the+ module (and in the module's telescope) are erased. A module is+ marked as erased by writing `@0` or `@erased` right after the+ `module` keyword:+ ```agda+ module @0 _ where++ F : @0 Set → Set+ F A = A++ module M (A : Set) where++ record R : Set where+ field+ @0 x : A++ module @0 N (@0 A : Set) = M A++ G : (@0 A : Set) → let module @0 M₂ = M A in Set+ G A = M.R B+ module @0 _ where+ B : Set+ B = A+ ```+ If an erased module is defined by a module application, then erased+ names can be used in the application, as in the definition of `N`+ above.++* Equivalence primitives no longer require full `--cubical` mode,+ `--erased-cubical` suffices. Equivalence definition is moved out of+ `Agda.Builtin.Cubical.Glue` into its own module `Agda.Builtin.Cubical.Equiv`,+ the former reexports the latter.++Reflection+----------++* `FOREIGN` and `COMPILE` pragmas can now be generated using two new reflection primitives:++ ```agda+ pragmaForeign : String → String → TC ⊤+ pragmaCompile : String → Name → String → TC ⊤+ ```++* Add 4 reflection primitives of the form `ask*` and `with*`:++ ```agda+ withNormalisation : ∀ {a} {A : Set a} → Bool → TC A → TC A+ askNormalisation : TC Bool++ withExpandLast : ∀ {a} {A : Set a} → Bool → TC A → TC A+ askExpandLast : TC Bool++ withReduceDefs : ∀ {a} {A : Set a} → (Σ Bool λ _ → List Name) → TC A → TC A+ askReduceDefs : TC (Σ Bool λ _ → List Name)++ askReconstructed : TC Bool+ ```+ to change the behaviour of `inferType`, `checkType`, `quoteTC`, `getContext`.++* [**Breaking**] The type of `withReconstructed` has been changed from++ ```agda+ withReconstructed : ∀ {a} {A : Set a} → TC A → TC A++ ```+ to+ ```agda+ withReconstructed : ∀ {a} {A : Set a} → Bool → TC A → TC A+ ```+ to match the type of primitives of the form `with*`.++* Two primitives `onlyReduceDefs` and `dontReduceDefs` are removed but re-implemented+ using the new family of primitives `with*` and `ask*` for backward compatibility.++* Blocking the type-checking monad can now be done with more precision+ by using the `Blocker` type, and the `blockTC` primitive:++ ```agda+ data Blocker : Set where+ blockerAny : List Blocker → Blocker+ blockerAll : List Blocker → Blocker+ blockerMeta : Meta → Blocker+ ```++ When blocking on a value of this type, the TCM computation will only+ be retried when any (resp. all) of the mentioned metavariables have+ been solved. This can avoid getting into loops where a macro blocks on+ a meta, gets unblocked, traverses some term again, and then blocks on+ a meta that was already present.++ The `blockOnMeta` builtin has been deprecated, and an implementation+ in terms of `blockTC` is given for backwards compatibility.+++Other issues closed+-------------------++For 2.6.4, the following issues were also+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.6.4+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++- [#1181](https://github.com/agda/agda/issues/1181): Display of let-bound variables in goals and error messages+- [#2271](https://github.com/agda/agda/issues/2271): Helper function abstracts over module parameters, with sometimes disastrous consequences for printing+- [#3437](https://github.com/agda/agda/issues/3437): Add Propω+- [#3605](https://github.com/agda/agda/issues/3605): Improve constraint reporting for cubical+- [#3690](https://github.com/agda/agda/issues/3690): Cubical interaction: Display inferred type with interval variables instantiated+- [#5900](https://github.com/agda/agda/issues/5900): De Bruijn fail in Cubical (Was: Garbled boundary contexts & naming eta expansion.)+- [#6124](https://github.com/agda/agda/issues/6124): Reflection: cannot reduce type because variable is erased+- [#6140](https://github.com/agda/agda/issues/6140): Unapplied `List` and `Maybe` are sometimes translated to `[AgdaAny]` and `Maybe AgdaAny` by GHC backend+- [#6229](https://github.com/agda/agda/issues/6229): Print warning name along with warning text+- [#6269](https://github.com/agda/agda/issues/6269): Documentation is missing for `--keep-covering-clauses` and `--lossy-unification`+- [#6271](https://github.com/agda/agda/issues/6271): Cubical: should generated code corresponding to erased constructors be erased?+- [#6272](https://github.com/agda/agda/issues/6272): Put Level type in a different sort+- [#6309](https://github.com/agda/agda/issues/6309): Drop support for GHC 8.0, 8.2, and 8.4+- [#6325](https://github.com/agda/agda/issues/6325): Hidden argument puns+- [#6333](https://github.com/agda/agda/issues/6333): Misleading file path in "Unrecognised option" error+- [#6336](https://github.com/agda/agda/issues/6336): Paradoxical self-reference in endpoints for path constructors+- [#6364](https://github.com/agda/agda/issues/6364): Instance candidates filtered out by type errors+- [#6371](https://github.com/agda/agda/issues/6371): Preserve metavariable name suggestion when eta-expanding+- [#6374](https://github.com/agda/agda/issues/6374): Refine does not work for overloaded record constructors+- [#6380](https://github.com/agda/agda/issues/6380): Confusing warning about turning instances into instances+- [#6395](https://github.com/agda/agda/issues/6395): `dataXXX` identifiers mis-parsed by {-# COMPILE GHC #-}+- [#6407](https://github.com/agda/agda/issues/6407): Agsy produces clauses with out of scope variables+- [#6413](https://github.com/agda/agda/issues/6413): Miscompilation of nested patterns in erased fields+- [#6415](https://github.com/agda/agda/issues/6415): Apparent infinite loop in cubical with --lossy-unification+- [#6418](https://github.com/agda/agda/issues/6418): Bug in rewriting with cubical primitives+- [#6434](https://github.com/agda/agda/issues/6434): Option to increase performance: do not filter out absurd clauses automatically+- [#6448](https://github.com/agda/agda/issues/6448): Don't define dependencies for elisp files included in the agda2-mode package+- [#6506](https://github.com/agda/agda/issues/6506): Cubical: `with` abstraction failing to type check+- [#6521](https://github.com/agda/agda/issues/6521): Support GHC 9.6 with cabal+- [#6523](https://github.com/agda/agda/issues/6523): Soundness bug: Tick constraints not properly propogated in Guarded Cubical+- [#6524](https://github.com/agda/agda/issues/6524): Ignore Unicode byte order mark+- [#6525](https://github.com/agda/agda/issues/6525): Recent Emacs's escape character handling improvement leads to an error when loading agda-mode+- [#6528](https://github.com/agda/agda/issues/6528): Guarded can block on solved metas+- [#6530](https://github.com/agda/agda/issues/6530): Miscompilation of case split RHS lambdas+- [#6541](https://github.com/agda/agda/issues/6541): Internal error in Agda.TypeChecking.Reduce.Fast+- [#6551](https://github.com/agda/agda/issues/6551): Doc: the keywords `hiding`,`public`, `renaming`, and `using` are always reserved+- [#6573](https://github.com/agda/agda/issues/6573): Check on presence of `--erasure` in `--erase-record-parameters` comes too early+- [#6581](https://github.com/agda/agda/issues/6581): Cubical: no canonicity for record types without η-equality+- [#6605](https://github.com/agda/agda/issues/6605): Doc: comments in "libraries" file+- [#6621](https://github.com/agda/agda/issues/6621): Enable K also for SSetω (like for SSet)+- [#6622](https://github.com/agda/agda/issues/6622): Bad error for `mutual` in implicit mutual block+- [#6624](https://github.com/agda/agda/issues/6624): Suffix not working for SSet+- [#6627](https://github.com/agda/agda/issues/6627): CheckArguments call exposes dummy checkArguments return type+- [#6632](https://github.com/agda/agda/issues/6632): hcompU eta rule in conversion checker loses solution+- [#6633](https://github.com/agda/agda/issues/6633): Bad interaction of Type:Type and SSet+- [#6648](https://github.com/agda/agda/issues/6648): `--level-universe` not respected when solving funSort `_->_ : ? -> Set -> SetOmega`+- [#6651](https://github.com/agda/agda/issues/6651): Agda fails on `univSort ? = SetOmega` even when `SizeUniv` is a solution+- [#6654](https://github.com/agda/agda/issues/6654): Forcing analysis is inconsistent for large indices+- [#6660](https://github.com/agda/agda/issues/6660): `{-# INLINE #-}` for copattern constructors+- [#6662](https://github.com/agda/agda/issues/6662): Error message for unsafe option combinations has wrong pluralization+- [#6677](https://github.com/agda/agda/issues/6677): Helper function type includes generalized parameters+- [#6687](https://github.com/agda/agda/issues/6687): Termination checker bug with `CATCHALL`+- [#6702](https://github.com/agda/agda/issues/6702): Inlining constructors to copattern should give warning with `--exact-split`+- [#6706](https://github.com/agda/agda/issues/6706): Shape-irrelevant variables marked as irrelevant in human-readable context+- [#6711](https://github.com/agda/agda/issues/6711): Internal error on `primStringUncons` when no builtin Sigma provided+- [#6714](https://github.com/agda/agda/issues/6714): Docstring error with Emacs 29+ due to changed escape rules for single quote+- [#6715](https://github.com/agda/agda/issues/6715): Type checking loops on certain pattern match in cubical (regression in 2.6.3)+- [#6720](https://github.com/agda/agda/issues/6720): Cubical: internal error in `Sort.hs`+- [#6725](https://github.com/agda/agda/issues/6725): Cubical: internal error in `Reduce.hs` (regression in 2.6.3)+- [#6750](https://github.com/agda/agda/issues/6750): Order of deserialization depends on build of Agda (version of `hashable`)+- [#6757](https://github.com/agda/agda/issues/6757): Incorrect `InteractionMetaBoundaries` warning+- [#6767](https://github.com/agda/agda/issues/6767): Internal error related to forcing on literals+- [#6786](https://github.com/agda/agda/issues/6786): Missing "when checking parameters of module M" in error message+- [#6787](https://github.com/agda/agda/issues/6787): Refine doesn't find proof of refl=refl without K+- [#6794](https://github.com/agda/agda/issues/6794): Safe Agda accepts `{-# TERMINATING #-}` pragma in `interleaved mutual` block+- [#6795](https://github.com/agda/agda/issues/6795): Missing warning about discarded `{-# TERMINATING #-}` pragma in `where` block inside `interleaved mutual` block+- [#6823](https://github.com/agda/agda/issues/6823): Suboptimal error location for missing definition before `mutual` block+- [#6868](https://github.com/agda/agda/issues/6868): With-abstraction fails for trailing instance argument
@@ -0,0 +1,72 @@+Release notes for Agda version 2.7.0.1+======================================++This is a minor release of Agda fixing some bugs and regressions.++Installation+------------++* During installation, Agda type-checks its built-in modules and installs the generated `.agdai` files.+ (This step is now skipped when the Agda executable is not installed, e.g. `cabal install --lib Agda`.)+ Should the generation for (some of) these files fail, the names of the missing ones are now printed,+ but installation continues nevertheless ([PR #7465](https://github.com/agda/agda/pull/7465)).+ Rationale: installation of these files is only crucial when installing Agda in super-user mode.++* Agda supports GHC versions 8.6.5 to 9.10.1.++Pragmas and options+-------------------++* The release notes of 2.7.0 claimed that the option `--exact-split` was now on by default+ ([Issue #7443](https://github.com/agda/agda/issues/7443)).+ This is actually not the case, the documentation has been suitably reverted.++* Default option `--save-metas` has been reverted to `--no-save-metas` because of performance regressions+ ([Issue #7452](https://github.com/agda/agda/issues/7452)).++Bug fixes+---------++* Fixed an internal error related to interface files+ ([Issue #7436](https://github.com/agda/agda/issues/7436)).++* Fixed two internal errors in Mimer:+ ([Issue #7402](https://github.com/agda/agda/issues/7402) and+ [Issue #7484](https://github.com/agda/agda/issues/7484)).++* Fixed a regression causing needless re-checking of files+ ([Issue #7199](https://github.com/agda/agda/issues/7199)).++* Improved printing of terms by fixing a display form bug+ ([PR #7480](https://github.com/agda/agda/issues/7480)).++List of closed issues+---------------------++For 2.7.0.1, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.7.0.1+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++- [Issue #7199](https://github.com/agda/agda/issues/7199): Agda re-checks a file with an up-to-date interface file+- [Issue #7402](https://github.com/agda/agda/issues/7402): Mimer internal error in hole with constraint+- [Issue #7436](https://github.com/agda/agda/issues/7436): Code only reachable from display forms not serialised in Agda 2.7.0+- [Issue #7442](https://github.com/agda/agda/issues/7442): Regression: emptiness check fails when erased constructors are involved+- [Issue #7443](https://github.com/agda/agda/issues/7443): `--exact-split` is not default in 2.7.0, contrary to claims+- [Issue #7452](https://github.com/agda/agda/issues/7452): Performance regression caused by making `--save-metas` the default+- [Issue #7455](https://github.com/agda/agda/issues/7455): Both stack and cabal fail to install Agda+- [Issue #7484](https://github.com/agda/agda/issues/7484): Internal error using Mimer in where block++These pull requests were merged for 2.7.0.1:++- [PR #7427](https://github.com/agda/agda/issues/7427): #7402: mimer failing on higher order goal+- [PR #7444](https://github.com/agda/agda/issues/7444): Fix #7436: make display forms of imported names DeadCode roots+- [PR #7445](https://github.com/agda/agda/issues/7445): Remove disclaimer that Agda would not follow the Haskell PVP+- [PR #7454](https://github.com/agda/agda/issues/7454): Fixed #7199+- [PR #7456](https://github.com/agda/agda/issues/7456): Actually, --exact-split is not really on by default+- [PR #7457](https://github.com/agda/agda/issues/7457): Revert default to `--no-save-metas`+- [PR #7465](https://github.com/agda/agda/issues/7465): Re #7455: Setup.hs: catch when Agda did not produce (all) agdai files+- [PR #7471](https://github.com/agda/agda/issues/7471): setup: Don't assume exe is built on --lib+- [PR #7475](https://github.com/agda/agda/issues/7475): Hotfix for #7442+- [PR #7476](https://github.com/agda/agda/issues/7476): Bump std-lib to latest (v2.1.1) and cubical to latest+- [PR #7480](https://github.com/agda/agda/issues/7480): Match display forms in the right context+- [PR #7487](https://github.com/agda/agda/issues/7487): Mimer shouldn't try to use existing pattern lambdas in solutions
@@ -0,0 +1,436 @@+Release notes for Agda version 2.7.0+====================================++Highlights+----------++* Mimer, a re-implementation of the "auto" term synthesizer, replaces Agsy.++* New syntax `using x ← e` to bind values on the left-hand-side of a function clause.++* Instance search is more performant thanks to a new indexing structure.+ Additionally, users can now control how instances should be selected+ in the case multiple candidates exist.++* User-facing options ~~`--exact-split`,~~ `--keep-pattern-variables`, and `--postfix-projections`+ are now on by default.++Installation+------------++* Agda versioning scheme switches to the [Haskell Package Versioning Policy](https://pvp.haskell.org/)+ so Agda can be more reliably used as a library.+ Major releases will now bump the second number in the version tuple: 2.7.0, 2.8.0, 2.9.0, ...++* When the creation of the Agda library interface files fails during installation,+ a warning is emitted rather than aborting installation.+ The absence of these interface files is not a problem if the Agda installation+ resides in user space; they will be created on the fly then.+ Yet for system-wide installations in root space or packaging,+ the interface files should be created.+ This can be achieved by a manual invocation of Agda on the library source files+ (i.e., primitive and builtin modules `Agda.*`).+ (See [Issue #7401](https://github.com/agda/agda/issues/7401) and [PR #7404](https://github.com/agda/agda/pull/7404).)++* Agda supports GHC versions 8.6.5 to 9.10.1.++Pragmas and options+-------------------++* [**Breaking**] The option `--overlapping-instances`, which allows+ backtracking during instance search, has been renamed to+ `--backtracking-instance-search`.++* These options are now on by default:++ * ~~`--exact-split`: Warn about clauses that are not definitional equalities.~~+ * `--keep-pattern-variables`: Do not introduce dot patterns in interactive splitting.+ * `--postfix-projections`: Print projections and projection patterns in postfix.+ * `--save-metas`: Try to not unfold metavariable solutions in interface files.++ To revert to the old behavior, use options `--no-...`.++* Option `--rewriting` is now considered infective.+ This means that if a module has this flag enabled,+ then all modules importing it must also have that flag enabled.++* New warnings:++ * `CoinductiveEtaRecord` if a record is declared both `coinductive` and having `eta-equality`.+ Used to be a hard error; now Agda continues, ignoring `eta-equality`.++ * `ConflictingPragmaOptions` if giving both `--this` and `--that`+ when `--this` implies `--no-that` (and analogous for `--no-this` implies+ `--that`, etc).++ * `ConstructorDoesNotFitInData` when a constructor parameter+ is too big (in the sense of universe level) for the target data type of the constructor.+ Error warning, used to be a hard error.++ * `DuplicateRecordDirectives` if e.g. a `record` is declared both `inductive` and `coinductive`,+ or declared `inductive` twice.++ * `UselessMacro` when a `macro` block does not contain any function definitions.++ * `WarningProblem` when trying to switch an unknown or non-benign warning with the `-W` option.+ Used to be a hard error.++* Rejected rewrite rules no longer cause a hard error but instead cause+ an error warning. The following warnings were added to document the+ various reasons for rejection:+ * `RewriteLHSNotDefinitionOrConstructor`+ * `RewriteVariablesNotBoundByLHS`+ * `RewriteVariablesBoundMoreThanOnce`+ * `RewriteLHSReduces`+ * `RewriteHeadSymbolIsProjection`+ * `RewriteHeadSymbolIsProjectionLikeFunction`+ * `RewriteHeadSymbolIsTypeConstructor`+ * `RewriteHeadSymbolContainsMetas`+ * `RewriteConstructorParametersNotGeneral`+ * `RewriteContainsUnsolvedMetaVariables`+ * `RewriteBlockedOnProblems`+ * `RewriteRequiresDefinitions`+ * `RewriteDoesNotTargetRewriteRelation`+ * `RewriteBeforeFunctionDefinition`+ * `RewriteBeforeMutualFunctionDefinition`++### Lossy unification++* [New option `--require-unique-meta-solutions`](https://agda.readthedocs.io/en/v2.7.0/tools/command-line-options.html#cmdoption-require-unique-meta-solutions)+ (turned on by default).+ Disabling it with `--no-require-unique-meta-solutions` allows the type checker+ to take advantage of `INJECTIVE_FOR_INFERENCE` pragmas (see below).+ The `--lossy-unification` flag implies `--no-require-unique-meta-solutions`.++* [New pragma `INJECTIVE_FOR_INFERENCE`](https://agda.readthedocs.io/en/v2.7.0/pragmas.html#injective-for-inference-pragma)+ which treats functions as injective for inferring implicit arguments if+ `--no-require-unique-meta-solutions` is given. The `--no-require-unique-meta-solutions` flag needs to be given in the+ file where the function is used, and not necessarily in the file where it is defined.+ For example:+ ```agda+ postulate+ reverse-≡ : {l l' : List A} → reverse l ≡ reverse l' → reverse l ≡ reverse l'++ []≡[] : [] ≡ []+ []≡[] = reverse-≡ (refl {x = reverse []})+ ```+ does not work since Agda won't solve `l` and `l'` for `[]`, even though it knows `reverse l = reverse []`.+ If `reverse` is marked as injective with `{-# INJECTIVE_FOR_INFERENCE reverse #-}` this example will work.++Syntax+------++Additions to the Agda syntax.++* [Left-hand side let](https://agda.readthedocs.io/en/v2.7.0/with-abstraction.html#left-hand-side-let-bindings):+ `using x ← e`+ ([PR #7078](https://github.com/agda/agda/pull/7078))++ This new construct can be use in left-hand sides together with `with` and+ `rewrite` to give names to subexpressions. It is the left-hand side+ counterpart of a `let`-binding and supports the same limited form of pattern+ matching on eta-expandable record values.++ It can be quite useful when you have a function doing a series of nested+ `with`s that share some expressions. Something like++ ```agda+ fun : A → B+ fun x using z ← e with foo z+ ... | p with bar z+ ... | q = r+ ```++ Here the expression `e` doesn't have to be repeated in the two `with`-expressions.++ As in a `with`, multiple bindings can be separated by a `|`, and variables to+ the left are in scope in bindings to the right.++* Pattern synonyms can now expose existing instance arguments+ ([PR 7173](https://github.com/agda/agda/pull/7173)).+ Example:+ ```agda+ data D : Set where+ c : {{D}} → D++ pattern p {{d}} = c {{d}}+ ```+ This allows us to explicitly bind these argument in a pattern match+ and supply them explicitly when using the pattern synonym in an expression.+ ```agda+ f : D → D+ f (p {{d = x}}) = p {{d = x}}+ ```++ We cannot create new instance arguments this way, though.+ The following is rejected:+ ```agda+ data D : Set where+ c : D → D++ pattern p {{d}} = c d+ ```++Language+--------++Changes to type checker and other components defining the Agda language.++* Agda now uses *discrimination trees* to store and look up instance+ definitions, rather than linearly searching through all instances for+ a given "class" ([PR #7109](https://github.com/agda/agda/pull/7109)).++ This is a purely internal change, and should not result in any change+ to which programs are accepted or rejected. However, it significantly+ improves the performance of instance search, especially for the case+ of a "type class" indexed by a single type argument. The new lookup+ procedure should never be slower than the previous implementation.++Reflection+----------++Changes to the meta-programming facilities.++* [**Breaking**] Erased constructors are now supported in reflection machinery.+ Quantity argument was added to `data-cons`. For erased constructors this+ argument has a value of `quantity-0`, otherwise it's `quantity-ω`.+ `defineData` now requires setting quantity for each constructor.++* Add new primitive to run instance search from reflection code:++ ```agda+ -- Try to solve open instance constraints. When wrapped in `noConstraints`,+ -- fails if there are unsolved instance constraints left over that originate+ -- from the current macro invokation. Outside constraints are still attempted,+ -- but failure to solve them are ignored by `noConstraints`.+ solveInstanceConstraints : TC ⊤+ ```++* A new reflection primitive `workOnTypes : TC A → TC A` was added to+ `Agda.Builtin.Reflection`. This runs the given computation at the type level,+ which enables the use of erased things. In particular, this is needed when+ working with (dependent) function types with erased arguments. For example,+ one can get the type of the tuple constructor `_,_` (which now takes its type+ parameters as erased arguments, see above) and unify it with the current goal+ as follows:+ ```agda+ macro+ testM : Term → TC ⊤+ testM hole = bindTC (getType (quote _,_)) (λ t → workOnTypes (unify hole t))++ typeOfComma = testM+ ```++Interaction and emacs mode+--------------------------++* [**Breaking**] [The Auto command](https://agda.readthedocs.io/en/v2.7.0/tools/auto.html)+ _Agsy_ has been replaced by an entirely new implementation _Mimer_+ ([PR #6410](https://github.com/agda/agda/pull/6410)).+ This fixes problems where Auto would fail in the presence of language features+ it did not know about, such as copatterns or anything cubical.++ The reimplementation does not support case splitting (`-c`), disproving+ (`-d`) or refining (`-r`).++* The Agda input method for Emacs has been extended by several character bindings.+ The list of changes can be obtained with a git diff on the sources:+ ```+ git diff v2.6.4.3 v2.7.0 -- src/data/emacs-mode/agda-input.el+ ```++API+---++Highlighting some changes to Agda as a library.++* New module `Agda.Syntax.Common.KeywordRange` providing type `KwRange` isomorphic to `Range`+ to indicate source positions that just span keywords ([PR #7162](https://github.com/agda/agda/pull/7162)).+ The motivation for `KwRange` is to distinguish such ranges from ranges for whole subtrees,+ e.g. in data type `Agda.Syntax.Concrete.Declaration`.++ API:+ ```haskell+ module Agda.Syntax.Common.KeywordRange where++ type KwRange++ -- From Range to KwRange+ kwRange :: HasRange a => a -> KwRange++ -- From KwRange to Range+ instance HasRange KwRange where+ getRange :: KwRange -> Range+ ```++* New hook in ``Agda.Compiler.ToTreeless`` to enable custom pipelines in compiler backends+ ([PR #7273](https://github.com/agda/agda/pull/7273)).+++List of closed issues+---------------------++For 2.7.0, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.7.0+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++- [Issue #2492](https://github.com/agda/agda/issues/2492): Limit the size of terms agsy is allowed to insert+- [Issue #2853](https://github.com/agda/agda/issues/2853): Auto does not work well with record types+- [Issue #4594](https://github.com/agda/agda/issues/4594): Improve the blocking primitive+- [Issue #4777](https://github.com/agda/agda/issues/4777): Interaction between tactics and instance search+- [Issue #5264](https://github.com/agda/agda/issues/5264): Should more flags be infective (or have coinfective negations)?+- [Issue #6101](https://github.com/agda/agda/issues/6101): Agsy gives up when no HIT is present+- [Issue #6124](https://github.com/agda/agda/issues/6124): Reflection: cannot reduce type because variable is erased+- [Issue #6181](https://github.com/agda/agda/issues/6181): Agda incorrectly reports type error when an identity function is not properly hidden from the termination checker+- [Issue #6270](https://github.com/agda/agda/issues/6270): Irrelevance in the type of a record module definition+- [Issue #6292](https://github.com/agda/agda/issues/6292): Document interaction between reflection and erasure+- [Issue #6335](https://github.com/agda/agda/issues/6335): Error message for non-canonical value when using Show instances is confusing+- [Issue #6361](https://github.com/agda/agda/issues/6361): Agsy ignores --postfix-projections+- [Issue #6406](https://github.com/agda/agda/issues/6406): Subject reduction problem related to projections with non-erased parameter arguments+- [Issue #6433](https://github.com/agda/agda/issues/6433): Add unicode character BALLOT X as \crossmark to Agda input mode+- [Issue #6509](https://github.com/agda/agda/issues/6509): Agda seems to be very slow at typechecking records with many fields+- [Issue #6584](https://github.com/agda/agda/issues/6584): Case splitting on record renames top-level function+- [Issue #6643](https://github.com/agda/agda/issues/6643): Rewrite rules are allowed in implicit mutual blocks+- [Issue #6663](https://github.com/agda/agda/issues/6663): Function arguments are nonvariant more often than they should be+- [Issue #6667](https://github.com/agda/agda/issues/6667): An internal error occurrs when (mis)using syntax declarations+- [Issue #6744](https://github.com/agda/agda/issues/6744): Alias in constructor index foils the forcing analysis+- [Issue #6768](https://github.com/agda/agda/issues/6768): auto: not implemented HITs error on non-cubical code+- [Issue #6783](https://github.com/agda/agda/issues/6783): `@tactic` does not kick in for lambdas+- [Issue #6806](https://github.com/agda/agda/issues/6806): Remove `GenericWarning`+- [Issue #6841](https://github.com/agda/agda/issues/6841): Uncaught pattern violation when using `with...in...` instead of old-school inspect+- [Issue #6866](https://github.com/agda/agda/issues/6866): User Manual: Make Installation as Easy as Possible+- [Issue #6867](https://github.com/agda/agda/issues/6867): Agda rejects identity function on indexed datatype with erased index+- [Issue #6919](https://github.com/agda/agda/issues/6919): improving formatting of warnings/errors+- [Issue #6943](https://github.com/agda/agda/issues/6943): Making `--exact-split` and `--postfix-projections` default?+- [Issue #6945](https://github.com/agda/agda/issues/6945): Missing warning for non-empty but effectless `private` blocks+- [Issue #6976](https://github.com/agda/agda/issues/6976): Unexpected failure of instance resolution+- [Issue #7017](https://github.com/agda/agda/issues/7017): Document instance projections+- [Issue #7058](https://github.com/agda/agda/issues/7058): Unclear specification and correctness of TypeChecking/DeadCode+- [Issue #7090](https://github.com/agda/agda/issues/7090): REWRITE rule with confluence, inconsistencies with documentation and error messages+- [Issue #7123](https://github.com/agda/agda/issues/7123): Citation.cff+- [Issue #7136](https://github.com/agda/agda/issues/7136): Pattern synonyms with named arguments can be defined but not used+- [Issue #7146](https://github.com/agda/agda/issues/7146): Misprinted domain-free parameters with cohesion attribute+- [Issue #7158](https://github.com/agda/agda/issues/7158): Non-sensical error since 2.5.4 when applying a non-function+- [Issue #7167](https://github.com/agda/agda/issues/7167): Underapplied pattern synonyms expand to lambdas with wrong hiding in expressions+- [Issue #7170](https://github.com/agda/agda/issues/7170): Confusing error "Unused variable in pattern synonym"+- [Issue #7176](https://github.com/agda/agda/issues/7176): Instanceness is lost when expanding absurd pattern in pattern synonym expression+- [Issue #7177](https://github.com/agda/agda/issues/7177): No scope info for underscores inserted by pattern synonym expansion+- [Issue #7181](https://github.com/agda/agda/issues/7181): Forcing translation prevents reduction within function definition+- [Issue #7182](https://github.com/agda/agda/issues/7182): `getDefinition` gives wrong constructor for record from applied parameterised module+- [Issue #7187](https://github.com/agda/agda/issues/7187): Sort metas produce ill-typed reflected terms when quoted+- [Issue #7191](https://github.com/agda/agda/issues/7191): `show` does not respect `abstract`/`opaque` when normalising a term in a hole+- [Issue #7192](https://github.com/agda/agda/issues/7192): GHC 9.10+- [Issue #7193](https://github.com/agda/agda/issues/7193): Agda always has irrelevant projections+- [Issue #7196](https://github.com/agda/agda/issues/7196): Regression when giving instances with visible arguments+- [Issue #7202](https://github.com/agda/agda/issues/7202): `ModuleDoesntExport` has imprecise deadcode highlighting+- [Issue #7208](https://github.com/agda/agda/issues/7208): Importing module with wrong namespace causes internal error instead of user-friendly error.+- [Issue #7218](https://github.com/agda/agda/issues/7218): Internal error in opaque block when case splitting when just given extended lambda+- [Issue #7219](https://github.com/agda/agda/issues/7219): Only warn about unknown warnings, don't fail hard+- [Issue #7227](https://github.com/agda/agda/issues/7227): Save-metas causes OOM during macro execution+- [Issue #7236](https://github.com/agda/agda/issues/7236): Expected a hidden argument, but found a visible argument in with-abstraction when using REWRITE+- [Issue #7262](https://github.com/agda/agda/issues/7262): Error "This clause has target type ... which is not usable" highlights pattern instead of clause+- [Issue #7266](https://github.com/agda/agda/issues/7266): Internal error at Agda/TypeChecking/Substitute.hs:140:33+- [Issue #7286](https://github.com/agda/agda/issues/7286): Hard error on `instance` definition with unsolved type+- [Issue #7301](https://github.com/agda/agda/issues/7301): Agda >=2.6.3 hangs on conflicting record directives+- [Issue #7318](https://github.com/agda/agda/issues/7318): `--postfix-projections` do not make use of mixfix syntax+- [Issue #7326](https://github.com/agda/agda/issues/7326): Internal error on pattern lambda with no clauses+- [Issue #7329](https://github.com/agda/agda/issues/7329): wrong type for unnamed record constructor+- [Issue #7331](https://github.com/agda/agda/issues/7331): Search for project root crashes when (parent) directory lacks permissions+- [Issue #7332](https://github.com/agda/agda/issues/7332): quoteTerm loops on dependent copattern lambda+- [Issue #7337](https://github.com/agda/agda/issues/7337): Caching loses reflection-generated pragmas+- [Issue #7346](https://github.com/agda/agda/issues/7346): Proof of ⊥ using HIT-indexed type++These (relevant) pull requests were merged for 2.7.0:++- [PR #5267](https://github.com/agda/agda/issues/5267): Make more flags infective+- [PR #6410](https://github.com/agda/agda/issues/6410): Mimer: a drop-in replacement for Agsy+- [PR #6569](https://github.com/agda/agda/issues/6569): Do final checks before freezing metas+- [PR #6570](https://github.com/agda/agda/issues/6570): Coerce `unquote` applications+- [PR #6640](https://github.com/agda/agda/issues/6640): Add `INJECTIVE_FOR_INFERENCE` pragma+- [PR #6674](https://github.com/agda/agda/issues/6674): Testcase for fixed #6542+- [PR #6769](https://github.com/agda/agda/issues/6769): Various symbol additions to agda-input+- [PR #6870](https://github.com/agda/agda/issues/6870): [ fix #6867 ] Only consider arguments with @0 for forcing if --erasure is on+- [PR #6978](https://github.com/agda/agda/issues/6978): [ fix #6976 ] Add constraint for resolving the head of an instance+- [PR #7055](https://github.com/agda/agda/issues/7055): Unspine system projections when they have display forms+- [PR #7071](https://github.com/agda/agda/issues/7071): Eta-expand mismatched cubical primitives+- [PR #7078](https://github.com/agda/agda/issues/7078): Left-hand side `let`+- [PR #7103](https://github.com/agda/agda/issues/7103): [ re #5267 ] Add new infective options to user manual+- [PR #7109](https://github.com/agda/agda/issues/7109): Discrimination trees for instance search+- [PR #7115](https://github.com/agda/agda/issues/7115): Flake improvements+- [PR #7119](https://github.com/agda/agda/issues/7119): Split GenericWarning into individual warnings+- [PR #7121](https://github.com/agda/agda/issues/7121): Update installation.rst+- [PR #7138](https://github.com/agda/agda/issues/7138): Fix #7136: proper error when pattern definition has unsupported arguments+- [PR #7142](https://github.com/agda/agda/issues/7142): Fix #6783: error for @tactic on lambda+- [PR #7144](https://github.com/agda/agda/issues/7144): Add reference to Cornelis in the documentation+- [PR #7147](https://github.com/agda/agda/issues/7147): Fix #7146: printing of cohesion and lock attributes+- [PR #7149](https://github.com/agda/agda/issues/7149): Fix mutual information not being set properly by the positivity checker+- [PR #7155](https://github.com/agda/agda/issues/7155): Fix #6866: User Manual: Make Installation as Easy as Possible+- [PR #7159](https://github.com/agda/agda/issues/7159): Fix #7158: Application: check for sufficient arity before checking target+- [PR #7160](https://github.com/agda/agda/issues/7160): Fix #6667: case not `__IMPOSSIBLE__` for nullary syntax+- [PR #7161](https://github.com/agda/agda/issues/7161): Fix #6945: warn about useless private even in absense of nice decls+- [PR #7162](https://github.com/agda/agda/issues/7162): Blocks in Concrete syntax: store Range of block keyword+- [PR #7168](https://github.com/agda/agda/issues/7168): Fix #7167: type checking underapplied pattern synonyms+- [PR #7169](https://github.com/agda/agda/issues/7169): Trigger and improve error UnusedVariableInPatternSynonym+- [PR #7173](https://github.com/agda/agda/issues/7173): Part of #2829: Allow instance arguments in pattern synonyms that are such in the pattern already+- [PR #7179](https://github.com/agda/agda/issues/7179): Fix #7177: only setScope when scope is not null+- [PR #7180](https://github.com/agda/agda/issues/7180): Use compareAs for assignE even in compareAtom+- [PR #7183](https://github.com/agda/agda/issues/7183): Instance overlap pragmas+- [PR #7185](https://github.com/agda/agda/issues/7185): Fix #7176: turn absurd pattern in instance position to instance meta+- [PR #7197](https://github.com/agda/agda/issues/7197): Re. #7196: Only prune instances in serialised iface+- [PR #7203](https://github.com/agda/agda/issues/7203): Fix incorrectly quoted sorts+- [PR #7204](https://github.com/agda/agda/issues/7204): Fix #7202: ModuleDoesntExport: only highlight missing names+- [PR #7209](https://github.com/agda/agda/issues/7209): Fix #7208: restore missing check for OverlappingProjects+- [PR #7210](https://github.com/agda/agda/issues/7210): Fix range for deprecated module import warning when applied+- [PR #7211](https://github.com/agda/agda/issues/7211): Fix #7181: Allow matching to continue when stuck on lazy pattern+- [PR #7222](https://github.com/agda/agda/issues/7222): Fix #7219: only warn about problems with warning options+- [PR #7231](https://github.com/agda/agda/issues/7231): Instantiate terms before traversing them in tcExtendContext+- [PR #7237](https://github.com/agda/agda/issues/7237): Fix #7236: use context rather than telescope for lambda-bound variables in rewrite patterns+- [PR #7238](https://github.com/agda/agda/issues/7238): Build with GHC 9.10+- [PR #7241](https://github.com/agda/agda/issues/7241): Drop time-compat dependency and Stack LTS for GHC 8.6+- [PR #7243](https://github.com/agda/agda/issues/7243): re. 7218: Saturate opaque blocks after Give commands+- [PR #7248](https://github.com/agda/agda/issues/7248): Overhaul dead code elimination, make --save-metas the default+- [PR #7249](https://github.com/agda/agda/issues/7249): docs/installation: point new wiki+- [PR #7251](https://github.com/agda/agda/issues/7251): re. 7250: copy instanceinfo+- [PR #7252](https://github.com/agda/agda/issues/7252): Fix #7193: persistently remember what is a projection+- [PR #7260](https://github.com/agda/agda/issues/7260): Reflection primitive to solve instances+- [PR #7273](https://github.com/agda/agda/issues/7273): ToTreeless: allow backends to define custom pipelines+- [PR #7274](https://github.com/agda/agda/issues/7274): #7182: copied records should refer to the copied constructor and fields+- [PR #7276](https://github.com/agda/agda/issues/7276): #7191: respect abstract mode when using show function+- [PR #7283](https://github.com/agda/agda/issues/7283): agdaLatex documentation+- [PR #7292](https://github.com/agda/agda/issues/7292): New error warning `ConstructorDoesNotFitInData` instead of hard error.+- [PR #7298](https://github.com/agda/agda/issues/7298): Remove fiddly attempt at instance postponement+- [PR #7300](https://github.com/agda/agda/issues/7300): New deadcode warning CoinductiveEtaRecord instead of GenericError+- [PR #7302](https://github.com/agda/agda/issues/7302): Fix #7301 (loop in parser): move verifyRecordDirectives to scope checker+- [PR #7305](https://github.com/agda/agda/issues/7305): Fix #7286: don't fail hard when there are instances with unresolved types+- [PR #7307](https://github.com/agda/agda/issues/7307): fix #7017: document instance projections+- [PR #7310](https://github.com/agda/agda/issues/7310): Add `workOnTypes` reflection primitive+- [PR #7311](https://github.com/agda/agda/issues/7311): [ #6406 ] Add test cases from discussion on this issue+- [PR #7313](https://github.com/agda/agda/issues/7313): Update universe-levels.lagda.rst+- [PR #7314](https://github.com/agda/agda/issues/7314): Add constructors for custom backend warning/errors+- [PR #7315](https://github.com/agda/agda/issues/7315): same shadowing logic for record patterns as for constructor patterns in absToCon+- [PR #7316](https://github.com/agda/agda/issues/7316): add \crossmark to emacs input mode+- [PR #7317](https://github.com/agda/agda/issues/7317): Don't mark eta unit records as irrelevant+- [PR #7319](https://github.com/agda/agda/issues/7319): Make --postfix-projections the default+- [PR #7320](https://github.com/agda/agda/issues/7320): Turn on --exact-split by default+- [PR #7322](https://github.com/agda/agda/issues/7322): Expose constructor erasure in reflection interface+- [PR #7325](https://github.com/agda/agda/issues/7325): add CSS rule for macro names+- [PR #7327](https://github.com/agda/agda/issues/7327): proper error instead of impossible for clauseless pat-lam+- [PR #7330](https://github.com/agda/agda/issues/7330): [#7329] Correct module name in module applications+- [PR #7333](https://github.com/agda/agda/issues/7333): [#7332] don't loop when quoting dependent copattern lambdas+- [PR #7334](https://github.com/agda/agda/issues/7334): Fix #7331: handle permission error in search for project file+- [PR #7336](https://github.com/agda/agda/issues/7336): Remove duplicate imports and pragmas in MAlonzo+- [PR #7338](https://github.com/agda/agda/issues/7338): (#7337) foreign code needs to go in post-scope state+- [PR #7343](https://github.com/agda/agda/issues/7343): Turn illegal rewrite rules into an error warning+- [PR #7347](https://github.com/agda/agda/issues/7347): [ fix #7266 ] Check that constructor names match before projecting in `matchPattern`+- [PR #7349](https://github.com/agda/agda/issues/7349): Fix #7346 by not considering HIT-constructor arguments forced+- [PR #7350](https://github.com/agda/agda/issues/7350): Fix #6744 by reducing during forcing analysis.+- [PR #7352](https://github.com/agda/agda/issues/7352): Fix issue 7262: Range of the lhs modality check+- [PR #7353](https://github.com/agda/agda/issues/7353): Update installation docs (e.g. re #7163: document installation problems with `executable-dynamic`)+- [PR #7355](https://github.com/agda/agda/issues/7355): Make `--keep-pattern-variables` the default+- [PR #7356](https://github.com/agda/agda/issues/7356): Add --save-metas default to CHANGELOG+- [PR #7358](https://github.com/agda/agda/issues/7358): [ doc ] Document `--termination-depth` in user manual+- [PR #7359](https://github.com/agda/agda/issues/7359): Fix #7354 by making types of live metas live in DeadCode+- [PR #7360](https://github.com/agda/agda/issues/7360): Fix for issue #6841 and related changes+- [PR #7362](https://github.com/agda/agda/issues/7362): Fix #6919: separate warnings by empty line+- [PR #7364](https://github.com/agda/agda/issues/7364): Resolve instance overlap for irrelevant metas+- [PR #7367](https://github.com/agda/agda/issues/7367): Minor fixes to instance overlap + constraint postponement
@@ -0,0 +1,6 @@+Release notes for Agda version 2.8.0.1+======================================++* Added support for GHC 9.14.1++* Agda supports GHC versions 8.8.4 to 9.14.1.
@@ -0,0 +1,11 @@+Release notes for Agda version 2.8.0.2+======================================++This version fixes two issues with the released binaries.+No non-installation related issues were fixed over 2.8.0 or 2.8.0.1.+So if you have installed 2.8.0 or 2.8.0.1 already there is no need to upgrade to 2.8.0.2.++* Fix problem with missing `zlib1.dll` in released Windows binary ([issue #8733](https://github.com/agda/agda/issues/8733))+* Remove commit hash from version number in released binaries ([issue #8716](https://github.com/agda/agda/issues/8716))++* Agda supports GHC versions 8.8.4 to 9.14.1.
@@ -0,0 +1,639 @@+Release notes for Agda version 2.8.0+====================================++Highlights+----------++* Agda is now a self-contained single binary.++* Build all Agda files reachable from paths in the `.agda-lib` file with new flag `--build-library`.++* Experimental support for polarity annotations with new flag `--polarity`.++* Compile to JavaScript with ES6 module syntax with new flag `--js-es6`.++* Errors now have an identifier and follow the GNU standard.++Installation+------------++* Dropped support for GHC 8.6, added support for GHC 9.12.++* Agda supports GHC versions 8.8.4 to 9.12.2.++* The `agda` binary now contains everything to set itself up,+ it need not be shipped with additional files.++ 1. The functionality of the `agda-mode` executable has been replicated+ under the new option `--emacs-mode`.+ The `agda-mode` executable is now deprecated.+ References to `agda-mode` in your `.emacs` file should be replaced+ by `agda --emacs-mode`.++ 2. Agda now contains all its data files,+ like primitive and builtin modules,+ supplements for the HTML and LaTeX backends,+ the runtimes for the `JS` and `GHC` backends,+ and the emacs mode.++ These will be written to the data directory+ on the first invocation of `agda` or an invocation of+ `agda --setup`, `agda --emacs-mode setup`, or `agda --emacs-mode compile`.++ The location of the data directory can be printed using+ `agda --print-agda-data-dir` and can be controlled by the `use-xdg-data-home`+ flag at build time and the `Agda_datadir` environment variable at runtime; see the+ documentation for more information.++* The Cabal/Stack custom installation `Setup.hs` has been removed+ that previously generated the `.agdai` files for the builtin and primitive modules.+ These will now be generated by Agda whenever they are needed,+ just as for ordinary modules.++ This change might be **breaking** for packagers of Agda+ as the packaging routines might need to be updated: in particular,+ declarative build systems like Nix or Guix should generate the `.agdai` files+ by invoking Agda at build time.++* Pre-built binaries are available as release assets for the following platforms++ * Windows (x86-64)+ * Linux (x86-64)+ * macOS (x86-64)+ * macOS (arm64)++ Installation instructions are provided in the Agda user manual.++* The `optimise-heavily` build flag is now turned on by default.++ This requires more resources when building Agda, but leads to a faster Agda binary.+ Should GHC run out of memory when building Agda, turn this flag off.++* Added cabal build flag `dump-core` to save the optimised GHC Core code during+ compilation of Agda. This can be useful for people working on improving the+ performance of the Agda implementation.++Pragmas and options+-------------------++* **BREAKING**: Abbreviation of options, such as `--warning` to `--warn`, is no longer supported.++* New main mode of operation `--build-library` (issue [#4338](https://github.com/agda/agda/issues/4338)).+ Invoking `agda --build-library` will look for an `.agda-lib` file starting in the current directory.+ It will then extract the `include` directories of this library,+ collect all Agda files in these directories and their subdirectories,+ and check all these files.++* New option `--setup` that writes out the Agda data files (see above)+ and can be used to regenerate them.++* New option `--emacs-mode` to administer the Emacs mode+ as previously done by the `agda-mode` executable.++* Option `--local-interfaces` and warning `DuplicateInterfaceFiles` have been removed.++* New option `--js-es6` for generating JavaScript with ES6 module syntax.++* `DISPLAY` pragmas can now define display forms that match on defined names+ beyond constructors ([issue #7533](https://github.com/agda/agda/issues/7533)).+ Example:+ ```agda+ {-# DISPLAY Irrelevant Empty = ⊥ #-}+ ```+ `Empty` used to be interpreted as a pattern variable, effectively installing+ the display form `Irrelevant _ = ⊥`.+ Now `Empty` is treated as a matchable name, as one would intuitively expect+ from a display form.+ As a consequence, only `Irrelevant Empty` is displayed as `⊥`, not just any+ `Irrelevant A`.++* A new **experimental** flag `--experimental-lazy-instances` causes+ instance selection to be deferred until the type of the instance+ constraint is determined enough to make an unamibiguous decision at+ the discrimination tree level. This significantly improves performance+ for cases where instances can be distinguished by rigid data.++ This flag will become the default in the future, but it is currently+ **disabled by default** because it has unexpected interactions with+ parts of the codebase (and macros) which rely on constraint solving+ order (see e.g. [issue #7882](https://github.com/agda/agda/issues/7883)+ and [issue #7847](https://github.com/agda/agda/issues/7847)).++Warnings+--------++* New warning `RewritesNothing` if a `rewrite` clause did not fire.++* New deadcode warnings `FixingCohesion`, `FixingPolarity` and `FixingRelevance`+ when wrong user-written attribute was corrected automatically by Agda.++* New deadcode warning `InvalidDisplayForm` instead of hard error+ when a display form is illegal (and thus ignored).++* New warning `UnusedVariablesInDisplayForm` when DISPLAY pragma+ binds variables that are not used.+ Example:+ ```agda+ {-# DISPLAY List (Fin n) = ListFin #-}+ ```+ Since pattern variable `n` is not used on the right hand side `ListFin`,+ Agda throws a warning and recommeds to rewrite it as:+ ```agda+ {-# DISPLAY List (Fin _) = ListFin #-}+ ```++* Unused `CATCHALL` pragmas now trigger `UselessPragma` warnings.++* New deadcode warning `EmptyPolarityPragma` for POLARITY pragma without polarities.+ E.g. triggered by `{-# POLARITY F #-}`.++* New parser warnings `MisplacedAttributes`, `UnknownAttribute`, and `UnknownPolarity`+ instead of hard parser errors.++* New deadcode warning `TooManyPolarities` instead of hard error+ when a POLARITY pragma gives polarities that exceed the known+ arity of the postulate.++* New deadcode warning `UselessTactic` when a `@tactic` attribute has no effect,+ typically when it is attached to a non-hidden or instance argument.++* New warning `WithClauseProjectionFixityMismatch` instead of hard error+ when in a with-clause a projection is used in a different fixity+ (prefix vs. postfix) than in its parent clause.++* New error warning `TooManyArgumentsToSort` instead of hard error.++* Warning `AbsurdPatternRequiresNoRHS` has been renamed to+ `AbsurdPatternRequiresAbsentRHS`.++* Warnings `OpenPublicAbstract` and `OpenPublicPrivate` have been replaced+ by new warnings `OpenImportAbstract` and `OpenImportPrivate`.++* Warning `NoGuardednessFlag` has been removed.+ Instead Agda gives a hint when `--guardedness` would help with termination checking,+ unless options `--sized-types` or `--no-guardedness` are set.+++Polarity+--------++* Support for polarity annotations can be enabled by the feature flag+ `--polarity`.++ This flag is infective.++ Uses of variables bound with polarity annotations are checked through modal+ typing rules, and the positivity checker has been expanded to take annotations+ into account. This means that the following is now definable:++ ```agda+ {-# OPTIONS --polarity #-}++ data Mu (F : @++ Set → Set) : Set where+ fix : F (Mu F) → Mu F+ ```++Syntax+------++Additions to the Agda syntax.++* Add new literate agda: forester, see [#7403](https://github.com/agda/agda/pull/7403).+ You will need the postprocessor [`agda-tree`](https://github.com/dannypsnl/agda-tree),+ see Agda user manual on literate programming for more information.++* It is now always possible to refer to the name of a record type's+ constructor, even if a name was not explicitly specified. This is done+ using the new `(Record name).constructor` syntax;+ see [issue #6964](https://github.com/agda/agda/issues/6964) for the motivation.++* The *left-hand-sides* of functions bound in a `let` expression can now+ contain the same types of patterns that are allowed in lambda+ expressions, in dependent function types, and in other `let` bindings.++ This means that++ ```agda+ let+ f : A → B → C+ f p1 p2 = ...+ in ...+ ```++ should be accepted exactly when, and have the same meaning as,++ ```agda+ let+ f : A → B → C+ f = λ p1 p2 → ...+ ```++ See [#7572](https://github.com/agda/agda/pull/7572).++Language+--------++Changes to type checker and other components defining the Agda language.++* **BREAKING**: The primitive "cubical identity type", previously+ exported from `Agda.Builtin.Cubical.Id`, has been removed. Its+ computational behaviour is exactly replicated by the user-definable+ identity type, which is also exported from `Agda.Builtin.Equality`.++ See [agda/cubical#1005](https://github.com/agda/cubical/pull/1005) for+ the PR removing it from the library, and+ [#7652](https://github.com/agda/agda/pull/7652) for the compiler.++* Inlining constructors no longer happens on the right-hand-sides of+ `INLINE` functions. This allows using `INLINE` functions to define+ "smart constructors" for record types which have the same reduction+ behaviour as using the actual constructor would. Small example:++ ```agda+ triple : Nat → Nat → Nat → Nat × Nat × Nat+ {-# INLINE triple #-}+ triple x y z = record { fst = x ; snd = y , z }++ ex = triple 1 2 3+ ```++ Here, constructor inlining happens on the right hand side *of `ex`*+ rather than of `triple`.++Reflection+----------++Changes to the meta-programming facilities.++* New reflection primitive: `checkFromStringTC : String → Type → TC Term`++ Parse and type check the given string against the given type, returning+ the resulting term (when successful).+++Library management+------------------++* **BREAKING**: Agda no longer accepts several `.agda-lib` files in the root+ of an Agda project.+ (Previously, it allowed this and took the union of their contents.)+++Interaction and emacs mode+--------------------------++* Agda's error messages now follow the [GNU standard](https://www.gnu.org/prep/standards/html_node/Errors.html).+ To comply with this policy, line and column are now separated by a dot instead of comma.+ The format of regular errors and error warnings follows this template:++ > _sourcefile_:_line1_._column1_-_line2_._column2_: error: [_ErrorName_]+ > ...+ > _error message_+ > ...+ > when _error context_++ _line2_ or even _column2_ can be missing, in some cases even the entire error location.+ Internal errors might follow a different format.++ Warnings are printed in a similar format:++ > _sourcefile_:_line1_._column1_-_line2_._column2_: warning: -W[no]_WarningName_+ > ...+ > _warning text_+ > ...+ > when _warning context_++* Emacs: new face `agda2-highlight-cosmetic-problem-face`+ for highlighting the new aspect `CosmeticProblem`.++* Emacs: new face `agda2-highlight-instance-problem-face`+ for highlighting the new aspect `InstanceProblem`.++* When generating clauses after case splitting on a datatype defined in a parameterised module,+ Agda now prints constructor names without a module prefix rather than fully qualified (see issue #3209).+ This is only a surface-level fix, since Agda might still fail to find the properly qualified name for+ the constructor in scope, but should at least make more sense in most situations.++* New bindings for unicode 'tacks' (⟘⟙⟛⟝⟞⫫⫪) via \tack (as well as specialised names for each of them)++Backends+--------++* New `backendInteractTop/backendInteractHole` fields for providing backend-specific interaction commands+ (run with keyboard shortcut `C-c C-i`).++* Buggy unused argument optimization removed from the JavaScript backend+ ([PR #7509](https://github.com/agda/agda/pull/7509)).++Issues closed+-------------++For 2.8.0, the following issues were+[closed](https://github.com/agda/agda/issues?q=is%3Aissue+milestone%3A2.8.0+is%3Aclosed)+(see [bug tracker](https://github.com/agda/agda/issues)):++Issues for closed for milestone 2.8.0+- [Issue #570](https://github.com/agda/agda/issues/570): Explicit polarity annotation+- [Issue #2004](https://github.com/agda/agda/issues/2004): `DISPLAY` should be more pragmatic+- [Issue #4100](https://github.com/agda/agda/issues/4100): GHC backend produces code that is wrongly compiled by GHC 8.4.* and 8.6.*+- [Issue #4338](https://github.com/agda/agda/issues/4338): Add mechanism to type check entire Agda libraries+- [Issue #4343](https://github.com/agda/agda/issues/4343): File order of checking matters (rewrite rules)+- [Issue #5299](https://github.com/agda/agda/issues/5299): Postfix projections are not documented+- [Issue #5865](https://github.com/agda/agda/issues/5865): Non Pattern Match Lambdas Missing From Docs+- [Issue #6111](https://github.com/agda/agda/issues/6111): Is compile-time irrelevance supposed to be erased with `COMPILE` pragmas?+- [Issue #6320](https://github.com/agda/agda/issues/6320): Parse strings to terms as reflection operation+- [Issue #6657](https://github.com/agda/agda/issues/6657): Turn `--guardedness` warning into an error-hint+- [Issue #6781](https://github.com/agda/agda/issues/6781): Making `@tactic` arguments visible leads to unsolved constraints+- [Issue #6916](https://github.com/agda/agda/issues/6916): Internal error at Agda/TypeChecking/Sort.hs:224:21+- [Issue #6964](https://github.com/agda/agda/issues/6964): Allow referring to unnamed record constructors+- [Issue #6994](https://github.com/agda/agda/issues/6994): Warnings are turned off, but code is still highlighted+- [Issue #7057](https://github.com/agda/agda/issues/7057): Document let-bindings in telescopes+- [Issue #7066](https://github.com/agda/agda/issues/7066): Documentation for anonymous modules+- [Issue #7157](https://github.com/agda/agda/issues/7157): Future: cabal build-type `Setup` will be phased out in favor of `Hooks`+- [Issue #7163](https://github.com/agda/agda/issues/7163): `cabal install Agda` fails with executable-dynamic+- [Issue #7321](https://github.com/agda/agda/issues/7321): No warning about useless `{-# CATCHALL #-}` pragma+- [Issue #7324](https://github.com/agda/agda/issues/7324): HTML backend: inconsistent highlighting for macro names+- [Issue #7375](https://github.com/agda/agda/issues/7375): The specification of `--safe` misses the pragmas+- [Issue #7381](https://github.com/agda/agda/issues/7381): Our error messages do not follow the GNU standard+- [Issue #7392](https://github.com/agda/agda/issues/7392): Pattern matching unifier does not preserve instances+- [Issue #7434](https://github.com/agda/agda/issues/7434): Range printed twice for "Parse error"+- [Issue #7440](https://github.com/agda/agda/issues/7440): Unexpected hidden argument in nested records/modules+- [Issue #7495](https://github.com/agda/agda/issues/7495): Catchall clauses with less arguments are considered exact+- [Issue #7503](https://github.com/agda/agda/issues/7503): Cumulativity `Prop <= Set` loses canonicity+- [Issue #7507](https://github.com/agda/agda/issues/7507): Broken CI/haskell installation on GitHub?+- [Issue #7508](https://github.com/agda/agda/issues/7508): Unused-arg optimization breaks function call+- [Issue #7517](https://github.com/agda/agda/issues/7517): `quoteTerm` accepts hidden arguments+- [Issue #7529](https://github.com/agda/agda/issues/7529): Strange problem with --level-universe and --cubical+- [Issue #7530](https://github.com/agda/agda/issues/7530): Generalized variable blocks projection-likeness+- [Issue #7531](https://github.com/agda/agda/issues/7531): JS backend crashes on big case split+- [Issue #7533](https://github.com/agda/agda/issues/7533): `DISPLAY` pragmas should treat any defined name as matchable+- [Issue #7535](https://github.com/agda/agda/issues/7535): Regression in 2.6.4: Agda thinks large propositions can be transported+- [Issue #7537](https://github.com/agda/agda/issues/7537): Type checking a definition with higher inductive type fails to terminate+- [Issue #7546](https://github.com/agda/agda/issues/7546): Why do we allow empty POLARITY pragmas?+- [Issue #7573](https://github.com/agda/agda/issues/7573): `primFloatRound` broken in JS+- [Issue #7574](https://github.com/agda/agda/issues/7574): Support GHC 9.12+- [Issue #7575](https://github.com/agda/agda/issues/7575): impossible error: `variable` in `BUILTIN`+- [Issue #7576](https://github.com/agda/agda/issues/7576): impossible error: parameter overflow in `declareData`+- [Issue #7580](https://github.com/agda/agda/issues/7580): Our Setup.hs does not build with Cabal-3.14+- [Issue #7585](https://github.com/agda/agda/issues/7585): Happy-2.1.1 causes Agda build to fail+- [Issue #7587](https://github.com/agda/agda/issues/7587): Mimer takes an absurd lambda as the solution of the original goal rather than the current (sub)goal+- [Issue #7588](https://github.com/agda/agda/issues/7588): __IMPOSSIBLE__, called at src/full/Agda/Compiler/JS/Compiler.hs:596:45+- [Issue #7590](https://github.com/agda/agda/issues/7590): Internal error with interaction point in a shared type signature+- [Issue #7618](https://github.com/agda/agda/issues/7618): De Bruijn index out of scope in the presence of rewrite rules and records+- [Issue #7624](https://github.com/agda/agda/issues/7624): Internal error when interactively checking expression with new meta-variables+- [Issue #7639](https://github.com/agda/agda/issues/7639): Internal error in `Agda/TypeChecking/Monad/Context.hs` using Mimer+- [Issue #7641](https://github.com/agda/agda/issues/7641): No error highlighting when "fits in" test fails+- [Issue #7642](https://github.com/agda/agda/issues/7642): Better not claim "Level should be a function type"+- [Issue #7643](https://github.com/agda/agda/issues/7643): Panic: uncaught pattern violation+- [Issue #7650](https://github.com/agda/agda/issues/7650): Internal error when utilizing Emacs case splits and `with .. in ..`+- [Issue #7655](https://github.com/agda/agda/issues/7655): haskell/cabal#10235 can still occur with Agda-2.7.0.1+- [Issue #7659](https://github.com/agda/agda/issues/7659): Using auto leads to `__IMPOSSIBLE__` when Σ and case_of_ are both present+- [Issue #7660](https://github.com/agda/agda/issues/7660): Add a warning for unresolved constructor name+- [Issue #7662](https://github.com/agda/agda/issues/7662): Using Auto with a goal involving musical coinduction `♭` produces incorrect projection+- [Issue #7668](https://github.com/agda/agda/issues/7668): Inductive identity allowed in negative position, inconsistent in Cubical Agda+- [Issue #7669](https://github.com/agda/agda/issues/7669): Positivity checker doesn't respect definitional equality+- [Issue #7673](https://github.com/agda/agda/issues/7673): `nix build` skips "generation of Agda core library interface files"+- [Issue #7675](https://github.com/agda/agda/issues/7675): `toIFile` logic from #6988 leads to scattering of `.agdai` files+- [Issue #7678](https://github.com/agda/agda/issues/7678): Order of agda-lib files in a directory affects flag settings+- [Issue #7692](https://github.com/agda/agda/issues/7692): Option to completely disable generation of dot patterns+- [Issue #7696](https://github.com/agda/agda/issues/7696): Panic: de Bruijn index out of scope+- [Issue #7707](https://github.com/agda/agda/issues/7707): ConstructorDoesNotFitInData error for record in Prop with Set fields+- [Issue #7709](https://github.com/agda/agda/issues/7709): Slow typecheck when importing a module with instances+- [Issue #7710](https://github.com/agda/agda/issues/7710): Forcing evaluation can give incorrect results in ghc compiled code+- [Issue #7712](https://github.com/agda/agda/issues/7712): Embed data files using file-embed+- [Issue #7722](https://github.com/agda/agda/issues/7722): Exponential behavior in pattern operator parser+- [Issue #7730](https://github.com/agda/agda/issues/7730): emacs-mode files fail to build with "file has no `lexical-binding` directive"+- [Issue #7738](https://github.com/agda/agda/issues/7738): Rewriting by a constructor+- [Issue #7751](https://github.com/agda/agda/issues/7751): Application of module with datatype fools the termination checker+- [Issue #7753](https://github.com/agda/agda/issues/7753): Coverage checker internal error with copatterns and dot patterns+- [Issue #7759](https://github.com/agda/agda/issues/7759): Internal error for ellipsis without with-patterns+- [Issue #7761](https://github.com/agda/agda/issues/7761): Propω is not actually proof irrelevant+- [Issue #7765](https://github.com/agda/agda/issues/7765): Supply reason with UselessPublic warning+- [Issue #7766](https://github.com/agda/agda/issues/7766): .lagda.org: {-1} outside agda code block messes up hole detection+- [Issue #7769](https://github.com/agda/agda/issues/7769): The warning OpenPublicAbstract is wrongly formulated+- [Issue #7777](https://github.com/agda/agda/issues/7777): Parse error when using tactic and irrelevance+- [Issue #7788](https://github.com/agda/agda/issues/7788): TooManyPatternsInWithClause when nesting hidden `with`+- [Issue #7792](https://github.com/agda/agda/issues/7792): Inlining happens at most twice+- [Issue #7795](https://github.com/agda/agda/issues/7795): Polarity annotation ignored by positivity checker?+- [Issue #7796](https://github.com/agda/agda/issues/7796): Distinguish --no-guardedness from default value in termination hints?+- [Issue #7799](https://github.com/agda/agda/issues/7799): Potential regression related to instance resolution+- [Issue #7811](https://github.com/agda/agda/issues/7811): Internal error with Path and with-abstraction II+- [Issue #7815](https://github.com/agda/agda/issues/7815): Missing highlighting in module telescopes+- [Issue #7823](https://github.com/agda/agda/issues/7823): DISPLAY matches pattern with wrong amount of arguments+- [Issue #7825](https://github.com/agda/agda/issues/7825): DISPLAY form on irrelevant projection drops arguments+- [Issue #7832](https://github.com/agda/agda/issues/7832): Recursive function over inductive record treats arguments as irrelevant+- [Issue #7851](https://github.com/agda/agda/issues/7851): Error TooManyPolarities is too eager+- [Issue #7853](https://github.com/agda/agda/issues/7853): Subject reduction failure with instance constructors in parameterised modules+- [Issue #7856](https://github.com/agda/agda/issues/7856): Strange interaction between `opaque` and extended lambdas+- [Issue #7863](https://github.com/agda/agda/issues/7863): Internal error when calling MakeCase on target `__`+- [Issue #7878](https://github.com/agda/agda/issues/7878): Impossible with malformed notation RHS+- [Issue #7884](https://github.com/agda/agda/issues/7884): Better documentation of forester backend in CHANGELOG+- [Issue #7898](https://github.com/agda/agda/issues/7898): Solving with auto doesn't update constraints+- [Issue #7903](https://github.com/agda/agda/issues/7903): Constructor inlining defeated by moving binders+- [Issue #7911](https://github.com/agda/agda/issues/7911): `UnsolvedConstraints` error should reference location even when all metas were solved+- [Issue #7912](https://github.com/agda/agda/issues/7912): Missing error location for error: [ModuleNameDoesntMatchFileName]+- [Issue #7916](https://github.com/agda/agda/issues/7916): Make `-f optimise-heavily` default+- [Issue #7935](https://github.com/agda/agda/issues/7935): Document scoping rules for rewrite rules+- [Issue #7938](https://github.com/agda/agda/issues/7938): Request: Expose backend-internal modules as part of the library+- [Issue #7943](https://github.com/agda/agda/issues/7943): Local erased definition remains in compiled code+- [Issue #7944](https://github.com/agda/agda/issues/7944): Local erased modules break erasure analysis+- [Issue #7952](https://github.com/agda/agda/issues/7952): Primitive root example in docs+- [Issue #7953](https://github.com/agda/agda/issues/7953): Confusing error in case of illegal declaration before top-level module in a nested file+- [Issue #7966](https://github.com/agda/agda/issues/7966): Disallow option abbreviation+- [Issue #7973](https://github.com/agda/agda/issues/7973): If rewrite does not rewrite anything, give a warning+- [Issue #7977](https://github.com/agda/agda/issues/7977): Soft error for unknown attributes++PRs for closed for milestone 2.8.0++- [PR #6629](https://github.com/agda/agda/issues/6629): Reflection primitive for parsing surface level syntax from string.+- [PR #7010](https://github.com/agda/agda/issues/7010): [new] backend-end specific interaction+- [PR #7023](https://github.com/agda/agda/issues/7023): Add ⧺ in agda-input.el+- [PR #7287](https://github.com/agda/agda/issues/7287): Temporary fix for reflection of partial elements.+- [PR #7366](https://github.com/agda/agda/issues/7366): Handle symlinks correctly when computing interface file locations+- [PR #7374](https://github.com/agda/agda/issues/7374): New warning `WithClauseProjectionFixityMismatch` instead of GenericError+- [PR #7377](https://github.com/agda/agda/issues/7377): New warning `RecursiveDisplayForm` instead of hard error+- [PR #7379](https://github.com/agda/agda/issues/7379): Print error name with error message+- [PR #7385](https://github.com/agda/agda/issues/7385): New error group GHCBackendError instead of GenericError+- [PR #7387](https://github.com/agda/agda/issues/7387): Factor out `give_` and remove PatternErr handler+- [PR #7388](https://github.com/agda/agda/issues/7388): GenericError crusade, continued+- [PR #7391](https://github.com/agda/agda/issues/7391): New error NeedOptionAllowExec etc. instead of GenericError+- [PR #7394](https://github.com/agda/agda/issues/7394): New error group InteractionError+- [PR #7395](https://github.com/agda/agda/issues/7395): Get rid of some MonadFail in favor of __IMPOSSIBLE__+- [PR #7396](https://github.com/agda/agda/issues/7396): instance warning+- [PR #7403](https://github.com/agda/agda/issues/7403): New literate programming backend forester, `*.lagda.tree`+- [PR #7409](https://github.com/agda/agda/issues/7409): GenericError crusade goes on: NeedOptionSizedTypes etc.+- [PR #7412](https://github.com/agda/agda/issues/7412): pattern in path lambda+- [PR #7414](https://github.com/agda/agda/issues/7414): Replace interaction `Cmd_no_metas` by `Cmd_load_no_metas`+- [PR #7415](https://github.com/agda/agda/issues/7415): Error refactoring: use of `Exception`, generic errors+- [PR #7418](https://github.com/agda/agda/issues/7418): New errors CannotGenerate{HComp,Transport}Clause+- [PR #7425](https://github.com/agda/agda/issues/7425): GenericError replacements+- [PR #7426](https://github.com/agda/agda/issues/7426): #7371: add Mimer tests for -s and -l+- [PR #7430](https://github.com/agda/agda/issues/7430): Warnings instead of GenericError for ill-formed pragmas+- [PR #7435](https://github.com/agda/agda/issues/7435): Print warning name on same line as location+- [PR #7437](https://github.com/agda/agda/issues/7437): Reform printing of parse error+- [PR #7447](https://github.com/agda/agda/issues/7447): Add new error `InvalidModalTelescopeUse` and add reproducer.+- [PR #7451](https://github.com/agda/agda/issues/7451): New warning FixingRelevance instead of GenericError+- [PR #7453](https://github.com/agda/agda/issues/7453): New error NotAllowedInDotPatterns instead of GenericError+- [PR #7458](https://github.com/agda/agda/issues/7458): Add ZuriHac Video to tutorial-list+- [PR #7459](https://github.com/agda/agda/issues/7459): NotAValidLet{Expression,Binding} instead of GenericError+- [PR #7462](https://github.com/agda/agda/issues/7462): Naming generic syntax errors (GenericError quest)+- [PR #7473](https://github.com/agda/agda/issues/7473): Re #6919: also separate compilation warnings by newlines+- [PR #7478](https://github.com/agda/agda/issues/7478): Store warnings in a set rather than a list+- [PR #7481](https://github.com/agda/agda/issues/7481): Named Backend errors instead of GenericError+- [PR #7483](https://github.com/agda/agda/issues/7483): Some named scope errors replacing GenericError+- [PR #7488](https://github.com/agda/agda/issues/7488): Named scope errors instead of GenericError+- [PR #7491](https://github.com/agda/agda/issues/7491): ES6 modules+- [PR #7492](https://github.com/agda/agda/issues/7492): Correctly print ParserWarning range, remove `mdo`+- [PR #7496](https://github.com/agda/agda/issues/7496): Fix #7495: Check extra split clause patterns are trivial for exactness+- [PR #7498](https://github.com/agda/agda/issues/7498): Add Left Multimap (⟜) to agda-input.el+- [PR #7500](https://github.com/agda/agda/issues/7500): Fix & test `primShowNat`+- [PR #7501](https://github.com/agda/agda/issues/7501): handle ProjPs in DISPLAY pragmas+- [PR #7502](https://github.com/agda/agda/issues/7502): Make termination checking more permissive wrt non-exact clause reduction+- [PR #7504](https://github.com/agda/agda/issues/7504): [ fix #7503 ] Use principal sort of datatype for checking if split is ok+- [PR #7509](https://github.com/agda/agda/issues/7509): Fix #7508: remove unused-arg optimization from the JS backend+- [PR #7510](https://github.com/agda/agda/issues/7510): Expose the names of generated record constructors (reopen #6975)+- [PR #7511](https://github.com/agda/agda/issues/7511): Fix #7381: comply to GNU error standard: use dot instead of comma in ranges+- [PR #7512](https://github.com/agda/agda/issues/7512): GenericError crusade+- [PR #7513](https://github.com/agda/agda/issues/7513): Reconcile PR #7510 with commit ac2888a7ad: add Maybe Induction to scopeRecords+- [PR #7516](https://github.com/agda/agda/issues/7516): New error CannotQuote instead of GenericError+- [PR #7518](https://github.com/agda/agda/issues/7518): OccursCheckErrors+- [PR #7520](https://github.com/agda/agda/issues/7520): Drop GHC 8.6+- [PR #7534](https://github.com/agda/agda/issues/7534): Fix #7529: treat `LevelUniv` in Cubical Agda+- [PR #7536](https://github.com/agda/agda/issues/7536): Re #7533: warn when DISPLAY form binds variables unused on the rhs+- [PR #7539](https://github.com/agda/agda/issues/7539): Fix #7413: Cubical: a `GenericError` is actually `__IMPOSSIBLE__`+- [PR #7543](https://github.com/agda/agda/issues/7543): DISPLAY: match on defined names+- [PR #7545](https://github.com/agda/agda/issues/7545): Fix #7531: Preserve let bindings in the JS backend+- [PR #7550](https://github.com/agda/agda/issues/7550): Fix #7546: warn about empty POLARITY pragmas+- [PR #7555](https://github.com/agda/agda/issues/7555): Some error housekeeping+- [PR #7556](https://github.com/agda/agda/issues/7556): unquote errors+- [PR #7557](https://github.com/agda/agda/issues/7557): kill GenericError in instance search+- [PR #7559](https://github.com/agda/agda/issues/7559): Fix compilation of serialisation code on 32 bit platforms+- [PR #7566](https://github.com/agda/agda/issues/7566): Make dangling hidden/instance args into a warning+- [PR #7570](https://github.com/agda/agda/issues/7570): Optimize concrete name scopeLookup+- [PR #7572](https://github.com/agda/agda/issues/7572): Improvements to let desugaring+- [PR #7577](https://github.com/agda/agda/issues/7577): chore: remove uses of genericError+- [PR #7581](https://github.com/agda/agda/issues/7581): don't add generalizedTel definitions to mutual blocks+- [PR #7583](https://github.com/agda/agda/issues/7583): Implement conversion to JS `BigInt`+- [PR #7586](https://github.com/agda/agda/issues/7586): Support Happy 2.1.1+- [PR #7589](https://github.com/agda/agda/issues/7589): Fix #7575: Check if variables are generalizable in builtin pragmas+- [PR #7591](https://github.com/agda/agda/issues/7591): Fix #7588: Remove overlapping branches when simplifying chained cases+- [PR #7593](https://github.com/agda/agda/issues/7593): Fix #7576+- [PR #7604](https://github.com/agda/agda/issues/7604): REPL: fix printing of result of `:typeOf`+- [PR #7613](https://github.com/agda/agda/issues/7613): Correct parameters to wrapper modules created in module telescopes+- [PR #7617](https://github.com/agda/agda/issues/7617): Fix de Bruijn indices in Treeless primitive translation+- [PR #7622](https://github.com/agda/agda/issues/7622): [ fix #7618 ] Use `underAbstraction_` for going under lambda in `reduceAndEtaContract`+- [PR #7640](https://github.com/agda/agda/issues/7640): [ emacs ] adding su(b/p)(sim/approx) to input method+- [PR #7645](https://github.com/agda/agda/issues/7645): Fix #7642: new error CannotApply that mentions also term, not only type+- [PR #7648](https://github.com/agda/agda/issues/7648): Fix #7641: Range for ConstructorDoesNotFit warning (anon. rec. con.)+- [PR #7651](https://github.com/agda/agda/issues/7651): Fix #7650: Throw CaseSplitError when splitting on with-abstraction equality+- [PR #7652](https://github.com/agda/agda/issues/7652): remove the cubical identity type+- [PR #7653](https://github.com/agda/agda/issues/7653): Print point-ranges as such (line.col rather than line:col-col)+- [PR #7657](https://github.com/agda/agda/issues/7657): Setup: unconditionally check if we want interfaces+- [PR #7670](https://github.com/agda/agda/issues/7670): Fix typo `COMPILED`+- [PR #7672](https://github.com/agda/agda/issues/7672): Fix #7643: coverage: handle blocked sort in isFibrant+- [PR #7674](https://github.com/agda/agda/issues/7674): Fix #7669: positivity checker: compute function arity up to def. eq.+- [PR #7676](https://github.com/agda/agda/issues/7676): Remove `--local-interfaces` and warning `DuplicateInterfaceFiles`+- [PR #7677](https://github.com/agda/agda/issues/7677): Setup: fix `wantInterfaces` check+- [PR #7679](https://github.com/agda/agda/issues/7679): Disallow several .agda-lib files in the project root (#7678)+- [PR #7682](https://github.com/agda/agda/issues/7682): New main mode `--build-library`+- [PR #7685](https://github.com/agda/agda/issues/7685): Add dump-core cabal flag+- [PR #7686](https://github.com/agda/agda/issues/7686): Monomorphise unifyIndices+- [PR #7687](https://github.com/agda/agda/issues/7687): Make toTerm return a monadic function+- [PR #7688](https://github.com/agda/agda/issues/7688): Add some links to lecture notes and videos on Agda+- [PR #7697](https://github.com/agda/agda/issues/7697): Fix #7696: Add missing `addContext` when splitting on literals+- [PR #7699](https://github.com/agda/agda/issues/7699): Remove custom Setup.hs+- [PR #7700](https://github.com/agda/agda/issues/7700): Never generate dot patterns under --keep-pattern-variables+- [PR #7704](https://github.com/agda/agda/issues/7704): Speed up nix build+- [PR #7719](https://github.com/agda/agda/issues/7719): Embed data files into Agda binary+- [PR #7726](https://github.com/agda/agda/issues/7726): Compare overlapping instances in the right context+- [PR #7727](https://github.com/agda/agda/issues/7727): Fix #7722: in pattern parser only consider pattern-relevant operators+- [PR #7728](https://github.com/agda/agda/issues/7728): Improvements to instance search performance+- [PR #7729](https://github.com/agda/agda/issues/7729): Let Agda perform several of `--help`, `--version` etc. if the user requests so+- [PR #7732](https://github.com/agda/agda/issues/7732): Duplicate `agda-mode` as `agda --emacs-mode`+- [PR #7734](https://github.com/agda/agda/issues/7734): Doc: executable-dynamic no longer a problem on Linux+- [PR #7739](https://github.com/agda/agda/issues/7739): Fix #7738: Allow rewrite rule defined with constructor or primitive+- [PR #7742](https://github.com/agda/agda/issues/7742): Fix #7741: Fix printing inserted binder from operator section+- [PR #7743](https://github.com/agda/agda/issues/7743): Re-enable dot-pattern termination for Cubical Agda+- [PR #7745](https://github.com/agda/agda/issues/7745): Limit depth of constructed discrimination tree+- [PR #7746](https://github.com/agda/agda/issues/7746): Compute occurrences in trX “constructors”+- [PR #7750](https://github.com/agda/agda/issues/7750): Support GHC 9.12.2+- [PR #7752](https://github.com/agda/agda/issues/7752): Fix #7751: Consider datatype clauses generated from module application in recursion checker+- [PR #7758](https://github.com/agda/agda/issues/7758): Fix #7753: a possible `__IMPOSSIBLE__`+- [PR #7763](https://github.com/agda/agda/issues/7763): Fix #7761: Include large Prop in checks whether something is a Prop+- [PR #7764](https://github.com/agda/agda/issues/7764): Fixed #7730+- [PR #7767](https://github.com/agda/agda/issues/7767): Fix #7766: emacs org mode: fix code block end detection+- [PR #7768](https://github.com/agda/agda/issues/7768): Reason for UselessPublic; `private` useless in `where` blocks+- [PR #7771](https://github.com/agda/agda/issues/7771): Fix #7769: replace warning `OpenPublic{Abstract,Private}`+- [PR #7772](https://github.com/agda/agda/issues/7772): Fix #7707: wording of warning `ConstructorDoesNotFitInData`+- [PR #7773](https://github.com/agda/agda/issues/7773): Fix #7662: Mimer: special case for printing ♭+- [PR #7774](https://github.com/agda/agda/issues/7774): Fix #7321: warn about unused CATCHALL pragmas+- [PR #7775](https://github.com/agda/agda/issues/7775): Fix #6994: highlighting only for enabled warnings+- [PR #7776](https://github.com/agda/agda/issues/7776): Fix #7624 by reifying Term before wrapping it in GoalAndElaboration+- [PR #7778](https://github.com/agda/agda/issues/7778): Fix #6657: termination checker hints at missing --guardedness flag+- [PR #7782](https://github.com/agda/agda/issues/7782): re #3209: print out-of-scope names unqualified in case splits+- [PR #7783](https://github.com/agda/agda/issues/7783): Don't inline constructors into inline functions+- [PR #7785](https://github.com/agda/agda/issues/7785): Fix #7777: parse both attributes and irrelevance markers+- [PR #7786](https://github.com/agda/agda/issues/7786): New warning `UselessTactic` for `tactic` attribute on non-hidden binder+- [PR #7787](https://github.com/agda/agda/issues/7787): Small fixes for parsing and printing attributes+- [PR #7789](https://github.com/agda/agda/issues/7789): Fix issues #7759 and #7788: wrong counting of with-patterns in nested with+- [PR #7791](https://github.com/agda/agda/issues/7791): [ new ] unicode symbols for various 'tacks'+- [PR #7793](https://github.com/agda/agda/issues/7793): re #7792: keep inlining after inlining a copy+- [PR #7800](https://github.com/agda/agda/issues/7800): Fix #7796: don't hint towards --guardedness when --no-guardedness+- [PR #7802](https://github.com/agda/agda/issues/7802): Remove broken AbsurdLam heuristics from Mimer+- [PR #7804](https://github.com/agda/agda/issues/7804): re #7799: add instance hack to checkSectionApplication+- [PR #7812](https://github.com/agda/agda/issues/7812): Fix #7803 fix #7811: new error PathAbstractionFailed instead of crash+- [PR #7814](https://github.com/agda/agda/issues/7814): Fix #7660: new DisambiguateConstructor postponed tc problem+- [PR #7816](https://github.com/agda/agda/issues/7816): re #7815: propagate range into wrapper modules+- [PR #7817](https://github.com/agda/agda/issues/7817): Add documentation for telescopes and some related things+- [PR #7818](https://github.com/agda/agda/issues/7818): Make data directory overridable, default to XDG_DATA_HOME+- [PR #7819](https://github.com/agda/agda/issues/7819): [ fix #7392 ] Ensure wildcards and variable instances are kept+- [PR #7822](https://github.com/agda/agda/issues/7822): Fix issue #7537+- [PR #7824](https://github.com/agda/agda/issues/7824): Fix #7823: Compare number of arguments when matching on DISPLAY pragma+- [PR #7826](https://github.com/agda/agda/issues/7826): Fix #7825 by using `droppedPars` instead of hand-knitted code+- [PR #7830](https://github.com/agda/agda/issues/7830): Disregard qualified names when assigning clauses to functions in the nicifier+- [PR #7831](https://github.com/agda/agda/issues/7831): Fix #7829 by reactivating my own fix of #1618+- [PR #7834](https://github.com/agda/agda/issues/7834): fix #7795: Use occurrences from type for defs+- [PR #7840](https://github.com/agda/agda/issues/7840): Document which pragmas are unsafe+- [PR #7848](https://github.com/agda/agda/issues/7848): fix #7846: instance hack in abstract axioms+- [PR #7849](https://github.com/agda/agda/issues/7849): Fix for #7639+- [PR #7850](https://github.com/agda/agda/issues/7850): Re #7225: new error DatatypeIndexPolarity instead of GenericError+- [PR #7852](https://github.com/agda/agda/issues/7852): Turn TooManyPolarities error into warning (fixes #7851)+- [PR #7854](https://github.com/agda/agda/issues/7854): Modality warnings for constructors and fields+- [PR #7855](https://github.com/agda/agda/issues/7855): Re #7225 name error CubicalNotErasure+- [PR #7857](https://github.com/agda/agda/issues/7857): Forget opacity when checking signatures+- [PR #7858](https://github.com/agda/agda/issues/7858): Fix for #7659+- [PR #7859](https://github.com/agda/agda/issues/7859): Fix #7853: don't drop parameters of constructor in the same module+- [PR #7860](https://github.com/agda/agda/issues/7860): [ re #7587 ] Properly reintroduce absurd lambdas to Mimer+- [PR #7865](https://github.com/agda/agda/issues/7865): Fix #7863: properly parse names before case-splitting+- [PR #7867](https://github.com/agda/agda/issues/7867): Fix #7832 by placing properlyMatching in monad to have isEtaRecordConstructor+- [PR #7879](https://github.com/agda/agda/issues/7879): Fix #7878: reorder checks in `mkNotation`+- [PR #7880](https://github.com/agda/agda/issues/7880): Defer `MissingDefinitions` error in `--safe` until after typechecking+- [PR #7885](https://github.com/agda/agda/issues/7885): disable discrim-based instance deferral by default+- [PR #7886](https://github.com/agda/agda/issues/7886): [doc] explain how to do postprocessing for literate forester+- [PR #7891](https://github.com/agda/agda/issues/7891): Remove duplicate inverse scope computation.+- [PR #7895](https://github.com/agda/agda/issues/7895): Fix #7590+- [PR #7896](https://github.com/agda/agda/issues/7896): Fix #7324: highlighting of macro names in their definition+- [PR #7900](https://github.com/agda/agda/issues/7900): intro: filter (higher) constructors based on dimension+- [PR #7901](https://github.com/agda/agda/issues/7901): Properly update interaction points when solving with Mimer+- [PR #7904](https://github.com/agda/agda/issues/7904): Fix lexical-scope issue in emacs mode+- [PR #7907](https://github.com/agda/agda/issues/7907): Fix issue #7903: etaExpandClause before constructor inlining+- [PR #7913](https://github.com/agda/agda/issues/7913): Range information for unsolved instance constraints+- [PR #7920](https://github.com/agda/agda/issues/7920): Fix #7916: make optimise-heavily the default+- [PR #7924](https://github.com/agda/agda/issues/7924): Add a few notes on irrelevance+- [PR #7925](https://github.com/agda/agda/issues/7925): Add documentation for lambda expressions and absurd lambdas+- [PR #7931](https://github.com/agda/agda/issues/7931): Hint towards --guardedness even when --sized-types is on+- [PR #7932](https://github.com/agda/agda/issues/7932): Add `use-xdg-data-home`+- [PR #7934](https://github.com/agda/agda/issues/7934): Hygienic import of rewrite rules+- [PR #7936](https://github.com/agda/agda/issues/7936): Highlight only record keyword when fields are missing+- [PR #7939](https://github.com/agda/agda/issues/7939): Fix #7938: API: export Agda Highlighting Backend modules+- [PR #7942](https://github.com/agda/agda/issues/7942): [ doc ] remove reference to Cubical.Core.Everything+- [PR #7945](https://github.com/agda/agda/issues/7945): Fix #7944: do not apply `@0` from where-module to clause rhs+- [PR #7946](https://github.com/agda/agda/issues/7946): Fix #7943: propagate erasure status to `where` blocks.+- [PR #7956](https://github.com/agda/agda/issues/7956): Fix #7955: replace impossible with syntax error+- [PR #7957](https://github.com/agda/agda/issues/7957): Doc: replace PrimRoot by PrimeFactor in introductory text+- [PR #7958](https://github.com/agda/agda/issues/7958): Fix #7953: remember whether top-level module name was inferred+- [PR #7965](https://github.com/agda/agda/issues/7965): Re #7932: restore data-files in Agda.cabal and default data-dir+- [PR #7967](https://github.com/agda/agda/issues/7967): Fix #7966: fork GetOpt to disallow long option abbreviations+- [PR #7971](https://github.com/agda/agda/issues/7971): flake: use --build-library to build the builtins+- [PR #7978](https://github.com/agda/agda/issues/7978): Fix #7973: print warning if `rewrite` does not fire+- [PR #7981](https://github.com/agda/agda/issues/7981): Parse warning instead of error on unknown attributes and polarities
@@ -0,0 +1,43 @@+<?xml version="1.0" encoding="UTF-8"?>+<svg width="5217px" height="1707px" viewBox="0 0 5217 1707" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">+ <!-- Generator: Sketch 52.6 (67491) - http://www.bohemiancoding.com/sketch -->+ <title>logotype</title>+ <desc>Created with Sketch.</desc>+ <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">+ <g id="Group" transform="translate(-4781.000000, -4784.000000)">+ <rect id="white-background" fill="#FFFFFF" x="0" y="0" width="45624" height="78038"></rect>+ <g id="black-logotypes" transform="translate(4781.000000, 4784.000000)">+ <g id="logotype" transform="translate(219.000000, 219.000000)">+ <g id="logo">+ <circle id="left-eye" fill="#000000" cx="240" cy="270" r="27"></circle>+ <circle id="right-eye" fill="#000000" cx="340" cy="270" r="27"></circle>+ <path d="M1000,0 L600,400" id="wing" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"></path>+ <path d="M1200,100 L1000,300" id="tail-middle" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"></path>+ <path d="M1200,0 L1000,200" id="tail-top" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"></path>+ <path d="M500,0 L300,200" id="head-middle" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"></path>+ <path d="M600,0 L400,200" id="head-right" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"></path>+ <path d="M400,-2.84217094e-13 L0,400 L200,400 L200,600 C200,820 380,1000 600,1000 C820,1000 1000,820 1000,600 L1000,400 L1200,200" id="body" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"></path>+ </g>+ <g id="type" transform="translate(1200.000000, 0.000000)" stroke="#000000" stroke-width="36">+ <g id="A">+ <polyline id="A-body" stroke-linecap="round" stroke-linejoin="round" points="0 1000 1002 -2.27373675e-13 1002 1000"></polyline>+ <path d="M360,640.5 L1000.5,640.5" id="A-stroke"></path>+ </g>+ <g id="g" transform="translate(1140.000000, 280.000000)">+ <circle id="g-body" cx="360" cy="360" r="360"></circle>+ <path d="M720,0 L720,630 C720,830 560,990 360,990 C225.742948,990 109.510851,917.900176 47.6033734,810.000189" id="g-stroke" stroke-linecap="round" stroke-linejoin="round"></path>+ </g>+ <g id="d" transform="translate(2000.000000, 0.000000)">+ <circle id="d-body" cx="360" cy="640" r="360"></circle>+ <path d="M720.5,5.68434189e-14 L720.5,1000" id="d-stroke" stroke-linecap="round" stroke-linejoin="round"></path>+ </g>+ <g id="a" transform="translate(2860.000000, 280.000000)">+ <circle id="a-body" cx="360" cy="360" r="360"></circle>+ <path d="M720,0 L720,720" id="a-stroke" stroke-linecap="round" stroke-linejoin="round"></path>+ </g>+ </g>+ </g>+ </g>+ </g>+ </g>+</svg>
@@ -1,202 +1,109 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} -- | A program which either tries to add setup code for Agda's Emacs -- mode to the users .emacs file, or provides information to Emacs -- about where the Emacs mode is installed.+--+-- This executable is deprecated, its functionality covered since 2.8+-- by the @--emacs-mode@ flag of the agda executable.+--+-- However, we will continue to ship it with Agda+-- because the emacs mode of older Agda versions assumes its existence+-- for the version switching functionality @agda2-set-program-version@. module Main (main) where -import Control.Exception-import Control.Monad-import Data.Char-import Data.List-import Data.Version-import Numeric-import System.Directory-import System.Environment-import System.Exit-import System.FilePath-import System.IO-#if !(MIN_VERSION_base(4,2,0))-import qualified System.IO.UTF8 as UTF8-#endif-import System.Process+import System.Environment ( getArgs, getProgName )+import System.Exit ( exitFailure )+import System.FilePath ( takeFileName ) -import Paths_Agda (getDataDir, version)+import Agda.Setup as Agda ( getDataDir, setup )+import Agda.Setup.EmacsMode+import Agda.Version ( version ) -- | The program. main :: IO () main = do- prog <- getProgName+ self <- takeFileName <$> getProgName+ args <- getArgs case args of- [arg] | arg == locateFlag -> printEmacsModeFile- | arg == setupFlag -> do- dotEmacs <- findDotEmacs- setupDotEmacs (Files { thisProgram = prog- , dotEmacs = dotEmacs- })- _ -> do inform usage- exitFailure+ [arg]+ | arg == locateFlag -> do --- Command line options.+ -- Ensure that Agda has been setup so the Emacs mode is available.+ Agda.setup False -setupFlag = "setup"-locateFlag = "locate"+ printEmacsModeFile + | arg == setupFlag -> do+ inform $ deprecation self++ -- Ensure that Agda has been setup so the Emacs mode is available.+ Agda.setup False++ setupDotEmacs "agda"++ | arg == compileFlag -> do+ inform $ deprecation self++ -- Ensure that Agda has been setup so the Emacs mode is available.+ Agda.setup False++ compileElispFiles++ _ -> do+ dir <- getDataDir+ inform $ deprecation self+ inform $ usage dir+ exitFailure+ -- | Usage information. -usage :: String-usage = unlines- [ "This program, which is part of Agda version " ++ ver ++ ", can be run"- , "in two modes, depending on which option it is invoked with:"+usage :: FilePath -> String+usage dataDir = unlines+ [ "This program, which is part of Agda version " ++ version ++ ", can be run"+ , "in three modes, depending on which option it is invoked with:" , "" , setupFlag , ""- , " The program tries to add setup code for Agda's Emacs mode to the"+ , " The program unloads Agda's data files, including the Emacs mode,"+ , " to the following location:"+ , ""+ , " " ++ dataDir+ , ""+ , " It then tries to add setup code for Agda's Emacs mode to the" , " current user's .emacs file. It is assumed that the .emacs file"-#if MIN_VERSION_base(4,2,0) , " uses the character encoding specified by the locale."-#else- , " uses ASCII or some other character encoding which ASCII is"- , " compatible with (like Latin-1 or UTF-8)."-#endif , "" , locateFlag , "" , " The path to the Emacs mode's main file is printed on standard" , " output (using the UTF-8 character encoding and no trailing" , " newline)."+ , ""+ , compileFlag+ , ""+ , " The program unloads Agda's data files, including the Emacs mode,"+ , " to the following location:"+ , ""+ , " " ++ dataDir+ , ""+ , " It then tries to compile Agda's Emacs mode's source files."+ , ""+ , " WARNING: If you reinstall the Agda mode without recompiling the Emacs"+ , " Lisp files, then Emacs may continue using the old, compiled files." ] --- | The current version of Agda.--ver :: String-ver = intercalate "." $ map show $- versionBranch version----------------------------------------------------------------------------- Locating the Agda mode---- | Prints out the path to the Agda mode's main file (using UTF-8 and--- without any trailing newline).--printEmacsModeFile :: IO ()-printEmacsModeFile = do- dataDir <- getDataDir- let path = dataDir </> "emacs-mode" </> "agda2.el"-#if MIN_VERSION_base(4,2,0)- hSetEncoding stdout utf8- putStr path-#else- UTF8.putStr path-#endif----------------------------------------------------------------------------- Setting up the .emacs file--data Files = Files { dotEmacs :: FilePath- -- ^ The .emacs file.- , thisProgram :: FilePath- -- ^ The name of the current program.- }---- | Tries to set up the Agda mode in the given .emacs file.--setupDotEmacs :: Files -> IO ()-setupDotEmacs files = do- informLn $ "The .emacs file used: " ++ dotEmacs files-- already <- alreadyInstalled files- if already then- informLn "It seems as if setup has already been performed."- else do-- appendFile (dotEmacs files) (setupString files)- inform $ unlines $- [ "Setup done. Try to (re)start Emacs and open an Agda file."- , "The following text was appended to the .emacs file:"- ] ++ lines (setupString files)---- | Tries to find the user's .emacs file by querying Emacs.--findDotEmacs :: IO FilePath-findDotEmacs = askEmacs "(insert (expand-file-name user-init-file))"---- | Has the Agda mode already been set up?--alreadyInstalled :: Files -> IO Bool-alreadyInstalled files = do- exists <- doesFileExist (dotEmacs files)- if not exists then return False else- withFile (dotEmacs files) ReadMode $ \h ->- evaluate . (identifier files `isInfixOf`) =<< hGetContents h- -- Uses evaluate to ensure that the file is not closed- -- prematurely.---- | If this string occurs in the .emacs file, then it is assumed that--- setup has already been performed.--identifier :: Files -> String-identifier files =- takeFileName (thisProgram files) ++ " " ++ locateFlag---- | The string appended to the end of the .emacs file.+-- | Deprecation warning. -setupString :: Files -> String-setupString files = unlines- [ ""- , "(load-file (let ((coding-system-for-read 'utf-8))"- , " (shell-command-to-string \""- ++ identifier files ++ "\")))"+deprecation :: String -> String+deprecation self = unlines+ [ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"+ , "@ Warning: " ++ self ++ " has been deprecated with Agda 2.8.0 @"+ , "@ and will be removed in the future. @"+ , "@ From Agda 2.8.0 on, use `agda --emacs-mode` instead. @"+ , "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"+ , "" ]----------------------------------------------------------------------------- Querying Emacs---- | Evaluates the given Elisp command using Emacs. The output of the--- command (whatever was written into the current buffer) is returned.------ Note: The input is not checked. The input is assumed to come from a--- trusted source.--askEmacs :: String -> IO String-askEmacs query = do- tempDir <- getTemporaryDirectory- bracket (openTempFile tempDir "askEmacs")- (removeFile . fst) $ \(file, h) -> do- hClose h- exit <- rawSystem "emacs"- [ "--eval"- , "(with-temp-file " ++ escape file ++ " "- ++ query ++ ")"- , "--kill"- ]- unless (exit == ExitSuccess) $ do- informLn "Unable to query Emacs."- exitFailure- withFile file ReadMode $ \h -> do- result <- hGetContents h- evaluate (length result)- -- Uses evaluate to ensure that the file is not closed- -- prematurely.- return result---- | Escapes the string so that Emacs can parse it as an Elisp string.--escape :: FilePath -> FilePath-escape s = "\"" ++ concatMap esc s ++ "\""- where- esc c | c `elem` ['\\', '"'] = '\\' : [c]- | isAscii c && isPrint c = [c]- | otherwise = "\\x" ++ showHex (fromEnum c) "\\ "----------------------------------------------------------------------------- Helper functions---- These functions inform the user about something by printing on--- stderr.--inform = hPutStr stderr-informLn = hPutStrLn stderr
@@ -1,31 +0,0 @@-/* Aspects. */-.Comment { color: #B22222 }-.Keyword { color: #CD6600 }-.String { color: #B22222 }-.Number { color: #A020F0 }-.Symbol { color: #404040 }-.PrimitiveType { color: #0000CD }-.Operator {}--/* NameKinds. */-.Bound { color: black }-.InductiveConstructor { color: #008B00 }-.CoinductiveConstructor { color: #8B7500 }-.Datatype { color: #0000CD }-.Field { color: #EE1289 }-.Function { color: #0000CD }-.Module { color: #A020F0 }-.Postulate { color: #0000CD }-.Primitive { color: #0000CD }-.Record { color: #0000CD }--/* OtherAspects. */-.DottedPattern {}-.UnsolvedMeta { color: black; background: yellow }-.TerminationProblem { color: black; background: #FFA07A }-.IncompletePattern { color: black; background: #F5DEB3 }-.Error { color: red; text-decoration: underline }--/* Standard attributes. */-a { text-decoration: none }-a[href]:hover { background-color: #B4EEB4 }
@@ -1,229 +0,0 @@-%include "string.h"---- IO--{--%inline putStr (x:String) -> Unit =- foreign Unit "wputStr" (x:String)--putStrLn (x:String) -> Unit =- putStr(primStringAppend(x,"\n"))--readStr () -> String =- foreign String "readStr" ()--intToStr (x:Int) -> String =- foreign String "intToStr" (x:Int)--strToInt (x:String) -> Int =- foreign String "strToInt" (x:String)--printInt (x:Int) -> Unit =- foreign Unit "printInt" (x:Int)--}--ioreturn (a : Any, u : Unit) -> Any = a-iobind (x : Any, f : Any, u : Unit) -> Any = %effect (let v : Any = %effect (x(u)) in f (v, u))---- String operations---- data String = Con 0 | Con 1 (Char*) String--freadStr (stream : Ptr) -> Data =- let isEof : Bool = foreign Int "feof" (stream : Ptr)- in if isEof then Con 0 ()- else let str : String = %effect(foreign String "freadStrChunk" (stream : Ptr))- in Con 1 ( str , freadStr (stream))--readStr (u : Unit) -> Data =- let isEof : Bool = foreign Int "eofstdin" ()- in if isEof then Con 0 ()- else let str : String = %effect(foreign String "readStrChunk" ())- in Con 1 ( str , readStr (u))--primStringAppend (xs : Data, ys : Data) -> Data = case xs of- { Con 0 () -> ys- | Con 1 (x : String, rest : Data) -> Con 1 (x, primStringAppend (rest, ys))- }--length (xs : Data) -> Int = case xs of- { Con 0 () -> 0- | Con 1 (x : String, rest : Data) -> strlen(x) + length(rest)- }--charAt (xs : Data, i : Int) -> Int = case xs of- { Con 0 () -> error "index: out of bounds!"- | Con 1 (x : String, rest : Data) -> - let len : Int = strlen(x)- in (if i < len then foreign Int "strIndex" (x : String, i : Int)- else charAt (rest, i - len))- }--mkString (xs : Data) -> String = case xs of- { Con 0 () -> ""- | Con 1 (s : String , rest : Data) -> - let rs : String = mkString (rest) in- {-let rsLen : Int = strlen (rs) in- if rsLen == 0 then s else-} foreign String "append" (s : String, rs : String)- }--frString( xs : String) -> Data = Con 1 (xs , Con 0 ())--primStringEquality (xs : Data, ys : Data) -> Bool =- foreign Int "eqString" (mkString(xs) : String, mkString(ys) : String)--charToString (c : Int) -> Data = - Con 1 (charToStr(c), Con 0 ())-charToStr (c : Int) -> String = - foreign String "charToStr" (c : Int)--strlen (s : String) -> Int = foreign Int "strlen" (s : String)---- TODO: toList/fromList could be made slightly more efficient.--primStringToListS (xs : String) -> Data = %effect(- let result : Data = primNil () in- let i : Int = strlen (xs) - 1 in- %while (i >= 0,- let ! result = primCons (foreign Int "strIndex" (xs : String, i : Int), result) in- let ! i = i - 1 in- unit) ;- result)--primStringToList (xs : Data) -> Data = case xs of- { Con 0 () -> primNil ()- | Con 1 (str : String, rest : Data) -> primListAppend(primStringToListS(str), primStringToList(rest))- }--map (f : Any, l : Any) -> Any = case l of- { Con 0 () -> Con 0 ()- | Con 1 (x : Any, xs : Any) -> Con 1 (f (x), map (f, xs))- }--primStringFromList (l : Data) -> String = map (charToStr, l)---strCons(i : Int , s : String) -> String =- foreign String "strCons" (i : Int, s : String)---- Lists--primNil () -> Data = Con 0 ()--primCons(x : Any , xs : Data) -> Data = Con 1 (x, xs)--listElim (op : Any, z : Any, xs : Data) -> Any = case xs of- { Con 0 () -> z- | Con 1 (y : Any, ys : Data) -> op (y, listElim(op, z, ys))- }--primListAppend (xs : Data, ys : Data) -> Data = listElim(primCons, ys, xs)--- Big number arithmetic--subBig (x:BigInt, y:BigInt) -> BigInt =- foreign BigInt "subBig" (x:BigInt, y:BigInt)--gtBig (x:BigInt, y:BigInt) -> Bool =- foreign Int "gtBig" (x:BigInt, y:BigInt)--leBig (x:BigInt, y:BigInt) -> Bool =- foreign Int "leBig" (x:BigInt, y:BigInt)--geBig (x:BigInt, y:BigInt) -> Bool =- foreign Int "geBig" (x:BigInt, y:BigInt)--printBig (x:BigInt) -> Unit =- foreign Unit "printBig" (x:BigInt)--bigToStr (x:BigInt) -> Data =- frString(foreign String "bigToStr" (x:BigInt))--strToBig (x : Data) -> Any = foreign BigInt "strToBig" (mkString(x) : String)---- strToBig (x:String) -> Any =--- foreign Any "strToBig" (x:String)--bigToInt (x : BigInt) -> Int =- foreign Int "bigToInt" (x : BigInt)---- Unit--%inline primUnit() -> Unit = unit---- Nats--primNatPlus (x:Any, y:Any) -> Any =- foreign Any "addBig" (x:Any, y:Any)--primNatTimes (x:Any, y:Any) -> Any =- foreign Any "mulBig" (x:Any, y:Any)--%inline primNatMinus(x : Any, y : Any) -> Any = atLeastZeroBig(subBig(x, y))----primZero() -> Any = foreign BigInt "bigZero" ()-primOne() -> Any = foreign BigInt "bigOne" ()--primSuc (n : Any) -> Any = primNatPlus(n, primOne())--primPred(n : Any) -> Any = subBig(n, primOne())--%inline atLeastZeroBig (x : Any) -> Any = - if primNatLess(x, primZero) - then primZero- else x--primNatModSucAux(k : BigInt, m : BigInt, n : BigInt, j : BigInt) -> BigInt =- foreign BigInt "modBig" (n : BigInt, m : BigInt)----primNatEquality (x:BigInt, y:BigInt) -> Bool =- foreign Int "eqBig" (x:BigInt, y:BigInt)--primNatLess (x:BigInt, y:BigInt) -> Bool =- foreign Int "ltBig" (x:BigInt, y:BigInt)----- Bools--%inline primTrue () -> Bool = true--%inline primFalse () -> Bool = false---- Chars--printChar (x:Int) -> Unit =- foreign Unit "printCharRep" (x:Int)--%inline primCharEquality (c1 : Int, c2 : Int) -> Bool = c1 == c2--primCharToNat (c : Int) -> BigInt = foreign BigInt "NEWBIGINTVALI" (c : Int)----- Floats-floatToStr (x : Float) -> String =- foreign String "floatToStr" (x : Float)--strToFloat (s : String) -> Float =- foreign Float "strToFloat" (s : String)---- Coinduction--primSharp (u1 : Any, u2 : Any, x : Any) -> Data = Con 0 (x)---- RUNTIME--init () -> Unit =- foreign Unit "init" ()- --- Levels--primLevelMax (x : Any, y : Any) -> Any = 0L -- error "primLevelMax"-primLevelZero () -> Any = 0L -- error "primLevelZero"-primLevelSuc (x : Any) -> Any = primSuc(x) -- error "primLevelSuc"---- TrustMe--primTrustMe (a : Unit, x : Any, y : Any) -> Any = Con 0 ()
@@ -1,95 +0,0 @@-#include "stdagda.h"-#include <stdlib.h>-#include <unistd.h>-#include <gmp.h>-#include <string.h>-#include <sys/time.h>-#include <locale.h>-//#include "closure.h"---#define _UNICODE-#define UNICODE--void wputStr(char* s) { wprintf(L"%s",s); }--int eqString(char *x, char *y) {- return strcmp(x, y) == 0;-}--VAL bigZeroRep;-VAL bigOneRep;--VAL bigZero() { return bigZeroRep;}-VAL bigOne() {return bigOneRep;}--void init(void) {- setlocale(LC_CTYPE, "");-- bigZeroRep = NEWBIGINTVALI(0);- bigOneRep = NEWBIGINTVALI(1);-}--void printCharRep(int c) {-- wprintf(L"%lc", c);-}--int bigToInt(VAL n) {- return (int) mpz_get_si(*(GETBIGINT(n)));-}--VAL intToBig(int n) {- return NEWBIGINTVALI(n);-} --VAL getArgBig(VAL num) {- return evm_getArg(bigToInt(num));-}--VAL numArgsBig(void) { - return NEWBIGINTVALI(epic_numArgs());-}--char* charToStr(int x)-{- char* buf = EMALLOC(2*sizeof(char));- buf[0] = (char)x; buf[1] = '\0';- return buf;-}--int eof() { return EOF; }--int charAtBig(char* str, VAL n)-{- return (int)str[bigToInt(n)];-}--int charAt(char* str, int n) { return (int)str[n]; }--#define STRING_BUFFER_SIZE 1024--int eofstdin() { return feof(stdin);}--char* readStrChunk() { return freadStrChunk(stdin); }--char* freadStrChunk(FILE* f) {- char* in = EMALLOC(sizeof(char)*STRING_BUFFER_SIZE);- fgets(in,STRING_BUFFER_SIZE,f);- return in;-}--void** newArray(VAL size)-{- return EMALLOC(sizeof(void*)*bigToInt(size));-}--void* arrayIndex(void** array, VAL i)-{- return array[bigToInt(i)];-}--void setArrayIndex(void** array, VAL i, void* val)-{- array[bigToInt(i)] = val;-}
@@ -1,41 +0,0 @@-#ifndef _STDAGDA_H-#define _STDAGDA_H--# ifndef WIN32-# include <pthread.h>-# define GC_THREADS-# else-# define GC_WIN32_THREADS-# endif--#include <gc/gc.h>-#include <gmp.h>-#include <stdio.h>-#include "stdfuns.h"-void init(void);-int eqString(char *x, char *y);-void printCharRep(int c);--void wputStr(char* s);--int bigToInt(VAL n);-VAL intToBig(int n);--VAL getArgBig(VAL num);--VAL numArgsBig(void);--FILE* getStdin (void);-FILE* getStdout(void);---char* charToStr(int x);-int charAt(char* str, int n);-int charAtBig(char* str, VAL n);--int eof();--char* freadStrChunk(FILE* f);-// void* freadStrChunk(void* h);--#endif
@@ -0,0 +1,377 @@+define([], function() {+var exports = {};+// Contains *most* of the primitives required by the JavaScript backend.+// (Some, e.g., those using Agda types like Maybe, are defined in their+// respective builtin modules.)+//+// Primitives prefixed by 'u' are uncurried variants, which are sometimes+// emitted by the JavaScript backend. Whenever possible, the curried primitives+// should be implemented in terms of the uncurried ones.+//+// Primitives prefixed by '_' are internal variants, usually for those primitives+// which return Agda types like Maybe. These are never emitted by the compiler,+// but can be used internally to define other prefixes.++// Integers++// primIntegerFromString : String -> Int+exports.primIntegerFromString = BigInt;++// primShowInteger : Int -> String+exports.primShowInteger = x => x.toString();++// uprimIntegerPlus : (Int, Int) -> Int+exports.uprimIntegerPlus = (x, y) => x + y;++// uprimIntegerMinus : (Int, Int) -> Int+exports.uprimIntegerMinus = (x, y) => x - y;++// uprimIntegerMultiply : (Int, Int) -> Int+exports.uprimIntegerMultiply = (x, y) => x * y;++// uprimIntegerRem : (Int, Int) -> Int+exports.uprimIntegerRem = (x, y) => x % y;++// uprimIntegerQuot : (Int, Int) -> Int+exports.uprimIntegerQuot = (x, y) => x / y;++// uprimIntegerEqual : (Int, Int) -> Bool+exports.uprimIntegerEqual = (x, y) => x === y;++// uprimIntegerGreaterOrEqualThan : (Int, Int) -> Bool+exports.uprimIntegerGreaterOrEqualThan = (x, y) => x >= y;++// uprimIntegerLessThan : (Int, Int) -> Bool+exports.uprimIntegerLessThan = (x, y) => x < y;++// Words+const WORD64_MAX_VALUE = 18446744073709552000n;++// primWord64ToNat : Word64 -> Nat+exports.primWord64ToNat = x => x;++// primWord64FromNat : Nat -> Word64+exports.primWord64FromNat = x => x % WORD64_MAX_VALUE;++// uprimWord64Plus : (Word64, Word64) -> Word64+exports.uprimWord64Plus = (x, y) => (x + y) % WORD64_MAX_VALUE;++// uprimWord64Minus : (Word64, Word64) -> Word64+exports.uprimWord64Minus = (x, y) => (x + WORD64_MAX_VALUE - y) % WORD64_MAX_VALUE;++// uprimWord64Multiply : (Word64, Word64) -> Word64+exports.uprimWord64Multiply = (x, y) => (x * y) % WORD64_MAX_VALUE;++// Natural numbers++// primNatMinus : Nat -> Nat -> Nat+exports.primNatMinus = x => y => {+ const z = x - y;+ return z < 0n ? 0n : z;+};++// Floating-point numbers+var _primFloatGreatestCommonFactor = function(x, y) {+ var z;+ x = Math.abs(x);+ y = Math.abs(y);+ while (y) {+ z = x % y;+ x = y;+ y = z;+ }+ return x;+};+exports._primFloatRound = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.round(x));+ }+};+exports._primFloatFloor = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.floor(x));+ }+};+exports._primFloatCeiling = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.ceil(x));+ }+};+exports._primFloatToRatio = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return {numerator: BigInt(0), denominator: BigInt(0)};+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return {numerator: BigInt(-1), denominator: BigInt(0)};+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return {numerator: BigInt(1), denominator: BigInt(0)};+ }+ else if (exports.primFloatIsNegativeZero(x)) {+ return {numerator: BigInt(0), denominator: BigInt(1)};+ }+ else if (x == 0.0) {+ return {numerator: BigInt(0), denominator: BigInt(1)};+ }+ else {+ var numerator = Math.round(x*1e9);+ var denominator = 1e9;+ var gcf = _primFloatGreatestCommonFactor(numerator, denominator);+ numerator /= gcf;+ denominator /= gcf;+ return {numerator: BigInt(numerator), denominator: BigInt(denominator)};+ }+};+exports._primFloatDecode = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return null;+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return null;+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ var mantissa = x, exponent = 0;+ while (!Number.isInteger(mantissa)) {+ mantissa *= 2.0;+ exponent -= 1;+ };+ while (mantissa % 2.0 === 0 && mantissa !== 0) {+ mantissa /= 2.0;+ exponent += 1;+ }+ return {mantissa: BigInt(mantissa), exponent: BigInt(exponent)};+ }+};+exports.uprimFloatEquality = function(x, y) {+ return x === y;+};+exports.primFloatEquality = function(x) {+ return function(y) {+ return exports.uprimFloatEquality(x, y);+ };+};+exports.primFloatInequality = function(x) {+ return function(y) {+ return x <= y;+ };+};+exports.primFloatLess = function(x) {+ return function(y) {+ return x < y;+ };+};+exports.primFloatIsInfinite = function(x) {+ return !Number.isNaN(x) && !Number.isFinite(x);+};+exports.primFloatIsNaN = function(x) {+ return Number.isNaN(x);+};+exports.primFloatIsNegativeZero = function(x) {+ return Object.is(x,-0.0);+};+exports.primFloatIsSafeInteger = function(x) {+ return Number.isSafeInteger(x);+};+++// These WORD64 values were obtained via `castDoubleToWord64` in Haskell:+const WORD64_NAN = 18444492273895866368n;+const WORD64_POS_INF = 9218868437227405312n;+const WORD64_NEG_INF = 18442240474082181120n;+const WORD64_POS_ZERO = 0n;+const WORD64_NEG_ZERO = 9223372036854775808n;++exports.primFloatToWord64 = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return WORD64_NAN;+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return WORD64_NEG_INF;+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return WORD64_POS_INF;+ }+ else if (exports.primFloatIsNegativeZero(x)) {+ return WORD64_NEG_ZERO;+ }+ else if (x == 0.0) {+ return WORD64_POS_ZERO;+ }+ else {+ var mantissa, exponent;+ ({mantissa, exponent} = exports._primFloatDecode(x));+ var sign = Math.sign(mantissa);+ console.log(mantissa);+ mantissa *= sign;+ sign = (sign === -1 ? "1" : "0");+ mantissa = (mantissa.toString(2)).padStart(11, "0");+ exponent = (mantissa.toString(2)).padStart(52, "0");+ return BigInt(parseInt(sign + mantissa + exponent, 2));+ }+};++// primNatToFloat : Nat -> Float+exports.primNatToFloat = Number;++// primIntToFloat : Int -> Float+exports.primIntToFloat = Number;++// primRatioToFloat : Int -> Int -> Float+exports.primRatioToFloat = x => y => Number(x) / Number(y);++// uprimFloatEncode : (Int, Int) -> Maybe Float+exports.uprimFloatEncode = (x, y) => {+ const mantissa = Number(x);+ const exponent = Number(y);++ if (Number.isSafeInteger(mantissa) && -1024 <= exponent && exponent <= 1024) {+ return mantissa * (2 ** exponent);+ }++ else {+ return null;+ }+};++exports.primShowFloat = function(x) {+ // See Issue #2192.+ if (Number.isInteger(x)) {+ if (exports.primFloatIsNegativeZero(x)) {+ return ("-0.0");+ } else {+ return (x.toString() + ".0");+ }+ } else {+ return x.toString();+ }+};+exports.primFloatPlus = function(x) {+ return function(y) {+ return x + y;+ };+};+exports.primFloatMinus = function(x) {+ return function(y) {+ return x - y;+ };+};+exports.primFloatTimes = function(x) {+ return function(y) {+ return x * y;+ };+};+exports.primFloatNegate = function(x) {+ return -x;+};+exports.primFloatDiv = function(x) {+ return function(y) {+ return x / y;+ };+};+exports.primFloatPow = function(x) {+ return function(y) {+ return x ** y;+ };+};+exports.primFloatSqrt = function(x) {+ return Math.sqrt(x);+};+exports.primFloatExp = function(x) {+ return Math.exp(x);+};+exports.primFloatLog = function(x) {+ return Math.log(x);+};+exports.primFloatSin = function(x) {+ return Math.sin(x);+};+exports.primFloatCos = function(x) {+ return Math.cos(x);+};+exports.primFloatTan = function(x) {+ return Math.tan(x);+};+exports.primFloatASin = function(x) {+ return Math.asin(x);+};+exports.primFloatACos = function(x) {+ return Math.acos(x);+};+exports.primFloatATan = function(x) {+ return Math.atan(x);+};+exports.primFloatATan2 = function(x) {+ return function(y){+ return Math.atan2(x, y);+ };+};+exports.primFloatSinh = function(x) {+ return Math.sinh(x);+};+exports.primFloatCosh = function(x) {+ return Math.cosh(x);+};+exports.primFloatTanh = function(x) {+ return Math.tanh(x);+};+exports.primFloatASinh = function(x) {+ return Math.asinh(x);+};+exports.primFloatACosh = function(x) {+ return Math.acosh(x);+};+exports.primFloatATanh = function(x) {+ return Math.atanh(x);+};++// Cubical primitives.+exports.primIMin = x => y => x && y;+exports.primIMax = x => y => x || y;+exports.primINeg = x => !x;+exports.primPartial = _ => _ => x => x;+exports.primPartialP = _ => _ => x => x;+exports.primPOr = _ => i => _ => _ => x => y => i ? x : y;+exports.primComp = _ => _ => _ => _ => x => x;+exports.primTransp = _ => _ => _ => x => x;+exports.primHComp = _ => _ => _ => _ => x => x;+exports.primSubOut = _ => _ => _ => _ => x => x;+exports.prim_glueU = _ => _ => _ => _ => _ => x => x;+exports.prim_unglueU = _ => _ => _ => _ => x => x;+exports.primFaceForall = f => f(true) == true && f(false) == false;++// Quotients.+exports.qrec = _ => _ => _ => _ => _ => _ => f => _ => _ => x => f(x);++// Other stuff++// primSeq : (X, Y) -> Y+exports.primSeq = (x, y) => y;++// uprimQNameEquality : (Name, Name) -> Bool+exports.uprimQNameEquality = (x, y) => x['id'] === y['id'] && x['moduleId'] === y['moduleId'];++// primQNameEquality : Name -> Name -> Bool+exports.primQNameEquality = x => y => exports.uprimQNameEquality(x, y);++// primQNameLess : Name -> Name -> Bool+exports.primQNameLess = x => y => x['id'] === y['id'] ? x['moduleId'] < y['moduleId'] : x['id'] < y['id'];++// primShowQName : Name -> String+exports.primShowQName = x => x['name'];++// primQNameFixity : Name -> Fixity+exports.primQNameFixity = x => x['fixity'];+return exports;+});
@@ -0,0 +1,389 @@+// Contains *most* of the primitives required by the JavaScript backend.+// (Some, e.g., those using Agda types like Maybe, are defined in their+// respective builtin modules.)+//+// Primitives prefixed by 'u' are uncurried variants, which are sometimes+// emitted by the JavaScript backend. Whenever possible, the curried primitives+// should be implemented in terms of the uncurried ones.+//+// Primitives prefixed by '_' are internal variants, usually for those primitives+// which return Agda types like Maybe. These are never emitted by the compiler,+// but can be used internally to define other prefixes.++// Integers++// primIntegerFromString : String -> Int+exports.primIntegerFromString = BigInt;++// primShowInteger : Int -> String+exports.primShowInteger = x => x.toString();++// uprimIntegerPlus : (Int, Int) -> Int+exports.uprimIntegerPlus = (x, y) => x + y;++// uprimIntegerMinus : (Int, Int) -> Int+exports.uprimIntegerMinus = (x, y) => x - y;++// uprimIntegerMultiply : (Int, Int) -> Int+exports.uprimIntegerMultiply = (x, y) => x * y;++// uprimIntegerRem : (Int, Int) -> Int+exports.uprimIntegerRem = (x, y) => x % y;++// uprimIntegerQuot : (Int, Int) -> Int+exports.uprimIntegerQuot = (x, y) => x / y;++// uprimIntegerEqual : (Int, Int) -> Bool+exports.uprimIntegerEqual = (x, y) => x === y;++// uprimIntegerGreaterOrEqualThan : (Int, Int) -> Bool+exports.uprimIntegerGreaterOrEqualThan = (x, y) => x >= y;++// uprimIntegerLessThan : (Int, Int) -> Bool+exports.uprimIntegerLessThan = (x, y) => x < y;++// Words+const WORD64_MAX_VALUE = 18446744073709552000n;++// primWord64ToNat : Word64 -> Nat+exports.primWord64ToNat = x => x;++// primWord64FromNat : Nat -> Word64+exports.primWord64FromNat = x => x % WORD64_MAX_VALUE;++// uprimWord64Plus : (Word64, Word64) -> Word64+exports.uprimWord64Plus = (x, y) => (x + y) % WORD64_MAX_VALUE;++// uprimWord64Minus : (Word64, Word64) -> Word64+exports.uprimWord64Minus = (x, y) => (x + WORD64_MAX_VALUE - y) % WORD64_MAX_VALUE;++// uprimWord64Multiply : (Word64, Word64) -> Word64+exports.uprimWord64Multiply = (x, y) => (x * y) % WORD64_MAX_VALUE;++// Natural numbers++// primNatMinus : Nat -> Nat -> Nat+exports.primNatMinus = x => y => {+ const z = x - y;+ return z < 0n ? 0n : z;+};++// Floating-point numbers+var _primFloatGreatestCommonFactor = function(x, y) {+ var z;+ x = Math.abs(x);+ y = Math.abs(y);+ while (y) {+ z = x % y;+ x = y;+ y = z;+ }+ return x;+};+exports._primFloatRound = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.round(x));+ }+};+exports._primFloatFloor = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.floor(x));+ }+};+exports._primFloatCeiling = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.ceil(x));+ }+};+exports._primFloatToRatio = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return {numerator: BigInt(0), denominator: BigInt(0)};+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return {numerator: BigInt(-1), denominator: BigInt(0)};+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return {numerator: BigInt(1), denominator: BigInt(0)};+ }+ else if (exports.primFloatIsNegativeZero(x)) {+ return {numerator: BigInt(0), denominator: BigInt(1)};+ }+ else if (x == 0.0) {+ return {numerator: BigInt(0), denominator: BigInt(1)};+ }+ else {+ var numerator = Math.round(x*1e9);+ var denominator = 1e9;+ var gcf = _primFloatGreatestCommonFactor(numerator, denominator);+ numerator /= gcf;+ denominator /= gcf;+ return {numerator: BigInt(numerator), denominator: BigInt(denominator)};+ }+};+exports._primFloatDecode = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return null;+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return null;+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ var mantissa = x, exponent = 0;+ while (!Number.isInteger(mantissa)) {+ mantissa *= 2.0;+ exponent -= 1;+ };+ while (mantissa % 2.0 === 0 && mantissa !== 0) {+ mantissa /= 2.0;+ exponent += 1;+ }+ return {mantissa: BigInt(mantissa), exponent: BigInt(exponent)};+ }+};+exports.uprimFloatEquality = function(x, y) {+ return x === y;+};+exports.primFloatEquality = function(x) {+ return function(y) {+ return exports.uprimFloatEquality(x, y);+ };+};+exports.primFloatInequality = function(x) {+ return function(y) {+ return x <= y;+ };+};+exports.primFloatLess = function(x) {+ return function(y) {+ return x < y;+ };+};+exports.primFloatIsInfinite = function(x) {+ return !Number.isNaN(x) && !Number.isFinite(x);+};+exports.primFloatIsNaN = function(x) {+ return Number.isNaN(x);+};+exports.primFloatIsNegativeZero = function(x) {+ return Object.is(x,-0.0);+};+exports.primFloatIsSafeInteger = function(x) {+ return Number.isSafeInteger(x);+};+++// These WORD64 values were obtained via `castDoubleToWord64` in Haskell:+const WORD64_POS_INF = 9218868437227405312n;+const WORD64_NEG_INF = 18442240474082181120n;+const WORD64_POS_ZERO = 0n;+const WORD64_NEG_ZERO = 9223372036854775808n;++exports.primFloatToWord64 = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return null;+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return WORD64_NEG_INF;+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return WORD64_POS_INF;+ }+ else if (exports.primFloatIsNegativeZero(x)) {+ return WORD64_NEG_ZERO;+ }+ else if (x == 0.0) {+ return WORD64_POS_ZERO;+ }+ else {+ var mantissa, exponent;+ ({mantissa, exponent} = exports._primFloatDecode(x));+ var sign = Math.sign(mantissa);+ console.log(mantissa);+ mantissa *= sign;+ sign = (sign === -1 ? "1" : "0");+ mantissa = (mantissa.toString(2)).padStart(11, "0");+ exponent = (mantissa.toString(2)).padStart(52, "0");+ return BigInt(parseInt(sign + mantissa + exponent, 2));+ }+};++// primNatToFloat : Nat -> Float+exports.primNatToFloat = Number;++// primIntToFloat : Int -> Float+exports.primIntToFloat = Number;++// primRatioToFloat : Int -> Int -> Float+exports.primRatioToFloat = x => y => Number(x) / Number(y);++// uprimFloatEncode : (Int, Int) -> Maybe Float+exports.uprimFloatEncode = (x, y) => {+ const mantissa = Number(x);+ const exponent = Number(y);++ if (Number.isSafeInteger(mantissa) && -1024 <= exponent && exponent <= 1024) {+ return mantissa * (2 ** exponent);+ }++ else {+ return null;+ }+};++exports.primShowFloat = function(x) {+ // See Issue #2192.+ if (Number.isInteger(x)) {+ if (exports.primFloatIsNegativeZero(x)) {+ return ("-0.0");+ } else {+ return (x.toString() + ".0");+ }+ } else {+ return x.toString();+ }+};+exports.primFloatPlus = function(x) {+ return function(y) {+ return x + y;+ };+};+exports.primFloatMinus = function(x) {+ return function(y) {+ return x - y;+ };+};+exports.primFloatTimes = function(x) {+ return function(y) {+ return x * y;+ };+};+exports.primFloatNegate = function(x) {+ return -x;+};+exports.primFloatDiv = function(x) {+ return function(y) {+ return x / y;+ };+};+exports.primFloatPow = function(x) {+ return function(y) {+ return x ** y;+ };+};+exports.primFloatSqrt = function(x) {+ return Math.sqrt(x);+};+exports.primFloatExp = function(x) {+ return Math.exp(x);+};+exports.primFloatLog = function(x) {+ return Math.log(x);+};+exports.primFloatSin = function(x) {+ return Math.sin(x);+};+exports.primFloatCos = function(x) {+ return Math.cos(x);+};+exports.primFloatTan = function(x) {+ return Math.tan(x);+};+exports.primFloatASin = function(x) {+ return Math.asin(x);+};+exports.primFloatACos = function(x) {+ return Math.acos(x);+};+exports.primFloatATan = function(x) {+ return Math.atan(x);+};+exports.primFloatATan2 = function(x) {+ return function(y){+ return Math.atan2(x, y);+ };+};+exports.primFloatSinh = function(x) {+ return Math.sinh(x);+};+exports.primFloatCosh = function(x) {+ return Math.cosh(x);+};+exports.primFloatTanh = function(x) {+ return Math.tanh(x);+};+exports.primFloatASinh = function(x) {+ return Math.asinh(x);+};+exports.primFloatACosh = function(x) {+ return Math.acosh(x);+};+exports.primFloatATanh = function(x) {+ return Math.atanh(x);+};++// Cubical primitives.+exports.primIMin = x => y => x && y;+exports.primIMax = x => y => x || y;+exports.primINeg = x => !x;+exports.primPartial = _ => _ => x => x;+exports.primPartialP = _ => _ => x => x;+exports.primPOr = _ => i => _ => _ => x => y => i ? x : y;+exports.primComp = _ => _ => _ => _ => x => x;+exports.primTransp = _ => _ => _ => x => x;+exports.primHComp = _ => _ => _ => _ => x => x;+exports.primSubOut = _ => _ => _ => _ => x => x;+exports.prim_glueU = _ => _ => _ => _ => _ => x => x;+exports.prim_unglueU = _ => _ => _ => _ => x => x;+exports.primFaceForall = f => f(true) == true && f(false) == false;++// Quotients.+exports.qrec = _ => _ => _ => _ => _ => _ => f => _ => _ => x => f(x);++// Other stuff++// primSeq : (X, Y) -> Y+exports.primSeq = (x, y) => y;++// uprimQNameEquality : (Name, Name) -> Bool+exports.uprimQNameEquality = (x, y) => x['id'] === y['id'] && x['moduleId'] === y['moduleId'];++// primQNameEquality : Name -> Name -> Bool+exports.primQNameEquality = x => y => exports.uprimQNameEquality(x, y);++// primQNameLess : Name -> Name -> Bool+exports.primQNameLess = x => y => x['id'] === y['id'] ? x['moduleId'] < y['moduleId'] : x['id'] < y['id'];++// primShowQName : Name -> String+exports.primShowQName = x => x['name'];++// primQNameFixity : Name -> Fixity+exports.primQNameFixity = x => x['fixity'];++// Meta++// primShowMeta : Meta -> String+// Should be kept in sync with version in `primitiveFunctions` in+// Agda.TypeChecking.Primitive+exports.primShowMeta = x => "_" + x['id'] + "@" + x['module'];++// primMetaToNat : Meta -> Nat+// Should be kept in sync with `metaToNat` in Agda.TypeChecking.Primitive+exports.primMetaToNat = x => x['module'] * 2^64 + x['id'];++// primMetaEquality : Meta -> Meta -> Bool+exports.primMetaEquality = x => y => x['id'] === y['id'] && x['module'] === y['module'];++// primMetaLess : Meta -> Meta -> Bool+exports.primMetaLess = x => y => x['id'] === y['id'] ? x['module'] < y['module'] : x['id'] < y['id'];
@@ -0,0 +1,393 @@+// Contains *most* of the primitives required by the JavaScript backend.+// (Some, e.g., those using Agda types like Maybe, are defined in their+// respective builtin modules.)+//+// Primitives prefixed by 'u' are uncurried variants, which are sometimes+// emitted by the JavaScript backend. Whenever possible, the curried primitives+// should be implemented in terms of the uncurried ones.+//+// Primitives prefixed by '_' are internal variants, usually for those primitives+// which return Agda types like Maybe. These are never emitted by the compiler,+// but can be used internally to define other prefixes.++const exports = {};++// Integers++// primIntegerFromString : String -> Int+exports.primIntegerFromString = BigInt;++// primShowInteger : Int -> String+exports.primShowInteger = x => x.toString();++// uprimIntegerPlus : (Int, Int) -> Int+exports.uprimIntegerPlus = (x, y) => x + y;++// uprimIntegerMinus : (Int, Int) -> Int+exports.uprimIntegerMinus = (x, y) => x - y;++// uprimIntegerMultiply : (Int, Int) -> Int+exports.uprimIntegerMultiply = (x, y) => x * y;++// uprimIntegerRem : (Int, Int) -> Int+exports.uprimIntegerRem = (x, y) => x % y;++// uprimIntegerQuot : (Int, Int) -> Int+exports.uprimIntegerQuot = (x, y) => x / y;++// uprimIntegerEqual : (Int, Int) -> Bool+exports.uprimIntegerEqual = (x, y) => x === y;++// uprimIntegerGreaterOrEqualThan : (Int, Int) -> Bool+exports.uprimIntegerGreaterOrEqualThan = (x, y) => x >= y;++// uprimIntegerLessThan : (Int, Int) -> Bool+exports.uprimIntegerLessThan = (x, y) => x < y;++// Words+const WORD64_MAX_VALUE = 18446744073709552000n;++// primWord64ToNat : Word64 -> Nat+exports.primWord64ToNat = x => x;++// primWord64FromNat : Nat -> Word64+exports.primWord64FromNat = x => x % WORD64_MAX_VALUE;++// uprimWord64Plus : (Word64, Word64) -> Word64+exports.uprimWord64Plus = (x, y) => (x + y) % WORD64_MAX_VALUE;++// uprimWord64Minus : (Word64, Word64) -> Word64+exports.uprimWord64Minus = (x, y) => (x + WORD64_MAX_VALUE - y) % WORD64_MAX_VALUE;++// uprimWord64Multiply : (Word64, Word64) -> Word64+exports.uprimWord64Multiply = (x, y) => (x * y) % WORD64_MAX_VALUE;++// Natural numbers++// primNatMinus : Nat -> Nat -> Nat+exports.primNatMinus = x => y => {+ const z = x - y;+ return z < 0n ? 0n : z;+};++// Floating-point numbers+var _primFloatGreatestCommonFactor = function(x, y) {+ var z;+ x = Math.abs(x);+ y = Math.abs(y);+ while (y) {+ z = x % y;+ x = y;+ y = z;+ }+ return x;+};+exports._primFloatRound = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.round(x));+ }+};+exports._primFloatFloor = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.floor(x));+ }+};+exports._primFloatCeiling = function(x) {+ if (exports.primFloatIsNaN(x) || exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ return BigInt(Math.ceil(x));+ }+};+exports._primFloatToRatio = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return {numerator: BigInt(0), denominator: BigInt(0)};+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return {numerator: BigInt(-1), denominator: BigInt(0)};+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return {numerator: BigInt(1), denominator: BigInt(0)};+ }+ else if (exports.primFloatIsNegativeZero(x)) {+ return {numerator: BigInt(0), denominator: BigInt(1)};+ }+ else if (x == 0.0) {+ return {numerator: BigInt(0), denominator: BigInt(1)};+ }+ else {+ var numerator = Math.round(x*1e9);+ var denominator = 1e9;+ var gcf = _primFloatGreatestCommonFactor(numerator, denominator);+ numerator /= gcf;+ denominator /= gcf;+ return {numerator: BigInt(numerator), denominator: BigInt(denominator)};+ }+};+exports._primFloatDecode = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return null;+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return null;+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return null;+ }+ else {+ var mantissa = x, exponent = 0;+ while (!Number.isInteger(mantissa)) {+ mantissa *= 2.0;+ exponent -= 1;+ };+ while (mantissa % 2.0 === 0 && mantissa !== 0) {+ mantissa /= 2.0;+ exponent += 1;+ }+ return {mantissa: BigInt(mantissa), exponent: BigInt(exponent)};+ }+};+exports.uprimFloatEquality = function(x, y) {+ return x === y;+};+exports.primFloatEquality = function(x) {+ return function(y) {+ return exports.uprimFloatEquality(x, y);+ };+};+exports.primFloatInequality = function(x) {+ return function(y) {+ return x <= y;+ };+};+exports.primFloatLess = function(x) {+ return function(y) {+ return x < y;+ };+};+exports.primFloatIsInfinite = function(x) {+ return !Number.isNaN(x) && !Number.isFinite(x);+};+exports.primFloatIsNaN = function(x) {+ return Number.isNaN(x);+};+exports.primFloatIsNegativeZero = function(x) {+ return Object.is(x,-0.0);+};+exports.primFloatIsSafeInteger = function(x) {+ return Number.isSafeInteger(x);+};+++// These WORD64 values were obtained via `castDoubleToWord64` in Haskell:+const WORD64_POS_INF = 9218868437227405312n;+const WORD64_NEG_INF = 18442240474082181120n;+const WORD64_POS_ZERO = 0n;+const WORD64_NEG_ZERO = 9223372036854775808n;++exports.primFloatToWord64 = function(x) {+ if (exports.primFloatIsNaN(x)) {+ return null;+ }+ else if (x < 0.0 && exports.primFloatIsInfinite(x)) {+ return WORD64_NEG_INF;+ }+ else if (x > 0.0 && exports.primFloatIsInfinite(x)) {+ return WORD64_POS_INF;+ }+ else if (exports.primFloatIsNegativeZero(x)) {+ return WORD64_NEG_ZERO;+ }+ else if (x == 0.0) {+ return WORD64_POS_ZERO;+ }+ else {+ var mantissa, exponent;+ ({mantissa, exponent} = exports._primFloatDecode(x));+ var sign = Math.sign(mantissa);+ console.log(mantissa);+ mantissa *= sign;+ sign = (sign === -1 ? "1" : "0");+ mantissa = (mantissa.toString(2)).padStart(11, "0");+ exponent = (mantissa.toString(2)).padStart(52, "0");+ return BigInt(parseInt(sign + mantissa + exponent, 2));+ }+};++// primNatToFloat : Nat -> Float+exports.primNatToFloat = Number;++// primIntToFloat : Int -> Float+exports.primIntToFloat = Number;++// primRatioToFloat : Int -> Int -> Float+exports.primRatioToFloat = x => y => Number(x) / Number(y);++// uprimFloatEncode : (Int, Int) -> Maybe Float+exports.uprimFloatEncode = (x, y) => {+ const mantissa = Number(x);+ const exponent = Number(y);++ if (Number.isSafeInteger(mantissa) && -1024 <= exponent && exponent <= 1024) {+ return mantissa * (2 ** exponent);+ }++ else {+ return null;+ }+};++exports.primShowFloat = function(x) {+ // See Issue #2192.+ if (Number.isInteger(x)) {+ if (exports.primFloatIsNegativeZero(x)) {+ return ("-0.0");+ } else {+ return (x.toString() + ".0");+ }+ } else {+ return x.toString();+ }+};+exports.primFloatPlus = function(x) {+ return function(y) {+ return x + y;+ };+};+exports.primFloatMinus = function(x) {+ return function(y) {+ return x - y;+ };+};+exports.primFloatTimes = function(x) {+ return function(y) {+ return x * y;+ };+};+exports.primFloatNegate = function(x) {+ return -x;+};+exports.primFloatDiv = function(x) {+ return function(y) {+ return x / y;+ };+};+exports.primFloatPow = function(x) {+ return function(y) {+ return x ** y;+ };+};+exports.primFloatSqrt = function(x) {+ return Math.sqrt(x);+};+exports.primFloatExp = function(x) {+ return Math.exp(x);+};+exports.primFloatLog = function(x) {+ return Math.log(x);+};+exports.primFloatSin = function(x) {+ return Math.sin(x);+};+exports.primFloatCos = function(x) {+ return Math.cos(x);+};+exports.primFloatTan = function(x) {+ return Math.tan(x);+};+exports.primFloatASin = function(x) {+ return Math.asin(x);+};+exports.primFloatACos = function(x) {+ return Math.acos(x);+};+exports.primFloatATan = function(x) {+ return Math.atan(x);+};+exports.primFloatATan2 = function(x) {+ return function(y){+ return Math.atan2(x, y);+ };+};+exports.primFloatSinh = function(x) {+ return Math.sinh(x);+};+exports.primFloatCosh = function(x) {+ return Math.cosh(x);+};+exports.primFloatTanh = function(x) {+ return Math.tanh(x);+};+exports.primFloatASinh = function(x) {+ return Math.asinh(x);+};+exports.primFloatACosh = function(x) {+ return Math.acosh(x);+};+exports.primFloatATanh = function(x) {+ return Math.atanh(x);+};++// Cubical primitives.+exports.primIMin = x => y => x && y;+exports.primIMax = x => y => x || y;+exports.primINeg = x => !x;+exports.primPartial = _ => _ => x => x;+exports.primPartialP = _ => _ => x => x;+exports.primPOr = _ => i => _ => _ => x => y => i ? x : y;+exports.primComp = _ => _ => _ => _ => x => x;+exports.primTransp = _ => _ => _ => x => x;+exports.primHComp = _ => _ => _ => _ => x => x;+exports.primSubOut = _ => _ => _ => _ => x => x;+exports.prim_glueU = _ => _ => _ => _ => _ => x => x;+exports.prim_unglueU = _ => _ => _ => _ => x => x;+exports.primFaceForall = f => f(true) == true && f(false) == false;++// Quotients.+exports.qrec = _ => _ => _ => _ => _ => _ => f => _ => _ => x => f(x);++// Other stuff++// primSeq : (X, Y) -> Y+exports.primSeq = (x, y) => y;++// uprimQNameEquality : (Name, Name) -> Bool+exports.uprimQNameEquality = (x, y) => x['id'] === y['id'] && x['moduleId'] === y['moduleId'];++// primQNameEquality : Name -> Name -> Bool+exports.primQNameEquality = x => y => exports.uprimQNameEquality(x, y);++// primQNameLess : Name -> Name -> Bool+exports.primQNameLess = x => y => x['id'] === y['id'] ? x['moduleId'] < y['moduleId'] : x['id'] < y['id'];++// primShowQName : Name -> String+exports.primShowQName = x => x['name'];++// primQNameFixity : Name -> Fixity+exports.primQNameFixity = x => x['fixity'];++// Meta++// primShowMeta : Meta -> String+// Should be kept in sync with version in `primitiveFunctions` in+// Agda.TypeChecking.Primitive+exports.primShowMeta = x => "_" + x['id'] + "@" + x['module'];++// primMetaToNat : Meta -> Nat+// Should be kept in sync with `metaToNat` in Agda.TypeChecking.Primitive+exports.primMetaToNat = x => x['module'] * 2^64 + x['id'];++// primMetaEquality : Meta -> Meta -> Bool+exports.primMetaEquality = x => y => x['id'] === y['id'] && x['module'] === y['module'];++// primMetaLess : Meta -> Meta -> Bool+exports.primMetaLess = x => y => x['id'] === y['id'] ? x['module'] < y['module'] : x['id'] < y['id'];++export default exports;
@@ -0,0 +1,121 @@+{-# LANGUAGE PolyKinds #-}++module MAlonzo.RTE where++import Prelude+ ( Bool, Char, Double, Integer, String+ , Enum(..), Eq(..), Ord(..), Integral(..), Num(..)+ , ($), error, otherwise+ , (++), fromIntegral+ )++import Data.Char ( GeneralCategory(Surrogate), generalCategory )+import Data.Kind ( Type)+import qualified Data.Word+import qualified GHC.Exts as GHC ( Any )+import Unsafe.Coerce ( unsafeCoerce )++type AgdaAny = GHC.Any++-- Special version of coerce that plays well with rules.+{-# INLINE [1] coe #-}+coe :: a -> b+coe = unsafeCoerce+{-# RULES "coerce-id" forall (x :: a) . coe x = x #-}++-- Builtin QNames.+data QName = QName { nameId, moduleId :: Integer, qnameString :: String, qnameFixity :: Fixity }++data Assoc = NonAssoc | LeftAssoc | RightAssoc+data Precedence = Unrelated | Related PrecedenceLevel+data Fixity = Fixity Assoc Precedence+type PrecedenceLevel = Double++instance Eq QName where+ QName a b _ _ == QName c d _ _ = (a, b) == (c, d)++instance Ord QName where+ compare (QName a b _ _) (QName c d _ _) = compare (a, b) (c, d)++erased :: a+erased = coe (\ _ -> erased)++mazUnreachableError :: a+mazUnreachableError = error ("Agda: unreachable code reached.")++mazHole :: String -> a+mazHole s = error ("Agda: reached hole: " ++ s)++addInt :: Integer -> Integer -> Integer+addInt = (+)++subInt :: Integer -> Integer -> Integer+subInt = (-)++mulInt :: Integer -> Integer -> Integer+mulInt = (*)++geqInt :: Integer -> Integer -> Bool+geqInt = (>=)++ltInt :: Integer -> Integer -> Bool+ltInt = (<)++eqInt :: Integer -> Integer -> Bool+eqInt = (==)++quotInt :: Integer -> Integer -> Integer+quotInt = quot++remInt :: Integer -> Integer -> Integer+remInt = rem++-- #4999: Data.Text maps surrogate code points (\xD800 - \xDFFF) to the replacement character+-- \xFFFD, so to keep strings isomorphic to list of characters we do the same for characters.+natToChar :: Integer -> Char+natToChar n | generalCategory c == Surrogate = '\xFFFD'+ | otherwise = c+ where c = toEnum $ fromIntegral $ mod n 0x110000++-- Words --++type Word64 = Data.Word.Word64++word64ToNat :: Word64 -> Integer+word64ToNat = fromIntegral++word64FromNat :: Integer -> Word64+word64FromNat = fromIntegral++{-# INLINE add64 #-}+add64 :: Word64 -> Word64 -> Word64+add64 = (+)++{-# INLINE sub64 #-}+sub64 :: Word64 -> Word64 -> Word64+sub64 = (-)++{-# INLINE mul64 #-}+mul64 :: Word64 -> Word64 -> Word64+mul64 = (*)++{-# INLINE quot64 #-}+quot64 :: Word64 -> Word64 -> Word64+quot64 = quot++{-# INLINE rem64 #-}+rem64 :: Word64 -> Word64 -> Word64+rem64 = rem++{-# INLINE eq64 #-}+eq64 :: Word64 -> Word64 -> Bool+eq64 = (==)++{-# INLINE lt64 #-}+lt64 :: Word64 -> Word64 -> Bool+lt64 = (<)++-- Support for musical coinduction.++data Inf a = Sharp { flat :: a }+type Infinity (level :: Type) a = Inf a
@@ -0,0 +1,285 @@+{-# LANGUAGE CPP #-}++module MAlonzo.RTE.Float where++import Prelude+ ( Bool, Double, Int, Integer, Maybe(..), Ordering(..)+ , Eq(..), Ord(..), Functor(..)+ , Floating(..), Fractional(..), Integral(..), Num(..), Real(..), RealFloat(..), RealFrac(..)+ , ($), (.), otherwise, uncurry, undefined+ , (&&), fst, snd+ , (^), even, fromIntegral+ )++import Data.Bifunctor ( bimap, second )+import Data.Function ( on )+import Data.Maybe ( fromMaybe )+import Data.Ratio ( (%), numerator, denominator )+import Data.Word ( Word64 )++#if __GLASGOW_HASKELL__ >= 804+import GHC.Float (castDoubleToWord64, castWord64ToDouble)+#else+import System.IO.Unsafe (unsafePerformIO)+import qualified Foreign as F+import qualified Foreign.Storable as F+#endif++#if __GLASGOW_HASKELL__ < 804+castDoubleToWord64 :: Double -> Word64+castDoubleToWord64 float = unsafePerformIO $ F.alloca $ \buf -> do+ F.poke (F.castPtr buf) float+ F.peek buf++castWord64ToDouble :: Word64 -> Double+castWord64ToDouble word = unsafePerformIO $ F.alloca $ \buf -> do+ F.poke (F.castPtr buf) word+ F.peek buf+#endif++{-# INLINE doubleEq #-}+doubleEq :: Double -> Double -> Bool+doubleEq = (==)++{-# INLINE doubleLe #-}+doubleLe :: Double -> Double -> Bool+doubleLe = (<=)++{-# INLINE doubleLt #-}+doubleLt :: Double -> Double -> Bool+doubleLt = (<)++truncateDouble :: Double -> Double+truncateDouble = castWord64ToDouble . castDoubleToWord64++{-# INLINE intToDouble #-}+intToDouble :: Integral a => a -> Double+intToDouble = truncateDouble . fromIntegral++{-# INLINE doublePlus #-}+doublePlus :: Double -> Double -> Double+doublePlus x y = truncateDouble (x + y)++{-# INLINE doubleMinus #-}+doubleMinus :: Double -> Double -> Double+doubleMinus x y = truncateDouble (x - y)++{-# INLINE doubleTimes #-}+doubleTimes :: Double -> Double -> Double+doubleTimes x y = truncateDouble (x * y)++{-# INLINE doubleNegate #-}+doubleNegate :: Double -> Double+doubleNegate = negate -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleDiv #-}+doubleDiv :: Double -> Double -> Double+doubleDiv = (/) -- NOTE: doesn't cause underflow/overflow++{-# INLINE doublePow #-}+doublePow :: Double -> Double -> Double+doublePow x y = truncateDouble (x ** y)++{-# INLINE doubleSqrt #-}+doubleSqrt :: Double -> Double+doubleSqrt = sqrt -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleExp #-}+doubleExp :: Double -> Double+doubleExp x = truncateDouble (exp x)++{-# INLINE doubleLog #-}+doubleLog :: Double -> Double+doubleLog = log -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleSin #-}+doubleSin :: Double -> Double+doubleSin = sin -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleCos #-}+doubleCos :: Double -> Double+doubleCos = cos -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleTan #-}+doubleTan :: Double -> Double+doubleTan = tan -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleASin #-}+doubleASin :: Double -> Double+doubleASin = asin -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleACos #-}+doubleACos :: Double -> Double+doubleACos = acos -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleATan #-}+doubleATan :: Double -> Double+doubleATan = atan -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleATan2 #-}+doubleATan2 :: Double -> Double -> Double+doubleATan2 = atan2 -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleSinh #-}+doubleSinh :: Double -> Double+doubleSinh = sinh -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleCosh #-}+doubleCosh :: Double -> Double+doubleCosh = cosh -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleTanh #-}+doubleTanh :: Double -> Double+doubleTanh = tanh -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleASinh #-}+doubleASinh :: Double -> Double+doubleASinh = asinh -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleACosh #-}+doubleACosh :: Double -> Double+doubleACosh = acosh -- NOTE: doesn't cause underflow/overflow++{-# INLINE doubleATanh #-}+doubleATanh :: Double -> Double+doubleATanh = atanh -- NOTE: doesn't cause underflow/overflow++{-# INLINE negativeZero #-}+negativeZero :: Double+negativeZero = -0.0++positiveInfinity :: Double+positiveInfinity = 1.0 / 0.0++negativeInfinity :: Double+negativeInfinity = -positiveInfinity++nan :: Double+nan = 0.0 / 0.0++isPosInf :: Double -> Bool+isPosInf x = x > 0.0 && isInfinite x++isNegInf :: Double -> Bool+isNegInf x = x < 0.0 && isInfinite x++isPosZero :: Double -> Bool+isPosZero x = doubleDenotEq x 0.0++isNegZero :: Double -> Bool+isNegZero x = doubleDenotEq x (-0.0)++doubleRound :: Double -> Maybe Integer+doubleRound = fmap round . asFinite++doubleFloor :: Double -> Maybe Integer+doubleFloor = fmap floor . asFinite++doubleCeiling :: Double -> Maybe Integer+doubleCeiling = fmap ceiling . asFinite++normaliseNaN :: Double -> Double+normaliseNaN x+ | isNaN x = nan+ | otherwise = x++doubleToWord64 :: Double -> Maybe Word64+doubleToWord64 x+ | isNaN x = Nothing+ | otherwise = Just (castDoubleToWord64 x)++-- |Denotational equality for floating point numbers, checks bitwise equality.+--+-- NOTE: Denotational equality distinguishes NaNs, so its results may vary+-- depending on the architecture and compilation flags. Unfortunately,+-- this is a problem with floating-point numbers in general.+--+doubleDenotEq :: Double -> Double -> Bool+doubleDenotEq = (==) `on` doubleToWord64++-- |I guess "denotational orderings" are now a thing? The point is that we need+-- an Ord instance which provides a total ordering, and is consistent with the+-- denotational equality.+--+-- NOTE: The ordering induced via `doubleToWord64` is total, and is consistent+-- with `doubleDenotEq`. However, it is *deeply* unintuitive. For one, it+-- considers all negative numbers to be larger than positive numbers.+--+doubleDenotOrd :: Double -> Double -> Ordering+doubleDenotOrd = compare `on` doubleToWord64++-- |Return Just x if it's a finite number, otherwise return Nothing.+asFinite :: Double -> Maybe Double+asFinite x+ | isNaN x = Nothing+ | isInfinite x = Nothing+ | otherwise = Just x++-- |Decode a Double to an integer ratio.+doubleToRatio :: Double -> (Integer, Integer)+doubleToRatio x+ | isNaN x = (0, 0)+ | isInfinite x = (signum (floor x), 0)+ | otherwise = let r = toRational x in (numerator r, denominator r)++-- |Encode an integer ratio as a double.+ratioToDouble :: Integer -> Integer -> Double+ratioToDouble n d+ | d == 0 = case compare n 0 of+ LT -> negativeInfinity+ EQ -> nan+ GT -> positiveInfinity+ | otherwise = fromRational (n % d)++-- |Decode a Double to its mantissa and its exponent, normalised such that the+-- mantissa is the smallest possible number without loss of accuracy.+doubleDecode :: Double -> Maybe (Integer, Integer)+doubleDecode x+ | isNaN x = Nothing+ | isInfinite x = Nothing+ | otherwise = Just (uncurry normalise (second toInteger (decodeFloat x)))+ where+ normalise :: Integer -> Integer -> (Integer, Integer)+ normalise mantissa exponent+ | even mantissa, mantissa /= 0 = normalise (mantissa `div` 2) (exponent + 1)+ | otherwise = (mantissa, exponent)++-- |Checks whether or not the Double is within a safe range of operation.+isSafeInteger :: Double -> Bool+isSafeInteger x = case properFraction x of+ (n, f) -> f == 0.0 && minMantissa <= n && n <= maxMantissa++doubleRadix :: Integer+doubleRadix = floatRadix (undefined :: Double)++doubleDigits :: Int+doubleDigits = floatDigits (undefined :: Double)++doubleRange :: (Int, Int)+doubleRange = floatRange (undefined :: Double)++-- |The smallest representable mantissa. Simultaneously, the smallest integer which can be+-- represented as a Double without loss of precision.+minMantissa :: Integer+minMantissa = - maxMantissa++-- |The largest representable mantissa. Simultaneously, the largest integer which can be+-- represented as a Double without loss of precision.+maxMantissa :: Integer+maxMantissa = (doubleRadix ^ toInteger doubleDigits) - 1++-- |The largest representable exponent.+minExponent :: Integer+minExponent = toInteger $ (fst doubleRange - doubleDigits) - 1++-- |The smallest representable exponent.+maxExponent :: Integer+maxExponent = toInteger $ snd doubleRange - doubleDigits++-- |Encode a mantissa and an exponent as a Double.+doubleEncode :: Integer -> Integer -> Maybe Double+doubleEncode mantissa exponent+ = if minMantissa <= mantissa && mantissa <= maxMantissa &&+ minExponent <= exponent && exponent <= maxExponent+ then Just (encodeFloat mantissa (fromInteger exponent))+ else Nothing
@@ -1,775 +1,1596 @@-;;; agda-input.el --- The Agda input method--;;; Commentary:--;; A highly customisable input method which can inherit from other-;; Quail input methods. By default the input method is geared towards-;; the input of mathematical and other symbols in Agda programs.-;;-;; Use M-x customize-group agda-input to customise this input method.-;; Note that the functions defined under "Functions used to tweak-;; translation pairs" below can be used to tweak both the key-;; translations inherited from other input methods as well as the-;; ones added specifically for this one.-;;-;; Use agda-input-show-translations to see all the characters which-;; can be typed using this input method (except for those-;; corresponding to ASCII characters).--;;; Code:--(require 'quail)-(require 'cl)--;; Quail is quite stateful, so be careful when editing this code. Note-;; that with-temp-buffer is used below whenever buffer-local state is-;; modified.--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Utility functions--(defun agda-input-concat-map (f xs)- "Concat (map F XS)."- (apply 'append (mapcar f xs)))--(defun agda-input-to-string-list (s)- "Convert a string S to a list of one-character strings, after-removing all space and newline characters."- (agda-input-concat-map- (lambda (c) (if (member c (string-to-list " \n"))- nil- (list (string c))))- (string-to-list s)))--(defun agda-input-character-range (from to)- "A string consisting of the characters from FROM to TO."- (let (seq)- (dotimes (i (1+ (- to from)))- (setq seq (cons (+ from i) seq)))- (concat (nreverse seq))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Functions used to tweak translation pairs--;; lexical-let is used since Elisp lacks lexical scoping.--(defun agda-input-compose (f g)- "\x -> concatMap F (G x)"- (lexical-let ((f1 f) (g1 g))- (lambda (x) (agda-input-concat-map f1 (funcall g1 x)))))--(defun agda-input-or (f g)- "\x -> F x ++ G x"- (lexical-let ((f1 f) (g1 g))- (lambda (x) (append (funcall f1 x) (funcall g1 x)))))--(defun agda-input-nonempty ()- "Only keep pairs with a non-empty first component."- (lambda (x) (if (> (length (car x)) 0) (list x))))--(defun agda-input-prepend (prefix)- "Prepend PREFIX to all key sequences."- (lexical-let ((prefix1 prefix))- (lambda (x) `((,(concat prefix1 (car x)) . ,(cdr x))))))--(defun agda-input-prefix (prefix)- "Only keep pairs whose key sequence starts with PREFIX."- (lexical-let ((prefix1 prefix))- (lambda (x)- (if (equal (substring (car x) 0 (length prefix1)) prefix1)- (list x)))))--(defun agda-input-suffix (suffix)- "Only keep pairs whose key sequence ends with SUFFIX."- (lexical-let ((suffix1 suffix))- (lambda (x)- (if (equal (substring (car x)- (- (length (car x)) (length suffix1)))- suffix1)- (list x)))))--(defun agda-input-drop (ss)- "Drop pairs matching one of the given key sequences.-SS should be a list of strings."- (lexical-let ((ss1 ss))- (lambda (x) (unless (member (car x) ss1) (list x)))))--(defun agda-input-drop-beginning (n)- "Drop N characters from the beginning of each key sequence."- (lexical-let ((n1 n))- (lambda (x) `((,(substring (car x) n1) . ,(cdr x))))))--(defun agda-input-drop-end (n)- "Drop N characters from the end of each key sequence."- (lexical-let ((n1 n))- (lambda (x)- `((,(substring (car x) 0 (- (length (car x)) n1)) .- ,(cdr x))))))--(defun agda-input-drop-prefix (prefix)- "Only keep pairs whose key sequence starts with PREFIX.-This prefix is dropped."- (agda-input-compose- (agda-input-drop-beginning (length prefix))- (agda-input-prefix prefix)))--(defun agda-input-drop-suffix (suffix)- "Only keep pairs whose key sequence ends with SUFFIX.-This suffix is dropped."- (lexical-let ((suffix1 suffix))- (agda-input-compose- (agda-input-drop-end (length suffix1))- (agda-input-suffix suffix1))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Customization--;; The :set keyword is set to 'agda-input-incorporate-changed-setting-;; so that the input method gets updated immediately when users-;; customize it. However, the setup functions cannot be run before all-;; variables have been defined. Hence the :initialize keyword is set to-;; 'custom-initialize-default to ensure that the setup is not performed-;; until agda-input-setup is called at the end of this file.--(defgroup agda-input nil- "The Agda input method.-After tweaking these settings you may want to inspect the resulting-translations using `agda-input-show-translations'."- :group 'agda2- :group 'leim)--(defcustom agda-input-tweak-all- '(agda-input-compose- (agda-input-prepend "\\")- (agda-input-nonempty))- "An expression yielding a function which can be used to tweak-all translations before they are included in the input method.-The resulting function (if non-nil) is applied to every-\(KEY-SEQUENCE . TRANSLATION) pair and should return a list of such-pairs. (Note that the translations can be anything accepted by-`quail-defrule'.)--If you change this setting manually (without using the-customization buffer) you need to call `agda-input-setup' in-order for the change to take effect."- :group 'agda-input- :set 'agda-input-incorporate-changed-setting- :initialize 'custom-initialize-default- :type 'sexp)--(defcustom agda-input-inherit- `(("TeX" . (agda-input-compose- (agda-input-drop '("geq" "leq" "bullet" "qed" "par"))- (agda-input-or- (agda-input-drop-prefix "\\")- (agda-input-or- (agda-input-compose- (agda-input-drop '("^o"))- (agda-input-prefix "^"))- (agda-input-prefix "_")))))- )- "A list of Quail input methods whose translations should be-inherited by the Agda input method (with the exception of-translations corresponding to ASCII characters).--The list consists of pairs (qp . tweak), where qp is the name of-a Quail package, and tweak is an expression of the same kind as-`agda-input-tweak-all' which is used to tweak the translation-pairs of the input method.--The inherited translation pairs are added last, after-`agda-input-user-translations' and `agda-input-translations'.--If you change this setting manually (without using the-customization buffer) you need to call `agda-input-setup' in-order for the change to take effect."- :group 'agda-input- :set 'agda-input-incorporate-changed-setting- :initialize 'custom-initialize-default- :type '(repeat (cons (string :tag "Quail package")- (sexp :tag "Tweaking function"))))--(defcustom agda-input-translations- (let ((max-lisp-eval-depth 2800)) `(-- ;; Equality and similar symbols.-- ("eq" . ,(agda-input-to-string-list "=∼∽≈≋∻∾∿≀≃⋍≂≅ ≌≊≡≣≐≑≒≓≔≕≖≗≘≙≚≛≜≝≞≟≍≎≏≬⋕"))- ("eqn" . ,(agda-input-to-string-list "≠≁ ≉ ≄ ≇≆ ≢ ≭ "))-- ("=n" . ("≠"))- ("~" . ("∼")) ("~n" . ("≁"))- ("~~" . ("≈")) ("~~n" . ("≉"))- ("~~~" . ("≋"))- (":~" . ("∻"))- ("~-" . ("≃")) ("~-n" . ("≄"))- ("-~" . ("≂"))- ("~=" . ("≅")) ("~=n" . ("≇"))- ("~~-" . ("≊"))- ("==" . ("≡")) ("==n" . ("≢"))- ("===" . ("≣"))- (".=" . ("≐")) (".=." . ("≑"))- (":=" . ("≔")) ("=:" . ("≕"))- ("=o" . ("≗"))- ("(=" . ("≘"))- ("and=" . ("≙")) ("or=" . ("≚"))- ("*=" . ("≛"))- ("t=" . ("≜"))- ("def=" . ("≝"))- ("m=" . ("≞"))- ("?=" . ("≟"))-- ;; Inequality and similar symbols.-- ("leq" . ,(agda-input-to-string-list "<≪⋘≤≦≲ ≶≺≼≾⊂⊆ ⋐⊏⊑ ⊰⊲⊴⋖⋚⋜⋞"))- ("leqn" . ,(agda-input-to-string-list "≮ ≰≨≴⋦≸⊀ ⋨⊄⊈⊊ ⋢⋤ ⋪⋬ ⋠"))- ("geq" . ,(agda-input-to-string-list ">≫⋙≥≧≳ ≷≻≽≿⊃⊇ ⋑⊐⊒ ⊱⊳⊵⋗⋛⋝⋟"))- ("geqn" . ,(agda-input-to-string-list "≯ ≱≩≵⋧≹⊁ ⋩⊅⊉⊋ ⋣⋥ ⋫⋭ ⋡"))-- ("<=" . ("≤")) (">=" . ("≥"))- ("<=n" . ("≰")) (">=n" . ("≱"))- ("len" . ("≰")) ("gen" . ("≱"))- ("<n" . ("≮")) (">n" . ("≯"))- ("<~" . ("≲")) (">~" . ("≳"))- ("<~n" . ("⋦")) (">~n" . ("⋧"))- ("<~nn" . ("≴")) (">~nn" . ("≵"))-- ("sub" . ("⊂")) ("sup" . ("⊃"))- ("subn" . ("⊄")) ("supn" . ("⊅"))- ("sub=" . ("⊆")) ("sup=" . ("⊇"))- ("sub=n" . ("⊈")) ("sup=n" . ("⊉"))-- ("squb" . ("⊏")) ("squp" . ("⊐"))- ("squb=" . ("⊑")) ("squp=" . ("⊒"))- ("squb=n" . ("⋢")) ("squp=n" . ("⋣"))-- ;; Set membership etc.-- ("member" . ,(agda-input-to-string-list "∈∉∊∋∌∍⋲⋳⋴⋵⋶⋷⋸⋹⋺⋻⋼⋽⋾⋿"))-- ("inn" . ("∉"))- ("nin" . ("∌"))-- ;; Intersections, unions etc.-- ("intersection" . ,(agda-input-to-string-list "∩⋂∧⋀⋏⨇⊓⨅⋒∏ ⊼ ⨉"))- ("union" . ,(agda-input-to-string-list "∪⋃∨⋁⋎⨈⊔⨆⋓∐⨿⊽⊻⊍⨃⊎⨄⊌∑⅀"))-- ("and" . ("∧")) ("or" . ("∨"))- ("And" . ("⋀")) ("Or" . ("⋁"))- ("i" . ("∩")) ("un" . ("∪")) ("u+" . ("⊎")) ("u." . ("⊍"))- ("I" . ("⋂")) ("Un" . ("⋃")) ("U+" . ("⨄")) ("U." . ("⨃"))- ("glb" . ("⊓")) ("lub" . ("⊔"))- ("Glb" . ("⨅")) ("Lub" . ("⨆"))-- ;; Entailment etc.-- ("entails" . ,(agda-input-to-string-list "⊢⊣⊤⊥⊦⊧⊨⊩⊪⊫⊬⊭⊮⊯"))-- ("|-" . ("⊢")) ("|-n" . ("⊬"))- ("-|" . ("⊣"))- ("|=" . ("⊨")) ("|=n" . ("⊭"))- ("||-" . ("⊩")) ("||-n" . ("⊮"))- ("||=" . ("⊫")) ("||=n" . ("⊯"))- ("|||-" . ("⊪"))-- ;; Divisibility, parallelity.-- ("|" . ("∣")) ("|n" . ("∤"))- ("||" . ("∥")) ("||n" . ("∦"))-- ;; Some symbols from logic and set theory.-- ("all" . ("∀"))- ("ex" . ("∃"))- ("exn" . ("∄"))- ("0" . ("∅"))- ("C" . ("∁"))-- ;; Corners, ceilings and floors.-- ("c" . ,(agda-input-to-string-list "⌜⌝⌞⌟⌈⌉⌊⌋"))- ("cu" . ,(agda-input-to-string-list "⌜⌝ ⌈⌉ "))- ("cl" . ,(agda-input-to-string-list " ⌞⌟ ⌊⌋"))-- ("cul" . ("⌜")) ("cuL" . ("⌈"))- ("cur" . ("⌝")) ("cuR" . ("⌉"))- ("cll" . ("⌞")) ("clL" . ("⌊"))- ("clr" . ("⌟")) ("clR" . ("⌋"))-- ;; Various operators/symbols.-- ("qed" . ("∎"))- ("x" . ("×"))- ("o" . ("∘"))- ("comp" . ("∘"))- ("." . ("∙"))- ("*" . ("⋆"))- (".+" . ("∔"))- (".-" . ("∸"))- (":" . ("∶"))- ("::" . ("∷"))- ("::-" . ("∺"))- ("-:" . ("∹"))- ("+ " . ("⊹"))- ("surd3" . ("∛"))- ("surd4" . ("∜"))- ("increment" . ("∆"))- ("inf" . ("∞"))-- ;; Circled operators.-- ("o+" . ("⊕"))- ("o--" . ("⊖"))- ("ox" . ("⊗"))- ("o/" . ("⊘"))- ("o." . ("⊙"))- ("oo" . ("⊚"))- ("o*" . ("⊛"))- ("o=" . ("⊜"))- ("o-" . ("⊝"))-- ("O+" . ("⨁"))- ("Ox" . ("⨂"))- ("O." . ("⨀"))- ("O*" . ("⍟"))-- ;; Boxed operators.-- ("b+" . ("⊞"))- ("b-" . ("⊟"))- ("bx" . ("⊠"))- ("b." . ("⊡"))-- ;; Various symbols.-- ("integral" . ,(agda-input-to-string-list "∫∬∭∮∯∰∱∲∳"))- ("angle" . ,(agda-input-to-string-list "∟∡∢⊾⊿"))- ("join" . ,(agda-input-to-string-list "⋈⋉⋊⋋⋌⨝⟕⟖⟗"))-- ;; Arrows.-- ("l" . ,(agda-input-to-string-list "←⇐⇚⇇⇆↤⇦↞↼↽⇠⇺↜⇽⟵⟸↚⇍⇷ ↹ ↢↩↫⇋⇜⇤⟻⟽⤆↶↺⟲ "))- ("r" . ,(agda-input-to-string-list "→⇒⇛⇉⇄↦⇨↠⇀⇁⇢⇻↝⇾⟶⟹↛⇏⇸⇶ ↴ ↣↪↬⇌⇝⇥⟼⟾⤇↷↻⟳⇰⇴⟴⟿ ➵➸➙➔➛➜➝➞➟➠➡➢➣➤➧➨➩➪➫➬➭➮➯➱➲➳➺➻➼➽➾"))- ("u" . ,(agda-input-to-string-list "↑⇑⟰⇈⇅↥⇧↟↿↾⇡⇞ ↰↱➦ ⇪⇫⇬⇭⇮⇯ "))- ("d" . ,(agda-input-to-string-list "↓⇓⟱⇊⇵↧⇩↡⇃⇂⇣⇟ ↵↲↳➥ ↯ "))- ("ud" . ,(agda-input-to-string-list "↕⇕ ↨⇳ "))- ("lr" . ,(agda-input-to-string-list "↔⇔ ⇼↭⇿⟷⟺↮⇎⇹ "))- ("ul" . ,(agda-input-to-string-list "↖⇖ ⇱↸ "))- ("ur" . ,(agda-input-to-string-list "↗⇗ ➶➹➚ "))- ("dr" . ,(agda-input-to-string-list "↘⇘ ⇲ ➴➷➘ "))- ("dl" . ,(agda-input-to-string-list "↙⇙ "))-- ("l-" . ("←")) ("<-" . ("←")) ("l=" . ("⇐"))- ("r-" . ("→")) ("->" . ("→")) ("r=" . ("⇒")) ("=>" . ("⇒"))- ("u-" . ("↑")) ("u=" . ("⇑"))- ("d-" . ("↓")) ("d=" . ("⇓"))- ("ud-" . ("↕")) ("ud=" . ("⇕"))- ("lr-" . ("↔")) ("<->" . ("↔")) ("lr=" . ("⇔")) ("<=>" . ("⇔"))- ("ul-" . ("↖")) ("ul=" . ("⇖"))- ("ur-" . ("↗")) ("ur=" . ("⇗"))- ("dr-" . ("↘")) ("dr=" . ("⇘"))- ("dl-" . ("↙")) ("dl=" . ("⇙"))-- ("l==" . ("⇚")) ("l-2" . ("⇇")) ("l-r-" . ("⇆"))- ("r==" . ("⇛")) ("r-2" . ("⇉")) ("r-3" . ("⇶")) ("r-l-" . ("⇄"))- ("u==" . ("⟰")) ("u-2" . ("⇈")) ("u-d-" . ("⇅"))- ("d==" . ("⟱")) ("d-2" . ("⇊")) ("d-u-" . ("⇵"))-- ("l--" . ("⟵")) ("<--" . ("⟵")) ("l~" . ("↜" "⇜"))- ("r--" . ("⟶")) ("-->" . ("⟶")) ("r~" . ("↝" "⇝" "⟿"))- ("lr--" . ("⟷")) ("<-->" . ("⟷")) ("lr~" . ("↭"))-- ("l-n" . ("↚")) ("<-n" . ("↚")) ("l=n" . ("⇍"))- ("r-n" . ("↛")) ("->n" . ("↛")) ("r=n" . ("⇏")) ("=>n" . ("⇏"))- ("lr-n" . ("↮")) ("<->n" . ("↮")) ("lr=n" . ("⇎")) ("<=>n" . ("⇎"))-- ("l-|" . ("↤")) ("ll-" . ("↞"))- ("r-|" . ("↦")) ("rr-" . ("↠"))- ("u-|" . ("↥")) ("uu-" . ("↟"))- ("d-|" . ("↧")) ("dd-" . ("↡"))- ("ud-|" . ("↨"))-- ("l->" . ("↢"))- ("r->" . ("↣"))-- ("dz" . ("↯"))-- ;; Ellipsis.-- ("..." . ,(agda-input-to-string-list "⋯⋮⋰⋱"))-- ;; Box-drawing characters.-- ("---" . ,(agda-input-to-string-list "─│┌┐└┘├┤┬┼┴╴╵╶╷╭╮╯╰╱╲╳"))- ("--=" . ,(agda-input-to-string-list "═║╔╗╚╝╠╣╦╬╩ ╒╕╘╛╞╡╤╪╧ ╓╖╙╜╟╢╥╫╨"))- ("--_" . ,(agda-input-to-string-list "━┃┏┓┗┛┣┫┳╋┻╸╹╺╻- ┍┯┑┕┷┙┝┿┥┎┰┒┖┸┚┠╂┨┞╀┦┟╁┧┢╈┪┡╇┩- ┮┭┶┵┾┽┲┱┺┹╊╉╆╅╄╃ ╿╽╼╾"))- ("--." . ,(agda-input-to-string-list "╌╎┄┆┈┊- ╍╏┅┇┉┋"))-- ;; Triangles.-- ;; Big/small, black/white.-- ("t" . ,(agda-input-to-string-list "◂◃◄◅▸▹►▻▴▵▾▿◢◿◣◺◤◸◥◹"))- ("T" . ,(agda-input-to-string-list "◀◁▶▷▲△▼▽◬◭◮"))-- ("tb" . ,(agda-input-to-string-list "◂▸▴▾◄►◢◣◤◥"))- ("tw" . ,(agda-input-to-string-list "◃▹▵▿◅▻◿◺◸◹"))-- ("Tb" . ,(agda-input-to-string-list "◀▶▲▼"))- ("Tw" . ,(agda-input-to-string-list "◁▷△▽"))-- ;; Squares.-- ("sq" . ,(agda-input-to-string-list "■□◼◻◾◽▣▢▤▥▦▧▨▩◧◨◩◪◫◰◱◲◳"))- ("sqb" . ,(agda-input-to-string-list "■◼◾"))- ("sqw" . ,(agda-input-to-string-list "□◻◽"))- ("sq." . ("▣"))- ("sqo" . ("▢"))-- ;; Rectangles.-- ("re" . ,(agda-input-to-string-list "▬▭▮▯"))- ("reb" . ,(agda-input-to-string-list "▬▮"))- ("rew" . ,(agda-input-to-string-list "▭▯"))-- ;; Parallelograms.-- ("pa" . ,(agda-input-to-string-list "▰▱"))- ("pab" . ("▰"))- ("paw" . ("▱"))-- ;; Diamonds.-- ("di" . ,(agda-input-to-string-list "◆◇◈"))- ("dib" . ("◆"))- ("diw" . ("◇"))- ("di." . ("◈"))-- ;; Circles.-- ("ci" . ,(agda-input-to-string-list "●○◎◌◯◍◐◑◒◓◔◕◖◗◠◡◴◵◶◷⚆⚇⚈⚉"))- ("cib" . ("●"))- ("ciw" . ("○"))- ("ci." . ("◎"))- ("ci.." . ("◌"))- ("ciO" . ("◯"))-- ;; Stars.-- ("st" . ,(agda-input-to-string-list "⋆✦✧✶✴✹ ★☆✪✫✯✰✵✷✸"))- ("st4" . ,(agda-input-to-string-list "✦✧"))- ("st6" . ("✶"))- ("st8" . ("✴"))- ("st12" . ("✹"))-- ;; Blackboard bold letters.-- ("bn" . ("ℕ"))- ("bz" . ("ℤ"))- ("bq" . ("ℚ"))- ("br" . ("ℝ"))- ("bc" . ("ℂ"))- ("bp" . ("ℙ"))- ("bsum" . ("⅀"))-- ;; Parentheses.-- ("(" . ,(agda-input-to-string-list "([{⁅⁽₍〈⎴⟅⟦⟨⟪⦃〈《「『【〔〖〚︵︷︹︻︽︿﹁﹃﹙﹛﹝([{「"))- (")" . ,(agda-input-to-string-list ")]}⁆⁾₎〉⎵⟆⟧⟩⟫⦄〉》」』】〕〗〛︶︸︺︼︾﹀﹂﹄﹚﹜﹞)]}」"))-- ("[[" . ("⟦"))- ("]]" . ("⟧"))- ("<" . ("⟨"))- (">" . ("⟩"))- ("<<" . ("⟪"))- (">>" . ("⟫"))- ("{{" . ("⦃"))- ("}}" . ("⦄"))-- ("(b" . ("⟅"))- (")b" . ("⟆"))-- ("lbag" . ("⟅"))- ("rbag" . ("⟆"))-- ;; Primes.-- ("'" . ,(agda-input-to-string-list "′″‴⁗"))- ("`" . ,(agda-input-to-string-list "‵‶‷"))-- ;; Fractions.-- ("frac" . ,(agda-input-to-string-list "¼½¾⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟"))-- ;; Bullets.-- ("bu" . ,(agda-input-to-string-list "•◦‣⁌⁍"))- ("bub" . ("•"))- ("buw" . ("◦"))- ("but" . ("‣"))-- ;; Musical symbols.-- ("note" . ,(agda-input-to-string-list "♩♪♫♬"))- ("b" . ("♭"))- ("#" . ("♯"))-- ;; Other punctuation and symbols.-- ("\\" . ("\\"))- ("en" . ("–"))- ("em" . ("—"))- ("^i" . ("ⁱ"))- ("!!" . ("‼"))- ("??" . ("⁇"))- ("?!" . ("‽" "⁈"))- ("!?" . ("⁉"))- ("die" . ,(agda-input-to-string-list "⚀⚁⚂⚃⚄⚅"))- ("asterisk" . ,(agda-input-to-string-list "⁎⁑⁂✢✣✤✥✱✲✳✺✻✼✽❃❉❊❋"))- ("8<" . ("✂" "✄"))- ("tie" . ("⁀"))- ("undertie" . ("‿"))- ("apl" . ,(agda-input-to-string-list "⌶⌷⌸⌹⌺⌻⌼⌽⌾⌿⍀⍁⍂⍃⍄⍅⍆⍇⍈- ⍉⍊⍋⍌⍍⍎⍏⍐⍑⍒⍓⍔⍕⍖⍗⍘⍙⍚⍛- ⍜⍝⍞⍟⍠⍡⍢⍣⍤⍥⍦⍧⍨⍩⍪⍫⍬⍭⍮- ⍯⍰⍱⍲⍳⍴⍵⍶⍷⍸⍹⍺⎕"))-- ;; Some combining characters.- ;;- ;; The following combining characters also have (other)- ;; translations:- ;; ̀ ́ ̂ ̃ ̄ ̆ ̇ ̈ ̋ ̌ ̣ ̧ ̱-- ("^--" . ,(agda-input-to-string-list"̅̿"))- ("_--" . ,(agda-input-to-string-list"̲̳"))- ("^~" . ,(agda-input-to-string-list"̃͌"))- ("_~" . ( "̰"))- ("^." . ,(agda-input-to-string-list"̇̈⃛⃜"))- ("_." . ,(agda-input-to-string-list"̣̤"))- ("^l" . ,(agda-input-to-string-list"⃖⃐⃔"))- ("^l-" . ( "⃖"))- ("^r" . ,(agda-input-to-string-list"⃗⃑⃕"))- ("^r-" . ( "⃗"))- ("^lr" . ( "⃡"))- ("_lr" . ( "͍"))- ("^^" . ,(agda-input-to-string-list"̂̑͆"))- ("_^" . ,(agda-input-to-string-list"̭̯̪"))- ("^v" . ,(agda-input-to-string-list"̌̆"))- ("_v" . ,(agda-input-to-string-list"̬̮̺"))-- ;; Shorter forms of many greek letters plus ƛ.-- ("Ga" . ("α")) ("GA" . ("Α"))- ("Gb" . ("β")) ("GB" . ("Β"))- ("Gg" . ("γ")) ("GG" . ("Γ"))- ("Gd" . ("δ")) ("GD" . ("Δ"))- ("Ge" . ("ε")) ("GE" . ("Ε"))- ("Gz" . ("ζ")) ("GZ" . ("Ζ"))- ;; \eta \Eta- ("Gth" . ("θ")) ("GTH" . ("θ"))- ("Gi" . ("ι")) ("GI" . ("Ι"))- ("Gk" . ("κ")) ("GK" . ("Κ"))- ("Gl" . ("λ")) ("GL" . ("Λ")) ("Gl-" . ("ƛ"))- ("Gm" . ("μ")) ("GM" . ("Μ"))- ("Gn" . ("ν")) ("GN" . ("Ν"))- ("Gx" . ("ξ")) ("GX" . ("Ξ"))- ;; \omicron \Omicron- ;; \pi \Pi- ("Gr" . ("ρ")) ("GR" . ("Ρ"))- ("Gs" . ("σ")) ("GS" . ("Σ"))- ("Gt" . ("τ")) ("GT" . ("Τ"))- ("Gu" . ("υ")) ("GU" . ("Υ"))- ("Gf" . ("φ")) ("GF" . ("Φ"))- ("Gc" . ("χ")) ("GC" . ("Χ"))- ("Gp" . ("ψ")) ("GP" . ("Ψ"))- ("Go" . ("ω")) ("GO" . ("Ω"))-- ;; Some ISO8859-1 characters.-- (" " . (" "))- ("!" . ("¡"))- ("cent" . ("¢"))- ("brokenbar" . ("¦"))- ("degree" . ("°"))- ("?" . ("¿"))- ("^a_" . ("ª"))- ("^o_" . ("º"))-- ;; Circled, parenthesised etc. numbers and letters.-- ( "(0)" . ,(agda-input-to-string-list " ⓪"))- ( "(1)" . ,(agda-input-to-string-list "⑴①⒈❶➀➊"))- ( "(2)" . ,(agda-input-to-string-list "⑵②⒉❷➁➋"))- ( "(3)" . ,(agda-input-to-string-list "⑶③⒊❸➂➌"))- ( "(4)" . ,(agda-input-to-string-list "⑷④⒋❹➃➍"))- ( "(5)" . ,(agda-input-to-string-list "⑸⑤⒌❺➄➎"))- ( "(6)" . ,(agda-input-to-string-list "⑹⑥⒍❻➅➏"))- ( "(7)" . ,(agda-input-to-string-list "⑺⑦⒎❼➆➐"))- ( "(8)" . ,(agda-input-to-string-list "⑻⑧⒏❽➇➑"))- ( "(9)" . ,(agda-input-to-string-list "⑼⑨⒐❾➈➒"))- ("(10)" . ,(agda-input-to-string-list "⑽⑩⒑❿➉➓"))- ("(11)" . ,(agda-input-to-string-list "⑾⑪⒒"))- ("(12)" . ,(agda-input-to-string-list "⑿⑫⒓"))- ("(13)" . ,(agda-input-to-string-list "⒀⑬⒔"))- ("(14)" . ,(agda-input-to-string-list "⒁⑭⒕"))- ("(15)" . ,(agda-input-to-string-list "⒂⑮⒖"))- ("(16)" . ,(agda-input-to-string-list "⒃⑯⒗"))- ("(17)" . ,(agda-input-to-string-list "⒄⑰⒘"))- ("(18)" . ,(agda-input-to-string-list "⒅⑱⒙"))- ("(19)" . ,(agda-input-to-string-list "⒆⑲⒚"))- ("(20)" . ,(agda-input-to-string-list "⒇⑳⒛"))-- ("(a)" . ,(agda-input-to-string-list "⒜Ⓐⓐ"))- ("(b)" . ,(agda-input-to-string-list "⒝Ⓑⓑ"))- ("(c)" . ,(agda-input-to-string-list "⒞Ⓒⓒ"))- ("(d)" . ,(agda-input-to-string-list "⒟Ⓓⓓ"))- ("(e)" . ,(agda-input-to-string-list "⒠Ⓔⓔ"))- ("(f)" . ,(agda-input-to-string-list "⒡Ⓕⓕ"))- ("(g)" . ,(agda-input-to-string-list "⒢Ⓖⓖ"))- ("(h)" . ,(agda-input-to-string-list "⒣Ⓗⓗ"))- ("(i)" . ,(agda-input-to-string-list "⒤Ⓘⓘ"))- ("(j)" . ,(agda-input-to-string-list "⒥Ⓙⓙ"))- ("(k)" . ,(agda-input-to-string-list "⒦Ⓚⓚ"))- ("(l)" . ,(agda-input-to-string-list "⒧Ⓛⓛ"))- ("(m)" . ,(agda-input-to-string-list "⒨Ⓜⓜ"))- ("(n)" . ,(agda-input-to-string-list "⒩Ⓝⓝ"))- ("(o)" . ,(agda-input-to-string-list "⒪Ⓞⓞ"))- ("(p)" . ,(agda-input-to-string-list "⒫Ⓟⓟ"))- ("(q)" . ,(agda-input-to-string-list "⒬Ⓠⓠ"))- ("(r)" . ,(agda-input-to-string-list "⒭Ⓡⓡ"))- ("(s)" . ,(agda-input-to-string-list "⒮Ⓢⓢ"))- ("(t)" . ,(agda-input-to-string-list "⒯Ⓣⓣ"))- ("(u)" . ,(agda-input-to-string-list "⒰Ⓤⓤ"))- ("(v)" . ,(agda-input-to-string-list "⒱Ⓥⓥ"))- ("(w)" . ,(agda-input-to-string-list "⒲Ⓦⓦ"))- ("(x)" . ,(agda-input-to-string-list "⒳Ⓧⓧ"))- ("(y)" . ,(agda-input-to-string-list "⒴Ⓨⓨ"))- ("(z)" . ,(agda-input-to-string-list "⒵Ⓩⓩ"))-- ))- "A list of translations specific to the Agda input method.-Each element is a pair (KEY-SEQUENCE-STRING . LIST-OF-TRANSLATION-STRINGS).-All the translation strings are possible translations-of the given key sequence; if there is more than one you can choose-between them using the arrow keys.--Note that if you customize this setting you will not-automatically benefit (or suffer) from modifications to its-default value when the library is updated. If you just want to-add some bindings it is probably a better idea to customize-`agda-input-user-translations'.--These translation pairs are included after those in-`agda-input-user-translations', but before the ones inherited-from other input methods (see `agda-input-inherit').--If you change this setting manually (without using the-customization buffer) you need to call `agda-input-setup' in-order for the change to take effect."- :group 'agda-input- :set 'agda-input-incorporate-changed-setting- :initialize 'custom-initialize-default- :type '(repeat (cons (string :tag "Key sequence")- (repeat :tag "Translations" string))))--(defcustom agda-input-user-translations nil- "Like `agda-input-translations', but more suitable for user-customizations since by default it is empty.--These translation pairs are included first, before those in-`agda-input-translations' and the ones inherited from other input-methods."- :group 'agda-input- :set 'agda-input-incorporate-changed-setting- :initialize 'custom-initialize-default- :type '(repeat (cons (string :tag "Key sequence")- (repeat :tag "Translations" string))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Inspecting and modifying translation maps--(defun agda-input-get-translations (qp)- "Return a list containing all translations from the Quail-package QP (except for those corresponding to ASCII).-Each pair in the list has the form (KEY-SEQUENCE . TRANSLATION)."- (with-temp-buffer- (activate-input-method qp) ; To make sure that the package is loaded.- (unless (quail-package qp)- (error "%s is not a Quail package." qp))- (let ((decode-map (list 'decode-map)))- (quail-build-decode-map (list (quail-map)) "" decode-map 0)- (cdr decode-map))))--(defun agda-input-show-translations (qp)- "Display all translations used by the Quail package QP (a string).-\(Except for those corresponding to ASCII)."- (interactive (list (read-input-method-name- "Quail input method (default %s): " "Agda")))- (let ((buf (concat "*" qp " input method translations*")))- (with-output-to-temp-buffer buf- (with-current-buffer buf- (quail-insert-decode-map- (cons 'decode-map (agda-input-get-translations qp)))))))--(defun agda-input-add-translations (trans)- "Add the given translations TRANS to the Agda input method.-TRANS is a list of pairs (KEY-SEQUENCE . TRANSLATION). The-translations are appended to the current translations."- (with-temp-buffer- (dolist (tr (agda-input-concat-map (eval agda-input-tweak-all) trans))- (quail-defrule (car tr) (cdr tr) "Agda" t))))--(defun agda-input-inherit-package (qp &optional fun)- "Let the Agda input method inherit the translations from the-Quail package QP (except for those corresponding to ASCII).--The optional function FUN can be used to modify the translations.-It is given a pair (KEY-SEQUENCE . TRANSLATION) and should return-a list of such pairs."- (let ((trans (agda-input-get-translations qp)))- (agda-input-add-translations- (if fun (agda-input-concat-map fun trans)- trans))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Setting up the input method--(defun agda-input-setup ()- "Set up the Agda input method based on the customisable-variables and underlying input methods."-- ;; Create (or reset) the input method.- (with-temp-buffer- (quail-define-package "Agda" "UTF-8" "∏" t ; guidance- "Agda input method.-The purpose of this input method is to edit Agda programs, but-since it is highly customisable it can be made useful for other-tasks as well."- nil nil nil nil nil nil t ; maximum-shortest- ))-- (agda-input-add-translations- (mapcar (lambda (tr) (cons (car tr) (vconcat (cdr tr))))- (append agda-input-user-translations- agda-input-translations)))- (dolist (def agda-input-inherit)- (agda-input-inherit-package (car def)- (eval (cdr def)))))--(defun agda-input-incorporate-changed-setting (sym val)- "Update the Agda input method based on the customisable-variables and underlying input methods.-Suitable for use in the :set field of `defcustom'."- (set-default sym val)- (agda-input-setup))--;; Set up the input method.--(agda-input-setup)+;;; -*- lexical-binding: t; -*-+;;; agda-input.el --- The Agda input method++;; SPDX-License-Identifier: MIT License+;;; Commentary:++;; A highly customisable input method which can inherit from other+;; Quail input methods. By default the input method is geared towards+;; the input of mathematical and other symbols in Agda programs.+;;+;; Use M-x customize-group agda-input to customise this input method.+;; Note that the functions defined under "Functions used to tweak+;; translation pairs" below can be used to tweak both the key+;; translations inherited from other input methods as well as the+;; ones added specifically for this one.+;;+;; Use agda-input-show-translations to see all the characters which+;; can be typed using this input method (except for those+;; corresponding to ASCII characters).++;;; Code:++(require 'quail)+(require 'cl-lib)+;; Quail is quite stateful, so be careful when editing this code. Note+;; that with-temp-buffer is used below whenever buffer-local state is+;; modified.++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Utility functions++(defun agda-input-concat-map (f xs)+ "Concat (map F XS)."+ (apply 'append (mapcar f xs)))++(defun agda-input-to-string-list (s)+ "Convert a string S to a list of one-character strings, after+removing all space and newline characters."+ (agda-input-concat-map+ (lambda (c) (if (member c (string-to-list " \n"))+ nil+ (list (string c))))+ (string-to-list s)))++(defun agda-input-character-range (from to)+ "A string consisting of the characters from FROM to TO."+ (let (seq)+ (dotimes (i (1+ (- to from)))+ (setq seq (cons (+ from i) seq)))+ (concat (nreverse seq))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Functions used to tweak translation pairs++(defun agda-input-compose (f g)+ "λ x -> concatMap F (G x)"+ (lambda (x) (agda-input-concat-map f (funcall g x))))++(defun agda-input-or (f g)+ "λ x -> F x ++ G x"+ (lambda (x) (append (funcall f x) (funcall g x))))++(defun agda-input-nonempty ()+ "Only keep pairs with a non-empty first component."+ (lambda (x) (if (> (length (car x)) 0) (list x))))++(defun agda-input-prepend (prefix)+ "Prepend PREFIX to all key sequences."+ (lambda (x) `((,(concat prefix (car x)) . ,(cdr x)))))++(defun agda-input-prefix (prefix)+ "Only keep pairs whose key sequence starts with PREFIX."+ (lambda (x)+ (if (equal (substring (car x) 0 (length prefix)) prefix)+ (list x))))++(defun agda-input-suffix (suffix)+ "Only keep pairs whose key sequence ends with SUFFIX."+ (lambda (x)+ (if (equal (substring (car x)+ (- (length (car x)) (length suffix)))+ suffix)+ (list x))))++(defun agda-input-drop (ss)+ "Drop pairs matching one of the given key sequences.+SS should be a list of strings."+ (lambda (x) (unless (member (car x) ss) (list x))))++(defun agda-input-drop-beginning (n)+ "Drop N characters from the beginning of each key sequence."+ (lambda (x) `((,(substring (car x) n) . ,(cdr x)))))++(defun agda-input-drop-end (n)+ "Drop N characters from the end of each key sequence."+ (lambda (x)+ `((,(substring (car x) 0 (- (length (car x)) n)) .+ ,(cdr x)))))++(defun agda-input-drop-prefix (prefix)+ "Only keep pairs whose key sequence starts with PREFIX.+This prefix is dropped."+ (agda-input-compose+ (agda-input-drop-beginning (length prefix))+ (agda-input-prefix prefix)))++(defun agda-input-drop-suffix (suffix)+ "Only keep pairs whose key sequence ends with SUFFIX.+This suffix is dropped."+ (agda-input-compose+ (agda-input-drop-end (length suffix))+ (agda-input-suffix suffix)))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Customization++;; The :set keyword is set to 'agda-input-incorporate-changed-setting+;; so that the input method gets updated immediately when users+;; customize it. However, the setup functions cannot be run before all+;; variables have been defined. Hence the :initialize keyword is set to+;; 'custom-initialize-default to ensure that the setup is not performed+;; until agda-input-setup is called at the end of this file.++(defgroup agda-input nil+ "The Agda input method.+After tweaking these settings you may want to inspect the resulting+translations using `agda-input-show-translations'."+ :group 'agda2+ :group 'leim)++(defcustom agda-input-tweak-all+ '(agda-input-compose+ (agda-input-prepend "\\")+ (agda-input-nonempty))+ "An expression yielding a function which can be used to tweak+all translations before they are included in the input method.+The resulting function (if non-nil) is applied to every+\(KEY-SEQUENCE . TRANSLATION) pair and should return a list of such+pairs. (Note that the translations can be anything accepted by+`quail-defrule'.)++If you change this setting manually (without using the+customization buffer) you need to call `agda-input-setup' in+order for the change to take effect."+ :group 'agda-input+ :set 'agda-input-incorporate-changed-setting+ :initialize 'custom-initialize-default+ :type 'sexp)++(defcustom agda-input-inherit+ `(("TeX" . (agda-input-compose+ (agda-input-drop '("geq" "leq" "bullet" "qed" "par"))+ (agda-input-or+ (agda-input-drop-prefix "\\")+ (agda-input-or+ (agda-input-compose+ (agda-input-drop '("^l" "^o" "^r" "^v"))+ (agda-input-prefix "^"))+ (agda-input-prefix "_")))))+ )+ "A list of Quail input methods whose translations should be+inherited by the Agda input method (with the exception of+translations corresponding to ASCII characters).++The list consists of pairs (qp . tweak), where qp is the name of+a Quail package, and tweak is an expression of the same kind as+`agda-input-tweak-all' which is used to tweak the translation+pairs of the input method.++The inherited translation pairs are added last, after+`agda-input-user-translations' and `agda-input-translations'.++If you change this setting manually (without using the+customization buffer) you need to call `agda-input-setup' in+order for the change to take effect."+ :group 'agda-input+ :set 'agda-input-incorporate-changed-setting+ :initialize 'custom-initialize-default+ :type '(repeat (cons (string :tag "Quail package")+ (sexp :tag "Tweaking function"))))++(defcustom agda-input-translations+ (let ((max-lisp-eval-depth 2800)) `(++ ;; Equality and similar symbols.++ ("eq" . ,(agda-input-to-string-list "=∼∽≈≋∻∾∿≀≃⋍≂≅ ≌≊≡≣≐≑≒≓≔≕≖≗≘≙≚≛≜≝≞≟≍≎≏≬⋕="))+ ("eqn" . ,(agda-input-to-string-list "≠≁ ≉ ≄ ≇≆ ≢ ≭ "))++ ("=n" . ("≠"))+ ("~" . ,(agda-input-to-string-list "∼~"))+ ("~n" . ("≁"))+ ("~~" . ("≈")) ("~~n" . ("≉"))+ ("~~~" . ("≋"))+ (":~" . ("∻"))+ ("~-" . ("≃")) ("~-n" . ("≄"))+ ("-~" . ("≂"))+ ("~=" . ("≅")) ("~=n" . ("≇"))+ ("~~-" . ("≊"))+ ("==" . ("≡")) ("==n" . ("≢"))+ ("===" . ("≣"))+ ("=" . ("="))+ (".=" . ("≐")) (".=." . ("≑"))+ (":=" . ("≔")) ("=:" . ("≕"))+ ("=o" . ("≗"))+ ("(=" . ("≘"))+ ("and=" . ("≙")) ("or=" . ("≚"))+ ("*=" . ("≛"))+ ("t=" . ("≜"))+ ("def=" . ("≝"))+ ("m=" . ("≞"))+ ("?=" . ("≟"))++ ;; Inequality and similar symbols.++ ("leq" . ,(agda-input-to-string-list "<≪⋘≤≦≲ ≶≺≼≾⊂⊆⫇⫉ ⋐⊏⊑ ⊰⊲⊴⋖⋚⋜⋞<"))+ ("leqn" . ,(agda-input-to-string-list "≮ ≰≨≴⋦≸⊀ ⋨⊄⊈⊊ ⋢⋤ ⋪⋬ ⋠"))+ ("geq" . ,(agda-input-to-string-list ">≫⋙≥≧≳ ≷≻≽≿⊃⊇⫈⫊ ⋑⊐⊒ ⊱⊳⊵⋗⋛⋝⋟>"))+ ("geqn" . ,(agda-input-to-string-list "≯ ≱≩≵⋧≹⊁ ⋩⊅⊉⊋ ⋣⋥ ⋫⋭ ⋡"))++ ("<=" . ("≤")) (">=" . ("≥"))+ ("<=n" . ("≰")) (">=n" . ("≱"))+ ("len" . ("≰")) ("gen" . ("≱"))+ ("<n" . ("≮")) (">n" . ("≯"))+ ("<~" . ("≲")) (">~" . ("≳"))+ ("<~n" . ("⋦")) (">~n" . ("⋧"))+ ("<~nn" . ("≴")) (">~nn" . ("≵"))++ ("sub" . ("⊂")) ("sup" . ("⊃"))+ ("subn" . ("⊄")) ("supn" . ("⊅"))+ ("sub=" . ("⊆")) ("sup=" . ("⊇"))+ ("sub=n" . ("⊈")) ("sup=n" . ("⊉"))+ ("sub~" . ("⫇")) ("sup~" . ("⫈"))+ ("sub~~" . ("⫉")) ("sup~~" . ("⫊"))++ ("squb" . ("⊏")) ("squp" . ("⊐"))+ ("squb=" . ("⊑")) ("squp=" . ("⊒"))+ ("squb=n" . ("⋢")) ("squp=n" . ("⋣"))++ ;; Set membership etc.++ ("member" . ,(agda-input-to-string-list "∈∉∊∋∌∍⋲⋳⋴⋵⋶⋷⋸⋹⋺⋻⋼⋽⋾⋿"))++ ("inn" . ("∉"))+ ("nin" . ("∌"))++ ;; Intersections, unions etc.++ ("intersection" . ,(agda-input-to-string-list "∩⋂∧⋀⋏⨇⊓⨅⋒∏ ⊼ ⨉"))+ ("union" . ,(agda-input-to-string-list "∪⋃∨⋁⋎⨈⊔⨆⋓∐⨿⊽⊻⊍⨃⊎⨄⊌∑⅀"))++ ("and" . ("∧")) ("or" . ("∨"))+ ("And" . ("⋀")) ("Or" . ("⋁"))+ ("i" . ("∩")) ("un" . ("∪")) ("u+" . ("⊎")) ("u." . ("⊍"))+ ("I" . ("⋂")) ("Un" . ("⋃")) ("U+" . ("⨄")) ("U." . ("⨃"))+ ("glb" . ("⊓")) ("lub" . ("⊔"))+ ("Glb" . ("⨅")) ("Lub" . ("⨆"))++ ;; Entailment, tacks, etc.++ ("entails" . ,(agda-input-to-string-list "⊢⊣⊤⊥⊦⊧⊨⊩⊪⊫⊬⊭⊮⊯"))++ ("|-" . ("⊢")) ("|-n" . ("⊬"))+ ("-|" . ("⊣"))+ ("|=" . ("⊨")) ("|=n" . ("⊭"))+ ("||-" . ("⊩")) ("||-n" . ("⊮"))+ ("||=" . ("⊫")) ("||=n" . ("⊯"))+ ("|||-" . ("⊪"))+++ ("tack" . ,(agda-input-to-string-list "⟘⟙⟛⟝⟞⫫⫪"))+ ("Bot" . ("⟘")) ;; similar to Glb/Lub vs. glb/lub+ ("Top" . ("⟙"))+ ("-||-" . ("⟛"))+ ("|--" . ("⟝"))+ ("--|" . ("⟞"))+ ("bbot" . ("⫫")) ;; similar to bN for blackboard N+ ("btop" . ("⫪"))++ ;; Divisibility, parallelity.++ ("|" . ("∣")) ("|n" . ("∤"))+ ("||" . ("∥")) ("||n" . ("∦"))++ ;; Some symbols from logic and set theory.++ ("all" . ("∀"))+ ("ex" . ("∃"))+ ("exn" . ("∄"))+ ("0" . ("∅"))+ ("C" . ("∁"))+ ("uin" . ("⟒"))+ ("din" . ("⫙"))++ ;; Corners, ceilings and floors.++ ("c" . ,(agda-input-to-string-list "⌜⌝⌞⌟⌈⌉⌊⌋"))+ ("cu" . ,(agda-input-to-string-list "⌜⌝ ⌈⌉ "))+ ("cl" . ,(agda-input-to-string-list " ⌞⌟ ⌊⌋"))++ ("cul" . ("⌜")) ("cuL" . ("⌈"))+ ("cur" . ("⌝")) ("cuR" . ("⌉"))+ ("cll" . ("⌞")) ("clL" . ("⌊"))+ ("clr" . ("⌟")) ("clR" . ("⌋"))++ ;; Various operators/symbols.++ ("qed" . ("∎"))+ ("x" . ("×"))+ ("o" . ("∘"))+ ("comp" . ("∘"))+ ("." . ,(agda-input-to-string-list "∙."))+ ("*" . ("⋆"))+ (".+" . ("∔"))+ (".-" . ("∸"))+ (":" . ,(agda-input-to-string-list "∶⦂ː꞉˸፥፦:﹕︓"))+ ("," . ,(agda-input-to-string-list "ʻ،⸲⸴⹁⹉、︐︑﹐﹑,、"))+ (";" . ,(agda-input-to-string-list "⨾⨟⁏፤꛶;︔﹔⍮⸵;"))+ ("++" . ("⧺"))+ ("::" . ("∷"))+ ("::-" . ("∺"))+ ("-:" . ("∹"))+ ("+ " . ("⊹"))+ ("+" . ("+"))+ ("sqrt" . ("√"))+ ("surd" . ("√"))+ ("surd3" . ("∛"))+ ("surd4" . ("∜"))+ ("increment" . ("∆"))+ ("inf" . ("∞"))+ ("&" . ,(agda-input-to-string-list "⅋﹠&"))+ ("z;" . ,(agda-input-to-string-list "⨟⨾"))+ ("z:" . ("⦂"))+ ("at" . ,(agda-input-to-string-list "@﹫@"))++ ;; Circled operators.++ ("o+" . ("⊕"))+ ("o--" . ("⊖"))+ ("ox" . ("⊗"))+ ("o/" . ("⊘"))+ ("o." . ("⊙"))+ ("oo" . ("⊚"))+ ("o*" . ("⊛"))+ ("o=" . ("⊜"))+ ("o-" . ,(agda-input-to-string-list "⊝⟜"))++ ("O+" . ("⨁"))+ ("Ox" . ("⨂"))+ ("O." . ("⨀"))+ ("O*" . ("⍟"))++ ;; Boxed operators.++ ("b+" . ("⊞"))+ ("b-" . ("⊟"))+ ("bx" . ("⊠"))+ ("b." . ("⊡"))++ ("b/" . ("⧄"))+ ("b\\" . ("⧅"))+ ("b*" . ("⧆"))+ ("bo" . ("⧇"))+ ("bsq" . ("⧈"))++ ;; APL boxed operators.++ ("box=" . ("⌸"))+ ("box?" . ("⍰"))+ ("box'" . ("⍞"))+ ("box:" . ("⍠"))+ ("box/" . ("⍁"))+ ("box\\" . ("⍂"))+ ("box<" . ("⍃"))+ ("box>" . ("⍄"))+ ("boxo" . ("⌻"))+ ("boxO" . ("⌼"))++ ("boxcomp" . ("⌻"))+ ("boxcircle" . ("⌼"))+ ("boxeq" . ("⌸"))+ ("boxneq" . ("⍯"))+ ("boxeqn" . ("⍯"))++ ("boxl" . ("⍇"))+ ("boxr" . ("⍈"))+ ("boxu" . ("⍐"))+ ("boxd" . ("⍗"))++ ("boxdi" . ("⌺"))+ ("boxdiv" . ("⌹"))+ ("boxwedge" . ("⍓"))+ ("boxvee" . ("⍌"))+ ("boxdelta" . ("⍍"))+ ("boxnabla" . ("⍔"))++ ;; Various symbols.++ ("integral" . ,(agda-input-to-string-list "∫∬∭∮∯∰∱∲∳"))+ ("angle" . ,(agda-input-to-string-list "∟∡∢⊾⊿"))+ ("join" . ,(agda-input-to-string-list "⋈⋉⋊⋋⋌⨝⟕⟖⟗"))+ ("esh" . ("ʃ"))++ ;; Arrows.++ ("l" . ,(agda-input-to-string-list "←⇐⇚⭅⇇⇆↤⇦↞↼↽⇠⇺↜⇽⟵⟸↚⇍⇷ ↹ ↢↩↫⇋⇜⇤⟻⟽⤆↶↺⟲ "))+ ("r" . ,(agda-input-to-string-list "→⇒⇛⭆⇉⇄↦⇨↠⇀⇁⇢⇻↝⇾⟶⟹↛⇏⇸⇶ ↴ ↣↪↬⇌⇝⇥⟼⟾⤇↷↻⟳⇰⇴⟴⟿ ➵➸➙➔➛➜➝➞➟➠➡➢➣➤➧➨➩➪➫➬➭➮➯➱➲➳➺➻➼➽➾⊸"))+ ("u" . ,(agda-input-to-string-list "↑⇑⤊⟰⇈⇅↥⇧↟↿↾⇡⇞ ↰↱➦ ⇪⇫⇬⇭⇮⇯ "))+ ("d" . ,(agda-input-to-string-list "↓⇓⤋⟱⇊⇵↧⇩↡⇃⇂⇣⇟ ↵↲↳➥ ↯ "))+ ("ud" . ,(agda-input-to-string-list "↕⇕ ↨⇳ "))+ ("lr" . ,(agda-input-to-string-list "↔⇔ ⇼↭⇿⟷⟺↮⇎⇹ "))+ ("ul" . ,(agda-input-to-string-list "↖⇖ ⇱↸ "))+ ("ur" . ,(agda-input-to-string-list "↗⇗ ➶➹➚ "))+ ("dr" . ,(agda-input-to-string-list "↘⇘ ⇲ ➴➷➘ "))+ ("dl" . ,(agda-input-to-string-list "↙⇙ "))++ ("l-" . ("←")) ("<-" . ("←")) ("l=" . ("⇐")) ("<=" . ("⇐"))+ ("r-" . ("→")) ("->" . ("→")) ("r=" . ("⇒")) ("=>" . ("⇒"))+ ("u-" . ("↑")) ("u=" . ("⇑"))+ ("d-" . ("↓")) ("d=" . ("⇓"))+ ("ud-" . ("↕")) ("ud=" . ("⇕"))+ ("lr-" . ("↔")) ("<->" . ("↔")) ("lr=" . ("⇔")) ("<=>" . ("⇔"))+ ("ul-" . ("↖")) ("ul=" . ("⇖"))+ ("ur-" . ("↗")) ("ur=" . ("⇗"))+ ("dr-" . ("↘")) ("dr=" . ("⇘"))+ ("dl-" . ("↙")) ("dl=" . ("⇙"))++ ("l==" . ("⇚")) ("l-2" . ("⇇")) ("l-r-" . ("⇆"))+ ("r==" . ("⇛")) ("r-2" . ("⇉")) ("r-3" . ("⇶")) ("r-l-" . ("⇄"))+ ("u==" . ("⟰")) ("u-2" . ("⇈")) ("u-d-" . ("⇅"))+ ("d==" . ("⟱")) ("d-2" . ("⇊")) ("d-u-" . ("⇵"))++ ("l--" . ("⟵")) ("<--" . ("⟵")) ("l~" . ("↜" "⇜"))+ ("r--" . ("⟶")) ("-->" . ("⟶")) ("r~" . ("↝" "⇝" "⟿"))+ ("lr--" . ("⟷")) ("<-->" . ("⟷")) ("lr~" . ("↭"))++ ("l-n" . ("↚")) ("<-n" . ("↚")) ("l=n" . ("⇍"))+ ("r-n" . ("↛")) ("->n" . ("↛")) ("r=n" . ("⇏")) ("=>n" . ("⇏"))+ ("lr-n" . ("↮")) ("<->n" . ("↮")) ("lr=n" . ("⇎")) ("<=>n" . ("⇎"))++ ("l-|" . ("↤")) ("ll-" . ("↞"))+ ("r-|" . ("↦")) ("rr-" . ("↠"))+ ("u-|" . ("↥")) ("uu-" . ("↟"))+ ("d-|" . ("↧")) ("dd-" . ("↡"))+ ("ud-|" . ("↨"))++ ("l->" . ("↢"))+ ("r->" . ("↣"))++ ("r-o" . ("⊸")) ("-o" . ("⊸"))+ ("l-o" . ("⟜"))++ ("dz" . ("↯"))++ ;; Ellipsis.++ ("..." . ,(agda-input-to-string-list "⋯⋮⋰⋱"))++ ;; Box-drawing characters.++ ("---" . ,(agda-input-to-string-list "─│┌┐└┘├┤┬┼┴╴╵╶╷╭╮╯╰╱╲╳"))+ ("--=" . ,(agda-input-to-string-list "═║╔╗╚╝╠╣╦╬╩ ╒╕╘╛╞╡╤╪╧ ╓╖╙╜╟╢╥╫╨"))+ ("--_" . ,(agda-input-to-string-list "━┃┏┓┗┛┣┫┳╋┻╸╹╺╻+ ┍┯┑┕┷┙┝┿┥┎┰┒┖┸┚┠╂┨┞╀┦┟╁┧┢╈┪┡╇┩+ ┮┭┶┵┾┽┲┱┺┹╊╉╆╅╄╃ ╿╽╼╾"))+ ("--." . ,(agda-input-to-string-list "╌╎┄┆┈┊+ ╍╏┅┇┉┋"))++ ;; Triangles.++ ;; Big/small, black/white.++ ("t" . ,(agda-input-to-string-list "◂◃◄◅▸▹►▻▴▵▾▿◢◿◣◺◤◸◥◹"))+ ("T" . ,(agda-input-to-string-list "◀◁▶▷▲△▼▽◬◭◮"))++ ("tb" . ,(agda-input-to-string-list "◂▸▴▾◄►◢◣◤◥"))+ ("tw" . ,(agda-input-to-string-list "◃▹▵▿◅▻◿◺◸◹"))++ ("Tb" . ,(agda-input-to-string-list "◀▶▲▼"))+ ("Tw" . ,(agda-input-to-string-list "◁▷△▽"))++ ;; Squares.++ ("sq" . ,(agda-input-to-string-list "■□◼◻◾◽▣▢▤▥▦▧▨▩◧◨◩◪◫◰◱◲◳"))+ ("sqb" . ,(agda-input-to-string-list "■◼◾"))+ ("sqw" . ,(agda-input-to-string-list "□◻◽"))+ ("sq." . ("▣"))+ ("sqo" . ("▢"))++ ;; Rectangles.++ ("re" . ,(agda-input-to-string-list "▬▭▮▯"))+ ("reb" . ,(agda-input-to-string-list "▬▮"))+ ("rew" . ,(agda-input-to-string-list "▭▯"))++ ;; Parallelograms.++ ("pa" . ,(agda-input-to-string-list "▰▱"))+ ("pab" . ("▰"))+ ("paw" . ("▱"))++ ;; Diamonds.++ ("di" . ,(agda-input-to-string-list "◆◇◈"))+ ("dib" . ("◆"))+ ("diw" . ("◇"))+ ("di." . ("◈"))++ ;; Circles.++ ("ci" . ,(agda-input-to-string-list "●○◎◌◯◍◐◑◒◓◔◕◖◗◠◡◴◵◶◷⚆⚇⚈⚉"))+ ("cib" . ("●"))+ ("ciw" . ("○"))+ ("ci." . ("◎"))+ ("ci.." . ("◌"))+ ("ciO" . ("◯"))++ ;; Stars.++ ("st" . ,(agda-input-to-string-list "⋆✦✧✶✴✹ ★☆✪✫✯✰✵✷✸"))+ ("st4" . ,(agda-input-to-string-list "✦✧"))+ ("st6" . ("✶"))+ ("st8" . ("✴"))+ ("st12" . ("✹"))++ ;; Blackboard bold letters.++ ("bA" . ("𝔸"))+ ("bB" . ("𝔹"))+ ("bC" . ("ℂ"))+ ("bD" . ("𝔻"))+ ("bE" . ("𝔼"))+ ("bF" . ("𝔽"))+ ("bG" . ("𝔾"))+ ("bH" . ("ℍ"))+ ("bI" . ("𝕀"))+ ("bJ" . ("𝕁"))+ ("bK" . ("𝕂"))+ ("bL" . ("𝕃"))+ ("bM" . ("𝕄"))+ ("bN" . ("ℕ"))+ ("bO" . ("𝕆"))+ ("bP" . ("ℙ"))+ ("bQ" . ("ℚ"))+ ("bR" . ("ℝ"))+ ("bS" . ("𝕊"))+ ("bT" . ("𝕋"))+ ("bU" . ("𝕌"))+ ("bV" . ("𝕍"))+ ("bW" . ("𝕎"))+ ("bX" . ("𝕏"))+ ("bY" . ("𝕐"))+ ("bZ" . ("ℤ"))+ ("bGG" . ("ℾ"))+ ("bGP" . ("ℿ"))+ ("bGS" . ("⅀"))+ ("ba" . ("𝕒"))+ ("bb" . ("𝕓"))+ ("bc" . ("𝕔"))+ ("bd" . ("𝕕"))+ ("be" . ("𝕖"))+ ("bf" . ("𝕗"))+ ("bg" . ("𝕘"))+ ("bh" . ("𝕙"))+ ("bi" . ("𝕚"))+ ("bj" . ("𝕛"))+ ("bk" . ("𝕜"))+ ("bl" . ("𝕝"))+ ("bm" . ("𝕞"))+ ("bn" . ("𝕟"))+ ("bo" . ("𝕠"))+ ("bp" . ("𝕡"))+ ("bq" . ("𝕢"))+ ("br" . ("𝕣"))+ ("bs" . ("𝕤"))+ ("bt" . ("𝕥"))+ ("bu" . ("𝕦"))+ ("bv" . ("𝕧"))+ ("bw" . ("𝕨"))+ ("bx" . ("𝕩"))+ ("by" . ("𝕪"))+ ("bz" . ("𝕫"))+ ("bGg" . ("ℽ"))+ ("bGp" . ("ℼ"))++ ;; Blackboard bold numbers.++ ("b0" . ("𝟘"))+ ("b1" . ("𝟙"))+ ("b2" . ("𝟚"))+ ("b3" . ("𝟛"))+ ("b4" . ("𝟜"))+ ("b5" . ("𝟝"))+ ("b6" . ("𝟞"))+ ("b7" . ("𝟟"))+ ("b8" . ("𝟠"))+ ("b9" . ("𝟡"))++ ;; Mathematical bold letters.++ ("BA" . ("𝐀"))+ ("BB" . ("𝐁"))+ ("BC" . ("𝐂"))+ ("BD" . ("𝐃"))+ ("BE" . ("𝐄"))+ ("BF" . ("𝐅"))+ ("BG" . ("𝐆"))+ ("BH" . ("𝐇"))+ ("BI" . ("𝐈"))+ ("BJ" . ("𝐉"))+ ("BK" . ("𝐊"))+ ("BL" . ("𝐋"))+ ("BM" . ("𝐌"))+ ("BN" . ("𝐍"))+ ("BO" . ("𝐎"))+ ("BP" . ("𝐏"))+ ("BQ" . ("𝐐"))+ ("BR" . ("𝐑"))+ ("BS" . ("𝐒"))+ ("BT" . ("𝐓"))+ ("BU" . ("𝐔"))+ ("BV" . ("𝐕"))+ ("BW" . ("𝐖"))+ ("BX" . ("𝐗"))+ ("BY" . ("𝐘"))+ ("BZ" . ("𝐙"))+ ("Ba" . ("𝐚"))+ ("Bb" . ("𝐛"))+ ("Bc" . ("𝐜"))+ ("Bd" . ("𝐝"))+ ("Be" . ("𝐞"))+ ("Bf" . ("𝐟"))+ ("Bg" . ("𝐠"))+ ("Bh" . ("𝐡"))+ ("Bi" . ("𝐢"))+ ("Bj" . ("𝐣"))+ ("Bk" . ("𝐤"))+ ("Bl" . ("𝐥"))+ ("Bm" . ("𝐦"))+ ("Bn" . ("𝐧"))+ ("Bo" . ("𝐨"))+ ("Bp" . ("𝐩"))+ ("Bq" . ("𝐪"))+ ("Br" . ("𝐫"))+ ("Bs" . ("𝐬"))+ ("Bt" . ("𝐭"))+ ("Bu" . ("𝐮"))+ ("Bv" . ("𝐯"))+ ("Bw" . ("𝐰"))+ ("Bx" . ("𝐱"))+ ("By" . ("𝐲"))+ ("Bz" . ("𝐳"))++ ;; Mathematical bold Greek letters.++ ("BGA" . ("𝚨"))+ ("BGB" . ("𝚩"))+ ("BGC" . ("𝚾"))+ ("BGD" . ("𝚫"))+ ("BGE" . ("𝚬"))+ ("BGG" . ("𝚪"))+ ("BGH" . ("𝚮"))+ ("BGI" . ("𝚰"))+ ("BGK" . ("𝚱"))+ ("BGL" . ("𝚲"))+ ("BGM" . ("𝚳"))+ ("BGN" . ("𝚴"))+ ("BGO" . ("𝛀"))+ ("BOmicron" . ("𝚶"))+ ("BGF" . ("𝚽"))+ ("BPi" . ("𝚷"))+ ("BGP" . ("𝚿"))+ ("BGR" . ("𝚸"))+ ("BGS" . ("𝚺"))+ ("BGT" . ("𝚻"))+ ("BGTH" . ("𝚯"))+ ("BGU" . ("𝚼"))+ ("BGX" . ("𝚵"))+ ("BGZ" . ("𝚭"))+ ("BGa" . ("𝛂"))+ ("BGb" . ("𝛃"))+ ("BGc" . ("𝛘"))+ ("BGd" . ("𝛅"))+ ("BGe" . ("𝛆"))+ ("BGg" . ("𝛄"))+ ("BGh" . ("𝛈"))+ ("BGi" . ("𝛊"))+ ("BGk" . ("𝛋"))+ ("BGl" . ("𝛌"))+ ("BGm" . ("𝛍"))+ ("BGn" . ("𝛎"))+ ("BGo" . ("𝛚"))+ ("Bomicron" . ("𝛐"))+ ("BGf" . ("𝛗"))+ ("Bpi" . ("𝛑"))+ ("BGp" . ("𝛙"))+ ("BGr" . ("𝛒"))+ ("BGs" . ("𝛔"))+ ("BGt" . ("𝛕"))+ ("BGth" . ("𝛉"))+ ("BGu" . ("𝛖"))+ ("BGx" . ("𝛏"))+ ("BGz" . ("𝛇"))++ ;; Mathematical bold digits.++ ("B0" . ("𝟎"))+ ("B1" . ("𝟏"))+ ("B2" . ("𝟐"))+ ("B3" . ("𝟑"))+ ("B4" . ("𝟒"))+ ("B5" . ("𝟓"))+ ("B6" . ("𝟔"))+ ("B7" . ("𝟕"))+ ("B8" . ("𝟖"))+ ("B9" . ("𝟗"))++ ;; Fullwidth letters.++ ("FA" . ("A"))+ ("FB" . ("B"))+ ("FC" . ("C"))+ ("FD" . ("D"))+ ("FE" . ("E"))+ ("FF" . ("F"))+ ("FG" . ("G"))+ ("FH" . ("H"))+ ("FI" . ("I"))+ ("FJ" . ("J"))+ ("FK" . ("K"))+ ("FL" . ("L"))+ ("FM" . ("M"))+ ("FN" . ("N"))+ ("FO" . ("O"))+ ("FP" . ("P"))+ ("FQ" . ("Q"))+ ("FR" . ("R"))+ ("FS" . ("S"))+ ("FT" . ("T"))+ ("FU" . ("U"))+ ("FV" . ("V"))+ ("FW" . ("W"))+ ("FX" . ("X"))+ ("FY" . ("Y"))+ ("FZ" . ("Z"))+ ("Fa" . ("a"))+ ("Fb" . ("b"))+ ("Fc" . ("c"))+ ("Fd" . ("d"))+ ("Fe" . ("e"))+ ("Ff" . ("f"))+ ("Fg" . ("g"))+ ("Fh" . ("h"))+ ("Fi" . ("i"))+ ("Fj" . ("j"))+ ("Fk" . ("k"))+ ("Fl" . ("l"))+ ("Fm" . ("m"))+ ("Fn" . ("n"))+ ("Fo" . ("o"))+ ("Fp" . ("p"))+ ("Fq" . ("q"))+ ("Fr" . ("r"))+ ("Fs" . ("s"))+ ("Ft" . ("t"))+ ("Fu" . ("u"))+ ("Fv" . ("v"))+ ("Fw" . ("w"))+ ("Fx" . ("x"))+ ("Fy" . ("y"))+ ("Fz" . ("z"))++ ;; Fullwidth digits.++ ("F0" . ("0"))+ ("F1" . ("1"))+ ("F2" . ("2"))+ ("F3" . ("3"))+ ("F4" . ("4"))+ ("F5" . ("5"))+ ("F6" . ("6"))+ ("F7" . ("7"))+ ("F8" . ("8"))+ ("F9" . ("9"))++ ;; Fullwidth symbols.++ ("F!" . ("!"))+ ("F\"" . ("""))+ ("F#" . ("#"))+ ("F$" . ("$"))+ ("F%" . ("%"))+ ("F&" . ("&"))+ ("F'" . ("'"))+ ("F(" . ("("))+ ("F)" . (")"))+ ("F*" . ("*"))+ ("F+" . ("+"))+ ("F," . (","))+ ("F-" . ("-"))+ ("F." . ("."))+ ("F/" . ("/"))+ ("F:" . (":"))+ ("F;" . (";"))+ ("F<" . ("<"))+ ("F=" . ("="))+ ("F>" . (">"))+ ("F?" . ("?"))+ ("F@" . ("@"))+ ("F[" . ("["))+ ("F\\" . ("\"))+ ("F]" . ("]"))+ ("F_" . ("_"))+ ("F{" . ("{"))+ ("F|" . ("|"))+ ("F}" . ("}"))+ ("F~" . ("~"))+ ("F((" . ("⦅"))+ ("F))" . ("⦆"))+ ("Fneg" . ("¬"))++ ;; Parentheses.++ ("(" . ,(agda-input-to-string-list "([{⁅⁽₍〈⎴⟅⟦⟨⟪⦃〈《「『【〔〖〚︵︷︹︻︽︿﹁﹃﹙﹛﹝([{「❪❬❰❲❴⟮⦅⦗⧼⸨❮⦇⦉"))+ (")" . ,(agda-input-to-string-list ")]}⁆⁾₎〉⎵⟆⟧⟩⟫⦄〉》」』】〕〗〛︶︸︺︼︾﹀﹂﹄﹚﹜﹞)]}」❫❭❱❳❵⟯⦆⦘⧽⸩❯⦈⦊"))++ ("[[" . ("⟦"))+ ("]]" . ("⟧"))+ ("<" . ,(agda-input-to-string-list "⟨<≪⋘≺⊂⋐⊏⊰⊲⋖<"))+ (">" . ,(agda-input-to-string-list "⟩>≫⋙≻⊃⋑⊐⊱⊳⋗>"))+ ("<<" . ("⟪"))+ (">>" . ("⟫"))+ ("{{" . ("⦃"))+ ("}}" . ("⦄"))++ ("(b" . ("⟅"))+ (")b" . ("⟆"))++ ("lbag" . ("⟅"))+ ("rbag" . ("⟆"))++ ("<|" . ("⦉")) ;; Angle bar brackets+ ("|>" . ("⦊"))++ ("(|" . ("⦇")) ;; Idiom brackets+ ("|)" . ("⦈"))++ ("((" . ,(agda-input-to-string-list "⦅⦅")) ;; Banana brackets+ ("))" . ,(agda-input-to-string-list "⦆⦆"))++ ;; Primes.++ ("'" . ,(agda-input-to-string-list "′″‴⁗'"))+ ("`" . ,(agda-input-to-string-list "‵‶‷`"))++ ;; Fractions.++ ("frac" . ,(agda-input-to-string-list "¼½¾⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟"))++ ;; Bullets.++ ("bu" . ,(agda-input-to-string-list "•◦‣⁌⁍"))+ ("bub" . ("•"))+ ("buw" . ("◦"))+ ("but" . ("‣"))++ ;; Musical symbols.++ ("note" . ,(agda-input-to-string-list "♩♪♫♬"))+ ("b" . ("♭"))+ ("#" . ("♯"))+ ("bb" . ("𝄫"))+ ("##" . ("𝄪"))++ ;; Other punctuation and symbols.++ ("\\" . ("\\"))+ ("en" . ("–"))+ ("em" . ("—"))+ ("!" . ("!"))+ ("!!" . ("‼"))+ ("?" . ("?"))+ ("??" . ("⁇"))+ ("?!" . ("‽" "⁈"))+ ("!?" . ("⁉"))+ ("die" . ,(agda-input-to-string-list "⚀⚁⚂⚃⚄⚅"))+ ("asterisk" . ,(agda-input-to-string-list "⁎⁑⁂✢✣✤✥✱✲✳✺✻✼✽❃❉❊❋*"))+ ("8<" . ("✂" "✄"))+ ("tie" . ("⁀"))+ ("undertie" . ("‿"))+ ("apl" . ,(agda-input-to-string-list "⌶⌷⌸⌹⌺⌻⌼⌽⌾⌿⍀⍁⍂⍃⍄⍅⍆⍇⍈+ ⍉⍊⍋⍌⍍⍎⍏⍐⍑⍒⍓⍔⍕⍖⍗⍘⍙⍚⍛+ ⍜⍝⍞⍟⍠⍡⍢⍣⍤⍥⍦⍧⍨⍩⍪⍫⍬⍭⍮+ ⍯⍰⍱⍲⍳⍴⍵⍶⍷⍸⍹⍺⎕"))+ ("#" . ("#"))+ ("%" . ("%"))+ ("&" . ("&"))+ ("*" . ("*"))+ ("/" . ,(agda-input-to-string-list "/\"))+ ("@" . ("@"))+ ("__" . ("_"))+ ("\"" . ("""))+ ("crossmark" . ("✗"))++ ;; Some combining characters.+ ;;+ ;; The following combining characters also have (other)+ ;; translations:+ ;;++ ("^--" . ,(agda-input-to-string-list"̅̿"))+ ("_--" . ,(agda-input-to-string-list"̲̳"))+ ("^~" . ,(agda-input-to-string-list"̃͌"))+ ("_~" . ( "̰"))+ ("^." . ,(agda-input-to-string-list"̇̈⃛⃜"))+ ("_." . ,(agda-input-to-string-list"̣̤"))+ ("^l" . ,(agda-input-to-string-list"⃖⃐⃔"))+ ("^l-" . ( "⃖"))+ ("^r" . ,(agda-input-to-string-list"⃗⃑⃕"))+ ("^r-" . ( "⃗"))+ ("^lr" . ( "⃡"))+ ("_lr" . ( "͍"))+ ("^^" . ,(agda-input-to-string-list"̂̑͆"))+ ("_^" . ,(agda-input-to-string-list"̭̯̪"))+ ("^v" . ,(agda-input-to-string-list"̌̆"))+ ("_v" . ,(agda-input-to-string-list"̬̮̺"))++ ;; Shorter forms of many greek letters plus ƛ.++ ("Ga" . ("α")) ("GA" . ("Α"))+ ("Gb" . ("β")) ("GB" . ("Β"))+ ("Gg" . ("γ")) ("GG" . ("Γ"))+ ("Gd" . ("δ")) ("GD" . ("Δ"))+ ("Ge" . ("ε")) ("GE" . ("Ε"))+ ("Gz" . ("ζ")) ("GZ" . ("Ζ"))+ ("Gh" . ("η")) ("GH" . ("Η"))+ ("Gth" . ("θ")) ("GTH" . ("Θ"))+ ("Gi" . ("ι")) ("GI" . ("Ι"))+ ("Gk" . ("κ")) ("GK" . ("Κ"))+ ("Gl" . ("λ")) ("GL" . ("Λ")) ("Gl-" . ("ƛ"))+ ("Gm" . ("μ")) ("GM" . ("Μ"))+ ("Gn" . ("ν")) ("GN" . ("Ν"))+ ("Gx" . ("ξ")) ("GX" . ("Ξ"))+ ;; \omicron \Omicron+ ;; \pi \Pi+ ("Gr" . ("ρ")) ("GR" . ("Ρ"))+ ("Gs" . ("σ")) ("GS" . ("Σ"))+ ("Gt" . ("τ")) ("GT" . ("Τ"))+ ("Gu" . ("υ")) ("GU" . ("Υ"))+ ("Gf" . ("φ")) ("GF" . ("Φ"))+ ("Gc" . ("χ")) ("GC" . ("Χ"))+ ("Gp" . ("ψ")) ("GP" . ("Ψ"))+ ("Go" . ("ω")) ("GO" . ("Ω"))++ ;; Mathematical characters.++ ("MiA" . ("𝐴"))+ ("MiB" . ("𝐵"))+ ("MiC" . ("𝐶"))+ ("MiD" . ("𝐷"))+ ("MiE" . ("𝐸"))+ ("MiF" . ("𝐹"))+ ("MiG" . ("𝐺"))+ ("MiH" . ("𝐻"))+ ("MiI" . ("𝐼"))+ ("MiJ" . ("𝐽"))+ ("MiK" . ("𝐾"))+ ("MiL" . ("𝐿"))+ ("MiM" . ("𝑀"))+ ("MiN" . ("𝑁"))+ ("MiO" . ("𝑂"))+ ("MiP" . ("𝑃"))+ ("MiQ" . ("𝑄"))+ ("MiR" . ("𝑅"))+ ("MiS" . ("𝑆"))+ ("MiT" . ("𝑇"))+ ("MiU" . ("𝑈"))+ ("MiV" . ("𝑉"))+ ("MiW" . ("𝑊"))+ ("MiX" . ("𝑋"))+ ("MiY" . ("𝑌"))+ ("MiZ" . ("𝑍"))+ ("Mia" . ("𝑎"))+ ("Mib" . ("𝑏"))+ ("Mic" . ("𝑐"))+ ("Mid" . ("𝑑"))+ ("Mie" . ("𝑒"))+ ("Mif" . ("𝑓"))+ ("Mig" . ("𝑔"))+ ("Mih" . ("ℎ"))+ ("Mii" . ("𝑖"))+ ("Mij" . ("𝑗"))+ ("Mik" . ("𝑘"))+ ("Mil" . ("𝑙"))+ ("Mim" . ("𝑚"))+ ("Min" . ("𝑛"))+ ("Mio" . ("𝑜"))+ ("Mip" . ("𝑝"))+ ("Miq" . ("𝑞"))+ ("Mir" . ("𝑟"))+ ("Mis" . ("𝑠"))+ ("Mit" . ("𝑡"))+ ("Miu" . ("𝑢"))+ ("Miv" . ("𝑣"))+ ("Miw" . ("𝑤"))+ ("Mix" . ("𝑥"))+ ("Miy" . ("𝑦"))+ ("Miz" . ("𝑧"))++ ("MIA" . ("𝑨"))+ ("MIB" . ("𝑩"))+ ("MIC" . ("𝑪"))+ ("MID" . ("𝑫"))+ ("MIE" . ("𝑬"))+ ("MIF" . ("𝑭"))+ ("MIG" . ("𝑮"))+ ("MIH" . ("𝑯"))+ ("MII" . ("𝑰"))+ ("MIJ" . ("𝑱"))+ ("MIK" . ("𝑲"))+ ("MIL" . ("𝑳"))+ ("MIM" . ("𝑴"))+ ("MIN" . ("𝑵"))+ ("MIO" . ("𝑶"))+ ("MIP" . ("𝑷"))+ ("MIQ" . ("𝑸"))+ ("MIR" . ("𝑹"))+ ("MIS" . ("𝑺"))+ ("MIT" . ("𝑻"))+ ("MIU" . ("𝑼"))+ ("MIV" . ("𝑽"))+ ("MIW" . ("𝑾"))+ ("MIX" . ("𝑿"))+ ("MIY" . ("𝒀"))+ ("MIZ" . ("𝒁"))++ ("MIa" . ("𝒂"))+ ("MIb" . ("𝒃"))+ ("MIc" . ("𝒄"))+ ("MId" . ("𝒅"))+ ("MIe" . ("𝒆"))+ ("MIf" . ("𝒇"))+ ("MIg" . ("𝒈"))+ ("MIh" . ("𝒉"))+ ("MIi" . ("𝒊"))+ ("MIj" . ("𝒋"))+ ("MIk" . ("𝒌"))+ ("MIl" . ("𝒍"))+ ("MIm" . ("𝒎"))+ ("MIn" . ("𝒏"))+ ("MIo" . ("𝒐"))+ ("MIp" . ("𝒑"))+ ("MIq" . ("𝒒"))+ ("MIr" . ("𝒓"))+ ("MIs" . ("𝒔"))+ ("MIt" . ("𝒕"))+ ("MIu" . ("𝒖"))+ ("MIv" . ("𝒗"))+ ("MIw" . ("𝒘"))+ ("MIx" . ("𝒙"))+ ("MIy" . ("𝒚"))+ ("MIz" . ("𝒛"))++ ("McA" . ("𝒜"))+ ("McB" . ("ℬ"))+ ("McC" . ("𝒞"))+ ("McD" . ("𝒟"))+ ("McE" . ("ℰ"))+ ("McF" . ("ℱ"))+ ("McG" . ("𝒢"))+ ("McH" . ("ℋ"))+ ("McI" . ("ℐ"))+ ("McJ" . ("𝒥"))+ ("McK" . ("𝒦"))+ ("McL" . ("ℒ"))+ ("McM" . ("ℳ"))+ ("McN" . ("𝒩"))+ ("McO" . ("𝒪"))+ ("McP" . ("𝒫"))+ ("McQ" . ("𝒬"))+ ("McR" . ("ℛ"))+ ("McS" . ("𝒮"))+ ("McT" . ("𝒯"))+ ("McU" . ("𝒰"))+ ("McV" . ("𝒱"))+ ("McW" . ("𝒲"))+ ("McX" . ("𝒳"))+ ("McY" . ("𝒴"))+ ("McZ" . ("𝒵"))+ ("Mca" . ("𝒶"))+ ("Mcb" . ("𝒷"))+ ("Mcc" . ("𝒸"))+ ("Mcd" . ("𝒹"))+ ("Mce" . ("ℯ"))+ ("Mcf" . ("𝒻"))+ ("Mcg" . ("ℊ"))+ ("Mch" . ("𝒽"))+ ("Mci" . ("𝒾"))+ ("Mcj" . ("𝒿"))+ ("Mck" . ("𝓀"))+ ("Mcl" . ("𝓁"))+ ("Mcm" . ("𝓂"))+ ("Mcn" . ("𝓃"))+ ("Mco" . ("ℴ"))+ ("Mcp" . ("𝓅"))+ ("Mcq" . ("𝓆"))+ ("Mcr" . ("𝓇"))+ ("Mcs" . ("𝓈"))+ ("Mct" . ("𝓉"))+ ("Mcu" . ("𝓊"))+ ("Mcv" . ("𝓋"))+ ("Mcw" . ("𝓌"))+ ("Mcx" . ("𝓍"))+ ("Mcy" . ("𝓎"))+ ("Mcz" . ("𝓏"))++ ("MCA" . ("𝓐"))+ ("MCB" . ("𝓑"))+ ("MCC" . ("𝓒"))+ ("MCD" . ("𝓓"))+ ("MCE" . ("𝓔"))+ ("MCF" . ("𝓕"))+ ("MCG" . ("𝓖"))+ ("MCH" . ("𝓗"))+ ("MCI" . ("𝓘"))+ ("MCJ" . ("𝓙"))+ ("MCK" . ("𝓚"))+ ("MCL" . ("𝓛"))+ ("MCM" . ("𝓜"))+ ("MCN" . ("𝓝"))+ ("MCO" . ("𝓞"))+ ("MCP" . ("𝓟"))+ ("MCQ" . ("𝓠"))+ ("MCR" . ("𝓡"))+ ("MCS" . ("𝓢"))+ ("MCT" . ("𝓣"))+ ("MCU" . ("𝓤"))+ ("MCV" . ("𝓥"))+ ("MCW" . ("𝓦"))+ ("MCX" . ("𝓧"))+ ("MCY" . ("𝓨"))+ ("MCZ" . ("𝓩"))+ ("MCa" . ("𝓪"))+ ("MCb" . ("𝓫"))+ ("MCc" . ("𝓬"))+ ("MCd" . ("𝓭"))+ ("MCe" . ("𝓮"))+ ("MCf" . ("𝓯"))+ ("MCg" . ("𝓰"))+ ("MCh" . ("𝓱"))+ ("MCi" . ("𝓲"))+ ("MCj" . ("𝓳"))+ ("MCk" . ("𝓴"))+ ("MCl" . ("𝓵"))+ ("MCm" . ("𝓶"))+ ("MCn" . ("𝓷"))+ ("MCo" . ("𝓸"))+ ("MCp" . ("𝓹"))+ ("MCq" . ("𝓺"))+ ("MCr" . ("𝓻"))+ ("MCs" . ("𝓼"))+ ("MCt" . ("𝓽"))+ ("MCu" . ("𝓾"))+ ("MCv" . ("𝓿"))+ ("MCw" . ("𝔀"))+ ("MCx" . ("𝔁"))+ ("MCy" . ("𝔂"))+ ("MCz" . ("𝔃"))++ ("MfA" . ("𝔄"))+ ("MfB" . ("𝔅"))+ ("MfC" . ("ℭ"))+ ("MfD" . ("𝔇"))+ ("MfE" . ("𝔈"))+ ("MfF" . ("𝔉"))+ ("MfG" . ("𝔊"))+ ("MfH" . ("ℌ"))+ ("MfI" . ("ℑ"))+ ("MfJ" . ("𝔍"))+ ("MfK" . ("𝔎"))+ ("MfL" . ("𝔏"))+ ("MfM" . ("𝔐"))+ ("MfN" . ("𝔑"))+ ("MfO" . ("𝔒"))+ ("MfP" . ("𝔓"))+ ("MfQ" . ("𝔔"))+ ("MfR" . ("ℜ"))+ ("MfS" . ("𝔖"))+ ("MfT" . ("𝔗"))+ ("MfU" . ("𝔘"))+ ("MfV" . ("𝔙"))+ ("MfW" . ("𝔚"))+ ("MfX" . ("𝔛"))+ ("MfY" . ("𝔜"))+ ("MfZ" . ("ℨ"))+ ("Mfa" . ("𝔞"))+ ("Mfb" . ("𝔟"))+ ("Mfc" . ("𝔠"))+ ("Mfd" . ("𝔡"))+ ("Mfe" . ("𝔢"))+ ("Mff" . ("𝔣"))+ ("Mfg" . ("𝔤"))+ ("Mfh" . ("𝔥"))+ ("Mfi" . ("𝔦"))+ ("Mfj" . ("𝔧"))+ ("Mfk" . ("𝔨"))+ ("Mfl" . ("𝔩"))+ ("Mfm" . ("𝔪"))+ ("Mfn" . ("𝔫"))+ ("Mfo" . ("𝔬"))+ ("Mfp" . ("𝔭"))+ ("Mfq" . ("𝔮"))+ ("Mfr" . ("𝔯"))+ ("Mfs" . ("𝔰"))+ ("Mft" . ("𝔱"))+ ("Mfu" . ("𝔲"))+ ("Mfv" . ("𝔳"))+ ("Mfw" . ("𝔴"))+ ("Mfx" . ("𝔵"))+ ("Mfy" . ("𝔶"))+ ("Mfz" . ("𝔷"))++ ("MFA" . ("𝕬"))+ ("MFB" . ("𝕭"))+ ("MFC" . ("𝕮"))+ ("MFD" . ("𝕯"))+ ("MFE" . ("𝕰"))+ ("MFF" . ("𝕱"))+ ("MFG" . ("𝕲"))+ ("MFH" . ("𝕳"))+ ("MFI" . ("𝕴"))+ ("MFJ" . ("𝕵"))+ ("MFK" . ("𝕶"))+ ("MFL" . ("𝕷"))+ ("MFM" . ("𝕸"))+ ("MFN" . ("𝕹"))+ ("MFO" . ("𝕺"))+ ("MFP" . ("𝕻"))+ ("MFQ" . ("𝕼"))+ ("MFR" . ("𝕽"))+ ("MFS" . ("𝕾"))+ ("MFT" . ("𝕿"))+ ("MFU" . ("𝖀"))+ ("MFV" . ("𝖁"))+ ("MFW" . ("𝖂"))+ ("MFX" . ("𝖃"))+ ("MFY" . ("𝖄"))+ ("MFZ" . ("𝖅"))+ ("MFa" . ("𝖆"))+ ("MFb" . ("𝖇"))+ ("MFc" . ("𝖈"))+ ("MFd" . ("𝖉"))+ ("MFe" . ("𝖊"))+ ("MFf" . ("𝖋"))+ ("MFg" . ("𝖌"))+ ("MFh" . ("𝖍"))+ ("MFi" . ("𝖎"))+ ("MFj" . ("𝖏"))+ ("MFk" . ("𝖐"))+ ("MFl" . ("𝖑"))+ ("MFm" . ("𝖒"))+ ("MFn" . ("𝖓"))+ ("MFo" . ("𝖔"))+ ("MFp" . ("𝖕"))+ ("MFq" . ("𝖖"))+ ("MFr" . ("𝖗"))+ ("MFs" . ("𝖘"))+ ("MFt" . ("𝖙"))+ ("MFu" . ("𝖚"))+ ("MFv" . ("𝖛"))+ ("MFw" . ("𝖜"))+ ("MFx" . ("𝖝"))+ ("MFy" . ("𝖞"))+ ("MFz" . ("𝖟"))++ ;; (Sub / Super) scripts.+ ;;+ ;; Unicode 12.1 omits several latin characters from sub/superscript.+ ;; https://www.quora.com/Why-is-there-no-character-for-superscript-q-in-Unicode+ ;;+ ;; Perhaps they will be added in future versions, however there are no+ ;; proposals for it currently in the pipeline:+ ;; https://www.unicode.org/alloc/Pipeline.html++ ("_a" . ("ₐ"))+ ;; ("_b" . ("b"))+ ;; ("_c" . ("c"))+ ;; ("_d" . ("d"))+ ("_e" . ("ₑ"))+ ;; ("_f" . ("f"))+ ;; ("_g" . ("g"))+ ("_h" . ("ₕ"))+ ("_i" . ("ᵢ"))+ ("_j" . ("ⱼ"))+ ("_k" . ("ₖ"))+ ("_l" . ("ₗ"))+ ("_m" . ("ₘ"))+ ("_n" . ("ₙ"))+ ("_o" . ("ₒ"))+ ("_p" . ("ₚ"))+ ;; ("_q" . ("q"))+ ("_r" . ("ᵣ"))+ ("_s" . ("ₛ"))+ ("_t" . ("ₜ"))+ ("_u" . ("ᵤ"))+ ("_v" . ("ᵥ"))+ ;; ("_w" . ("w"))+ ("_x" . ("ₓ"))+ ;; ("_y" . ("y"))+ ;; ("_z" . ("z"))++ ("_Gb" . ("ᵦ"))+ ("_Gg" . ("ᵧ"))+ ("_Gr" . ("ᵨ"))+ ("_Gf" . ("ᵩ"))+ ("_Gc" . ("ᵪ"))++ ("^a" . ("ᵃ"))+ ("^b" . ("ᵇ"))+ ("^c" . ("ᶜ"))+ ("^d" . ("ᵈ"))+ ("^e" . ("ᵉ"))+ ("^f" . ("ᶠ"))+ ("^g" . ("ᵍ"))+ ("^h" . ("ʰ"))+ ("^i" . ("ⁱ"))+ ("^j" . ("ʲ"))+ ("^k" . ("ᵏ"))+ ("^l" . ("ˡ"))+ ("^m" . ("ᵐ"))+ ("^n" . ("ⁿ"))+ ("^o" . ("ᵒ"))+ ("^p" . ("ᵖ"))+ ;; ("^q" . ("q"))+ ("^r" . ("ʳ"))+ ("^s" . ("ˢ"))+ ("^t" . ("ᵗ"))+ ("^u" . ("ᵘ"))+ ("^v" . ("ᵛ"))+ ("^w" . ("ʷ"))+ ("^x" . ("ˣ"))+ ("^y" . ("ʸ"))+ ("^z" . ("ᶻ"))++ ("^A" . ("ᴬ"))+ ("^B" . ("ᴮ"))+ ;; ("^C" . ("C"))+ ("^D" . ("ᴰ"))+ ("^E" . ("ᴱ"))+ ;; ("^F" . ("F"))+ ("^G" . ("ᴳ"))+ ("^H" . ("ᴴ"))+ ("^I" . ("ᴵ"))+ ("^J" . ("ᴶ"))+ ("^K" . ("ᴷ"))+ ("^L" . ("ᴸ"))+ ("^M" . ("ᴹ"))+ ("^N" . ("ᴺ"))+ ("^O" . ("ᴼ"))+ ("^P" . ("ᴾ"))+ ;; ("^Q" . ("Q"))+ ("^R" . ("ᴿ"))+ ;; ("^S" . ("S"))+ ("^T" . ("ᵀ"))+ ("^U" . ("ᵁ"))+ ("^V" . ("ⱽ"))+ ("^W" . ("ᵂ"))+ ;; ("^X" . ("X"))+ ;; ("^Y" . ("Y"))+ ;; ("^Z" . ("Z"))++ ("^Ga" . ("ᵅ"))+ ("^Gb" . ("ᵝ"))+ ("^Gg" . ("ᵞ"))+ ("^Gd" . ("ᵟ"))+ ("^Ge" . ("ᵋ"))+ ("^Gth" . ("ᶿ"))+ ("^Gi" . ("ᶥ"))+ ("^Gf" . ("ᵠ"))+ ("^Gc" . ("ᵡ"))++ ("^GF" . ("ᶲ"))++ ;; Some ISO8859-1 characters.++ (" " . (" "))+ ("!" . ("¡"))+ ("cent" . ("¢"))+ ("brokenbar" . ("¦"))+ ("degree" . ("°"))+ ("?" . ("¿"))+ ("^a_" . ("ª"))+ ("^o_" . ("º"))++ ;; Circled, parenthesised etc. numbers and letters.++ ( "(0)" . ,(agda-input-to-string-list " ⓪🄀⓿🄋🄌"))+ ( "(1)" . ,(agda-input-to-string-list "⑴①⒈❶➀➊"))+ ( "(2)" . ,(agda-input-to-string-list "⑵②⒉❷➁➋"))+ ( "(3)" . ,(agda-input-to-string-list "⑶③⒊❸➂➌"))+ ( "(4)" . ,(agda-input-to-string-list "⑷④⒋❹➃➍"))+ ( "(5)" . ,(agda-input-to-string-list "⑸⑤⒌❺➄➎"))+ ( "(6)" . ,(agda-input-to-string-list "⑹⑥⒍❻➅➏"))+ ( "(7)" . ,(agda-input-to-string-list "⑺⑦⒎❼➆➐"))+ ( "(8)" . ,(agda-input-to-string-list "⑻⑧⒏❽➇➑"))+ ( "(9)" . ,(agda-input-to-string-list "⑼⑨⒐❾➈➒"))+ ("(10)" . ,(agda-input-to-string-list "⑽⑩⒑❿➉➓"))+ ("(11)" . ,(agda-input-to-string-list "⑾⑪⒒⓫"))+ ("(12)" . ,(agda-input-to-string-list "⑿⑫⒓⓬"))+ ("(13)" . ,(agda-input-to-string-list "⒀⑬⒔⓭"))+ ("(14)" . ,(agda-input-to-string-list "⒁⑭⒕⓮"))+ ("(15)" . ,(agda-input-to-string-list "⒂⑮⒖⓯"))+ ("(16)" . ,(agda-input-to-string-list "⒃⑯⒗⓰"))+ ("(17)" . ,(agda-input-to-string-list "⒄⑰⒘⓱"))+ ("(18)" . ,(agda-input-to-string-list "⒅⑱⒙⓲"))+ ("(19)" . ,(agda-input-to-string-list "⒆⑲⒚⓳"))+ ("(20)" . ,(agda-input-to-string-list "⒇⑳⒛⓴"))++ ("(a)" . ,(agda-input-to-string-list "⒜Ⓐⓐ🅐🄰🅰"))+ ("(b)" . ,(agda-input-to-string-list "⒝Ⓑⓑ🅑🄱🅱"))+ ("(c)" . ,(agda-input-to-string-list "⒞Ⓒⓒ🅒🄲🅲"))+ ("(d)" . ,(agda-input-to-string-list "⒟Ⓓⓓ🅓🄳🅳"))+ ("(e)" . ,(agda-input-to-string-list "⒠Ⓔⓔ🅔🄴🅴"))+ ("(f)" . ,(agda-input-to-string-list "⒡Ⓕⓕ🅕🄵🅵"))+ ("(g)" . ,(agda-input-to-string-list "⒢Ⓖⓖ🅖🄶🅶"))+ ("(h)" . ,(agda-input-to-string-list "⒣Ⓗⓗ🅗🄷🅷"))+ ("(i)" . ,(agda-input-to-string-list "⒤Ⓘⓘ🅘🄸🅸"))+ ("(j)" . ,(agda-input-to-string-list "⒥Ⓙⓙ🅙🄹🅹"))+ ("(k)" . ,(agda-input-to-string-list "⒦Ⓚⓚ🅚🄺🅺"))+ ("(l)" . ,(agda-input-to-string-list "⒧Ⓛⓛ🅛🄻🅻"))+ ("(m)" . ,(agda-input-to-string-list "⒨Ⓜⓜ🅜🄼🅼"))+ ("(n)" . ,(agda-input-to-string-list "⒩Ⓝⓝ🅝🄽🅽"))+ ("(o)" . ,(agda-input-to-string-list "⒪Ⓞⓞ🅞🄾🅾"))+ ("(p)" . ,(agda-input-to-string-list "⒫Ⓟⓟ🅟🄿🅿"))+ ("(q)" . ,(agda-input-to-string-list "⒬Ⓠⓠ🅠🅀🆀"))+ ("(r)" . ,(agda-input-to-string-list "⒭Ⓡⓡ🅡🅁🆁"))+ ("(s)" . ,(agda-input-to-string-list "⒮Ⓢⓢ🅢🅂🆂"))+ ("(t)" . ,(agda-input-to-string-list "⒯Ⓣⓣ🅣🅃🆃"))+ ("(u)" . ,(agda-input-to-string-list "⒰Ⓤⓤ🅤🅄🆄"))+ ("(v)" . ,(agda-input-to-string-list "⒱Ⓥⓥ🅥🅅🆅"))+ ("(w)" . ,(agda-input-to-string-list "⒲Ⓦⓦ🅦🅆🆆"))+ ("(x)" . ,(agda-input-to-string-list "⒳Ⓧⓧ🅧🅇🆇"))+ ("(y)" . ,(agda-input-to-string-list "⒴Ⓨⓨ🅨🅈🆈"))+ ("(z)" . ,(agda-input-to-string-list "⒵Ⓩⓩ🅩🅉🆉"))++ ))+ "A list of translations specific to the Agda input method.+Each element is a pair (KEY-SEQUENCE-STRING . LIST-OF-TRANSLATION-STRINGS).+All the translation strings are possible translations+of the given key sequence; if there is more than one you can choose+between them using the arrow keys.++Note that if you customize this setting you will not+automatically benefit (or suffer) from modifications to its+default value when the library is updated. If you just want to+add some bindings it is probably a better idea to customize+`agda-input-user-translations'.++These translation pairs are included after those in+`agda-input-user-translations', but before the ones inherited+from other input methods (see `agda-input-inherit').++If you change this setting manually (without using the+customization buffer) you need to call `agda-input-setup' in+order for the change to take effect."+ :group 'agda-input+ :set 'agda-input-incorporate-changed-setting+ :initialize 'custom-initialize-default+ :type '(repeat (cons (string :tag "Key sequence")+ (repeat :tag "Translations" string))))++(defcustom agda-input-user-translations nil+ "Like `agda-input-translations', but more suitable for user+customizations since by default it is empty.++These translation pairs are included first, before those in+`agda-input-translations' and the ones inherited from other input+methods."+ :group 'agda-input+ :set 'agda-input-incorporate-changed-setting+ :initialize 'custom-initialize-default+ :type '(repeat (cons (string :tag "Key sequence")+ (repeat :tag "Translations" string))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Inspecting and modifying translation maps++(defun agda-input-get-translations (qp)+ "Return a list containing all translations from the Quail+package QP (except for those corresponding to ASCII).+Each pair in the list has the form (KEY-SEQUENCE . TRANSLATION)."+ (with-temp-buffer+ (activate-input-method qp) ; To make sure that the package is loaded.+ (unless (quail-package qp)+ (error "%s is not a Quail package." qp))+ (let ((decode-map (list 'decode-map)))+ (quail-build-decode-map (list (quail-map)) "" decode-map 0)+ (cdr decode-map))))++(defun agda-input-show-translations (qp)+ "Display all translations used by the Quail package QP (a string).+\(Except for those corresponding to ASCII)."+ (interactive (list (read-input-method-name+ "Quail input method (default %s): " "Agda")))+ (let ((buf (concat "*" qp " input method translations*")))+ (with-output-to-temp-buffer buf+ (with-current-buffer buf+ (quail-insert-decode-map+ (cons 'decode-map (agda-input-get-translations qp)))))))++(defun agda-input-add-translations (trans)+ "Add the given translations TRANS to the Agda input method.+TRANS is a list of pairs (KEY-SEQUENCE . TRANSLATION). The+translations are appended to the current translations."+ (with-temp-buffer+ (dolist (tr (agda-input-concat-map (eval agda-input-tweak-all) trans))+ (quail-defrule (car tr) (cdr tr) "Agda" t))))++(defun agda-input-inherit-package (qp &optional fun)+ "Let the Agda input method inherit the translations from the+Quail package QP (except for those corresponding to ASCII).++The optional function FUN can be used to modify the translations.+It is given a pair (KEY-SEQUENCE . TRANSLATION) and should return+a list of such pairs."+ (let ((trans (agda-input-get-translations qp)))+ (agda-input-add-translations+ (if fun (agda-input-concat-map fun trans)+ trans))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Setting up the input method++(defun agda-input-setup ()+ "Set up the Agda input method based on the customisable+variables and underlying input methods."++ ;; Create (or reset) the input method.+ (with-temp-buffer+ (quail-define-package "Agda" "UTF-8" "∏" t ; guidance+ "Agda input method.+The purpose of this input method is to edit Agda programs, but+since it is highly customisable it can be made useful for other+tasks as well."+ nil nil nil nil nil nil t ; maximum-shortest+ ))++ (agda-input-add-translations+ (mapcar (lambda (tr) (cons (car tr) (vconcat (cdr tr))))+ (append agda-input-user-translations+ agda-input-translations)))+ (dolist (def agda-input-inherit)+ (agda-input-inherit-package (car def)+ (eval (cdr def)))))++(defun agda-input-incorporate-changed-setting (sym val)+ "Update the Agda input method based on the customisable+variables and underlying input methods.+Suitable for use in the :set field of `defcustom'."+ (set-default sym val)+ (agda-input-setup))++;; Set up the input method.++(agda-input-setup)++;; Allow disabling resizing of the minibuffer++(defun agda-input--fix-quail-newline (arglist)+ "Argument-filtering advice for `quail-minibuffer-message'.+This function takes the argument list ARGLIST before it is+applied to `quail-minibuffer-message', and makes sure the first+and only argument has no newline. This only has an effect if the+Agda input method is active."+ (save-match-data+ (pcase arglist+ ((and `(,(and (pred stringp) prompt))+ (guard (string-match+ (rx "[" (literal (cadr (assoc "Agda" quail-package-alist))) "]" (group "\n"))+ prompt)))+ (list (replace-match " " nil nil prompt 1)))+ (_ arglist))))++(defcustom agda-input-single-line nil+ "Avoid the Agda input method from resizing the minibuffer."+ :set (lambda (var val)+ (if val+ (advice-add #'quail-minibuffer-message :filter-args+ #'agda-input--fix-quail-newline)+ (advice-remove #'quail-minibuffer-message+ #'agda-input--fix-quail-newline))+ (custom-set-default var val))+ :type 'boolean) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Administrative details
@@ -1,4 +1,6 @@+;; -*- lexical-binding: t -*- ;; agda2-abbrevs.el --- Default Agda abbrevs+;; SPDX-License-Identifier: MIT License ;;; Commentary: @@ -18,11 +20,6 @@ nil "data " _ " : Set where\n") -(define-skeleton agda2-abbrevs-codata- "Inserts a codata template."- nil- "codata " _ " : Set where\n")- (define-skeleton agda2-abbrevs-record "Inserts a record type template." nil@@ -54,13 +51,18 @@ nil "∀ {" _ "} ") +(define-skeleton agda2-abbrevs-code-block+ "Inserts a code block."+ nil+ "\\begin{code}\n " _ "\n\\end{code}\n")+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Abbrevs (defvar agda2-abbrevs-defaults '( ("m" "" agda2-abbrevs-module) ("d" "" agda2-abbrevs-data)- ("c" "" agda2-abbrevs-codata)+ ("c" "" agda2-abbrevs-code-block) ("re" "" agda2-abbrevs-record) ("rec" "" agda2-abbrevs-record-value) ("u" "" agda2-abbrevs-using)@@ -76,27 +78,27 @@ ("oi" "open import ")) "Abbreviations defined by default in the Agda mode.") +(defvar agda2-mode-abbrev-table nil "Agda mode abbrev table.")+ (defcustom agda2-mode-abbrevs-use-defaults nil "If non-nil include the default Agda mode abbrevs in `agda2-mode-abbrev-table'. The abbrevs are designed to be expanded explicitly, so users of `abbrev-mode' probably do not want to include them. -Restart Emacs in order for this change to take effect."+You do not need to restart Emacs in order for this change to take+effect, if you adjust the value using the Customize UI or a macro like+`setopt'." :group 'agda2- :type '(choice (const :tag "Yes" t)- (const :tag "No" nil)))--(defvar agda2-mode-abbrev-table nil- "Agda mode abbrev table.")--(define-abbrev-table- 'agda2-mode-abbrev-table- (if agda2-mode-abbrevs-use-defaults- (mapcar (lambda (abbrev)- (append abbrev- (make-list (- 4 (length abbrev)) nil)- '((:system t))))- agda2-abbrevs-defaults)))+ :set (lambda (sym val)+ (custom-set-default sym val)+ (define-abbrev-table+ 'agda2-mode-abbrev-table+ (and val (mapcar (lambda (abbrev)+ (append abbrev+ (make-list (- 4 (length abbrev)) nil)+ '((:system t))))+ agda2-abbrevs-defaults))))+ :type 'boolean) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Administrative details
@@ -1,4 +1,6 @@+;; -*- lexical-binding: t -*- ;;; agda2-highlight.el --- Syntax highlighting for Agda (version ≥ 2)+;; SPDX-License-Identifier: MIT License ;;; Commentary: @@ -10,11 +12,29 @@ (require 'annotation) (require 'font-lock)+(require 'agda2) (defgroup agda2-highlight nil "Syntax highlighting for Agda." :group 'agda2) +(defcustom agda2-highlight-level 'non-interactive+ "How much syntax highlighting should be produced?+Interactive highlighting includes highlighting of the expression+that is currently being type-checked."+ :type '(choice+ (const :tag "None" none)+ (const :tag "Non-interactive" non-interactive)+ (const :tag "Interactive" interactive))+ :group 'agda2-highlight)++(defun agda2-highlight-level nil+ "Formats the highlighting level in a Haskelly way."+ (cond ((equal agda2-highlight-level 'none) "None")+ ((equal agda2-highlight-level 'non-interactive) "NonInteractive")+ ((equal agda2-highlight-level 'interactive) "Interactive")+ (t "None")))+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Functions for setting faces @@ -38,25 +58,7 @@ :inherit 'unspecified :box 'unspecified :font 'unspecified)- (eval `(set-face-attribute face nil ,@attrs)))--(defvar agda2-highlight-face-attributes-list- '(:family :width :height :weight :slant :foreground :background- :inverse-video :stipple :underline :overline :strike-through- :inherit :box :font)- "The attributes considered by `agda2-highlight-face-attributes'.")--(defun agda2-highlight-face-attributes (face)- "The names and values of all attributes in FACE.-Only the attributes in `agda2-highlight-face-attributes-list' are-considered. The attributes are returned in a flat list of the-form (name1 value1 name2 value2...)."- (apply 'append- (mapcar (lambda (attr)- (let ((val (face-attribute face attr)))- (if (member val '(unspecified nil)) '()- (list attr (if (symbolp val) `',val val)))))- agda2-highlight-face-attributes-list)))+ (eval `(set-face-attribute ',face nil ,@attrs))) (defun agda2-highlight-set-faces (variable group) "Set all Agda faces according to the value of GROUP.@@ -68,134 +70,157 @@ (cond ((equal group 'conor) '((agda2-highlight-keyword-face- :underline t)- (agda2-highlight-string-face)- (agda2-highlight-number-face)- (agda2-highlight-symbol-face)+ :bold t)+ (agda2-highlight-string-face+ :foreground "firebrick3")+ (agda2-highlight-number-face+ :foreground "firebrick3")+ (agda2-highlight-symbol-face+ :foreground "grey25") (agda2-highlight-primitive-type-face- :foreground "blue")+ :foreground "medium blue") (agda2-highlight-bound-variable-face :foreground "purple")+ (agda2-highlight-generalizable-variable-face+ :foreground "purple") (agda2-highlight-inductive-constructor-face- :foreground "dark red")+ :foreground "firebrick3") (agda2-highlight-coinductive-constructor-face- :foreground "dark red")+ :foreground "firebrick3") (agda2-highlight-datatype-face- :foreground "blue")+ :foreground "medium blue") (agda2-highlight-field-face- :foreground "dark red")+ :foreground "deeppink") (agda2-highlight-function-face- :foreground "dark green")+ :foreground "darkgreen") (agda2-highlight-module-face- :foreground "dark green")+ :foreground "medium blue") (agda2-highlight-postulate-face- :foreground "dark green")+ :foreground "darkgreen") (agda2-highlight-primitive-face- :foreground "dark green")+ :foreground "darkgreen")+ (agda2-highlight-macro-face+ :foreground "aquamarine4") (agda2-highlight-record-face- :foreground "blue")+ :foreground "medium blue") (agda2-highlight-dotted-face) (agda2-highlight-error-face- :foreground "black"- :background "sandy brown")+ :foreground "red"+ :underline t)+ (agda2-highlight-error-warning-face+ :background "light coral"+ :underline t) (agda2-highlight-unsolved-meta-face :foreground "black"- :background "gold")+ :background "yellow")+ (agda2-highlight-unsolved-constraint-face+ :foreground "black"+ :background "yellow") (agda2-highlight-termination-problem-face :foreground "black"- :background "red")+ :background "light salmon")+ (agda2-highlight-positivity-problem-face+ :foreground "black"+ :background "peru") (agda2-highlight-incomplete-pattern-face :foreground "black"- :background "purple")))- ((equal group 'default-faces)+ :background "purple")+ (agda2-highlight-typechecks-face+ :foreground "black"+ :background "light blue")))+ ((equal group 'default-faces) (list (cons 'agda2-highlight-keyword-face- (agda2-highlight-face-attributes- font-lock-keyword-face))- (cons 'agda2-highlight-string-face- (agda2-highlight-face-attributes- font-lock-string-face))- (cons 'agda2-highlight-number-face- (agda2-highlight-face-attributes- font-lock-constant-face))- (cons 'agda2-highlight-symbol-face- (agda2-highlight-face-attributes- font-lock-keyword-face))- (cons 'agda2-highlight-primitive-type-face- (agda2-highlight-face-attributes- font-lock-keyword-face))- (cons 'agda2-highlight-bound-variable-face- (agda2-highlight-face-attributes- font-lock-variable-name-face))- (cons 'agda2-highlight-inductive-constructor-face- (agda2-highlight-face-attributes- font-lock-type-face))- (cons 'agda2-highlight-coinductive-constructor-face- (agda2-highlight-face-attributes- font-lock-type-face))- (cons 'agda2-highlight-datatype-face- (agda2-highlight-face-attributes- font-lock-type-face))- (cons 'agda2-highlight-field-face- (agda2-highlight-face-attributes- font-lock-variable-name-face))- (cons 'agda2-highlight-function-face- (agda2-highlight-face-attributes- font-lock-function-name-face))- (cons 'agda2-highlight-module-face- (agda2-highlight-face-attributes- font-lock-type-face))- (cons 'agda2-highlight-postulate-face- (agda2-highlight-face-attributes- font-lock-type-face))- (cons 'agda2-highlight-primitive-face- (agda2-highlight-face-attributes- font-lock-constant-face))- (cons 'agda2-highlight-record-face- (agda2-highlight-face-attributes- font-lock-variable-name-face))- (cons 'agda2-highlight-dotted-face- (agda2-highlight-face-attributes- font-lock-variable-name-face))- (cons 'agda2-highlight-operator-face- (agda2-highlight-face-attributes- font-lock-function-name-face))- (cons 'agda2-highlight-error-face- (agda2-highlight-face-attributes- font-lock-warning-face)))))))+ (list :inherit 'font-lock-keyword-face))+ (cons 'agda2-highlight-string-face+ (list :inherit 'font-lock-string-face))+ (cons 'agda2-highlight-number-face+ (list :inherit 'font-lock-constant-face))+ (cons 'agda2-highlight-symbol-face+ (list :inherit 'font-lock-keyword-face))+ (cons 'agda2-highlight-primitive-type-face+ (list :inherit 'font-lock-keyword-face))+ (cons 'agda2-highlight-bound-variable-face+ (list :inherit 'font-lock-variable-name-face))+ (cons 'agda2-highlight-generalizable-variable-face+ (list :inherit 'font-lock-variable-name-face))+ (cons 'agda2-highlight-inductive-constructor-face+ (list :inherit 'font-lock-type-face))+ (cons 'agda2-highlight-coinductive-constructor-face+ (list :inherit 'font-lock-type-face))+ (cons 'agda2-highlight-datatype-face+ (list :inherit 'font-lock-type-face))+ (cons 'agda2-highlight-field-face+ (list :inherit 'font-lock-variable-name-face))+ (cons 'agda2-highlight-function-face+ (list :inherit 'font-lock-function-name-face))+ (cons 'agda2-highlight-module-face+ (list :inherit 'font-lock-type-face))+ (cons 'agda2-highlight-postulate-face+ (list :inherit 'font-lock-type-face))+ (cons 'agda2-highlight-primitive-face+ (list :inherit 'font-lock-constant-face))+ (cons 'agda2-highlight-macro-face+ (list :inherit 'font-lock-function-name-face))+ (cons 'agda2-highlight-record-face+ (list :inherit 'font-lock-variable-name-face))+ (cons 'agda2-highlight-dotted-face+ (list :inherit 'font-lock-variable-name-face))+ (cons 'agda2-highlight-operator-face+ (list :inherit 'font-lock-function-name-face))+ (cons 'agda2-highlight-error-face+ (list :inherit 'font-lock-warning-face))+ (cons 'agda2-highlight-typechecks-face+ (list :inherit 'font-lock-type-face))+ (cons 'agda2-highlight-typechecking-face+ (list :inherit 'font-lock-preprocessor-face))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Faces (defcustom agda2-highlight-face-groups nil "Colour scheme used in Agda buffers.-Note that changing this option does not remove the customisations-below; you can get them back by resetting this option and-restarting Emacs. If you are using the default-faces option and-change your colour theme the changes may not take effect in Agda-buffers until you have restarted Emacs."+Changes to this variable may not take full effect until you have+restarted Emacs. Note also that if you are using the+default-faces option and change your colour theme, then the+changes may not take effect in Agda buffers until you have+restarted Emacs." :type '(choice- (const :tag "Use the settings below." nil)- (const :tag "Use an approximation of Conor McBride's colour scheme."- conor)- (const :tag "Use simplified highlighting and default font-lock faces."- default-faces))+ (const :tag "Use the settings in the \"Agda2 Highlight Faces\" subgroup." nil)+ (const :tag "Use an approximation of Conor McBride's colour scheme."+ conor)+ (const :tag "Use simplified highlighting and default font-lock faces."+ default-faces)) :group 'agda2-highlight :set 'agda2-highlight-set-faces) +(defgroup agda2-highlight-faces nil+ "Faces used to highlight Agda code.+If `agda2-highlight-face-groups' is nil."+ :group 'agda2-highlight)+ (defface agda2-highlight-keyword-face- '((t (:foreground "DarkOrange3")))+ '((((background light))+ (:foreground "DarkOrange3"))+ (((background dark))+ (:foreground "#FF9932"))) "The face used for keywords."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-string-face- '((t (:foreground "firebrick")))+ '((((background light))+ (:foreground "firebrick"))+ (((background dark))+ (:foreground "#DD4D4D"))) "The face used for strings."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-number-face- '((t (:foreground "purple")))+ '((((background light))+ (:foreground "purple"))+ (((background dark))+ (:foreground "#9010E0"))) "The face used for numbers."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-symbol-face '((((background light))@@ -203,103 +228,252 @@ (((background dark)) (:foreground "gray75"))) "The face used for symbols like forall, =, ->, etc."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-primitive-type-face- '((t (:foreground "medium blue")))+ '((((background light))+ (:foreground "medium blue"))+ (((background dark))+ (:foreground "#8080FF"))) "The face used for primitive types (like Set and Prop)."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-bound-variable-face '((t nil)) "The face used for bound variables."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) +(defface agda2-highlight-generalizable-variable-face+ '((t nil))+ "The face used for generalizable variables."+ :group 'agda2-highlight-faces)+ (defface agda2-highlight-inductive-constructor-face- '((t (:foreground "green4")))+ '((((background light))+ :foreground "green4")+ (((background dark))+ :foreground "#29CC29")) "The face used for inductive constructors."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-coinductive-constructor-face- '((t (:foreground "gold4")))+ '((((background light))+ :foreground "gold4")+ (((background dark))+ :foreground "#FFEA75")) "The face used for coinductive constructors."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-datatype-face- '((t (:foreground "medium blue")))+ '((((background light))+ (:foreground "medium blue"))+ (((background dark))+ (:foreground "#8080FF"))) "The face used for datatypes."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-field-face- '((t (:foreground "DeepPink2")))+ '((((background light))+ (:foreground "DeepPink2"))+ (((background dark))+ (:foreground "#F570B7"))) "The face used for record fields."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-function-face- '((t (:foreground "medium blue")))+ '((((background light))+ (:foreground "medium blue"))+ (((background dark))+ (:foreground "#8080FF"))) "The face used for functions."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-module-face- '((t (:foreground "purple")))+ '((((background light))+ (:foreground "purple"))+ (((background dark))+ (:foreground "#CD80FF"))) "The face used for module names."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-postulate-face- '((t (:foreground "medium blue")))+ '((((background light))+ (:foreground "medium blue"))+ (((background dark))+ (:foreground "#8080FF"))) "The face used for postulates."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) +(defface agda2-highlight-pragma-face+ '((t nil))+ "The face used for (some text in) pragmas."+ :group 'agda2-highlight-faces)+ (defface agda2-highlight-primitive-face- '((t (:foreground "medium blue")))+ '((((background light))+ (:foreground "medium blue"))+ (((background dark))+ (:foreground "#8080FF"))) "The face used for primitive functions."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) +(defface agda2-highlight-macro-face+ '((((background light))+ (:foreground "aquamarine4"))+ (((background dark))+ (:foreground "#73BAA2")))+ "The face used for macros."+ :group 'agda2-highlight-faces)+ (defface agda2-highlight-record-face- '((t (:foreground "medium blue")))+ '((((background light))+ (:foreground "medium blue"))+ (((background dark))+ (:foreground "#8080FF"))) "The face used for record types."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-dotted-face '((t nil)) "The face used for dotted patterns."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-operator-face '((t nil)) "The face used for operators."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) (defface agda2-highlight-error-face- '((t (:foreground "red" :underline t)))+ '((((background light))+ (:foreground "red" :underline t))+ (((background dark))+ (:foreground "#FF0000" :underline t))) "The face used for errors."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) +(defface agda2-highlight-error-warning-face+ '((((background light))+ (:background "light coral" :underline t))+ (((background dark))+ (:background "#802400" :underline t)))+ "The face used for fatal warnings."+ :group 'agda2-highlight-faces)+ (defface agda2-highlight-unsolved-meta-face- '((t (:background "yellow"- :foreground "black")))+ '((((background light))+ (:background "yellow"))+ (((background dark))+ (:background "#806B00"))) "The face used for unsolved meta variables."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) +(defface agda2-highlight-unsolved-constraint-face+ '((((background light))+ (:background "yellow"))+ (((background dark))+ (:background "#806B00")))+ "The face used for unsolved constraints which are not connected to metas."+ :group 'agda2-highlight-faces)+ (defface agda2-highlight-termination-problem-face- '((t (:background "light salmon"- :foreground "black")))+ '((((background light))+ (:background "light salmon"))+ (((background dark))+ (:background "#802400"))) "The face used for termination problems."- :group 'agda2-highlight)+ :group 'agda2-highlight-faces) -(defface agda2-highlight-incomplete-pattern-face- '((t (:background "wheat"- :foreground "black")))- "The face used for incomplete patterns. (Currently unused.)"- :group 'agda2-highlight)+(defface agda2-highlight-positivity-problem-face+ '((((background light))+ (:background "peru"))+ (((background dark))+ (:background "#803F00")))+ "The face used for positivity problems."+ :group 'agda2-highlight-faces) +(defface agda2-highlight-deadcode-face+ '((((background light))+ (:background "dark gray"))+ (((background dark))+ (:background "#808080")))+ "The face used for dead code (unreachable clauses, etc.)."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-shadowing-in-telescope-face+ '((((background light))+ (:background "dark gray"))+ (((background dark))+ (:background "#808080")))+ "The face used for shadowed repeated variable names in telescopes."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-coverage-problem-face+ '((((background light))+ (:background "wheat"))+ (((background dark))+ (:background "#805300")))+ "The face used for coverage problems."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-catchall-clause-face+ '((((background light))+ (:background "white smoke"))+ (((background dark))+ (:background "#404040")))+ "The face used for catchall clauses."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-cosmetic-problem-face+ '((((background light))+ (:background "white smoke"))+ (((background dark))+ (:background "#404040")))+ "The face used for cosmetic problems."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-confluence-problem-face+ '((((background light))+ (:background "pink"))+ (((background dark))+ (:background "#800080")))+ "The face used for confluence problems."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-instance-problem-face+ '((((background light))+ (:background "wheat"))+ (((background dark))+ (:background "#805300")))+ "The face used for instance problems."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-missing-definition-face+ '((((background light))+ (:background "orange"))+ (((background dark))+ (:background "#804040")))+ "The face used for type declarations with missing definitions."+ :group 'agda2-highlight-faces)++(defface agda2-highlight-typechecks-face+ '((((background light))+ (:background "light blue" :foreground "black"))+ (((background dark))+ (:background "#006080" :foreground "white")))+ "The face used for code which is being type-checked."+ :group 'agda2-highlight-faces)+ (defvar agda2-highlight-faces '((keyword . agda2-highlight-keyword-face)+ (comment . font-lock-comment-face)+ (background . default)+ (markup . font-lock-comment-delimiter-face) (string . agda2-highlight-string-face) (number . agda2-highlight-number-face) (symbol . agda2-highlight-symbol-face) (primitivetype . agda2-highlight-primitive-type-face) (bound . agda2-highlight-bound-variable-face)+ (generalizable . agda2-highlight-generalizable-variable-face) (inductiveconstructor . agda2-highlight-inductive-constructor-face) (coinductiveconstructor . agda2-highlight-coinductive-constructor-face) (datatype . agda2-highlight-datatype-face)@@ -307,71 +481,153 @@ (function . agda2-highlight-function-face) (module . agda2-highlight-module-face) (postulate . agda2-highlight-postulate-face)+ (pragma . agda2-highlight-pragma-face) (primitive . agda2-highlight-primitive-face)+ (macro . agda2-highlight-macro-face) (record . agda2-highlight-record-face) (dotted . agda2-highlight-dotted-face) (operator . agda2-highlight-operator-face) (error . agda2-highlight-error-face)+ (errorwarning . agda2-highlight-error-warning-face) (unsolvedmeta . agda2-highlight-unsolved-meta-face)+ (unsolvedconstraint . agda2-highlight-unsolved-constraint-face) (terminationproblem . agda2-highlight-termination-problem-face)- (incompletepattern . agda2-highlight-incomplete-pattern-face))+ (deadcode . agda2-highlight-deadcode-face)+ (shadowingintelescope . agda2-highlight-shadowing-in-telescope-face)+ (coverageproblem . agda2-highlight-coverage-problem-face)+ (positivityproblem . agda2-highlight-positivity-problem-face)+ (incompletepattern . agda2-highlight-incomplete-pattern-face)+ (catchallclause . agda2-highlight-catchall-clause-face)+ (confluenceproblem . agda2-highlight-confluence-problem-face)+ (cosmeticproblem . agda2-highlight-cosmetic-problem-face)+ (instanceproblem . agda2-highlight-instance-problem-face)+ (missingdefinition . agda2-highlight-missing-definition-face)+ (typechecks . agda2-highlight-typechecks-face)) "Alist mapping code aspects to the face used when displaying them. The aspects currently recognised are the following: +`background' Non-Agda code contents in literate mode. `bound' Bound variables.+`catchallclause' Clause not holding definitionally. `coinductiveconstructor' Coinductive constructors.+`comment' Comments.+`cosmeticproblem' Code that could be prettier.+`coverageproblem' Coverage problems. `datatype' Data types.+`deadcode' Deadcode (like unreachable clauses or RHS). `dotted' Dotted patterns. `error' Errors.+`errorwarning' Fatal warnings. `field' Record fields. `function' Functions.+`generalizable' Generalizable variables. `incompletepattern' Incomplete patterns. `inductiveconstructor' Inductive constructors.+`instanceproblem' Unusable instance(argument)s. `keyword' Keywords.+`macro' Macros.+`markup' Delimiters to separate the Agda code blocks+ from other contents. `module' Module names. `number' Numbers. `operator' Operators.+`positivityproblem' Positivity problems. `postulate' Postulates.+`pragma' Text occurring in pragmas that does not have+ a more specific (syntactic) aspect. `primitive' Primitive functions. `primitivetype' Primitive types (like Set and Prop). `record' Record types.+`shadowingintelescope' Shadowed repeated variable names in telescopes. `string' Strings. `symbol' Symbols like forall, =, ->, etc. `terminationproblem' Termination problems.-`unsolvedmeta' Unsolved meta variables.--The following aspect is ignored:+`typechecks' Code which is being type-checked.+`unsolvedconstraint' Unsolved constraints, not connected to meta+ variables.+`unsolvedmeta' Unsolved meta variables.") -`comment' Comments.+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Variables -Comments are handled by Font Lock mode (which uses the syntax-table). The face `font-lock-comment-face' is used for comments.")+(defvar agda2-highlight-in-progress nil+ "If nil, then highlighting annotations are not applied.")+(make-variable-buffer-local 'agda2-highlight-in-progress) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Functions (defun agda2-highlight-setup nil "Set up the `annotation' library for use with `agda2-mode'."- (font-lock-mode 0)+ (agda2-highlight-set-faces 'agda2-highlight-face-groups agda2-highlight-face-groups) (setq annotation-bindings agda2-highlight-faces)) -(defun agda2-highlight-load (file &optional keep)- "Load syntax highlighting information from FILE.-Old syntax highlighting information is first removed, unless KEEP-is non-nil."- (let ((coding-system-for-read 'utf-8)- ;; Ignore read-only status, otherwise this function may fail.+(defun agda2-highlight-apply (remove &rest cmds)+ "Adds the syntax highlighting information in the annotation list CMDS.++If REMOVE is nil, then old syntax highlighting information is not+removed. Otherwise all token-based syntax highlighting is removed."+ (let (;; Ignore read-only status, otherwise this function may fail. (inhibit-read-only t))- (annotation-load-file file (lambda (anns) (not keep))- "Click mouse-2 to jump to definition")))+ (apply 'annotation-load+ "Click mouse-2 to jump to definition"+ remove+ nil ;; apply highlighting to current buffer+ cmds))) -(defun agda2-highlight-clear nil- "Remove all syntax highlighting added by `agda2-highlight-reload'."+(defun agda2-highlight-add-annotations (file remove &rest cmds)+ "Apply highlighting CMDS to FILE, or to the current buffer if FILE is nil.+But only if `agda2-highlight-in-progress' is non-nil. If REMOVE is+non-nil, token-based highlighting is removed first. CMDS are annotation+commands as described by `agda2-highlight-apply'."+ (declare (agda2-command (t boolean &repeat list)))+ (if agda2-highlight-in-progress+ (if file+ (let ((buffer (find-buffer-visiting file)))+ (when buffer+ (with-current-buffer buffer+ (apply 'agda2-highlight-apply remove cmds))))+ (apply 'agda2-highlight-apply remove cmds))))++(defun agda2-highlight-load (file)+ "Load syntax highlighting information from FILE.++Old syntax highlighting information is not removed."+ (let* ((coding-system-for-read 'utf-8)+ (cmds (with-temp-buffer+ (insert-file-contents file)+ (goto-char (point-min))+ (read (current-buffer)))))+ (apply 'agda2-highlight-apply cmds)))++(defun agda2-highlight-load-and-delete-action (file target)+ "Like `agda2-highlight-load', but deletes FILE when done.+And highlighting is only updated if `agda2-highlight-in-progress'+is non-nil. TARGET is the buffer's file, or nil for the current buffer."+ (declare (agda2-command (string t)))+ (unwind-protect+ (if agda2-highlight-in-progress+ (let* ((coding-system-for-read 'utf-8)+ (cmds (with-temp-buffer+ (insert-file-contents file)+ (goto-char (point-min))+ (read (current-buffer)))))+ (if target+ (apply 'agda2-highlight-add-annotations target cmds)+ (apply 'agda2-highlight-apply cmds))))+ (delete-file file)))++(defun agda2-highlight-clear (&optional token-based)+ "Remove all syntax highlighting.++If TOKEN-BASED is non-nil, then only token-based highlighting is+removed."+ (declare (agda2-command (boolean))) (interactive) (let ((inhibit-read-only t)) ; Ignore read-only status, otherwise this function may fail.- (annotation-remove-annotations)))+ (annotation-remove-annotations token-based))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Administrative details
@@ -0,0 +1,3 @@+(define-package "agda2-mode" "2.9.0"+ "interactive development for Agda, a dependently typed functional programming language"+ '((emacs "24.3"))) ;; dep defs for `annotation.el` and `eri.el` are not required if they are packaged together
@@ -1,1207 +1,2557 @@-;;; agda2-mode.el --- Major mode for Agda--;;; Commentary:--;;--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; Dependency---;;; Code:--(defvar agda2-version "2.3.0"- "The version of the Agda mode.-Note that, by default, the same version of the underlying Haskell-library is used (see `agda2-ghci-options').")--(require 'cl)-(set (make-local-variable 'lisp-indent-function)- 'common-lisp-indent-function)-(require 'comint)-(require 'pp)-(require 'eri)-(require 'annotation)-(require 'agda-input)-(require 'agda2-highlight)-(require 'agda2-abbrevs)-(require 'haskell-ghci)-;; due to a bug in haskell-mode-2.1-(setq haskell-ghci-mode-map (copy-keymap comint-mode-map))-;; Load filladapt, if it is installed.-(condition-case nil- (require 'filladapt)- (error nil))-(unless (fboundp 'overlays-in) (load "overlay")) ; for Xemacs-(unless (fboundp 'propertize) ; for Xemacs 21.4- (defun propertize (string &rest properties)- "Return a copy of STRING with text properties added.-First argument is the string to copy.-Remaining arguments form a sequence of PROPERTY VALUE pairs for text-properties to add to the result."- (let ((str (copy-sequence string)))- (add-text-properties 0 (length str) properties str)- str)))-(unless (fboundp 'run-mode-hooks)- (fset 'run-mode-hooks 'run-hooks)) ; For Emacs versions < 21.--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; Utilities--(defmacro agda2-protect (form &optional default)- "Expands to (condition-case nil FORM (error DEFAULT))."- `(condition-case nil ,form (error ,default)))-(put 'agda2-protect 'lisp-indent-function 0)--(defmacro agda2-let (varbind funcbind &rest body)- "Expands to (let* VARBIND (labels FUNCBIND BODY...))."- `(let* ,varbind (labels ,funcbind ,@body)))-(put 'agda2-let 'lisp-indent-function 2)--(defun agda2-chunkify (n xs)- "Returns a list containing chunks of XS of length at most N.-All the elements of XS are included, in their original order."- (let ((i 0)- (len (length xs))- out)- (while (< i len)- (let ((new-i (+ i (min n (- len i)))))- (setq out (cons (subseq xs i new-i) out))- (setq i new-i)))- (nreverse out)))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; User options--(defgroup agda2 nil- "Major mode for interactively developing Agda programs."- :group 'languages)--(defcustom agda2-include-dirs- '(".")- "The directories Agda uses to search for files.-The directory names should either be absolute or be relative to-the root of the current project."- :type '(repeat directory)- :group 'agda2)--(defcustom agda2-backend- "MAlonzo"- "The backend which is used to compile Agda programs."- :type '(choice (const "MAlonzo")- (const "Epic")- (const "JS"))- :group 'agda2)--(defcustom agda2-ghci-options- (list (concat "-package Agda-" agda2-version))- "Options set in GHCi before loading `agda2-toplevel-module'.-Note that only dynamic options can be set using this variable."- :type '(repeat string)- :group 'agda2)--(defcustom agda2-toplevel-module "Agda.Interaction.GhciTop"- "The name of the Agda toplevel module."- :type 'string :group 'agda2)--(defcustom agda2-mode-hook- '(agda2-fix-ghci-for-windows)- "Hooks for `agda2-mode'."- :type 'hook :group 'agda2)--(defcustom agda2-information-window-max-height- 0.35- "*The maximum height of the information window.-A multiple of the frame height."- :type 'number- :group 'agda2)--(defcustom agda2-fontset-name- (unless (or (eq window-system 'mac)- ;; Emacs-23 uses a revamped font engine which should- ;; make agda2-fontset-name unnecessary in most cases.- ;; And if it turns out to be necessary, we should- ;; probably use face-remapping-alist rather than- ;; set-frame-font so the special font only applies to- ;; Agda buffers, and so it applies in all frames where- ;; Agda buffers are displayed.- (boundp 'face-remapping-alist))- "fontset-agda2")- "Default font to use in the selected frame when activating the Agda mode.-This is only used if it's non-nil and Emacs is not running in a-terminal.--Note that this setting (if non-nil) affects non-Agda buffers as-well, and that you have to restart Emacs if you want settings to-this variable to take effect."- :type '(choice (string :tag "Fontset name")- (const :tag "Do not change the font" nil))- :group 'agda2)--(defcustom agda2-fontset-spec-of-fontset-agda2- "-*-fixed-Medium-r-Normal-*-18-*-*-*-c-*-fontset-agda2,- ascii:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO8859-1,- latin-iso8859-2:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-2,- latin-iso8859-3:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-3,- latin-iso8859-4:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-4,- cyrillic-iso8859-5:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-5,- greek-iso8859-7:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-7,- latin-iso8859-9:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-9,- mule-unicode-0100-24ff:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO10646-1,- mule-unicode-2500-33ff:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO10646-1,- mule-unicode-e000-ffff:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO10646-1,- japanese-jisx0208:-Misc-Fixed-Medium-R-Normal-ja-18-*-*-*-C-*-JISX0208.1990-0,- japanese-jisx0212:-Misc-Fixed-Medium-R-Normal-ja-18-*-*-*-C-*-JISX0212.1990-0,- thai-tis620:-Misc-Fixed-Medium-R-Normal--24-240-72-72-C-120-TIS620.2529-1,- lao:-Misc-Fixed-Medium-R-Normal--24-240-72-72-C-120-MuleLao-1,- tibetan:-TibMdXA-fixed-medium-r-normal--16-160-72-72-m-160-MuleTibetan-0,- tibetan-1-column:-TibMdXA-fixed-medium-r-normal--16-160-72-72-m-80-MuleTibetan-1,- korean-ksc5601:-Daewoo-Mincho-Medium-R-Normal--16-120-100-100-C-160-KSC5601.1987-0,- chinese-gb2312:-ISAS-Fangsong ti-Medium-R-Normal--16-160-72-72-c-160-GB2312.1980-0,- chinese-cns11643-1:-HKU-Fixed-Medium-R-Normal--16-160-72-72-C-160-CNS11643.1992.1-0,- chinese-big5-1:-ETen-Fixed-Medium-R-Normal--16-150-75-75-C-160-Big5.ETen-0,- chinese-big5-2:-ETen-Fixed-Medium-R-Normal--16-150-75-75-C-160-Big5.ETen-0"- "Specification of the \"fontset-agda2\" fontset.-This fontset is only created if `agda2-fontset-name' is-\"fontset-agda2\" and Emacs is not run in a terminal.--Note that the text \"fontset-agda2\" has to be part of the-string (in a certain way; see the default setting) in order for the-agda2 fontset to be created properly.--Note also that the default setting may not work unless suitable-fonts are installed on your system. Refer to the README file-accompanying the Agda distribution for more details.--Note finally that you have to restart Emacs if you want settings-to this variable to take effect."- :group 'agda2- :type 'string)--(if (and (equal agda2-fontset-name "fontset-agda2") window-system)- (create-fontset-from-fontset-spec agda2-fontset-spec-of-fontset-agda2 t t))--(defun agda2-fix-ghci-for-windows ()- (if (string-match "windows" system-configuration)- (setq haskell-ghci-program-name "ghc"- haskell-ghci-program-args '("--interactive"))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; Global and buffer-local vars, initialization--(defvar agda2-mode-syntax-table- (let ((tbl (make-syntax-table)))- ;; Set the syntax of every char to "w" except for those whose default- ;; syntax in `standard-syntax-table' is `paren' or `whitespace'.- (map-char-table (lambda (keys val)- ;; `keys' here can be a normal char, a generic char- ;; (Emacs<23), or a char range (Emacs>=23).- (unless (memq (car val)- (eval-when-compile- (mapcar 'car- (list (string-to-syntax "(")- (string-to-syntax ")")- (string-to-syntax " ")))))- (modify-syntax-entry keys "w" tbl)))- (standard-syntax-table))- ;; Then override the remaining special cases.- (dolist (cs '((?{ . "(}1n") (?} . "){4n") (?- . "w 123b") (?\n . "> b")- (?. . ".") (?\; . ".") (?_ . ".") (?! . ".")))- (modify-syntax-entry (car cs) (cdr cs) tbl))- tbl)- "Syntax table used by the Agda mode:--{} | Comment characters, matching parentheses.-- | Comment character, word constituent.-\n | Comment ender.-.;_! | Punctuation.--Remaining characters inherit their syntax classes from the-standard syntax table if that table treats them as matching-parentheses or whitespace. Otherwise they are treated as word-constituents.")--(defconst agda2-command-table- `(- (agda2-load "\C-c\C-l" (global) "Load")- (agda2-load "\C-c\C-x\C-l")- (agda2-compile "\C-c\C-x\C-c" (global) "Compile")- (agda2-quit "\C-c\C-x\C-q" (global) "Quit")- (agda2-restart "\C-c\C-x\C-r" (global) "Restart")- (agda2-remove-annotations "\C-c\C-x\C-d" (global) "Remove goals and highlighting (\"deactivate\")")- (agda2-display-implicit-arguments "\C-c\C-x\C-h" (global) "Toggle display of hidden arguments")- (agda2-show-constraints ,(kbd "C-c C-=") (global) "Show constraints")- (agda2-solveAll ,(kbd "C-c C-s") (global) "Solve constraints")- (agda2-show-goals ,(kbd "C-c C-?") (global) "Show goals")- (agda2-next-goal "\C-c\C-f" (global) "Next goal") ; Forward.- (agda2-previous-goal "\C-c\C-b" (global) "Previous goal") ; Back.- (agda2-give ,(kbd "C-c C-SPC") (local) "Give")- (agda2-refine "\C-c\C-r" (local) "Refine")- (agda2-auto "\C-c\C-a" (local) "Auto")- (agda2-make-case "\C-c\C-c" (local) "Case")- (agda2-goal-type "\C-c\C-t" (local) "Goal type")- (agda2-show-context "\C-c\C-e" (local) "Context (environment)")- (agda2-infer-type-maybe-toplevel "\C-c\C-d" (local global) "Infer (deduce) type")- (agda2-goal-and-context ,(kbd "C-c C-,") (local) "Goal type and context")- (agda2-goal-and-context-and-inferred ,(kbd "C-c C-.") (local) "Goal type, context and inferred type")- (agda2-module-contents-maybe-toplevel ,(kbd "C-c C-o") (local global) "Module contents")- (agda2-compute-normalised-maybe-toplevel "\C-c\C-n" (local global) "Evaluate term to normal form")- (eri-indent ,(kbd "TAB"))- (eri-indent-reverse [S-iso-lefttab])- (eri-indent-reverse [S-lefttab])- (eri-indent-reverse [S-tab])- (agda2-goto-definition-mouse [mouse-2])- (agda2-goto-definition-keyboard "\M-.")- (agda2-go-back "\M-*")- )- "Table of commands, used to build keymaps and menus.-Each element has the form (CMD &optional KEYS WHERE DESC) where-CMD is a command; KEYS is its key binding (if any); WHERE is a-list which should contain 'local if the command should exist in-the goal menu and 'global if the command should exist in the main-menu; and DESC is the description of the command used in the-menus.")--(defvar agda2-mode-map- (let ((map (make-sparse-keymap "Agda mode")))- (define-key map [menu-bar Agda]- (cons "Agda" (make-sparse-keymap "Agda")))- (define-key map [down-mouse-3] 'agda2-popup-menu-3)- (dolist (d (reverse agda2-command-table))- (destructuring-bind (f &optional keys kinds desc) d- (if keys (define-key map keys f))- (if (member 'global kinds)- (define-key map- (vector 'menu-bar 'Agda (intern desc)) (cons desc f)))))- map)- "Keymap for `agda2-mode'.")--(defvar agda2-goal-map- (let ((map (make-sparse-keymap "Agda goal")))- (dolist (d (reverse agda2-command-table))- (destructuring-bind (f &optional keys kinds desc) d- (if (member 'local kinds)- (define-key map- (vector (intern desc)) (cons desc f)))))- map)- "Keymap for agda2 goal menu.")--(defvar agda2-buffer nil "Agda subprocess buffer. Set in `agda2-restart'.")-(defvar agda2-process nil "Agda subprocess. Set in `agda2-restart'.")--;; Some buffer locals-(defvar agda2-buffer-external-status ""- "External status of an `agda2-mode' buffer (dictated by the Haskell side).")-(make-variable-buffer-local 'agda2-buffer-external-status)--(defconst agda2-help-address- ""- "Address accepting submissions of bug reports and questions.")--;; Annotation for a goal-;; {! .... !}-;; ---------- overlay: agda2-gn num, face highlight, after-string num,-;; modification-hooks (agda2-protect-goal-markers)-;; - text-props: category agda2-delim1-;; - text-props: category agda2-delim2-;; - text-props: category agda2-delim3-;; - text-props: category agda2-delim4-;;-;; Char categories for {! ... !}-(defvar agda2-open-brace "{")-(defvar agda2-close-brace " }")-(setplist 'agda2-delim1 `(display ,agda2-open-brace))-(setplist 'agda2-delim2 `(display ,agda2-open-brace rear-nonsticky t- agda2-delim2 t))-(setplist 'agda2-delim3 `(display ,agda2-close-brace agda2-delim3 t))-(setplist 'agda2-delim4 `(display ,agda2-close-brace rear-nonsticky t))--;; Note that strings used with the display property are compared by-;; reference. If the agda2-*-brace definitions were inlined, then-;; goals would be displayed as "{{ }}n" instead of "{ }n".--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; agda2-mode--;;;###autoload-(add-to-list 'auto-mode-alist '("\\.l?agda\\'" . agda2-mode))-;;;###autoload-(modify-coding-system-alist 'file "\\.l?agda\\'" 'utf-8)-;;;###autoload-(define-derived-mode agda2-mode nil "Agda"- "Major mode for Agda files.--The following paragraph does not apply to Emacs 23.-- Note that when this mode is activated the default font of the- current frame is changed to the fontset `agda2-fontset-name'.- The reason is that Agda programs often use mathematical symbols- and other Unicode characters, so we try to provide a suitable- default font setting, which can display many of the characters- encountered. If you prefer to use your own settings, set- `agda2-fontset-name' to nil.--Special commands:-\\{agda2-mode-map}"- (setq local-abbrev-table agda2-mode-abbrev-table- indent-tabs-mode nil- mode-line-process- '((:eval (unless (eq 0 (length agda2-buffer-external-status))- (concat ":" agda2-buffer-external-status)))))- (let ((l '(max-specpdl-size 2600- max-lisp-eval-depth 2800)))- (while l (set (make-local-variable (pop l)) (pop l))))- (if (and window-system agda2-fontset-name)- (condition-case nil- (set-frame-font agda2-fontset-name)- (error (error "Unable to change the font; change agda2-fontset-name or tweak agda2-fontset-spec-of-fontset-agda2"))))- ;; If GHCi is not running syntax highlighting does not work properly.- (unless (eq 'run (agda2-process-status))- (agda2-restart))- (agda2-highlight-setup)- (agda2-highlight-reload)- (agda2-comments-and-paragraphs-setup)- (force-mode-line-update)- ;; Protect global value of default-input-method from set-input-method.- (make-local-variable 'default-input-method)- (set-input-method "Agda")- ;; Highlighting is removed when we switch from the Agda mode. Use- ;; case: When a file M.lagda with a local variables list including- ;; "mode: latex" is loaded chances are that the Agda mode is- ;; activated before the LaTeX mode, and the LaTeX mode does not seem- ;; to remove the text properties set by the Agda mode.- (add-hook (make-local-variable 'change-major-mode-hook)- 'agda2-remove-annotations))--(defun agda2-restart ()- "Kill and restart the *ghci* buffer and load `agda2-toplevel-module'."- (interactive)- (save-excursion (let ((agda2-bufname "*ghci*")- (ignore-dot-ghci "-ignore-dot-ghci"))- (agda2-protect- (progn- ;; GHCi doesn't always die when its buffer is- ;; killed, so GHCi is killed before the buffer- ;; is.- (set-buffer agda2-bufname)- (agda2-protect (comint-kill-subjob))- (kill-buffer agda2-bufname)))- ;; Make sure that the user's .ghci is not read.- ;; Users can override this by adding- ;; "-read-dot-ghci" to- ;; `haskell-ghci-program-args'.- (unless (equal (car-safe haskell-ghci-program-args)- ignore-dot-ghci)- (set (make-local-variable 'haskell-ghci-program-args)- (cons ignore-dot-ghci haskell-ghci-program-args)))- (haskell-ghci-start-process nil)- (setq agda2-process haskell-ghci-process- agda2-buffer haskell-ghci-process-buffer- mode-name "Agda GHCi")- (set (make-local-variable 'comint-input-sender)- 'agda2-send)- (set-buffer-file-coding-system 'utf-8)- (set-buffer-process-coding-system 'utf-8 'utf-8)- (rename-buffer agda2-bufname)- (set-process-query-on-exit-flag agda2-process nil)))- (apply 'agda2-call-ghci ":set" agda2-ghci-options)- (agda2-call-ghci ":mod +" agda2-toplevel-module)- (agda2-remove-annotations))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; Communicating with Agda--(defun agda2-raise-ghci-error ()- "Raises an error.-The error message directs the user to the *ghci* buffer."- (error "Problem encountered. The *ghci* buffer can perhaps explain why."))--(defun agda2-send (proc s)- "Sends the string S to PROC.-Splits up S into small chunks and sends them one after the other,-because when GHCi is used in shell buffers it chokes on overly-long strings (some versions of GHCi, on some systems)."- (let* ((chunk-size 200))- (dolist (chunk (agda2-chunkify chunk-size s))- (comint-send-string proc chunk)))- (comint-send-string proc "\n"))--(defun agda2-call-ghci (&rest args)- "Executes commands in GHCi.-Sends the list of strings ARGS to GHCi, waits for output and-returns the responses."- (unless (eq 'run (agda2-process-status))- ;; Try restarting automatically, but only once, in case there is- ;; some major problem.- (agda2-restart)- (unless (eq 'run (agda2-process-status))- (agda2-raise-ghci-error)))- (save-excursion- ;; By setting local-enable-local-variables to nil the call to- ;; hack-local-variables in haskell-ghci-go becomes more or less a- ;; no-op. (Note that hack-local-variables can interfere with the- ;; setup of a mode, because it can potentially perform the setup- ;; of another mode...)- (let ((local-enable-local-variables nil))- (haskell-ghci-go (apply 'concat (agda2-intersperse " " args))- nil)))- (let (response)- (with-current-buffer haskell-ghci-process-buffer- (haskell-ghci-wait-for-output)- (let ((tempfile (make-temp-file "agda2-mode")))- (unwind-protect- (let ((coding-system-for-read 'utf-8)- (coding-system-for-write 'utf-8))- (comint-write-output tempfile)- (with-temp-buffer- (insert-file-contents tempfile)- (setq response (buffer-substring-no-properties- (point-min) (point-max)))))- (delete-file tempfile))))- response))--(defun agda2-go (responses-expected highlight &rest args)- "Executes commands in GHCi.-Sends the list of strings ARGS to GHCi, waits for output and-executes the responses, if any. If no responses are received, and-RESPONSES-EXPECTED is non-nil, then an error is raised; otherwise-the syntax highlighting information is reloaded (unless HIGHLIGHT-is nil; if HIGHLIGHT is a string, then highlighting info is read-from the corresponding file)."- (let* ((highlighting-temp (and highlight (not (stringp highlight))))- (highlighting (cond ((stringp highlight) highlight)- (highlighting-temp (make-temp-file "agda2-mode")))))- (unwind-protect- (let ((responses- (agda2-read-responses- (apply 'agda2-call-ghci- "ioTCM"- (agda2-string-quote (buffer-file-name))- (if highlighting-temp- (concat "(Just "- (agda2-string-quote highlighting)- ")")- "Nothing")- "("- (append args '(")"))))))- (when (and responses-expected (null responses))- (agda2-raise-ghci-error))- (if highlight (agda2-highlight-load highlighting))- (agda2-exec-responses responses))- (if highlighting-temp (delete-file highlighting)))))--(defun agda2-goal-cmd (cmd &optional want ask &rest args)- "Reads input from goal or minibuffer and sends command to Agda.--An error is raised if point is not in a goal.--The command sent to Agda is-- CMD <goal number> <goal range> <user input> ARGS.--The user input is computed as follows:--* If WANT is nil, then the user input is the empty string.--* If WANT is a string, and either ASK is non-nil or the goal only- contains whitespace, then the input is taken from the- minibuffer. In this case WANT is used as the prompt string.--* Otherwise (including if WANT is 'goal) the goal contents are- used.--If the user input is not taken from the goal, then an empty goal-range is given.--An error is raised if no responses are received."- (multiple-value-bind (o g) (agda2-goal-at (point))- (unless g (error "For this command, please place the cursor in a goal"))- (let ((txt (buffer-substring-no-properties (+ (overlay-start o) 2)- (- (overlay-end o) 2)))- (input-from-goal nil))- (cond ((null want) (setq txt ""))- ((and (stringp want)- (or ask (string-match "\\`\\s *\\'" txt)))- (setq txt (read-string (concat want ": ") nil nil txt t)))- (t (setq input-from-goal t)))- (apply 'agda2-go t nil cmd- (format "%d" g)- (if input-from-goal (agda2-goal-Range o) "noRange")- (agda2-string-quote txt) args))))--(defun agda2-read-responses (response)- "Returns a list containing the responses in the response string.-Responses of the form (last . actual-response) are placed last in-the returned list, with last stripped."- (let ((responses)- (former)- (latter))- (while (string-match "agda2_mode_code" response)- (setq response (substring response (match-end 0)))- (push (read response) responses))- (dolist (r responses (append former latter))- (if (and (consp r) (equal (car r) 'last))- (push (cdr r) latter)- (push r former)))))--;; Note that the following function is a security risk, since it-;; evaluates code without first inspecting it. The code (supposedly)-;; comes from the Agda backend, but there could be bugs in the backend-;; which can be exploited by an attacker which manages to trick-;; someone into type-checking compromised Agda code.--(defun agda2-exec-responses (responses)- "Interprets responses."- (mapc (lambda (r)- (let ((inhibit-read-only t))- (eval r)))- responses))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; User commands and response processing--(defun agda2-load ()- "Load current buffer."- (interactive)- (agda2-go t t "cmd_load"- (agda2-string-quote (buffer-file-name))- (agda2-list-quote agda2-include-dirs)- ))--(defun agda2-compile ()- "Compile the current module.--The variable `agda2-backend' determines which backend is used."- (interactive)- (agda2-go t t "cmd_compile"- agda2-backend- (agda2-string-quote (buffer-file-name))- (agda2-list-quote agda2-include-dirs)- ))--(defun agda2-give()- "Give to the goal at point the expression in it" (interactive)- (agda2-goal-cmd "cmd_give" "expression to give"))--(defun agda2-give-action (old-g paren)- "Update the goal OLD-G with the expression in it."- (agda2-update old-g paren))--(defun agda2-refine ()- "Refine the goal at point.-If the goal contains an expression e, and some \"suffix\" of the-type of e unifies with the goal type, then the goal is replaced-by e applied to a suitable number of new goals.--If the goal is empty, the goal type is a data type, and there is-exactly one constructor which unifies with this type, then the-goal is replaced by the constructor applied to a suitable number-of new goals."- (interactive)- (agda2-goal-cmd "cmd_refine_or_intro" 'goal))--(defun agda2-auto ()- "Simple proof search" (interactive)- (agda2-goal-cmd "cmd_auto" 'goal))--(defun agda2-make-case ()- "Refine the pattern var given in the goal.-Assumes that <clause> = {!<var>!} is on one line."- (interactive)- (agda2-goal-cmd "cmd_make_case" "pattern var to case"))--(defun agda2-make-case-action (newcls)- "Replace the line at point with new clauses NEWCLS and reload."- (agda2-forget-all-goals);; we reload later anyway.- (let* ((p0 (point))- ;; (p1 (goto-char (agda2-decl-beginning)))- (p1 (goto-char (+ (current-indentation) (line-beginning-position))))- (indent (current-column))- cl)- (goto-char p0)- (re-search-forward "!}" (line-end-position) 'noerr)- (delete-region p1 (point))- (while (setq cl (pop newcls))- (insert cl)- (if newcls (insert "\n" (make-string indent ? ))))- (goto-char p1))- (agda2-load))--(defun agda2-make-case-action-extendlam (newcls)- "Replace definition of extended lambda with new clauses NEWCLS and reload."- (agda2-forget-all-goals);; we reload later anyway.- (let* ((p (+ (re-search-backward "\\({[^!]\\)\\|;") 1))- cl)- (goto-char p)- (delete-region p (- (re-search-forward "\\([^!]}\\)\\|;") 1))- (goto-char p)- (insert " ")- (goto-char (+ p 1))- (while (setq cl (pop newcls))- (insert cl)- (if newcls (insert " ; ")))- (goto-char p))- (agda2-load))--(defun agda2-status-action (status)- "Display the string STATUS in the current buffer's mode line.-\(precondition: the current buffer has to use the Agda mode as the-major mode)."- (setq agda2-buffer-external-status status))--(defun agda2-info-action (name text)- "Insert TEXT into the Agda info buffer, display it, and display NAME-in the buffer's mode line."- (interactive)- (with-current-buffer (get-buffer-create "*Agda information*")- (erase-buffer)- (insert text)- (set-syntax-table agda2-mode-syntax-table)- (set-input-method "Agda")-- ;; Support for jumping to positions mentioned in the text.- (set (make-local-variable 'compilation-error-regexp-alist)- '(("\\([\\\\/][^[:space:]]*\\):\\([0-9]+\\),\\([0-9]+\\)-\\(\\([0-9]+\\),\\)?\\([0-9]+\\)"- 1 (2 . 5) (3 . 6))))- ;; No support for recompilation. An attempt to recompile via the- ;; info buffer (using "g") will (most likely) lead to a (dynamic)- ;; type error. (The default is to run "make -k".)- (set (make-local-variable 'compile-command)- 'agda2-does-not-support-compilation-via-the-compilation-minor-mode)- (compilation-minor-mode 1)-- ;; The info buffer is read-only. Compilation minor mode introduces- ;; the keybindings "g" (recompile) and "q" (bury the buffer), and- ;; these keybindings can make it rather awkward to edit the info- ;; buffer. To avoid surprises we make the buffer read-only.- (setq buffer-read-only t)-- (goto-char (point-min))- (put-text-property 0 (length name) 'face '(:weight bold) name)- (setq mode-line-buffer-identification name)- (save-selected-window- (pop-to-buffer (current-buffer) 'not-this-window 'norecord)- (fit-window-to-buffer- nil (truncate- (* (frame-height) agda2-information-window-max-height))))))--(defun agda2-show-goals()- "Show all goals." (interactive)- (agda2-go t t "cmd_metas"))--(defun agda2-show-constraints()- "Show constraints." (interactive)- (agda2-go t t "cmd_constraints"))--(defun agda2-remove-annotations ()- "Removes buffer annotations (overlays and text properties)."- (interactive)- (dolist (o (overlays-in (point-min) (point-max)))- (delete-overlay o))- (let ((inhibit-read-only t))- (annotation-preserve-mod-p-and-undo- (set-text-properties (point-min) (point-max) '()))- (force-mode-line-update)))--(defun agda2-next-goal () "Go to the next goal, if any." (interactive)- (agda2-mv-goal 'next-single-property-change 'agda2-delim2 1 (point-min)))-(defun agda2-previous-goal () "Go to the previous goal, if any." (interactive)- (agda2-mv-goal 'previous-single-property-change 'agda2-delim3 0 (point-max)))-(defun agda2-mv-goal (change delim adjust wrapped)- (agda2-let ()- ((go (p) (while (and (setq p (funcall change p 'category))- (not (eq (get-text-property p 'category) delim))))- (if p (goto-char (+ adjust p)))))- (or (go (point)) (go wrapped) (message "No goals in the buffer"))))--(defun agda2-quit ()- "Quit and clean up after agda2."- (interactive)- (agda2-protect (progn (kill-buffer agda2-buffer)- (kill-buffer (current-buffer)))))--(defmacro agda2-maybe-normalised (name comment cmd want)- "This macro constructs a function NAME which runs CMD.-COMMENT is used to build the function's comment. The function-NAME takes a prefix argument which tells whether it should-normalise types or not when running CMD (through-`agda2-goal-cmd'; WANT is used as `agda2-goal-cmd's WANT-argument)."- (let ((eval (make-symbol "eval")))- `(defun ,name (&optional not-normalise)- ,(concat comment ".--With a prefix argument the result is not explicitly normalised.")- (interactive "P")- (let ((,eval (if not-normalise "Instantiated" "Normalised")))- (agda2-goal-cmd (concat ,cmd " Agda.Interaction.BasicOps." ,eval)- ,want)))))--(defmacro agda2-maybe-normalised-toplevel (name comment cmd prompt)- "This macro constructs a function NAME which runs CMD.-COMMENT is used to build the function's comments. The function-NAME takes a prefix argument which tells whether it should-normalise types or not when running CMD (through-`agda2-go' t nil; the string PROMPT is used as the goal command-prompt)."- (let ((eval (make-symbol "eval")))- `(defun ,name (not-normalise expr)- ,(concat comment ".--With a prefix argument the result is not explicitly normalised.")- (interactive ,(concat "P\nM" prompt ": "))- (let ((,eval (if not-normalise "Instantiated" "Normalised")))- (agda2-go t nil- (concat ,cmd " Agda.Interaction.BasicOps." ,eval " "- (agda2-string-quote expr)))))))--(agda2-maybe-normalised- agda2-goal-type- "Show the type of the goal at point"- "cmd_goal_type"- nil)--(agda2-maybe-normalised- agda2-infer-type- "Infer the type of the goal at point"- "cmd_infer"- "expression to type")--(agda2-maybe-normalised-toplevel- agda2-infer-type-toplevel- "Infers the type of the given expression. The scope used for-the expression is that of the last point inside the current-top-level module"- "cmd_infer_toplevel"- "Expression")--(defun agda2-infer-type-maybe-toplevel ()- "Infers the type of the given expression.-Either uses the scope of the current goal or, if point is not in a goal, the-top-level scope."- (interactive)- (call-interactively (if (agda2-goal-at (point))- 'agda2-infer-type- 'agda2-infer-type-toplevel)))--(agda2-maybe-normalised- agda2-goal-and-context- "Shows the type of the goal at point and the currect context"- "cmd_goal_type_context"- nil)--(agda2-maybe-normalised- agda2-goal-and-context-and-inferred- "Shows the context, the goal and the given expression's inferred type"- "cmd_goal_type_context_infer"- "expression to type")--(agda2-maybe-normalised- agda2-show-context- "Show the context of the goal at point"- "cmd_context"- nil)--(defun agda2-module-contents ()- "Shows all the top-level names in the given module.-Along with their types."- (interactive)- (agda2-goal-cmd "cmd_show_module_contents" "Module name"))--(defun agda2-module-contents-toplevel (module)- "Shows all the top-level names in the given module.-Along with their types."- (interactive "MModule name: ")- (agda2-go t nil- "cmd_show_module_contents_toplevel"- (agda2-string-quote module)))--(defun agda2-module-contents-maybe-toplevel ()- "Shows all the top-level names in the given module.-Along with their types.--Uses either the scope of the current goal or, if point is not in-a goal, the top-level scope."- (interactive)- (call-interactively (if (agda2-goal-at (point))- 'agda2-module-contents- 'agda2-module-contents-toplevel)))--(defun agda2-solveAll ()- "Solves all goals that are already instantiated internally."- (interactive)- (agda2-go t t "cmd_solveAll"))--(defun agda2-solveAll-action (iss)- (save-excursion- (while iss- (let* ((g (pop iss)) (txt (pop iss)))- (agda2-replace-goal g txt)- (agda2-goto-goal g)- (agda2-give)))))--(defun agda2-compute-normalised (&optional arg)- "Compute the normal form of the expression in the goal at point.-With a prefix argument \"abstract\" is ignored during the computation."- (interactive "P")- (let ((cmd (concat "cmd_compute"- (if arg " True" " False"))))- (agda2-goal-cmd cmd "expression to normalise")))--(defun agda2-compute-normalised-toplevel (expr &optional arg)- "Computes the normal form of the given expression.-The scope used for the expression is that of the last point inside the current-top-level module.-With a prefix argument \"abstract\" is ignored during the computation."- (interactive "MExpression: \nP")- (let ((cmd (concat "cmd_compute_toplevel"- (if arg " True" " False")- " ")))- (agda2-go t nil (concat cmd (agda2-string-quote expr)))))--(defun agda2-compute-normalised-maybe-toplevel ()- "Computes the normal form of the given expression,-using the scope of the current goal or, if point is not in a goal, the-top-level scope.-With a prefix argument \"abstract\" is ignored during the computation."- (interactive)- (if (agda2-goal-at (point))- (call-interactively 'agda2-compute-normalised)- (call-interactively 'agda2-compute-normalised-toplevel)))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;;--(defun agda2-highlight-reload nil- "Loads precomputed syntax highlighting info for the current buffer.-If there is any to load."- (let ((highlighting (make-temp-file "agda2-mode")))- (unwind-protect- (progn- (agda2-go nil highlighting- "cmd_write_highlighting_info"- (agda2-string-quote (buffer-file-name))- (agda2-string-quote highlighting)))- (delete-file highlighting))))--(defun agda2-literate-p ()- "Is the current buffer a literate Agda buffer?"- (equal (file-name-extension (buffer-name)) "lagda"))--(defun agda2-goals-action (goals)- "Annotates the goals in the current buffer with text properties.-GOALS is a list of the buffer's goal numbers, in the order in-which they appear in the buffer. Note that this function should-be run /after/ syntax highlighting information has been loaded,-because the two highlighting mechanisms interact in unfortunate-ways."- (agda2-forget-all-goals)- (agda2-let- ((literate (agda2-literate-p))- stk- top)- ((delims() (re-search-forward "[?]\\|[{][-!]\\|[-!][}]\\|--\\|\\\\begin{code}\\|\\\\end{code}" nil t))- (is-lone-questionmark ()- (save-excursion- (save-match-data- (backward-char 3)- (looking-at- "\\(.[{(]\\|.\\s \\)[?]\\(\\s \\|[)};]\\|$\\)"))))- (make(p) (agda2-make-goal p (point) (pop goals)))- (inside-comment() (and stk (null (car stk))))- (inside-goal() (and stk (integerp (car stk))))- (outside-code() (and stk (eq (car stk) 'outside)))- (inside-code() (not (outside-code))))- (save-excursion- ;; In literate mode we should start out in the "outside of code"- ;; state.- (if literate (push 'outside stk))- (goto-char (point-min))- (while (and goals (delims))- (labels ((c (s) (equal s (match-string 0))))- (cond- ((c "\\begin{code}") (when (outside-code) (pop stk)))- ((c "\\end{code}") (when (not stk) (push 'outside stk)))- ((c "--") (when (not stk) (end-of-line)))- ((c "{-") (when (and (inside-code)- (not (inside-goal))) (push nil stk)))- ((c "-}") (when (inside-comment) (pop stk)))- ((c "{!") (when (and (inside-code)- (not (inside-comment))) (push (- (point) 2) stk)))- ((c "!}") (when (inside-goal)- (setq top (pop stk))- (unless stk (make top))))- ((c "?") (progn- (when (and (not stk) (is-lone-questionmark))- (delete-char -1)- (insert "{!!}")- (make (- (point) 4)))))))))))--(defun agda2-make-goal (p q n)- "Make a goal with number N at <P>{!...!}<Q>. Assume the region is clean."- (annotation-preserve-mod-p-and-undo- (flet ((atp (x ps) (add-text-properties x (1+ x) ps)))- (atp p '(category agda2-delim1))- (atp (1+ p) '(category agda2-delim2))- (atp (- q 2) '(category agda2-delim3))- (atp (1- q) '(category agda2-delim4)))- (let ((o (make-overlay p q nil t nil)))- (overlay-put o 'modification-hooks '(agda2-protect-goal-markers))- (overlay-put o 'agda2-gn n)- (overlay-put o 'face 'highlight)- (overlay-put o 'after-string (propertize (format "%s" n) 'face 'highlight)))))--(defun agda2-protect-goal-markers (ol action beg end &optional length)- "Ensures that the goal markers cannot be tampered with.-Except if `inhibit-read-only' is non-nil or /all/ of the goal is-modified."- (if action- ;; This is the after-change hook.- nil- ;; This is the before-change hook.- (cond- ((and (<= beg (overlay-start ol)) (>= end (overlay-end ol)))- ;; The user is trying to remove the whole goal:- ;; manually evaporate the overlay and add an undo-log entry so- ;; it gets re-added if needed.- (when (listp buffer-undo-list)- (push (list 'apply 0 (overlay-start ol) (overlay-end ol)- 'move-overlay ol (overlay-start ol) (overlay-end ol))- buffer-undo-list))- (delete-overlay ol))- ((or (< beg (+ (overlay-start ol) 2))- (> end (- (overlay-end ol) 2)))- (unless inhibit-read-only- (signal 'text-read-only nil))))))--(defun agda2-update (old-g new-txt)- "Update the goal OLD-G.-If NEW-TXT is a string, then the goal is replaced by the string,-and otherwise the text inside the goal is retained (parenthesised-if NEW-TXT is `'paren').--Removes the goal braces, but does not remove the goal overlay or-text properties."- (multiple-value-bind (p q) (agda2-range-of-goal old-g)- (save-excursion- (cond ((stringp new-txt)- (agda2-replace-goal old-g new-txt))- ((equal new-txt 'paren)- (goto-char (- q 2)) (insert ")")- (goto-char (+ p 2)) (insert "(")))- (multiple-value-bind (p q) (agda2-range-of-goal old-g)- (delete-region (- q 2) q)- (delete-region p (+ p 2))))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;; Misc--(defun agda2-process-status ()- "Status of `agda2-buffer', or \"no process\"."- (agda2-protect (process-status agda2-process) "no process"))--(defun agda2-intersperse (sep xs)- (let(ys)(while xs (push (pop xs) ys)(push sep ys))(pop ys)(nreverse ys)))--(defun agda2-goal-Range (o)- "The Haskell Range of goal overlay O."- (format "(Range [Interval %s %s])"- (agda2-mkPos (+ (overlay-start o) 2))- (agda2-mkPos (- (overlay-end o) 2))))--(defun agda2-mkPos (&optional p)- "The Haskell Position corresponding to P or `point'."- (save-excursion- (if p (goto-char p))- (format "(Pn (Just (mkAbsolute %s)) %d %d %d)"- (agda2-string-quote (file-truename (buffer-file-name)))- (point)- (count-lines (point-min) (point))- (1+ (current-column)))))--(defun agda2-char-quote (c)- "Convert character C to the notation used in Haskell strings.-The non-ASCII characters are actually rendered as-\"\\xNNNN\\&\", i.e. followed by a \"null character\", to avoid-problems if they are followed by digits. ASCII characters (code-points < 128) are converted to singleton strings."- (if (< c 128)- (list c)- ;; FIXME: Why return a list rather than a string? --Stef- (append (format "\\x%x\\&" (encode-char c 'ucs)) nil)))--(defun agda2-string-quote (s)- "Format S as a Haskell string literal.-Removes any text properties, escapes newlines, double quotes,-etc., adds surrounding double quotes, and converts non-ASCII-characters to the \\xNNNN notation used in Haskell strings."- (let ((pp-escape-newlines t)- (s2 (copy-sequence s)))- (set-text-properties 0 (length s2) nil s2)- (mapconcat 'agda2-char-quote (pp-to-string s2) "")))--(defun agda2-list-quote (strings)- "Convert a list of STRINGS into a string representing it in Haskell syntax."- (concat "[" (mapconcat 'agda2-string-quote strings ", ") "]"))--(defun agda2-goal-at(pos)- "Return (goal overlay, goal number) at POS, or nil."- (let ((os (and pos (overlays-at pos))) o g)- (while (and os (not(setq g (overlay-get (setq o (pop os)) 'agda2-gn)))))- (if g (list o g))))--(defun agda2-goal-overlay (g)- "Returns the overlay of goal number G, if any."- (car- (remove nil- (mapcar (lambda (o) (if (equal (overlay-get o 'agda2-gn) g) o))- (overlays-in (point-min) (point-max))))))--(defun agda2-range-of-goal (g)- "The range of goal G."- (let ((o (agda2-goal-overlay g)))- (if o (list (overlay-start o) (overlay-end o)))))--(defun agda2-goto-goal (g)- (let ((p (+ 2 (car (agda2-range-of-goal g)))))- (if p (goto-char p))))--(defun agda2-replace-goal (g newtxt)- "Replace the content of goal G with NEWTXT." (interactive)- (save-excursion- (multiple-value-bind (p q) (agda2-range-of-goal g)- (setq p (+ p 2) q (- q 2))- (let ((indent (and (goto-char p) (current-column))))- (delete-region p q) (insert newtxt)- (while (re-search-backward "^" p t)- (insert-char ? indent) (backward-char (1+ indent)))))))--(defun agda2-forget-all-goals ()- "Remove all goal annotations.-\(Including some text properties which might be used by other-\(minor) modes.)"- (annotation-preserve-mod-p-and-undo- (remove-text-properties (point-min) (point-max)- '(category nil agda2-delim2 nil agda2-delim3 nil- display nil rear-nonsticky nil)))- (let ((p (point-min)))- (while (< (setq p (next-single-char-property-change p 'agda2-gn))- (point-max))- (delete-overlay (car (agda2-goal-at p))))))--(defun agda2-decl-beginning ()- "Find the beginning point of the declaration containing the point.-To do: dealing with semicolon separated decls."- (interactive)- (save-excursion- (let* ((pEnd (point))- (pDef (progn (goto-char (point-min))- (re-search-forward "\\s *" pEnd t)))- (cDef (current-column)))- (while (re-search-forward- "where\\(\\s +\\)\\S \\|^\\(\\s *\\)\\S " pEnd t)- (if (match-end 1)- (setq pDef (goto-char (match-end 1))- cDef (current-column))- (goto-char (match-end 2))- (if (>= cDef (current-column))- (setq pDef (point)- cDef (current-column))))- (forward-char))- (goto-char pDef)- (if (equal (current-word) "mutual")- (or (match-end 2) (match-end 1))- pDef))))--(defun agda2-beginning-of-decl ()- (interactive)- (goto-char (agda2-decl-beginning)))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Comments and paragraphs--(defun agda2-comments-and-paragraphs-setup nil- "Set up comment and paragraph handling for Agda mode."-- ;; Syntax table setup for comments is done elsewhere.-- ;; Enable highlighting of comments via Font Lock mode (which uses- ;; the syntax table).- (set (make-local-variable 'font-lock-defaults)- '(nil nil nil nil nil))-- ;; Empty lines (all white space according to Emacs) delimit- ;; paragraphs.- (set (make-local-variable 'paragraph-start) "\\s-*$")- (set (make-local-variable 'paragraph-separate) paragraph-start)-- ;; Support for adding/removing comments.- (set (make-local-variable 'comment-start) "-- ")-- ;; Support for proper filling of text in comments (requires that- ;; Filladapt is activated).- (when (featurep 'filladapt)- (add-to-list (make-local-variable- 'filladapt-token-table)- '("--" agda2-comment))- (add-to-list (make-local-variable 'filladapt-token-match-table)- '(agda2-comment agda2-comment) t)- (add-to-list (make-local-variable 'filladapt-token-conversion-table)- '(agda2-comment . exact))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Go to definition site--(defun agda2-goto-definition-keyboard (&optional other-window)- "Go to the definition site of the name under point (if any).-If this function is invoked with a prefix argument then another window is used-to display the given position."- (interactive "P")- (annotation-goto-indirect (point) other-window))--(defun agda2-goto-definition-mouse (ev prefix)- "Go to the definition site of the name clicked on, if any.-Otherwise, yank (see `mouse-yank-at-click')."- (interactive "e\nP")- (let ((pos (posn-point (event-end ev))))- (if (annotation-goto-possible pos)- (annotation-goto-indirect pos)- ;; FIXME: Shouldn't we use something like- ;; (call-interactively (key-binding ev))? --Stef- (mouse-yank-at-click ev prefix))))--(defun agda2-go-back nil- "Go back to the previous position in which-`agda2-goto-definition-keyboard' or `agda2-goto-definition-mouse' was-invoked."- (interactive)- (annotation-go-back))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;; Implicit arguments--(defun agda2-display-implicit-arguments (&optional arg)- "Toggle display of implicit arguments.-With prefix argument, turn on display of implicit arguments if-the argument is a positive number, otherwise turn it off."- (interactive "P")- (cond ((eq arg nil) (agda2-go t t "toggleImplicitArgs"))- ((and (numberp arg)- (> arg 0)) (agda2-go t t "showImplicitArgs" "True"))- (t (agda2-go t t "showImplicitArgs" "False"))))--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-;;;;--(defun agda2-popup-menu-3 (ev)- "If in a goal, popup the goal menu and call chosen command."- (interactive "e")- (let (choice)- (save-excursion- (and (agda2-goal-at (goto-char (posn-point (event-end ev))))- (setq choice (x-popup-menu ev agda2-goal-map))- (call-interactively- (lookup-key agda2-goal-map (apply 'vector choice)))))))+;; -*- lexical-binding: t -*-+;;; agda2-mode.el --- Major mode for Agda+;; SPDX-License-Identifier: MIT License++;;; Commentary:++;; A major mode for editing Agda (the dependently typed programming+;; language / interactive theorem prover).+;;+;; Major features include:+;;+;; - syntax highlighting.+;;+;; - on the fly Agda interpretation.+;;+;; - goal-driven development+;;+;; - interactive case-splitting+;;+;; - proof search+;;+;; - input support (for utf8 characters)+;;+;; see https://agda.readthedocs.io/ for more information++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; Dependency+++;;; Code:++(defvar agda2-version "2.9.0"+ "The version of the Agda mode.+Note that the same version of the Agda executable must be used.")++(require 'cl-lib)+(require 'compile)+(require 'time-date)+(require 'eri)+(require 'annotation)+(require 'fontset)+(require 'agda-input)+(require 'agda2)+(require 'agda2-highlight)+(require 'agda2-abbrevs)+(require 'agda2-queue)+(require 'xref)+(eval-and-compile+ ;; Load filladapt, if it is installed.+ (condition-case nil+ (require 'filladapt)+ (error nil))+ (unless (fboundp 'overlays-in) (load "overlay")) ; for Xemacs+ (unless (fboundp 'propertize) ; for Xemacs 21.4+ ;; FIXME: XEmacs-21.4 (patch 22) does have `propertize' and so does Emacs-22+ ;; (and agda2-mode doesn't work in Emacs-21, AFAICT).+ (defun propertize (string &rest properties)+ "Return a copy of STRING with text properties added.+First argument is the string to copy.+Remaining arguments form a sequence of PROPERTY VALUE pairs for text+properties to add to the result."+ (let ((str (copy-sequence string)))+ (add-text-properties 0 (length str) properties str)+ str)))+ (unless (fboundp 'prog-mode) ;For Emacs<24.+ (defalias 'prog-mode 'fundamental-mode)))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; Utilities++(defmacro agda2-let (varbind funcbind &rest body)+ "Expands to (let* VARBIND (cl-labels FUNCBIND BODY...)).+Or possibly (let* VARBIND (labels FUNCBIND BODY...))."+ (declare (debug ((&rest [&or symbolp (symbolp form)])+ (&rest (cl-defun))+ body))+ (indent 2))+ ;; Use cl-labels if available to avoid obsolescence warnings.+ `(let* ,varbind (,(if (fboundp 'cl-labels) 'cl-labels 'labels) ,funcbind ,@body)))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; User options++(defgroup agda2 nil+ "Major mode for interactively developing Agda programs."+ :group 'languages)++(defcustom agda2-program-name "agda"+ "The name of the Agda executable."+ :type 'string+ :group 'agda2)++(defcustom agda2-program-args nil+ "Command-line arguments given to the Agda executable (one per string).++Note: Do not give several arguments in the same string.++The flag \"--interaction\" is always included as the first+argument, and does not need to be listed here."+ :type '(repeat string)+ :group 'agda2)++(defvar agda2-backends '("GHC" "GHCNoMain" "JS" "LaTeX" "QuickLaTeX" "HTML")+ "Compilation backends.")++(defcustom agda2-backend+ nil+ "The backend used to compile Agda programs (nil to ask every time)."+ :type 'string+ :group 'agda2)++(defcustom agda2-backend-default-payload+ nil+ "The default payload for interactive backend commands (nil to ask every time)."+ :type 'string+ :group 'agda2)++(defcustom agda2-restart-timeout+ 5+ "The number of seconds to wait before timing out restart attempts.++If nil, never time out."+ :type '(choice (const :tag "No timeout")+ (number :tag "Number of seconds"))+ :group 'agda2)++(defcustom agda2-information-window-max-height+ 0.35+ "The maximum height of the information window.+A multiple of the frame height."+ :type 'number+ :group 'agda2)++(defcustom agda2-fontset-name+ ;; Emacs-23 uses a revamped font engine which should make+ ;; agda2-fontset-name unnecessary in most cases. And if it turns+ ;; out to be necessary, we should probably use face-remapping-alist+ ;; rather than set-frame-font so the special font only applies to+ ;; Agda buffers, and so it applies in all frames where Agda buffers+ ;; are displayed.+ (and (not (boundp 'face-remapping-alist)) "fontset-agda2")+ "Default font to use in the selected frame when activating the Agda mode.+This is only used if it's non-nil and Emacs is not running in a+terminal.++Note that this setting (if non-nil) affects non-Agda buffers as+well, and that you have to restart Emacs if you want settings to+this variable to take effect."+ :type '(choice (string :tag "Fontset name")+ (const :tag "Do not change the font" nil))+ :group 'agda2)++(defcustom agda2-fontset-spec-of-fontset-agda2+ "-*-fixed-Medium-r-Normal-*-18-*-*-*-c-*-fontset-agda2,+ ascii:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO8859-1,+ latin-iso8859-2:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-2,+ latin-iso8859-3:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-3,+ latin-iso8859-4:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-4,+ cyrillic-iso8859-5:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-5,+ greek-iso8859-7:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-7,+ latin-iso8859-9:-*-Fixed-*-r-*-*-18-*-*-*-c-*-iso8859-9,+ mule-unicode-0100-24ff:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO10646-1,+ mule-unicode-2500-33ff:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO10646-1,+ mule-unicode-e000-ffff:-Misc-Fixed-Medium-R-Normal--18-120-100-100-C-90-ISO10646-1,+ japanese-jisx0208:-Misc-Fixed-Medium-R-Normal-ja-18-*-*-*-C-*-JISX0208.1990-0,+ japanese-jisx0212:-Misc-Fixed-Medium-R-Normal-ja-18-*-*-*-C-*-JISX0212.1990-0,+ thai-tis620:-Misc-Fixed-Medium-R-Normal--24-240-72-72-C-120-TIS620.2529-1,+ lao:-Misc-Fixed-Medium-R-Normal--24-240-72-72-C-120-MuleLao-1,+ tibetan:-TibMdXA-fixed-medium-r-normal--16-160-72-72-m-160-MuleTibetan-0,+ tibetan-1-column:-TibMdXA-fixed-medium-r-normal--16-160-72-72-m-80-MuleTibetan-1,+ korean-ksc5601:-Daewoo-Mincho-Medium-R-Normal--16-120-100-100-C-160-KSC5601.1987-0,+ chinese-gb2312:-ISAS-Fangsong ti-Medium-R-Normal--16-160-72-72-c-160-GB2312.1980-0,+ chinese-cns11643-1:-HKU-Fixed-Medium-R-Normal--16-160-72-72-C-160-CNS11643.1992.1-0,+ chinese-big5-1:-ETen-Fixed-Medium-R-Normal--16-150-75-75-C-160-Big5.ETen-0,+ chinese-big5-2:-ETen-Fixed-Medium-R-Normal--16-150-75-75-C-160-Big5.ETen-0"+ "Specification of the \"fontset-agda2\" fontset.+This fontset is only created if `agda2-fontset-name' is+\"fontset-agda2\" and Emacs is not run in a terminal.++Note that the text \"fontset-agda2\" has to be part of the+string (in a certain way; see the default setting) in order for the+agda2 fontset to be created properly.++Note also that the default setting may not work unless suitable+fonts are installed on your system. Refer to the README file+accompanying the Agda distribution for more details.++Note finally that you have to restart Emacs if you want settings+to this variable to take effect."+ :group 'agda2+ :type 'string)++(if (and (equal agda2-fontset-name "fontset-agda2") (display-graphic-p))+ (create-fontset-from-fontset-spec agda2-fontset-spec-of-fontset-agda2 t t))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; Global and buffer-local vars, initialization++(defconst agda2-mode-syntax-table+ (with-syntax-table (make-syntax-table)+ ;; The `standard-syntax-table' marks characters like "[" and "⟨" as delimiters.+ ;; This breaks `symbol-at-point' for identifiers like "[[X]]" when the point+ ;; is on the outer brackets. To fix this, we go through and mark all non-whitespace+ ;; characters as word constitutents, and then patch things up afterwards.+ (map-char-table+ (lambda (range val)+ (unless (memq (car val) (eval-when-compile (mapcar (lambda (c) (car (string-to-syntax c))) '(" " "w"))))+ (modify-syntax-entry range "w")))+ (char-table-parent (syntax-table)))++ ;; String literals+ ;;+ ;; We do not include ?\' as a quote char, as it can+ ;; be used in identifiers.+ (modify-syntax-entry ?\" "\"")++ ;; Comments+ ;;+ ;; We use the "c" alternative comment style over "b", as "b"+ ;; only can be attached to the second char of a starting sequence+ ;; or the first char of an ending sequence. This leads to ambiguities,+ ;; as "{-" and "--" both have "-" as their second char.+ (modify-syntax-entry ?\{ "(}1nc")+ (modify-syntax-entry ?\} "){4nc")+ (modify-syntax-entry ?\n ">")+ ;; [HACK: Reed M, 04/03/2026]+ ;; We mark "-" as a word character so that `word-at-point' selects+ ;; whole identifiers in kebab-case like "foo-bar-baz". However, we+ ;; also mark the sequences "--", "{-", and "-}" as comment sequences.+ ;; This makes `comment-kill' function, but has the somewhat unintended+ ;; side effect of making killing off "--bar" in an identifier like "foo--bar".+ (modify-syntax-entry ?- "w 123")++ ;; Parens+ (modify-syntax-entry ?\( "()")+ (modify-syntax-entry ?\) ")(")+ ;; Adding ⦃⦄ and ⦇⦈ is a bit dubious here, as ⦃a⦄ and ⦇a⦈ are+ ;; valid identifers. However, it is more useful to be able+ ;; to get matching paren highlights then it is to support this+ ;; somewhat suspicious grammatical choice.+ (modify-syntax-entry ?⦃ "(⦄")+ (modify-syntax-entry ?⦄ ")⦃")+ (modify-syntax-entry ?⦇ "(⦈")+ (modify-syntax-entry ?⦈ ")⦇")++ ;; Punctuation+ (modify-syntax-entry ?. ".")+ (modify-syntax-entry ?\; ".")+ ;; [FIXME: Reed M, 04/03/2026]+ ;; Why is this marked as puncutation?+ (modify-syntax-entry ?! ".")++ (syntax-table))+ "Syntax table used by `agda2-mode':++\" | String delimiter.+- | Comment character, word constituent.+{} | Comment character, parentheses.+\n | Comment ender.+⦃⦄⦇⦈() | Parenthesis.+.;! | Punctuation.++Remaining characters inherit their syntax classes from the+`standard-syntax-table' if that table treats them as matching+whitespace. Otherwise they are treated as word+constituents.")++(defconst agda2-command-table+ `(+ (agda2-load "\C-c\C-l" (global) "Load")+ (agda2-load "\C-c\C-x\C-l")+ (agda2-compile "\C-c\C-x\C-c" (global) "Compile")+ (agda2-backend-cmd "\C-c\C-i" (global) "Run backend interaction")+ (agda2-quit "\C-c\C-x\C-q" (global) "Quit")+ (agda2-restart "\C-c\C-x\C-r" (global) "Kill and restart Agda")+ (agda2-abort "\C-c\C-x\C-a" (global) "Abort a command")+ (agda2-remove-annotations "\C-c\C-x\C-d" (global) "Remove goals and highlighting (\"deactivate\")")+ (agda2-display-implicit-arguments "\C-c\C-x\C-h" (global) "Toggle display of hidden arguments")+ (agda2-display-irrelevant-arguments "\C-c\C-x\C-i" (global) "Toggle display of irrelevant arguments")+ (agda2-show-constraints ,(kbd "C-c C-=") (global) "Show constraints")+ (agda2-solve-maybe-all ,(kbd "C-c C-s") (local global) "Solve constraints")+ (agda2-show-goals ,(kbd "C-c C-?") (global) "Show goals")+ (agda2-next-goal "\C-c\C-f" (global) "Next goal") ; Forward.+ (agda2-previous-goal "\C-c\C-b" (global) "Previous goal") ; Back.+ (agda2-give ,(kbd "C-c C-SPC") (local) "Give")+ (agda2-elaborate-give ,(kbd "C-c C-m") (local) "Elaborate and Give")+ (agda2-refine "\C-c\C-r" (local) "Refine")+ (agda2-mimer-maybe-all "\C-c\C-a" (local global) "Auto")+ (agda2-make-case "\C-c\C-c" (local) "Case")+ (agda2-goal-type "\C-c\C-t" (local) "Goal type")+ (agda2-show-context "\C-c\C-e" (local) "Context (environment)")+ (agda2-helper-function-type "\C-c\C-h" (local) "Helper function type")+ (agda2-infer-type-maybe-toplevel "\C-c\C-d" (local global) "Infer (deduce) type")+ (agda2-why-in-scope-maybe-toplevel "\C-c\C-w" (local global) "Explain why a particular name is in scope")+ (agda2-goal-and-context ,(kbd "C-c C-,") (local) "Goal type and context")+ (agda2-goal-and-context-and-inferred ,(kbd "C-c C-.") (local) "Goal type, context and inferred type")+ (agda2-goal-and-context-and-checked ,(kbd "C-c C-;") (local) "Goal type, context and checked type")+ (agda2-search-about-toplevel ,(kbd "C-c C-z") (local global) "Search About")+ (agda2-module-contents-maybe-toplevel ,(kbd "C-c C-o") (local global) "Module contents")+ (agda2-compute-normalised-maybe-toplevel "\C-c\C-n" (local global) "Evaluate term to normal form")+ (describe-char nil (global) "Information about the character at point")+ (agda2-comment-dwim-rest-of-buffer ,(kbd "C-c C-x M-;") (global) "Comment/uncomment the rest of the buffer")+ (agda2-display-program-version nil (global) "Version")+ (agda2-set-program-version "\C-c\C-x\C-s" (global) "Switch to another version of Agda")+ (eri-indent ,(kbd "TAB"))+ (eri-indent-reverse [S-iso-lefttab])+ (eri-indent-reverse [S-lefttab])+ (eri-indent-reverse [S-tab])+ (agda2-goto-definition-mouse [mouse-2]))+ "Table of commands, used to build keymaps and menus.+Each element has the form (CMD &optional KEYS WHERE DESC) where+CMD is a command; KEYS is its key binding (if any); WHERE is a+list which should contain \\='local if the command should exist in+the goal menu and \\='global if the command should exist in the main+menu; and DESC is the description of the command used in the+menus.")++(defvar agda2-movement-repeat-map (make-sparse-keymap))+(defcustom agda2-repeatable-commands+ '(agda2-next-goal+ agda2-previous-goal+ agda2-give+ agda2-refine+ agda2-make-case+ agda2-goal-and-context+ agda2-goal-and-context-and-inferred+ agda2-goal-and-context-and-checked)+ "List of commands that should be supported by `repeat-mode'.+This feature added in Emacs 28 enables a transient keymap after invoking+a command that binds shorter key chords. For Agda, the shorter keys+derived from the last key of the global key chord (so \"C-c C-f\" just+becomes \"C-f\" until you invoke a non-repeatable command). To make use+of this feature, the global minor mode `repeat-mode' must be enabled+separately."+ :set (lambda (sym val)+ (let ((m (make-sparse-keymap)))+ (map-keymap+ (lambda (_ev def)+ (when (symbolp def)+ (put def 'repeat-map nil)))+ agda2-movement-repeat-map)+ (dolist (fn val)+ (let* ((chord (cadr (assq fn agda2-command-table)))+ (key (aref chord (1- (length chord))))+ (kbd (vector key))+ (prev (lookup-key m kbd)))+ (when prev+ (error "Repeat-key duplicate: %S for `%S' already bound for `%S'"+ kbd fn prev))+ (define-key m kbd fn))+ (put fn 'repeat-map agda2-movement-repeat-map))+ (setq agda2-movement-repeat-map m))+ (custom-set-default sym val))+ :type '(repeat function))++(defvar agda2-mode-map+ (let ((map (make-sparse-keymap "Agda mode")))+ (define-key map [menu-bar Agda]+ (cons "Agda" (make-sparse-keymap "Agda")))+ (define-key map [down-mouse-3] 'agda2-popup-menu-3)+ (dolist (d (reverse agda2-command-table))+ (cl-destructuring-bind (f &optional keys kinds desc) d+ (if keys (define-key map keys f))+ (if (member 'global kinds)+ (define-key map+ (vector 'menu-bar 'Agda (intern desc)) (cons desc f)))))+ map)+ "Keymap for `agda2-mode'.")++(defvar agda2-goal-map+ (let ((map (make-sparse-keymap "Agda goal")))+ (dolist (d (reverse agda2-command-table))+ (cl-destructuring-bind (f &optional _keys kinds desc) d+ (if (member 'local kinds)+ (define-key map+ (vector (intern desc)) (cons desc f)))))+ map)+ "Keymap for agda2 goal menu.")++(defvar agda2-info-buffer nil+ "Agda information buffer.")++(defvar agda2-process-buffer nil+ "Agda subprocess buffer.+Set in `agda2-restart'.")++(defvar agda2-process nil+ "Agda subprocess.+Set in `agda2-restart'.")++(defvar agda2-in-progress nil+ "Is the Agda process currently busy?+Valid values: `nil' (not busy), `busy' (busy),+`not-so-busy' (busy with something that should typically+terminate fairly quickly).")++;; Some buffer locals+(defvar agda2-buffer-external-status ""+ "External status of an `agda2-mode' buffer (dictated by the Haskell side).")+(make-variable-buffer-local 'agda2-buffer-external-status)++(defvar agda2-output-prompt "Agda2> "+ "The Agda2 buffer's prompt.")++(defconst agda2-help-address+ ""+ "Address accepting submissions of bug reports and questions.")++;; Annotation for a goal+;; {! .... !}+;; ---------- overlay: agda2-gn num, face highlight, after-string num,+;; modification-hooks (agda2-protect-goal-markers)+;; - text-props: category agda2-delim1+;; - text-props: category agda2-delim2+;; - text-props: category agda2-delim3+;; - text-props: category agda2-delim4+;;+;; Char categories for {! ... !}+(defvar agda2-open-brace "{")+(defvar agda2-close-brace " }")+(setplist 'agda2-delim1 `(display ,agda2-open-brace))+(setplist 'agda2-delim2 `(display ,agda2-open-brace rear-nonsticky t+ agda2-delim2 t))+(setplist 'agda2-delim3 `(display ,agda2-close-brace agda2-delim3 t))+(setplist 'agda2-delim4 `(display ,agda2-close-brace rear-nonsticky t))++;; Note that strings used with the display property are compared by+;; reference. If the agda2-*-brace definitions were inlined, then+;; goals would be displayed as "{{ }}n" instead of "{ }n".++;; The following variables are used by the filter process,+;; `agda2-output-filter'. Their values are only modified by the filter+;; process, `agda2-go', `agda2-restart', `agda2-abort-highlighting',+;; and `agda2-abort-done'.++(defvar agda2-output-chunk-incomplete (agda2-queue-empty)+ "Buffer for incomplete lines.+\(See `agda2-output-filter'.)")+(make-variable-buffer-local 'agda2-output-chunk-incomplete)++(defvar agda2-last-responses nil+ "Response commands which should be run after other commands.+The command which arrived last is stored first in the list.")+(make-variable-buffer-local 'agda2-last-responses)++(defvar agda2-file-buffer nil+ "The Agda buffer.+Note that this variable is not buffer-local.")+++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; agda2-mode++;;;###autoload+(add-to-list 'completion-ignored-extensions ".agdai")+;;;###autoload+(add-to-list 'auto-mode-alist '("\\.l?agda\\'" . agda2-mode))+;;;###autoload+(modify-coding-system-alist 'file "\\.l?agda\\'" 'utf-8)+;;;###autoload+(define-derived-mode agda2-mode prog-mode "Agda"+ "Major mode for Agda files.++The following paragraph does not apply to Emacs 23 or newer.++ Note that when this mode is activated the default font of the+ current frame is changed to the fontset `agda2-fontset-name'.+ The reason is that Agda programs often use mathematical symbols+ and other Unicode characters, so we try to provide a suitable+ default font setting, which can display many of the characters+ encountered. If you prefer to use your own settings, set+ `agda2-fontset-name' to nil.++Special commands:+\\{agda2-mode-map}"+ :group 'agda2+ :interactive t+ :after-hook (agda2-initialize)++ (if (boundp 'agda2-include-dirs)+ (display-warning 'agda2 "Note that the variable agda2-include-dirs is+no longer used. You may want to update your configuration. You+have at least two choices:+* Use the library management system.+* Set the include path using agda2-program-args.++One way to avoid seeing this warning is to make sure that+agda2-include-dirs is not bound." :warning))++ (setq local-abbrev-table agda2-mode-abbrev-table+ indent-tabs-mode nil+ mode-line-process+ '((:eval (unless (eq 0 (length agda2-buffer-external-status))+ (concat ":" agda2-buffer-external-status)))))+ (let ((l '(max-specpdl-size 2600+ max-lisp-eval-depth 2800)))+ (while l (set (make-local-variable (pop l)) (pop l))))+ (if (and (display-graphic-p) agda2-fontset-name)+ (condition-case nil+ (set-frame-font agda2-fontset-name)+ (error (error "Unable to change the font; change agda2-fontset-name or tweak agda2-fontset-spec-of-fontset-agda2"))))+ ;; Deactivate highlighting if the buffer is edited before+ ;; typechecking is complete.+ (add-hook 'first-change-hook 'agda2-abort-highlighting nil 'local)+++ ;; Make sure that Font Lock mode is not used.+ (font-lock-mode 0)+ (agda2-highlight-setup)++ (agda2-comments-and-paragraphs-setup)+ (force-mode-line-update)+ ;; Don't take script into account when determining word boundaries+ (set (make-local-variable 'word-combining-categories) (cons '(nil . nil) word-combining-categories))+ (activate-input-method "Agda")+ ;; Highlighting etc. is removed when we switch from the Agda mode.+ ;; Use case: When a file M.lagda with a local variables list+ ;; including "mode: latex" is loaded chances are that the Agda mode+ ;; is activated before the LaTeX mode, and the LaTeX mode does not+ ;; seem to remove the text properties set by the Agda mode.+ (add-hook 'change-major-mode-hook 'agda2-quit nil 'local)+ ;; Enable Xref+ (add-hook 'xref-backend-functions #'agda2-xref-backend -90 t))++(defun agda2-initialize ()+ "Initialize the `agda2-process'."+ (unless (eq 'run (agda2-process-status))+ (agda2-restart))+ (condition-case err+ (agda2-highlight-reload)+ (error (message "Highlighting not loaded: %s"+ (error-message-string err)))))++(defun agda2-restart ()+ "Tries to start or restart the Agda process."+ (interactive)++ ;; Kill any running instance of the Agda process.+ (condition-case nil+ (agda2-term)+ (error nil))++ ;; Check that the right version of Agda is used.+ (let* ((coding-system-for-read 'utf-8)+ (output (with-output-to-string+ (call-process agda2-program-name+ nil standard-output nil "--version")))+ (version (and (string-match "^Agda version \\([0-9.]+\\)" output)+ (match-string 1 output))))+ (unless (equal version agda2-version)+ (error "The Agda mode's version (%s) does not match that of %s (%s)."+ agda2-version+ agda2-program-name (or version "unknown"))))++ (let ((all-program-args (cons "--interaction" agda2-program-args)))++ ;; Check that the arguments are not malformed.+ (let* ((coding-system-for-read 'utf-8)+ (status)+ (output+ (with-output-to-string+ (setq status+ (apply 'call-process agda2-program-name+ nil standard-output nil all-program-args)))))+ (unless (equal status 0)+ (error "Failed to start the Agda process:\n%s" output)))++ ;; Start the Agda process.+ (let ((agda2-bufname "*agda2*"))++ (let ((process-connection-type nil)) ; Pipes are faster than PTYs.+ (setq agda2-process+ (apply 'start-process "Agda2" agda2-bufname+ agda2-program-name all-program-args)))++ (set-process-coding-system agda2-process 'utf-8 'utf-8)+ (set-process-query-on-exit-flag agda2-process nil)+ (set-process-filter agda2-process 'agda2-output-filter)+ (setq agda2-in-progress 'busy+ agda2-file-buffer (current-buffer))++ (with-current-buffer agda2-bufname+ (setq agda2-process-buffer (current-buffer)+ mode-name "Agda executable"+ agda2-last-responses nil)+ (set-buffer-file-coding-system 'utf-8))++ ;; Block until we see an initial prompt.+ ;;+ ;; This avoids a race condition triggered by sending a command before we've had+ ;; a chance to read any process output, which in turn makes `agda2-output-filter'+ ;; erroneously set `agda2-in-progress' to nil when it sees the initial prompt.+ (while agda2-in-progress+ (unless (accept-process-output agda2-process agda2-restart-timeout nil t)+ (error "Failed to start the Agda process")))++ (agda2-remove-annotations))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; Communicating with Agda++(defun agda2-raise-error ()+ "Raises an error.+The error message directs the user to the *agda2* buffer."+ (error "Problem encountered. The *agda2* buffer can perhaps explain why."))++(defun agda2-running-p nil+ "Does the *agda2* buffer exist, and is the Agda2 process running?"+ (and (buffer-live-p agda2-process-buffer)+ (eq (agda2-process-status) 'run)))++(defun agda2-send-command (restart &rest args)+ "Send a command to the Agda process.+Sends the list of strings ARGS to the process. If RESTART is+non-nil and the process is not running, or the *agda2*+buffer does not exist, then an attempt is made to restart the+process."+ (when (and restart (not (agda2-running-p)))+ ;; Try restarting automatically, but only once, in case there is+ ;; some major problem.+ (agda2-restart)+ (unless (agda2-running-p)+ (agda2-raise-error)))+ (let ((command (apply 'concat (agda2-intersperse " " args))))+ (with-current-buffer agda2-process-buffer+ (goto-char (point-max))+ (insert command)+ (insert "\n")+ (process-send-string agda2-process (concat command "\n")))))++(defun agda2-go (save highlight how-busy do-abort &rest args)+ "Executes commands in the Agda2 interpreter.+Sends the list of strings ARGS to the Agda2 interpreter, waits+for output and executes the responses, if any.++If SAVE is \\='save, then the buffer is saved first.++If HIGHLIGHT is non-nil, then the buffer's syntax highlighting+may be updated. This is also the case if the Agda process is+busy (or `not-so-busy') and `agda2-highlight-in-process' is+non-nil.++The value HOW-BUSY should be `busy' if it should not be possible+to invoke other commands while this command is running (with the+exception of commands for which DO-ABORT is nil). Otherwise it+should be `not-so-busy' (which should only be used for commands+that typically terminate fairly quickly).++If the Agda process is busy (or `not-so-busy'), and the current+buffer does not match `agda2-file-buffer', then the command is+not executed and an error is raised. The same applies if DO-ABORT+is non-nil and the Agda process is `busy'."++ ; Check that how-busy is well-formed.+ (cl-assert (or (equal how-busy 'busy)+ (equal how-busy 'not-so-busy)))++ (when (and agda2-in-progress+ (not (equal agda2-file-buffer+ (current-buffer))))+ (error "Agda is busy with something in the buffer %s"+ agda2-file-buffer))++ (when (and do-abort+ (equal agda2-in-progress 'busy))+ (error "Agda is busy with something+\(you have the option to abort or restart Agda)"))++ (setq agda2-file-buffer (current-buffer))++ (setq agda2-highlight-in-progress+ (or highlight+ (and agda2-in-progress+ agda2-highlight-in-progress)))++ (unless agda2-in-progress+ (setq agda2-output-chunk-incomplete (agda2-queue-empty)))++ (setq agda2-in-progress+ (if (or (equal how-busy 'busy)+ (equal agda2-in-progress 'busy))+ 'busy+ 'not-so-busy))++ (when (equal save 'save) (save-buffer))++ (apply 'agda2-send-command+ 'restart+ "IOTCM"+ (agda2-string-quote (buffer-file-name))+ (if highlight (agda2-highlight-level) "None")+ "Indirect"+ "("+ (append args '(")"))))++(defun agda2-abort ()+ "Tries to abort the current computation, if any.+May be more efficient than restarting Agda."+ (interactive)+ (agda2-send-command nil+ "IOTCM"+ (agda2-string-quote (buffer-file-name))+ "None"+ "Indirect"+ "Cmd_abort"))++(defun agda2-abort-done ()+ "Resets certain variables.+Intended to be used by the backend if an abort command was+successful."+ (declare (agda2-command ()))+ (agda2-info-action "*Aborted*" "Aborted." t)+ (setq agda2-highlight-in-progress nil+ agda2-last-responses nil))++(defun agda2-output-filter (_proc chunk)+ "Evaluate the Agda process's commands.+This filter function assumes that every line contains either some+kind of error message (which cannot be parsed as a list), or+exactly one command. Incomplete lines are stored in a+buffer (`agda2-output-chunk-incomplete').++Every command is run by this function, unless it has the form+\"(('last . priority) . cmd)\", in which case it is run by+`agda2-run-last-commands' at the end, after the Agda2 prompt+has reappeared, after all non-last commands, and after all+interactive highlighting is complete. The last commands can have+different integer priorities; those with the lowest priority are+executed first.++Non-last commands should not call the Agda process.++All commands are echoed to the *agda2* buffer, with the exception+of commands of the form \"(agda2-highlight-... ...)\".++The non-last commands are run in the order in which they appear.++When the prompt has been reached highlighting annotations are+reloaded from `agda2-highlighting-file', unless+`agda2-highlighting-in-progress' is nil."++ ;; Beware: the buffer may have been killed in the mean time. E.g. when+ ;; viewing an attachment containing Agda code in Gnus, Gnus will+ ;; create a temp buffer, set it in agda2-mode, call font-lock-ensure on it+ ;; (which won't know that it needs to wait for some process to reply), then+ ;; extract the fontified text and kill the temp buffer; so when Agda+ ;; finally answers, the temp buffer is long gone.+ (when (buffer-live-p agda2-file-buffer)++ (let (;; The input lines in the current chunk.+ (lines (split-string chunk "\n"))++ ;; Non-last commands found in the current chunk (reversed).+ (non-last-commands ())++ ;; Last incomplete line, if any.+ (output-chunk-incomplete ""))+ (with-current-buffer agda2-file-buffer+ (when (consp lines)+ (agda2-queue-enqueue agda2-output-chunk-incomplete (pop lines))+ (when (consp lines)+ ;; The previous uncomplete chunk is now complete.+ (push (agda2-queue-to-string agda2-output-chunk-incomplete)+ lines)++ ;; Stash away the last incomplete line, if any. (Note that+ ;; (split-string "...\n" "\n") evaluates to (... "").)+ (setq output-chunk-incomplete (car (last lines))+ agda2-output-chunk-incomplete+ (agda2-queue-from-string output-chunk-incomplete))++ ;; Handle every complete line.+ (dolist (line (butlast lines))+ (let* (;; The command. Lines which cannot be parsed as a single+ ;; list, without any junk, are ignored.+ (cmd (condition-case nil+ (let ((result (read-from-string line)))+ (if (and (listp (car result))+ (= (cdr result) (length line)))+ (car result)))+ (error nil)))+ (is-highlighting-command+ (and cmd+ (symbolp (car cmd))+ (let ((case-fold-search nil))+ (string-match "^agda2-highlight-"+ (symbol-name (car cmd)))))))++ ;; Do not echo highlighting commands.+ (unless is-highlighting-command+ (with-current-buffer agda2-process-buffer+ (save-excursion+ (goto-char (point-max))+ (insert line)+ (insert "\n"))))+ (when cmd+ (if (equal 'last (car-safe (car cmd)))+ (push (cons (cdr (car cmd)) (cdr cmd))+ agda2-last-responses)+ (push cmd non-last-commands)))))++ ;; Run non-last commands.+ (mapc 'agda2-exec-response (nreverse non-last-commands)))++ ;; Check if the prompt has been reached. This function assumes+ ;; that the prompt does not include any newline characters.+ (when (agda2-queue-is-prefix-of agda2-output-prompt+ agda2-output-chunk-incomplete)+ (with-current-buffer agda2-process-buffer+ (insert output-chunk-incomplete))+ (setq agda2-output-chunk-incomplete (agda2-queue-empty)+ agda2-in-progress nil+ agda2-last-responses (nreverse agda2-last-responses))++ (agda2-run-last-commands)))))))++(defun agda2-run-last-commands nil+ "Execute the last commands in the right order.+\(After the prompt has reappeared.) See `agda2-output-filter'."++ ;; with-current-buffer is used repeatedly below, because some last+ ;; commands may switch the focus to another buffer.++ (while (with-current-buffer agda2-file-buffer+ (and (not agda2-in-progress) (consp agda2-last-responses)))+ (with-current-buffer agda2-file-buffer+ ;; The list is sorted repeatedly because this function may be+ ;; called recursively (via `agda2-exec-response').+ (setq agda2-last-responses (sort agda2-last-responses+ (lambda (x y) (<= (car x) (car y)))))+ (let ((r (pop agda2-last-responses)))+ (agda2-exec-response (cdr r)))))++ ;; Unset agda2-highlight-in-progress when all the asynchronous+ ;; commands have terminated.+ (unless agda2-in-progress+ (setq agda2-highlight-in-progress nil)))++(defun agda2-abort-highlighting nil+ "Abort any interactive highlighting.+This function should be used in `first-change-hook'."+ (when agda2-highlight-in-progress+ (setq agda2-highlight-in-progress nil)+ (message "\"%s\" has been modified. Interrupting highlighting."+ (buffer-name (current-buffer)))))++(defun agda2-goal-cmd (cmd save &optional want ask &rest args)+ "Reads input from goal or minibuffer and sends command to Agda.++An error is raised if point is not in a goal.++The command sent to Agda is++ CMD <goal number> <goal range> <user input> ARGS.++The user input is computed as follows:++* If WANT is nil, then the user input is the empty string.++* If WANT is a string, and either ASK is non-nil or the goal only+ contains whitespace, then the input is taken from the+ minibuffer. In this case WANT is used as the prompt string.++* Otherwise (including if WANT is \\='goal) the goal contents are+ used.++If the user input is not taken from the goal, then an empty goal+range is given.++If SAVE is \\='save, then the buffer is saved just before the+command is sent to Agda (if it is sent)."+ (cl-multiple-value-bind (o g) (agda2-goal-at (point))+ (unless g (error "For this command, please place the cursor in a goal"))+ (let ((txt (buffer-substring-no-properties (+ (overlay-start o) 2)+ (- (overlay-end o) 2)))+ (input-from-goal nil))+ (cond ((null want) (setq txt ""))+ ((and (stringp want)+ (or ask (string-match "\\`\\s *\\'" txt)))+ (setq txt (read-string (concat want ": ") nil nil txt t)))+ (t (setq input-from-goal t)))+ (apply 'agda2-go save input-from-goal 'busy t cmd+ (format "%d" g)+ (if input-from-goal (agda2-goal-Range o) (agda2-mkRange nil))+ (agda2-string-quote txt) args))))++(defun agda2-exec-response (response)+ "Execute RESPONSE if recognised by `agda2-handler-alist'."+ (cl-assert (symbolp (car-safe response)))+ ;; Agda sends us a an S-expression that we can just `eval'uate. To+ ;; avoid arbitrary code execution and ensure that the commands Agda+ ;; sends us are well-formed, we use `apply' without evaluating any+ ;; arguments. The symbol of the invoked function must have a+ ;; `agda2-safe-function' symbol property asserting the expected+ ;; types of all arguments, w.r.t `cl-typep'.+ (let* ((inhibit-read-only t)+ (func (car response))+ (safe-p (plist-member (symbol-plist func) 'agda2-safe-function))+ (safe-data (cadr safe-p))+ (args '()))+ (unless safe-p+ (error "The function `%S' is not a valid Agda command" func))+ ;; Check each argument+ (dolist (arg (cdr response))+ (when (null safe-data)+ (error "More arguments than expected for `%S' (%S, got %S)"+ func safe-data response))+ (when (eq (car-safe arg) 'quote) ;unquote arguments+ (setq arg (cadr arg)))+ (let ((type (pop safe-data)))+ (unless (cl-typep arg type)+ (error "The function `%S' was invoked with %S which is not a %S"+ func arg type)))+ (push arg args))+ (condition-case err+ (with-local-quit+ (apply func (nreverse args)))+ (error (warn "Error while evaluating %S: %S" response err)))))++++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; User commands and response processing++(defun agda2-load ()+ "Load current buffer."+ (interactive)+ (agda2-go 'save t 'busy t "Cmd_load"+ (agda2-string-quote (buffer-file-name))+ (agda2-list-quote agda2-program-args)+ ))++(defun agda2-read-backend ()+ "Get the currently set backend from the `agda2-backend' variable,+or ask the user for input in case the variable is not set."+ (let ((name (cond+ ((equal agda2-backend "MAlonzo") "GHC")+ ((equal agda2-backend "MAlonzoNoMain") "GHCNoMain")+ ((equal agda2-backend nil)+ (completing-read "Backend: " agda2-backends nil nil nil nil nil 'inherit-input-method))+ (t agda2-backend))))+ (when (equal name "") (error "No backend chosen"))+ name))++(defun agda2-compile (backend)+ "Compile the current module using BACKEND.++The variable `agda2-backend' determines which backend is used."+ (interactive (list (agda2-read-backend)))+ (agda2-go 'save t 'busy t "Cmd_compile"+ backend+ (agda2-string-quote (buffer-file-name))+ (agda2-list-quote agda2-program-args)+ ))++(defun agda2-backend-cmd (backend payload)+ "Run the current backend's (from variable `agda2-backend`) interaction command."+ (interactive (list (agda2-read-backend) (or agda2-backend-default-payload (read-string "Payload: "))))+ (if (agda2-goal-at (point))+ (agda2-goal-cmd "Cmd_backend_hole" nil 'goal nil backend (agda2-string-quote payload))+ (agda2-go 'save t 'busy t "Cmd_backend_top" backend (agda2-string-quote payload))+ )+)++(defmacro agda2-maybe-forced (name comment cmd save want)+ "This macro constructs a function NAME which runs CMD.+COMMENT is used to build the function's comment. The function+NAME takes a prefix argument which tells whether it should+apply force or not when running CMD (through+`agda2-goal-cmd';+SAVE is used as `agda2-goal-cmd's SAVE argument and+WANT is used as `agda2-goal-cmd's WANT argument)."+ (let ((eval (make-symbol "eval")))+ `(defun ,name (&optional prefix)+ ,(concat comment ".++The action depends on the prefix argument:++* If the prefix argument is `nil' (i.e., if no prefix argument is+ given), then no force is applied.++* If any other prefix argument is used (for instance, if C-u is+ typed once or twice right before the command is invoked), then+ force is applied.")+ (interactive "P")+ (let ((,eval (cond ((equal prefix nil) "WithoutForce")+ ("WithForce"))))+ (agda2-goal-cmd (concat ,cmd " " ,eval)+ ,save ,want)))))++(agda2-maybe-forced+ agda2-give+ "Give to the goal at point the expression in it"+ "Cmd_give"+ 'save+ "expression to give")++;; (defun agda2-give()+;; "Give to the goal at point the expression in it" (interactive)+;; (agda2-goal-cmd "Cmd_give" 'save "expression to give"))++(defun agda2-give-action (old-g paren)+ "Update the goal OLD-G with the expression in it."+ (declare (agda2-command (integer (or (eql paren)+ (eql no-paren)+ string+ null))))+ (let+ ;; Don't run modification hooks: we don't want this to+ ;; trigger agda2-abort-highlighting.+ ((inhibit-modification-hooks t))+ (agda2-update old-g paren)))++(defun agda2-refine (pmlambda)+ "Refine the goal at point.+If the goal contains an expression e, and some \"suffix\" of the+type of e unifies with the goal type, then the goal is replaced+by e applied to a suitable number of new goals.++PMLAMBDA is only used if the goal has a functional type.+When the prefix argument is given a pattern maching lambda will+be inserted, otherwise a standard lambda will be used.++If the goal is empty, the goal type is a data type, and there is+exactly one constructor which unifies with this type, then the+goal is replaced by the constructor applied to a suitable number+of new goals."+ (interactive "P")+ (if pmlambda+ (agda2-goal-cmd "Cmd_refine_or_intro True" 'save 'goal)+ (agda2-goal-cmd "Cmd_refine_or_intro False" 'save 'goal)))++(defun agda2-make-case ()+ "Refine the pattern variables given in the goal.+Assumes that <clause> = {!<variables>!} is on one line."+ (interactive)+ (agda2-goal-cmd "Cmd_make_case" 'save "pattern variables to case (empty for split on result)"))++(defun agda2-make-case-action (newcls)+ "Replace the line at point with new clauses NEWCLS and reload."+ (declare (agda2-command (list)))+ (agda2-forget-all-goals);; we reload later anyway.+ (let* ((p0 (point))+ (p1 (goto-char (+ (current-indentation) (line-beginning-position))))+ (indent (current-column))+ cl)+ (delete-region p1 (line-end-position))+ (while (setq cl (pop newcls))+ (insert cl)+ (if newcls (insert "\n" (make-string indent ? ))))+ (goto-char p0))+ (agda2-load))++(defun agda2-make-case-action-extendlam (newcls)+ "Replace definition of extended lambda with new clauses NEWCLS and reload."+ (declare (agda2-command (list)))+ (agda2-forget-all-goals);; we reload later anyway.+ (let* ((p0 (point))+ (pmax (re-search-forward "!}"))+ (bracketCount 0)+ (p1 (goto-char (+ (current-indentation) (line-beginning-position))))+ (indent (current-column))+ cl)+ (goto-char p0)+ (re-search-backward "{!")+ (while (and (not (equal (preceding-char) ?\;)) (>= bracketCount 0) (> (point) p1))+ (backward-char)+ (if (equal (preceding-char) ?}) (cl-incf bracketCount))+ (if (equal (preceding-char) ?{) (cl-decf bracketCount)))+ (let* ((is-lambda-where (= (point) p1))+ (p (point)))+ (delete-region (point) pmax)+ (if (not is-lambda-where) (insert " "))+ (while (setq cl (pop newcls))+ (insert cl)+ (if newcls (if is-lambda-where (insert "\n" (make-string indent ? )) (insert " ; "))))+ (goto-char p)))+ (agda2-load))++(defun agda2-status-action (status)+ "Display the string STATUS in the current buffer's mode line.+\(precondition: the current buffer has to use the Agda mode as the+major mode)."+ (declare (agda2-command (string)))+ (setq agda2-buffer-external-status status)+ (force-mode-line-update))++(defmacro agda2-information-buffer (buffer kind name-of-mode title)+ "Used to define functions like `agda2-info-buffer'."+ `(defun ,buffer nil+ ,(concat "Creates the Agda " kind+ " buffer, if it does not already exist.+The buffer is returned.")+ (unless (buffer-live-p ,buffer)+ (setq ,buffer+ (generate-new-buffer ,title))++ (with-current-buffer ,buffer+ (compilation-mode ,name-of-mode)+ ;; Support for jumping to positions mentioned in the text.+ (set (make-local-variable 'compilation-error-regexp-alist)+ '(("\\([\\\\/][^[:space:]]*\\):\\([0-9]+\\)\\.\\([0-9]+\\)\\(-\\(\\([0-9]+\\)\\.\\)?\\([0-9]+\\)\\)?"+ 1 (2 . 6) (3 . 7))))++ ;; compilation-mode adds font-lock keywords for highlighting+ ;; things like "make: ", assuming that they're command output.+ ;;+ ;; This is annoying because sometimes our messages get+ ;; line-wrapped to start with "declaration:" (e.g. Issue2899).+ ;;+ ;; Conveniently all of these stupid highlights are in a variable+ ;; that we can just undo!+ (font-lock-remove-keywords nil compilation-mode-font-lock-keywords)+ (font-lock-flush)++ ;; Do not skip errors that start in the same position as the+ ;; current one.+ (set (make-local-variable 'compilation-skip-to-next-location) nil)++ ;; No support for recompilation. The key binding is removed, and+ ;; attempts to run `recompile' will (hopefully) result in an+ ;; error.+ (let ((map (copy-keymap (current-local-map))))+ (define-key map (kbd "g") 'undefined)++ ;; Hijack the bindings for going to definition in the info+ ;; buffer, away from compilation-mode's, into something that+ ;; can read definition sites from highlighting info.+ (define-key map (kbd "RET") #'xref-find-definitions)+ (define-key map '[mouse-2] #'agda2-goto-definition-mouse)++ (use-local-map map))++ (set (make-local-variable 'compile-command)+ 'agda2-does-not-support-compilation-via-the-compilation-mode)++ (set-syntax-table agda2-mode-syntax-table)+ (set (make-local-variable 'word-combining-categories) (cons '(nil . nil) word-combining-categories))+ (set-input-method "Agda")+ ;; Andreas, 2025-08-05, PR #8047.+ ;; We setup highlighting so that annotation-bindings is defined+ ;; and can be accessed by annotation-annotate.+ ;; This allows us to create Agda-style highlighting from aspects+ ;; also in the Agda information buffer.+ (agda2-highlight-setup)++ ;; Use Xref+ (add-hook 'xref-backend-functions #'agda2-xref-backend -90 t)))++ ,buffer))++(agda2-information-buffer agda2-info-buffer "info" "AgdaInfo" "*Agda information*")++(defun agda2-display-information-buffer ()+ "Make sure the Agda information buffer is displayed in the current window.+Helper factored out from agda2-info-action."+ (interactive)+ (let ((buf (agda2-info-buffer)))+ ;; If the current window displays the information buffer, then the+ ;; window configuration is left untouched.+ (unless (equal (window-buffer) buf)+ (let ((agda-window+ (and agda2-file-buffer+ (car-safe+ ;; All windows, including minibuffers, on any+ ;; frame on the current terminal, displaying the+ ;; present Agda file buffer.+ (get-buffer-window-list agda2-file-buffer t 0)))))+ (save-selected-window+ ;; Select a window displaying the Agda file buffer (if such+ ;; a window exists). With certain configurations of+ ;; display-buffer this should increase the likelihood that+ ;; the info buffer will be displayed on the same frame.+ (when agda-window+ (select-window agda-window 'no-record))+ (let* (;; If there is only one window, then the info window+ ;; should be created above or below the code window,+ ;; not to the left or right.+ (split-width-threshold nil)+ (window+ (display-buffer+ buf+ ;; Under Emacs 23 the effect of the following+ ;; argument is only that the current window+ ;; should not be used.+ '(nil+ .+ (;; Do not use the same window.+ (inhibit-same-window . t)+ ;; Do not raise or select another frame.+ (inhibit-switch-frame . t))))))+ (if window+ (fit-window-to-buffer window+ (truncate+ (* (frame-height)+ agda2-information-window-max-height))))))))))++(defun agda2-info-action (name text append &rest annotations)+ "Insert TEXT plus a final newline into the Agda info buffer and display it.+NAME is displayed in the buffer's mode line.++The TEXT is highlighted by the given ANNOTATIONS+which come in the same format as for agda2-highlight-apply.++If APPEND is non-nil, then TEXT is appended at the end of the+buffer, and point placed after this text.++If APPEND is nil, then any previous text is removed before TEXT+is inserted, and point is placed before this text."+ (declare (agda2-command (string string boolean &repeat t))) ;+ (interactive)+ (let ((buf (agda2-info-buffer)))+ (with-current-buffer buf+ ;; In some cases the jump-to-position-mentioned-in-text+ ;; functionality (see compilation-error-regexp-alist above)+ ;; didn't work: Emacs jumped to the wrong position. However, it+ ;; seems to work if compilation-forget-errors is used. This+ ;; problem may be related to Emacs bug #9679+ ;; (http://debbugs.gnu.org/cgi/bugreport.cgi?bug=9679). The idea+ ;; to use compilation-forget-errors comes from a comment due to+ ;; Oleksandr Manzyuk+ ;; (https://github.com/haskell/haskell-mode/issues/67).+ (compilation-forget-errors)+ (unless append (erase-buffer))+ (unless (string-empty-p text)+ ;; (message "text = //%s//" text)+ (save-excursion+ (goto-char (point-max))+ ;; Andreas, 2025-08-04, PR #8047.+ ;; Experiment shows that 'face annotations do not survive in compilation-mode,+ ;; but 'font-lock-face is not removed.+ ;; https://emacs.stackexchange.com/questions/17141/how-do-i-insert-text-with-a-specific-face+ ;; (put-text-property 0 (max 0 (- (length text) 10)) 'font-lock-face '(:weight bold) text)+ ;; (message "text: %s" text)+ ;; (message "length: %i" (length text))+ ;; (message "annotations = %s" annotations)+ (apply 'annotation-load "Click to jump to definition" nil text annotations)+ ;; (pp (text-properties-at 0 text))+ (insert text)+ (newline)))+ ;; Update the mode line of the Agda information buffer,+ ;; displaying NAME in bold+ ;; in the place where usually the file name is displayed.+ (put-text-property 0 (length name) 'face '(:weight bold) name)+ (setq mode-line-buffer-identification name)+ (force-mode-line-update))+ (agda2-display-information-buffer)+ ;; Move point in every window displaying the information buffer.+ ;; Exception: If we are appending, don't move point in selected+ ;; windows.+ (dolist (window (get-buffer-window-list buf 'no-minibuffer t))+ (unless (and append+ (equal window (selected-window)))+ (with-selected-window window+ (if append+ (goto-char (point-max))+ (goto-char (point-min))))))))++(defun agda2-info-action-and-copy (name text &optional append)+ "Same as agda2-info-action but also puts TEXT in the kill ring."+ (declare (agda2-command (string string t)))+ (kill-new text)+ (agda2-info-action name text append))++(defun agda2-remove-annotations ()+ "Removes buffer annotations (overlays and text properties)."+ (interactive)+ (dolist (o (overlays-in (point-min) (point-max)))+ (delete-overlay o))+ (let ((inhibit-read-only t))+ (annotation-preserve-mod-p-and-undo+ (set-text-properties (point-min) (point-max) '()))+ (force-mode-line-update)))++(defun agda2-next-goal () "Go to the next goal, if any." (interactive)+ (agda2-mv-goal 'next-single-property-change 'agda2-delim2 1 (point-min)))+(defun agda2-previous-goal () "Go to the previous goal, if any." (interactive)+ (agda2-mv-goal 'previous-single-property-change 'agda2-delim3 0 (point-max)))+(defun agda2-mv-goal (change delim adjust wrapped)+ (agda2-let ()+ ((go (p) (while (and (setq p (funcall change p 'category))+ (not (eq (get-text-property p 'category) delim))))+ (if p (goto-char (+ adjust p)))))+ (or (go (point)) (go wrapped) (message "No goals in the buffer"))))++(defun agda2-quit ()+ "Quit and clean up after agda2."+ (interactive)+ (remove-hook 'first-change-hook 'agda2-abort-highlighting 'local)+ (remove-hook 'after-save-hook 'agda2-highlight-tokens 'local)+ (agda2-remove-annotations)+ (agda2-term))++(defun agda2-term (&optional nicely)+ "Interrupt the Agda process and kill its buffer.+If this function is invoked with a prefix argument, then Agda is+asked nicely to terminate itself after any previously invoked+commands have completed."+ (interactive "P")+ (if nicely+ (progn+ ;; Set up things so that if the Agda process terminates, then+ ;; its buffer is killed.+ (when (and agda2-process+ (process-status agda2-process))+ (set-process-sentinel agda2-process 'agda2-kill-process-buffer))+ ;; Kill the process buffer if the Agda process has already+ ;; been killed.+ (agda2-kill-process-buffer)+ ;; Try to kill the Agda process.+ (agda2-send-command nil+ "IOTCM"+ (agda2-string-quote (buffer-file-name))+ "None"+ "Indirect"+ "Cmd_exit"))+ ;; Try to kill the Agda process and the process buffer.+ (when (and agda2-process+ (process-status agda2-process))+ (interrupt-process agda2-process))+ (when (buffer-live-p agda2-process-buffer)+ (kill-buffer agda2-process-buffer))))++(defun agda2-kill-process-buffer (&optional _process _event)+ "Kills the Agda process buffer, if any.+But only if the Agda process does not exist or has terminated.++This function can be used as a process sentinel."+ (when (and (or (null agda2-process)+ (member (process-status agda2-process)+ '(exit signal failed nil)))+ (buffer-live-p agda2-process-buffer))+ (kill-buffer agda2-process-buffer)))++(cl-defmacro agda2--with-gensyms ((&rest names) &body body)+ "Bind NAMES to fresh symbols in BODY"+ (declare (indent 1))+ `(let ,(cl-loop for x in names collecting `(,x (make-symbol (symbol-name',x))))+ ,@body))++;; This macro is meant to be used to generate other macros which define+;; functions which can be used either directly from a goal or at a global+;; level and are modifiable using one of three levels of normalisation.++(defmacro agda2-proto-maybe-normalised (name comment cmd norm0 norm1 norm2 norm3 spec)+ "This macro constructs a function NAME which runs CMD.+COMMENT is used to build the function's comment.+The function NAME takes a prefix argument which tells whether it+should normalise types according to either NORM0, NORM1, NORM2, or NORM3+when running CMD through `agda2-goal-cmd`.+SPEC can be either (fromgoal want) or (global prompt).+"++ ;; Names bound in a macro should be ``uninterned'' to avoid name capture+ ;; We use the macro `agda2--with-gensyms' to bind these.+ (agda2--with-gensyms (eval prefix args)+ `(defun ,name (,prefix &rest ,args)+ ,(format "%s.++The form of the result depends on the prefix argument:++* If the prefix argument is `nil' (i.e., if no prefix argument is+ given), then the result is %s.++* If the prefix argument is `(4)' (for instance if C-u is typed+ exactly once right before the command is invoked), then the+ result is %s.++* If the prefix argument is `(16)' (for instance if C-u is typed+ exactly twice right before the command is invoked), then the+ result is %s.++* If any other prefix argument is used (for instance if C-u is+ typed thrice right before the command is invoked), then the+ result is %s." comment (nth 1 norm0) (nth 1 norm1) (nth 1 norm2) (nth 1 norm3))++ ;; All the commands generated by the macro are interactive.+ ;; Those called from a goal, grab the value present there (if any)+ ;; Whereas those called globally always use a prompt+ (interactive ,(pcase spec+ (`(fromgoal ,_want)+ "P")+ (`(global ,prompt)+ (if prompt+ (concat "P\nM" prompt ": ")+ "P"))))+ ;; Depending on the prefix's value we pick one of the three+ ;; normalisation levels+ (let ((,eval (cond ((null ,prefix)+ ,(car norm0))+ ((equal ,prefix '(4))+ ,(car norm1))+ ((equal ,prefix '(16))+ ,(car norm2))+ (t ,(car norm3)))))+ ;; Finally, if the command is called from a goal, we use `agda2-goal-cmd'+ ;; Otherwise we resort to `agda2-go'+ ,(pcase spec+ (`(fromgoal ,want)+ `(agda2-goal-cmd (concat ,cmd " " ,eval) nil ,want))+ (`(global ,prompt)+ `(agda2-go nil t 'busy t+ (concat ,cmd " "+ ,eval " "+ (if ,prompt+ (agda2-string-quote (car ,args))+ "")))))))))++(defmacro agda2-maybe-normalised (name comment cmd want)+ `(agda2-proto-maybe-normalised+ ,name ,comment ,cmd+ ("Simplified" "simplified")+ ("Instantiated" "neither explicitly normalised nor simplified")+ ("Normalised" "normalised")+ ("HeadNormal" "head normalised")+ (fromgoal ,want)))++(defmacro agda2-maybe-normalised-asis (name comment cmd want)+ `(agda2-proto-maybe-normalised+ ,name ,comment ,cmd+ ("AsIs" "returned as is")+ ("Simplified" "simplified")+ ("Normalised" "normalised")+ ("HeadNormal" "head normalised")+ (fromgoal ,want)))++(defmacro agda2-maybe-normalised-toplevel (name comment cmd prompt)+ `(agda2-proto-maybe-normalised+ ,name ,comment ,cmd+ ("Simplified" "simplified")+ ("Instantiated" "neither explicitly normalised nor simplified")+ ("Normalised" "normalised")+ ("HeadNormal" "head normalised")+ (global ,prompt)))++(defmacro agda2-maybe-normalised-toplevel-noprompt (name comment cmd)+ `(agda2-proto-maybe-normalised+ ,name ,comment ,cmd+ ("Simplified" "simplified")+ ("Instantiated" "neither explicitly normalised nor simplified")+ ("Normalised" "normalised")+ ("HeadNormal" "head normalised")+ (global nil)))++(defmacro agda2-maybe-normalised-toplevel-asis-noprompt (name comment cmd)+ `(agda2-proto-maybe-normalised+ ,name ,comment ,cmd+ ("AsIs" "returned as is")+ ("Simplified" "simplified")+ ("Normalised" "normalised")+ ("HeadNormal" "head normalised")+ (global nil)))++(agda2-maybe-normalised+ agda2-goal-type+ "Show the type of the goal at point"+ "Cmd_goal_type"+ nil)++(agda2-maybe-normalised+ agda2-infer-type+ "Infer the type of the goal at point"+ "Cmd_infer"+ "expression to type")++(agda2-maybe-normalised-toplevel+ agda2-infer-type-toplevel+ "Infers the type of the given expression. The scope used for+the expression is that of the last point inside the current+top-level module"+ "Cmd_infer_toplevel"+ "Expression")++(defun agda2-infer-type-maybe-toplevel ()+ "Infers the type of the given expression.+Either uses the scope of the current goal or, if point is not in a goal, the+top-level scope."+ (interactive)+ (call-interactively (if (agda2-goal-at (point))+ 'agda2-infer-type+ 'agda2-infer-type-toplevel)))++(defun agda2-why-in-scope ()+ "Explain why something is in scope in a goal."+ (interactive)+ (agda2-goal-cmd "Cmd_why_in_scope" nil "Name"))++(defun agda2-why-in-scope-toplevel (name)+ "Explain why something is in scope at the top level."+ (interactive "MName: ")+ (agda2-go nil t 'busy t+ "Cmd_why_in_scope_toplevel"+ (agda2-string-quote name)))++(defun agda2-why-in-scope-maybe-toplevel ()+ "Explains why a given name is in scope."+ (interactive)+ (call-interactively (if (agda2-goal-at (point))+ 'agda2-why-in-scope+ 'agda2-why-in-scope-toplevel)))++(agda2-maybe-normalised+ agda2-elaborate-give+ "Elaborate check the given expression against the hole's type and fill in the+ hole with the elaborated term"+ "Cmd_elaborate_give"+ "expression to elaborate and give")++(agda2-maybe-normalised+ agda2-goal-and-context+ "Shows the type of the goal at point and the currect context"+ "Cmd_goal_type_context"+ nil)++(agda2-maybe-normalised+ agda2-goal-and-context-and-inferred+ "Shows the context, the goal and the given expression's inferred type"+ "Cmd_goal_type_context_infer"+ "expression to type")++(agda2-maybe-normalised+ agda2-goal-and-context-and-checked+ "Shows the context, the goal and check the given expression's against+ the hole's type"+ "Cmd_goal_type_context_check"+ "expression to type")++(agda2-maybe-normalised+ agda2-show-context+ "Show the context of the goal at point"+ "Cmd_context"+ nil)++(agda2-maybe-normalised-asis+ agda2-helper-function-type+ "Compute the type of a hypothetical helper function."+ "Cmd_helper_function"+ "Expression")++(agda2-maybe-normalised+ agda2-module-contents+ "Shows all the top-level names in the given module.+Along with their types."+ "Cmd_show_module_contents"+ "Module name (empty for current module)")++(agda2-maybe-normalised-toplevel+ agda2-module-contents-toplevel+ "Shows all the top-level names in the given module.+Along with their types."+ "Cmd_show_module_contents_toplevel"+ "Module name (empty for top-level module)"+)++(agda2-maybe-normalised-toplevel+ agda2-search-about-toplevel+ "Search About an identifier"+ "Cmd_search_about_toplevel"+ "Name"+)++(defun agda2-module-contents-maybe-toplevel ()+ "Shows all the top-level names in the given module.+Along with their types.++Uses either the scope of the current goal or, if point is not in+a goal, the top-level scope."+ (interactive)+ (call-interactively (if (agda2-goal-at (point))+ 'agda2-module-contents+ 'agda2-module-contents-toplevel)))++(defun agda2-solve-maybe-all ()+ "Solves goals that are already instantiated internally.+Either only one if point is a goal, or all of them."+ (interactive)+ (call-interactively (if (agda2-goal-at (point))+ 'agda2-solveOne+ 'agda2-solveAll))+)++(defun agda2-mimer-maybe-all ()+ "Run proof search.+Either only one if point is a goal, or all of them."+ (interactive)+ (call-interactively (if (agda2-goal-at (point))+ 'agda2-mimer+ 'agda2-mimerAll))+)++(agda2-maybe-normalised-asis+ agda2-mimer+ "Run proof search on a goal."+ "Cmd_autoOne"+ 'goal+)++(agda2-maybe-normalised-toplevel-asis-noprompt+ agda2-mimerAll+ "Solves all goals by simple proof search."+ "Cmd_autoAll"+)++(agda2-maybe-normalised-toplevel-asis-noprompt+ agda2-show-goals+ "Show all goals."+ "Cmd_metas"+ )++(agda2-maybe-normalised-toplevel-asis-noprompt+ agda2-solveAll+ "Solves all goals that are already instantiated internally."+ "Cmd_solveAll"+ )++;; Andreas, 2025-09-12+;; Cmd_constraints has same normalization strategy as Cmd_solveOne+;; since after showing the meta solutions one might want to+;; apply them at the same normalization level.+(agda2-maybe-normalised-toplevel-noprompt+ agda2-show-constraints+ "Show meta solutions and constraints."+ "Cmd_constraints"+)++(agda2-maybe-normalised+ agda2-solveOne+ "Solves the goal at point if it is already instantiated internally"+ "Cmd_solveOne"+ nil+)++(defun agda2-solveAll-action (iss)+ (declare (agda2-command (list)))+ (while iss+ (let* ((g (pop iss)) (txt (pop iss))+ (cmd (cons 'agda2-solve-action (cons g (cons txt nil)))))+ (if (null agda2-last-responses)+ (push (cons 1 cmd) agda2-last-responses)+ (nconc agda2-last-responses (cons (cons 3 cmd) nil))))))++(defun agda2-solve-action (g txt)+ (declare (agda2-command (integer string)))+ (save-excursion+ (agda2-replace-goal g txt)+ (agda2-goto-goal g)+ (agda2-give)))++(defun agda2-compute-normalised (&optional arg)+ "Compute the normal form of the expression in the goal at point.++With the prefix argument `(4)' \"abstract\" is ignored during the+computation.++With a prefix argument `(16)' the normal form of+\"show <expression>\" is computed, and then the resulting string+is printed.++With any other prefix the head normal form is computed."+ (interactive "P")+ (let ((cmd (concat "Cmd_compute"+ (cond ((equal arg nil) " DefaultCompute")+ ((equal arg '(4)) " IgnoreAbstract")+ ((equal arg '(16)) " UseShowInstance")+ (" HeadCompute")))))+ (agda2-goal-cmd cmd nil "expression to normalise")))++(defun agda2-compute-normalised-toplevel (expr &optional arg)+ "Compute the normal form of the given expression.+The scope used for the expression is that of the last point+inside the current top-level module.++With a prefix argument distinct from `(4)' the normal form of+\"show <expression>\" is computed, and then the resulting string+is printed.++With the prefix argument `(4)' \"abstract\" is ignored during the+computation."+ (interactive "MExpression: \nP")+ (let ((cmd (concat "Cmd_compute_toplevel"+ (cond ((equal arg nil) " DefaultCompute")+ ((equal arg '(4)) " IgnoreAbstract")+ ((equal arg '(16)) " UseShowInstance")+ (" HeadCompute")) " ")))+ (agda2-go nil t 'busy t+ (concat cmd (agda2-string-quote expr)))))++(defun agda2-compute-normalised-maybe-toplevel ()+ "Compute the normal form of the given expression.+The scope used for the expression is that of the last point+inside the current top-level module.++With a prefix argument distinct from `(4)' the normal form of+\"show <expression>\" is computed, and then the resulting string+is printed.++With the prefix argument `(4)' \"abstract\" is ignored during the+computation."+ (interactive)+ (if (agda2-goal-at (point))+ (call-interactively 'agda2-compute-normalised)+ (call-interactively 'agda2-compute-normalised-toplevel)))++(defun agda2-display-program-version ()+ "Display version of Agda"+ (interactive)+ (agda2-go nil nil 'busy t "Cmd_show_version"))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;;++(defun agda2-highlight-reload nil+ "Loads precomputed syntax highlighting info for the current buffer.+Only if the buffer is unmodified, and only if there is anything to load."+ (unless (buffer-modified-p)+ (agda2-go nil t 'not-so-busy t+ "Cmd_load_highlighting_info"+ (agda2-string-quote (buffer-file-name)))))++(defun agda2-file-type (&optional path)+ "Determine the type of literate agda file based off of the file extension.++If PATH is nil, use the filepath of the current buffer.++Will return one of the following options:++-- plain+-- latex+-- rst+-- markdown+-- org+-- typst+-- forester"+ (pcase (file-name-extension (or path (buffer-file-name)))+ ("agda" 'plain)+ ((or "lagda" "tex") 'latex)+ ("rst" 'rst)+ ("org" 'org)+ ("md" 'markdown)+ ("typ" 'typst)+ ("tree" 'forester)+ (ext (error "Unknown agda file extension %s" ext))))++(defun agda2-goals-action (goals)+ "Annotates the goals in the current buffer with text properties.+GOALS is a list of the buffer's goal numbers, in the order in+which they appear in the buffer. Note that this function should+be run /after/ syntax highlighting information has been loaded,+because the two highlighting mechanisms interact in unfortunate+ways."+ (declare (agda2-command (list)))+ (agda2-forget-all-goals)+ (agda2-let+ ((file-type (agda2-file-type))+ ;; All regexes in `code-start-rx' are headed by line-start (blank *) to avoid+ ;; creating interaction points in code blocks that are commented+ ;; out using the host languages comments (EG: % \begin{code})+ ;; See issue #1331.+ ;;+ ;; [TODO: Reed M, 14/04/2026] Literate RST support.+ (code-start-rx+ (pcase file-type+ ('latex+ (rx line-start (* blank) "\\begin{code}"))+ ('org+ (rx line-start (* blank) "#+begin_src" (+ blank) "agda2"))+ ((or 'typst 'markdown)+ (rx line-start (* blank) "```"))+ ('forester+ (rx line-start (* blank) "\\agda{"))))+ ;; We don't need to be as careful with comments in `code-end-rx', as+ ;; `code-rx' and the main lexer loop will handle comments for us.+ (code-end-rx+ (pcase file-type+ ('latex+ (rx "\\end{code}"))+ ('org+ (rx "#+end_src"))+ ((or 'typst 'markdown)+ (rx "```"))+ ;; Forester uses } to close out code blocks,+ ;; which requires special handling due to implicit+ ;; arguments.+ (_ (rx unmatchable))))+ (comment-rx+ (rx (or "{-" "-}")))+ (string-end-rx+ (rx (not "\\") "\""))+ (char-end-rx+ (rx (not "\\") "'"))+ (goal-end-rx+ (rx (or "{!" "!}")))+ (code-rx+ (rx (or+ (submatch-n 1 "\"")+ (and blank (submatch-n 1 "'"))+ ;; We want to make sure that we only match proper comments so that we don't+ ;; stop lexing on identifiers like foo--bar.+ (and (or bol (any "." "{" "}" "(" ")" ";" space)) (submatch-n 1 "--"))+ ;; Similar idea: don't match ? inside of an identifier name.+ (and (or bol (any "." "{" "}" "(" ")" ";" space))+ (submatch-n 1 "?")+ (or eol (any "." "{" "}" "(" ")" ";" space)))+ (submatch-n 1 (and "{" (? (any "-" "!"))))+ (submatch-n 1 "}")+ (submatch-n 1 (regexp code-end-rx)))))+ ;; Don't run modification hooks: we don't want this function to+ ;; trigger `agda2-abort-highlighting'.+ (inhibit-modification-hooks t)+ ;; Make sure that we don't use case-sensitive matching+ ;; so that we can pick up on all capitalizations of #+BEGIN_SRC.+ (case-fold-search t)+ (nbrackets 0))+ ((advance-to-code-block ()+ (when code-start-rx (re-search-forward code-start-rx nil t)))+ (advance-to-comment-end (n)+ (re-search-forward comment-rx nil t)+ (pcase (match-string 0)+ ("{-"+ (advance-to-comment-end (1+ n)))+ ("-}"+ (unless (zerop n)+ (advance-to-comment-end (1- n))))))+ (advance-to-string-end ()+ (re-search-forward string-end-rx nil t))+ (advance-to-char-end ()+ (re-search-forward char-end-rx nil t))+ (advance-to-goal-end (n)+ (re-search-forward goal-end-rx nil t)+ (pcase (match-string 0)+ ("{!"+ (advance-to-goal-end (1+ n)))+ ("!}"+ (if (zerop n)+ (point)+ (advance-to-goal-end (1- n))))))+ (end-of-code-block (str)+ (pcase file-type+ ('latex (equal str "\\end{code}"))+ ('org (equal (downcase str) "#+end_src"))+ ((or 'typst 'markdown) (equal str "```"))+ ('forester (and (equal str "}") (zerop nbrackets))))))+ (save-excursion+ (goto-char (point-min))+ ;; This code assumes that all delimiters in Agda code+ ;; are properly matched, which may not hold if the user+ ;; performs a slow load and then starts insert/deleting+ ;; braces or quotes. However, this sort of problem is unavoidable+ ;; with our current synchronization strategy (or lack thereof).+ (advance-to-code-block)+ (while (and goals (re-search-forward code-rx nil t))+ (pcase (match-string 1)+ ((pred end-of-code-block)+ (advance-to-code-block))+ ("\""+ (advance-to-string-end))+ ("'"+ (advance-to-char-end))+ ("{-"+ (advance-to-comment-end 0))+ ("--"+ (end-of-line))+ ("{!"+ (let ((start (- (point) 2))+ (end (advance-to-goal-end 0)))+ (agda2-make-goal start end (pop goals))))+ ("?"+ (goto-char (match-beginning 1))+ (delete-char 1)+ (insert "{!!}")+ (agda2-make-goal (- (point) 4) (point) (pop goals)))+ ("{"+ (cl-incf nbrackets))+ ("}"+ (cl-decf nbrackets)))))))++(defun agda2-make-goal (p q n)+ "Make a goal with number N at <P>{!...!}<Q>. Assume the region is clean."+ (annotation-preserve-mod-p-and-undo+ (let ((atp (lambda (x ps) (add-text-properties x (1+ x) ps))))+ (funcall atp p '(category agda2-delim1))+ (funcall atp (1+ p) '(category agda2-delim2))+ (funcall atp (- q 2) '(category agda2-delim3))+ (funcall atp (1- q) '(category agda2-delim4)))+ (let ((o (make-overlay p q nil t nil)))+ (overlay-put o 'modification-hooks '(agda2-protect-goal-markers))+ (overlay-put o 'agda2-gn n)+ (overlay-put o 'face 'highlight)+ (overlay-put o 'after-string (propertize (format "%s" n) 'face 'highlight)))))++(defun agda2-protect-goal-markers (ol action beg end &optional _length)+ "Ensures that the goal markers cannot be tampered with.+Except if `inhibit-read-only' is non-nil or /all/ of the goal is+modified."+ (if action+ ;; This is the after-change hook.+ nil+ ;; This is the before-change hook.+ (cond+ ((and (<= beg (overlay-start ol)) (>= end (overlay-end ol)))+ ;; The user is trying to remove the whole goal:+ ;; manually evaporate the overlay and add an undo-log entry so+ ;; it gets re-added if needed.+ (when (listp buffer-undo-list)+ (push (list 'apply 0 (overlay-start ol) (overlay-end ol)+ 'move-overlay ol (overlay-start ol) (overlay-end ol))+ buffer-undo-list))+ (delete-overlay ol))+ ((or (< beg (+ (overlay-start ol) 2))+ (> end (- (overlay-end ol) 2)))+ (unless inhibit-read-only+ (signal 'text-read-only nil))))))++(defun agda2-update (old-g new-txt)+ "Update the goal OLD-G.+If NEW-TXT is a string, then the goal is replaced by the string,+and otherwise the text inside the goal is retained (parenthesised+if NEW-TXT is `'paren').++Removes the goal braces, but does not remove the goal overlay or+text properties."+ (cl-multiple-value-bind (p q) (agda2-range-of-goal old-g)+ (save-excursion+ (cond ((stringp new-txt)+ (agda2-replace-goal old-g new-txt))+ ((equal new-txt 'paren)+ (goto-char (- q 2)) (insert ")")+ (goto-char (+ p 2)) (insert "(")))+ (cl-multiple-value-bind (p q) (agda2-range-of-goal old-g)+ (delete-region (- q 2) q)+ (delete-region p (+ p 2)))+ ;; Update highlighting+ (if (and (not (equal new-txt 'paren)) (not (equal new-txt 'no-paren)))+ (apply 'agda2-go 'save t 'busy nil "Cmd_highlight"+ (format "%d" old-g)+ (agda2-mkRange `(,p ,(- q 2)))+ (agda2-string-quote new-txt) nil))+ )))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;; Misc++(defun agda2-process-status ()+ "Status of `agda2-process-buffer', or \"no process\"."+ (condition-case nil+ (process-status agda2-process)+ (error "no process")))++(defun agda2-intersperse (sep xs)+ (let (ys)+ (while xs+ (push (pop xs) ys)+ (push sep ys))+ (pop ys)+ (nreverse ys)))++(defun agda2-goal-Range (o)+ "The Haskell Range of goal overlay O."+ (agda2-mkRange `(,(+ (overlay-start o) 2)+ ,(- (overlay-end o) 2))))++(defun agda2-mkRange (points)+ "A string representing a range corresponding to POINTS.+POINTS must be a list of integers, and its length must be 0 or 2."+ (if points+ (format "(intervalsToRange (Just (mkAbsolute %s)) %s)"+ (agda2-string-quote (file-truename (buffer-file-name)))+ (format "[Interval () %s %s]"+ (agda2-mkPos (car points))+ (agda2-mkPos (cadr points))))+ "noRange"))++(defun agda2-mkPos (&optional p)+ "The Haskell PositionWithoutFile corresponding to P or `point'."+ (save-excursion+ (save-restriction+ (widen)+ (if p (goto-char p))+ (format "(Pn () %d %d %d)"+ (point)+ (count-lines (point-min) (point))+ (1+ (current-column))))))++(defun agda2-char-quote (c)+ "Convert character C to the notation used in Haskell strings.+The non-ASCII characters are actually rendered as+\"\\xNNNN\\&\", i.e. followed by a \"null character\", to avoid+problems if they are followed by digits. ASCII characters (code+points < 128) are converted to singleton strings."+ (if (< c 128)+ (list c)+ ;; FIXME: Why return a list rather than a string? --Stef+ (append (format "\\x%x\\&" (encode-char c 'ucs)) nil)))++(defun agda2-string-quote (s)+ "Format S as a Haskell string literal.+Removes any text properties, escapes newlines, double quotes,+etc., adds surrounding double quotes, and converts non-ASCII+characters to the \\xNNNN notation used in Haskell strings."+ (let ((print-escape-newlines t)+ (s2 (copy-sequence s)))+ (set-text-properties 0 (length s2) nil s2)+ (mapconcat 'agda2-char-quote (prin1-to-string s2) "")))++(defun agda2-list-quote (strings)+ "Convert a list of STRINGS into a string representing it in Haskell syntax."+ (concat "[" (mapconcat 'agda2-string-quote strings ", ") "]"))++(defun agda2-goal-at(pos)+ "Return (goal overlay, goal number) at POS, or nil."+ (let ((os (and pos (overlays-at pos))) o g)+ (while (and os (not(setq g (overlay-get (setq o (pop os)) 'agda2-gn)))))+ (if g (list o g))))++(defun agda2-goal-overlay (g)+ "Returns the overlay of goal number G, if any."+ (car+ (remove nil+ (mapcar (lambda (o) (if (equal (overlay-get o 'agda2-gn) g) o))+ (overlays-in (point-min) (point-max))))))++(defun agda2-range-of-goal (g)+ "The range of goal G."+ (let ((o (agda2-goal-overlay g)))+ (if o (list (overlay-start o) (overlay-end o)))))++(defun agda2-goto-goal (g)+ (let ((p (+ 2 (car (agda2-range-of-goal g)))))+ (if p (goto-char p))))++(defun agda2-replace-goal (g newtxt)+ "Replace the content of goal G with NEWTXT." (interactive)+ (save-excursion+ (cl-multiple-value-bind (p q) (agda2-range-of-goal g)+ (setq p (+ p 2) q (- q 2))+ (let ((indent (and (goto-char p) (current-column))))+ (delete-region p q) (insert newtxt)+ (while (re-search-backward "^" p t)+ (insert-char ? indent) (backward-char (1+ indent)))))))++(defun agda2-forget-all-goals ()+ "Remove all goal annotations."+ (annotation-preserve-mod-p-and-undo+ (remove-text-properties (point-min) (point-max) '(category nil)))+ (dolist (ovl (overlays-in (point-min) (point-max)))+ (when (overlay-get ovl 'agda2-gn)+ (delete-overlay ovl))))++(defun agda2-decl-beginning ()+ "Find the beginning point of the declaration containing the point.+To do: dealing with semicolon separated decls."+ (interactive)+ (save-excursion+ (let* ((pEnd (point))+ (pDef (progn (goto-char (point-min))+ (re-search-forward "\\s *" pEnd t)))+ (cDef (current-column)))+ (while (re-search-forward+ "where\\(\\s +\\)\\S \\|^\\(\\s *\\)\\S " pEnd t)+ (if (match-end 1)+ (setq pDef (goto-char (match-end 1))+ cDef (current-column))+ (goto-char (match-end 2))+ (if (>= cDef (current-column))+ (setq pDef (point)+ cDef (current-column))))+ (forward-char))+ (goto-char pDef)+ (if (equal (current-word) "mutual")+ (or (match-end 2) (match-end 1))+ pDef))))++(defun agda2-beginning-of-decl ()+ (interactive)+ (goto-char (agda2-decl-beginning)))++(defvar agda2-debug-buffer-name "*Agda debug*"+ "The name of the buffer used for Agda debug messages.")++(defvar agda2-debug-buffer nil+ "Agda debug buffer.")++(agda2-information-buffer agda2-debug-buffer "debug" "AgdaDebug" agda2-debug-buffer-name)++(defun agda2-verbose (msg &rest annotations)+ "Appends the string MSG plus a final newline+to the `agda2-debug-buffer-name' buffer.+Note that this buffer's contents is not erased automatically when+a file is loaded."+ (declare (agda2-command (string &repeat t)))+ (unless (string-empty-p msg)+ (with-current-buffer (agda2-debug-buffer)+ (save-excursion+ (goto-char (point-max))+ (apply 'annotation-load "Click to jump to definition" nil msg annotations)+ (insert msg)+ (newline)))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Comments and paragraphs++(defun agda2-comments-and-paragraphs-setup nil+ "Set up comment and paragraph handling for the Agda mode."++ ;; Empty lines (all white space according to Emacs) delimit+ ;; paragraphs.+ (set (make-local-variable 'paragraph-start) "\\s-*$")+ (set (make-local-variable 'paragraph-separate) paragraph-start)++ ;; Support for adding/removing comments.+ (set (make-local-variable 'comment-start) "-- ")++ ;; Use the syntax table to locate comments (and possibly other+ ;; things). Syntax table setup for comments is done elsewhere.+ (set (make-local-variable 'comment-use-syntax) t)++ ;; Update token-based highlighting after the buffer has been saved.+ (add-hook 'after-save-hook 'agda2-highlight-tokens nil 'local)++ ;; Support for proper filling of text in comments (requires that+ ;; Filladapt is activated).+ (when (featurep 'filladapt)+ (add-to-list (make-local-variable+ 'filladapt-token-table)+ '("--" agda2-comment))+ (add-to-list (make-local-variable 'filladapt-token-match-table)+ '(agda2-comment agda2-comment) t)+ (add-to-list (make-local-variable 'filladapt-token-conversion-table)+ '(agda2-comment . exact))))++(defun agda2-comment-dwim-rest-of-buffer ()+ "Comment or uncomment the rest of the buffer.+From the beginning of the current line to the end of the buffer."+ (interactive)+ (save-excursion+ (forward-line 0)+ (push-mark (point) 'no-message 'activate-mark)+ (unwind-protect+ (progn+ (goto-char (point-max))+ (comment-dwim nil))+ (pop-mark))))++(defun agda2-highlight-tokens nil+ "Compute token-based highlighting information.++Unless `agda2-highlight-level' is `none' or the Agda process is+busy (or `not-so-busy') with something. This command might save+the buffer."+ (unless (or agda2-in-progress+ (equal agda2-highlight-level 'none))+ (agda2-go 'save t 'not-so-busy t+ "Cmd_tokenHighlighting"+ (agda2-string-quote (buffer-file-name))+ "Keep")))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Xref integration++(defun agda2-xref-backend ()+ "Return an Xref backend."+ 'agda2)++(cl-defmethod xref-backend-identifier-at-point ((_ (eql agda2)))+ "Return the symbol at point with text properties."+ (and (consp (get-text-property (point) 'annotation-goto))+ (thing-at-point 'symbol)))++(defun agda2-make-xref (file point)+ "Return a `xref-item' pointing to FILE at POINT."+ (with-current-buffer (find-file-noselect file)+ (save-excursion+ (goto-char point)+ (xref-make+ (buffer-substring+ (line-beginning-position)+ (save-excursion+ (goto-char (line-end-position))+ (skip-syntax-backward " >")+ (point)))+ (xref-make-buffer-location+ (current-buffer)+ (point))))))++(defvar agda2-last-xref-ict (make-hash-table :test 'equal)+ "Cached table of unambiguous identifiers and their locations.")++(defun agda2-slurp-identifiers ()+ "Traverse the buffer for identifiers and update `agda2-last-xref-ict'."+ (save-excursion+ (let ((idents (make-hash-table)) start end)+ (goto-char (point-min))+ (catch 'done+ (while t+ (setq start (next-single-property-change+ (point) 'annotation-goto))+ (goto-char (or start (throw 'done t)))+ (cl-assert (get-text-property (point) 'annotation-goto))+ (setq end (next-single-property-change+ (point) 'annotation-goto))+ (goto-char (or end (throw 'done t)))+ (cl-assert (null (get-text-property (point) 'annotation-goto)))+ (when (< start end)+ (push (get-text-property (1- (point)) 'annotation-goto)+ (gethash (buffer-substring-no-properties start end)+ idents)))))+ (maphash+ (lambda (ident refs)+ (when (and (car refs) (null (cadr refs))) ;(length= refs 1)+ (puthash ident+ (agda2-make-xref (caar refs) (cdar refs))+ agda2-last-xref-ict)))+ idents)))+ agda2-last-xref-ict)++(cl-defmethod xref-backend-identifier-completion-table ((_ (eql agda2)))+ "Generate a list of possible candidates."+ ;; We clear and re-generate the hash-table mapping identifiers to+ ;; `xref-item' objects so that the completion is up-to-date and that+ ;; `xref-backend-definitions' can use the hash-table to lookup the+ ;; position of the identifier without a `annotation-goto'+ (clrhash agda2-last-xref-ict)+ (agda2-slurp-identifiers))++(cl-defmethod xref-backend-definitions ((_ (eql agda2)) ident)+ "Generate a list of definitions for identifier IDENT."+ (pcase (get-text-property 0 'annotation-goto ident)+ (`(,file . ,pos) (list (agda2-make-xref file pos)))+ ((pred null) ;`nil' is not backwards compatible...+ (let ((item (gethash ident agda2-last-xref-ict)))+ (and item (list item))))+ (prop (error "Unexpected `annotation-goto' on %S: %S" ident prop))))++(cl-defmethod xref-backend-references ((_ (eql agda2)) identifier)+ "Generate a list of references for IDENTIFIER."+ ;; TODO: Do not defer to the default implementation. This is just+ ;; grep, but we could also look through all open buffers as well.+ (xref-backend-references nil identifier))++;; Compatibility definition for releases of Emacs <28.1+(defalias 'agda2-mode-apropos-regexp+ (if (fboundp 'xref-apropos-regexp)+ 'xref-apropos-regexp+ (lambda (pattern)+ "Return an Emacs regexp from PATTERN similar to `apropos'."+ (require 'apropos)+ (declare-function+ apropos-parse-pattern "apropos"+ (pattern &optional multiline-p))+ (apropos-parse-pattern+ (if (string-equal (regexp-quote pattern) pattern)+ ;; Split into words+ (or (split-string pattern "[ \t]+" t)+ (user-error "No word list given"))+ pattern)))))++(cl-defmethod xref-backend-apropos ((_ (eql agda2)) pattern)+ "Generate a list of definitions matching PATTERN."+ (clrhash agda2-last-xref-ict)+ (dolist (buf (buffer-list))+ (with-current-buffer buf+ (when (derived-mode-p 'agda2-mode)+ (agda2-slurp-identifiers))))+ ;; TODO: add type annotations+ (cl-loop with regexp = (agda2-mode-apropos-regexp pattern)+ for ident being the hash-keys of agda2-last-xref-ict+ using (hash-values item)+ when (string-match-p regexp ident)+ collect item))++(defun agda2-goto-definition-keyboard (&optional other-window)+ "Go to the definition site of the name under point (if any).+If this function is invoked with a prefix argument then another window is used+to display the given position."+ (interactive "P")+ (annotation-goto-indirect (point) other-window))++(defun agda2-goto-definition-mouse (ev)+ "Go to the definition site of the name clicked on, if any.+Otherwise, yank (see `mouse-yank-primary')."+ (interactive "e")+ (if (consp (save-excursion+ (mouse-set-point ev)+ (get-text-property (point) 'annotation-goto)))+ (let ((xref-prompt-for-identifier nil))+ (mouse-set-point ev)+ (call-interactively #'xref-find-definitions))+ ;; FIXME: Shouldn't we use something like+ ;; (call-interactively (key-binding ev))? --Stef+ (mouse-yank-primary ev)))++(defun agda2-info-goto-definition-mouse (ev)+ "While in the information buffer, to the definition site of the name+clicked on, if any.++Otherwise, invoke `compile-goto'."+ (interactive "e")++ ;; Always "use other window" because find-file-other-window will reuse+ ;; an existing window (i.e. the source file buffer) if it exists+ (unless (and agda2-file-buffer (annotation-goto-indirect ev t))+ (compile-goto-error ev)))++(defun agda2-info-goto-definition-keyboard ()+ "As `agda2-info-goto-definition-mouse', but at point."+ (declare (obsolete "Use `xref-find-definitions'" "2.9.0"))+ (interactive)+ (agda2-info-goto-definition-mouse (point)))++(defun agda2-go-back nil+ "Go back to the previous position in which+`agda2-goto-definition-keyboard' or `agda2-goto-definition-mouse' was+invoked."+ (declare (obsolete "Use `xref-go-back'" "2.9.0"))+ (interactive)+ (annotation-go-back))++(defun agda2-maybe-goto (filepos)+ "Might move point to the given error.+FILEPOS should have the form (FILE . POSITION).++If `agda2-highlight-in-progress' is `nil', or if the selected+window does not visit (does not contain a buffer that visits)+`agda2-file-buffer', then nothing happens.++Otherwise:+* If the selected window visits FILE, or if no visible window+ visits FILE, then the selected window is made to visit FILE,+ and point is set to POSITION.+* Otherwise point is set to POSITION in every visible window that+ visits FILE."+ (declare (agda2-command (cons)))+ (when (and agda2-highlight-in-progress+ (consp filepos)+ (stringp (car filepos))+ (integerp (cdr filepos))+ (eq (window-buffer) agda2-file-buffer))+ ;; We don't use `xref-show-xrefs', as we know that there is a+ ;; concrete position we want to jump to. nevertheless, we push+ ;; the current marker onto Xref' stack to make it seem like a Xref+ ;; jump.+ (xref-push-marker-stack)+ (if-let*+ ((buffer (find-buffer-visiting (car filepos)))+ (windows+ (get-buffer-window-list buffer 'no-minibuffer 'visible)))+ ;; Some visible window visits FILE.+ (if (eq buffer (window-buffer))+ ;; The selected window visits FILE.+ (goto-char (cdr filepos))+ ;; The selected window does not visit FILE. Update point in+ ;; all visible windows that visit FILE.+ (dolist (window windows)+ (with-selected-window window+ (goto-char (cdr filepos)))))+ ;; No visible window visits FILE. Make the current window visit+ ;; FILE.+ (switch-to-buffer+ (find-file-noselect (car filepos)) nil 'force-same-window)+ (goto-char (cdr filepos)))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Implicit arguments++(defun agda2-display-implicit-arguments (&optional arg)+ "Toggle display of implicit arguments.+With prefix argument, turn on display of implicit arguments if+the argument is a positive number, otherwise turn it off."+ (interactive "P")+ (cond+ ((eq arg nil)+ (agda2-go nil t 'not-so-busy t "ToggleImplicitArgs"))+ ((and (numberp arg) (> arg 0))+ (agda2-go nil t 'not-so-busy t "ShowImplicitArgs" "True"))+ (t (agda2-go nil t 'not-so-busy t "ShowImplicitArgs" "False"))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Irrelevant arguments++(defun agda2-display-irrelevant-arguments (&optional arg)+ "Toggle display of irrelevant arguments.+With prefix argument, turn on display of irrelevant arguments if+the argument is a positive number, otherwise turn it off."+ (interactive "P")+ (cond+ ((eq arg nil)+ (agda2-go nil t 'not-so-busy t "ToggleIrrelevantArgs"))+ ((and (numberp arg) (> arg 0))+ (agda2-go nil t 'not-so-busy t "ShowIrrelevantArgs" "True"))+ (t (agda2-go nil t 'not-so-busy t "ShowIrrelevantArgs" "False"))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;;;;++(defun agda2-popup-menu-3 (ev)+ "If in a goal, popup the goal menu and call chosen command."+ (interactive "e")+ (let (choice)+ (save-excursion+ (and (agda2-goal-at (goto-char (posn-point (event-end ev))))+ (setq choice (x-popup-menu ev agda2-goal-map))+ (call-interactively+ (lookup-key agda2-goal-map (apply 'vector choice)))))))++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+;; Switching to a different version of Agda++(defun agda2-get-agda-program-versions ()+ "Get suffixes (\"version strings\") of executables starting with+\\='agda-\\=' in exec-path."+ (interactive) ;; for debugging purposes+ (delete-dups+ (mapcar (lambda (path)+ ;; strip 'agda-' prefix+ (replace-regexp-in-string "^agda-?" ""+ (file-name-nondirectory path)))+ (cl-remove-if-not 'file-executable-p+ ;; concatenate result+ (cl-reduce 'append+ ;; for each directory in exec-path, get list of+ ;; files whose name starts with 'agda-'+ (mapcar (lambda (path)+ (when (file-accessible-directory-p path)+ (directory-files path 't "^agda-")))+ exec-path))))))+++(defun agda2-old-version (version)+ "Check if the given version is less that 2.8.++Agda 2.8 is the version where the agda-mode executable was deprecated.++If the version cannot be parsed, the answer is no.+So e.g. agda-fast would be interpreted as not older than+agda-2.9.0"+ ;; If the given string does not have a numeric prefix, we answer no.+ (and (string-match "^[0-9][0-9.]*" version)+ (version< (match-string 0 version) "2.8")))++;; Note that other versions of Agda may use different protocols, so+;; this function unloads the Emacs mode.++(defun agda2-set-program-version (version)+ "Tries to switch to Agda version VERSION.++This command assumes that the agda and agda-mode executables for+Agda version VERSION are called agda-VERSION and agda-mode-VERSION.+It searches for these executables on the exec-path+which is often identical to PATH but can be different+depending how Emacs is configured and invoked.++Only if VERSION is numeric and less than \"2.8\"+the agda-mode executable is used to locate the respective agda2.el,+otherwise \"agda --emacs-mode locate\" is invoked.++If VERSION is empty or \"agda\", then agda is used.+A prefix \"agda-\" is stripped from VERSION,+so one can invoke this function e.g. with+\"agda-2.9.0\" instead of \"2.9.0\".++An attempt is made to preserve the default value of `agda2-mode-hook'."+ (interactive+ (list (completing-read "Version: " (agda2-get-agda-program-versions))))++ (let*+ ((agda-buffers+ (cl-mapcan (lambda (buf)+ (with-current-buffer buf+ (when (equal major-mode 'agda2-mode)+ (list buf))))+ (buffer-list)))++ (default-hook (default-value 'agda2-mode-hook))++ ;; Sanitize version.+ ;; * Strip "agda-" prefix from version.+ ;; * Replace version "agda" by just "".+ ;;+ ;; Rationale:+ ;; The user might by accident enter "agda-2.9.0" instead of "2.9.0",+ ;; or "agda" instead of "".+ (version+ (cond+ ;; Strip "agda-" prefix from version.+ ((string-prefix-p "agda-" version) (substring version (length "agda-")))+ ;; Replace version "agda" by just "".+ ((equal version "agda") "")+ ;; Default.+ (t version)))++ (version-suffix (if (or (equal version "")+ (equal version nil))+ ""+ (concat "-" version)))++ ;; Run agda-mode<version-suffix> and make sure that it returns+ ;; successfully.+ (coding-system-for-read 'utf-8)+ (old-agda (agda2-old-version version))+ (agda-mode-prog (concat (if old-agda "agda-mode" "agda") version-suffix))+ (agda-mode-path+ (condition-case nil+ (with-temp-buffer+ (unless+ (equal 0+ (if old-agda+ (call-process agda-mode-prog nil (current-buffer) nil "locate")+ (call-process agda-mode-prog nil (current-buffer) nil "--emacs-mode" "locate")))+ (error "%s" (concat "Error when running "+ agda-mode-prog)))+ (buffer-string))+ (file-error+ (error "%s" (concat "Could not find " agda-mode-prog))))))++ ;; Make sure that agda-mode<version-suffix> returns a valid file.+ (unless (file-readable-p agda-mode-path)+ (error "%s" (concat "Could not read " agda-mode-path)))++ ;; Turn off the Agda mode.+ (agda2-quit)++ ;; Kill some buffers related to Agda.+ (when (buffer-live-p agda2-info-buffer)+ (kill-buffer agda2-info-buffer))+ (when (buffer-live-p agda2-debug-buffer)+ (kill-buffer agda2-debug-buffer))++ ;; Remove the Agda mode directory from the load path.+ (setq load-path (delete agda2-directory load-path))++ ;; Unload the Agda mode and its dependencies.+ (unload-feature 'agda2-mode 'force)+ (unload-feature 'agda2 'force)+ (unload-feature 'eri 'force)+ (unload-feature 'annotation 'force)+ (unload-feature 'agda-input 'force)+ (unload-feature 'agda2-highlight 'force)+ (unload-feature 'agda2-abbrevs 'force)+ (unload-feature 'agda2-queue 'force)++ ;; Load the new version of Agda.+ (load-file agda-mode-path)+ (require 'agda2-mode)+ (setq agda2-program-name (concat "agda" version-suffix))++ ;; Restore the Agda mode's default hook (if any).+ (when default-hook+ (set-default 'agda2-mode-hook default-hook))++ ;; Restart the Agda mode in all former Agda mode buffers.+ (mapc (lambda (buf)+ (with-current-buffer buf+ (agda2-mode)))+ agda-buffers))) (provide 'agda2-mode) ;;; agda2-mode.el ends here
@@ -0,0 +1,45 @@+;; -*- lexical-binding: t -*-+;;; agda2-queue.el --- Simple FIFO character queues.+;; SPDX-License-Identifier: MIT License++(defun agda2-queue-empty ()+ "Creates a new empty FIFO character queue.+Queues are represented as pairs. The car contains the queue. If+the queue is empty, then the cdr contains the symbol nil, and+otherwise it points to the queue's last cons-cell."+ (cons nil nil))++(defun agda2-queue-is-prefix-of (prefix queue)+ "Returns a non-nil result iff the string PREFIX is a prefix of QUEUE.+Linear in the length of PREFIX."+ (let ((queue (car queue))+ (prefix (append prefix nil)))+ (while (and (consp queue) (consp prefix)+ (equal (car queue) (car prefix)))+ (pop queue)+ (pop prefix))+ (null prefix)))++(defun agda2-queue-enqueue (queue string)+ "Adds the characters in STRING to the end of QUEUE.+This function updates QUEUE destructively, and is linear in the+length of STRING."+ (let ((chars (append string nil)))+ (when (consp chars)+ (if (null (cdr queue))+ (setcar queue chars)+ (setcdr (cdr queue) chars))+ (setcdr queue (last chars))))+ queue)++(defun agda2-queue-from-string (string)+ "Creates a new FIFO containing the characters in STRING.+Linear in the length of STRING."+ (agda2-queue-enqueue (agda2-queue-empty) string))++(defun agda2-queue-to-string (queue)+ "Constructs a string containing all the characters in QUEUE.+Linear in the length of QUEUE."+ (concat "" (car queue)))++(provide 'agda2-queue)
@@ -1,12 +1,51 @@+;; -*- lexical-binding: t -*- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Agda mode code which should run before the first Agda file is ;; loaded+;; SPDX-License-Identifier: MIT License -(add-to-list 'load-path- (or (file-name-directory load-file-name) (car load-path)))+;;; Code: +;; By adding an `agda2--mark-as-safe' to `defun-declarations-alist',+;; we can use the `declare' syntax at the beginning of a `defun' to+;; denote that the function may be invoked and what form the arguments+;; ought to have.+(eval-and-compile+ (defun agda2--mark-as-safe (fn _args type)+ "Set the `agda2-safe-function' property for the function FN.+TYPE must be a list of `cl-typep'-compatible types that will+each be checked against the arguments when invoked. This+information is used by `agda2-exec-response' to safeguard the+execution."+ ;; Handle a `&repeat' in the safe argument spec by creating a+ ;; cyclic list. We copy the list to avoid destructively modifying+ ;; the argument list, which might be part of the physical code+ ;; structure.+ (dolist (arg type)+ (when (and (symbolp arg)+ (string-match-p "\\`&" (symbol-name arg))+ (not (eq '&repeat arg)))+ (error "%S: Unsupported keyword %S" fn arg)))+ (let* ((type (copy-sequence type))+ (rep (memq '&repeat type)))+ (when rep+ (setf (car rep) (cadr rep)+ (cdr rep) (cddr rep)+ (cdr (last rep)) rep))+ `(put ',fn 'agda2-safe-function ',type)))++ (add-to-list+ 'defun-declarations-alist+ (list 'agda2-command #'agda2--mark-as-safe)))++(defvar agda2-directory (file-name-directory load-file-name)+ "Path to the directory that contains agda2.el(c).")++(add-to-list 'load-path (or agda2-directory (car load-path)))+ (autoload 'agda2-mode "agda2-mode" "Major mode for editing Agda files (version ≥ 2)." t)+(add-to-list 'completion-ignored-extensions ".agdai") (add-to-list 'auto-mode-alist '("\\.l?agda\\'" . agda2-mode)) (modify-coding-system-alist 'file "\\.l?agda\\'" 'utf-8)
@@ -1,15 +1,18 @@+;; -*- lexical-binding: t -*- ;;; annotation.el --- Functions for annotating text with faces and help bubbles +;; Version: 1.0++;; SPDX-License-Identifier: MIT License+;; URL: https://github.com/agda/agda+;; Version: 1.0+ ;;; Commentary:-;; -;;; Code:-(require 'cl)+;; Note that this library enumerates buffer positions starting from 1,+;; just like Emacs. -(defconst annotations-offset (- (save-restriction (widen) (point-min)) 1)- "Offset between buffer positions and annotations's positions.-Annotations's positions are based on 1, so this adjusts it to the base-position used by your Emacs.")+(require 'cl-lib) (defvar annotation-bindings nil "An association list mapping symbols to faces.")@@ -18,32 +21,70 @@ (defvar annotation-goto-stack nil "Positions from which `annotation-goto' was invoked.") -(defun annotation-goto-possible (pos)- "Return t if there's a hyperlink at the buffer position POS, and nil otherwise."- (if (get-text-property pos 'annotation-goto) t))+(defun annotation-goto-indirect (link &optional other-window)+ "Follow the `annotation-goto' hyperlink pointed to by LINK, if any. -(defun annotation-goto-indirect (pos &optional other-window)- "Follow the `annotation-goto' hyperlink at position POS, if any.-If OTHER-WINDOW is t, use another window to display the given position."- (let ((previous-file-name buffer-file-name))- (if (and (annotation-goto (get-text-property pos 'annotation-goto)- other-window)- (not (eq (point) pos)))- (push `(,previous-file-name . ,pos) annotation-goto-stack))))+LINK should be a buffer position, or an event object (in which+case the ending position is used). +If the hyperlink exists and the jump is performed successfully,+then `t' is returned, and otherwise `nil' (unless an error is+raised).++If OTHER-WINDOW is non-nil, then another window is used to+display the target position."+ (let (source-pos+ source-window+ source-buffer+ target)+ (cond ((eventp link)+ (let ((pn (event-end link)))+ (when (not (posn-area pn))+ (setq source-pos (posn-point pn))+ (setq source-window (posn-window pn))+ (setq source-buffer (window-buffer source-window)))))+ ((integerp link)+ (setq source-pos link)+ (setq source-window (selected-window))+ (setq source-buffer (current-buffer)))+ (t (error "Not an integer or event object: %S" link)))+ (when (and source-pos source-buffer)+ (with-current-buffer source-buffer+ (setq target (get-text-property source-pos 'annotation-goto)))+ (when target+ (unless (equal source-window (selected-window))+ (select-window source-window))+ (annotation-goto-and-push source-buffer source-pos target+ other-window)))))+ (defun annotation-go-back nil- "Go back to the previous position in which `annotation-goto' was+ "Go back to the previous position.+The previous position in which `annotation-goto-and-push' was successfully invoked." (when annotation-goto-stack (let ((pos (pop annotation-goto-stack))) (annotation-goto pos)))) +(defun annotation-goto-and-push (source-buffer source-pos filepos &optional other-window)+ "Like `annotation-goto', but pushes a position when successful.+The position consists of the file visited by SOURCE-BUFFER, and+the position given by SOURCE-POS."+ (let (source-file-name)+ (with-current-buffer source-buffer+ (setq source-file-name buffer-file-name))+ (when (annotation-goto filepos other-window)+ (unless (and (equal source-buffer (current-buffer))+ (eq source-pos (point)))+ (push `(,source-file-name . ,source-pos)+ annotation-goto-stack))+ t)))+ (defun annotation-goto (filepos &optional other-window) "Go to file position FILEPOS if the file is readable. FILEPOS should have the form (FILE . POS). Return t if successful. -If OTHER-WINDOW is t, use another window to display the given-position."+If OTHER-WINDOW is non-nil, use another window to display the+given position." (when (consp filepos) (let ((file (car filepos))) (if (file-readable-p file)@@ -51,16 +92,69 @@ (if other-window (find-file-other-window file) (find-file file))- (goto-char (+ (cdr filepos) annotations-offset))+ (goto-char (cdr filepos)) t) (error "File does not exist or is unreadable: %s." file))))) -(defun annotation-annotate (start end anns &optional info goto)- "Annotate text between START and END in the current buffer.-ANNS are the annotations to apply. All the symbols in ANNS are-looked up in `annotation-bindings', and the font-lock-face text-property for the given character range is set to the resulting-list of faces. If the string INFO is non-nil, the mouse-face+(defun annotation-merge-faces (start end faces &optional object)+ "Helper procedure used by `annotation-annotate'.+For each position in the range the FACES are merged+with the current value of the annotation-faces text property, and+both the face and the annotation-faces text properties are set to+the resulting list of faces.++If annotations are set in an OBJECT rather than in the current buffer,+we set the \='font-lock-face property rather than the \='face property,+as the latter is overwritten if we place the OBJECT in a buffer+that uses font-lock-mode, such as the Agda information buffer.++Precondition: START and END must be numbers, and START must be+less than END."+ (cl-assert (condition-case nil (< start end) (error nil)))+ (let ((pos start)+ ;; For the Agda buffers we use 'face,+ ;; but for putting annotated text in the Agda information buffer+ ;; we use 'font-lock-face, otherwise it is overwritten by font-lock.+ ;; In particular, compilation-mode as used in the Agda information buffer+ ;; will clear 'face annotations but preserve 'font-lock-face ones.+ ;; https://emacs.stackexchange.com/questions/17141/how-do-i-insert-text-with-a-specific-face+ (face-or-font-lock-face (if object 'font-lock-face 'face))+ mid)+ (while (< pos end)+ (setq mid (next-single-property-change pos 'annotation-faces+ object end))+ (let* ((old-faces (get-text-property pos 'annotation-faces object))+ (all-faces (cl-union old-faces faces)))+ (put-text-property pos mid 'annotation-faces all-faces object)+ (put-text-property pos mid face-or-font-lock-face all-faces object)+ (setq pos mid)))))++(defun annotation-annotate+ (start end anns &optional token-based info goto object)+ "Annotate text between START and END in the current buffer,+or in OBJECT if given.++Nothing happens if either START or END are out of bounds for the+current (possibly narrowed) buffer, or END <= START.++If ANNS is nil, then those text properties between START and END+that have been set by this function are deleted. Otherwise the+following happens.++All the symbols in ANNS are looked up in `annotation-bindings',+and the resulting list of faces is used to set the face text+property. For each position in the range the faces are merged+with the current value of the annotation-faces text property, and+both the face and the annotation-faces text properties are set to+the resulting list of faces.++If TOKEN-BASED is non-nil, then the annotation-token-based+property is set to t. This means that all text properties set by+`annotation-annotate' in this range are interpreted as being+token-based, including those set by previous calls to this+procedure.++If the string INFO is non-nil, the mouse-face property is set to highlight, and INFO is used as the help-echo string. If GOTO has the form (FILENAME . POSITION), then the mouse-face property is set to highlight, and the given@@ -75,93 +169,110 @@ annotation-annotations is set to a list with all the properties that have been set; this ensures that the text properties can later be removed (if the annotation-* properties are not tampered-with).--Note finally that nothing happens if either START or END are out of-bounds for the current (possibly narrowed) buffer, or END < START."- (incf start annotations-offset)- (incf end annotations-offset)- (when (and (<= (point-min) start)- (< start end)- (<= end (point-max)))- (let ((faces (delq nil- (mapcar (lambda (ann)- (cdr (assoc ann annotation-bindings)))- anns)))- (props nil))- (when faces- (put-text-property start end 'font-lock-face faces)- (add-to-list 'props 'font-lock-face))- (when (consp goto)- (add-text-properties start end- `(annotation-goto ,goto- mouse-face highlight))- (add-to-list 'props 'annotation-goto)- (add-to-list 'props 'mouse-face))- (when info- (add-text-properties start end- `(mouse-face highlight help-echo ,info))- (add-to-list 'props 'mouse-face)- (add-to-list 'props 'help-echo))- (when props- (let ((pos start)- mid)- (while (< pos end)- (setq mid (next-single-property-change pos- 'annotation-annotations nil end))- (let* ((old-props (get-text-property pos 'annotation-annotations))- (all-props (union old-props props)))- (add-text-properties pos mid- `(annotation-annotated t annotation-annotations ,all-props))- (setq pos mid))))))))+with)."+ (when (and (< start end)+ (or object+ (and (<= (point-min) start)+ (<= end (point-max)))))+ (if (null anns)+ (annotation-remove-annotations nil start end object)+ (let ((faces (delq nil+ (mapcar (lambda (ann)+ (cdr (assoc ann annotation-bindings)))+ anns)))+ (props nil))+ ;; (message "annotation-bindings = %s" annotation-bindings)+ ;; (message "anns = %s" anns)+ ;; (message "faces = %s" faces)+ (when faces+ (annotation-merge-faces start end faces object)+ (cl-pushnew 'face props)+ (cl-pushnew 'annotation-faces props))+ (when token-based+ (add-text-properties start end+ `(annotation-token-based t) object)+ (cl-pushnew 'annotation-token-based props))+ (when (consp goto)+ (add-text-properties start end+ `(annotation-goto ,goto mouse-face highlight)+ object)+ (cl-pushnew 'annotation-goto props)+ (cl-pushnew 'mouse-face props))+ (when info+ (add-text-properties start end+ `(mouse-face highlight help-echo ,info) object)+ (cl-pushnew 'mouse-face props)+ (cl-pushnew 'help-echo props))+ (when props+ (cl-pushnew 'annotation-annotated props)+ (let ((pos start)+ mid)+ (while (< pos end)+ (setq mid (next-single-property-change pos+ 'annotation-annotations object end))+ (let* ((old-props (get-text-property pos 'annotation-annotations object))+ (all-props (cl-union old-props props)))+ (add-text-properties pos mid+ `(annotation-annotated t annotation-annotations ,all-props) object)+ (setq pos mid))))))))) (defmacro annotation-preserve-mod-p-and-undo (&rest code)- "Run CODE preserving both the undo data and the modification bit."+ "Run CODE preserving both the undo data and the modification bit.+Modification hooks are also disabled."+ (declare (debug (&rest form))) (let ((modp (make-symbol "modp"))) `(let ((,modp (buffer-modified-p)) ;; Don't check if the file is being modified by some other process. (buffer-file-name nil) ;; Don't record those changes on the undo-log.- (buffer-undo-list t))+ (buffer-undo-list t)+ ;; Don't run modification hooks.+ (inhibit-modification-hooks t)) (unwind-protect (progn ,@code) (restore-buffer-modified-p ,modp))))) -(defun annotation-remove-annotations ()- "Remove all text properties set by `annotation-annotate' in the current buffer.-This function preserves the file modification stamp of the current buffer-and does not modify the undo list.+(defun annotation-remove-annotations (&optional token-based start end object)+ "Remove text properties set by `annotation-annotate'. -Note: This function may fail if there is read-only text in the buffer."+In the current buffer or OBJECT. If START and END are given, then+properties are only removed between these positions. If+TOKEN-BASED is non-nil, then only token-based properties are+removed. +This function preserves the file modification stamp of the+current buffer, does not modify the undo list, and temporarily+disables all modification hooks.++Note: This function may fail if there is read-only text in the+buffer."+ ;; remove-text-properties fails for read-only text. (annotation-preserve-mod-p-and-undo- (let ((pos (point-min))+ (let ((tag (if token-based+ 'annotation-token-based+ 'annotation-annotated))+ (pos (or start (if object 0 (point-min))))+ (end (or end (if object (length object) (point-max)))) pos2) (while pos- (setq pos2 (next-single-property-change pos 'annotation-annotated))- (let ((props (get-text-property pos 'annotation-annotations)))- (when props+ (let ((props (get-text-property pos 'annotation-annotations object)))+ (setq pos2 (next-single-property-change pos tag object end))+ (when (and props+ (or (not token-based)+ (member 'annotation-token-based props))) (remove-text-properties pos (or pos2 (point-max))- (mapcan (lambda (prop) (list prop nil))- (append '(annotation-annotated annotation-annotations)- props)))))- (setq pos pos2)))))--(defun annotation-load-file (file removep &optional goto-help)- "Apply the annotations in FILE.-If FILE is empty, then this function does nothing; otherwise the-following comments apply.+ (cl-mapcan (lambda (prop) (list prop nil))+ (cons 'annotation-annotations props))+ object)))+ (setq pos (unless (or (not pos2) (>= pos2 end)) pos2)))))) -If (`funcall' REMOVEP anns) is non-nil, then all existing text-properties set by `annotation-annotate' in the current buffer are-first removed. Here anns is a list containing all the-annotations (third argument to `annotation-annotate') to be-applied (in some order, with duplicates removed).+(defun annotation-load (goto-help remove object &rest cmds)+ "Apply highlighting annotations in CMDS in OBJECT or the current buffer. -FILE, if non-empty, should contain a list of lists (start end-anns &optional info goto). Text between start and end will be+The argument CMDS should be a list of lists (start end anns+&optional info goto). Text between start and end will be annotated with the annotations in the list anns (using `annotation-annotate'). If info and/or goto are present they will be used as the corresponding arguments to `annotation-annotate'.@@ -171,29 +282,42 @@ GOTO-HELP. The intention is that the default help text should inform the user about the \"goto\" facility. +If REMOVE is nil, then old syntax highlighting information is not+removed. Otherwise all token-based syntax highlighting is+removed. In order to reduce the risk of flicker this highlighting+is removed step by step, in conjunction with the addition of new+highlighting. (This process assumes that CMDS is ordered by the+positions of the annotations. If it isn't, then the highlighting+is still applied correctly, but perhaps with more flicker.)+ This function preserves the file modification stamp of the-current buffer and does not modify the undo list.+current buffer, does not modify the undo list, and temporarily+disables all modification hooks. -Note: This function may fail if there is read-only text in the buffer."+Note: This function may fail if there is read-only text in the+buffer." (annotation-preserve-mod-p-and-undo- (when (file-readable-p file)- (let ((cmds (with-temp-buffer- (insert-file-contents file)- (if (eq (point-min) (point-max))- 'empty-file- (goto-char (point-min))- (read (current-buffer))))))- (when (listp cmds)- (let ((anns (delete-dups- (apply 'append (mapcar (lambda (x) (nth 2 x)) cmds)))))- (if (funcall removep anns)- (annotation-remove-annotations))- (dolist (cmd cmds)- (destructuring-bind (start end anns &optional info goto) cmd- (let ((info (if (and (not info) (consp goto))- goto-help- info)))- (annotation-annotate start end anns info goto))))))))))+ (when (listp cmds)+ ;; (message "cmds = %s" cmds)+ (let ((pos (if object 0 (point-min))))+ (dolist (cmd cmds)+ ;; (message "cmd = %s" cmd)+ (when cmd+ (cl-destructuring-bind+ (start end anns &optional token-based info goto) cmd+ (let ((info (if (and (not info) (consp goto))+ goto-help+ info)))+ (when remove+ (annotation-remove-annotations+ 'token-based pos end object)+ (setq pos end))+ (annotation-annotate+ start end anns token-based info goto object)))))+ ;; Remove annotations from the last point to the end of the buffer.+ (when remove+ (annotation-remove-annotations+ 'token-based pos (if object (length object) (point-max)) object)))))) (provide 'annotation) ;;; annotation.el ends here
@@ -1,10 +1,17 @@+;; -*- lexical-binding: t -*- ;;; eri.el --- Enhanced relative indentation (eri) +;; SPDX-License-Identifier: MIT License+;; URL: https://github.com/agda/agda+;; Version: 1.0+ ;;; Commentary: +;; Cycle between indentation points with enhanced relative indentation.+ ;;; Code: -(require 'cl)+(require 'cl-lib) (defun eri-current-line-length nil "Calculate length of current line."@@ -28,7 +35,7 @@ "Return a pair of lists (XS1 . XS2). If XS is sorted, then XS = (append XS1 XS2), and all elements in XS1 are <= X, whereas all elements in XS2 are > X."- (let* ((pos (or (position-if (lambda (y) (> y x)) xs) (length xs)))+ (let* ((pos (or (cl-position-if (lambda (y) (> y x)) xs) (length xs))) (xs1 (eri-take pos xs)) (xs2 (nthcdr pos xs))) (cons xs1 xs2)))@@ -45,7 +52,7 @@ ^ ^ ^ ^ ^ ^ ^ ^ | | MAX"- (let ((result))+ (let ((result nil)) (save-excursion (save-restriction (beginning-of-line)@@ -59,7 +66,7 @@ (when (not (null pos)) (let ((pos1 (- pos (line-beginning-position)))) (when (or (null max) (< pos1 max))- (add-to-list 'result pos1))))+ (cl-pushnew pos1 result)))) (and pos (< (point) (line-end-position)) (or (null max) (< (current-column) max))))))
@@ -0,0 +1,42 @@+/* Aspects. */+.Agda .Comment { color: #B22222 }+.Agda .Background {}+.Agda .Markup { color: #000000 }+.Agda .Keyword { color: #CD6600 }+.Agda .String { color: #B22222 }+.Agda .Number { color: #A020F0 }+.Agda .Symbol { color: #404040 }+.Agda .PrimitiveType { color: #0000CD }+.Agda .Pragma { color: black }+.Agda .Operator {}+.Agda .Hole { background: #B4EEB4 }++/* NameKinds. */+.Agda .Bound { color: black }+.Agda .Generalizable { color: black }+.Agda .InductiveConstructor { color: #008B00 }+.Agda .CoinductiveConstructor { color: #8B7500 }+.Agda .Datatype { color: #0000CD }+.Agda .Field { color: #EE1289 }+.Agda .Function { color: #0000CD }+.Agda .Macro { color: #0000CD }+.Agda .Module { color: #A020F0 }+.Agda .Postulate { color: #0000CD }+.Agda .Primitive { color: #0000CD }+.Agda .Record { color: #0000CD }++/* OtherAspects. */+.Agda .DottedPattern {}+.Agda .UnsolvedMeta { color: black; background: yellow }+.Agda .UnsolvedConstraint { color: black; background: yellow }+.Agda .TerminationProblem { color: black; background: #FFA07A }+.Agda .IncompletePattern { color: black; background: #F5DEB3 }+.Agda .Error { color: red; text-decoration: underline }+.Agda .TypeChecks { color: black; background: #ADD8E6 }+.Agda .Deadcode { color: black; background: #808080 }+.Agda .ShadowingInTelescope { color: black; background: #808080 }++/* Standard attributes. */+.Agda a { text-decoration: none }+.Agda a[href]:hover { background-color: #B4EEB4 }+.Agda [href].hover-highlight { background-color: #B4EEB4; }
@@ -0,0 +1,35 @@+// Copyright 2023, Andreas Abel.+// Falls under the Agda license at https://github.com/agda/agda/blob/master/LICENSE++// When we hover over an Agda identifier, we highlight all occurrences of this identifier on the page.+// To this end, we create a map from identifier to all of its occurrences in the beginning.++// A dictionary from hrefs to 'a'-elements that have this href.+const dict = new Map();++window.onload = function () {++ // Get all 'a' tags with an 'href' attribute.+ // We call those "objects".+ const objs = document.querySelectorAll('a[href]');++ // Build a dictionary mapping a href to a set of objects that have this href.+ for (const obj of objs) {+ const key = obj.href;+ const set = dict.get(key) ?? new Set();+ set.add(obj);+ dict.set(key, set);+ }++ // Install 'onmouseover' and 'onmouseout' event handlers for all objects.+ for (const obj of objs) {+ // 'onmouseover' for an object adds attribute 'hover-highlight' to all objects with the same href.+ obj.onmouseover = function () {+ for (const o of dict.get(this.href)) { o.classList.add('hover-highlight'); }+ }+ // 'onmouseover' removes the added 'hover-highlight' attributes again.+ obj.onmouseout = function () {+ for (const o of dict.get(this.href)) { o.classList.remove('hover-highlight'); }+ }+ }+};
@@ -0,0 +1,741 @@+% ----------------------------------------------------------------------+% Some useful commands when doing highlighting of Agda code in LaTeX.+% ----------------------------------------------------------------------++% !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!+% !!! NOTE: when you make changes to this file, bump the date. !!!+% !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!+\ProvidesPackage{agda}+ [2026/10/17 version 2.9.0 Formatting LaTeX generated by Agda]++\RequirePackage{ifxetex, ifluatex, xifthen, xcolor, polytable, etoolbox,+ calc, environ, xparse, xkeyval}++% https://tex.stackexchange.com/questions/47576/combining-ifxetex-and-ifluatex-with-the-logical-or-operation+\newif\ifxetexorluatex+\ifxetex+ \xetexorluatextrue+\else+ \ifluatex+ \xetexorluatextrue+ \else+ \xetexorluatexfalse+ \fi+\fi++% ----------------------------------------------------------------------+% Options++\DeclareOption{bw} {\newcommand{\AgdaColourScheme}{bw}}+\DeclareOption{conor}{\newcommand{\AgdaColourScheme}{conor}}++\newif\if@AgdaEnableReferences\@AgdaEnableReferencesfalse+\DeclareOption{references}{+ \@AgdaEnableReferencestrue+}++\newif\if@AgdaEnableLinks\@AgdaEnableLinksfalse+\DeclareOption{links}{+ \@AgdaEnableLinkstrue+}++\ProcessOptions\relax++% ----------------------------------------------------------------------+% Font setup++\tracinglostchars=2 % If the font is missing some symbol, then say+ % so in the compilation output.++% ----------------------------------------------------------------------+% Colour schemes.++\providecommand{\AgdaColourScheme}{standard}++% ----------------------------------------------------------------------+% References to code (needs additional post-processing of tex files to+% work, see wiki for details).++\if@AgdaEnableReferences+ \RequirePackage{catchfilebetweentags, xstring}+ \newcommand{\AgdaRef}[2][]{%+ \StrSubstitute{#2}{\_}{AgdaUnderscore}[\tmp]%+ \ifthenelse{\isempty{#1}}%+ {\ExecuteMetaData{AgdaTag-\tmp}}%+ {\ExecuteMetaData{#1}{AgdaTag-\tmp}}+ }+\fi++\providecommand{\AgdaRef}[2][]{#2}++% ----------------------------------------------------------------------+% Links (only done if the option is passed and the user has loaded the+% hyperref package).++\if@AgdaEnableLinks+ \@ifpackageloaded{hyperref}{++ % List that holds added targets.+ \newcommand{\AgdaList}[0]{}++ \newtoggle{AgdaIsElem}+ \newcounter{AgdaIndex}+ \newcommand{\AgdaLookup}[3]{%+ \togglefalse{AgdaIsElem}%+ \setcounter{AgdaIndex}{0}%+ \renewcommand*{\do}[1]{%+ \ifstrequal{#1}{##1}%+ {\toggletrue{AgdaIsElem}\listbreak}%+ {\stepcounter{AgdaIndex}}}%+ \dolistloop{\AgdaList}%+ \iftoggle{AgdaIsElem}{#2}{#3}%+ }++ \newcommand*{\AgdaTargetHelper}[1]{%+ \AgdaLookup{#1}%+ {\PackageError{agda}{``#1'' used as target more than once}%+ {Overloaded identifiers and links do not%+ work well, consider using unique%+ \MessageBreak identifiers instead.}%+ }%+ {\listadd{\AgdaList}{#1}%+ \hypertarget{Agda\theAgdaIndex}{}%+ }%+ }++ \newcommand{\AgdaTarget}[1]{\forcsvlist{\AgdaTargetHelper}{#1}}++ \newcommand{\AgdaLink}[1]{%+ \AgdaLookup{#1}%+ {\hyperlink{Agda\theAgdaIndex}{#1}}%+ {#1}%+ }+ }{\PackageError{agda}{Load the hyperref package before the agda package}{}}+\fi++\providecommand{\AgdaTarget}[1]{}+\providecommand{\AgdaLink}[1]{#1}++% ----------------------------------------------------------------------+% Font styles.++\newcommand{\AgdaFontStyle}[1]{\textsf{#1}}+\ifthenelse{\equal{\AgdaColourScheme}{bw}}{+ \newcommand{\AgdaKeywordFontStyle}[1]{\underline{#1}}+}{+ \newcommand{\AgdaKeywordFontStyle}[1]{\textsf{#1}}+}+\newcommand{\AgdaStringFontStyle}[1]{\texttt{#1}}+\newcommand{\AgdaCommentFontStyle}[1]{\texttt{#1}}+\newcommand{\AgdaBoundFontStyle}[1]{\textit{#1}}++% ----------------------------------------------------------------------+% Colours.++% ----------------------------------+% The black and white colour scheme.+\ifthenelse{\equal{\AgdaColourScheme}{bw}}{++ % Aspect colours.+ \definecolor{AgdaComment} {HTML}{000000}+ \definecolor{AgdaPragma} {HTML}{000000}+ \definecolor{AgdaKeyword} {HTML}{000000}+ \definecolor{AgdaString} {HTML}{000000}+ \definecolor{AgdaNumber} {HTML}{000000}+ \definecolor{AgdaSymbol} {HTML}{000000}+ \definecolor{AgdaPrimitiveType}{HTML}{000000}++ % NameKind colours.+ \definecolor{AgdaBound} {HTML}{000000}+ \definecolor{AgdaGeneralizable} {HTML}{000000}+ \definecolor{AgdaInductiveConstructor} {HTML}{000000}+ \definecolor{AgdaCoinductiveConstructor}{HTML}{000000}+ \definecolor{AgdaDatatype} {HTML}{000000}+ \definecolor{AgdaField} {HTML}{000000}+ \definecolor{AgdaFunction} {HTML}{000000}+ \definecolor{AgdaMacro} {HTML}{000000}+ \definecolor{AgdaModule} {HTML}{000000}+ \definecolor{AgdaPostulate} {HTML}{000000}+ \definecolor{AgdaPrimitive} {HTML}{000000}+ \definecolor{AgdaRecord} {HTML}{000000}+ \definecolor{AgdaArgument} {HTML}{000000}++ % Other aspect colours.+ \definecolor{AgdaDottedPattern} {HTML}{000000}+ \definecolor{AgdaUnsolvedMeta} {HTML}{D3D3D3}+ \definecolor{AgdaUnsolvedConstraint}{HTML}{D3D3D3}+ \definecolor{AgdaTerminationProblem}{HTML}{BEBEBE}+ \definecolor{AgdaPositivityProblem} {HTML}{BEBEBE}+ \definecolor{AgdaInstanceProblem} {HTML}{BEBEBE} %% TODO pick color+ \definecolor{AgdaCoverageProblem} {HTML}{D3D3D3}+ \definecolor{AgdaErrorWarning} {HTML}{BEBEBE}+ \definecolor{AgdaError} {HTML}{696969}+ \definecolor{AgdaDeadcode} {HTML}{EDEDED}++ % Misc.+ \definecolor{AgdaHole} {HTML}{BEBEBE}++% ----------------------------------+% Conor McBride's colour scheme.+}{ \ifthenelse{\equal{\AgdaColourScheme}{conor}}{++ % Aspect colours.+ \definecolor{AgdaComment} {HTML}{B22222}+ \definecolor{AgdaPragma} {HTML}{000000}+ \definecolor{AgdaKeyword} {HTML}{000000}+ \definecolor{AgdaString} {HTML}{000000}+ \definecolor{AgdaNumber} {HTML}{000000}+ \definecolor{AgdaSymbol} {HTML}{000000}+ \definecolor{AgdaPrimitiveType}{HTML}{0000CD}++ % NameKind colours.+ \definecolor{AgdaBound} {HTML}{A020F0}+ \definecolor{AgdaGeneralizable} {HTML}{A020F0}+ \definecolor{AgdaInductiveConstructor} {HTML}{8B0000}+ \definecolor{AgdaCoinductiveConstructor}{HTML}{8B0000}+ \definecolor{AgdaDatatype} {HTML}{0000CD}+ \definecolor{AgdaField} {HTML}{8B0000}+ \definecolor{AgdaFunction} {HTML}{006400}+ \definecolor{AgdaMacro} {HTML}{006400}+ \definecolor{AgdaModule} {HTML}{006400}+ \definecolor{AgdaPostulate} {HTML}{006400}+ \definecolor{AgdaPrimitive} {HTML}{006400}+ \definecolor{AgdaRecord} {HTML}{0000CD}+ \definecolor{AgdaArgument} {HTML}{404040}++ % Other aspect colours.+ \definecolor{AgdaDottedPattern} {HTML}{000000}+ \definecolor{AgdaUnsolvedMeta} {HTML}{FFD700}+ \definecolor{AgdaUnsolvedConstraint}{HTML}{FFD700}+ \definecolor{AgdaTerminationProblem}{HTML}{FF0000}+ \definecolor{AgdaPositivityProblem} {HTML}{FF0000}+ \definecolor{AgdaInstanceProblem} {HTML}{FF0000} %% TODO pick color+ \definecolor{AgdaCoverageProblem} {HTML}{A020F0}+ \definecolor{AgdaErrorWarning} {HTML}{FF0000}+ \definecolor{AgdaError} {HTML}{F4A460}+ \definecolor{AgdaDeadcode} {HTML}{EDEDED}++ % Misc.+ \definecolor{AgdaHole} {HTML}{9DFF9D}++% ----------------------------------+% The standard colour scheme.+}{+ % Aspect colours.+ \definecolor{AgdaComment} {HTML}{B22222}+ \definecolor{AgdaPragma} {HTML}{000000}+ \definecolor{AgdaKeyword} {HTML}{CD6600}+ \definecolor{AgdaString} {HTML}{B22222}+ \definecolor{AgdaNumber} {HTML}{A020F0}+ \definecolor{AgdaSymbol} {HTML}{404040}+ \definecolor{AgdaPrimitiveType}{HTML}{0000CD}++ % NameKind colours.+ \definecolor{AgdaBound} {HTML}{000000}+ \definecolor{AgdaGeneralizable} {HTML}{000000}+ \definecolor{AgdaInductiveConstructor} {HTML}{008B00}+ \definecolor{AgdaCoinductiveConstructor}{HTML}{8B7500}+ \definecolor{AgdaDatatype} {HTML}{0000CD}+ \definecolor{AgdaField} {HTML}{EE1289}+ \definecolor{AgdaFunction} {HTML}{0000CD}+ \definecolor{AgdaMacro} {HTML}{458B74}+ \definecolor{AgdaModule} {HTML}{A020F0}+ \definecolor{AgdaPostulate} {HTML}{0000CD}+ \definecolor{AgdaPrimitive} {HTML}{0000CD}+ \definecolor{AgdaRecord} {HTML}{0000CD}+ \definecolor{AgdaArgument} {HTML}{404040}++ % Other aspect colours.+ \definecolor{AgdaDottedPattern} {HTML}{000000}+ \definecolor{AgdaUnsolvedMeta} {HTML}{FFFF00}+ \definecolor{AgdaUnsolvedConstraint}{HTML}{FFFF00}+ \definecolor{AgdaTerminationProblem}{HTML}{FFA07A}+ \definecolor{AgdaPositivityProblem} {HTML}{FFA07A}+ \definecolor{AgdaInstanceProblem} {HTML}{FFA07A} %% TODO pick color+ \definecolor{AgdaCoverageProblem} {HTML}{F5DEB3}+ \definecolor{AgdaErrorWarning} {HTML}{FFA07A}+ \definecolor{AgdaError} {HTML}{FF0000}+ \definecolor{AgdaDeadcode} {HTML}{EDEDED}++ % Misc.+ \definecolor{AgdaHole} {HTML}{9DFF9D}+}}++% ----------------------------------------------------------------------+% Commands.++\newcommand{\AgdaNoSpaceMath}[1]+ {\begingroup\thickmuskip=0mu\medmuskip=0mu#1\endgroup}++% Aspect commands.+\newcommand{\AgdaComment} [1]+ {\AgdaNoSpaceMath{\textcolor{AgdaComment}{\AgdaCommentFontStyle{#1}}}}+\newcommand{\AgdaPragma} [1]+ {\AgdaNoSpaceMath{\textcolor{AgdaPragma}{\AgdaCommentFontStyle{#1}}}}+\newcommand{\AgdaKeyword} [1]+ {\AgdaNoSpaceMath{\textcolor{AgdaKeyword}{\AgdaKeywordFontStyle{#1}}}}+\newcommand{\AgdaString} [1]+ {\AgdaNoSpaceMath{\textcolor{AgdaString}{\AgdaStringFontStyle{#1}}}}+\newcommand{\AgdaNumber} [1]+ {\AgdaNoSpaceMath{\textcolor{AgdaNumber}{\AgdaFontStyle{#1}}}}+\newcommand{\AgdaSymbol} [1]+ {\AgdaNoSpaceMath{\textcolor{AgdaSymbol}{\AgdaFontStyle{#1}}}}+\newcommand{\AgdaPrimitiveType}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaPrimitiveType}{\AgdaFontStyle{#1}}}}+%% Andreas, 2021-07-14, issue #5471+%% To make italics correction \/ work, the font-style modifier+%% needs to be inside, in particular inside the \textcolor modifier,+%% as the \textcolor{} wrapping around something hides its content+%% to the logic that resolves \/ into a space or not.++% Note that, in code generated by the LaTeX backend, \AgdaOperator is+% always applied to a NameKind command.+\newcommand{\AgdaOperator} [1]{#1}++% NameKind commands.++% The user can control the typesetting of (certain) individual tokens+% by redefining the following command. The first argument is the token+% and the second argument the thing to be typeset (sometimes just the+% token, sometimes \AgdaLink{<the token>}). Example:+%+% \usepackage{ifthen}+%+% % Insert extra space before some tokens.+% \DeclareRobustCommand{\AgdaFormat}[2]{%+% \ifthenelse{+% \equal{#1}{≡⟨} \OR+% \equal{#1}{≡⟨⟩} \OR+% \equal{#1}{∎}+% }{\ }{}#2}+%+% Note the use of \DeclareRobustCommand.++\newcommand{\AgdaFormat}[2]{#2}++\newcommand{\AgdaBound}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaBound}{\AgdaBoundFontStyle{\AgdaFormat{#1}{#1}}}}}+\newcommand{\AgdaGeneralizable}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaGeneralizable}{\AgdaBoundFontStyle{\AgdaFormat{#1}{#1}}}}}+\newcommand{\AgdaInductiveConstructor}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaInductiveConstructor}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaCoinductiveConstructor}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaCoinductiveConstructor}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaDatatype}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaDatatype}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaField}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaField}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaFunction}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaFunction}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaMacro}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaMacro}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaModule}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaModule}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaPostulate}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaPostulate}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaPrimitive}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaPrimitive}{\AgdaFontStyle{\AgdaFormat{#1}{#1}}}}}+\newcommand{\AgdaRecord}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaRecord}{\AgdaFontStyle{\AgdaFormat{#1}{\AgdaLink{#1}}}}}}+\newcommand{\AgdaArgument}[1]+ {\AgdaNoSpaceMath{\textcolor{AgdaArgument}{\AgdaBoundFontStyle{\AgdaFormat{#1}{#1}}}}}++% Other aspect commands.+\newcommand{\AgdaFixityOp} [1]{\AgdaNoSpaceMath{$#1$}}+\newcommand{\AgdaDottedPattern} [1]{\textcolor{AgdaDottedPattern}{#1}}+% Boxes (background color):+\newcommand{\AgdaDeadcode} [1]{\AgdaFontStyle{\colorbox{AgdaDeadcode}{#1}}}+\newcommand{\AgdaInstanceProblem} [1]{\AgdaFontStyle{\colorbox{AgdaInstanceProblem}{#1}}}+\newcommand{\AgdaUnsolvedConstraint}[1]{\AgdaFontStyle{\colorbox{AgdaUnsolvedConstraint}{#1}}}+\newcommand{\AgdaUnsolvedMeta} [1]{\AgdaFontStyle{\colorbox{AgdaUnsolvedMeta}{#1}}}+% TODO: add coloring+\newcommand{\AgdaCatchallClause }[1]{#1} % feel free to change this+\newcommand{\AgdaCosmeticProblem }[1]{#1} % feel free to change this+\newcommand{\AgdaShadowingInTelescope}[1]{#1} % feel free to change this++% The following aspect are currently unused because Agda does not texify+% documents with error warnings.+\newcommand{\AgdaError} [1]{\textcolor{AgdaError}{\AgdaFontStyle{\underline{#1}}}}+% Boxes (background color):+\newcommand{\AgdaConfluenceProblem }[1]{#1} % feel free to change this+\newcommand{\AgdaCoverageProblem }[1]{\colorbox{CoverageProblem}{#1}}+\newcommand{\AgdaErrorWarning }[1]{\colorbox{AgdaErrorWarning}{#1}}+\newcommand{\AgdaMissingDefinition }[1]{#1} % currently unused+\newcommand{\AgdaPositivityProblem }[1]{\AgdaFontStyle{\colorbox{AgdaPositivityProblem}{#1}}}+\newcommand{\AgdaTerminationProblem}[1]{\AgdaFontStyle{\colorbox{AgdaTerminationProblem}{#1}}}+\newcommand{\AgdaTypeChecks }[1]{#1} % currently unused++% Used to hide code from LaTeX.+%+% Note that this macro has been deprecated in favour of giving the+% hide argument to the code environment.+\long\def\AgdaHide#1{\ignorespaces}++% Misc.+\newcommand{\AgdaHole}[1]{\colorbox{AgdaHole}{#1}}++% ----------------------------------------------------------------------+% The code environment.++\newcommand{\AgdaCodeStyle}{}+% \newcommand{\AgdaCodeStyle}{\tiny}++\ifdefined\mathindent+ {}+\else+ \newdimen\mathindent\mathindent\leftmargini+\fi++% Adds the given amount of vertical space and starts a new line.+%+% The implementation comes from lhs2TeX's polycode.fmt, written by+% Andres Löh.+\newcommand{\Agda@NewlineWithVerticalSpace}[1]{%+ {\parskip=0pt\parindent=0pt\par\vskip #1\noindent}}++% Should there be space around code?+\newboolean{Agda@SpaceAroundCode}++% Use this command to avoid extra space around code blocks.+\newcommand{\AgdaNoSpaceAroundCode}{%+ \setboolean{Agda@SpaceAroundCode}{false}}++% Use this command to include extra space around code blocks.+\newcommand{\AgdaSpaceAroundCode}{%+ \setboolean{Agda@SpaceAroundCode}{true}}++% By default space is inserted around code blocks.+\AgdaSpaceAroundCode{}++% Sometimes one might want to break up a code block into multiple+% pieces, but keep code in different blocks aligned with respect to+% each other. Then one can use the AgdaAlign environment. Example+% usage:+%+% \begin{AgdaAlign}+% \begin{code}+% code+% code (more code)+% \end{code}+% Explanation...+% \begin{code}+% aligned with "code"+% code (aligned with (more code))+% \end{code}+% \end{AgdaAlign}+%+% Note that AgdaAlign environments should not be nested.+%+% Sometimes one might also want to hide code in the middle of a code+% block. This can be accomplished in the following way:+%+% \begin{AgdaAlign}+% \begin{code}+% visible+% \end{code}+% \begin{code}[hide]+% hidden+% \end{code}+% \begin{code}+% visible+% \end{code}+% \end{AgdaAlign}+%+% However, the result may be ugly: extra space is perhaps inserted+% around the code blocks.+%+% The AgdaSuppressSpace environment ensures that extra space is only+% inserted before the first code block, and after the last one (but+% not if \AgdaNoSpaceAroundCode{} is used). Example usage:+%+% \begin{AgdaAlign}+% \begin{code}+% code+% more code+% \end{code}+% Explanation...+% \begin{AgdaSuppressSpace}+% \begin{code}+% aligned with "code"+% aligned with "more code"+% \end{code}+% \begin{code}[hide]+% hidden code+% \end{code}+% \begin{code}+% also aligned with "more code"+% \end{code}+% \end{AgdaSuppressSpace}+% \end{AgdaAlign}+%+% Note that AgdaSuppressSpace environments should not be nested.+%+% There is also a combined environment, AgdaMultiCode, that combines+% the effects of AgdaAlign and AgdaSuppressSpace.++% The number of the current/next code block (excluding hidden ones).+\newcounter{Agda@Current}+\setcounter{Agda@Current}{0}++% The number of the previous code block (excluding hidden ones), used+% locally in \Agda@SuppressEnd.+\newcounter{Agda@Previous}++% Is AgdaAlign active?+\newboolean{Agda@Align}+\setboolean{Agda@Align}{false}++% The number of the first code block (if any) in a given AgdaAlign+% environment.+\newcounter{Agda@AlignStart}++\newcommand{\Agda@AlignStart}{%+ \ifthenelse{\boolean{Agda@Align}}{%+ \PackageError{agda}{Nested AgdaAlign environments}{%+ AgdaAlign and AgdaMultiCode environments must not be+ nested.}}{%+ \setboolean{Agda@Align}{true}%+ \setcounter{Agda@AlignStart}{\value{Agda@Current}}}}++\newcommand{\Agda@AlignEnd}{\setboolean{Agda@Align}{false}}++\newenvironment{AgdaAlign}{%+ \Agda@AlignStart{}}{%+ \Agda@AlignEnd{}%+ \ignorespacesafterend}++% Is AgdaSuppressSpace active?+\newboolean{Agda@Suppress}+\setboolean{Agda@Suppress}{false}++% The number of the first code block (if any) in a given+% AgdaSuppressSpace environment.+\newcounter{Agda@SuppressStart}++% Does a "do not suppress space after" label exist for the current+% code block? (This boolean is used locally in the code environment's+% implementation.)+\newboolean{Agda@DoNotSuppressSpaceAfter}++\newcommand{\Agda@SuppressStart}{%+ \ifthenelse{\boolean{Agda@Suppress}}{%+ \PackageError{agda}{Nested AgdaSuppressSpace environments}{%+ AgdaSuppressSpace and AgdaMultiCode environments must not be+ nested.}}{%+ \setboolean{Agda@Suppress}{true}%+ \setcounter{Agda@SuppressStart}{\value{Agda@Current}}}}++% Marks the given code block as one that space should not be+% suppressed after (if AgdaSpaceAroundCode and AgdaSuppressSpace are+% both active).+\newcommand{\Agda@DoNotSuppressSpaceAfter}[1]{%+ % The use of labels is intended to ensure that LaTeX will provide a+ % warning if the document needs to be recompiled.+ \label{Agda@DoNotSuppressSpaceAfter@#1}}++\newcommand{\Agda@SuppressEnd}{%+ \ifthenelse{\value{Agda@SuppressStart} = \value{Agda@Current}}{}{%+ % Mark the previous code block in the .aux file.+ \setcounter{Agda@Previous}{\theAgda@Current-1}%+ \immediate\write\@auxout{%+ \noexpand\Agda@DoNotSuppressSpaceAfter{\theAgda@Previous}}}%+ \setboolean{Agda@Suppress}{false}}++\newenvironment{AgdaSuppressSpace}{%+ \Agda@SuppressStart{}}{%+ \Agda@SuppressEnd{}%+ \ignorespacesafterend}++\newenvironment{AgdaMultiCode}{%+ \Agda@AlignStart{}%+ \Agda@SuppressStart{}}{%+ \Agda@SuppressEnd{}%+ \Agda@AlignEnd{}%+ \ignorespacesafterend}++% Vertical space used for empty lines. By default \abovedisplayskip.+\newlength{\AgdaEmptySkip}+\setlength{\AgdaEmptySkip}{\abovedisplayskip}++% Extra space to be inserted for empty lines (the difference between+% \AgdaEmptySkip and \baselineskip). Used internally.+\newlength{\AgdaEmptyExtraSkip}++% Counter used for code numbers.+\newcounter{AgdaCodeNumber}+% Formats a code number.+\newcommand{\AgdaFormatCodeNumber}[1]{(#1)}++% A boolean used to handle the option number.+\newboolean{Agda@Number}+\setboolean{Agda@Number}{false}++% A boolean used to handle the option inline*. (For some reason the+% approach used for hide and inline does not work for inline*.)+\newboolean{Agda@InlineStar}+\setboolean{Agda@InlineStar}{false}++% Keys used by the code environment.+\define@boolkey[Agda]{code}{hide}[true]{}+\define@boolkey[Agda]{code}{inline}[true]{}+\define@boolkey[Agda]{code}{inline*}[true]{%+ \setboolean{Agda@InlineStar}{true}}+\define@key[Agda]{code}{number}[]{%+ \ifthenelse{\boolean{Agda@Number}}{}{%+ \setboolean{Agda@Number}{true}%+ % Increase the counter if this has not already been done.+ \refstepcounter{AgdaCodeNumber}}%+ % If the label is non-empty, set it. Note that it is possible to+ % give several labels for a single code listing.+ \ifthenelse{\equal{#1}{}}{}{\label{#1}}}++% The code environment.+%+% Options:+%+% * hide: The code is hidden. Other options are ignored.+%+% * number: Give the code an equation number.+%+% * number=l: Give the code an equation number and the label l. It is+% possible to use this option several times with different labels.+%+% * inline/inline*: The code is inlined. In this case most of the+% discussion above does not apply, alignment is not respected, and so+% on. It is recommended to only use this option for a single line of+% code, and to not use two consecutive spaces in this piece of code.+%+% Note that this environment ignores spaces after its end. If a space+% (\AgdaSpace{}) should be inserted after the inline code, use+% inline*, otherwise use inline.+%+% When this option is used number is ignored.+%+% The implementation is based on plainhscode in lhs2TeX's+% polycode.fmt, written by Andres Löh.+\NewEnviron{code}[1][]{%+ % Process the options. Complain about unknown options.+ \setkeys[Agda]{code}[number]{#1}%+ \ifAgda@code@hide%+ % Hide the code.+ \else%+ \ifAgda@code@inline%+ % Inline code.+ %+ % Make the polytable primitives emitted by the LaTeX backend+ % do nothing.+ \DeclareDocumentCommand{\>}{O{}O{}}{}%+ \DeclareDocumentCommand{\<}{O{}}{}%+ \AgdaCodeStyle\BODY%+ \else%+ \ifthenelse{\boolean{Agda@InlineStar}}{%+ % Inline code with space at the end.+ %+ \DeclareDocumentCommand{\>}{O{}O{}}{}%+ \DeclareDocumentCommand{\<}{O{}}{}%+ \AgdaCodeStyle\BODY\AgdaSpace{}}{%+ %+ % Displayed code.+ %+ % Conditionally emit space before the code block. Unconditionally+ % switch to a new line.+ \ifthenelse{\boolean{Agda@SpaceAroundCode} \and%+ \(\not \boolean{Agda@Suppress} \or%+ \value{Agda@SuppressStart} = \value{Agda@Current}\)}{%+ \Agda@NewlineWithVerticalSpace{\abovedisplayskip}}{%+ \Agda@NewlineWithVerticalSpace{0pt}}%+ %+ % Check if numbers have been requested. If they have, then a side+ % effect of this call is that Agda@Number is set to true, the code+ % number counter is increased, and the label (if any) is set.+ \setkeys[Agda]{code}[hide,inline,inline*]{#1}%+ \ifthenelse{\boolean{Agda@Number}}{%+ % Equation numbers have been requested. Use a minipage, so that+ % there is room for the code number to the right, and the code+ % number becomes centered vertically.+ \begin{minipage}{%+ \linewidth-%+ \widthof{%+ \AgdaSpace{}%+ \AgdaFormatCodeNumber{\theAgdaCodeNumber}}}}{}%+ %+ % Indent the entire code block.+ \advance\leftskip\mathindent%+ %+ % The code's style can be customised.+ \AgdaCodeStyle%+ %+ % Used to control the height of empty lines.+ \setlength{\AgdaEmptyExtraSkip}{\AgdaEmptySkip - \baselineskip}%+ %+ % The environment used to handle indentation (of individual lines)+ % and alignment.+ \begin{pboxed}%+ %+ % Conditionally preserve alignment between code blocks.+ \ifthenelse{\boolean{Agda@Align}}{%+ \ifthenelse{\value{Agda@AlignStart} = \value{Agda@Current}}{%+ \savecolumns}{%+ \restorecolumns}}{}%+ %+ % The code.+ \BODY%+ \end{pboxed}%+ %+ \ifthenelse{\boolean{Agda@Number}}{%+ % Equation numbers have been requested.+ \end{minipage}%+ % Insert the code number to the right.+ \hfill \AgdaFormatCodeNumber{\theAgdaCodeNumber}}{}%+ %+ % Does the label Agda@DoNotSuppressAfter@<current code block+ % number> exist?+ \ifcsdef{r@Agda@DoNotSuppressSpaceAfter@\theAgda@Current}{%+ \setboolean{Agda@DoNotSuppressSpaceAfter}{true}}{%+ \setboolean{Agda@DoNotSuppressSpaceAfter}{false}}%+ %+ % Conditionally emit space after the code block. Unconditionally+ % switch to a new line.+ \ifthenelse{\boolean{Agda@SpaceAroundCode} \and%+ \(\not \boolean{Agda@Suppress} \or%+ \boolean{Agda@DoNotSuppressSpaceAfter}\)}{%+ \Agda@NewlineWithVerticalSpace{\belowdisplayskip}}{%+ \Agda@NewlineWithVerticalSpace{0pt}}%+ %+ % Step the code block counter, but only for non-hidden code.+ \stepcounter{Agda@Current}}%+ \fi%+ \fi%+ % Reset Agda@Number and Agda@InlineStar.+ \setboolean{Agda@Number}{false}%+ \setboolean{Agda@InlineStar}{false}}++% Space inserted after tokens.+\newcommand{\AgdaSpace}{ }++% Space inserted to indent something.+\newcommand{\AgdaIndentSpace}{\AgdaSpace{}$\;\;$}++% Default column for polytable.+\defaultcolumn{@{}l@{\AgdaSpace{}}}++% \AgdaIndent expects a non-negative integer as its only argument.+% This integer should be the distance, in code blocks, to the thing+% relative to which the text is indented.+%+% The default implementation only indents if the thing that the text+% is indented relative to exists in the same code block or is wrapped+% in the same AgdaAlign or AgdaMultiCode environment.+\newcommand{\AgdaIndent}[1]{%+ \ifthenelse{#1 = 0+ \or+ \( \boolean{Agda@Align}+ \and+ \cnttest{\value{Agda@Current} - #1}{>=}{+ \value{Agda@AlignStart}}+ \)}{\AgdaIndentSpace{}}{}}++% Underscores are typeset using \AgdaUnderscore{}.+\newcommand{\AgdaUnderscore}{\_}++\endinput
@@ -0,0 +1,24 @@+#!/usr/bin/env perl++use strict;+use warnings;++my $tag_prefix = "AgdaTag";+my $underscore = "AgdaUnderscore";+my $commands = qr"(InductiveConstructor|CoinductiveConstructor\+ |Datatype|Field|Function|Module|Postulate|Record)";++while (<>) {++ s|(\\Agda$commands)\{(.*?)\}++ | my $cmd = $1;+ my $arg = $3;+ my $tag = "$tag_prefix-$3" =~ s/\\_/$underscore/gr;++ $_ = "%\n%<*$tag>\n$cmd\{$arg\}%\n%</$tag>\n";+ |gxe;++ print;++}
@@ -0,0 +1,15 @@+{-# OPTIONS --cubical-compatible --safe --no-universe-polymorphism+ --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Bool where++data Bool : Set where+ false true : Bool++{-# BUILTIN BOOL Bool #-}+{-# BUILTIN FALSE false #-}+{-# BUILTIN TRUE true #-}++{-# COMPILE JS Bool = function (x,v) { return ((x)? v["true"]() : v["false"]()); } #-}+{-# COMPILE JS false = false #-}+{-# COMPILE JS true = true #-}
@@ -0,0 +1,35 @@+{-# OPTIONS --cubical-compatible --safe --no-universe-polymorphism+ --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Char where++open import Agda.Builtin.Nat+open import Agda.Builtin.Bool++postulate Char : Set+{-# BUILTIN CHAR Char #-}++primitive+ primIsLower primIsDigit primIsAlpha primIsSpace primIsAscii+ primIsLatin1 primIsPrint primIsHexDigit : Char → Bool+ primToUpper primToLower : Char → Char+ primCharToNat : Char → Nat+ primNatToChar : Nat → Char+ primCharEquality : Char → Char → Bool++{-# COMPILE JS primCharEquality = x => y => x === y #-}+{-# COMPILE JS primIsLower = x => /\p{Ll}/u.test(x) #-} -- Ll stands for Lowercase letters+{-# COMPILE JS primIsDigit = x => /\d/u.test(x) #-}+{-# COMPILE JS primIsAlpha = x => /\p{L}/u.test(x) #-} -- L stands for Letters+{-# COMPILE JS primIsSpace = x => /\p{space}/u.test(x) #-}+{-# COMPILE JS primIsAscii = x => x.codePointAt(0) < 128 #-}+{-# COMPILE JS primIsLatin1 = x => x.codePointAt(0) < 256 #-}+{-# COMPILE JS primIsPrint = x => !/[\p{Cc}\p{Cf}]/u.test(x) #-}+{-# COMPILE JS primIsHexDigit = x => /\p{AHex}/u.test(x) #-} -- AHex stands for ASCII Hexadecimal digits+{-# COMPILE JS primToUpper = x => x.toUpperCase() #-}+{-# COMPILE JS primToLower = x => x.toLowerCase() #-}+{-# COMPILE JS primCharToNat = x => BigInt(x.codePointAt(0)) #-}+{-# COMPILE JS primNatToChar = function(x) {+ const y = x % 0x110000n;+ return 0xD800n <= y && y <= 0xDFFFn ? '�' : String.fromCodePoint(Number(y));+} #-}
@@ -0,0 +1,10 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Char.Properties where++open import Agda.Builtin.Char+open import Agda.Builtin.Equality++primitive++ primCharToNatInjective : ∀ a b → primCharToNat a ≡ primCharToNat b → a ≡ b
@@ -0,0 +1,15 @@+{-# OPTIONS --cubical-compatible --safe --universe-polymorphism --no-sized-types+ --guardedness --level-universe #-}++module Agda.Builtin.Coinduction where++infix 1000 ♯_++postulate+ ∞ : ∀ {a} (A : Set a) → Set a+ ♯_ : ∀ {a} {A : Set a} → A → ∞ A+ ♭ : ∀ {a} {A : Set a} → ∞ A → A++{-# BUILTIN INFINITY ∞ #-}+{-# BUILTIN SHARP ♯_ #-}+{-# BUILTIN FLAT ♭ #-}
@@ -0,0 +1,113 @@+{-# OPTIONS --cubical=no-glue --safe --no-sized-types --no-guardedness --no-irrelevance #-}++module Agda.Builtin.Cubical.Equiv where++open import Agda.Primitive+open import Agda.Builtin.Sigma+open import Agda.Primitive.Cubical+ renaming ( primINeg to infix 30 ~_ -- I → I+ ; primIMin to infixr 20 _∧_ -- I → I → I+ ; primIMax to infixr 20 _∨_ -- I → I → I+ ; primHComp to hcomp+ ; primTransp to transp+ ; primComp to comp+ ; itIsOne to 1=1+ )+open import Agda.Builtin.Cubical.Path+open import Agda.Builtin.Cubical.Sub renaming (Sub to _[_↦_])+import Agda.Builtin.Cubical.HCompU as HCompU++module Helpers = HCompU.Helpers++open Helpers+++-- We make this a record so that isEquiv can be proved using+-- copatterns. This is good because copatterns don't get unfolded+-- unless a projection is applied so it should be more efficient.+record isEquiv {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} (f : A → B) : Set (ℓ ⊔ ℓ') where+ no-eta-equality+ field+ equiv-proof : (y : B) → isContr (fiber f y)++open isEquiv public++infix 4 _≃_++_≃_ : ∀ {ℓ ℓ'} (A : Set ℓ) (B : Set ℓ') → Set (ℓ ⊔ ℓ')+A ≃ B = Σ (A → B) \ f → (isEquiv f)++equivFun : ∀ {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} → A ≃ B → A → B+equivFun e = fst e++-- Improved version of equivProof compared to Lemma 5 in CCHM. We put+-- the (φ = i0) face in contr' making it be definitionally c in this+-- case. This makes the computational behavior better, in particular+-- for transp in Glue.+equivProof : ∀ {la lt} (T : Set la) (A : Set lt) → (w : T ≃ A) → (a : A)+ → ∀ ψ (f : Partial ψ (fiber (w .fst) a)) → fiber (w .fst) a [ ψ ↦ f ]+equivProof A B w a ψ fb =+ inS (contr' {A = fiber (w .fst) a} (w .snd .equiv-proof a) ψ fb)+ where+ contr' : ∀ {ℓ} {A : Set ℓ} → isContr A → (φ : I) → (u : Partial φ A) → A+ contr' {A = A} (c , p) φ u = hcomp (λ i → λ { (φ = i1) → p (u 1=1) i+ ; (φ = i0) → c }) c+++{-# BUILTIN EQUIV _≃_ #-}+{-# BUILTIN EQUIVFUN equivFun #-}+{-# BUILTIN EQUIVPROOF equivProof #-}++module _ {ℓ : I → Level} (P : (i : I) → Set (ℓ i)) where+ private+ E : (i : I) → Set (ℓ i)+ E = λ i → P i+ ~E : (i : I) → Set (ℓ (~ i))+ ~E = λ i → P (~ i)++ A = P i0+ B = P i1++ f : A → B+ f x = transp E i0 x++ g : B → A+ g y = transp ~E i0 y++ u : ∀ i → A → E i+ u i x = transp (λ j → E (i ∧ j)) (~ i) x++ v : ∀ i → B → E i+ v i y = transp (λ j → ~E ( ~ i ∧ j)) i y++ fiberPath : (y : B) → (xβ0 xβ1 : fiber f y) → xβ0 ≡ xβ1+ fiberPath y (x0 , β0) (x1 , β1) k = ω , λ j → δ (~ j) where+ module _ (j : I) where+ private+ sys : A → ∀ i → PartialP (~ j ∨ j) (λ _ → E (~ i))+ sys x i (j = i0) = v (~ i) y+ sys x i (j = i1) = u (~ i) x+ ω0 = comp ~E (sys x0) ((β0 (~ j)))+ ω1 = comp ~E (sys x1) ((β1 (~ j)))+ θ0 = fill ~E (sys x0) (inS (β0 (~ j)))+ θ1 = fill ~E (sys x1) (inS (β1 (~ j)))+ sys = λ {j (k = i0) → ω0 j ; j (k = i1) → ω1 j}+ ω = hcomp sys (g y)+ θ = hfill sys (inS (g y))+ δ = λ (j : I) → comp E+ (λ i → λ { (j = i0) → v i y ; (k = i0) → θ0 j (~ i)+ ; (j = i1) → u i ω ; (k = i1) → θ1 j (~ i) })+ (θ j)++ γ : (y : B) → y ≡ f (g y)+ γ y j = comp E (λ i → λ { (j = i0) → v i y+ ; (j = i1) → u i (g y) }) (g y)++ pathToisEquiv : isEquiv f+ pathToisEquiv .equiv-proof y .fst .fst = g y+ pathToisEquiv .equiv-proof y .fst .snd = sym (γ y)+ pathToisEquiv .equiv-proof y .snd = fiberPath y _++ pathToEquiv : A ≃ B+ pathToEquiv .fst = f+ pathToEquiv .snd = pathToisEquiv
@@ -0,0 +1,18 @@+{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness --no-irrelevance #-}++module Agda.Builtin.Cubical.Glue where++open import Agda.Primitive+open import Agda.Primitive.Cubical+open import Agda.Builtin.Cubical.Equiv public++primitive+ primGlue : ∀ {ℓ ℓ'} (A : Set ℓ) {φ : I}+ → (T : Partial φ (Set ℓ')) → (e : PartialP φ (λ o → T o ≃ A))+ → Set ℓ'+ prim^glue : ∀ {ℓ ℓ'} {A : Set ℓ} {φ : I}+ → {T : Partial φ (Set ℓ')} → {e : PartialP φ (λ o → T o ≃ A)}+ → (t : PartialP φ T) → (a : A) → primGlue A T e+ prim^unglue : ∀ {ℓ ℓ'} {A : Set ℓ} {φ : I}+ → {T : Partial φ (Set ℓ')} → {e : PartialP φ (λ o → T o ≃ A)}+ → primGlue A T e → A
@@ -0,0 +1,84 @@+{-# OPTIONS --cubical=no-glue --safe --no-sized-types --no-guardedness --no-irrelevance #-}++module Agda.Builtin.Cubical.HCompU where++open import Agda.Primitive+open import Agda.Builtin.Sigma+open import Agda.Primitive.Cubical+ renaming ( primINeg to infix 30 ~_ -- I → I+ ; primIMin to infixr 20 _∧_ -- I → I → I+ ; primIMax to infixr 20 _∨_ -- I → I → I+ ; primHComp to hcomp+ ; primTransp to transp+ ; primComp to comp+ ; itIsOne to 1=1+ )+open import Agda.Builtin.Cubical.Path+open import Agda.Builtin.Cubical.Sub renaming (Sub to _[_↦_]; primSubOut to outS)++module Helpers where+ -- Homogeneous filling+ hfill : ∀ {ℓ} {A : Set ℓ} {φ : I}+ (u : ∀ i → Partial φ A)+ (u0 : A [ φ ↦ u i0 ]) (i : I) → A+ hfill {φ = φ} u u0 i =+ hcomp (λ j → \ { (φ = i1) → u (i ∧ j) 1=1+ ; (i = i0) → outS u0 })+ (outS u0)++ -- Heterogeneous filling defined using comp+ fill : ∀ {ℓ : I → Level} (A : ∀ i → Set (ℓ i)) {φ : I}+ (u : ∀ i → Partial φ (A i))+ (u0 : A i0 [ φ ↦ u i0 ]) →+ ∀ i → A i+ fill A {φ = φ} u u0 i =+ comp (λ j → A (i ∧ j))+ (λ j → \ { (φ = i1) → u (i ∧ j) 1=1+ ; (i = i0) → outS u0 })+ (outS {φ = φ} u0)++ module _ {ℓ} {A : Set ℓ} where+ refl : {x : A} → x ≡ x+ refl {x = x} = λ _ → x++ sym : {x y : A} → x ≡ y → y ≡ x+ sym p = λ i → p (~ i)++ cong : ∀ {ℓ'} {B : A → Set ℓ'} {x y : A}+ (f : (a : A) → B a) (p : x ≡ y)+ → PathP (λ i → B (p i)) (f x) (f y)+ cong f p = λ i → f (p i)++ isContr : ∀ {ℓ} → Set ℓ → Set ℓ+ isContr A = Σ A \ x → (∀ y → x ≡ y)++ fiber : ∀ {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} (f : A → B) (y : B) → Set (ℓ ⊔ ℓ')+ fiber {A = A} f y = Σ A \ x → f x ≡ y++open Helpers+++primitive+ prim^glueU : {la : Level} {φ : I} {T : I → Partial φ (Set la)}+ {A : Set la [ φ ↦ T i0 ]} →+ PartialP φ (T i1) → outS A → hcomp T (outS A)+ prim^unglueU : {la : Level} {φ : I} {T : I → Partial φ (Set la)}+ {A : Set la [ φ ↦ T i0 ]} →+ hcomp T (outS A) → outS A+ -- Needed for transp.+ primFaceForall : (I → I) → I++transpProof : ∀ {l} → (e : I → Set l) → (φ : I) → (a : Partial φ (e i0)) → (b : e i1 [ φ ↦ (\ o → transp (\ i → e i) i0 (a o)) ] ) → fiber (transp (\ i → e i) i0) (outS b)+transpProof e φ a b = f , \ j → comp (\ i → e i) (\ i →+ \ { (φ = i1) → transp (\ j → e (j ∧ i)) (~ i) (a 1=1)+ ; (j = i0) → transp (\ j → e (j ∧ i)) (~ i) f+ ; (j = i1) → g (~ i) })+ f+ where+ b' = outS {u = (\ o → transp (\ i → e i) i0 (a o))} b+ g : (k : I) → e (~ k)+ g k = fill (\ i → e (~ i)) (\ i → \ { (φ = i1) → transp (\ j → e (j ∧ ~ i)) i (a 1=1)+ ; (φ = i0) → transp (\ j → e (~ j ∨ ~ i)) (~ i) b' }) (inS b') k+ f = comp (\ i → e (~ i)) (\ i → \ { (φ = i1) → transp (\ j → e (j ∧ ~ i)) i (a 1=1); (φ = i0) → transp (\ j → e (~ j ∨ ~ i)) (~ i) b' }) b'++{-# BUILTIN TRANSPPROOF transpProof #-}
@@ -0,0 +1,15 @@+{-# OPTIONS --cubical=no-glue --safe --no-sized-types --no-guardedness --no-irrelevance #-}++module Agda.Builtin.Cubical.Path where++ open import Agda.Primitive.Cubical using (PathP) public+++ infix 4 _≡_++ -- We have a variable name in `(λ i → A)` as a hint for case+ -- splitting.+ _≡_ : ∀ {ℓ} {A : Set ℓ} → A → A → Set ℓ+ _≡_ {A = A} = PathP (λ i → A)++ {-# BUILTIN PATH _≡_ #-}
@@ -0,0 +1,18 @@+{-# OPTIONS --cubical=no-glue --safe --no-sized-types --no-guardedness --no-irrelevance #-}++module Agda.Builtin.Cubical.Sub where++ open import Agda.Primitive.Cubical++ {-# BUILTIN SUB Sub #-}++ postulate+ inS : ∀ {ℓ} {A : Set ℓ} {φ} (x : A) → Sub A φ (λ _ → x)++ {-# BUILTIN SUBIN inS #-}++ -- Sub A φ u is treated as A.+ {-# COMPILE JS inS = _ => _ => _ => x => x #-}++ primitive+ primSubOut : ∀ {ℓ} {A : Set ℓ} {φ : I} {u : Partial φ A} → Sub _ φ u → A
@@ -0,0 +1,9 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Equality where++infix 4 _≡_+data _≡_ {a} {A : Set a} (x : A) : A → Set a where+ instance refl : x ≡ x++{-# BUILTIN EQUALITY _≡_ #-}
@@ -0,0 +1,7 @@+{-# OPTIONS --with-K --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Equality.Erase where++open import Agda.Builtin.Equality++primitive primEraseEquality : ∀ {a} {A : Set a} {x y : A} → x ≡ y → x ≡ y
@@ -0,0 +1,9 @@+{-# OPTIONS --cubical-compatible --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Equality.Rewrite where++open import Agda.Builtin.Equality++{-# BUILTIN REWRITE _≡_ #-}++primitive primRewriteNoMatch : ∀ {a} {A : Set a} → A → A
@@ -0,0 +1,33 @@+------------------------------------------------------------------------+-- The function []-cong+------------------------------------------------------------------------++{-# OPTIONS --cubical-compatible --safe --no-sized-types+ --no-guardedness --level-universe+ --erased-matches=restricted #-}++-- The flag --erased-matches=restricted turns on all kinds of erased+-- matches for indexed data types, but only in certain builtin+-- modules. The code below must only give access to []-cong, no other+-- forms of erased matches.++module Agda.Builtin.Erased.Box-cong where++open import Agda.Builtin.Equality+open import Agda.Builtin.Erased.Erased+open import Agda.Primitive++private variable+ a : Level+ @0 A : Set a+ @0 x y : A++-- Given an erased proof of equality of x and y one can show that+-- [ x ] is equal to [ y ].+--+-- Note that this function cannot at the time of writing be+-- implemented in regular Agda code (unless+-- --erased-matches=unrestricted is turned on).++[]-cong : @0 x ≡ y → [ x ] ≡ [ y ]+[]-cong refl = refl
@@ -0,0 +1,32 @@+------------------------------------------------------------------------+-- The type Erased+------------------------------------------------------------------------++{-# OPTIONS --cubical-compatible --safe --no-sized-types+ --no-guardedness --level-universe+ --erasure --erased-matches=none #-}++module Agda.Builtin.Erased.Erased where++open import Agda.Builtin.Equality+open import Agda.Primitive++private variable+ a : Level++-- The type Erased, which is a type-level variant of @0.+--+-- This type is defined as a record type *without* η-equality, in+-- anticipation of a possible future addition of linear types to Agda.+-- If η-equality is enabled, then the η-expansion of the linear+-- identity function λ x → x at type Erased A → Erased A is+-- λ x → [ erased x ], which is arguably not linear.++record Erased (@0 A : Set a) : Set a where+ no-eta-equality+ pattern+ constructor [_]+ field+ @0 erased : A++open Erased public
@@ -0,0 +1,25 @@+------------------------------------------------------------------------+-- Postulated, erased function extensionality+------------------------------------------------------------------------++{-# OPTIONS --cubical-compatible --safe --no-sized-types+ --no-guardedness --level-universe --erased-funext+ --erased-matches=none #-}++module Agda.Builtin.Erased.Funext where++open import Agda.Builtin.Equality++private variable+ A : Set _+ P : A → Set _+ f g : (x : A) → P x++-- Function extensionality.+--+-- This statement is not of the form "certain functions are+-- equivalences", but it is logically equivalent to such a statement,+-- and it does not depend on a definition of equivalence.++postulate+ @0 funext : (∀ x → f x ≡ g x) → f ≡ g
@@ -0,0 +1,28 @@+------------------------------------------------------------------------+-- Postulated, erased propositional extensionality+------------------------------------------------------------------------++{-# OPTIONS --cubical-compatible --safe --no-sized-types+ --no-guardedness --level-universe --erased-propext+ --erased-matches=none #-}++module Agda.Builtin.Erased.Propext where++open import Agda.Builtin.Equality+open import Agda.Primitive++private variable+ a : Level+ A B : Set _++-- The property of being a proposition.++Is-proposition : Set a → Set a+Is-proposition A = (x y : A) → x ≡ y++-- Propositional extensionality.++postulate+ @0 propext :+ Is-proposition A → Is-proposition B →+ (A → B) → (B → A) → A ≡ B
@@ -0,0 +1,78 @@+------------------------------------------------------------------------+-- Set quotients with erased higher constructors and an eliminator+-- that computes for the point constructor+------------------------------------------------------------------------++-- The interface is based on the presentations of quotients in Martin+-- Hofmann's PhD thesis and the HoTT book, as well as the set quotient+-- HIT in the cubical library, due to Zesen Qian and Anders Mörtberg.++{-# OPTIONS --cubical-compatible --safe --no-sized-types+ --no-guardedness --level-universe --erased-quotients+ --erased-matches=none #-}++module Agda.Builtin.Erased.Quotient where++open import Agda.Builtin.Equality+open import Agda.Primitive++private variable+ a p r : Level+ A : Set _+ @0 R : A → A → Set _+ x y : A++-- The property of being a set.++Is-set : Set a → Set a+Is-set A = {x y : A} (p q : x ≡ y) → p ≡ q++-- The subst function.++subst : (P : A → Set p) → x ≡ y → P x → P y+subst _ refl p = p++infix 4 _/_++postulate++ -- Set quotients.++ _/_ : (A : Set a) (@0 R : A → A → Set r) → Set (a ⊔ r)++ -- The point constructor.+ --+ -- If the type of [_] is changed, then+ -- Agda.TypeChecking.Primitive.primQrec might need to be modified.++ [_] : {a r : Level} {A : Set a} {@0 R : A → A → Set r} → A → A / R++ -- [_] respects the quotient relation.++ @0 resp : R x y → _≡_ {A = A / R} [ x ] [ y ]++ -- The quotients are set-truncated.++ @0 set : Is-set (A / R)++{-# BUILTIN QUOTIENTCONSTRUCTOR [_] #-}+{-# FOREIGN GHC type Quotient a r a' r' = a' #-}+{-# COMPILE GHC _/_ = type Quotient #-}+{-# COMPILE GHC [_] = \_ _ _ _ x -> x #-}+{-# COMPILE JS [_] = _ => _ => _ => _ => x => x #-}++primitive++ -- An eliminator for _/_.+ --+ -- If the type of qrec is changed, then+ -- Agda.TypeChecking.Primitive.primQrec and compiler backend code+ -- might need to be modified.++ qrec :+ {a r p : Level} {A : Set a} {@0 R : A → A → Set r}+ (P : A / R → Set p)+ (f : ∀ x → P [ x ]) →+ @0 (∀ {x y} (r : R x y) → subst P (resp r) (f x) ≡ f y) →+ @0 (∀ x → Is-set (P x)) →+ (x : A / R) → P x
@@ -0,0 +1,209 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Float where++open import Agda.Builtin.Bool+open import Agda.Builtin.Int+open import Agda.Builtin.Maybe+open import Agda.Builtin.Nat+open import Agda.Builtin.Sigma+open import Agda.Builtin.String+open import Agda.Builtin.Word++postulate Float : Set+{-# BUILTIN FLOAT Float #-}++primitive+ -- Relations+ primFloatInequality : Float → Float → Bool+ primFloatEquality : Float → Float → Bool+ primFloatLess : Float → Float → Bool+ primFloatIsInfinite : Float → Bool+ primFloatIsNaN : Float → Bool+ primFloatIsNegativeZero : Float → Bool+ primFloatIsSafeInteger : Float → Bool+ -- Conversions+ primFloatToWord64 : Float → Maybe Word64+ primNatToFloat : Nat → Float+ primIntToFloat : Int → Float+ primFloatRound : Float → Maybe Int+ primFloatFloor : Float → Maybe Int+ primFloatCeiling : Float → Maybe Int+ primFloatToRatio : Float → (Σ Int λ _ → Int)+ primRatioToFloat : Int → Int → Float+ primFloatDecode : Float → Maybe (Σ Int λ _ → Int)+ primFloatEncode : Int → Int → Maybe Float+ primShowFloat : Float → String+ -- Operations+ primFloatPlus : Float → Float → Float+ primFloatMinus : Float → Float → Float+ primFloatTimes : Float → Float → Float+ primFloatDiv : Float → Float → Float+ primFloatPow : Float → Float → Float+ primFloatNegate : Float → Float+ primFloatSqrt : Float → Float+ primFloatExp : Float → Float+ primFloatLog : Float → Float+ primFloatSin : Float → Float+ primFloatCos : Float → Float+ primFloatTan : Float → Float+ primFloatASin : Float → Float+ primFloatACos : Float → Float+ primFloatATan : Float → Float+ primFloatATan2 : Float → Float → Float+ primFloatSinh : Float → Float+ primFloatCosh : Float → Float+ primFloatTanh : Float → Float+ primFloatASinh : Float → Float+ primFloatACosh : Float → Float+ primFloatATanh : Float → Float++{-# COMPILE JS+ primFloatRound = function(x) {+ x = agdaRTS._primFloatRound(x);+ if (x === null) {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["nothing"];+ }+ else {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["just"](x);+ }+ };+#-}+{-# COMPILE JS+ primFloatFloor = function(x) {+ x = agdaRTS._primFloatFloor(x);+ if (x === null) {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["nothing"];+ }+ else {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["just"](x);+ }+ };+#-}+{-# COMPILE JS+ primFloatCeiling = function(x) {+ x = agdaRTS._primFloatCeiling(x);+ if (x === null) {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["nothing"];+ }+ else {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["just"](x);+ }+ };+#-}+{-# COMPILE JS+ primFloatToRatio = function(x) {+ x = agdaRTS._primFloatToRatio(x);+ return z_jAgda_Agda_Builtin_Sigma["_,_"](x.numerator)(x.denominator);+ };+#-}+{-# COMPILE JS+ primFloatDecode = function(x) {+ x = agdaRTS._primFloatDecode(x);+ if (x === null) {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["nothing"];+ }+ else {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["just"](+ z_jAgda_Agda_Builtin_Sigma["_,_"](x.mantissa)(x.exponent));+ }+ };+#-}+{-# COMPILE JS+ primFloatEncode = function(x) {+ return function (y) {+ x = agdaRTS.uprimFloatEncode(x, y);+ if (x === null) {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["nothing"];+ }+ else {+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["just"](x);+ }+ }+ };+#-}++primFloatNumericalEquality = primFloatEquality+{-# WARNING_ON_USAGE primFloatNumericalEquality+"Warning: primFloatNumericalEquality was deprecated in Agda v2.6.2.+Please use primFloatEquality instead."+#-}++primFloatNumericalLess = primFloatLess+{-# WARNING_ON_USAGE primFloatNumericalLess+"Warning: primFloatNumericalLess was deprecated in Agda v2.6.2.+Please use primFloatLess instead."+#-}++primRound = primFloatRound+{-# WARNING_ON_USAGE primRound+"Warning: primRound was deprecated in Agda v2.6.2.+Please use primFloatRound instead."+#-}++primFloor = primFloatFloor+{-# WARNING_ON_USAGE primFloor+"Warning: primFloor was deprecated in Agda v2.6.2.+Please use primFloatFloor instead."+#-}++primCeiling = primFloatCeiling+{-# WARNING_ON_USAGE primCeiling+"Warning: primCeiling was deprecated in Agda v2.6.2.+Please use primFloatCeiling instead."+#-}++primExp = primFloatExp+{-# WARNING_ON_USAGE primExp+"Warning: primExp was deprecated in Agda v2.6.2.+Please use primFloatExp instead."+#-}++primLog = primFloatLog+{-# WARNING_ON_USAGE primLog+"Warning: primLog was deprecated in Agda v2.6.2.+Please use primFloatLog instead."+#-}++primSin = primFloatSin+{-# WARNING_ON_USAGE primSin+"Warning: primSin was deprecated in Agda v2.6.2.+Please use primFloatSin instead."+#-}++primCos = primFloatCos+{-# WARNING_ON_USAGE primCos+"Warning: primCos was deprecated in Agda v2.6.2.+Please use primFloatCos instead."+#-}++primTan = primFloatTan+{-# WARNING_ON_USAGE primTan+"Warning: primTan was deprecated in Agda v2.6.2.+Please use primFloatTan instead."+#-}++primASin = primFloatASin+{-# WARNING_ON_USAGE primASin+"Warning: primASin was deprecated in Agda v2.6.2.+Please use primFloatASin instead."+#-}+++primACos = primFloatACos+{-# WARNING_ON_USAGE primACos+"Warning: primACos was deprecated in Agda v2.6.2.+Please use primFloatACos instead."+#-}++primATan = primFloatATan+{-# WARNING_ON_USAGE primATan+"Warning: primATan was deprecated in Agda v2.6.2.+Please use primFloatATan instead."+#-}++primATan2 = primFloatATan2+{-# WARNING_ON_USAGE primATan2+"Warning: primATan2 was deprecated in Agda v2.6.2.+Please use primFloatATan2 instead."+#-}
@@ -0,0 +1,10 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Float.Properties where++open import Agda.Builtin.Float+open import Agda.Builtin.Equality++primitive++ primFloatToWord64Injective : ∀ a b → primFloatToWord64 a ≡ primFloatToWord64 b → a ≡ b
@@ -0,0 +1,16 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.FromNat where++open import Agda.Primitive+open import Agda.Builtin.Nat++record Number {a} (A : Set a) : Set (lsuc a) where+ field+ Constraint : Nat → Set a+ fromNat : ∀ n → {{_ : Constraint n}} → A++open Number {{...}} public using (fromNat)++{-# BUILTIN FROMNAT fromNat #-}+{-# DISPLAY Number.fromNat _ n = fromNat n #-}
@@ -0,0 +1,16 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.FromNeg where++open import Agda.Primitive+open import Agda.Builtin.Nat++record Negative {a} (A : Set a) : Set (lsuc a) where+ field+ Constraint : Nat → Set a+ fromNeg : ∀ n → {{_ : Constraint n}} → A++open Negative {{...}} public using (fromNeg)++{-# BUILTIN FROMNEG fromNeg #-}+{-# DISPLAY Negative.fromNeg _ n = fromNeg n #-}
@@ -0,0 +1,16 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.FromString where++open import Agda.Primitive+open import Agda.Builtin.String++record IsString {a} (A : Set a) : Set (lsuc a) where+ field+ Constraint : String → Set a+ fromString : (s : String) {{_ : Constraint s}} → A++open IsString {{...}} public using (fromString)++{-# BUILTIN FROMSTRING fromString #-}+{-# DISPLAY IsString.fromString _ s = fromString s #-}
@@ -0,0 +1,10 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.IO where++postulate IO : ∀ {a} → Set a → Set a+{-# POLARITY IO ++ ++ #-}+{-# BUILTIN IO IO #-}++{-# FOREIGN GHC type AgdaIO a b = IO b #-}+{-# COMPILE GHC IO = type AgdaIO #-}
@@ -0,0 +1,16 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Int where++open import Agda.Builtin.Nat+open import Agda.Builtin.String++data Int : Set where+ pos : (n : Nat) → Int+ negsuc : (n : Nat) → Int++{-# BUILTIN INTEGER Int #-}+{-# BUILTIN INTEGERPOS pos #-}+{-# BUILTIN INTEGERNEGSUC negsuc #-}++primitive primShowInteger : Int → String
@@ -0,0 +1,16 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.List where++infixr 5 _∷_+data List {a} (A : Set a) : Set a where+ [] : List A+ _∷_ : (x : A) (xs : List A) → List A++{-# BUILTIN LIST List #-}++{-# COMPILE JS List = function(x,v) {+ if (x.length < 1) { return v["[]"](); } else { return v["_∷_"](x[0], x.slice(1)); }+} #-}+{-# COMPILE JS [] = Array() #-}+{-# COMPILE JS _∷_ = function (x) { return function(y) { return [x].concat(y); }; } #-}
@@ -0,0 +1,9 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Maybe where++data Maybe {a} (A : Set a) : Set a where+ just : A → Maybe A+ nothing : Maybe A++{-# BUILTIN MAYBE Maybe #-}
@@ -0,0 +1,173 @@+{-# OPTIONS --cubical-compatible --safe --no-universe-polymorphism+ --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Nat where++open import Agda.Builtin.Bool++data Nat : Set where+ zero : Nat+ suc : (n : Nat) → Nat++{-# BUILTIN NATURAL Nat #-}++infix 4 _==_ _<_+infixl 6 _+_ _-_+infixl 7 _*_++_+_ : Nat → Nat → Nat+zero + m = m+suc n + m = suc (n + m)++{-# BUILTIN NATPLUS _+_ #-}++_-_ : Nat → Nat → Nat+n - zero = n+zero - suc m = zero+suc n - suc m = n - m++{-# BUILTIN NATMINUS _-_ #-}++_*_ : Nat → Nat → Nat+zero * m = zero+suc n * m = m + n * m++{-# BUILTIN NATTIMES _*_ #-}++_==_ : Nat → Nat → Bool+zero == zero = true+suc n == suc m = n == m+_ == _ = false++{-# BUILTIN NATEQUALS _==_ #-}++_<_ : Nat → Nat → Bool+_ < zero = false+zero < suc _ = true+suc n < suc m = n < m++{-# BUILTIN NATLESS _<_ #-}++-- Helper function div-helper for Euclidean division.+---------------------------------------------------------------------------+--+-- div-helper computes n / 1+m via iteration on n.+--+-- n div (suc m) = div-helper 0 m n m+--+-- The state of the iterator has two accumulator variables:+--+-- k: The quotient, returned once n=0. Initialized to 0.+--+-- j: A counter, initialized to the divisor m, decreased on each iteration step.+-- Once it reaches 0, the quotient k is increased and j reset to m,+-- starting the next countdown.+--+-- Under the precondition j ≤ m, the invariant is+--+-- div-helper k m n j = k + (n + m - j) div (1 + m)++div-helper : (k m n j : Nat) → Nat+div-helper k m zero j = k+div-helper k m (suc n) zero = div-helper (suc k) m n m+div-helper k m (suc n) (suc j) = div-helper k m n j++{-# BUILTIN NATDIVSUCAUX div-helper #-}++-- Proof of the invariant by induction on n.+--+-- clause 1: div-helper k m 0 j+-- = k by definition+-- = k + (0 + m - j) div (1 + m) since m - j < 1 + m+--+-- clause 2: div-helper k m (1 + n) 0+-- = div-helper (1 + k) m n m by definition+-- = 1 + k + (n + m - m) div (1 + m) by induction hypothesis+-- = 1 + k + n div (1 + m) by simplification+-- = k + (n + (1 + m)) div (1 + m) by expansion+-- = k + (1 + n + m - 0) div (1 + m) by expansion+--+-- clause 3: div-helper k m (1 + n) (1 + j)+-- = div-helper k m n j by definition+-- = k + (n + m - j) div (1 + m) by induction hypothesis+-- = k + ((1 + n) + m - (1 + j)) div (1 + m) by expansion+--+-- Q.e.d.++-- If we don't give a definition for div-helper in JS, the JS backend will+-- generate a recursive function, which can exhaust the heap memory.+-- So we provide a direct definition for the JS backend.+--+-- If the precondition j ≤ m is not met, the formula above is still valid,+-- as m - j < 1 + m and other steps do not depend on the precondition.+-- And the only point to notice is that n + m may be greater than j,+-- in which case n + m - j is 0 in Agda's Nat, but can be negative in JS's BigInt.+-- Thus n + m - j should be changed to something like max (n + m - j) 0,+-- so that the JS backend produces equivalent codes.+{-# COMPILE JS div-helper = k => m => n => j => k + (n + m - j >= 0n ? n + m - j : 0n) / (1n + m) #-}++-- Helper function mod-helper for the remainder computation.+---------------------------------------------------------------------------+--+-- (Analogous to div-helper.)+--+-- mod-helper computes n % 1+m via iteration on n.+--+-- n mod (suc m) = mod-helper 0 m n m+--+-- The invariant is:+--+-- m = k + j ==> mod-helper k m n j = (n + k) mod (1 + m).++mod-helper : (k m n j : Nat) → Nat+mod-helper k m zero j = k+mod-helper k m (suc n) zero = mod-helper 0 m n m+mod-helper k m (suc n) (suc j) = mod-helper (suc k) m n j++{-# BUILTIN NATMODSUCAUX mod-helper #-}++-- Proof of the invariant by induction on n.+--+-- clause 1: mod-helper k m 0 j+-- = k by definition+-- = (0 + k) mod (1 + m) since m = k + j, thus k < m+--+-- clause 2: mod-helper k m (1 + n) 0+-- = mod-helper 0 m n m by definition+-- = (n + 0) mod (1 + m) by induction hypothesis+-- = (n + (1 + m)) mod (1 + m) by expansion+-- = ((1 + n) + k) mod (1 + m) since k = m (as l = 0)+--+-- clause 3: mod-helper k m (1 + n) (1 + j)+-- = mod-helper (1 + k) m n j by definition+-- = (n + (1 + k)) mod (1 + m) by induction hypothesis+-- = ((1 + n) + k) mod (1 + m) by commutativity+--+-- Q.e.d.++-- Unfortunately, when the invariant m = k + j is not met, the formula above+-- is not valid, and we need a different formula for the JS backend,+-- so that the JS backend produces fully equivalent codes.+--+-- If j ≥ n, then the recursion will eventually run into clause 1, and we have+--+-- mod-helper k m n j+-- = mod-helper (k + n) m 0 (j - n) by applying definition (case 1) n times+-- = k + n by definition (case 3)+--+-- otherwise, the recursion will eventually run into clause 2, which will+-- make the invariant valid again, and we have+--+-- mod-helper k m n j+-- = mod-helper (k + j) m (n - j) 0 by applying definition (case 3) j times+-- = mod-helper 0 m (n - j - 1) m by definition (case 2)+-- = (n - j - 1 + 0) mod (1 + m) by previous proof+-- = (n - j - 1) mod (1 + m) by simplification+--+{-# COMPILE JS mod-helper = k => m => n => j => m ==+ k + j ?+ (n + k) % (1n + m) :+ (j >= n) ?+ k + n :+ (n - j - 1n) % (1n + m)+#-}
@@ -0,0 +1,486 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Reflection where++open import Agda.Builtin.Unit+open import Agda.Builtin.Bool+open import Agda.Builtin.Nat+open import Agda.Builtin.Word+open import Agda.Builtin.List+open import Agda.Builtin.String+open import Agda.Builtin.Char+open import Agda.Builtin.Float+open import Agda.Builtin.Int+open import Agda.Builtin.Sigma+open import Agda.Primitive++-- Names --++postulate Name : Set+{-# BUILTIN QNAME Name #-}++primitive+ primQNameEquality : Name → Name → Bool+ primQNameLess : Name → Name → Bool+ primShowQName : Name → String++-- Fixity --++data Associativity : Set where+ left-assoc : Associativity+ right-assoc : Associativity+ non-assoc : Associativity++data Precedence : Set where+ related : Float → Precedence+ unrelated : Precedence++data Fixity : Set where+ fixity : Associativity → Precedence → Fixity++{-# BUILTIN ASSOC Associativity #-}+{-# BUILTIN ASSOCLEFT left-assoc #-}+{-# BUILTIN ASSOCRIGHT right-assoc #-}+{-# BUILTIN ASSOCNON non-assoc #-}++{-# BUILTIN PRECEDENCE Precedence #-}+{-# BUILTIN PRECRELATED related #-}+{-# BUILTIN PRECUNRELATED unrelated #-}++{-# BUILTIN FIXITY Fixity #-}+{-# BUILTIN FIXITYFIXITY fixity #-}++{-# COMPILE GHC Associativity = data MAlonzo.RTE.Assoc (MAlonzo.RTE.LeftAssoc | MAlonzo.RTE.RightAssoc | MAlonzo.RTE.NonAssoc) #-}+{-# COMPILE GHC Precedence = data MAlonzo.RTE.Precedence (MAlonzo.RTE.Related | MAlonzo.RTE.Unrelated) #-}+{-# COMPILE GHC Fixity = data MAlonzo.RTE.Fixity (MAlonzo.RTE.Fixity) #-}++{-# COMPILE JS Associativity = function (x,v) { return v[x](); } #-}+{-# COMPILE JS left-assoc = "left-assoc" #-}+{-# COMPILE JS right-assoc = "right-assoc" #-}+{-# COMPILE JS non-assoc = "non-assoc" #-}++{-# COMPILE JS Precedence =+ function (x,v) {+ if (x === "unrelated") { return v[x](); } else { return v["related"](x); }} #-}+{-# COMPILE JS related = function(x) { return x; } #-}+{-# COMPILE JS unrelated = "unrelated" #-}++{-# COMPILE JS Fixity = function (x,v) { return v["fixity"](x["assoc"], x["prec"]); } #-}+{-# COMPILE JS fixity = function (x) { return function (y) { return { "assoc": x, "prec": y}; }; } #-}++primitive+ primQNameFixity : Name → Fixity+ primQNameToWord64s : Name → Σ Word64 (λ _ → Word64)++-- Metavariables --++postulate Meta : Set+{-# BUILTIN AGDAMETA Meta #-}++primitive+ primMetaEquality : Meta → Meta → Bool+ primMetaLess : Meta → Meta → Bool+ primShowMeta : Meta → String+ primMetaToNat : Meta → Nat++-- Arguments --++-- Arguments can be (visible), {hidden}, or {{instance}}.+data Visibility : Set where+ visible hidden instance′ : Visibility++{-# BUILTIN HIDING Visibility #-}+{-# BUILTIN VISIBLE visible #-}+{-# BUILTIN HIDDEN hidden #-}+{-# BUILTIN INSTANCE instance′ #-}++-- Arguments can be relevant or irrelevant.+data Relevance : Set where+ relevant irrelevant : Relevance++{-# BUILTIN RELEVANCE Relevance #-}+{-# BUILTIN RELEVANT relevant #-}+{-# BUILTIN IRRELEVANT irrelevant #-}++-- Arguments also have a quantity.+data Quantity : Set where+ quantity-0 quantity-ω : Quantity++{-# BUILTIN QUANTITY Quantity #-}+{-# BUILTIN QUANTITY-0 quantity-0 #-}+{-# BUILTIN QUANTITY-ω quantity-ω #-}++-- Relevance and quantity are combined into a modality.+data Modality : Set where+ modality : (r : Relevance) (q : Quantity) → Modality++{-# BUILTIN MODALITY Modality #-}+{-# BUILTIN MODALITY-CONSTRUCTOR modality #-}++data ArgInfo : Set where+ arg-info : (v : Visibility) (m : Modality) → ArgInfo++data Arg {a} (A : Set a) : Set a where+ arg : (i : ArgInfo) (x : A) → Arg A++{-# BUILTIN ARGINFO ArgInfo #-}+{-# BUILTIN ARGARGINFO arg-info #-}+{-# BUILTIN ARG Arg #-}+{-# BUILTIN ARGARG arg #-}++data Blocker : Set where+ blockerAny : List Blocker → Blocker+ blockerAll : List Blocker → Blocker+ blockerMeta : Meta → Blocker++{-# BUILTIN AGDABLOCKER Blocker #-}+{-# BUILTIN AGDABLOCKERANY blockerAny #-}+{-# BUILTIN AGDABLOCKERALL blockerAll #-}+{-# BUILTIN AGDABLOCKERMETA blockerMeta #-}++-- Name abstraction --++data Abs {a} (A : Set a) : Set a where+ abs : (s : String) (x : A) → Abs A++{-# BUILTIN ABS Abs #-}+{-# BUILTIN ABSABS abs #-}++-- Literals --++data Literal : Set where+ nat : (n : Nat) → Literal+ word64 : (n : Word64) → Literal+ float : (x : Float) → Literal+ char : (c : Char) → Literal+ string : (s : String) → Literal+ name : (x : Name) → Literal+ meta : (x : Meta) → Literal++{-# BUILTIN AGDALITERAL Literal #-}+{-# BUILTIN AGDALITNAT nat #-}+{-# BUILTIN AGDALITWORD64 word64 #-}+{-# BUILTIN AGDALITFLOAT float #-}+{-# BUILTIN AGDALITCHAR char #-}+{-# BUILTIN AGDALITSTRING string #-}+{-# BUILTIN AGDALITQNAME name #-}+{-# BUILTIN AGDALITMETA meta #-}+++-- Terms and patterns --++data Term : Set+data Sort : Set+data Pattern : Set+data Clause : Set+Type = Term+Telescope = List (Σ String λ _ → Arg Type)++data Term where+ var : (x : Nat) (args : List (Arg Term)) → Term+ con : (c : Name) (args : List (Arg Term)) → Term+ def : (f : Name) (args : List (Arg Term)) → Term+ lam : (v : Visibility) (t : Abs Term) → Term+ pat-lam : (cs : List Clause) (args : List (Arg Term)) → Term+ pi : (a : Arg Type) (b : Abs Type) → Term+ agda-sort : (s : Sort) → Term+ lit : (l : Literal) → Term+ meta : (x : Meta) → List (Arg Term) → Term+ unknown : Term++data Sort where+ set : (t : Term) → Sort+ lit : (n : Nat) → Sort+ prop : (t : Term) → Sort+ propLit : (n : Nat) → Sort+ inf : (n : Nat) → Sort+ unknown : Sort++data Pattern where+ con : (c : Name) (ps : List (Arg Pattern)) → Pattern+ dot : (t : Term) → Pattern+ var : (x : Nat) → Pattern+ lit : (l : Literal) → Pattern+ proj : (f : Name) → Pattern+ absurd : (x : Nat) → Pattern -- absurd patterns counts as variables++data Clause where+ clause : (tel : Telescope) (ps : List (Arg Pattern)) (t : Term) → Clause+ absurd-clause : (tel : Telescope) (ps : List (Arg Pattern)) → Clause++{-# BUILTIN AGDATERM Term #-}+{-# BUILTIN AGDASORT Sort #-}+{-# BUILTIN AGDAPATTERN Pattern #-}+{-# BUILTIN AGDACLAUSE Clause #-}++{-# BUILTIN AGDATERMVAR var #-}+{-# BUILTIN AGDATERMCON con #-}+{-# BUILTIN AGDATERMDEF def #-}+{-# BUILTIN AGDATERMMETA meta #-}+{-# BUILTIN AGDATERMLAM lam #-}+{-# BUILTIN AGDATERMEXTLAM pat-lam #-}+{-# BUILTIN AGDATERMPI pi #-}+{-# BUILTIN AGDATERMSORT agda-sort #-}+{-# BUILTIN AGDATERMLIT lit #-}+{-# BUILTIN AGDATERMUNSUPPORTED unknown #-}++{-# BUILTIN AGDASORTSET set #-}+{-# BUILTIN AGDASORTLIT lit #-}+{-# BUILTIN AGDASORTPROP prop #-}+{-# BUILTIN AGDASORTPROPLIT propLit #-}+{-# BUILTIN AGDASORTINF inf #-}+{-# BUILTIN AGDASORTUNSUPPORTED unknown #-}++{-# BUILTIN AGDAPATCON con #-}+{-# BUILTIN AGDAPATDOT dot #-}+{-# BUILTIN AGDAPATVAR var #-}+{-# BUILTIN AGDAPATLIT lit #-}+{-# BUILTIN AGDAPATPROJ proj #-}+{-# BUILTIN AGDAPATABSURD absurd #-}++{-# BUILTIN AGDACLAUSECLAUSE clause #-}+{-# BUILTIN AGDACLAUSEABSURD absurd-clause #-}++-- Definitions --++data Definition : Set where+ function : (cs : List Clause) → Definition+ data-type : (pars : Nat) (cs : List Name) → Definition+ record-type : (c : Name) (fs : List (Arg Name)) → Definition+ data-cons : (d : Name) (q : Quantity) → Definition+ axiom : Definition+ prim-fun : Definition++{-# BUILTIN AGDADEFINITION Definition #-}+{-# BUILTIN AGDADEFINITIONFUNDEF function #-}+{-# BUILTIN AGDADEFINITIONDATADEF data-type #-}+{-# BUILTIN AGDADEFINITIONRECORDDEF record-type #-}+{-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR data-cons #-}+{-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-}+{-# BUILTIN AGDADEFINITIONPRIMITIVE prim-fun #-}++-- Errors --++data ErrorPart : Set where+ strErr : String → ErrorPart+ termErr : Term → ErrorPart+ pattErr : Pattern → ErrorPart+ nameErr : Name → ErrorPart++{-# BUILTIN AGDAERRORPART ErrorPart #-}+{-# BUILTIN AGDAERRORPARTSTRING strErr #-}+{-# BUILTIN AGDAERRORPARTTERM termErr #-}+{-# BUILTIN AGDAERRORPARTPATT pattErr #-}+{-# BUILTIN AGDAERRORPARTNAME nameErr #-}++-- TC monad --++postulate+ TC : ∀ {a} → Set a → Set a+ returnTC : ∀ {a} {A : Set a} → A → TC A+ bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B+ unify : Term → Term → TC ⊤+ typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A+ inferType : Term → TC Type+ checkType : Term → Type → TC Term+ normalise : Term → TC Term+ reduce : Term → TC Term+ catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A+ quoteTC : ∀ {a} {A : Set a} → A → TC Term+ unquoteTC : ∀ {a} {A : Set a} → Term → TC A+ quoteωTC : ∀ {A : Setω} → A → TC Term+ getContext : TC Telescope+ extendContext : ∀ {a} {A : Set a} → String → Arg Type → TC A → TC A+ inContext : ∀ {a} {A : Set a} → Telescope → TC A → TC A+ freshName : String → TC Name+ declareDef : Arg Name → Type → TC ⊤+ declarePostulate : Arg Name → Type → TC ⊤+ declareData : Name → Nat → Type → TC ⊤+ defineData : Name → List (Σ Name (λ _ → Σ Quantity (λ _ → Type))) → TC ⊤+ defineFun : Name → List Clause → TC ⊤+ getType : Name → TC Type+ getDefinition : Name → TC Definition+ blockTC : ∀ {a} {A : Set a} → Blocker → TC A+ commitTC : TC ⊤+ isMacro : Name → TC Bool+ pragmaForeign : String → String → TC ⊤+ pragmaCompile : String → Name → String → TC ⊤++ -- If 'true', makes the following primitives also normalise+ -- their results: inferType, checkType, quoteTC, getType, and getContext+ withNormalisation : ∀ {a} {A : Set a} → Bool → TC A → TC A+ askNormalisation : TC Bool++ -- If 'true', makes the following primitives to reconstruct hidden arguments:+ -- getDefinition, normalise, reduce, inferType, checkType and getContext+ withReconstructed : ∀ {a} {A : Set a} → Bool → TC A → TC A+ askReconstructed : TC Bool++ -- Whether implicit arguments at the end should be turned into metavariables+ withExpandLast : ∀ {a} {A : Set a} → Bool → TC A → TC A+ askExpandLast : TC Bool++ -- White/blacklist specific definitions for reduction while executing the TC computation+ -- 'true' for whitelist, 'false' for blacklist+ withReduceDefs : ∀ {a} {A : Set a} → (Σ Bool λ _ → List Name) → TC A → TC A+ askReduceDefs : TC (Σ Bool λ _ → List Name)++ formatErrorParts : List ErrorPart → TC String+ -- Prints the third argument if the corresponding verbosity level is turned+ -- on (with the -v flag to Agda).+ debugPrint : String → Nat → List ErrorPart → TC ⊤++ -- Fail if the given computation gives rise to new, unsolved+ -- "blocking" constraints.+ noConstraints : ∀ {a} {A : Set a} → TC A → TC A++ -- Run the given computation at the type level, allowing use of erased things.+ workOnTypes : ∀ {a} {A : Set a} → TC A → TC A++ -- Run the given TC action and return the first component. Resets to+ -- the old TC state if the second component is 'false', or keep the+ -- new TC state if it is 'true'.+ runSpeculative : ∀ {a} {A : Set a} → TC (Σ A λ _ → Bool) → TC A++ -- Get a list of all possible instance candidates for the given meta+ -- variable (it does not have to be an instance meta).+ getInstances : Meta → TC (List Term)++ -- Try to solve open instance constraints. When wrapped in `noConstraints`,+ -- fails if there are unsolved instance constraints left over that originate+ -- from the current macro invokation. Outside constraints are still attempted,+ -- but failure to solve them are ignored by `noConstraints`.+ solveInstanceConstraints : TC ⊤++ -- Parse and type check the given string against the given type, returning+ -- the resulting term (when successful).+ checkFromStringTC : String → Type → TC Term++{-# BUILTIN AGDATCM TC #-}+{-# BUILTIN AGDATCMRETURN returnTC #-}+{-# BUILTIN AGDATCMBIND bindTC #-}+{-# BUILTIN AGDATCMUNIFY unify #-}+{-# BUILTIN AGDATCMTYPEERROR typeError #-}+{-# BUILTIN AGDATCMINFERTYPE inferType #-}+{-# BUILTIN AGDATCMCHECKTYPE checkType #-}+{-# BUILTIN AGDATCMNORMALISE normalise #-}+{-# BUILTIN AGDATCMREDUCE reduce #-}+{-# BUILTIN AGDATCMCATCHERROR catchTC #-}+{-# BUILTIN AGDATCMQUOTETERM quoteTC #-}+{-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-}+{-# BUILTIN AGDATCMQUOTEOMEGATERM quoteωTC #-}+{-# BUILTIN AGDATCMGETCONTEXT getContext #-}+{-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-}+{-# BUILTIN AGDATCMINCONTEXT inContext #-}+{-# BUILTIN AGDATCMFRESHNAME freshName #-}+{-# BUILTIN AGDATCMDECLAREDEF declareDef #-}+{-# BUILTIN AGDATCMDECLAREPOSTULATE declarePostulate #-}+{-# BUILTIN AGDATCMDECLAREDATA declareData #-}+{-# BUILTIN AGDATCMDEFINEDATA defineData #-}+{-# BUILTIN AGDATCMDEFINEFUN defineFun #-}+{-# BUILTIN AGDATCMGETTYPE getType #-}+{-# BUILTIN AGDATCMGETDEFINITION getDefinition #-}+{-# BUILTIN AGDATCMBLOCK blockTC #-}+{-# BUILTIN AGDATCMCOMMIT commitTC #-}+{-# BUILTIN AGDATCMISMACRO isMacro #-}+{-# BUILTIN AGDATCMPRAGMAFOREIGN pragmaForeign #-}+{-# BUILTIN AGDATCMPRAGMACOMPILE pragmaCompile #-}+{-# BUILTIN AGDATCMWITHNORMALISATION withNormalisation #-}+{-# BUILTIN AGDATCMWITHRECONSTRUCTED withReconstructed #-}+{-# BUILTIN AGDATCMWITHEXPANDLAST withExpandLast #-}+{-# BUILTIN AGDATCMWITHREDUCEDEFS withReduceDefs #-}+{-# BUILTIN AGDATCMASKNORMALISATION askNormalisation #-}+{-# BUILTIN AGDATCMASKRECONSTRUCTED askReconstructed #-}+{-# BUILTIN AGDATCMASKEXPANDLAST askExpandLast #-}+{-# BUILTIN AGDATCMASKREDUCEDEFS askReduceDefs #-}+{-# BUILTIN AGDATCMFORMATERRORPARTS formatErrorParts #-}+{-# BUILTIN AGDATCMDEBUGPRINT debugPrint #-}+{-# BUILTIN AGDATCMNOCONSTRAINTS noConstraints #-}+{-# BUILTIN AGDATCMWORKONTYPES workOnTypes #-}+{-# BUILTIN AGDATCMRUNSPECULATIVE runSpeculative #-}+{-# BUILTIN AGDATCMGETINSTANCES getInstances #-}+{-# BUILTIN AGDATCMSOLVEINSTANCES solveInstanceConstraints #-}+{-# BUILTIN AGDATCMCHECKFROMSTRING checkFromStringTC #-}++-- All the TC primitives are compiled to functions that return+-- undefined, rather than just undefined, in an attempt to make sure+-- that code will run properly.+{-# COMPILE JS returnTC = _ => _ => _ => undefined #-}+{-# COMPILE JS bindTC = _ => _ => _ => _ =>+ _ => _ => undefined #-}+{-# COMPILE JS unify = _ => _ => undefined #-}+{-# COMPILE JS typeError = _ => _ => _ => undefined #-}+{-# COMPILE JS inferType = _ => undefined #-}+{-# COMPILE JS checkType = _ => _ => undefined #-}+{-# COMPILE JS normalise = _ => undefined #-}+{-# COMPILE JS reduce = _ => undefined #-}+{-# COMPILE JS catchTC = _ => _ => _ => _ => undefined #-}+{-# COMPILE JS quoteTC = _ => _ => _ => undefined #-}+{-# COMPILE JS unquoteTC = _ => _ => _ => undefined #-}+{-# COMPILE JS quoteωTC = _ => _ => undefined #-}+{-# COMPILE JS getContext = undefined #-}+{-# COMPILE JS extendContext = _ => _ => _ => _ => _ => undefined #-}+{-# COMPILE JS inContext = _ => _ => _ => _ => undefined #-}+{-# COMPILE JS freshName = _ => undefined #-}+{-# COMPILE JS declareDef = _ => _ => undefined #-}+{-# COMPILE JS declarePostulate = _ => _ => undefined #-}+{-# COMPILE JS declareData = _ => _ => _ => undefined #-}+{-# COMPILE JS defineData = _ => _ => undefined #-}+{-# COMPILE JS defineFun = _ => _ => undefined #-}+{-# COMPILE JS getType = _ => undefined #-}+{-# COMPILE JS getDefinition = _ => undefined #-}+{-# COMPILE JS blockTC = _ => _ => undefined #-}+{-# COMPILE JS commitTC = undefined #-}+{-# COMPILE JS isMacro = _ => undefined #-}+{-# COMPILE JS pragmaForeign = _ => _ => undefined #-}+{-# COMPILE JS pragmaCompile = _ => _ => _ => undefined #-}+{-# COMPILE JS withNormalisation = _ => _ => _ => _ => undefined #-}+{-# COMPILE JS withReconstructed = _ => _ => _ => _ => undefined #-}+{-# COMPILE JS withExpandLast = _ => _ => _ => _ => undefined #-}+{-# COMPILE JS withReduceDefs = _ => _ => _ => _ => undefined #-}+{-# COMPILE JS askNormalisation = undefined #-}+{-# COMPILE JS askReconstructed = undefined #-}+{-# COMPILE JS askExpandLast = undefined #-}+{-# COMPILE JS askReduceDefs = undefined #-}+{-# COMPILE JS debugPrint = _ => _ => _ => undefined #-}+{-# COMPILE JS noConstraints = _ => _ => _ => undefined #-}+{-# COMPILE JS runSpeculative = _ => _ => _ => undefined #-}+{-# COMPILE JS getInstances = _ => undefined #-}++private+ filter : (Name → Bool) → List Name → List Name+ filter p [] = []+ filter p (x ∷ xs) with p x+ ... | true = x ∷ filter p xs+ ... | false = filter p xs++ _∈_ : Name → List Name → Bool+ n ∈ [] = false+ n ∈ (n' ∷ l) with primQNameEquality n n'+ ... | true = true+ ... | false = n ∈ l++ _∉_ : Name → List Name → Bool+ n ∉ l with n ∈ l+ ... | true = false+ ... | false = true++ _++_ : List Name → List Name → List Name+ [] ++ l = l+ (x ∷ xs) ++ l = x ∷ (xs ++ l)++ combineReduceDefs : (Σ Bool λ _ → List Name) → (Σ Bool λ _ → List Name) → (Σ Bool λ _ → List Name)+ combineReduceDefs (true , defs₁) (true , defs₂) = (true , filter (_∈ defs₁) defs₂)+ combineReduceDefs (false , defs₁) (true , defs₂) = (true , filter (_∉ defs₁) defs₂)+ combineReduceDefs (true , defs₁) (false , defs₂) = (true , filter (_∉ defs₂) defs₁)+ combineReduceDefs (false , defs₁) (false , defs₂) = (false , defs₁ ++ defs₂)++onlyReduceDefs dontReduceDefs : ∀ {a} {A : Set a} → List Name → TC A → TC A+onlyReduceDefs defs x = bindTC askReduceDefs (λ exDefs → withReduceDefs (combineReduceDefs (true , defs) exDefs) x)+dontReduceDefs defs x = bindTC askReduceDefs (λ exDefs → withReduceDefs (combineReduceDefs (false , defs) exDefs) x)++blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A+blockOnMeta m = blockTC (blockerMeta m)++{-# WARNING_ON_USAGE onlyReduceDefs "DEPRECATED: Use `withReduceDefs` instead of `onlyReduceDefs`" #-}+{-# WARNING_ON_USAGE dontReduceDefs "DEPRECATED: Use `withReduceDefs` instead of `dontReduceDefs`" #-}
@@ -0,0 +1,17 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Reflection.External where++open import Agda.Builtin.List+open import Agda.Builtin.Nat+open import Agda.Builtin.Sigma+open import Agda.Builtin.String+open import Agda.Builtin.Reflection++postulate+ execTC : String → List String → String+ → TC (Σ Nat (λ _ → Σ String (λ _ → String)))++{-# BUILTIN AGDATCMEXEC execTC #-}++{-# COMPILE JS execTC = _ => _ => _ => undefined #-}
@@ -0,0 +1,11 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Reflection.Properties where++open import Agda.Builtin.Reflection+open import Agda.Builtin.Equality++primitive++ primMetaToNatInjective : ∀ a b → primMetaToNat a ≡ primMetaToNat b → a ≡ b+ primQNameToWord64sInjective : ∀ a b → primQNameToWord64s a ≡ primQNameToWord64s b → a ≡ b
@@ -0,0 +1,17 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Sigma where++open import Agda.Primitive++record Σ {a b} (A : Set a) (B : A → Set b) : Set (a ⊔ b) where+ constructor _,_+ field+ fst : A+ snd : B fst++open Σ public++infixr 4 _,_++{-# BUILTIN SIGMA Σ #-}
@@ -0,0 +1,21 @@+{-# OPTIONS --cubical-compatible --no-universe-polymorphism --sized-types+ --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Size where++{-# BUILTIN SIZEUNIV SizeUniv #-}+{-# BUILTIN SIZE Size #-}+{-# BUILTIN SIZELT Size<_ #-}+{-# BUILTIN SIZESUC ↑_ #-}+{-# BUILTIN SIZEINF ∞ #-}+{-# BUILTIN SIZEMAX _⊔ˢ_ #-}++{-# FOREIGN GHC+ type SizeLT i = ()+ #-}++{-# COMPILE GHC Size = type () #-}+{-# COMPILE GHC Size<_ = type SizeLT #-}+{-# COMPILE GHC ↑_ = \_ -> () #-}+{-# COMPILE GHC ∞ = () #-}+{-# COMPILE GHC _⊔ˢ_ = \_ _ -> () #-}
@@ -0,0 +1,9 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Strict where++open import Agda.Builtin.Equality++primitive+ primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x+ primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x
@@ -0,0 +1,36 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.String where++open import Agda.Builtin.Bool+open import Agda.Builtin.Char+open import Agda.Builtin.List+open import Agda.Builtin.Maybe+open import Agda.Builtin.Nat using (Nat)+open import Agda.Builtin.Sigma++postulate String : Set+{-# BUILTIN STRING String #-}++primitive+ primStringUncons : String → Maybe (Σ Char (λ _ → String))+ primStringToList : String → List Char+ primStringFromList : List Char → String+ primStringAppend : String → String → String+ primStringEquality : String → String → Bool+ primShowChar : Char → String+ primShowString : String → String+ primShowNat : Nat → String++{-# COMPILE JS primStringUncons = function(x) {+ if (x === "") { return z_jAgda_Agda_Builtin_Maybe["Maybe"]["nothing"]; };+ return z_jAgda_Agda_Builtin_Maybe["Maybe"]["just"](z_jAgda_Agda_Builtin_Sigma["_,_"](x.charAt(0))(x.slice(1)));+ }+ #-}+{-# COMPILE JS primStringToList = function(x) { return x.split(""); } #-}+{-# COMPILE JS primStringFromList = function(x) { return x.join(""); } #-}+{-# COMPILE JS primStringAppend = function(x) { return function(y) { return x+y; }; } #-}+{-# COMPILE JS primStringEquality = function(x) { return function(y) { return x===y; }; } #-}+{-# COMPILE JS primShowChar = function(x) { return JSON.stringify(x); } #-}+{-# COMPILE JS primShowString = function(x) { return JSON.stringify(x); } #-}+{-# COMPILE JS primShowNat = function(x) { return x.toString(); } #-}
@@ -0,0 +1,11 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.String.Properties where++open import Agda.Builtin.String+open import Agda.Builtin.Equality++primitive++ primStringToListInjective : ∀ a b → primStringToList a ≡ primStringToList b → a ≡ b+ primStringFromListInjective : ∀ a b → primStringFromList a ≡ primStringFromList b → a ≡ b
@@ -0,0 +1,15 @@+{-# OPTIONS --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.TrustMe where++open import Agda.Builtin.Equality+open import Agda.Builtin.Equality.Erase++private+ postulate+ unsafePrimTrustMe : ∀ {a} {A : Set a} {x y : A} → x ≡ y++primTrustMe : ∀ {a} {A : Set a} {x y : A} → x ≡ y+primTrustMe = primEraseEquality unsafePrimTrustMe++{-# DISPLAY primEraseEquality unsafePrimTrustMe = primTrustMe #-}
@@ -0,0 +1,10 @@+{-# OPTIONS --cubical-compatible --safe --no-universe-polymorphism+ --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Unit where++record ⊤ : Set where+ instance constructor tt++{-# BUILTIN UNIT ⊤ #-}+{-# COMPILE GHC ⊤ = data () (()) #-}
@@ -0,0 +1,13 @@+{-# OPTIONS --cubical-compatible --safe --no-universe-polymorphism+ --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Word where++open import Agda.Builtin.Nat++postulate Word64 : Set+{-# BUILTIN WORD64 Word64 #-}++primitive+ primWord64ToNat : Word64 → Nat+ primWord64FromNat : Nat → Word64
@@ -0,0 +1,10 @@+{-# OPTIONS --cubical-compatible --safe --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Builtin.Word.Properties where++open import Agda.Builtin.Word+open import Agda.Builtin.Equality++primitive++ primWord64ToNatInjective : ∀ a b → primWord64ToNat a ≡ primWord64ToNat b → a ≡ b
@@ -0,0 +1,41 @@+-- The Agda primitives (preloaded).++{-# OPTIONS --cubical-compatible --safe --no-import-sorts --no-sized-types --no-guardedness --no-irrelevance --level-universe #-}++module Agda.Primitive where++------------------------------------------------------------------------+-- Universe levels+------------------------------------------------------------------------++infixl 6 _⊔_++{-# BUILTIN PROP Prop #-}+{-# BUILTIN TYPE Set #-}+{-# BUILTIN STRICTSET SSet #-}++{-# BUILTIN PROPOMEGA Propω #-}+{-# BUILTIN SETOMEGA Setω #-}+{-# BUILTIN STRICTSETOMEGA SSetω #-}++{-# BUILTIN LEVELUNIV LevelUniv #-}++-- Level is the first thing we need to define.+-- The other postulates can only be checked if built-in Level is known.++postulate+ Level : LevelUniv++-- MAlonzo compiles Level to (). This should be safe, because it is+-- not possible to pattern match on levels.++{-# BUILTIN LEVEL Level #-}++postulate+ lzero : Level+ lsuc : (ℓ : Level) → Level+ _⊔_ : (ℓ₁ ℓ₂ : Level) → Level++{-# BUILTIN LEVELZERO lzero #-}+{-# BUILTIN LEVELSUC lsuc #-}+{-# BUILTIN LEVELMAX _⊔_ #-}
@@ -0,0 +1,75 @@+{-# OPTIONS --cubical=no-glue --safe --no-sized-types --no-guardedness --no-irrelevance #-}++module Agda.Primitive.Cubical where++{-# BUILTIN CUBEINTERVALUNIV IUniv #-} -- IUniv : SSet₁+{-# BUILTIN INTERVAL I #-} -- I : IUniv++{-# BUILTIN IZERO i0 #-}+{-# BUILTIN IONE i1 #-}++-- I is treated as the type of booleans.+{-# COMPILE JS i0 = false #-}+{-# COMPILE JS i1 = true #-}++primitive+ primIMin : I → I → I+ primIMax : I → I → I+ primINeg : I → I++{-# BUILTIN ISONE IsOne #-} -- IsOne : I → Setω++postulate+ itIsOne : IsOne i1+ IsOne1 : ∀ i j → IsOne i → IsOne (primIMax i j)+ IsOne2 : ∀ i j → IsOne j → IsOne (primIMax i j)++{-# BUILTIN ITISONE itIsOne #-}+{-# BUILTIN ISONE1 IsOne1 #-}+{-# BUILTIN ISONE2 IsOne2 #-}++-- IsOne i is treated as the unit type.+{-# COMPILE JS itIsOne = { "tt" : a => a["tt"]() } #-}+{-# COMPILE JS IsOne1 =+ _ => _ => _ => { return { "tt" : a => a["tt"]() } }+ #-}+{-# COMPILE JS IsOne2 =+ _ => _ => _ => { return { "tt" : a => a["tt"]() } }+ #-}++-- Partial : ∀{ℓ} (i : I) (A : Set ℓ) → Set ℓ+-- Partial i A = IsOne i → A++{-# BUILTIN PARTIAL Partial #-}+{-# BUILTIN PARTIALP PartialP #-}++postulate+ isOneEmpty : ∀ {ℓ} {A : Partial i0 (Set ℓ)} → PartialP i0 A++{-# BUILTIN ISONEEMPTY isOneEmpty #-}++-- Partial i A and PartialP i A are treated as IsOne i → A.+{-# COMPILE JS isOneEmpty =+ _ => x => _ => x({ "tt" : a => a["tt"]() })+ #-}++primitive+ primPOr : ∀ {ℓ} (i j : I) {A : Partial (primIMax i j) (Set ℓ)}+ → (u : PartialP i (λ z → A (IsOne1 i j z)))+ → (v : PartialP j (λ z → A (IsOne2 i j z)))+ → PartialP (primIMax i j) A++ -- Computes in terms of primHComp and primTransp+ primComp : ∀ {ℓ} (A : (i : I) → Set (ℓ i)) {φ : I} (u : ∀ i → Partial φ (A i)) (a : A i0) → A i1++syntax primPOr p q u t = [ p ↦ u , q ↦ t ]++primitive+ primTransp : ∀ {ℓ} (A : (i : I) → Set (ℓ i)) (φ : I) (a : A i0) → A i1+ primHComp : ∀ {ℓ} {A : Set ℓ} {φ : I} (u : ∀ i → Partial φ A) (a : A) → A+++postulate+ PathP : ∀ {ℓ} (A : I → Set ℓ) → A i0 → A i1 → Set ℓ++{-# BUILTIN PATHP PathP #-}
@@ -0,0 +1,2 @@+name: agda-builtins+include: .
@@ -1,445 +0,0 @@-{-# LANGUAGE CPP #-}--module Agda.Auto.Auto (auto) where--import Agda.Utils.Impossible-#include "../undefined.h"--import Control.Monad.Error-import Control.Monad.State-import System.IO.Unsafe (unsafePerformIO)-import Data.List-import Data.Map (Map)-import qualified Data.Map as Map-import Data.IORef-import qualified System.Timeout-import Data.Maybe (catMaybes)--import Agda.Utils.Permutation (permute, takeP)-import Agda.TypeChecking.Monad.Base-import Agda.TypeChecking.Monad.MetaVars-import Agda.TypeChecking.Monad.Context-import Agda.TypeChecking.Monad.Signature-import Agda.TypeChecking.Monad.State (getScope)-import Agda.TypeChecking.Substitute-import qualified Agda.Syntax.Abstract as A-import Agda.Syntax.Abstract.Pretty (prettyA)-import qualified Text.PrettyPrint as PP-import qualified Agda.Syntax.Concrete as C-import Agda.Syntax.Position-import qualified Agda.Syntax.Internal as I-import Agda.Syntax.Common-import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Translation.AbstractToConcrete (abstractToConcrete, abstractToConcrete_, makeEnv, runAbsToCon, toConcrete)-import Agda.Interaction.BasicOps hiding (refine)-import Agda.Interaction.MakeCase (findClause)-import Agda.TypeChecking.Reduce (normalise)-import qualified Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad (withCurrentModule)-import qualified Agda.Syntax.Abstract.Name as AN-import qualified Agda.TypeChecking.Monad.Base as MB-import Agda.TypeChecking.EtaContract (etaContract)--import Agda.Auto.Convert-import Agda.Auto.NarrowingSearch-import Agda.Auto.Syntax-import Agda.Auto.SearchControl-import Agda.Auto.Typecheck---import Agda.Auto.CaseSplit---insertAbsurdPattern [] = []-insertAbsurdPattern s@(_:_) | take (length abspatvarname) s == abspatvarname = "()" ++ drop (length abspatvarname) s-insertAbsurdPattern (c:s) = c : insertAbsurdPattern s--getName :: A.Expr -> Maybe (Bool, I.QName)-getName (A.ScopedExpr _ e) = getName e-getName (A.Def qname) = Just (False, qname)-getName (A.Con qname) = Just (True, head $ I.unAmbQ qname)-getName _ = Nothing--dispmsg msg = return (Left [], Just msg)--auto :: InteractionId -> Range -> String -> TCM (Either [(InteractionId, String)] (Either [String] String), Maybe String)-auto ii rng argstr = liftTCM $ do- let (hints, timeout, pick, mode, hintmode) = parseargs argstr- ahints <- mapM (parseExprIn ii rng) (case mode of {MRefine{} -> []; _ -> hints})-- eqstuff <- liftM (maybe Nothing (mapM getName)) $- catchError (liftM Just $ mapM (parseExprIn ii rng) ["_≡_", "begin_", "_≡⟨_⟩_", "_∎", "sym", "cong"]) (\_ -> return Nothing)-- case mapM getName ahints of- Nothing -> dispmsg "Hints must be a list of constant names"- Just ehints -> do- mi <- lookupInteractionId ii- --thisdefinfo <- catchError (liftM Just $ findClause mi) (\_ -> return Nothing)- thisdefinfo <- findClauseDeep mi- ehints <- liftM (ehints ++) $ autohints hintmode mi (case thisdefinfo of {Just (def, _, _) -> Just def; Nothing -> Nothing})- mrectyp <- case thisdefinfo of- Nothing -> return []- Just (def, _, _) -> do- recdef <- getConstInfo def- let rectyp = MB.defType recdef- rectyp <- normalise rectyp- return [rectyp]-- let ehints' = ehints ++ maybe [] id eqstuff--- (myhints', mymrectyp, tccons, eqcons, cmap) <- tomy mi ehints' mrectyp-- let myhints = take (length myhints' - (length ehints' - length ehints)) myhints'- meqr = case eqstuff of- Nothing -> Nothing- Just _ -> let [c1, c2, c3, c4, c5, c6] = drop (length myhints' - (length ehints' - length ehints)) myhints'- in Just $ EqReasoningConsts c1 c2 c3 c4 c5 c6--- let tcSearchSC isdep ctx typ trm =-- (case meqr of- Nothing -> id- Just eqr -> mpret . Sidecondition (calcEqRState eqr trm)- )-- (tcSearch isdep ctx typ trm)- let (mainm, _, _, _) = tccons Map.! mi- case mode of- MNormal listmode disprove -> do- sols <- liftIO $ newIORef ([] :: [[I.Term]])- nsol <- liftIO $ newIORef (if listmode then (pick + 10) else (pick + 1))- let hsol =--- if listmode then do- nsol' <- readIORef nsol- when (nsol' <= 10) $ runErrorT (mapM (\(m, _, _, _) -> frommy (Meta m)) (Map.elems tccons)) >>= \trms -> case trms of {Left{} -> writeIORef nsol $! nsol' + 1; Right trms -> modifyIORef sols (trms :)}- else do- nsol' <- readIORef nsol- when (nsol' == 1) $ runErrorT (mapM (\(m, _, _, _) -> frommy (Meta m)) (Map.elems tccons)) >>= \trms -> case trms of {Left{} -> writeIORef nsol $! nsol' + 1; Right trms -> writeIORef sols [trms]}- ticks <- liftIO $ newIORef 0- let exsearch initprop recinfo defdfv = liftIO $ System.Timeout.timeout (timeout * 1000000) (- let r d = do- let rechint x = case recinfo of- Nothing -> x- Just (_, recdef) -> (recdef, HMRecCall) : x- env = RIEnv {rieHints = rechint $ map (\x -> (x, HMNormal)) myhints,- rieDefFreeVars = defdfv-- , rieEqReasoningConsts = meqr-- }- depreached <- topSearch ticks nsol hsol env (initprop) d costIncrease- nsol' <- readIORef nsol- if nsol' /= 0 && depreached then- r (d + costIncrease)- else- return depreached- in r 0)- let getsols sol = do- exprs <- mapM (\(mi, e) -> do- mv <- lookupMeta mi- e <- etaContract e- expr <- liftM modifyAbstractExpr $ withMetaInfo (getMetaInfo mv) $ reify e- return (mi, expr)- ) (zip (Map.keys tccons) sol)- let r :: I.MetaId -> StateT [I.MetaId] TCM [(I.MetaId, A.Expr)]- r midx = do- let (m, _, _, deps) = tccons Map.! midx- asolss <- mapM r deps- dones <- get- asols <- if (midx `notElem` dones) then do- put (midx : dones)- return [(midx, let Just e = lookup midx exprs in e)]- else- return []- return $ concat asolss ++ asols- (asols, _) <- runStateT (r mi) []- return asols- if disprove then- case eqcons of- [] -> case Map.elems tccons of- (m, mytype, mylocalVars, _) : [] -> do- defdfv <- case thisdefinfo of- Just (def, _, _) -> fromIntegral `liftM` getdfv mi def- Nothing -> return 0- ee <- liftIO $ newIORef $ ConstDef {cdname = "T", cdorigin = __IMPOSSIBLE__, cdtype = NotM $ Sort (Set 0), cdcont = Postulate, cddeffreevars = 0}- let modargs = drop (length mylocalVars - defdfv) mylocalVars- restargs = take (length mylocalVars - defdfv) mylocalVars- mytype' = foldl (\x y -> NotM $ Pi Nothing Agda.Auto.Syntax.NotHidden (freeIn 0 y) y (Abs NoId x)) mytype restargs- htyp = negtype ee mytype'- sctx = (Id "h", closify htyp) : map (\x -> (NoId, closify x)) modargs- ntt = closify (NotM $ App Nothing (NotM OKVal) (Const ee) (NotM ALNil))- res <- exsearch (tcSearchSC False sctx ntt (Meta m)) Nothing defdfv- rsols <- liftM reverse $ liftIO $ readIORef sols- if null rsols then do- nsol' <- liftIO $ readIORef nsol- dispmsg $ insuffsols (pick + (if listmode then 10 else 1) - nsol')- else do- aexprss <- mapM getsols rsols- cexprss <- mapM (mapM (\(mi, e) -> lookupMeta mi >>= \mv -> withMetaInfo (getMetaInfo mv) $ abstractToConcrete_ e >>= \e' -> return (mi, e'))) aexprss- let ss = dropWhile (== ' ') . dropWhile (/= ' ') . show- disp [(_, cexpr)] = ss cexpr- disp cexprs = concat (map (\(mi, cexpr) -> ss cexpr ++ " ") cexprs)- ticks <- liftIO $ readIORef ticks- dispmsg $ "Listing disproof(s) " ++ show pick ++ "-" ++ show (pick + length rsols - 1) ++--- "\n" ++ unlines (map (\(x, y) -> show y ++ " " ++ disp x) $ zip cexprss [pick..])- _ -> dispmsg "Metavariable dependencies not allowed in disprove mode"- _ -> dispmsg "Metavariable dependencies not allowed in disprove mode"- else do- (recinfo, defdfv) <-- case thisdefinfo of- Just (def, clause, _) -> do- let [rectyp'] = mymrectyp- defdfv <- getdfv mi def- myrecdef <- liftIO $ newIORef $ ConstDef {cdname = "", cdorigin = (Nothing, def), cdtype = rectyp', cdcont = Postulate, cddeffreevars = fromIntegral defdfv}- (_, pats) <- constructPats cmap mi clause- defdfv <- fromIntegral `liftM` getdfv mi def- return $ if contains_constructor pats then- (Just (pats, myrecdef), defdfv)- else- (Nothing, defdfv)- Nothing -> return (Nothing, 0)- let tc (m, mytype, mylocalVars) isdep = tcSearchSC isdep (map (\x -> (NoId, closify x)) mylocalVars) (closify mytype) (Meta m)- initprop =- foldl (\x (ineq, e, i) -> mpret $ And Nothing x (comp' ineq (closify e) (closify i)))- (foldl (\x (m, mt, mlv, _) ->- if hequalMetavar m mainm then- case recinfo of- Just (recpats, recdef) ->- mpret $ Sidecondition (localTerminationSidecond (localTerminationEnv recpats) recdef (Meta m))- (tc (m, mt, mlv) False)- Nothing -> mpret $ And Nothing x (tc (m, mt, mlv) False)- else- mpret $ And Nothing x (tc (m, mt, mlv) True)- )- (mpret OK)- (Map.elems tccons)- ) eqcons- res <- exsearch initprop recinfo defdfv- iis <- getInteractionPoints- riis <- mapM (\ii -> lookupInteractionId ii >>= \mi -> return (mi, ii)) iis- if listmode then do- rsols <- liftM reverse $ liftIO $ readIORef sols- if null rsols then do- nsol' <- liftIO $ readIORef nsol- dispmsg $ insuffsols (pick + 10 - nsol')- else do- aexprss <- mapM getsols rsols- cexprss <- mapM (mapM (\(mi, e) -> lookupMeta mi >>= \mv -> withMetaInfo (getMetaInfo mv) $ abstractToConcrete_ e >>= \e' -> return (mi, e'))) aexprss- let disp [(_, cexpr)] = show cexpr- disp cexprs = concat (map (\(mi, cexpr) -> case lookup mi riis of {Nothing -> show mi; Just ii -> show ii} ++ " := " ++ show cexpr ++ " ") cexprs)- ticks <- liftIO $ readIORef ticks- dispmsg $ "Listing solution(s) " ++ show pick ++ "-" ++ show (pick + length rsols - 1) ++--- "\n" ++ unlines (map (\(x, y) -> show y ++ " " ++ disp x) $ zip cexprss [pick..])- else- case res of- Nothing -> do- nsol' <- liftIO $ readIORef nsol- dispmsg $ insuffsols (pick + 1 - nsol') ++ " at time out (" ++ show timeout ++ "s)"- Just depthreached -> do- ticks <- liftIO $ readIORef ticks- rsols <- liftIO $ readIORef sols- case rsols of- [] -> do- nsol' <- liftIO $ readIORef nsol- dispmsg $ insuffsols (pick + 1 - nsol')- (term : _) -> do- exprs <- getsols term- giveress <-- mapM (\(mi, expr) ->- case lookup mi riis of- Nothing -> giveExpr mi expr >>= \_ -> return Nothing- Just ii' -> do (ae, []) <- give ii' Nothing expr- mv <- lookupMeta mi- let scope = getMetaScope mv- ce = abstractToConcrete (makeEnv scope) ae- let cmnt = if ii' == ii then agsyinfo ticks else ""- return $ Just (ii', show ce ++ cmnt)- ) exprs- let msg = if length exprs == 1 then- Nothing- else- Just $ "Also gave solution(s) for hole(s)" ++- concatMap (\(mi', _) ->- if mi' == mi then "" else (" " ++ case lookup mi' riis of {Nothing -> show mi'; Just ii -> show ii})- ) exprs- return (Left $ catMaybes giveress, msg)-- MCaseSplit -> do- case thisdefinfo of- Just (def, clause, True) ->- case Map.elems tccons of- ((m, mytype, mylocalVars, _) : []) | null eqcons -> do--- (ids, pats) <- constructPats cmap mi clause- let pids = concat $ map (\(_, x) -> " " ++ case x of {Id s -> s; NoId -> "noid"}) ids- ctx = map (\((hid, id), t) -> HI hid (id, t)) (zip ids mylocalVars)- ticks <- liftIO $ newIORef 0- let [rectyp'] = mymrectyp- defdfv <- getdfv mi def- myrecdef <- liftIO $ newIORef $ ConstDef {cdname = "", cdorigin = (Nothing, def), cdtype = rectyp', cdcont = Postulate, cddeffreevars = fromIntegral defdfv}- sols <- liftIO $ System.Timeout.timeout (timeout * 1000000) (- let r d = do- sols <- liftIO $ caseSplitSearch ticks __IMPOSSIBLE__ myhints meqr __IMPOSSIBLE__ d myrecdef ctx mytype pats- case sols of- [] -> r (d + costIncrease)- (_:_) -> return sols- in r 0)- case sols of- Just (cls : _) -> withInteractionId ii $ do- cls' <- liftIO $ runErrorT (mapM frommyClause cls)- case cls' of- Left{} -> dispmsg "No solution found"- Right cls' -> do- cls'' <- mapM (\(I.Clause _ tel perm ps body) ->- withCurrentModule (AN.qnameModule def) $ do- -- Normalise the dot patterns- ps <- addCtxTel tel $ normalise ps- body <- etaContractBody body- liftM modifyAbstractClause $ inContext [] $ reify $ NamedClause def $ I.Clause noRange tel perm ps body- ) cls'- pcs <- withInteractionId ii $ mapM prettyA cls''- ticks <- liftIO $ readIORef ticks--- return (Right $ Left (map (insertAbsurdPattern . PP.renderStyle (PP.style { PP.mode = PP.OneLineMode })) pcs), Nothing)-- Just [] -> dispmsg "No solution found" -- case not possible at the moment because case split doesnt care about search exhaustiveness- Nothing -> dispmsg $ "No solution found at time out (" ++ show timeout ++ "s)"- _ -> dispmsg "Metavariable dependencies not allowed in case split mode"- _ -> dispmsg "Metavariable is not at top level of clause RHS"-- MRefine listmode -> do- mv <- lookupMeta mi- let HasType _ tt = mvJudgement mv- minfo = getMetaInfo mv- targettyp <- withMetaInfo minfo $ do- vs <- getContextArgs- let targettype = tt `piApply` permute (takeP (fromIntegral $ length vs) $ mvPermutation mv) vs- normalise targettype- let tctx = length $ envContext $ clEnv minfo-- hits <- if elem "-a" hints then do- st <- liftTCM $ join $ pureTCM $ \st _ -> return st- let defs = sigDefinitions $ stSignature st- idefs = sigDefinitions $ stImports st- alldefs = Map.keys defs ++ Map.keys idefs- liftM catMaybes $ mapM (\n ->- case thisdefinfo of- Just (def, _, _) | def == n -> return Nothing- _ -> do- cn <- withMetaInfo minfo $ runAbsToCon $ toConcrete n- if head (show cn) == '.' then -- not in scope- return Nothing- else do- c <- getConstInfo n- ctyp <- normalise $ defType c- cdfv <- withMetaInfo minfo $ getDefFreeVars n- return $ case matchType cdfv (fromIntegral tctx) ctyp targettyp of- Nothing -> Nothing- Just score -> Just (show cn, score)- ) alldefs- else do- let scopeinfo = clScope (getMetaInfo mv)- namespace = Agda.Syntax.Scope.Base.everythingInScope scopeinfo- names = Agda.Syntax.Scope.Base.nsNames namespace- qnames = map (\(x, y) -> (x, Agda.Syntax.Scope.Base.anameName $ head y)) $ Map.toList names- modnames = case thisdefinfo of- Just (def, _, _) -> filter (\(_, n) -> n /= def) qnames- Nothing -> qnames- liftM catMaybes $ mapM (\(cn, n) -> do- c <- getConstInfo n- ctyp <- normalise $ defType c- cdfv <- withMetaInfo minfo $ getDefFreeVars n- return $ case matchType cdfv (fromIntegral tctx) ctyp targettyp of- Nothing -> Nothing- Just score -> Just (show cn, score)- ) modnames-- let sorthits = sortBy (\(_, (pa1, pb1)) (_, (pa2, pb2)) -> case compare pa2 pa1 of {EQ -> compare pb1 pb2; o -> o}) hits- if listmode || pick == (-1) then- let pick' = max 0 pick- in if pick' >= length sorthits then- dispmsg $ insuffcands $ length sorthits- else- let showhits = take 10 $ drop pick' sorthits- in dispmsg $ "Listing candidate(s) " ++ show pick' ++ "-" ++ show (pick' + length showhits - 1) ++ " (found " ++ show (length sorthits) ++ " in total)\n" ++- unlines (map (\(i, (cn, _)) -> show i ++ " " ++ cn) (zip [pick'..pick' + length showhits - 1] showhits))- else- if pick >= length sorthits then- dispmsg $ insuffcands $ length sorthits- else- return (Right $ Right (fst $ sorthits !! pick), Nothing)- where--- agsyinfo ticks = ""-autohints AHMModule mi (Just def) = do- mv <- lookupMeta mi- let scopeinfo = clScope (getMetaInfo mv)- namespace = Agda.Syntax.Scope.Base.everythingInScope scopeinfo- names = Agda.Syntax.Scope.Base.nsNames namespace- qnames = map (Agda.Syntax.Scope.Base.anameName . head) $ Map.elems names- modnames = filter (\n -> AN.qnameModule n == AN.qnameModule def && n /= def) qnames- modnames' <- filterM (\n -> do- c <- getConstInfo n- return (case theDef c of- Axiom{} -> True- Function{} -> True- _ -> False- )- ) modnames- return $ map (\x -> (False, x)) modnames'-autohints _ _ _ = return []--insuffsols 0 = "No solution found"-insuffsols n = "Only " ++ show n ++ " solution(s) found"--insuffcands 0 = "No candidate found"-insuffcands n = "Only " ++ show n ++ " candidate(s) found"--data Mode = MNormal Bool Bool -- true if list mode, true if disprove-- | MCaseSplit-- | MRefine Bool -- true if list mode---data AutoHintMode = AHMNone- | AHMModule--parseargs :: String -> ([String], Int, Int, Mode, AutoHintMode)-parseargs s =- let r ("-t" : timeout : ws) (_, pick, mode, hintmode) =- r ws (read timeout, pick, mode, hintmode)- r ("-s" : pick : ws) (timeout, _, mode, hintmode) =- r ws (timeout, read pick, mode, hintmode)--- r ("-l" : ws) (timeout, pick, MNormal _ disprove, hintmode) =- r ws (timeout, pick, MNormal True disprove, hintmode)- r ("-l" : ws) (timeout, pick, MRefine _, hintmode) =- r ws (timeout, pick, MRefine True, hintmode)- r ("-d" : ws) (timeout, pick, MNormal listmode _, hintmode) =- r ws (timeout, pick, MNormal listmode True, hintmode)- r ("-m" : ws) (timeout, pick, mode, _) =- r ws (timeout, pick, mode, AHMModule)-- r ("-c" : ws) (timeout, pick, _, hintmode) =- r ws (timeout, pick, MCaseSplit, hintmode)-- r ("-r" : ws) (timeout, pick, _, hintmode) =- r ws (timeout, (-1), MRefine False, hintmode)- r (h : ws) x =- let (hints, timeout, pick, mode, hintmode) = r ws x- in (h : hints, timeout, pick, mode, hintmode)- r [] (x,y,z,w) = ([],x,y,z,w)- in r (words s) (5, 0, MNormal False False, AHMNone)
@@ -1,645 +0,0 @@-{-# LANGUAGE Rank2Types, ScopedTypeVariables, CPP #-}-module Agda.Auto.CaseSplit where--import Agda.Utils.Impossible-#include "../undefined.h"--import Data.IORef-import Data.List (findIndex, union)-import qualified Data.IntMap as IntMap--import Agda.Auto.NarrowingSearch-import Agda.Auto.Syntax---import Agda.Auto.SearchControl-import Agda.Auto.Typecheck--abspatvarname = "\0absurdPattern"--costCaseSplitVeryHigh = 10000-costCaseSplitHigh = 5000-costCaseSplitLow = 2000-costAddVarDepth = 1000---data HI a = HI FMode a-drophid = map (\(HI _ x) -> x)---type CSPat o = HI (CSPatI o)-type CSCtx o = [HI (MId, MExp o)]--data CSPatI o = CSPatConApp (ConstRef o) [CSPat o]- | CSPatVar Nat- | CSPatExp (MExp o)- | CSWith (MExp o) -- always an App- | CSAbsurd-- | CSOmittedArg-type Sol o = [(CSCtx o, [CSPat o], Maybe (MExp o))]--caseSplitSearch :: forall o . IORef Int -> Int -> [ConstRef o] -> Maybe (EqReasoningConsts o) -> Int -> Int -> ConstRef o -> CSCtx o -> MExp o -> [CSPat o] -> IO [Sol o]-caseSplitSearch ticks nsolwanted chints meqr depthinterval depth recdef ctx tt pats = do- let branchsearch depth ctx tt termcheckenv = do--- nsol <- newIORef 1- m <- initMeta- sol <- newIORef Nothing- let trm = Meta m- hsol = do trm' <- expandExp trm--- writeIORef sol (Just trm')--- hpartsol = __IMPOSSIBLE__-- initcon = mpret $ Sidecondition (localTerminationSidecond termcheckenv recdef trm)- (-- (case meqr of- Nothing -> id- Just eqr -> mpret . Sidecondition (calcEqRState eqr trm)- )-- (tcSearch False (map (\(id, t) -> (id, closify t)) (drophid ctx)) (closify tt) trm)- )- recdefd <- readIORef recdef- let env = RIEnv {rieHints = (recdef, HMRecCall) : map (\x -> (x, HMNormal)) chints,- rieDefFreeVars = cddeffreevars recdefd-- , rieEqReasoningConsts = meqr-- }- depreached <- topSearch ticks nsol hsol env initcon depth (depth + 1)- rsol <- readIORef sol- return rsol- ctx' = ff 1 ctx- ff _ [] = []- ff n (HI hid (id, t) : ctx) = HI hid (id, lift n t) : ff (n + 1) ctx- caseSplitSearch' branchsearch depthinterval depth recdef ctx' tt pats--caseSplitSearch' :: forall o . (Int -> CSCtx o -> MExp o -> ([Nat], Nat, [Nat]) -> IO (Maybe (MExp o))) -> Int -> Int -> ConstRef o -> CSCtx o -> MExp o -> [CSPat o] -> IO [Sol o]-caseSplitSearch' branchsearch depthinterval depth recdef ctx tt pats = do- recdefd <- readIORef recdef- sols <- rc depth (cddeffreevars recdefd) ctx tt pats- return sols- where- rc :: Int -> Int -> CSCtx o -> MExp o -> [CSPat o] -> IO [Sol o]- rc depth _ _ _ _ | depth < 0 = return []- rc depth nscrutavoid ctx tt pats = do-- mblkvar <- getblks tt--- fork- mblkvar- where- fork :: [Nat] -> IO [Sol o]- fork mblkvar = do- sols1 <- dobody- case sols1 of- (_:_) -> return sols1- [] -> do- let r [] = return []- r (v:vs) = do- sols2 <- splitvar mblkvar v- case sols2 of- (_:_) -> return sols2- [] -> r vs- r [nv - x | x <- [0..nv]] -- [0..length ctx - 1 - nscrutavoid]- where nv = length ctx - 1- dobody :: IO [Sol o]- dobody = do- case findperm (map snd (drophid ctx)) of- Just perm -> do- let (ctx', tt', pats') = applyperm perm ctx tt pats- res <- branchsearch depth ctx' tt' (localTerminationEnv pats')- return $ case res of- Just trm -> [[(ctx', pats', Just trm)]]- Nothing -> []- Nothing -> __IMPOSSIBLE__ -- no permutation found- splitvar :: [Nat] -> Nat -> IO [Sol o]- splitvar mblkvar scrut = do- let scruttype = infertypevar ctx scrut- case rm scruttype of- App _ _ (Const c) _ -> do- cd <- readIORef c- case cdcont cd of- Datatype cons _ -> do- sols <- dobranches cons- return $ map (\sol -> case sol of- [] ->- case findperm (map snd (drophid ctx)) of- Just perm ->- let HI scrhid(_, scrt) = ctx !! scrut- ctx1 = take scrut ctx ++ (HI scrhid (Id abspatvarname, scrt)) : drop (scrut + 1) ctx- (ctx', _, pats') = applyperm perm ctx1 tt ({-map (replacep scrut 1 CSAbsurd __IMPOSSIBLE__) -}pats)- in [(ctx', pats', Nothing)]- Nothing -> __IMPOSSIBLE__ -- no permutation found- _ -> sol- ) sols- where- dobranches :: [ConstRef o] -> IO [Sol o]- dobranches [] = return [[]]- dobranches (con : cons) = do- cond <- readIORef con- let ff t = case rm t of- Pi _ h _ it (Abs id ot) ->- let (xs, inft) = ff ot- in ((Pair h (scrut + length xs), id, lift (scrut + length xs + 1) it) : xs, inft)- _ -> ([], lift scrut t)- (newvars, inftype) = ff (cdtype cond)- constrapp = mm $ App Nothing (mm OKVal) (Const con) (foldl (\xs (Pair h v, _, _) -> mm $ ALCons h (mm $ App Nothing (mm OKVal) (Var v) (mm ALNil)) xs) (mm ALNil) (reverse newvars))- pconstrapp = CSPatConApp con (map (\(Pair hid v, _, _) -> HI hid (CSPatVar v)) newvars)- thesub = replace scrut (length newvars) constrapp- Id newvarprefix = fst $ (drophid ctx) !! scrut- ctx1 = map (\(HI hid (id, t)) -> HI hid (id, thesub t)) (take scrut ctx) ++- reverse (map (\((Pair hid _, id, t), i) ->- HI hid (Id (case id of {NoId -> newvarprefix{- ++ show i-}; Id id -> id}), t)- ) (zip newvars [0..])) ++- map (\(HI hid (id, t)) -> HI hid (id, thesub t)) (drop (scrut + 1) ctx)- tt' = thesub tt- pats' = map (replacep scrut (length newvars) pconstrapp constrapp) pats- scruttype' = thesub scruttype -- scruttype shouldn't really refer to scrutvar so lift is enough, but what if circular ref has been created and this is not detected until case split is done- case unifyexp inftype scruttype' of- Nothing -> do- res <- notequal scrut (length newvars) scruttype' inftype- if res then -- branch absurd- dobranches cons- else -- branch dont know- return []- Just unif ->- do- let (ctx2, tt2, pats2) = removevar ctx1 tt' pats' unif- --cost = if elem scrut mblkvar then costCaseSplit - (costCaseSplit - costCaseSplitFollow) `div` (length mblkvar) else costCaseSplit- cost = if null mblkvar then- if scrut < length ctx - nscrutavoid && nothid then costCaseSplitLow + costAddVarDepth * depthofvar scrut pats else costCaseSplitVeryHigh- else- if elem scrut mblkvar then costCaseSplitLow else (if scrut < length ctx - nscrutavoid && nothid then costCaseSplitHigh else costCaseSplitVeryHigh)-- nothid = let HI hid _ = ctx !! scrut- in case hid of {Hidden -> False; Instance -> False; NotHidden -> True}--- sols <- rc (depth - cost) (length ctx - 1 - scrut) ctx2 tt2 pats2- case sols of- [] -> return []- _ -> do- sols2 <- dobranches cons- return $ concat (map (\sol -> map (\sol2 -> sol ++ sol2) sols2) sols)- _ -> return [] -- split failed "scrut type is not datatype"- _ -> return [] -- split failed "scrut type is not datatype"-infertypevar :: CSCtx o -> Nat -> MExp o-infertypevar ctx v = snd $ (drophid ctx) !! v-replace :: Nat -> Nat -> MExp o -> MExp o -> MExp o-replace sv nnew re = r 0- where- r n e =- case rm e of- App uid ok elr@(Var v) args ->- if v >= n then- if v - n == sv then- betareduce (lift n re) (rs n args)- else- if v - n > sv then- mm $ App uid ok (Var (v + nnew - 1)) (rs n args)- else- mm $ App uid ok elr (rs n args)- else- mm $ App uid ok elr (rs n args)- App uid ok elr@(Const _) args ->- mm $ App uid ok elr (rs n args)- Lam hid (Abs mid e) -> mm $ Lam hid (Abs mid (r (n + 1) e))- Pi uid hid possdep it (Abs mid ot) -> mm $ Pi uid hid possdep (r n it) (Abs mid (r (n + 1) ot))- Sort{} -> e-- AbsurdLambda{} -> e--- rs n es =- case rm es of- ALNil -> mm $ ALNil- ALCons hid a as -> mm $ ALCons hid (r n a) (rs n as)-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> mm $ ALConPar (rs n as)---betareduce :: MExp o -> MArgList o -> MExp o-betareduce e args = case rm args of- ALNil -> e- ALCons _ a rargs -> case rm e of- App uid ok elr eargs -> mm $ App uid ok elr (concatargs eargs args)- Lam _ (Abs _ b) -> betareduce (replace 0 0 a b) rargs- _ -> __IMPOSSIBLE__ -- not type correct if this happens-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> __IMPOSSIBLE__---concatargs xs ys = case rm xs of- ALNil -> ys- ALCons hid x xs -> mm $ ALCons hid x (concatargs xs ys)-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> mm $ ALConPar (concatargs xs ys)---eqelr :: Elr o -> Elr o -> Bool-eqelr (Var v1) (Var v2) = v1 == v2-eqelr (Const c1) (Const c2) = c1 == c2-eqelr _ _ = False--replacep :: Nat -> Nat -> CSPatI o -> MExp o -> CSPat o -> CSPat o-replacep sv nnew rp re = r- where- r (HI hid (CSPatConApp c ps)) = HI hid (CSPatConApp c (map r ps))- r (HI hid (CSPatVar v)) = if v == sv then- HI hid rp- else- if v > sv then- HI hid (CSPatVar (v + nnew - 1))- else- HI hid (CSPatVar v)- r (HI hid (CSPatExp e)) = HI hid (CSPatExp $ replace sv nnew re e)-- r p@(HI _ CSOmittedArg) = p-- r _ = __IMPOSSIBLE__ -- other constructors dont appear in indata Pats--rm :: MM a b -> a-rm (NotM x) = x-rm (Meta{}) = __IMPOSSIBLE__--mm :: a -> MM a b-mm = NotM--unifyexp :: MExp o -> MExp o -> Maybe [(Nat, MExp o)]-unifyexp e1 e2 = r e1 e2 (\unif -> Just unif) []- where- r e1 e2 cont unif = case (rm e1, rm e2) of- (App _ _ elr1 args1, App _ _ elr2 args2) | eqelr elr1 elr2 -> rs args1 args2 cont unif- (Lam hid1 (Abs _ b1), Lam hid2 (Abs _ b2)) | hid1 == hid2 -> r b1 b2 cont unif- (Pi _ hid1 _ it1 (Abs _ ot1), Pi _ hid2 _ it2 (Abs _ ot2)) | hid1 == hid2 -> r it1 it2 (r ot1 ot2 cont) unif- (Sort _, Sort _) -> cont unif -- a bit sloppy- (App _ _ (Var v) (NotM ALNil), _) ->- case lookup v unif of- Nothing -> cont ((v, e2) : unif)- Just e1' -> r e1' e2 cont unif- (_, App _ _ (Var v) (NotM ALNil)) ->- case lookup v unif of- Nothing -> cont ((v, e1) : unif)- Just e2' -> r e1 e2' cont unif- _ -> Nothing- rs args1 args2 cont unif = case (rm args1, rm args2) of- (ALNil, ALNil) -> cont unif- (ALCons hid1 a1 as1, ALCons hid2 a2 as2) | hid1 == hid2 -> r a1 a2 (rs as1 as2 cont) unif- (ALConPar as1, ALCons _ _ as2) -> rs as1 as2 cont unif- (ALCons _ _ as1, ALConPar as2) -> rs as1 as2 cont unif- (ALConPar as1, ALConPar as2) -> rs as1 as2 cont unif- _ -> Nothing--lift :: Nat -> MExp o -> MExp o-lift 0 = id-lift n = r 0- where- r j e =- case rm e of- App uid ok elr args -> case elr of- Var v | v >= j -> mm $ App uid ok (Var (v + n)) (rs j args)- _ -> mm $ App uid ok elr (rs j args)- Lam hid (Abs mid e) -> mm $ Lam hid (Abs mid (r (j + 1) e))- Pi uid hid possdep it (Abs mid ot) -> mm $ Pi uid hid possdep (r j it) (Abs mid (r (j + 1) ot))- Sort{} -> e-- AbsurdLambda{} -> e--- rs j es =- case rm es of- ALNil -> mm $ ALNil- ALCons hid a as -> mm $ ALCons hid (r j a) (rs j as)-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> mm $ ALConPar (rs j as)---removevar :: CSCtx o -> MExp o -> [CSPat o] -> [(Nat, MExp o)] -> (CSCtx o, MExp o, [CSPat o])-removevar ctx tt pats [] = (ctx, tt, pats)-removevar ctx tt pats ((v, e) : unif) =- let- e2 = replace v 0 (__IMPOSSIBLE__ {- occurs check failed -}) e- thesub = replace v 0 e2- ctx1 = map (\(HI hid (id, t)) -> HI hid (id, thesub t)) (take v ctx) ++- map (\(HI hid (id, t)) -> HI hid (id, thesub t)) (drop (v + 1) ctx)- tt' = thesub tt- pats' = map (replacep v 0 (CSPatExp e2) e2) pats- unif' = map (\(uv, ue) -> (if uv > v then uv - 1 else uv, thesub ue)) unif- in- removevar ctx1 tt' pats' unif'--notequal :: Nat -> Nat -> MExp o -> MExp o -> IO Bool-notequal firstnew nnew e1 e2 =- case (rm e1, rm e2) of- (App _ _ _ es1, App _ _ _ es2) -> rs es1 es2 (\_ -> return False) []- _ -> __IMPOSSIBLE__- where- rs :: MArgList o -> MArgList o -> ([(Nat, MExp o)] -> IO Bool) -> [(Nat, MExp o)] -> IO Bool- rs es1 es2 cont unifier2 =- case (rm es1, rm es2) of- (ALCons _ e1 es1, ALCons _ e2 es2) -> r e1 e2 (rs es1 es2 cont) unifier2-- (ALConPar es1, ALConPar es2) -> rs es1 es2 cont unifier2-- _ -> cont unifier2-- r :: MExp o -> MExp o -> ([(Nat, MExp o)] -> IO Bool) -> [(Nat, MExp o)] -> IO Bool- r e1 e2 cont unifier2 = case rm e2 of- App _ _ (Var v2) es2 | firstnew <= v2 && v2 < firstnew + nnew ->- case rm es2 of- ALNil ->- case lookup v2 unifier2 of- Nothing -> cont ((v2, e1) : unifier2)- Just e2' -> cc e1 e2'- ALCons{} -> cont unifier2-- ALProj{} -> __IMPOSSIBLE__--- ALConPar{} -> __IMPOSSIBLE__-- _ -> cc e1 e2- where- cc e1 e2 = case (rm e1, rm e2) of- (App _ _ (Const c1) es1, App _ _ (Const c2) es2) -> do- cd1 <- readIORef c1- cd2 <- readIORef c2- case (cdcont cd1, cdcont cd2) of- (Constructor{}, Constructor{}) ->- if c1 == c2 then- rs es1 es2 cont unifier2- else- return True- _ -> cont unifier2- _ -> cont unifier2--findperm :: [MExp o] -> Maybe [Nat]-findperm ts =- let- frees = map freevars ts- m = IntMap.fromList (map (\i -> (i, length (filter (elem i) frees))) [0..length ts - 1])- r _ perm 0 = Just $ reverse perm- r m perm n =- case lookup 0 (map (\(x,y) -> (y,x)) (IntMap.toList m)) of- Nothing -> Nothing- Just i -> r (foldl (\m i -> IntMap.adjust (\x -> x - 1) i m) (IntMap.insert i (-1) m) (frees !! i)) (i : perm) (n - 1)- in r m [] (length ts)--freevars :: MExp o -> [Nat]-freevars = f 0- where- f n e = case rm e of- App _ _ (Var v) args -> union [v - n] (fs n args)- App _ _ (Const _) args -> fs n args- Lam _ (Abs _ b) -> f (n + 1) b- Pi _ _ _ it (Abs _ ot) -> union (f n it) (f (n + 1) ot)- Sort{} -> []-- AbsurdLambda{} -> []--- fs n es = case rm es of- ALNil -> []- ALCons _ e es -> union (f n e) (fs n es)-- ALProj{} -> __IMPOSSIBLE__--- ALConPar es -> fs n es---applyperm :: [Nat] -> CSCtx o -> MExp o -> [CSPat o] -> (CSCtx o, MExp o, [CSPat o])-applyperm perm ctx tt pats =- let ctx1 = map (\(HI hid (id, t)) -> HI hid (id, rename (ren perm) t)) ctx- ctx2 = map (\i -> ctx1 !! i) perm- ctx3 = seqctx ctx2- tt' = rename (ren perm) tt- pats' = map (renamep (ren perm)) pats- in (ctx3, tt', pats')--ren n i = let Just j = findIndex (== i) n in j--rename :: (Nat -> Nat) -> MExp o -> MExp o-rename ren = r 0- where- r j e =- case rm e of- App uid ok elr args -> case elr of- Var v | v >= j -> mm $ App uid ok (Var (ren (v - j) + j)) (rs j args)- _ -> mm $ App uid ok elr (rs j args)- Lam hid (Abs mid e) -> mm $ Lam hid (Abs mid (r (j + 1) e))- Pi uid hid possdep it (Abs mid ot) -> mm $ Pi uid hid possdep (r j it) (Abs mid (r (j + 1) ot))- Sort{} -> e-- AbsurdLambda{} -> e--- rs j es =- case rm es of- ALNil -> mm $ ALNil- ALCons hid a as -> mm $ ALCons hid (r j a) (rs j as)-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> mm $ ALConPar (rs j as)---renamep :: (Nat -> Nat) -> CSPat o -> CSPat o-renamep ren = r- where- r (HI hid (CSPatConApp c pats)) = HI hid (CSPatConApp c (map r pats))- r (HI hid (CSPatVar i)) = HI hid (CSPatVar $ ren i)- r (HI hid (CSPatExp e)) = HI hid (CSPatExp $ rename ren e)-- r p@(HI _ CSOmittedArg) = p-- r _ = __IMPOSSIBLE__--seqctx :: CSCtx o -> CSCtx o-seqctx = r (-1)- where- r _ [] = []- r n (HI hid (id, t) : ctx) = HI hid (id, lift n t) : r (n - 1) ctx--- ----------------------depthofvar :: Nat -> [CSPat o] -> Nat-depthofvar v pats =- let [depth] = concatMap (f 0) (drophid pats)- f d (CSPatConApp _ pats) = concatMap (f (d + 1)) (drophid pats)- f d (CSPatVar v') = if v == v' then [d] else []- f _ _ = []- in depth---- ----------------------localTerminationEnv :: [CSPat o] -> ([Nat], Nat, [Nat])-localTerminationEnv pats =- let g _ [] = ([], 0, [])- g i (hp@(HI _ p) : ps) = case p of- CSPatConApp{} ->- let (size, vars) = h hp- (is, size', vars') = g (i + 1) ps- in (i : is, size + size', vars ++ vars')- _ -> g (i + 1) ps- h (HI _ p) = case p of- CSPatConApp c ps ->- let (size, vars) = hs ps- in (size + 1, vars)- CSPatVar n -> (0, [n])- CSPatExp e -> he e- _ -> (0, [])- hs [] = (0, [])- hs (p : ps) =- let (size, vars) = h p- (size', vars') = hs ps- in (size + size', vars ++ vars')- he e = case rm e of- App _ _ (Var v) _ -> (0, [v])- App _ _ (Const _) args ->- let (size, vars) = hes args- in (size + 1, vars)- _ -> (0, [])- hes as = case rm as of- ALNil -> (0, [])- ALCons _ a as ->- let (size, vars) = he a- (size', vars') = hes as- in (size + size', vars ++ vars')-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> hes as-- in g 0 pats---localTerminationSidecond :: ([Nat], Nat, [Nat]) -> ConstRef o -> MExp o -> EE (MyPB o)-localTerminationSidecond (is, size, vars) reccallc b =- ok b- where- ok e = mmpcase (False, prioNo, Nothing) e $ \e -> case e of- App _ _ elr args -> mpret $ Sidecondition- (oks args)- (case elr of- Const c | c == reccallc -> if size == 0 then mpret (Error "localTerminationSidecond: no size to decrement") else okcall 0 size vars args- _ -> mpret OK- )- Lam _ (Abs _ e) -> ok e- Pi _ _ _ it (Abs _ ot) -> mpret $ Sidecondition- (ok it)- (ok ot)- Sort{} -> mpret OK-- AbsurdLambda{} -> mpret OK--- oks as = mmpcase (False, prioNo, Nothing) as $ \as -> case as of- ALNil -> mpret OK- ALCons _ a as -> mpret $ Sidecondition- (ok a)- (oks as)-- ALProj eas _ _ as -> mpret $ Sidecondition (oks eas) (oks as)--- ALConPar as -> oks as-- okcall i size vars as = mmpcase (False, prioNo, Nothing) as $ \as -> case as of- ALNil -> mpret OK- ALCons _ a as | elem i is ->- mbpcase prioNo Nothing (he size vars a) $ \x -> case x of- Nothing -> mpret $ Error "localTerminationSidecond: reccall not ok"- Just (size', vars') -> okcall (i + 1) size' vars' as- ALCons _ a as -> okcall (i + 1) size vars as-- ALProj{} -> mpret OK--- ALConPar as -> __IMPOSSIBLE__-- he size vars e = mmcase e $ \e -> case e of- App _ _ (Var v) _ ->- case remove v vars of- Nothing -> mbret Nothing- Just vars' -> mbret $ Just (size, vars')- App _ _ (Const c) args -> do- cd <- readIORef c- case cdcont cd of- Constructor{} ->- if size == 1 then- mbret Nothing- else- hes (size - 1) vars args- _ -> mbret Nothing- _ -> mbret Nothing- hes size vars as = mmcase as $ \as -> case as of- ALNil -> mbret $ Just (size, vars)- ALCons _ a as ->- mbcase (he size vars a) $ \x -> case x of- Nothing -> mbret Nothing- Just (size', vars') -> hes size' vars' as-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> __IMPOSSIBLE__-- remove _ [] = Nothing- remove x (y : ys) | x == y = Just ys- remove x (y : ys) = case remove x ys of {Nothing -> Nothing; Just ys' -> Just (y : ys')}---- ------------------------------getblks :: MExp o -> IO [Nat]-getblks tt = do- NotB (hntt, blks) <- hnn_blks (Clos [] tt)- case f blks of- Just v -> return [v]- Nothing -> case hntt of- HNApp _ (Const c) args -> do- cd <- readIORef c- case cdcont cd of- Datatype{} -> g [] args- _ -> return []- _ -> return []- where- f blks = case blks of- (_:_) -> case last blks of- HNApp _ (Var v) _ -> Just v- _ -> Nothing- _ -> Nothing- g vs args = do- NotB hnargs <- hnarglist args- case hnargs of- HNALCons _ a as -> do- NotB (_, blks) <- hnn_blks a- let vs' = case f blks of- Just v | v `notElem` vs -> v : vs- _ -> vs- g vs' as- _ -> return vs--- ---------------------------
@@ -1,752 +0,0 @@-{-# LANGUAGE CPP #-}--module Agda.Auto.Convert where--import Agda.Utils.Impossible-#include "../undefined.h"--import Control.Applicative hiding (getConst, Const(..))-import Data.IORef-import Data.Map (Map)-import qualified Data.Map as Map-import Control.Monad.State-import Control.Monad.Error--import qualified Agda.Syntax.Internal as I-import qualified Agda.Syntax.Literal as I-import qualified Agda.Syntax.Common as C-import qualified Agda.Syntax.Abstract.Name as AN-import qualified Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Position as SP-import qualified Agda.TypeChecking.Monad.Base as MB-import Agda.TypeChecking.Monad.Signature (getConstInfo, getDefFreeVars, getImportedSignature)-import Agda.Utils.Permutation (Permutation(Perm), idP, permute, takeP)-import Agda.Interaction.BasicOps (rewrite, Rewrite(..))-import Agda.TypeChecking.Level (reallyUnLevelView)-import Agda.TypeChecking.Monad.Base (mvJudgement, mvPermutation, getMetaInfo, ctxEntry, envContext, clEnv, Judgement(HasType))-import Agda.TypeChecking.Monad.MetaVars (lookupMeta, withMetaInfo)-import Agda.TypeChecking.Monad.Context (getContextArgs)-import Agda.TypeChecking.Monad.Constraints (getAllConstraints)-import Agda.TypeChecking.Substitute (piApply, raise)-import qualified Agda.TypeChecking.Substitute as I (absBody)-import Agda.TypeChecking.Reduce (Normalise, normalise, instantiate)-import Agda.TypeChecking.EtaContract (etaContract)-import Agda.TypeChecking.Primitive (constructorForm)-import Agda.TypeChecking.Free (freeIn)--import Agda.Auto.NarrowingSearch-import Agda.Auto.Syntax--import Agda.Auto.CaseSplit hiding (lift)---norm :: Normalise t => t -> MB.TCM t-norm x = normalise x---norm x = return x--type O = (Maybe Int, AN.QName) -- Nothing - Def, Just npar - Con with npar parameters which don't appear in Agda--data TMode = TMAll -- can be extended to distinguish between different modes (all, only def)- deriving Eq--type MapS a b = (Map a b, [a])-initMapS = (Map.empty, [])-popMapS r w = do (m, xs) <- gets r- case xs of- [] -> return Nothing- (x:xs) -> do- modify (w (m, xs))- return $ Just x--data S = S {sConsts :: MapS AN.QName (TMode, ConstRef O),- sMetas :: MapS I.MetaId (Metavar (Exp O) (RefInfo O), Maybe (MExp O, [MExp O]), [I.MetaId]),- sEqs :: MapS Int (Maybe (Bool, MExp O, MExp O)),- sCurMeta :: Maybe I.MetaId,- sMainMeta :: I.MetaId- }--type TOM = StateT S MB.TCM--tomy :: I.MetaId -> [(Bool, AN.QName)] -> [I.Type] -> MB.TCM ([ConstRef O], [MExp O], Map I.MetaId (Metavar (Exp O) (RefInfo O), MExp O, [MExp O], [I.MetaId]), [(Bool, MExp O, MExp O)], Map AN.QName (TMode, ConstRef O))-tomy imi icns typs = do- eqs <- getEqs- let- r :: [AN.QName] -> TOM [AN.QName]- r projfcns = do- nxt <- popMapS sConsts (\x y -> y {sConsts = x})- case nxt of- Just cn -> do- cmap <- fst `liftM` gets sConsts- let (mode, c) = cmap Map.! cn- def <- lift $ getConstInfo cn- let typ = MB.defType def- defn = MB.theDef def- typ <- lift $ norm typ- typ' <- tomyType typ- let clausesToDef clauses = do- clauses' <- tomyClauses clauses- let narg = case clauses of- [] -> 0- I.Clause {I.clausePats = xs} : _ -> length xs- return (Def narg clauses' Nothing Nothing, [])- (cont, projfcns2) <- case defn of- MB.Axiom {} -> return (Postulate, [])- MB.Function {MB.funClauses = clauses} -> clausesToDef clauses- MB.Primitive {MB.primClauses = Just clauses} -> clausesToDef clauses- MB.Primitive {} -> throwError $ strMsg "Auto: Primitive functions are not supported"- MB.Datatype {MB.dataCons = cons} -> do- cons2 <- mapM (\con -> getConst True con TMAll) cons- return (Datatype cons2 [], [])- MB.Record {MB.recFields = fields, MB.recTel = tel} -> do -- the value of recPars seems unreliable or don't know what it signifies- let pars n (I.El _ (I.Pi it typ)) = C.Arg (C.argHiding it) (C.argRelevance it) (I.Var n []) : pars (n - 1) (I.unAbs typ)- pars _ (I.El _ _) = []- contyp npar I.EmptyTel = I.El (I.mkType 0 {- arbitrary -}) (I.Def cn (pars (npar - 1) typ))- contyp npar (I.ExtendTel it (I.Abs v tel)) = I.El (I.mkType 0 {- arbitrary -}) (I.Pi it (I.Abs v (contyp (npar + 1) tel)))- contyp npar (I.ExtendTel it I.NoAbs{}) = __IMPOSSIBLE__- contyp' <- tomyType $ contyp 0 tel- cc <- lift $ liftIO $ readIORef c- let Datatype [con] [] = cdcont cc- lift $ liftIO $ modifyIORef con (\cdef -> cdef {cdtype = contyp'})-- projfcns <- mapM (\name -> getConst False name TMAll) (map C.unArg fields)-- return (Datatype [con] projfcns, []{-map snd fields-})- MB.Constructor {MB.conData = dt} -> do- _ <- getConst False dt TMAll -- make sure that datatype is included- cc <- lift $ liftIO $ readIORef c- let (Just nomi, _) = cdorigin cc- return (Constructor (nomi - cddeffreevars cc), [])- lift $ liftIO $ modifyIORef c (\cdef -> cdef {cdtype = typ', cdcont = cont})- r $ projfcns2 ++ projfcns- Nothing -> do- nxt <- popMapS sMetas (\x y -> y {sMetas = x})- case nxt of- Just mi -> do- mapM_ (\((_, e, i), eqi) -> do- when (fmExp mi e || fmExp mi i) $ do- (eqsm, eqsl) <- gets sEqs- when (Map.notMember eqi eqsm) $ do- modify $ \s -> s {sEqs = (Map.insert eqi Nothing eqsm, eqi : eqsl)}- ) (zip eqs [0..])- mv <- lift $ lookupMeta mi- msol <- case MB.mvInstantiation mv of- MB.InstV{} ->- lift $ withMetaInfo (getMetaInfo mv) $ do- args <- getContextArgs- --sol <- norm (I.MetaV mi args)- sol <- instantiate (I.MetaV mi args)- return $ Just sol- _ -> return Nothing- case msol of- Nothing -> return ()- Just sol -> do- m <- getMeta mi- sol' <- tomyExp sol- modify $ \s -> s {sEqs = (Map.insert (Map.size (fst $ sEqs s)) (Just (False, Meta m, sol')) (fst $ sEqs s), snd $ sEqs s)}- let HasType _ tt = mvJudgement mv- minfo = getMetaInfo mv- localVars = map (snd . C.unArg . ctxEntry) . envContext . clEnv $ minfo- (targettype, localVars) <- lift $ withMetaInfo minfo $ do- vs <- getContextArgs- let targettype = tt `piApply` permute (takeP (fromIntegral $ length vs) $ mvPermutation mv) vs- targettype <- norm targettype- localVars <- mapM norm localVars- return (targettype, localVars)- modify (\s -> s {sCurMeta = Just mi})- typ' <- tomyType targettype- ctx' <- mapM tomyType localVars- modify (\s -> s {sCurMeta = Nothing})- modify (\s -> s {sMetas = (Map.adjust (\(m, _, deps) -> (m, Just (typ', ctx'), deps)) mi (fst $ sMetas s), snd $ sMetas s)})- r projfcns- Nothing -> do- nxt <- popMapS sEqs (\x y -> y {sEqs = x})- case nxt of- Just eqi -> do- let (ineq, e, i) = eqs !! eqi- e' <- tomyExp e- i' <- tomyExp i- modify (\s -> s {sEqs = (Map.adjust (\_ -> Just (ineq, e', i')) eqi (fst $ sEqs s), snd $ sEqs s)})- r projfcns- Nothing ->- return projfcns- ((icns', typs'), s) <- runStateT- (do _ <- getMeta imi- icns' <- mapM (\(iscon, name) -> getConst iscon name TMAll) icns- typs' <- mapM tomyType typs- projfcns <- r []- projfcns' <- mapM (\name -> getConst False name TMAll) projfcns- [] <- r []- return (projfcns' ++ icns', typs')- ) (S {sConsts = initMapS, sMetas = initMapS, sEqs = initMapS, sCurMeta = Nothing, sMainMeta = imi})- lift $ liftIO $ mapM_ categorizedecl icns'- return (icns', typs', Map.map flatten (fst (sMetas s)), map fromJust $ Map.elems (fst (sEqs s)), fst (sConsts s))- where- flatten (x, Just (y, z), w) = (x, y, z, w)- flatten (x, Nothing, w) = __IMPOSSIBLE__-- fromJust (Just x) = x- fromJust Nothing = __IMPOSSIBLE__--getConst :: Bool -> AN.QName -> TMode -> TOM (ConstRef O)-getConst iscon name mode = do- def <- lift $ getConstInfo name- case MB.theDef def of- MB.Record {MB.recCon = conname} -> do- cmap <- fst `liftM` gets sConsts- case Map.lookup name cmap of- Just (mode', c) ->- if iscon then do- cd <- lift $ liftIO $ readIORef c- let Datatype [con] _ = cdcont cd- return con- else- return c- Nothing -> do- mainm <- gets sMainMeta- dfv <- lift $ getdfv mainm name- let nomi = fromIntegral $ I.arity (MB.defType def)- ccon <- lift $ liftIO $ newIORef (ConstDef {cdname = show name ++ ".CONS", cdorigin = (Just nomi, conname), cdtype = __IMPOSSIBLE__, cdcont = Constructor (nomi - fromIntegral dfv), cddeffreevars = fromIntegral dfv}) -- ?? correct value of deffreevars for records?- c <- lift $ liftIO $ newIORef (ConstDef {cdname = show name, cdorigin = (Nothing, name), cdtype = __IMPOSSIBLE__, cdcont = Datatype [ccon] [], cddeffreevars = fromIntegral dfv}) -- ?? correct value of deffreevars for records?- modify (\s -> s {sConsts = (Map.insert name (mode, c) cmap, name : snd (sConsts s))})- return $ if iscon then ccon else c- _ -> do- cmap <- fst `liftM` gets sConsts- case Map.lookup name cmap of- Just (mode', c) ->- return c- Nothing -> do- (miscon, sname) <- if iscon then do- let MB.Constructor {MB.conPars = npar, MB.conData = dname} = MB.theDef def- return (Just (fromIntegral npar), show dname ++ "." ++ show (I.qnameName name))- else- return (Nothing, show name)- mainm <- gets sMainMeta- dfv <- lift $ getdfv mainm name- c <- lift $ liftIO $ newIORef (ConstDef {cdname = sname, cdorigin = (miscon, name), cdtype = __IMPOSSIBLE__, cdcont = __IMPOSSIBLE__, cddeffreevars = fromIntegral dfv})- modify (\s -> s {sConsts = (Map.insert name (mode, c) cmap, name : snd (sConsts s))})- return c--getdfv mainm name = do- mv <- lookupMeta mainm- withMetaInfo (getMetaInfo mv) $ getDefFreeVars name--getMeta :: I.MetaId -> TOM (Metavar (Exp O) (RefInfo O))-getMeta name = do- mmap <- fst `liftM` gets sMetas- case Map.lookup name mmap of- Just (m, _, _) ->- return m- Nothing -> do- m <- lift $ liftIO initMeta- modify (\s -> s {sMetas = (Map.insert name (m, Nothing, []) mmap, name : snd (sMetas s))})- return m--getEqs :: MB.TCM [(Bool, I.Term, I.Term)]-getEqs = do- eqs <- getAllConstraints- let r = mapM (\eqc -> do- neqc <- norm eqc- case MB.clValue $ MB.theConstraint neqc of- MB.ValueCmp ineq _ i e -> do- ei <- etaContract i- ee <- etaContract e- return [(tomyIneq ineq, ee, ei)]- MB.TypeCmp ineq i e -> do- I.El _ ei <- etaContract i- I.El _ ee <- etaContract e- return [(tomyIneq ineq, ee, ei)]- MB.Guarded (MB.UnBlock _) pid -> return []- _ -> return []- )- eqs' <- r eqs- return $ concat eqs'---tomyClauses [] = return []-tomyClauses (cl:cls) = do- cl' <- tomyClause cl- cls' <- tomyClauses cls- return $ case cl' of- Just cl' -> cl' : cls'- Nothing -> cls'--tomyClause cl@(I.Clause {I.clausePerm = Perm n ps, I.clausePats = pats, I.clauseBody = body}) = do- pats' <- mapM tomyPat pats- body' <- tomyBody body- return $ case body' of- Just (body', _) -> Just (pats', body')- Nothing -> Nothing--tomyPat p = case C.unArg p of- I.VarP n -> return $ PatVar (show n)- I.DotP _ -> return $ PatVar "_" -- because Agda includes these when referring to variables in the body- I.ConP n _ pats -> do- c <- getConst True n TMAll- pats' <- mapM tomyPat pats- def <- lift $ getConstInfo n- cc <- lift $ liftIO $ readIORef c- let Just npar = fst $ cdorigin cc- return $ PatConApp c (replicate npar PatExp ++ pats')- I.LitP _ -> throwError $ strMsg "Auto: Literals in patterns are not supported"--tomyBody (I.Body t) = do- t <- lift $ norm t- t' <- tomyExp t- return $ Just (t', 0)-tomyBody (I.Bind (I.Abs _ b)) = do- res <- tomyBody b- return $ case res of- Nothing -> Nothing- Just (b', i) -> Just (b', i + 1)-tomyBody (I.Bind (I.NoAbs _ b)) = tomyBody b-tomyBody I.NoBody = return Nothing--weaken :: Int -> MExp O -> MExp O-weaken _ e@(Meta m) = e-weaken i (NotM e) =- case e of- App uid okh elr as ->- let elr' = case elr of- Var v -> if v >= i then Var (v + 1) else elr- Const{} -> elr- as' = weakens i as- in NotM $ App uid okh elr' as'- Lam hid (Abs mid t) ->- let t' = weaken (i + 1) t- in NotM $ Lam hid (Abs mid t')- Pi uid hid possdep x (Abs mid y) ->- let x' = weaken i x- y' = weaken (i + 1) y- in NotM $ Pi uid hid possdep x' (Abs mid y')- Sort{} -> NotM e-- AbsurdLambda{} -> NotM e---weakens :: Int -> MArgList O -> MArgList O-weakens _ as@(Meta m) = as-weakens i (NotM as) =- case as of- ALNil -> NotM as- ALCons hid x xs ->- let x' = weaken i x- xs' = weakens i xs- in NotM $ ALCons hid x' xs'-- ALProj{} -> __IMPOSSIBLE__-- ALConPar xs ->- let xs' = weakens i xs- in NotM $ ALConPar xs'---tomyType :: I.Type -> TOM (MExp O)-tomyType (I.El _ t) = tomyExp t -- sort info is thrown away--tomyExp :: I.Term -> TOM (MExp O)-tomyExp (I.Var v as) = do- as' <- tomyExps as- return $ NotM $ App Nothing (NotM OKVal) (Var $ fromIntegral v) as'-tomyExp (I.Lam hid b) = do- b' <- tomyExp (I.absBody b)- return $ NotM $ Lam (cnvh hid) (Abs (Id $ I.absName b) b')-tomyExp t@(I.Lit{}) = do- t <- lift $ constructorForm t- case t of- I.Lit{} -> throwError $ strMsg "Auto: Literals in terms are not supported"- _ -> tomyExp t-tomyExp (I.Level l) = tomyExp =<< lift (reallyUnLevelView l)-tomyExp (I.Def name as) = do- c <- getConst False name TMAll- as' <- tomyExps as- return $ NotM $ App Nothing (NotM OKVal) (Const c) as'-tomyExp (I.Con name as) = do- c <- getConst True name TMAll- as' <- tomyExps as- def <- lift $ getConstInfo name- cc <- lift $ liftIO $ readIORef c- let Just npar = fst $ cdorigin cc- return $ NotM $ App Nothing (NotM OKVal) (Const c) (foldl (\x _ -> NotM $ ALConPar x) as' [1..npar])-tomyExp (I.Pi (C.Arg hid _ x) b) = do- let y = I.absBody b- name = I.absName b- x' <- tomyType x- y' <- tomyType y- return $ NotM $ Pi Nothing (cnvh hid) (Agda.TypeChecking.Free.freeIn 0 y) x' (Abs (Id name) y')-tomyExp (I.Sort (I.Type (I.Max [I.ClosedLevel l]))) = return $ NotM $ Sort $ Set $ fromIntegral l-tomyExp (I.Sort _) = return $ NotM $ Sort UnknownSort-tomyExp t@I.MetaV{} = do- t <- lift $ instantiate t- case t of- I.MetaV mid _ -> do- mcurmeta <- gets sCurMeta- case mcurmeta of- Nothing -> return ()- Just curmeta ->- modify (\s -> s {sMetas = (Map.adjust (\(m, x, deps) -> (m, x, mid : deps)) curmeta (fst $ sMetas s), snd $ sMetas s)})- m <- getMeta mid- return $ Meta m- _ -> tomyExp t-tomyExp (I.DontCare _) = return $ NotM $ dontCare--tomyExps [] = return $ NotM ALNil-tomyExps (C.Arg hid _ a : as) = do- a' <- tomyExp a- as' <- tomyExps as- return $ NotM $ ALCons (cnvh hid) a' as'--tomyIneq MB.CmpEq = False-tomyIneq MB.CmpLeq = True---- -----------------------------------------------fmType :: I.MetaId -> I.Type -> Bool-fmType m (I.El _ t) = fmExp m t--fmExp :: I.MetaId -> I.Term -> Bool-fmExp m (I.Var _ as) = fmExps m as-fmExp m (I.Lam _ b) = fmExp m (I.unAbs b)-fmExp m (I.Lit _) = False-fmExp m (I.Level (I.Max as)) = any (fmLevel m) as-fmExp m (I.Def _ as) = fmExps m as-fmExp m (I.Con _ as) = fmExps m as-fmExp m (I.Pi x y) = fmType m (C.unArg x) || fmType m (I.unAbs y)-fmExp m (I.Sort _) = False-fmExp m (I.MetaV mid _) = mid == m-fmExp m (I.DontCare _) = False--fmExps m [] = False-fmExps m (a : as) = fmExp m (C.unArg a) || fmExps m as--fmLevel :: I.MetaId -> I.PlusLevel -> Bool-fmLevel m I.ClosedLevel{} = False-fmLevel m (I.Plus _ l) = case l of- I.MetaLevel m' _ -> m == m'- I.NeutralLevel v -> fmExp m v- I.BlockedLevel _ v -> fmExp m v- I.UnreducedLevel v -> fmExp m v---- -----------------------------------------------cnvh C.NotHidden = NotHidden-cnvh C.Instance = Instance-cnvh C.Hidden = Hidden-icnvh NotHidden = C.NotHidden-icnvh Instance = C.Instance-icnvh Hidden = C.Hidden---- -----------------------------------------------frommy = frommyExp--frommyType :: MExp O -> ErrorT String IO I.Type-frommyType e = do- e' <- frommyExp e- return $ I.El (I.mkType 0) e' -- 0 is arbitrary, sort not read by Agda when reifying--frommyExp :: MExp O -> ErrorT String IO I.Term-frommyExp (Meta m) = do- bind <- lift $ readIORef $ mbind m- case bind of- Nothing -> throwError "meta not bound"- Just e -> frommyExp (NotM e)-frommyExp (NotM e) =- case e of- App _ _ (Var v) as ->- frommyExps 0 as (I.Var (fromIntegral v) [])- App _ _ (Const c) as -> do- cdef <- lift $ readIORef c- let (iscon, name) = cdorigin cdef- (ndrop, h) = case iscon of {Just n -> (n, I.Con); Nothing -> (0, I.Def)}- frommyExps ndrop as (h name [])- Lam hid (Abs mid t) -> do- t' <- frommyExp t- return $ I.Lam (icnvh hid) (I.Abs (case mid of {NoId -> "x"; Id id -> id}) t')- Pi _ hid _ x (Abs mid y) -> do- x' <- frommyType x- y' <- frommyType y- return $ I.Pi (C.Arg (icnvh hid) C.Relevant x') (I.Abs (case mid of {NoId -> "x"; Id id -> id}) y')- -- maybe have case for Pi where possdep is False which produces Fun (and has to unweaken y), return $ I.Fun (C.Arg (icnvh hid) x') y'- Sort (Set l) ->- return $ I.Sort (I.mkType (fromIntegral l))- Sort Type -> __IMPOSSIBLE__- Sort UnknownSort -> return $ I.Sort (I.mkType 0) -- hoping that it's thrown away-- AbsurdLambda hid ->- return $ I.Lam (icnvh hid) (I.Abs abslamvarname (I.Var 0 []))---frommyExps :: Nat -> MArgList O -> I.Term -> ErrorT String IO I.Term-frommyExps ndrop (Meta m) trm = do- bind <- lift $ readIORef $ mbind m- case bind of- Nothing -> throwError "meta not bound"- Just e -> frommyExps ndrop (NotM e) trm-frommyExps ndrop (NotM as) trm =- case as of- ALNil -> return trm- ALCons _ _ xs | ndrop > 0 -> frommyExps (ndrop - 1) xs trm- ALCons hid x xs -> do- x' <- frommyExp x- frommyExps ndrop xs (addend (C.Arg (icnvh hid) C.Relevant x') trm)-- ALProj eas idx hid xs -> do- idx <- lift $ expandbind idx- c <- case idx of- NotM c -> return c- Meta{} -> throwError "meta not bound"- cdef <- lift $ readIORef c- let name = snd $ cdorigin cdef- trm2 <- frommyExps 0 eas (I.Def name [])- frommyExps 0 xs (addend (C.Arg (icnvh hid) C.Relevant trm) trm2)-- ALConPar xs | ndrop > 0 -> frommyExps (ndrop - 1) xs trm- ALConPar _ -> __IMPOSSIBLE__- where- addend x (I.Var h xs) = I.Var h (xs ++ [x])- addend x (I.Con h xs) = I.Con h (xs ++ [x])- addend x (I.Def h xs) = I.Def h (xs ++ [x])- addend _ _ = __IMPOSSIBLE__---- ----------------------------------abslamvarname = "\0absurdlambda"--modifyAbstractExpr :: A.Expr -> A.Expr-modifyAbstractExpr = f- where- f (A.App i e1 (C.Arg h r (C.Named n e2))) = A.App i (f e1) (C.Arg h r (C.Named n (f e2)))- f (A.Lam i (A.DomainFree h rel n) _) | show n == abslamvarname = A.AbsurdLam i h- f (A.Lam i b e) = A.Lam i b (f e)- f (A.Rec i xs) = A.Rec i (map (\(n, e) -> (n, f e)) xs)- f (A.RecUpdate i e xs) = A.RecUpdate i (f e) (map (\(n, e) -> (n, f e)) xs)- f (A.ScopedExpr i e) = A.ScopedExpr i (f e)- f e = e--modifyAbstractClause :: A.Clause -> A.Clause-modifyAbstractClause (A.Clause lhs (A.RHS e) decls) = A.Clause lhs (A.RHS (modifyAbstractExpr e)) decls-modifyAbstractClause cl = cl---- ------------------------------------constructPats :: Map AN.QName (TMode, ConstRef O) -> I.MetaId -> I.Clause -> MB.TCM ([(FMode, MId)], [CSPat O])-constructPats cmap mainm clause = do- let cnvps ns [] = return (ns, [])- cnvps ns (p : ps) = do- (ns', ps') <- cnvps ns ps- (ns'', p') <- cnvp ns' p- return (ns'', p' : ps')- cnvp ns p =- let hid = cnvh $ C.argHiding p- in case C.unArg p of- I.VarP n -> return ((hid, Id n) : ns, HI hid (CSPatVar $ length ns))- I.ConP c _ ps -> do- (c2, _) <- runStateT (getConst True c TMAll) (S {sConsts = (cmap, []), sMetas = initMapS, sEqs = initMapS, sCurMeta = Nothing, sMainMeta = mainm})- (ns', ps') <- cnvps ns ps- cc <- liftIO $ readIORef c2- let Just npar = fst $ cdorigin cc- return (ns', HI hid (CSPatConApp c2 (replicate npar (HI Hidden CSOmittedArg) ++ ps')))- I.DotP t -> do- (t2, _) <- runStateT (tomyExp t) (S {sConsts = (cmap, []), sMetas = initMapS, sEqs = initMapS, sCurMeta = Nothing, sMainMeta = mainm})- return (ns, HI hid (CSPatExp t2))- _ -> __IMPOSSIBLE__- (names, pats) <- cnvps [] (I.clausePats clause)- return (reverse names, pats)---frommyClause :: (CSCtx O, [CSPat O], Maybe (MExp O)) -> ErrorT String IO I.Clause-frommyClause (ids, pats, mrhs) = do- let ctel [] = return I.EmptyTel- ctel (HI hid (mid, t) : ctx) = do- let Id id = mid- tel <- ctel ctx- t' <- frommyType t- return $ I.ExtendTel (C.Arg (icnvh hid) C.Relevant t') (I.Abs id tel)- tel <- ctel $ reverse ids- let getperms 0 [] perm nv = return (perm, nv)- getperms n [] _ _ = __IMPOSSIBLE__- getperms 0 (p : ps) perm nv = do- (perm, nv) <- getperm p perm nv- getperms 0 ps perm nv- getperms n (HI _ CSPatExp{} : ps) perm nv = getperms (n - 1) ps perm nv- getperms n (HI _ CSOmittedArg{} : ps) perm nv = getperms (n - 1) ps perm nv- getperms n (_ : _) _ _ = __IMPOSSIBLE__- getperm (HI _ p) perm nv =- case p of- --CSPatVar v -> return (length ids + nv - 1 - v : perm, nv)- CSPatVar v -> return ((length ids - 1 - v, nv) : perm, nv + 1)- CSPatConApp c ps -> do- cdef <- lift $ readIORef c- let (Just ndrop, _) = cdorigin cdef- getperms ndrop ps perm nv- CSPatExp e -> return (perm, nv + 1)- _ -> __IMPOSSIBLE__- (rperm, nv) <- getperms 0 pats [] 0- let --perm = reverse rperm- perm = map (\i -> let Just x = lookup i rperm in x) [0..length ids - 1]- --renperm = map (\i -> length ids + nv - 1 - i) rperm- --renm = rename (\i -> renperm !! i)- cnvps 0 [] = return []- cnvps n [] = __IMPOSSIBLE__- cnvps 0 (p : ps) = do- p' <- cnvp p- ps' <- cnvps 0 ps- return (p' : ps')- cnvps n (HI _ CSPatExp{} : ps) = cnvps (n - 1) ps- cnvps n (HI _ CSOmittedArg{} : ps) = cnvps (n - 1) ps- cnvps n (_ : _) = __IMPOSSIBLE__- cnvp (HI hid p) = do- p' <- case p of- CSPatVar v -> return (I.VarP $ let HI _ (Id n, _) = ids !! v in n)- CSPatConApp c ps -> do- cdef <- lift $ readIORef c- let (Just ndrop, name) = cdorigin cdef- ps' <- cnvps ndrop ps- return (I.ConP name Nothing ps')- CSPatExp e -> do- e' <- frommyExp {- renm e -} e -- rename disabled to match (incorrect?) Agda reification of clauses- return (I.DotP e')- CSAbsurd -> __IMPOSSIBLE__ -- CSAbsurd not used- _ -> __IMPOSSIBLE__- return $ C.Arg (icnvh hid) C.Relevant p'- ps <- cnvps 0 pats- body <- case mrhs of- Nothing -> return $ I.NoBody- Just e -> do- e' <- frommyExp {- renm e -} e -- rename disabled to match (incorrect?) Agda reification of clauses- let r 0 = I.Body e'- r n = I.Bind $ I.Abs "h" $ r (n - 1)- e'' = r ({-length ids + -}nv)- return e''- return $ I.Clause SP.noRange tel (Perm (nv{- + length ids-}) perm) ps body--contains_constructor :: [CSPat O] -> Bool-contains_constructor = any f- where- f (HI _ p) = case p of- CSPatConApp{} -> True- _ -> False---etaContractBody :: I.ClauseBody -> MB.TCM I.ClauseBody-etaContractBody (I.NoBody) = return I.NoBody-etaContractBody (I.Body b) = etaContract b >>= \b -> return (I.Body b)-etaContractBody (I.Bind (I.Abs id b)) = etaContractBody b >>= \b -> return (I.Bind (I.Abs id b))-etaContractBody (I.Bind (I.NoAbs x b)) = I.Bind . I.NoAbs x <$> etaContractBody b----- -----------------------------------freeIn :: Nat -> MExp o -> Bool-freeIn = f- where- mr x = let NotM x' = x in x'- f v e = case mr e of- App _ _ elr args -> case elr of- Var v' | v' == v -> False- _ -> fs v args- Lam _ (Abs _ b) -> f (v + 1) b- Pi _ _ _ it (Abs _ ot) -> f v it && f (v + 1) ot- Sort{} -> True-- AbsurdLambda{} -> True--- fs v es = case mr es of- ALNil -> True- ALCons _ a as -> f v a && fs v as-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> fs v as---negtype :: ConstRef o -> MExp o -> MExp o-negtype ee = f 0- where- mr x = let NotM x' = x in x'- f n e = case mr e of- Pi uid hid possdep it (Abs id ot) -> NotM $ Pi uid hid possdep it (Abs id (f (n + 1) ot))- _ -> NotM $ Pi Nothing NotHidden False (NotM $ Pi Nothing NotHidden False e (Abs NoId (NotM $ Pi Nothing NotHidden True (NotM $ Sort (Set 0)) (Abs NoId (NotM $ App Nothing (NotM OKVal) (Var 0) (NotM ALNil)))))) (Abs NoId (NotM $ App Nothing (NotM OKVal) (Const ee) (NotM ALNil)))---- -----------------------------------------findClauseDeep :: I.MetaId -> MB.TCM (Maybe (AN.QName, I.Clause, Bool))-findClauseDeep m = do- sig <- getImportedSignature- let res = do- def <- Map.elems $ MB.sigDefinitions sig- MB.Function{MB.funClauses = cs} <- [MB.theDef def]- c <- cs- unless (peelbinds False findMeta $ I.clauseBody c) []- return (MB.defName def, c, peelbinds __IMPOSSIBLE__ toplevel $ I.clauseBody c)- return $ case res of- [] -> Nothing- r:_ -> Just r -- TODO: with pattern matching lambdas we might get more than one hit, which to choose?- where- peelbinds d f = r- where r b = case b of- I.Bind b -> r $ I.absBody b- I.NoBody -> d- I.Body e -> f e- findMeta e =- case e of- I.Var _ as -> findMetas as- I.Lam _ b -> findMeta (I.absBody b)- I.Lit{} -> False- I.Level (I.Max as) -> any (fmLevel m) as- I.Def _ as -> findMetas as- I.Con _ as -> findMetas as- I.Pi it ot -> findMetat (C.unArg it) || findMetat (I.unAbs ot)- I.Sort{} -> False- I.MetaV m' _ -> m == m'- I.DontCare _ -> False- findMetas = any (findMeta . C.unArg)- findMetat (I.El _ e) = findMeta e- toplevel e =- case e of- I.MetaV{} -> True- _ -> False---- -----------------------------------------matchType :: Integer -> Integer -> I.Type -> I.Type -> Maybe (Nat, Nat) -- Nat is deffreevars of const, Nat is ctx length of target type, left arg is const type, right is target type-matchType cdfv tctx ctyp ttyp = trmodps cdfv ctyp- where- trmodps 0 ctyp = tr 0 0 ctyp- trmodps n ctyp = case ctyp of- I.El _ (I.Pi _ ot) -> trmodps (n - 1) (I.absBody ot)- _ -> __IMPOSSIBLE__- tr narg na ctyp =- case ft 0 0 Just ctyp ttyp of- Just n -> Just (n, narg)- Nothing -> case ctyp of- I.El _ (I.Pi _ (I.Abs _ ot)) -> tr (narg + 1) (na + 1) ot- I.El _ (I.Pi _ (I.NoAbs _ ot)) -> tr (narg + 1) na ot- _ -> Nothing- where- ft nl n c (I.El _ e1) (I.El _ e2) = f nl n c e1 e2- f nl n c e1 e2 = case e1 of- I.Var v1 as1 | v1 < nl -> case e2 of- I.Var v2 as2 | v1 == v2 -> fs nl (n + 1) c as1 as2- _ -> Nothing- I.Var v1 _ | v1 < nl + na -> c n -- unify vars with no args?- I.Var v1 as1 -> case e2 of- I.Var v2 as2 | cdfv + na + nl - v1 == tctx + nl - v2 -> fs nl (n + 1) c as1 as2- _ -> Nothing- _ -> case (e1, e2) of- (I.MetaV{}, _) -> c n- (_, I.MetaV{}) -> c n- (I.Lam hid1 b1, I.Lam hid2 b2) | hid1 == hid2 -> f (nl + 1) n c (I.absBody b1) (I.absBody b2)- (I.Lit lit1, I.Lit lit2) | lit1 == lit2 -> c (n + 1)- (I.Def n1 as1, I.Def n2 as2) | n1 == n2 -> fs nl (n + 1) c as1 as2- (I.Con n1 as1, I.Con n2 as2) | n1 == n2 -> fs nl (n + 1) c as1 as2- (I.Pi (C.Arg hid1 rel1 it1) ot1, I.Pi (C.Arg hid2 rel2 it2) ot2) | hid1 == hid2 -> ft nl n (\n -> ft (nl + 1) n c (I.absBody ot1) (I.absBody ot2)) it1 it2- (I.Sort{}, I.Sort{}) -> c n -- sloppy- _ -> Nothing- fs nl n c es1 es2 = case (es1, es2) of- ([], []) -> c n- (C.Arg hid1 rel1 e1 : es1, C.Arg hid2 rel2 e2 : es2) | hid1 == hid2 -> f nl n (\n -> fs nl n c es1 es2) e1 e2- _ -> Nothing
@@ -1,614 +0,0 @@-{-# LANGUAGE UndecidableInstances, Rank2Types,- ExistentialQuantification, MultiParamTypeClasses,- FunctionalDependencies, FlexibleInstances,- ScopedTypeVariables, CPP #-}--module Agda.Auto.NarrowingSearch where--import Agda.Utils.Impossible-#include "../undefined.h"--import Data.IORef hiding (writeIORef, modifyIORef)-import qualified Data.IORef as NoUndo (writeIORef, modifyIORef)-import Control.Monad.State---type Prio = Int--class Trav a blk | a -> blk where- traverse :: Monad m => (forall b . Trav b blk => MM b blk -> m ()) -> a -> m ()--instance Trav a blk => Trav (MM a blk) blk where- traverse f me = f me--data Term blk = forall a . Trav a blk => Term a--data Prop blk = OK- | Error String- | forall a . AddExtraRef String (Metavar a blk) (Int, RefCreateEnv blk a)- | And (Maybe [Term blk]) (MetaEnv (PB blk)) (MetaEnv (PB blk))- | Sidecondition (MetaEnv (PB blk)) (MetaEnv (PB blk)) -- first arg is sidecondition- | Or Prio (MetaEnv (PB blk)) (MetaEnv (PB blk))- | ConnectHandle (OKHandle blk) (MetaEnv (PB blk))--data OKVal = OKVal-type OKHandle blk = MM OKVal blk-type OKMeta blk = Metavar OKVal blk-data Metavar a blk = Metavar- {mbind :: IORef (Maybe a),- mprincipalpresent :: IORef Bool,- mobs :: IORef [(QPB a blk, Maybe (CTree blk))],- mcompoint :: IORef [SubConstraints blk],- mextrarefs :: IORef [(Int, RefCreateEnv blk a)]--- }--hequalMetavar :: Metavar a1 blk1 -> Metavar a2 bkl2 -> Bool-hequalMetavar m1 m2 = mprincipalpresent m1 == mprincipalpresent m2--instance Eq (Metavar a blk) where- x == y = hequalMetavar x y--newMeta :: IORef [SubConstraints blk] -> IO (Metavar a blk)-newMeta mcompoint = do- bind <- newIORef Nothing- pp <- newIORef False- obs <- newIORef []- erefs <- newIORef []- return $ Metavar bind pp obs mcompoint erefs--initMeta :: IO (Metavar a blk)-initMeta = do- cp <- newIORef []- newMeta cp--data CTree blk = CTree- {ctpriometa :: IORef (PrioMeta blk),- ctsub :: IORef (Maybe (SubConstraints blk)),- ctparent :: IORef (Maybe (CTree blk)), -- Nothing - root- cthandles :: IORef [OKMeta blk]- }--data SubConstraints blk = SubConstraints- {scflip :: IORef Bool,- sccomcount :: IORef Int,- scsub1 :: CTree blk,- scsub2 :: CTree blk- }---newCTree :: Maybe (CTree blk) -> IO (CTree blk)-newCTree parent = do- priometa <- newIORef (NoPrio False)- sub <- newIORef Nothing- rparent <- newIORef parent- handles <- newIORef []- return $ CTree priometa sub rparent handles--newSubConstraints :: CTree blk -> IO (SubConstraints blk)-newSubConstraints node = do- flip <- newIORef True -- False -- initially (and always) True, trying out prefer rightmost subterm when none have priority- comcount <- newIORef 0- sub1 <- newCTree $ Just node- sub2 <- newCTree $ Just node- return $ SubConstraints flip comcount sub1 sub2---data PrioMeta blk = forall a . Refinable a blk => PrioMeta Prio (Metavar a blk)- | NoPrio Bool -- True if subconstraint is done (all OK)--instance Eq (PrioMeta blk) where- NoPrio d1 == NoPrio d2 = d1 == d2- PrioMeta p1 m1 == PrioMeta p2 m2 = p1 == p2 && hequalMetavar m1 m2- _ == _ = False---- -------------------------data Restore = forall a . Restore (IORef a) a--type Undo = StateT [Restore] IO--ureadIORef :: IORef a -> Undo a-ureadIORef ptr = lift $ readIORef ptr--uwriteIORef :: IORef a -> a -> Undo ()-uwriteIORef ptr newval = do- oldval <- ureadIORef ptr- modify (Restore ptr oldval :)- lift $ NoUndo.writeIORef ptr newval--umodifyIORef :: IORef a -> (a -> a) -> Undo ()-umodifyIORef ptr f = do- oldval <- ureadIORef ptr- modify (Restore ptr oldval :)- lift $ NoUndo.writeIORef ptr (f oldval)--ureadmodifyIORef :: IORef a -> (a -> a) -> Undo a-ureadmodifyIORef ptr f = do- oldval <- ureadIORef ptr- modify (Restore ptr oldval :)- lift $ NoUndo.writeIORef ptr (f oldval)- return oldval--runUndo :: Undo a -> IO a-runUndo x = do- (res, restores) <- runStateT x []- mapM_ (\(Restore ptr oldval) -> NoUndo.writeIORef ptr oldval) restores- return res---- --------------------------type RefCreateEnv blk = StateT ( ( (IORef [SubConstraints blk])), Int) IO--data Pair a b = Pair a b--class Refinable a blk | a -> blk where- refinements :: blk -> [blk] -> Metavar a blk -> IO [(Int, RefCreateEnv blk a)]---newPlaceholder :: RefCreateEnv blk (MM a blk)-newPlaceholder = do- (e@( ( mcompoint)), c) <- get- m <- lift $ newMeta mcompoint- put (e, (c + 1))- return $ Meta m--newOKHandle :: RefCreateEnv blk (OKHandle blk)-newOKHandle = do- (e@( ( _)), c) <- get- cp <- lift $ newIORef []- m <- lift $ newMeta cp- put (e, (c + 1))- return $ Meta m--dryInstantiate :: RefCreateEnv blk a -> IO a-dryInstantiate bind = evalStateT bind ( ( __IMPOSSIBLE__), 0)--type BlkInfo blk = (Bool, Prio, Maybe blk) -- Bool - is principal--data MM a blk = NotM a- | Meta (Metavar a blk)--type MetaEnv = IO---data MB a blk = NotB a- | forall b . Refinable b blk => Blocked (Metavar b blk) (MetaEnv (MB a blk))- | Failed String--data PB blk = NotPB (Prop blk)- | forall b . Refinable b blk => PBlocked (Metavar b blk) (BlkInfo blk) (MetaEnv (PB blk))- | forall b1 b2 . (Refinable b1 blk, Refinable b2 blk) => PDoubleBlocked (Metavar b1 blk) (Metavar b2 blk) (MetaEnv (PB blk))--data QPB b blk = QPBlocked (BlkInfo blk) (MetaEnv (PB blk))- | QPDoubleBlocked (IORef Bool) (MetaEnv (PB blk)) -- flag set True by first observer that continues--mmcase :: Refinable a blk => MM a blk -> (a -> MetaEnv (MB b blk)) -> MetaEnv (MB b blk)-mmcase x f = case x of- NotM x -> f x- x@(Meta m) -> do- bind <- readIORef $ mbind m- case bind of- Just x -> f x- Nothing -> return $ Blocked m (mmcase x f)--mmmcase :: Refinable a blk => MM a blk -> MetaEnv (MB b blk) -> (a -> MetaEnv (MB b blk)) -> MetaEnv (MB b blk)-mmmcase x fm f = case x of- NotM x -> f x- Meta m -> do- bind <- readIORef $ mbind m- case bind of- Just x -> f x- Nothing -> fm--mmpcase :: Refinable a blk => BlkInfo blk -> MM a blk -> (a -> MetaEnv (PB blk)) -> MetaEnv (PB blk)-mmpcase blkinfo x f = case x of- NotM x -> f x- x@(Meta m) -> do- bind <- readIORef $ mbind m- case bind of- Just x -> f x- Nothing -> return $ PBlocked m blkinfo (mmpcase __IMPOSSIBLE__ x f) -- blkinfo not needed because will be notb next time--doubleblock :: (Refinable a blk, Refinable b blk) => MM a blk -> MM b blk -> MetaEnv (PB blk) -> MetaEnv (PB blk)-doubleblock (Meta m1) (Meta m2) cont = return $ PDoubleBlocked m1 m2 cont-doubleblock _ _ _ = __IMPOSSIBLE__--mbcase :: MetaEnv (MB a blk) -> (a -> MetaEnv (MB b blk)) -> MetaEnv (MB b blk)-mbcase x f = do- x' <- x- case x' of- NotB x -> f x- Blocked m x -> return $ Blocked m (mbcase x f)- Failed msg -> return $ Failed msg--mbpcase :: Prio -> Maybe blk -> MetaEnv (MB a blk) -> (a -> MetaEnv (PB blk)) -> MetaEnv (PB blk)-mbpcase prio bi x f = do- x' <- x- case x' of- NotB x -> f x- Blocked m x -> return $ PBlocked m (False, prio, bi) (mbpcase prio bi x f)- Failed msg -> return $ NotPB $ Error msg--mmbpcase :: MetaEnv (MB a blk) -> (forall b . Refinable b blk => MM b blk -> MetaEnv (PB blk)) -> (a -> MetaEnv (PB blk)) -> MetaEnv (PB blk)-mmbpcase x fm f = do- x' <- x- case x' of- NotB x -> f x- Blocked m x -> fm (Meta m)- Failed msg -> return $ NotPB $ Error msg--waitok :: OKHandle blk -> MetaEnv (MB b blk) -> MetaEnv (MB b blk)-waitok okh f =- mmcase okh $ \b -> case b of -- principle constraint is never present for okhandle so it will not be refined- OKVal -> f--mbret :: a -> MetaEnv (MB a blk)-mbret x = return $ NotB x--mbfailed :: String -> MetaEnv (MB a blk)-mbfailed msg = return $ Failed msg--mpret :: Prop blk -> MetaEnv (PB blk)-mpret p = return $ NotPB p--expandbind :: MM a blk -> MetaEnv (MM a blk)-expandbind x = case x of- NotM{} -> return x- Meta m -> do- bind <- readIORef $ mbind m- case bind of- Just x -> return $ NotM x- Nothing -> return x----- -------------------------type HandleSol = IO ()---type SRes = Either Bool Int--topSearch :: forall blk . IORef Int -> IORef Int -> HandleSol -> blk -> MetaEnv (PB blk) -> Int -> Int -> IO Bool-topSearch ticks nsol hsol envinfo p searchdepth depthinterval = do- depthreached <- newIORef False--- mainroot <- newCTree Nothing-- let- searchSubProb :: [(CTree blk, Maybe (IORef Bool))] -> Int -> IO SRes- searchSubProb [] depth = do- when (depth < depthinterval) $ do--- hsol- n <- readIORef nsol- NoUndo.writeIORef nsol $! n - 1--- return $ Left True- searchSubProb ((root, firstdone) : restprobs) depth =- let- search :: Int -> IO SRes- search depth = do- pm <- readIORef $ ctpriometa root- case pm of- NoPrio False -> return $ Left False -- nothing to refine but not done, this can happen when eq constraints are passed along with main constraint in agdaplugin- NoPrio True ->- searchSubProb restprobs depth -- ?? what should depth be- PrioMeta _ m -> do- let carryon = fork m depth- sub <- readIORef $ ctsub root- case sub of- Nothing -> carryon- Just sc -> do- let sub1 = scsub1 sc- sub2 = scsub2 sc- pm1 <- readIORef $ ctpriometa sub1- pm2 <- readIORef $ ctpriometa sub2- let split = carryon -- split disabled- case pm1 of- NoPrio True -> split- _ ->- case pm2 of- NoPrio True -> split- _ -> do- comc <- readIORef $ sccomcount sc- case comc of- 0 -> split- _ -> carryon-- fork :: Refinable a blk => Metavar a blk -> Int -> IO SRes- fork m depth = do- blkinfos <- extractblkinfos m- refs <- refinements envinfo blkinfos m- f refs- where- f [] = do- erefs <- readIORef $ mextrarefs m- case erefs of- [] -> return (Left False)- _ -> do- NoUndo.writeIORef (mextrarefs m) []- f erefs- f ((cost, bind) : binds) = hsres (refine m bind (depth - cost) ) (f binds)- hsres :: IO SRes -> IO SRes -> IO SRes- hsres x1 x2 = do- res <- x1- case res of- Right _ -> return res- Left found -> do- n <- readIORef nsol- if n == 0 then- return res- else do- res2 <- x2- case res2 of- Right _ -> if found then __IMPOSSIBLE__ else return res2- Left found2 -> return $ Left (found || found2)-- refine :: Metavar a blk -> RefCreateEnv blk a -> Int -> IO SRes-- refine _ _ depthleft | depthleft < 0 = do- NoUndo.writeIORef depthreached True- return $ Left False--- refine m bind depthleft = runUndo $- do t <- ureadIORef ticks- lift $ NoUndo.writeIORef ticks $! t + 1--- (bind, (_, nnewmeta)) <- lift $ runStateT bind ( ( (mcompoint m)), 0)- uwriteIORef (mbind m) (Just bind)- mcomptr <- ureadIORef $ mcompoint m- mapM_ (\comptr ->- umodifyIORef (sccomcount comptr) (+ (nnewmeta - 1))- -- umodifyIORef (scflip comptr) not -- don't flip now since trying prefer rightmost subterm if non have prio- ) mcomptr- obs <- ureadIORef (mobs m)- res <- recalcs obs- case res of- True -> -- failed- return $ Left False- False -> lift $ search depthleft -- succeeded-- doit = do- res <- search depth- return $ case res of- Right n ->- case firstdone of- Nothing ->- if n == 0 then- Left False- else- Right (n - 1)- Just _ ->- Right (n + 1)- res@(Left True) -> res- res@(Left False) ->- case firstdone of- Nothing -> res- Just _ -> Right 0- in- case firstdone of- Nothing -> doit- Just rdone -> do- done <- readIORef rdone- if done then- searchSubProb restprobs depth- else do- NoUndo.writeIORef rdone True- doit-- runUndo $ do- res <- reccalc p (Just mainroot)- case res of- True -> -- failed immediately- return False- False -> do- Left solfound <- lift $ searchSubProb [(mainroot, Nothing)] searchdepth- dr <- lift $ readIORef depthreached- return dr--extractblkinfos :: Metavar a blk -> IO [blk]-extractblkinfos m = do- obs <- readIORef $ mobs m- return $ f obs- where- f [] = []- f ((QPBlocked (_,_,mblkinfo) _, _) : cs) =- case mblkinfo of- Nothing -> f cs- Just blkinfo -> blkinfo : f cs- f ((QPDoubleBlocked{}, _) : cs) = f cs--recalcs :: [(QPB a blk, Maybe (CTree blk))] -> Undo Bool-recalcs [] = return False-recalcs (c : cs) = seqc (recalc c) (recalcs cs)--seqc :: Undo Bool -> Undo Bool -> Undo Bool-seqc x y = do- res1 <- x- case res1 of- res1@True -> return res1- False -> y--recalc :: (QPB a blk, Maybe (CTree blk)) -> Undo Bool-recalc (con, node) =- case con of- QPBlocked _ cont -> reccalc cont node- QPDoubleBlocked flag cont -> do- fl <- ureadIORef flag- if fl then- return False- else do- uwriteIORef flag True- reccalc cont node--reccalc :: MetaEnv (PB blk) -> Maybe (CTree blk) -> Undo Bool-reccalc cont node = do- res <- calc cont node- case res of- Nothing -> return True- Just pendhandles ->- foldM (\res1 h ->- case res1 of- True -> return res1- False -> do--- uwriteIORef (mbind h) $ Just OKVal- obs <- ureadIORef (mobs h)- recalcs obs- ) False pendhandles--calc :: forall blk . MetaEnv (PB blk) -> Maybe (CTree blk) -> Undo (Maybe [OKMeta blk])-calc cont node = do- res <- donewp node cont- case res of- Just (_, pendhandles) -> do- pendhandles2 <- case node of- Just node -> propagatePrio node- Nothing -> return []- return $ Just (pendhandles ++ pendhandles2)- Nothing -> return Nothing- where- storeprio (Just node) pm pendhandles = do- pendhandles' <- case pm of- NoPrio True -> do- handles <- ureadIORef (cthandles node)- return $ handles ++ pendhandles- _ -> return pendhandles- uwriteIORef (ctpriometa node) pm- return $ Just (pm, pendhandles')- storeprio Nothing _ _ =- return $ Just (NoPrio False, [])- donewp node p = do- bp <- lift p- case bp of- NotPB p ->- doprop node p- PBlocked m blkinfo cont -> do- oldobs <- ureadmodifyIORef (mobs m) ((QPBlocked blkinfo cont, node) :)- let (princ, prio, _) = blkinfo- pp <- ureadIORef (mprincipalpresent m)- when (princ && not pp) $ do- uwriteIORef (mprincipalpresent m) True- mapM_ (\(qpb, node) -> case node of- Just node ->- case qpb of- QPBlocked (_, prio, _) _ -> do--- uwriteIORef (ctpriometa node) (PrioMeta prio m)- propagatePrio node- QPDoubleBlocked flag _ ->- return []- Nothing -> return []- ) oldobs- if pp || princ then- storeprio node (PrioMeta prio m) []- else- storeprio node (NoPrio False) []- PDoubleBlocked m1 m2 cont -> do- flag <- lift $ newIORef False- let newobs = ((QPDoubleBlocked flag cont, node) :)- umodifyIORef (mobs m1) newobs- umodifyIORef (mobs m2) newobs- storeprio node (NoPrio False) []- doprop node p =- case p of- OK -> storeprio node (NoPrio True) []- Error _ -> return Nothing--- AddExtraRef _ m eref -> do- lift $ NoUndo.modifyIORef (mextrarefs m) (eref :)- return Nothing- And coms p1 p2 -> do- let Just jnode = node- sc <- lift $ newSubConstraints jnode--- uwriteIORef (ctsub jnode) $ Just sc- ndep <- case coms of- Nothing -> return 1 -- no metas pointing to it so will never decrement to 0- Just coms -> return 1 -- dito- lift $ NoUndo.writeIORef (sccomcount sc) ndep -- OK since sc was just created- resp1 <- donewp (Just $ scsub1 sc) p1- case resp1 of- Just (pm1, phs1) -> do- resp2 <- donewp (Just $ scsub2 sc) p2- case resp2 of- Just (pm2, phs2) ->- storeprio node (choosePrioMeta False pm1 pm2) (phs1 ++ phs2)- resp2@Nothing -> return resp2- resp1@Nothing -> return resp1- Sidecondition sidep mainp -> do- resp1 <- donewp Nothing sidep- case resp1 of- Just{} -> do- resp2 <- donewp node mainp- case resp2 of- Just (pm2, phs2) ->- storeprio node pm2 phs2- resp2@Nothing -> return resp2- resp1@Nothing -> return resp1- Or prio p1 p2 -> do- cm <- lift $ initMeta- donewp node (choose (Meta cm) prio p1 p2)- ConnectHandle (Meta handle) p' -> do- let Just jnode = node- umodifyIORef (cthandles jnode) (handle :)- donewp node p'- ConnectHandle (NotM _) _ -> __IMPOSSIBLE__--choosePrioMeta :: Bool -> PrioMeta blk -> PrioMeta blk -> PrioMeta blk-choosePrioMeta flip pm1@(PrioMeta p1 _) pm2@(PrioMeta p2 _) = if p1 > p2 then pm1 else if p2 > p1 then pm2 else if flip then pm2 else pm1-choosePrioMeta _ pm@(PrioMeta _ _) (NoPrio _) = pm-choosePrioMeta _ (NoPrio _) pm@(PrioMeta _ _) = pm-choosePrioMeta _ (NoPrio d1) (NoPrio d2) = NoPrio (d1 && d2)--propagatePrio :: CTree blk -> Undo [OKMeta blk]-propagatePrio node = do- parent <- lift $ readIORef $ ctparent node- case parent of- Nothing -> return []- Just parent -> do- Just sc <- ureadIORef (ctsub parent)- pm1 <- ureadIORef $ ctpriometa $ scsub1 sc- pm2 <- ureadIORef $ ctpriometa $ scsub2 sc- flip <- ureadIORef $ scflip sc- let pm = choosePrioMeta flip pm1 pm2- opm <- ureadIORef (ctpriometa parent)- if (not (pm == opm)) then do- uwriteIORef (ctpriometa parent) pm- phs <- case pm of- NoPrio True -> ureadIORef (cthandles parent)- _ -> return []- phs2 <- propagatePrio parent- return $ phs ++ phs2- else- return []--data Choice = LeftDisjunct | RightDisjunct--choose :: MM Choice blk -> Prio -> MetaEnv (PB blk) -> MetaEnv (PB blk) -> MetaEnv (PB blk)-choose c prio p1 p2 =- mmpcase (True, prio, Nothing) c $ \c -> case c of- LeftDisjunct -> p1- RightDisjunct -> p2--instance Refinable Choice blk where- refinements _ x _ = return [(0, return LeftDisjunct), (0, return RightDisjunct)]---instance Refinable OKVal blk where- refinements _ _ _ = __IMPOSSIBLE__ -- OKVal should never be refined----- ------------------------------------
@@ -1,362 +0,0 @@-{-# LANGUAGE UndecidableInstances, MultiParamTypeClasses,- TypeSynonymInstances, FlexibleInstances, CPP #-}--module Agda.Auto.SearchControl where--import Agda.Utils.Impossible-#include "../undefined.h"--import Control.Monad-import Data.IORef-import Control.Monad.State-import Data.Maybe (mapMaybe)--import Agda.Auto.NarrowingSearch-import Agda.Auto.Syntax---instance Refinable (ArgList o) (RefInfo o) where- refinements _ infos _ =- return $ [- (0, return ALNil),-- (0, cons NotHidden),- (0, cons Hidden)--- ]-- ++- (let isdep = rr infos- rr (RICheckElim isdep : _) = isdep- rr (_ : xs) = rr xs- rr _ = __IMPOSSIBLE__- proj hid = newPlaceholder >>= \p1 -> newPlaceholder >>= \p2 -> newPlaceholder >>= \p3 -> return $ ALProj p1 p2 hid p3- in if isdep then- []- else-- [(0, proj NotHidden), (0, proj Hidden)]--- )-- where cons hid = newPlaceholder >>= \p1 -> newPlaceholder >>= \p2 -> return $ ALCons hid p1 p2---data ExpRefInfo o = ExpRefInfo {eriMain :: Maybe (RefInfo o), eriUnifs :: [RefInfo o], eriInfTypeUnknown, eriIsEliminand :: Bool, eriUsedVars :: Maybe ([UId o], [Elr o]),- eriIotaStep :: Maybe Bool, eriPickSubsVar :: Bool-- , eriEqRState :: Maybe EqReasoningState-- }--getinfo = f (ExpRefInfo {eriMain = Nothing, eriUnifs = [], eriInfTypeUnknown = False, eriIsEliminand = False, eriUsedVars = Nothing,- eriIotaStep = Nothing, eriPickSubsVar = False-- , eriEqRState = Nothing-- })- where- f i [] = i- f i (x@RIMainInfo{} : xs) = f (i {eriMain = Just x}) xs- f i (x@RIUnifInfo{} : xs) = f (i {eriUnifs = x : eriUnifs i}) xs- f i (RIInferredTypeUnknown : xs) = f (i {eriInfTypeUnknown = True}) xs- f i (RINotConstructor : xs) = f (i {eriIsEliminand = True}) xs- f i (RIUsedVars nuids nused : xs) = f (i {eriUsedVars = Just (nuids, nused)}) xs- f i (RIIotaStep semif : xs) = f (i {eriIotaStep = Just (semif || maybe False id (eriIotaStep i))}) xs- f i (RIPickSubsvar : xs) = f (i {eriPickSubsVar = True}) xs-- f i (RIEqRState s : xs) = f (i {eriEqRState = Just s}) xs-- f i _ = __IMPOSSIBLE__---univar :: [CAction o] -> Nat -> Maybe Nat-univar cl v = f cl v 0- where- f [] v v' = Just (v' + v)- f (Weak n : _) v v' | v < n = Nothing- f (Weak n : xs) v v' = f xs (v - n) v'- f (Sub _ : xs) v v' = f xs v (v' + 1)- f (Skip : _) 0 v' = Just v'- f (Skip : xs) v v' = f xs (v - 1) (v' + 1)--subsvars :: [CAction o] -> [Nat]-subsvars = f 0- where- f n [] = []- f n (Weak _ : xs) = f n xs- f n (Sub _ : xs) = n : f (n + 1) xs- f n (Skip : xs) = f (n + 1) xs---instance Refinable (Exp o) (RefInfo o) where- refinements envinfo infos meta =- let- hints = rieHints envinfo- deffreevars = rieDefFreeVars envinfo-- meqr = rieEqReasoningConsts envinfo-- ExpRefInfo {eriMain = Just (RIMainInfo n tt iotastepdone), eriUnifs = unis, eriInfTypeUnknown = inftypeunknown, eriIsEliminand = iseliminand, eriUsedVars = Just (uids, usedvars),- eriIotaStep = iotastep, eriPickSubsVar = picksubsvar-- , eriEqRState = meqrstate-- } = getinfo infos-- eqrstate = maybe EqRSNone id meqrstate-- app muid elr = do p <- newPlaceholder- p <- case elr of- Var{} -> return p- Const c -> do- cd <- lift $ readIORef c- let dfvapp 0 _ = p- dfvapp i n = NotM $ ALCons NotHidden (NotM $ App Nothing (NotM $ OKVal) (Var n) (NotM ALNil)) (dfvapp (i - 1) (n - 1))- -- NotHidden is ok because agda reification throws these arguments away and agsy skips typechecking them- return $ dfvapp (cddeffreevars cd) (n - 1)-- okh <- newOKHandle- let uid = case muid of- Just _ -> muid- Nothing -> Just meta- return $ App uid okh elr p- lam hid id = do- p <- newPlaceholder- return $ Lam hid (Abs id p)- pi muid dep hid =- do p1 <- newPlaceholder- p2 <- newPlaceholder- let uid = case muid of- Just _ -> muid- Nothing -> Just meta- return $ Pi uid hid dep p1 (Abs NoId p2)- set l = return $ Sort (Set l)- in case unis of- [] ->- let-- eqr = maybe __IMPOSSIBLE__ id meqr- foldargs [] = NotM ALNil- foldargs ((h, a) : xs) = NotM $ ALCons h a (foldargs xs)- eq_begin_step_step = (costEqStep,- do psb <- replicateM 4 newPlaceholder- okhb <- newOKHandle- pss1 <- replicateM 6 newPlaceholder- okhs1 <- newOKHandle- pss2 <- replicateM 7 newPlaceholder- okhs2 <- newOKHandle- return $ App (Just meta) okhb (Const $ eqrcBegin eqr) (foldargs (zip [Hidden, Hidden, Hidden, Hidden, NotHidden] (psb ++ [- NotM $ App (Just meta) okhs1 (Const $ eqrcStep eqr) (foldargs (zip [Hidden, Hidden, NotHidden, Hidden, Hidden, NotHidden, NotHidden] (pss1 ++ [- NotM $ App (Just meta) okhs2 (Const $ eqrcStep eqr) (foldargs (zip [Hidden, Hidden, NotHidden, Hidden, Hidden, NotHidden, NotHidden] pss2))- ])))- ])))- )- eq_step = (costEqStep,- do ps <- replicateM 7 newPlaceholder- okh <- newOKHandle- return $ App (Just meta) okh (Const $ eqrcStep eqr) (foldargs (zip [Hidden, Hidden, NotHidden, Hidden, Hidden, NotHidden, NotHidden] ps))- )- eq_end = (costEqEnd,- do ps <- replicateM 3 newPlaceholder- okh <- newOKHandle- return $ App (Just meta) okh (Const $ eqrcEnd eqr) (foldargs (zip [Hidden, Hidden, NotHidden] ps))- )- eq_sym = (costEqSym,- do ps <- replicateM 5 newPlaceholder- okh <- newOKHandle- return $ App (Just meta) okh (Const $ eqrcSym eqr) (foldargs (zip [Hidden, Hidden, Hidden, Hidden, NotHidden] ps))- )- eq_cong = (costEqCong,- do ps <- replicateM 8 newPlaceholder- okh <- newOKHandle- return $ App (Just meta) okh (Const $ eqrcCong eqr) (foldargs (zip [Hidden, Hidden, Hidden, Hidden, NotHidden, Hidden, Hidden, NotHidden] ps))- )-- pcav i = if inftypeunknown then costInferredTypeUnkown else i- pc i = pcav i- varcost v | v < n - deffreevars = pcav (case Just usedvars of {Just usedvars -> if elem v (mapMaybe (\x -> case x of {Var v -> Just v; Const{} -> Nothing}) usedvars) then costAppVarUsed else costAppVar; Nothing -> if picksubsvar then costAppVar else costAppVarUsed})- varcost v | otherwise = pcav costAppHint- varapps = map (\v ->- (varcost v,- app Nothing (Var v)- )) [0..n - 1]- hintapps = map (\(c, hm) ->- (cost c hm,- app Nothing (Const c)- )) hints- where cost c hm = pc (case iotastep of- Just _ -> costIotaStep- Nothing -> if elem c (mapMaybe (\x -> case x of {Var{} -> Nothing; Const c -> Just c}) usedvars) then- case hm of {HMNormal -> costAppHintUsed; HMRecCall -> costAppRecCallUsed}- else- case hm of {HMNormal -> costAppHint; HMRecCall -> costAppRecCall})- generics = varapps ++ hintapps- in case tt of-- _ | eqrstate == EqRSChain ->- return $ [eq_end, eq_step]-- HNPi _ hid possdep _ (Abs id _) -> return $ (pc (if iotastepdone then costLamUnfold else costLam), lam hid id) : (costAbsurdLam, return $ AbsurdLambda hid) : generics-- HNSort (Set l) -> return $ map (\l -> (pc costSort, set l)) [0..l - 1] ++ [(pc costPi, pi Nothing True NotHidden), (pc costPi, pi Nothing True Hidden)] ++ generics--- HNApp _ (Const c) _ -> do- cd <- readIORef c- return $ case cdcont cd of- Datatype cons _-- | eqrstate == EqRSNone-- -> map (\c -> (pc (case iotastep of {Just True -> costUnification; _ -> if length cons <= 1 then costAppConstructorSingle else costAppConstructor}), app Nothing (Const c))) cons ++- generics-- ++ if maybe False (\eqr -> c == eqrcId eqr) meqr then [eq_sym, eq_cong, eq_begin_step_step] else []- _ | eqrstate == EqRSPrf1 -> generics ++ [eq_sym, eq_cong]- _ | eqrstate == EqRSPrf2 -> generics ++ [eq_cong]-- _ -> generics- _ -> return generics- (RIUnifInfo cl hne : _) ->- let- subsvarapps = map (\v ->- (costUnification,- app Nothing (Var v)- )) (subsvars cl)- mlam = case tt of- HNPi _ hid _ _ (Abs id _) -> [(costUnification, lam hid id)]- _ -> []- generics = mlam ++ subsvarapps-- pickuid seenuids =- case f seenuids of- Just uid -> (uid, True)- Nothing -> (head seenuids, False) -- ?? which uid to pick- where f [] = Nothing- f (Nothing:_) = Just Nothing- f (Just u:us) = if elem u uids then f us else Just (Just u)- in- return $ case hne of- HNApp seenuids (Var v) _ ->- let (uid, isunique) = pickuid seenuids- uni = case univar cl v of- Just v | v < n -> [(if isunique then costUnification else costUnificationOccurs, app uid (Var v))]- _ -> []- in uni ++ generics- HNApp seenuids (Const c) _ ->- let (uid, isunique) = pickuid seenuids- in (if isunique then costUnification else costUnificationOccurs, app uid (Const c)) : generics- HNLam{} -> generics- HNPi seenuids hid possdep _ _ ->- let (uid, isunique) = pickuid seenuids- in (if isunique then costUnification else costUnificationOccurs, pi uid possdep hid) : generics- HNSort (Set l) -> map (\l -> (costUnification, set l)) [0..l] ++ generics- HNSort _ -> generics- _ -> __IMPOSSIBLE__---extraref meta seenuids c = (costAppExtraRef, app (head seenuids) (Const c))- where- app muid elr = do p <- newPlaceholder- okh <- newOKHandle- let uid = case muid of- Just _ -> muid- Nothing -> Just meta- return $ App uid okh elr p---instance Refinable (ICExp o) (RefInfo o) where- refinements _ infos _ =- let (RICopyInfo e : _) = infos- in return [(0, return e)]---instance Refinable (ConstRef o) (RefInfo o) where- refinements _ [RICheckProjIndex projs] _ = return $ map (\x -> (0, return x)) projs- refinements _ _ _ = __IMPOSSIBLE__----- ----------------------------------costIotaStep, costAppExtraRef, costIncrease :: Int-costIncrease = 1000-costUnificationOccurs = 100 -- 1000001 -- 1 -- 100-costUnification = 0000-costAppVar = 0000 -- 0, 1-costAppVarUsed = 1000 -- 5-costAppHint = 3000 -- 2, 5-costAppHintUsed = 5000-costAppRecCall = 0 -- 1000?-costAppRecCallUsed = 10000 -- 1000?-costAppConstructor = 1000-costAppConstructorSingle = 0000-costAppExtraRef = 1000-costLam = 0000 -- 1, 0-costLamUnfold = 1000 -- 1, 0-costPi = 1000003 -- 100 -- 5-costSort = 1000004 -- 0-costIotaStep = 3000 -- 1000005 -- 2 -- 100-costInferredTypeUnkown = 1000006 -- 100-costAbsurdLam = 0--costEqStep = 2000-costEqEnd = 0-costEqSym = 0-costEqCong = 500---prioNo, prioTypeUnknown, prioTypecheckArgList, prioInferredTypeUnknown, prioCompBeta, prioCompBetaStructured, prioCompareArgList, prioCompIota, prioCompChoice, prioCompUnif, prioCompCopy, prioNoIota, prioAbsurdLambda :: Int-prioNo = (-1)-prioTypeUnknown = 0-prioTypecheck False = 1000-prioTypecheck True = 0-prioTypecheckArgList = 3000-prioInferredTypeUnknown = 4000-prioCompBeta = 4000-prioCompBetaStructured = 4000-prioCompIota = 4000-prioCompChoice = 5000 -- 700 -- 5000-prioCompUnif = 6000 -- 2-prioCompCopy = 8000-prioCompareArgList = 7000 -- 5 -- 2-prioNoIota = 500 -- 500-prioAbsurdLambda = 1000--prioProjIndex = 3000 :: Int----- -----------------------------------instance Trav a blk => Trav [a] blk where- traverse _ [] = return ()- traverse f (x:xs) = traverse f x >> traverse f xs--instance Trav (MId, CExp o) (RefInfo o) where- traverse f (_, ce) = traverse f ce--instance Trav (TrBr a o) (RefInfo o) where- traverse f (TrBr es _) = traverse f es--instance Trav (Exp o) (RefInfo o) where- traverse f e = case e of- App _ _ _ args -> traverse f args- Lam _ (Abs _ b) -> traverse f b- Pi _ _ _ it (Abs _ ot) -> traverse f it >> traverse f ot- Sort _ -> return ()-- AbsurdLambda{} -> return ()---instance Trav (ArgList o) (RefInfo o) where- traverse _ ALNil = return ()- traverse f (ALCons _ arg args) = traverse f arg >> traverse f args-- traverse f (ALProj eas _ _ as) = traverse f eas >> traverse f as--- traverse f (ALConPar args) = traverse f args----- ---------------------------------
@@ -1,325 +0,0 @@-{-# LANGUAGE ExistentialQuantification, CPP #-}--module Agda.Auto.Syntax where--import Agda.Utils.Impossible-#include "../undefined.h"--import Data.IORef--import Agda.Auto.NarrowingSearch--type UId o = Metavar (Exp o) (RefInfo o)--data HintMode = HMNormal- | HMRecCall---data EqReasoningConsts o = EqReasoningConsts {eqrcId, eqrcBegin, eqrcStep, eqrcEnd, eqrcSym, eqrcCong :: ConstRef o} -- "_≡_", "begin_", "_≡⟨_⟩_", "_∎", "sym", "cong"--data EqReasoningState = EqRSNone | EqRSChain | EqRSPrf1 | EqRSPrf2 | EqRSPrf3- deriving (Eq, Show)---data RefInfo o = RIEnv {rieHints :: [(ConstRef o, HintMode)], rieDefFreeVars :: Nat -- Nat - deffreevars (to make cost of using module parameters correspond to that of hints)-- , rieEqReasoningConsts :: Maybe (EqReasoningConsts o)-- }- | RIMainInfo Nat (HNExp o) Bool -- true if iota steps performed when normalising target type (used to put cost when traversing a definition by construction instantiation)- | forall a . RIUnifInfo [CAction o] (HNExp o) -- meta environment, opp hne- | RICopyInfo (ICExp o)- | RIIotaStep Bool -- True - semiflex- | RIInferredTypeUnknown- | RINotConstructor- | RIUsedVars [UId o] [Elr o]- | RIPickSubsvar-- | RIEqRState EqReasoningState--- | RICheckElim Bool -- isdep- | RICheckProjIndex [ConstRef o] -- noof proj functions---type MyPB o = PB (RefInfo o)-type MyMB a o = MB a (RefInfo o)--type Nat = Int---data FMode = Hidden- | Instance- | NotHidden- deriving Eq---data MId = Id String- | NoId--data Abs a = Abs MId a--data ConstDef o = ConstDef {cdname :: String, cdorigin :: o, cdtype :: MExp o, cdcont :: DeclCont o-- , cddeffreevars :: Nat-- } -- contains no metas--data DeclCont o = Def Nat [Clause o] (Maybe Nat) (Maybe Nat) -- maybe an index to elimand argument, maybe index to elim arg if semiflex- | Datatype [ConstRef o] -- constructors-- [ConstRef o] -- projection functions-- | Constructor Nat -- number of omitted args- | Postulate--type Clause o = ([Pat o], MExp o)--data Pat o = PatConApp (ConstRef o) [Pat o]- | PatVar String- | PatExp--type ConstRef o = IORef (ConstDef o)--data Elr o = Var Nat- | Const (ConstRef o)--data Sort = Set Nat-- | UnknownSort-- | Type--data Exp o = App (Maybe (UId o)) (OKHandle (RefInfo o)) (Elr o) (MArgList o)- | Lam FMode (Abs (MExp o))- | Pi (Maybe (UId o)) FMode Bool (MExp o) (Abs (MExp o)) -- true if possibly dependent (var not known to not occur)- | Sort Sort-- | AbsurdLambda FMode---dontCare = Sort UnknownSort---type MExp o = MM (Exp o) (RefInfo o)--data ArgList o = ALNil- | ALCons FMode (MExp o) (MArgList o)-- | ALProj (MArgList o) (MM (ConstRef o) (RefInfo o)) FMode (MArgList o) -- proj pre args, projfcn idx, tail--- | ALConPar (MArgList o) -- inserted to cover glitch of polymorphic constructor applications coming from Agda---type MArgList o = MM (ArgList o) (RefInfo o)--data HNExp o = HNApp [Maybe (UId o)] (Elr o) (ICArgList o)- | HNLam [Maybe (UId o)] FMode (Abs (ICExp o))- | HNPi [Maybe (UId o)] FMode Bool (ICExp o) (Abs (ICExp o))- | HNSort Sort--data HNArgList o = HNALNil- | HNALCons FMode (ICExp o) (ICArgList o)-- | HNALConPar (ICArgList o)---type ICExp o = Clos (MExp o) o--type CExp o = TrBr (ICExp o) o--data ICArgList o = CALNil- | CALConcat (Clos (MArgList o) o) (ICArgList o)--data Clos a o = Clos [CAction o] a-data TrBr a o = TrBr [MExp o] a--data CAction o = Sub (ICExp o)- | Skip- | Weak Nat--type Ctx o = [(MId, CExp o)]--type EE = IO---- ---------------------------------------------detecteliminand :: [Clause o] -> Maybe Nat-detecteliminand cls =- case map cleli cls of- [] -> Nothing- (i:is) -> if all (i ==) is then i else Nothing- where- cleli (pats, _) = pateli 0 pats- pateli i (PatConApp _ args : pats) = if all notcon (args ++ pats) then Just i else Nothing- pateli i (_ : pats) = pateli (i + 1) pats- pateli i [] = Nothing- notcon PatConApp{} = False- notcon _ = True--detectsemiflex :: ConstRef o -> [Clause o] -> IO Bool-detectsemiflex _ _ = return False -- disabled-categorizedecl :: ConstRef o -> IO ()-categorizedecl c = do- cd <- readIORef c- case cdcont cd of- Def narg cls _ _ -> do- semif <- detectsemiflex c cls- let elim = detecteliminand cls- semifb = case (semif, elim) of- (True, Just i) -> Just i -- just copying val of elim arg. this should be changed- (_, _) -> Nothing- writeIORef c (cd {cdcont = Def narg cls elim semifb})- _ -> return ()---- ---------------------------------------------metaliseokh :: MExp o -> IO (MExp o)-metaliseokh = fm- where- fm (Meta m) = return $ Meta m- fm (NotM e) = do- e <- f e- return $ NotM e- f (App uid _ elr args) = do- m <- initMeta- args <- fms args- return $ App uid (Meta m) elr args- f (Lam hid (Abs id b)) = do- b <- fm b- return $ Lam hid (Abs id b)- f (Pi uid hid posdep it (Abs id ot)) = do- it <- fm it- ot <- fm ot- return $ Pi uid hid posdep it (Abs id ot)- f e@(Sort{}) = return e-- f e@(AbsurdLambda{}) = return e--- fms (Meta m) = return $ Meta m- fms (NotM es) = do- es <- fs es- return $ NotM es- fs ALNil = return ALNil- fs (ALCons hid a as) = do- a <- fm a- as <- fms as- return $ ALCons hid a as-- fs (ALProj eas idx hid as) = do- eas <- fms eas- as <- fms as- return $ ALProj eas idx hid as--- fs (ALConPar as) = do- as <- fms as- return $ ALConPar as----- ---------------------------------------------expandExp :: MExp o -> IO (MExp o)-expandExp = fm- where- fm (Meta m) = do- mb <- readIORef $ mbind m- case mb of- Nothing -> return $ Meta m- Just e -> fm (NotM e)- fm (NotM e) = do- e <- f e- return $ NotM e- f (App uid okh elr args) = do- args <- fms args- return $ App uid okh elr args- f (Lam hid (Abs id b)) = do- b <- fm b- return $ Lam hid (Abs id b)- f (Pi uid hid posdep it (Abs id ot)) = do- it <- fm it- ot <- fm ot- return $ Pi uid hid posdep it (Abs id ot)- f e@(Sort{}) = return e-- f e@(AbsurdLambda{}) = return e--- fms (Meta m) = do- mb <- readIORef $ mbind m- case mb of- Nothing -> return $ Meta m- Just es -> fms (NotM es)- fms (NotM es) = do- es <- fs es- return $ NotM es- fs ALNil = return ALNil- fs (ALCons hid a as) = do- a <- fm a- as <- fms as- return $ ALCons hid a as-- fs (ALProj eas idx hid as) = do- idx <- expandbind idx- eas <- fms eas- as <- fms as- return $ ALProj eas idx hid as--- fs (ALConPar as) = do- as <- fms as- return $ ALConPar as----- -----------------------------------addtrailingargs :: Clos (MArgList o) o -> ICArgList o -> ICArgList o-addtrailingargs newargs CALNil = CALConcat newargs CALNil-addtrailingargs newargs (CALConcat x xs) = CALConcat x (addtrailingargs newargs xs)---- -----------------------------------closify :: MExp o -> CExp o-closify e = TrBr [e] (Clos [] e)--sub :: MExp o -> CExp o -> CExp o--- sub e (Clos [] x) = Clos [Sub e] x-sub e (TrBr trs (Clos (Skip : as) x)) = TrBr (e : trs) (Clos (Sub (Clos [] e) : as) x)-{-sub e (Clos (Weak n : as) x) = if n == 1 then- Clos as x- else- Clos (Weak (n - 1) : as) x-}-sub _ _ = __IMPOSSIBLE__--subi :: MExp o -> ICExp o -> ICExp o-subi e (Clos (Skip : as) x) = Clos (Sub (Clos [] e) : as) x-subi _ _ = __IMPOSSIBLE__--weak :: Nat -> CExp o -> CExp o-weak n (TrBr trs e) = TrBr trs (weaki n e)--weaki :: Nat -> Clos a o -> Clos a o-weaki 0 x = x-weaki n (Clos as x) = Clos (Weak n : as) x--weakarglist :: Nat -> ICArgList o -> ICArgList o-weakarglist 0 = id-weakarglist n = f- where f CALNil = CALNil- f (CALConcat (Clos cl as) as2) = CALConcat (Clos (Weak n : cl) as) (f as2)-weakelr :: Nat -> Elr o -> Elr o-weakelr 0 elr = elr-weakelr n (Var v) = Var (v + n)-weakelr _ elr@(Const _) = elr--doclos :: [CAction o] -> Nat -> Either Nat (ICExp o)-doclos = f 0- where- f ns [] i = Left (ns + i)- f ns (Weak n : xs) i = f (ns + n) xs i- f ns (Sub s : _) 0 = Right (weaki ns s)- f ns (Skip : _) 0 = Left ns- f ns (Skip : xs) i = f (ns + 1) xs (i - 1)- f ns (Sub _ : xs) i = f ns xs (i - 1)
@@ -1,808 +0,0 @@-{-# LANGUAGE ExistentialQuantification, FlexibleContexts,- ScopedTypeVariables, CPP #-}--module Agda.Auto.Typecheck where--import Agda.Utils.Impossible-#include "../undefined.h"--import Data.IORef-import Control.Monad (liftM)--import Agda.Auto.NarrowingSearch-import Agda.Auto.Syntax-import Agda.Auto.SearchControl----- -----------------------------------tcExp :: Bool -> Ctx o -> CExp o -> MExp o -> EE (MyPB o)-tcExp isdep ctx typ@(TrBr typtrs ityp@(Clos _ itypexp)) trm =- mbpcase prioTypeUnknown Nothing (hnn_checkstep ityp) $ \(hntyp, iotastepdone) ->- mmpcase (True, prioTypecheck isdep, Just (RIMainInfo (length ctx) hntyp iotastepdone)) trm $ \trm -> case trm of- App _ okh elr args -> case hntyp of- HNPi{} | isdep -> mpret $ Error "tcExp, dep terms should be eta-long"- _ -> do- (ityp, sc) <- case elr of- Var v -> -- assuming within scope- return (weak (v + 1) (snd $ ctx !! v), id)- Const c -> do- cdef <- readIORef c- return (closify (cdtype cdef), \x -> mpret $ And (Just [Term args]) (noiotastep_term c args) x)-- ndfv <- case elr of- Var{} -> return 0- Const c -> readIORef c >>= \cd -> return (cddeffreevars cd)--- isconstructor <- case elr of- Var{} -> return False- Const c -> do- cdef <- readIORef c- return $ case cdcont cdef of {Constructor{} -> True; _ -> False}-- sc $ tcargs ndfv isdep ctx ityp args (NotM $ App Nothing (NotM OKVal) elr (NotM ALNil)) isconstructor $ \ityp _ -> mpret $ ConnectHandle okh (comp' True typ ityp)- Lam hid (Abs id1 b) -> case hntyp of- HNPi _ hid2 _ it (Abs id2 ot) | hid == hid2 ->- tcExp isdep ((pickid id1 id2, t it) : ctx) (t ot) b- _ -> mpret $ Error "tcExp, type of lam should be fun or pi (and same hid)"- Pi _ _ _ it (Abs id ot) -> case hntyp of- HNSort s ->- mpret $ And (Just [Term ctx, Term it])- (tcExp True ctx (closify (NotM $ Sort s)) it)- (tcExp isdep ((id, closify it) : ctx) (closify (NotM $ Sort s)) ot)- _ -> mpret $ Error "tcExp, type of pi should be set"- Sort (Set i) -> case hntyp of- HNSort s2 -> case s2 of- Set j -> mpret $ if i < j then OK else Error "tcExp, type of set should be larger set"-- UnknownSort -> mpret OK -- mpret $ Error "tcExp, type of set i unknown sort" -- OK instead? (prev __IMPOSSIBLE__)-- Type -> mpret OK- _ -> mpret $ Error "tcExp, type of set should be set"-- Sort UnknownSort -> __IMPOSSIBLE__-- Sort Type -> __IMPOSSIBLE__-- AbsurdLambda hid -> case hntyp of- HNPi _ hid2 _ it _ | hid == hid2 ->- mbpcase prioAbsurdLambda Nothing (getDatatype it) $ \res -> case res of- Just (indeces, cons) ->- foldl (\p con -> mpret $ And Nothing p (- constructorImpossible indeces con- )) (mpret OK) cons- Nothing -> mpret $ Error "tcExp, absurd lambda, datatype needed"- _ -> mpret $ Error "tcExp, type of absurd lam should be fun or pi (and same hid)"--- where- t = TrBr typtrs---getDatatype :: ICExp o -> EE (MyMB (Maybe (ICArgList o, [ConstRef o])) o)-getDatatype t =- mbcase (hnn t) $ \hnt -> case hnt of- HNApp _ (Const c) args -> do- cd <- readIORef c- case cdcont cd of- Datatype cons _ -> mbret $ Just (args, cons) -- ?? check that lenth args corresponds to type of datatype- _ -> mbret Nothing- _ -> mbret Nothing--constructorImpossible :: ICArgList o -> ConstRef o -> EE (MyPB o)-constructorImpossible args c = do- cd <- readIORef c- mbpcase prioAbsurdLambda Nothing (traversePi (-1) (Clos [] $ cdtype cd)) $ \hnot ->- case hnot of- HNApp _ _ args2 -> unequals args args2 (\_ -> mpret $ Error "not unequal") []- _ -> mpret $ Error "constructorImpossible 1"--unequals :: ICArgList o -> ICArgList o -> ([(Nat, HNExp o)] -> EE (MyPB o)) -> [(Nat, HNExp o)] -> EE (MyPB o)-unequals es1 es2 cont unifier2 =- mbpcase prioAbsurdLambda Nothing (hnarglist es1) $ \hnes1 ->- mbpcase prioAbsurdLambda Nothing (hnarglist es2) $ \hnes2 ->- case (hnes1, hnes2) of- (HNALCons _ e1 es1, HNALCons _ e2 es2) -> unequal e1 e2 (unequals es1 es2 cont) unifier2-- (HNALConPar es1, HNALConPar es2) -> unequals es1 es2 cont unifier2-- _ -> cont unifier2--unequal :: ICExp o -> ICExp o -> ([(Nat, HNExp o)] -> EE (MyPB o)) -> [(Nat, HNExp o)] -> EE (MyPB o)-unequal e1 e2 cont unifier2 =- mbpcase prioAbsurdLambda Nothing (hnn e1) $ \hne1 ->- mbpcase prioAbsurdLambda Nothing (hnn e2) $ \hne2 ->- case hne2 of- HNApp _ (Var v2) es2 | v2 < 0 ->- mbpcase prioAbsurdLambda Nothing (hnarglist es2) $ \hnes2 -> case hnes2 of- HNALNil ->- case lookup v2 unifier2 of- Nothing -> cont ((v2, hne1) : unifier2)- Just hne2' -> cc hne1 hne2'- HNALCons{} -> cont unifier2-- HNALConPar{} -> __IMPOSSIBLE__-- _ -> cc hne1 hne2- where- cc hne1 hne2 = case (hne1, hne2) of- (HNApp _ (Const c1) es1, HNApp _ (Const c2) es2) -> do- cd1 <- readIORef c1- cd2 <- readIORef c2- case (cdcont cd1, cdcont cd2) of- (Constructor{}, Constructor{}) ->- if c1 == c2 then- unequals es1 es2 cont unifier2- else- mpret OK- _ -> cont unifier2- _ -> cont unifier2--traversePi :: Int -> ICExp o -> EE (MyMB (HNExp o) o)-traversePi v t =- mbcase (hnn t) $ \hnt ->- case hnt of- HNPi _ _ _ _ (Abs _ ot) -> traversePi (v - 1) (subi (NotM $ App Nothing (NotM OKVal) (Var v) (NotM ALNil)) ot)- _ -> mbret hnt---tcargs :: Nat -> Bool -> Ctx o -> CExp o -> MArgList o -> MExp o -> Bool -> (CExp o -> MExp o -> EE (MyPB o)) -> EE (MyPB o)-tcargs ndfv isdep ctx ityp@(TrBr ityptrs iityp) args elimtrm isconstructor cont = mmpcase (True, prioTypecheckArgList, (Just $ RICheckElim $ isdep || isconstructor)) args $ \args' -> case args' of- ALNil -> cont ityp elimtrm- ALCons hid a as ->- mbpcase prioInferredTypeUnknown (Just RIInferredTypeUnknown) (hnn iityp) $ \hnityp -> case hnityp of- HNPi _ hid2 possdep it (Abs _ ot) | ndfv > 0 || copyarg a || hid == hid2 -> mpret $- And (Just ((if possdep then [Term a] else []) ++ [Term ctx, Term ityptrs]))- (if ndfv > 0 then mpret OK else (tcExp (isdep || possdep) ctx (t it) a))- (tcargs (ndfv - 1) isdep ctx (sub a (t ot)) as (addend hid a elimtrm) isconstructor cont)- _ -> mpret $ Error "tcargs, inf type should be fun or pi (and same hid)"--- ALProj{} | ndfv > 0 -> __IMPOSSIBLE__-- ALProj preas projidx hid as ->- mbpcase prioInferredTypeUnknown (Just RIInferredTypeUnknown) (hnn iityp) $ \hnityp -> case hnityp of- HNApp _ (Const dd) _ -> do- dddef <- readIORef dd- case cdcont dddef of- Datatype _ projs ->- mmpcase (True, prioProjIndex, Just (RICheckProjIndex projs)) projidx $- \projidx -> do- projd <- readIORef projidx- tcargs (cddeffreevars projd) isdep ctx (closify $ cdtype projd) preas (NotM $ App Nothing (NotM OKVal) (Const projidx) (NotM ALNil)) True $- \ityp2@(TrBr ityp2trs iityp2) elimtrm2 ->- case iityp2 of- Clos _ (NotM (Pi _ _ _ (NotM (App _ _ (Const dd2) _)) _)) | dd2 == dd ->- mbpcase prioInferredTypeUnknown (Just RIInferredTypeUnknown) (hnn iityp2) $ \hnityp2 -> case hnityp2 of- HNPi _ hid2 possdep it (Abs _ ot) | hid == hid2 -> mpret $- And Nothing- (comp' True (TrBr ityp2trs it) ityp)- (tcargs 0 isdep ctx (sub elimtrm (t ot)) as (addend hid elimtrm elimtrm2) isconstructor cont)- _ -> mpret $ Error "proj function type is not a Pi"- _ -> mpret $ Error "proj function type is not correct"- _ -> mpret $ Error "proj, not a datatype"- _ -> mpret $ Error "proj, not a const app"--- ALConPar _ -> __IMPOSSIBLE__-- where- t = TrBr ityptrs---addend hid a (NotM (App uid okh elr as)) = NotM $ App uid okh elr (f as)- where f (NotM ALNil) = NotM $ ALCons hid a (NotM $ ALNil)- f (NotM (ALCons hid a as)) = NotM $ ALCons hid a (f as)- f _ = __IMPOSSIBLE__-addend _ _ _ = __IMPOSSIBLE__-copyarg _ = False----- ------------------------------------type HNNBlks o = [HNExp o]--noblks = []-addblk = (:)---hnn :: ICExp o -> EE (MyMB (HNExp o) o)-hnn e = mbcase (hnn_blks e) $ \(hne, _) -> mbret hne--hnn_blks :: ICExp o -> EE (MyMB (HNExp o, HNNBlks o) o)-hnn_blks e = hnn' e CALNil--hnn_checkstep :: ICExp o -> EE (MyMB (HNExp o, Bool) o)-hnn_checkstep e =- mbcase (hnb e CALNil) $ \hne ->- mbcase (iotastep True hne) $ \res -> case res of- Right _ -> mbret (hne, False)- Left (e, as) ->- mbcase (hnn' e as) $ \(hne, _) -> mbret (hne, True)---hnn' :: ICExp o -> ICArgList o -> EE (MyMB (HNExp o, HNNBlks o) o)-hnn' e as =- mbcase (hnb e as) $ \hne ->- mbcase (iotastep True hne) $ \res -> case res of- Right blks -> mbret (hne, blks)- Left (e, as) -> hnn' e as--hnb :: ICExp o -> ICArgList o -> EE (MyMB (HNExp o) o)-hnb e as = mbcase (hnc False e as []) $ \res -> case res of- HNDone _ hne -> mbret hne- HNMeta{} -> __IMPOSSIBLE__--data HNRes o = HNDone (Maybe (Metavar (Exp o) (RefInfo o))) (HNExp o)- | HNMeta (ICExp o) (ICArgList o) [Maybe (UId o)]--hnc :: Bool -> ICExp o -> ICArgList o -> [Maybe (UId o)] -> EE (MyMB (HNRes o) o)-hnc haltmeta = loop- where- loop ce@(Clos cl e) cargs seenuids =- (if haltmeta then mmmcase e (mbret $ HNMeta ce cargs seenuids) else mmcase e) $- \ee -> case ee of- App uid okh elr args ->- let ncargs = CALConcat (Clos cl args) cargs- in case elr of- Var v -> case doclos cl v of- Left v' -> mbret $ HNDone expmeta (HNApp (uid : seenuids) (Var v') ncargs)- Right f -> loop f ncargs (uid : seenuids)- Const _ -> mbret $ HNDone expmeta (HNApp (uid : seenuids) elr ncargs)- Lam hid (Abs id b) ->- mbcase (hnarglist cargs) $ \hncargs -> case hncargs of- HNALNil -> mbret $ HNDone expmeta (HNLam seenuids hid (Abs id (Clos (Skip : cl) b)))- HNALCons _ arg cargs' -> loop (Clos (Sub arg : cl) b) cargs' seenuids-- HNALConPar{} -> __IMPOSSIBLE__-- Pi uid hid possdep it (Abs id ot) -> checkNoArgs cargs $ mbret $ HNDone expmeta (HNPi (uid : seenuids) hid possdep (Clos cl it) (Abs id (Clos (Skip : cl) ot)))- Sort s -> checkNoArgs cargs $ mbret $ HNDone expmeta (HNSort s)-- AbsurdLambda{} -> mbfailed "hnc: encountered absurdlambda"--- where expmeta = case e of {Meta m -> Just m; NotM _ -> Nothing}- checkNoArgs cargs c =- mbcase (hnarglist cargs) $ \hncargs -> case hncargs of- HNALNil -> c- HNALCons{} -> mbfailed "hnc: there should be no args"-- HNALConPar{} -> __IMPOSSIBLE__---hnarglist :: ICArgList o -> EE (MyMB (HNArgList o) o)-hnarglist args =- case args of- CALNil -> mbret HNALNil- CALConcat (Clos cl args) args2 ->- mmcase args $ \args -> case args of- ALNil -> hnarglist args2- ALCons hid arg argsb -> mbret $ HNALCons hid (Clos cl arg) (CALConcat (Clos cl argsb) args2)-- ALProj{} -> mbret HNALNil -- dirty hack to make check of no-iota in term work--- ALConPar args -> mbret $ HNALConPar (CALConcat (Clos cl args) args2)--- -------------------------------getNArgs :: Nat -> ICArgList o -> EE (MyMB (Maybe ([ICExp o], ICArgList o)) o)-getNArgs 0 args = mbret $ Just ([], args)-getNArgs narg args =- mbcase (hnarglist args) $ \hnargs -> case hnargs of- HNALNil -> mbret Nothing- HNALCons _ arg args' ->- mbcase (getNArgs (narg - 1) args') $ \res -> case res of- Nothing -> mbret Nothing- Just (pargs, rargs) -> mbret $ Just (arg : pargs, rargs)-- HNALConPar{} -> __IMPOSSIBLE__---getAllArgs :: ICArgList o -> EE (MyMB [ICExp o] o)-getAllArgs args =- mbcase (hnarglist args) $ \hnargs -> case hnargs of- HNALNil -> mbret []- HNALCons _ arg args' ->- mbcase (getAllArgs args') $ \args'' ->- mbret (arg : args'')-- HNALConPar args2 ->- mbcase (getAllArgs args2) $ \args3 -> mbret (__IMPOSSIBLE__ : args3)---data PEval o = PENo (ICExp o)- | PEConApp (ICExp o) (ConstRef o) [PEval o]--iotastep :: Bool -> HNExp o -> EE (MyMB (Either (ICExp o, ICArgList o) (HNNBlks o)) o)-iotastep smartcheck e = case e of- HNApp _ (Const c) args -> do- cd <- readIORef c- case cdcont cd of- Def narg cls _ _ ->- mbcase (getNArgs narg args) $ \res -> case res of- Nothing -> mbret (Right noblks)- Just (pargs, rargs) ->- mbcase (dorules cls (map PENo pargs)) $ \res -> case res of- Right blks -> mbret (Right blks)- Left rhs -> mbret $ Left (rhs, rargs)- _ -> mbret $ Right noblks- _ -> mbret $ Right noblks- where- dorules :: [Clause o] -> [PEval o] -> EE (MyMB (Either (ICExp o) (HNNBlks o)) o)- dorules [] _ = mbret $ Right noblks- dorules (rule:rules') as =- mbcase (dorule rule as) $ \x -> case x of- Left (Left as') -> dorules rules' as'- Left (Right blks) -> mbret (Right blks)- Right rhs -> mbret $ Left rhs-- dorule :: Clause o -> [PEval o] -> EE (MyMB (Either (Either [PEval o] (HNNBlks o)) (ICExp o)) o)- dorule (pats, rhs) as =- mbcase (dopats pats as) $ \x -> case x of- Right (_, ss) -> mbret $ Right (Clos (map Sub ss) rhs)- Left hnas -> mbret $ Left hnas-- dopats :: [Pat o] -> [PEval o] -> EE (MyMB (Either (Either [PEval o] (HNNBlks o)) ([PEval o], [ICExp o])) o)- dopats [] [] = mbret $ Right ([], [])- dopats (p:ps') (a:as') =- mbcase (dopat p a) $ \x -> case x of- Right (hna, ss) ->- mbcase (dopats ps' as') $ \x -> case x of- Right (hnas, ss2) -> mbret $ Right (hna : hnas, ss2 ++ ss)- Left (Right blks) -> mbret $ Left (Right blks)- Left (Left hnas) -> mbret $ Left $ Left (hna : hnas)- Left (Right blks) -> mbret $ Left (Right blks)- Left (Left hna) -> mbret $ Left $ Left (hna : as')- dopats _ _ = __IMPOSSIBLE__-- dopat :: Pat o -> PEval o -> EE (MyMB (Either (Either (PEval o) (HNNBlks o)) (PEval o, [ICExp o])) o)- dopat (PatConApp c pas) a =- case a of- PENo a ->- if smartcheck then- mbcase (meta_not_constructor a) $ \notcon -> if notcon then mbret $ Left $ Right noblks else qq -- to know more often if iota step is possible- else- qq- where- qq =- mbcase (hnn_blks a) $ \(hna, blks) -> case hna of- HNApp _ (Const c') as ->- if c == c' then- mbcase (getAllArgs as) $ \as' ->- if length as' == length pas then- mbcase (dopats pas (map PENo as')) $ \x -> case x of- Right (hnas, ss) -> mbret $ Right (PEConApp a c' hnas, ss)- Left (Right blks) -> mbret $ Left (Right blks)- Left (Left hnas) -> mbret $ Left $ Left (PEConApp a c' hnas)- else- mbfailed "dopat: wrong amount of args"- else do- cd <- readIORef c'- case cdcont cd of- Constructor{} -> mbcase (getAllArgs as) $ \as' ->- mbret $ Left (Left (PEConApp a c' (map PENo as')))- _ -> mbret $ Left (Right (addblk hna blks))- _ -> mbret $ Left (Right (addblk hna blks))- aa@(PEConApp a c' as) ->- if c == c' then- if length as == length pas then- mbcase (dopats pas as) $ \x -> case x of- Right (hnas, ss) -> mbret $ Right (PEConApp a c' hnas, ss)- Left (Right blks) -> mbret $ Left (Right blks)- Left (Left hnas) -> mbret $ Left $ Left (PEConApp a c' hnas)- else- mbfailed "dopat: wrong amount of args"- else- mbret $ Left (Left aa)- dopat PatVar{} a@(PENo a') = mbret $ Right (a, [a'])- dopat PatVar{} a@(PEConApp a' _ _) = mbret $ Right (a, [a'])- dopat PatExp a = mbret $ Right (a, [])---- -------------------------------noiotastep :: HNExp o -> EE (MyPB o)-noiotastep hne =- mbpcase prioNoIota Nothing (iotastep False hne) $ \res -> case res of- Left _ -> mpret $ Error "iota step possible contrary to assumed"- Right _ -> mpret OK--noiotastep_term :: ConstRef o -> MArgList o -> EE (MyPB o)-noiotastep_term c args = f (HNApp [] (Const c) (CALConcat (Clos [] args) CALNil))- where- f hne@(HNApp _ (Const c) _) = do- cd <- readIORef c- let isshorthand =- case cdcont cd of- Def _ [(pats, _)] _ _ -> True -- all (\pat -> case pat of {PatConApp{} -> False; _ -> True}) pats- _ -> False- if isshorthand then- mpret OK- else- noiotastep hne- f _ = __IMPOSSIBLE__--data CMode o = CMRigid (Maybe (Metavar (Exp o) (RefInfo o))) (HNExp o)- | forall b . Refinable b (RefInfo o) => CMFlex (MM b (RefInfo o)) (CMFlex o)-data CMFlex o = CMFFlex (ICExp o) (ICArgList o) [Maybe (UId o)]- | CMFSemi (Maybe (Metavar (Exp o) (RefInfo o))) (HNExp o)- | CMFBlocked (Maybe (Metavar (Exp o) (RefInfo o))) (HNExp o)--comp' :: forall o . Bool -> CExp o -> CExp o -> EE (MyPB o)-comp' ineq lhs@(TrBr trs1 e1) rhs@(TrBr trs2 e2) = comp ineq e1 e2- where- comp :: Bool -> ICExp o -> ICExp o -> EE (MyPB o)- comp ineq e1 e2 =- proc e1 e2-- where- proc e1 e2 = f True e1 CALNil [] $ \res1 -> f True e2 CALNil [] $ \res2 -> g res1 res2- f semifok e as seenuids cont =- mbpcase prioCompBeta Nothing (hnc True e as seenuids) $ \res ->- case res of- HNDone mexpmeta hne -> fhn semifok mexpmeta hne cont-- HNMeta ce@(Clos cl m) cargs seenuids -> do- b1 <- boringClos cl- b2 <- boringArgs cargs- if b1 && b2 then- cont $ CMFlex m (CMFFlex ce cargs seenuids)- else- mbpcase prioCompBetaStructured Nothing (hnc False ce cargs seenuids) $ \res ->- case res of- HNDone mexpmeta hne -> cont $ CMFlex m (CMFBlocked mexpmeta hne)- HNMeta{} -> __IMPOSSIBLE__--- fhn semifok mexpmeta hne cont =- mmbpcase (iotastep True hne)- (\m -> do- sf <- return False {- semiflex hne -}- if semifok && sf then- cont (CMFlex m (CMFSemi mexpmeta hne))- else- cont (CMFlex m (CMFBlocked mexpmeta hne))- )- (\res -> case res of- Right _ -> cont (CMRigid mexpmeta hne)- Left (e, as) -> f semifok e as [] cont- )- g res1 res2 =- case (res1, res2) of- (CMRigid mexpmeta1 hne1, CMRigid mexpmeta2 hne2) -> comphn ineq mexpmeta1 hne1 mexpmeta2 hne2- (CMFlex m1 (CMFBlocked mexpmeta1 hne1), _) -> mstp False mexpmeta1 hne1 $ \res1 -> g res1 res2- (_, CMFlex m2 (CMFBlocked mexpmeta2 hne2)) -> mstp False mexpmeta2 hne2 $ \res2 -> g res1 res2- (CMRigid mexpmeta1 hne1, CMFlex _ fl2) -> unif True mexpmeta1 hne1 fl2- (CMFlex _ fl1, CMRigid mexpmeta2 hne2) -> unif False mexpmeta2 hne2 fl1--- (CMFlex m1 fl1, CMFlex m2 fl2) -> doubleblock m1 m2 $ fcm fl1 $ \res1 -> fcm fl2 $ \res2 -> g res1 res2- fcm (CMFFlex ce cargs seenuids) = f True ce cargs seenuids- fcm (CMFSemi mexpmeta hne) = fhn True mexpmeta hne- fcm (CMFBlocked _ hne) = __IMPOSSIBLE__ -- not used. if so should be: fhn False hne- mstp semif mexpmeta hne cont =- mpret $ Or prioCompChoice- (mpret $ And (Just [Term lhs, Term rhs])- (noiotastep hne)- (cont (CMRigid mexpmeta hne))- )- (stp semif hne cont)- stp semif hne cont =- mbpcase prioCompIota (Just $ RIIotaStep semif) (iotastep True hne) $ \res -> case res of- Right _ -> mpret $ Error "no iota step possible, contrary to assumed"- Left (e, as) -> f semif e as [] cont- unif oppis1 oppmexpmeta opphne res =- let iter res = if oppis1 then- g (CMRigid oppmexpmeta opphne) res- else- g res (CMRigid oppmexpmeta opphne)- in case res of- CMFFlex ce cargs seenuids -> do- poss <- iotapossmeta ce cargs- maybeor poss prioCompChoice- (loop ce cargs seenuids)--- (mbpcase prioCompBeta (Just $ RIIotaStep False) (hnb ce cargs) $ \hne ->- (mbpcase prioCompBeta (Just $ RIIotaStep False) (hnc False ce cargs seenuids) $ \res ->- -- RIIotaStep here on beta-norm to make cost high when guessing elim const in type par- case res of- HNDone mexpmeta hne -> stp False hne iter- HNMeta{} -> __IMPOSSIBLE__- )- where- loop ce@(Clos cl m) cargs seenuids =- mmpcase (False, prioCompUnif, Just (RIUnifInfo cl opphne)) m $ \_ ->- mbpcase prioCompBeta Nothing (hnc True ce cargs seenuids) $ \res -> case res of- HNDone mexpmeta hne ->- mpret $ And (Just [Term lhs, Term rhs])- (noiotastep hne)- (iter (CMRigid mexpmeta hne))- HNMeta ce cargs seenuids -> loop ce cargs seenuids- CMFSemi _ hne ->- __IMPOSSIBLE__ -- CMFSemi disabled, if used should be: stp True hne iter- CMFBlocked{} -> __IMPOSSIBLE__- comphn :: Bool -> Maybe (Metavar (Exp o) (RefInfo o)) -> HNExp o -> Maybe (Metavar (Exp o) (RefInfo o)) -> HNExp o -> EE (MyPB o)- comphn ineq mexpmeta1 hne1 mexpmeta2 hne2 =- case (hne1, hne2) of- (HNApp _ elr1 args1, HNApp _ elr2 args2) ->- let ce = case (elr1, elr2) of- (Var v1, Var v2) -> if v1 == v2 then Nothing else Just "comphn, elr, vars not equal"- (Const c1, Const c2) -> if c1 == c2 then Nothing else Just "comphn, elr, consts not equal"- (_, _) -> Just "comphn, elrs not equal"- in case ce of- Nothing -> compargs args1 args2- Just msg -> mpret $ Error msg- (HNLam _ hid1 (Abs id1 b1), HNLam _ hid2 (Abs id2 b2)) -> comp False b1 b2- (HNLam seenuids _ (Abs _ b1), HNApp uid2 elr2 args2) ->- f True b1 CALNil seenuids $ \res1 -> fhn True mexpmeta2 (HNApp uid2 (weakelr 1 elr2) (addtrailingargs (Clos [] $ NotM $ ALCons NotHidden{- arbitrary -} (NotM $ App Nothing (NotM OKVal) (Var 0) (NotM ALNil)) (NotM ALNil)) (weakarglist 1 args2))) $ \res2 -> g res1 res2- (HNApp uid1 elr1 args1, HNLam seenuids _ (Abs _ b2)) ->- fhn True mexpmeta1 (HNApp uid1 (weakelr 1 elr1) (addtrailingargs (Clos [] $ NotM $ ALCons NotHidden{- arbitrary -} (NotM $ App Nothing (NotM OKVal) (Var 0) (NotM ALNil)) (NotM ALNil)) (weakarglist 1 args1))) $ \res1 -> f True b2 CALNil seenuids $ \res2 -> g res1 res2-{-- (HNLam _ (Abs _ b1), HNApp uid2 elr2 args2) ->- f True b1 CALNil $ \res1 -> g res1- (CMRigid mexpmeta2 (HNApp uid2 (weakelr 1 elr2) (addtrailingargs (Clos [] $ NotM $ ALCons NotHidden{- arbitrary -} (NotM $ App Nothing (NotM OKVal) (Var 0) (NotM ALNil)) (NotM ALNil)) (weakarglist 1 args2))))- (HNApp uid1 elr1 args1, HNLam _ (Abs _ b2)) ->- f True b2 CALNil $ \res2 -> g- (CMRigid mexpmeta1 (HNApp uid1 (weakelr 1 elr1) (addtrailingargs (Clos [] $ NotM $ ALCons NotHidden{- arbitrary -} (NotM $ App Nothing (NotM OKVal) (Var 0) (NotM ALNil)) (NotM ALNil)) (weakarglist 1 args1))))- res2--}- (HNPi _ hid1 _ it1 (Abs id1 ot1), HNPi _ hid2 _ it2 (Abs id2 ot2)) -> mpret $- And (Just [Term trs1, Term trs2]) (comp False it1 it2) (comp ineq ot1 ot2)- (HNSort s1, HNSort s2) -> mpret $- case (s1, s2) of- (Set i1, Set i2) -> if i1 == i2 || ineq && i1 > i2 then OK else Error "comphn, set levels not matching"- (Set _, UnknownSort) -> OK- (UnknownSort, Set _) -> OK- (UnknownSort, UnknownSort) -> OK- (Type, Set _) | ineq -> OK- (Type, UnknownSort) | ineq -> OK- _ -> __IMPOSSIBLE__- (HNApp uid1 (Const c1) _, _) -> case mexpmeta2 of- Nothing -> mpret $ Error "comphn, not equal (2)"- Just m2 -> mpret $ AddExtraRef "comphn: not equal, adding extra ref" m2 (extraref m2 uid1 c1)- (_, HNApp uid2 (Const c2) _) -> case mexpmeta1 of- Nothing -> mpret $ Error "comphn, not equal (3)"- Just m1 -> mpret $ AddExtraRef "comphn: not equal, adding extra ref" m1 (extraref m1 uid2 c2)- (_, _) -> mpret $ Error "comphn, not equal"-- compargs :: ICArgList o -> ICArgList o -> EE (MyPB o)- compargs args1 args2 =- mbpcase prioCompareArgList Nothing (hnarglist args1) $ \hnargs1 ->- mbpcase prioCompareArgList Nothing (hnarglist args2) $ \hnargs2 ->- case (hnargs1, hnargs2) of- (HNALNil, HNALNil) -> mpret OK- (HNALCons hid1 arg1 args1b, HNALCons hid2 arg2 args2b) -> mpret $- And (Just [Term trs1, Term trs2]) (comp False arg1 arg2) (compargs args1b args2b)-- (HNALConPar args1b, HNALCons _ _ args2b) -> compargs args1b args2b- (HNALCons _ _ args1b, HNALConPar args2b) -> compargs args1b args2b- (HNALConPar args1', HNALConPar args2') -> compargs args1' args2'-- (_, _) -> mpret $ Error $ "comphnargs, not equal"--- boringExp :: ICExp o -> EE Bool- boringExp (Clos cl e) = do- e <- expandbind e- case e of- Meta{} -> boringClos cl- NotM e -> case e of- App _ _ (Var v) as -> do- as <- expandbind as- case as of- Meta{} -> return False- NotM as -> case as of- ALNil -> case doclos cl v of- Left _ -> return True- Right e -> boringExp e- ALCons{} -> return False-- ALProj{} -> __IMPOSSIBLE__--- ALConPar{} -> return False-- _ -> return False-- boringClos :: [CAction o] -> EE Bool- boringClos cl = liftM (all id) $ mapM f cl- where f (Sub e) = boringExp e- f Skip = return True- f (Weak _) = return True-- boringArgs :: ICArgList o -> EE Bool- boringArgs CALNil = return True- boringArgs (CALConcat (Clos cl as) as2) = do- b1 <- f cl as- b2 <- boringArgs as2- return $ b1 && b2- where- f cl as = do- as <- expandbind as- case as of- Meta{} -> return False- NotM as -> case as of- ALNil -> return True- ALCons _ a as -> do- b1 <- boringExp (Clos cl a)- b2 <- f cl as- return $ b1 && b2-- ALProj{} -> __IMPOSSIBLE__--- ALConPar as -> f cl as--- -----------------------------------checkeliminand :: MExp o -> EE (MyPB o)-checkeliminand = f [] []- where- f uids used e =- mmpcase (False, prioNo, Just (RIUsedVars uids used)) e $ \e -> case e of- App uid _ elr@(Var{}) args -> fs (adduid uid uids) (elr : used) args- App uid _ elr@(Const c) args -> do- cd <- readIORef c- case cdcont cd of- Def _ _ (Just i) _ -> mpret $ Sidecondition (fs (adduid uid uids) (elr : used) args) (g i args)- where- g i as = mmpcase (False, prioNo, Nothing) as $ \as -> case as of- ALNil -> mpret OK- ALCons _ a as -> case i of- 0 -> mmpcase (False, prioNo, Just RINotConstructor) a $ \_ ->- mpret OK- _ -> g (i - 1) as-- ALProj eas _ _ as -> mpret OK--- ALConPar as -> case i of- 0 -> __IMPOSSIBLE__- _ -> g (i - 1) as-- _ -> fs (adduid uid uids) (elr : used) args- Lam _ (Abs _ e) -> f uids (w used) e- Pi uid _ _ e1 (Abs _ e2) -> mpret $ Sidecondition (f (adduid uid uids) used e1) (f (adduid uid uids) (w used) e2)- Sort _ -> mpret OK-- AbsurdLambda{} -> mpret OK--- fs uids used as =- mmpcase (False, prioNo, Nothing) as $ \as -> case as of- ALNil -> mpret OK- ALCons _ a as -> mpret $ Sidecondition (f uids used a) (fs uids used as)-- ALProj eas _ _ as -> mpret $ Sidecondition (fs uids used eas) (fs uids used as)--- ALConPar as -> fs uids used as-- w = map (\x -> case x of {Var v -> Var (v + 1); Const{} -> x})- adduid (Just uid) uids = uid : uids- adduid Nothing uids = uids---- ------------------------------------maybeor _ _ mainalt _ = mainalt--iotapossmeta :: ICExp o -> ICArgList o -> EE Bool-iotapossmeta ce@(Clos cl _) cargs = do- xs <- mapM ncaction cl- y <- nccargs cargs- return $ not (all id xs && y)- where- ncaction (Sub ce) = nonconstructor ce- ncaction Skip = return True- ncaction (Weak{}) = return True- nccargs CALNil = return True- nccargs (CALConcat (Clos cl margs) cargs) = do- x <- ncmargs cl margs- y <- nccargs cargs- return $ x && y- ncmargs cl (Meta m) = do- mb <- readIORef (mbind m)- case mb of- Nothing -> return False- Just x -> ncargs cl x- ncmargs cl (NotM args) = ncargs cl args- ncargs cl ALNil = return True- ncargs cl (ALCons _ a args) = do- x <- nonconstructor (Clos cl a)- y <- ncmargs cl args- return $ x && y-- ncargs _ (ALProj{}) = __IMPOSSIBLE__--- ncargs cl (ALConPar args) = ncmargs cl args-- nonconstructor :: ICExp o -> EE Bool- nonconstructor ce = do- res <- hnc True ce CALNil []- case res of- Blocked{} -> return False- Failed{} -> return False- NotB res -> case res of- HNMeta ce _ _ -> do- let (Clos _ (Meta m)) = ce- infos <- extractblkinfos m- if any (\info -> case info of {RINotConstructor -> True; _ -> False}) infos then do- return True- else- return False- -- return False -- return True -- ?? removes completeness - Yes, in DavidW1.additionRight- HNDone{} -> do- res <- hnn ce- case res of- NotB hne -> case hne of- HNApp _ (Const c) _ -> do- cd <- readIORef c- case cdcont cd of- Constructor{} -> return False- _ -> return True- _ -> return True- Blocked m _ -> return False -- not necessary to do check here because already done by hnn (!! if it's known that m stands for an eliminator then it cannot be constructor so True instead)- Failed _ -> return False--meta_not_constructor :: ICExp o -> EE (MB Bool (RefInfo o))-meta_not_constructor a =- mbcase (hnc True a CALNil []) $ \res -> case res of- HNMeta ce _ _ -> do- let (Clos _ (Meta m)) = ce- infos <- extractblkinfos m- if any (\info -> case info of {RINotConstructor -> True; _ -> False}) infos then do- b <- iotapossmeta ce CALNil- mbret $ not b- else- mbret False- HNDone{} -> mbret False---- -----------------------------------calcEqRState :: EqReasoningConsts o -> MExp o -> EE (MyPB o)-calcEqRState cs = f EqRSNone- where- f s e =- mmpcase (False, prioNo, Just (RIEqRState s)) e $ \e -> case e of- App _ _ (Const c) args -> case () of- _ | c == eqrcBegin cs -> fs [EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSChain] args- _ | c == eqrcStep cs -> fs [EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSPrf1, EqRSChain] args- _ | c == eqrcSym cs -> fs [EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSPrf2] args- _ | c == eqrcCong cs -> fs [EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSNone, EqRSPrf3] args- _ -> fs [] args- App _ _ (Var{}) args -> fs [] args- Lam _ (Abs _ b) -> f EqRSNone b- Pi _ _ _ it (Abs _ ot) -> mpret $ Sidecondition (f EqRSNone it) (f EqRSNone ot)- Sort{} -> mpret OK-- AbsurdLambda{} -> mpret OK--- fs ss args =- mmpcase (False, prioNo, Nothing) args $ \args -> case (ss, args) of- (_, ALNil) -> mpret OK- (s : ss, ALCons _ a args) -> mpret $ Sidecondition (f s a) (fs ss args)- ([], ALCons _ a args) -> mpret $ Sidecondition (f EqRSNone a) (fs [] args)-- (_, ALProj eas _ _ as) -> mpret $ Sidecondition (fs [] eas) (fs [] as) -- when eqr-hint is given manually, ss can be non-empty here--- (_ : ss, ALConPar args) -> fs ss args- ([], ALConPar args) -> fs [] args----- -----------------------------------pickid :: MId -> MId -> MId-pickid mid1@(Id _) _ = mid1-pickid _ mid2 = mid2---- -----------------------------------tcSearch :: Bool -> Ctx o -> CExp o -> MExp o -> EE (MyPB o)-tcSearch isdep ctx typ trm = mpret $ Sidecondition (checkeliminand trm)- (tcExp isdep ctx typ trm)---- ----------------------------
@@ -0,0 +1,172 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# OPTIONS_GHC -fno-warn-orphans #-}++-- | Agda-specific benchmarking structure.++module Agda.Benchmarking where++import Control.DeepSeq+import qualified Control.Exception as E++import GHC.Generics (Generic)++import System.IO.Unsafe++import Agda.Syntax.Abstract.Name+import Agda.Syntax.TopLevelModuleName (TopLevelModuleName)++import Agda.Utils.Benchmark (MonadBench(..))+import qualified Agda.Utils.Benchmark as B+import qualified Agda.Utils.IORef.Strict as Strict+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty++-- | Phases to allocate CPU time to.+data Phase+ = Parsing+ -- ^ Happy parsing and operator parsing.+ | Import+ -- ^ Import chasing.+ | Deserialization+ -- ^ Reading interface files.+ | Scoping+ -- ^ Scope checking and translation to abstract syntax.+ | Typing+ -- ^ Type checking and translation to internal syntax.+ | Termination+ -- ^ Termination checking.+ | Polarity+ -- ^ Polarity computation.+ | Positivity+ -- ^ Positivity checking.+ | Injectivity+ -- ^ Injectivity checking.+ | ProjectionLikeness+ -- ^ Checking for projection likeness.+ | Coverage+ -- ^ Coverage checking and compilation to case trees.+ | Highlighting+ -- ^ Generating highlighting info.+ | Serialization+ -- ^ Writing interface files.+ | DeadCode+ -- ^ Dead code elimination.+ | InterfaceInstantiateFull+ -- ^ Unfolding all metas before serialization.+ | DeadCodeReachable+ -- ^ Dead code reachable definitions subphase.+ | Graph+ -- ^ Subphase for 'Termination'.+ | RecCheck+ -- ^ Subphase for 'Termination'.+ | Reduce+ -- ^ Subphase for 'Termination'.+ | Level+ -- ^ Subphase for 'Termination'.+ | Compare+ -- ^ Subphase for 'Termination'.+ | With+ -- ^ Subphase for 'Termination'.+ | ModuleName+ -- ^ Subphase for 'Import'.+ | Compaction+ -- ^ Subphase for 'Deserialization': compacting interfaces.+ | BuildInterface+ -- ^ Subphase for 'Serialization'.+ | Sort+ -- ^ Subphase for 'Serialization'.+ | BinaryEncode+ -- ^ Subphase for 'Serialization'.+ | Compress+ -- ^ Subphase for 'Serialization'.+ | OperatorsExpr+ -- ^ Subphase for 'Parsing'.+ | OperatorsPattern+ -- ^ Subphase for 'Parsing'.+ | Free+ -- ^ Subphase for 'Typing': free variable computation.+ | OccursCheck+ -- ^ Subphase for 'Typing': occurs check for solving metas.+ | CheckLHS+ -- ^ Subphase for 'Typing': checking the LHS+ | CheckRHS+ -- ^ Subphase for 'Typing': checking the RHS+ | TypeSig+ -- ^ Subphase for 'Typing': checking a type signature+ | Generalize+ -- ^ Subphase for 'Typing': generalizing over `variable`s+ | InstanceSearch+ -- ^ Subphase for 'Typing': solving instance goals+ | Reflection+ -- ^ Subphase for 'Typing': evaluating elaborator reflection+ | ApplySection+ -- ^ Subphase for 'Typing': copying definitions for a module macro+ | InitialCandidates+ -- ^ Subphase for 'InstanceSearch': collecting initial candidates+ | FilterCandidates+ -- ^ Subphase for 'InstanceSearch': checking candidates for validity+ | OrderCandidates+ -- ^ Subphase for 'InstanceSearch': ordering candidates for specificity+ | CheckOverlap+ -- ^ Subphase for 'InstanceSearch': reducing overlapping instances+ | UnifyIndices+ -- ^ Subphase for 'CheckLHS': unification of the indices+ | InverseNameLookup+ | InverseModuleLookup+ | InverseInScope+ | InverseNameModuleRecompute+ | InverseInScopeRecompute+ | TopModule TopLevelModuleName+ | CubicalLeftInversion+ -- ^ Generating left inverses in LHS unification in cubical or cubical-compatible mode.+ | Typeclass QName+ | Definition QName+ deriving (Eq, Ord, Show, Generic)++instance Pretty Phase where+ pretty (TopModule m) = pretty m+ pretty (Definition q) = pretty q+ pretty a = text (show a)++instance NFData Phase++type Benchmark = B.Benchmark Phase+type Account = B.Account Phase++isModuleAccount :: Account -> Bool+isModuleAccount [] = True+isModuleAccount (TopModule{} : _) = True+isModuleAccount _ = False++isDefAccount :: Account -> Bool+isDefAccount [] = True+isDefAccount (Definition{} : _) = True+isDefAccount _ = False++isInternalAccount :: Account -> Bool+isInternalAccount (TopModule{} : _) = False+isInternalAccount (Definition{} : _) = False+isInternalAccount _ = True++-- * Benchmarking in the IO monad.++-- | Global variable to store benchmark statistics.+{-# NOINLINE benchmarks #-}+benchmarks :: Strict.IORef Benchmark+benchmarks = unsafePerformIO $ Strict.newIORef empty++instance MonadBench IO where+ type BenchPhase IO = Phase+ getBenchmark = Strict.readIORef benchmarks+ putBenchmark = Strict.writeIORef benchmarks+ finally = E.finally++-- | Benchmark an IO computation and bill it to the given account.+billToIO :: Account -> IO a -> IO a+billToIO = B.billTo++-- | Benchmark a pure computation and bill it to the given account.+billToPure :: Account -> a -> a+billToPure acc a = unsafePerformIO $ billToIO acc $ return a+{-# NOINLINE billToPure #-}
@@ -0,0 +1,207 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Interface for compiler backend writers.+module Agda.Compiler.Backend+ ( module Agda.Compiler.Backend.Base+ , Recompile(..), IsMain(..)+ , Flag+ , toTreeless+ , module Agda.Syntax.Treeless+ , module Agda.TypeChecking.Monad+ , module CheckResult+ -- For Agda.Main+ , backendInteraction+ , parseBackendOptions+ -- For InteractionTop+ , callBackend+ , callBackendInteractTop+ , callBackendInteractHole+ ) where++import Prelude hiding (null)++import Control.DeepSeq++import qualified Data.Map as Map+import qualified Data.Set as Set++import Agda.Utils.GetOpt++import Agda.Compiler.Backend.Base+import Agda.Compiler.Common+import Agda.Compiler.ToTreeless++import Agda.Interaction.Options+import Agda.Interaction.FindFile+import Agda.Interaction.Imports as CheckResult (CheckResult(CheckResult), crInterface, crWarnings, crMode)++import Agda.Syntax.Common (BackendName)+import Agda.Syntax.Treeless++import Agda.TypeChecking.Errors (getAllWarnings)+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Warnings++import Agda.Utils.CallStack (HasCallStack)+import Agda.Utils.FileName+import Agda.Utils.IndexedList+import Agda.Utils.List+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Maybe+import Agda.Syntax.Common (InteractionId)+import Agda.Syntax.Position (Range)++import Agda.Interaction.Command (CommandM)++-- Public interface -------------------------------------------------------++-- | Call the 'compilerMain' function of the given backend.+callBackend :: BackendName -> IsMain -> CheckResult -> TCM ()+callBackend name iMain checkResult =+ withKnownBackend name $ \(Backend b) ->+ compilerMain b iMain checkResult++-- | Call the 'backendInteractTop' function of the given backend.+callBackendInteractTop :: BackendName -> String -> CommandM ()+callBackendInteractTop name cmd =+ withKnownBackend name $ \(Backend b) ->+ whenJust (backendInteractTop b) \bi ->+ bi cmd++-- | Call the 'backendInteractHole' function of the given backend.+callBackendInteractHole ::+ BackendName -> String -> InteractionId -> Range -> String -> CommandM ()+callBackendInteractHole name cmd ii rng s =+ withKnownBackend name $ \(Backend b) ->+ whenJust (backendInteractHole b) \bi ->+ bi cmd ii rng s++-- | Run a monadic action given an existing backend.+-- Throws an error if the user requested an unknown backend.+withKnownBackend ::+ (MonadTCError m) => BackendName -> (Backend -> m ()) -> m ()+withKnownBackend name k = ifJustM (lookupBackend name) k $ do+ backends <- useSession lensBackends+ let backendSet = otherBackends ++! [ backendName b | Backend b <- backends ]+ typeError $ UnknownBackend name (Set.fromList backendSet)++-- | Backends that are not included in the state, but still available+-- to the user.+otherBackends :: [BackendName]+otherBackends = ["GHCNoMain", "QuickLaTeX"]++-- Internals --------------------------------------------------------------++data BackendWithOpts opts where+ BackendWithOpts ::+ NFData opts =>+ Backend' opts env menv mod def ->+ BackendWithOpts opts++backendWithOpts :: Backend -> Some BackendWithOpts+backendWithOpts (Backend backend) = Some (BackendWithOpts backend)++forgetOpts :: BackendWithOpts opts -> Backend+forgetOpts (BackendWithOpts backend) = Backend backend++bOptions :: Lens' (BackendWithOpts opts) opts+bOptions f (BackendWithOpts b) = f (options b) <&> \ opts -> BackendWithOpts b{ options = opts }++embedFlag :: Lens' b a -> Flag a -> Flag b+embedFlag l flag = l flag++embedOpt :: Lens' b a -> OptDescr (Flag a) -> OptDescr (Flag b)+embedOpt l = fmap (embedFlag l)++parseBackendOptions :: [Backend] -> [String] -> CommandLineOptions -> OptM ([Backend], CommandLineOptions)+parseBackendOptions backends argv opts0 =+ case makeAll backendWithOpts backends of+ Some bs -> do+ let agdaFlags = map' (embedOpt _2) (deadStandardOptions ++! standardOptions)+ backendFlags = do+ Some i <- forgetAll Some $ allIndices bs+ BackendWithOpts b <- [lookupIndex bs i]+ opt <- commandLineFlags b+ return $ embedOpt (_1 . lIndex i . bOptions) opt+ (backends, opts) <- getOptSimple (stripRTS argv)+ (agdaFlags ++! backendFlags) (embedFlag _2 . inputFlag)+ (bs, opts0)+ opts <- checkOpts opts+ return (forgetAll forgetOpts backends, opts)++backendInteraction :: AbsolutePath -> [Backend] -> TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM ()+backendInteraction mainFile backends setup check = do+ setup+ checkResult <- check mainFile++ -- reset warnings+ stTCWarnings `setTCLens` empty++ noMain <- optCompileNoMain <$> pragmaOptions+ let isMain | noMain = NotMain+ | otherwise = IsMain++ sequence_ [ compilerMain backend isMain checkResult | Backend backend <- backends ]++ -- print warnings that might have accumulated during compilation+ ws <- filter (not . isUnsolvedWarning . tcWarning) . Set.toAscList <$> getAllWarnings AllWarnings+ unless (null ws) $ alwaysReportSDoc "warning" 1 $+ -- Andreas, 2024-09-06 start warning list by a newline+ -- since type checker warnings are also newline separated.+ -- See e.g. test/Succeed/CompileBuiltinListWarning.warn.+ -- Also separate warnings by newlines (issue #6919).+ vcat $ concatMap (\ w -> [ "", prettyTCM w ]) ws+++compilerMain :: Backend' opts env menv mod def -> IsMain -> CheckResult -> TCM ()+compilerMain backend isMain0 checkResult = inCompilerEnv checkResult $ do+ locallyTC eActiveBackendName (const $ Just $ backendName backend) $ do+ -- BEWARE: Do not use @optOnlyScopeChecking@ here; it does not authoritatively describe the type-checking mode!+ -- InteractionTop currently may invoke type-checking with scope checking regardless of that flag.+ when (not (scopeCheckingSuffices backend) && crMode checkResult == ModuleScopeChecked) $+ typeError $ BackendDoesNotSupportOnlyScopeChecking $ backendName backend++ !i <- instantiateFull $ crInterface checkResult+ -- Andreas, 2017-08-23, issue #2714+ -- If the backend is invoked from Emacs, we can only get the --no-main+ -- pragma option now, coming from the interface file.+ !isMain <- ifM (optCompileNoMain <$> pragmaOptions)+ {-then-} (return NotMain)+ {-else-} (return isMain0)++ env <- preCompile backend (options backend)+ mods <- doCompile+ -- This inner function is called for both `Agda.Primitive` and the module in question,+ -- and all (distinct) imported modules. So avoid shadowing "isMain" or "i".+ (\ifaceIsMain iface ->+ Map.singleton (iTopLevelModuleName iface) <$>+ compileModule backend env ifaceIsMain iface)+ isMain i+ -- Note that `doCompile` calls `setInterface` for each distinct module in the graph prior to calling into+ -- `compileModule`. This last one is just to ensure it's reset to _this_ module.+ setInterface i+ postCompile backend env isMain mods++compileModule :: HasCallStack => Backend' opts env menv mod def -> env -> IsMain -> Interface -> TCM mod+compileModule backend env isMain i = do+ mName <- curMName+ -- The interface file will only exist if performing af full type-check, vs scoping.+ -- FIXME: Expecting backends to read the timestamp of the output path of the interface+ -- file for dirtiness checking is very roundabout and heavily couples backend+ -- implementations to the filesystem as the source of cache state.+ mifile <- (Just . filePath . intFilePath =<<) <$> findInterfaceFile mName+ r <- preModule backend env isMain (iTopLevelModuleName i) mifile+ case r of+ Skip m -> return m+ Recompile menv -> do+ defs <- map' snd . sortDefs <$> curDefs+ res <- mapM (compileDef' backend env menv isMain) defs+ postModule backend env menv isMain (iTopLevelModuleName i) res++compileDef' :: Backend' opts env menv mod def -> env -> menv -> IsMain -> Definition -> TCM def+compileDef' backend env menv isMain def =+ setCurrentRange (defName def) $+ compileDef backend env menv isMain def
@@ -0,0 +1,108 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Backend.Base where++import Control.DeepSeq (NFData, rnf)+import Data.Map (Map)+import Data.Text (Text)+import GHC.Generics (Generic)++import Agda.Syntax.Abstract.Name (QName)+import Agda.Syntax.Common (BackendName, IsMain, InteractionId)+import Agda.Syntax.TopLevelModuleName (TopLevelModuleName)+import Agda.Syntax.Position (Range)++import Agda.Interaction.Base (CommandM')+import Agda.Interaction.Options (OptDescr, Flag)++type BackendVersion = Text++data Backend_boot definition tcm where+ Backend :: NFData opts => Backend'_boot definition tcm opts env menv mod def -> Backend_boot definition tcm++data Backend'_boot definition tcm opts env menv mod def = Backend'+ { backendName :: BackendName+ -- ^ the name of the backend+ , backendVersion :: Maybe BackendVersion+ -- ^ Optional version information to be printed with @--version@.+ , options :: opts+ -- ^ Default options+ , commandLineFlags :: [OptDescr (Flag opts)]+ -- ^ Backend-specific command-line flags. Should at minimum contain a+ -- flag to enable the backend.+ , isEnabled :: opts -> Bool+ -- ^ Unless the backend has been enabled, @runAgda@ will fall back to+ -- vanilla Agda behaviour.+ , preCompile :: opts -> tcm env+ -- ^ Called after type checking completes, but before compilation starts.+ , postCompile :: env -> IsMain -> Map TopLevelModuleName mod ->+ tcm ()+ -- ^ Called after module compilation has completed. The @IsMain@ argument+ -- is @NotMain@ if the @--no-main@ flag is present.+ , preModule :: env -> IsMain -> TopLevelModuleName ->+ Maybe FilePath -> tcm (Recompile menv mod)+ -- ^ Called before compilation of each module. Gets the path to the+ -- @.agdai@ file to allow up-to-date checking of previously written+ -- compilation results. Should return @Skip m@ if compilation is not+ -- required. Will be @Nothing@ if only scope checking.+ , postModule :: env -> menv -> IsMain -> TopLevelModuleName ->+ [def] -> tcm mod+ -- ^ Called after all definitions of a module have been compiled.+ , compileDef :: env -> menv -> IsMain -> definition -> tcm def+ -- ^ Compile a single definition.+ , scopeCheckingSuffices :: Bool+ -- ^ True if the backend works if @--only-scope-checking@ is used.+ , mayEraseType :: QName -> tcm Bool+ -- ^ The treeless compiler may ask the Backend if elements+ -- of the given type maybe possibly erased.+ -- The answer should be 'False' if the compilation of the type+ -- is used by a third party, e.g. in a FFI binding.+ , backendInteractTop :: Maybe (BackendCommandTop tcm)+ -- ^ Backend-specific top-level interactive command.+ , backendInteractHole :: Maybe (BackendCommandHole tcm)+ -- ^ Backend-specific hole-level interactive command.+ }+ deriving Generic++data Recompile menv mod = Recompile menv | Skip mod++-- | For the sake of flexibility, we parametrize interactive commands with an+-- arbitrary string payload, e.g. to allow extra user input, or have backends+-- provide multiple commands with a single record field.+type CommandPayload = String++-- | The type of top-level backend interactive commmands.+type BackendCommandTop tcm+ = CommandPayload -- ^ arbitrary user payload+ -> CommandM' tcm ()++-- | The type of top-level backend interactive commmands.+type BackendCommandHole tcm+ = CommandPayload -- ^ arbitrary user payload+ -> InteractionId -- ^ the hole's ID+ -> Range -- ^ the hole's range+ -> String -- ^ the hole's contents+ -> CommandM' tcm ()++instance NFData (Backend_boot definition tcm) where+ rnf (Backend b) = rnf b++instance NFData opts => NFData (Backend'_boot definition tcm opts env menv mod def) where+ rnf (Backend' a b c d e f g h i j k l !m !n) =+ rnf a `seq`+ rnf b `seq`+ rnf c `seq`+ -- Andreas, 2025-07-31, cannot normalize functions with deepseq-1.5.2.0 (GHC 9.10.3).+ -- see https://github.com/haskell/deepseq/issues/111.+ -- rnf d `seq`+ -- rnf e `seq`+ -- rnf f `seq`+ -- rnf g `seq`+ -- rnf h `seq`+ -- rnf i `seq`+ -- rnf j `seq`+ rnf k `seq`+ -- rnf l `seq`+ -- rnf m `seq`+ -- rnf n `seq`+ ()
@@ -0,0 +1,24 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-|+ Built-in backends.+-}++module Agda.Compiler.Builtin where++import Agda.Compiler.Backend (Backend)++import Agda.Compiler.MAlonzo.Compiler (ghcBackend)+import Agda.Compiler.JS.Compiler (jsBackend)+import Agda.Interaction.Highlighting.Dot (dotBackend)+import Agda.Interaction.Highlighting.HTML (htmlBackend)+import Agda.Interaction.Highlighting.LaTeX (latexBackend)++builtinBackends :: [Backend]+builtinBackends =+ [ ghcBackend+ , jsBackend+ , dotBackend+ , htmlBackend+ , latexBackend+ ]
@@ -0,0 +1,106 @@+{-# OPTIONS_GHC -Wunused-imports #-}++------------------------------------------------------------------------+-- | A command which calls a compiler+------------------------------------------------------------------------++module Agda.Compiler.CallCompiler where++import qualified Control.Exception as E+import Control.Monad.Trans++import System.Exit+import System.IO+import System.Process++import Agda.TypeChecking.Monad++import Agda.Utils.Impossible++-- | Calls a compiler:+--+-- * Checks the exit code to see if the compiler exits successfully.+-- If not, then an exception is raised, containing the text the+-- compiler printed to stderr (if any).+--+-- * Uses the debug printout machinery to relay any progress+-- information the compiler prints to stdout.++callCompiler+ :: Bool+ -- ^ Should we actually call the compiler+ -> FilePath+ -- ^ The path to the compiler+ -> [String]+ -- ^ Command-line arguments.+ -> Maybe FilePath+ -- ^ The working directory that should be used when the compiler+ -- is invoked. The default is the current working directory.+ -> Maybe TextEncoding+ -- ^ Use the given text encoding, if any, when reading the output+ -- from the process (stdout and stderr).+ -> TCM ()+callCompiler doCall cmd args cwd enc =+ if doCall then do+ merrors <- callCompiler' cmd args cwd enc+ case merrors of+ Nothing -> return ()+ Just errors -> typeError (CompilationError errors)+ else+ alwaysReportSLn "compile.cmd" 1 $ "NOT calling: " ++ unwords (cmd : args)++-- | Generalisation of @callCompiler@ where the raised exception is+-- returned.+callCompiler'+ :: FilePath+ -- ^ The path to the compiler+ -> [String]+ -- ^ Command-line arguments.+ -> Maybe FilePath+ -- ^ The working directory that should be used when the compiler+ -- is invoked. The default is the current working directory.+ -> Maybe TextEncoding+ -- ^ Use the given text encoding, if any, when reading the output+ -- from the process (stdout and stderr).+ -> TCM (Maybe String)+callCompiler' cmd args cwd enc = do+ alwaysReportSLn "compile.cmd" 1 $ "Calling: " ++ unwords (cmd : args)+ (_, out, err, p) <-+ liftIO $ createProcess+ (proc cmd args) { std_err = CreatePipe+ , std_out = CreatePipe+ , cwd = cwd+ }++ -- In -v0 mode we throw away any progress information printed to+ -- stdout.+ case out of+ Nothing -> __IMPOSSIBLE__+ Just out -> forkTCM $ do+ -- The handle should be in text mode.+ liftIO $ hSetBinaryMode out False+ case enc of+ Nothing -> return ()+ Just enc -> liftIO $ hSetEncoding out enc+ progressInfo <- liftIO $ hGetContents out+ mapM_ (alwaysReportSLn "compile.output" 1) $ lines progressInfo++ errors <- liftIO $ case err of+ Nothing -> __IMPOSSIBLE__+ Just err -> do+ -- The handle should be in text mode.+ hSetBinaryMode err False+ case enc of+ Nothing -> return ()+ Just enc -> liftIO $ hSetEncoding err enc+ hGetContents err++ exitcode <- liftIO $ do+ -- Ensure that the output has been read before waiting for the+ -- process.+ _ <- E.evaluate (length errors)+ waitForProcess p++ case exitcode of+ ExitFailure _ -> return $ Just errors+ _ -> return Nothing
@@ -0,0 +1,197 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Common+ ( module Agda.Compiler.Common+ , IsMain(..)+ )+ where++import Prelude hiding ((!!))++import Data.List (sortBy, isPrefixOf)+import qualified Data.Map as Map+import Data.Set (Set)+import qualified Data.Set as Set+import qualified Data.HashMap.Strict as HMap+import Data.Char+import Data.Function (on)++import Control.Monad+import Control.Monad.State++import Agda.Syntax.Common+import Agda.Syntax.Internal as I+import Agda.Syntax.TopLevelModuleName++import Agda.Interaction.Options+import Agda.Interaction.Imports ( CheckResult, crInterface, crSource, Source(..) )+import Agda.Interaction.Library++import Agda.TypeChecking.Monad as TCM++import Agda.Utils.FileName+import Agda.Utils.List+import Agda.Utils.List1 ( pattern (:|) )+import Agda.Utils.Maybe+import Agda.Utils.WithDefault ( lensCollapseDefault )+import Agda.Utils.Tuple.Strict (Pair(..))+import Agda.Utils.Tuple.Strict qualified as Strict+import Agda.Utils.Maybe.Strict qualified as Strict++import Agda.Utils.Impossible++doCompile :: Monoid r => (IsMain -> Interface -> TCM r) -> IsMain -> Interface -> TCM r+doCompile f isMain i = do+ flip evalStateT Set.empty $ compilePrim $ doCompile' f isMain i+ where+ -- The Agda.Primitive module is only loaded if the --no-load-primitives flag was not given,+ -- thus, only try to compile it if we have visited it.+ compilePrim cont = do+ agdaPrim <- lift $ do+ agdaPrim <- TCM.topLevelModuleName agdaPrim+ Map.lookup agdaPrim <$> getVisitedModules+ case agdaPrim of+ Nothing -> cont+ Just prim ->+ mappend <$> doCompile' f NotMain (miInterface prim) <*> cont+ where+ agdaPrim = RawTopLevelModuleName+ { rawModuleNameRange = mempty+ , rawModuleNameParts = "Agda" :| "Primitive" : []+ , rawModuleNameInferred = False+ }+ -- N.B. The Range in TopLevelModuleName is ignored for Ord, so we can set it to mempty.++-- This helper function is called for both `Agda.Primitive` and the module in question.+-- It's also called for each imported module, recursively. (Avoiding duplicates).+doCompile'+ :: Monoid r+ => (IsMain -> Interface -> TCM r) -> (IsMain -> Interface -> StateT (Set ModuleName) TCM r)+doCompile' f isMain i = do+ alreadyDone <- gets (Set.member (iModuleName i))+ if alreadyDone then return mempty else do+ imps <- lift $+ map' miInterface . catMaybes <$>+ mapM (getVisitedModule . fst) (iImportedModules i)+ ri <- mconcat <$> mapM (doCompile' f NotMain) imps+ lift $ setInterface i+ r <- lift $ f isMain i+ modify (Set.insert $ iModuleName i)+ return $ mappend ri r++setInterface :: Interface -> TCM ()+setInterface i = do+ opts <- getsTC (stPersistentOptions . stPersistentState)+ setCommandLineOptions opts+ mapM_ setOptionsFromPragma (iDefaultPragmaOptions i ++! iFilePragmaOptions i)+ -- One could perhaps make the following command lazy. Note, however,+ -- that it doesn't suffice to replace setTCLens' with setTCLens,+ -- because the stPreImportedModules field is strict.+ stImportedModules `setTCLens'`+ Set.fromList (map' fst (iImportedModules i))+ stCurrentModule `setTCLens'`+ Strict.Just (iModuleName i :!: iTopLevelModuleName i)++curIF :: ReadTCState m => m Interface+curIF = do+ name <- curMName+ maybe __IMPOSSIBLE__ miInterface <$> getVisitedModule name++curMName :: ReadTCState m => m TopLevelModuleName+curMName = Strict.maybe __IMPOSSIBLE__ Strict.snd <$> useTC stCurrentModule++curDefs :: ReadTCState m => m Definitions+curDefs = HMap.filter (not . defNoCompilation) . (^. sigDefinitions) . iSignature <$> curIF++sortDefs :: Definitions -> [(QName, Definition)]+sortDefs defs =+ -- The list is sorted to ensure that the order of the generated+ -- definitions does not depend on things like the number of bits+ -- in an Int (see Issue 1900).+ sortBy (compare `on` fst) $+ HMap.toList defs++compileDir :: HasOptions m => m FilePath+compileDir = do+ mdir <- optCompileDir <$> commandLineOptions+ maybe __IMPOSSIBLE__ return mdir+++repl :: [String] -> String -> String+repl subs = go where+ go ('<':'<':c:'>':'>':s) | 0 <= i && i < length subs = subs !! i ++! go s+ where i = ord c - ord '0'+ go (c:s) = c : go s+ go [] = []+++-- | Sets up the compilation environment.+inCompilerEnv :: CheckResult -> TCM a -> TCM a+inCompilerEnv checkResult cont = do+ let mainI = crInterface checkResult+ checkedSource = crSource checkResult++ -- Preserve the state (the compiler modifies the state).+ -- Andreas, 2014-03-23 But we might want to collect Benchmark info,+ -- so use localTCState.+ -- FNF, 2017-02-22 we also want to keep the warnings we have encountered,+ -- so use localTCStateSaving and pick them out.+ (a , s) <- localTCStateSaving $ do++ -- Compute the output directory. Note: using commandLineOptions would make+ -- the current pragma options persistent when we setCommandLineOptions+ -- below.+ opts <- getsTC $ stPersistentOptions . stPersistentState+ compileDir <- case optCompileDir opts of+ Just dir -> pure dir+ Nothing -> do+ -- The default output directory is the project root.+ let tm = iTopLevelModuleName mainI+ f <- srcFilePath $ srcOrigin checkedSource+ pure $ filePath $ projectRoot f tm+ setCommandLineOptions $+ opts { optCompileDir = Just compileDir }++ -- Andreas, 2017-08-23, issue #2714 recover pragma option --no-main+ -- Unfortunately, a pragma option is stored in the interface file as+ -- just a list of strings, thus, the solution is a bit of hack:+ -- We match on whether @["--no-main"]@ is one of the stored options.+ let iFilePragmaStrings = map' pragmaStrings . iFilePragmaOptions+ when (["--no-main"] `elem` iFilePragmaStrings mainI) $+ setTCLens (stPragmaOptions . lensOptCompileMain . lensCollapseDefault) False++ -- Perhaps all pragma options from the top-level module should be+ -- made available to the compiler in a suitable way. Here are more+ -- hacks:+ when (any (any (flip elem ["--cubical", "--cubical=full"])) $ iFilePragmaStrings mainI) $+ setTCLens (stPragmaOptions . lensOptCubical) $ Just CFull+ when (any (any (flip elem ["--erased-cubical", "--cubical=erased"])) $ iFilePragmaStrings mainI) $+ setTCLens (stPragmaOptions . lensOptCubical) $ Just CErased+ when (any ("--cubical=no-glue" `elem`) $ iFilePragmaStrings mainI) $+ setTCLens (stPragmaOptions . lensOptCubical) $ Just CWithoutGlue++ setScope $ iInsideScope mainI -- so that compiler errors don't use overly qualified names+ -- András, 2025-08-30: this is a fresh creation of a scope from an interface+ -- so inverse scopes don't yet exist.+ recomputeInverseScope+ ignoreAbstractMode cont+ -- keep generated warnings+ let newWarnings = s ^. stTCWarnings+ stTCWarnings `setTCLens` newWarnings+ return a++topLevelModuleName ::+ ReadTCState m => ModuleName -> m TopLevelModuleName+topLevelModuleName m = do+ -- Interfaces of visited modules.+ visited <- map' miInterface . Map.elems <$> getVisitedModules+ -- find the module with the longest matching prefix to m+ let is = sortBy (compare `on` (length . mnameToList . iModuleName)) $+ filter' (\i -> mnameToList (iModuleName i) `isPrefixOf`+ mnameToList m)+ visited+ case is of+ (i : _) -> return (iTopLevelModuleName i)+ -- if we did not get anything, it may be because m is a section+ -- (a module _ ), see e.g. #1866+ [] -> curMName
@@ -1,167 +0,0 @@-{-# LANGUAGE CPP #-}--- | Intermediate abstract syntax tree used in the compiler. Pretty close to--- Epic syntax.-module Agda.Compiler.Epic.AuxAST where--import Data.Set (Set)-import qualified Data.Set as S--import Agda.Syntax.Abstract.Name--import Agda.Compiler.Epic.Interface--#include "../../undefined.h"-import Agda.Utils.Impossible--type Comment = String-type Inline = Bool--data Fun- = Fun- { funInline :: Inline- , funName :: Var- , funQName :: Maybe QName- , funComment :: Comment- , funArgs :: [Var]- , funExpr :: Expr- }- | EpicFun- { funName :: Var- , funQName :: Maybe QName- , funComment :: Comment- , funEpicCode :: String --EpicCode- }- deriving (Eq, Ord, Show)--data Lit- = LInt Integer- | LChar Char- | LString String- | LFloat Double- deriving (Show, Ord, Eq)---data Expr- = Var Var- | Lit Lit- | Lam Var Expr- | Con Tag QName [Expr]- | App Var [Expr]- | Case Expr [Branch]- | If Expr Expr Expr- | Let Var Expr Expr- | Lazy Expr- | UNIT- | IMPOSSIBLE- deriving (Show, Ord, Eq)--data Branch- = Branch {brTag :: Tag, brName :: QName, brVars :: [Var], brExpr :: Expr}- | BrInt {brInt :: Int, brExpr :: Expr}- | Default {brExpr :: Expr}- deriving (Show, Ord, Eq)--getBrVars :: Branch -> [Var]-getBrVars (Branch {brVars = vs}) = vs-getBrVars _ = []------------------------------------------------------------------------------------- * Some smart constructors---- | Smart constructor for let expressions to avoid unneceessary lets-lett :: Var -> Expr -> Expr -> Expr-lett v (Var v') e' = subst v v' e'-lett v e e' = if v `elem` fv e' then Let v e e' else e'---- | Some things are pointless to make lazy-lazy :: Expr -> Expr-lazy (Lazy e) = Lazy e-lazy (Lit l) = Lit l-lazy UNIT = UNIT-lazy x = Lazy x---- | If casing on the same expression in a sub-expression, we know what branch to--- pick-casee :: Expr -> [Branch] -> Expr-casee x brs = Case x [br{brExpr = casingE br (brExpr br)} | br <- brs]- where- casingE br expr = let rec = casingE br in case expr of- Var v -> Var v- Lit l -> Lit l- Lam v e -> Lam v (rec e)- Con t n es -> Con t n (map rec es)- App v es -> App v (map rec es)- Case e brs | expr == e -> case filter (sameCon br) brs of- [] -> Case (rec e) [b {brExpr = rec (brExpr b)} | b <- brs]- [b] -> substs (getBrVars br `zip` getBrVars b) (brExpr b)- _ -> __IMPOSSIBLE__- | otherwise -> Case (rec e) [b {brExpr = rec (brExpr b)} | b <- brs]- If e1 e2 e3 -> If (rec e1) (rec e2) (rec e3)- Let v e1 e2 -> Let v (rec e1) (rec e2)- Lazy e -> Lazy (rec e)- UNIT -> UNIT- IMPOSSIBLE -> IMPOSSIBLE- sameCon (Branch {brTag = t1}) (Branch {brTag = t2}) = t1 == t2- sameCon (BrInt {brInt = i1}) (BrInt {brInt = i2}) = i1 == i2- sameCon _ _ = False---- | Smart constructor for applications to avoid empty applications-apps :: Var -> [Expr] -> Expr-apps v [] = Var v-apps v as = App v as------------------------------------------------------------------------------------- * Substitution---- | Substitution-subst :: Var -- ^ Substitute this ...- -> Var -- ^ with this ...- -> Expr -- ^ in this.- -> Expr-subst var var' expr = case expr of- Var v | var == v -> Var var'- | otherwise -> Var v- Lit l -> Lit l- Lam v e | var == v -> Lam v e- | otherwise -> Lam v (subst var var' e)- Con t q es -> Con t q (map (subst var var') es)- App v es | var == v -> App var' (map (subst var var') es)- | otherwise -> App v (map (subst var var') es)- Case e brs -> Case (subst var var' e) (map (substBranch var var') brs)- If a b c -> let s = subst var var'- in If (s a) (s b) (s c)- Let v e e' | var == v -> Let v (subst var var' e) e'- | otherwise -> Let v (subst var var' e) (subst var var' e')- Lazy e -> Lazy (subst var var' e)- UNIT -> UNIT- IMPOSSIBLE -> IMPOSSIBLE--substs :: [(Var, Var)] -> Expr -> Expr-substs ss e = foldr (uncurry subst) e ss--substBranch :: Var -> Var -> Branch -> Branch-substBranch x e br = br { brExpr = subst x e (brExpr br) }---- | Get the free variables in an expression-fv :: Expr -> [Var]-fv = S.toList . fv'- where- fv' :: Expr -> Set Var- fv' expr = case expr of- Var v -> S.singleton v- Lit _ -> S.empty- Lam v e1 -> S.delete v (fv' e1)- Con _ _ es -> S.unions (map fv' es)- App v es -> S.insert v $ S.unions (map fv' es)- Case e brs -> fv' e `S.union` S.unions (map fvBr brs)- If a b c -> S.unions (map fv' [a,b,c])- Let v e e' -> fv' e `S.union` (S.delete v $ fv' e')- Lazy e -> fv' e- UNIT -> S.empty- IMPOSSIBLE -> S.empty-- fvBr :: Branch -> Set Var- fvBr b = case b of- Branch _ _ vs e -> fv' e S.\\ S.fromList vs- BrInt _ e -> fv' e- Default e -> fv' e
@@ -1,42 +0,0 @@--- | Perform simple optimisations based on case-laws-module Agda.Compiler.Epic.CaseOpts where--import Control.Applicative-import Control.Monad--import Agda.TypeChecking.Monad--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface--caseOpts :: [Fun] -> Compile TCM [Fun]-caseOpts = mapM $ \ def -> case def of- Fun{} -> do- e' <- caseOptsExpr (funExpr def)- return def { funExpr = e' }- _ -> return def---- | Run the case-opts on an expression-caseOptsExpr :: Expr -> Compile TCM Expr-caseOptsExpr expr = case expr of- Var v -> return $ Var v- Lit l -> return $ Lit l- Lam v e -> Lam v <$> caseOptsExpr e- Con c n es -> Con c n <$> mapM caseOptsExpr es- App v es -> apps v <$> mapM caseOptsExpr es- -- If there is only one constructor branch, perform a projection to get the result- Case e [Branch {brVars = vs, brExpr = eorg}] -> do- e' <- caseOptsExpr eorg- bindExpr e $ \var ->- return $ foldr (\(v, n) -> lett v $ App "proj" [Lit (LInt n), Var var]) e'- $ zip vs [0..]- -- If there is only a default branch, the case is not necessary- Case e [Default{brExpr = e'}] -> caseOptsExpr e'- Case e brs -> Case <$> caseOptsExpr e <*> (mapM (\br -> do e' <- caseOptsExpr (brExpr br)- return br {brExpr = e'}) brs)- If a b c -> If <$> caseOptsExpr a <*> caseOptsExpr b <*> caseOptsExpr c- Let v e1 e2 -> Let v <$> caseOptsExpr e1 <*> caseOptsExpr e2- Lazy e -> Lazy <$> caseOptsExpr e- UNIT -> return UNIT- IMPOSSIBLE -> return IMPOSSIBLE
@@ -1,214 +0,0 @@-{-# LANGUAGE CPP #-}---- | Contains the state monad that the compiler works in and some functions--- for tampering with the state.-module Agda.Compiler.Epic.CompileState where--import Control.Applicative-import Control.Monad.State-import Data.List-import Data.Map(Map)-import qualified Data.Map as M-import Data.Maybe-import Data.Monoid-import Data.Set(Set)-import qualified Data.Set as S--import Agda.Compiler.Epic.AuxAST as AuxAST-import Agda.Compiler.Epic.Interface-import Agda.Interaction.Options-import Agda.Syntax.Internal-import Agda.Syntax.Concrete(TopLevelModuleName)-import Agda.Syntax.Common-import Agda.TypeChecking.Monad (TCM, internalError, defType, theDef, getConstInfo, sigDefinitions, stImports, stPersistentOptions, stPersistent)-import qualified Agda.TypeChecking.Monad as TM-import Agda.TypeChecking.Reduce--#include "../../undefined.h"-import Agda.Utils.Impossible-import Agda.Utils.Monad----- | Stuff we need in our compiler-data CompileState = CompileState- { nameSupply :: [Var]- , compiledModules :: Map TopLevelModuleName (EInterface, Set FilePath)- , curModule :: EInterface- , importedModules :: EInterface- , curFun :: String- } deriving Show---- | The initial (empty) state-initCompileState :: CompileState-initCompileState = CompileState- { nameSupply = map (('h':) . show) [0 :: Integer ..]- , compiledModules = M.empty- , curModule = mempty- , importedModules = mempty- , curFun = undefined- }---- | Compiler monad-type Compile = StateT CompileState---- | When normal errors are not enough-epicError :: String -> Compile TCM a-epicError = lift . internalError---- | Modify the state of the current module's Epic Interface-modifyEI :: (EInterface -> EInterface) -> Compile TCM ()-modifyEI f = modify $ \s -> s {curModule = f (curModule s)}---- | Get the state of the current module's Epic Interface-getsEI :: (EInterface -> a) -> Compile TCM a-getsEI f = gets (f . curModule)---- | Returns the type of a definition given its name-getType :: QName -> Compile TCM Type-getType q = do- map <- lift (gets (sigDefinitions . stImports))- return $ maybe __IMPOSSIBLE__ defType (M.lookup q map)---- | Create a name which can be used in Epic code from a QName.-unqname :: QName -> Var-unqname qn = case nameId $ qnameName qn of- NameId name modul -> 'd' : show modul- ++ "_" ++ show name---- * State modifiers--resetNameSupply :: Compile TCM ()-resetNameSupply = modify $ \s -> s {nameSupply = nameSupply initCompileState}--getDelayed :: QName -> Compile TCM Bool-getDelayed q = lookInterface (M.lookup q . defDelayed) (return False)--putDelayed :: QName -> Bool -> Compile TCM ()-putDelayed q d = modifyEI $ \s -> s {defDelayed = M.insert q d (defDelayed s)}--newName :: Compile TCM Var-newName = do- n:ns <- gets nameSupply- modify $ \s -> s { nameSupply = ns}- return n--putConstrTag :: QName -> Tag -> Compile TCM ()-putConstrTag q t = modifyEI $ \s -> s { constrTags = M.insert q t $ constrTags s }--assignConstrTag :: QName -> Compile TCM Tag-assignConstrTag constr = assignConstrTag' constr []--assignConstrTag' :: QName -> [QName] -> Compile TCM Tag-assignConstrTag' constr constrs = do- constrs <- concat <$> mapM ((getDataCon =<<) . getConData) (constr : constrs)- tags <- catMaybes <$> mapM getConstrTag' constrs- let tag = head $ map Tag [0..] \\ tags- putConstrTag constr tag- return tag--getConData :: QName -> Compile TCM QName-getConData con = do- lmap <- lift (gets (TM.sigDefinitions . TM.stImports))- case M.lookup con lmap of- Just def -> case theDef def of- c@(TM.Constructor{}) -> return $ TM.conData c- _ -> __IMPOSSIBLE__- Nothing -> __IMPOSSIBLE__--getDataCon :: QName -> Compile TCM [QName]-getDataCon con = do- lmap <- lift (gets (TM.sigDefinitions . TM.stImports))- case M.lookup con lmap of- Just def -> case theDef def of- d@(TM.Datatype{}) -> return $ TM.dataCons d- r@(TM.Record{}) -> return [ TM.recCon r]- _ -> __IMPOSSIBLE__- Nothing -> __IMPOSSIBLE__--getConstrTag :: QName -> Compile TCM Tag-getConstrTag con = lookInterface (M.lookup con . constrTags)- (assignConstrTag con)--getConstrTag' :: QName -> Compile TCM (Maybe Tag)-getConstrTag' con = do- cur <- gets curModule- case M.lookup con (constrTags cur) of- Just x -> return (Just x)- Nothing -> do- imps <- gets importedModules- return $ M.lookup con (constrTags imps)--addDefName :: QName -> Compile TCM ()-addDefName q = do- modifyEI $ \s -> s {definitions = S.insert (unqname q) $ definitions s }--topBindings :: Compile TCM (Set Var)-topBindings = S.union <$> gets (definitions . importedModules) <*> gets (definitions . curModule)--getConArity :: QName -> Compile TCM Int-getConArity n = lookInterface (M.lookup n . conArity) __IMPOSSIBLE__--putConArity :: QName -> Int -> Compile TCM ()-putConArity n p = modifyEI $ \s -> s { conArity = M.insert n p (conArity s) }--putMain :: QName -> Compile TCM ()-putMain m = modifyEI $ \s -> s { mainName = Just m }--getMain :: Compile TCM Var-getMain = maybe (epicError "Where is main? :(") (return . unqname) =<< getsEI mainName--lookInterface :: (EInterface -> Maybe a) -> Compile TCM a -> Compile TCM a-lookInterface f def = do- cur <- gets curModule- case f cur of- Just x -> return x- Nothing -> do- imps <- gets importedModules- case f imps of- Nothing -> def- Just x -> return x--constrInScope :: QName -> Compile TCM Bool-constrInScope name = do- cur <- gets curModule- case M.lookup name (constrTags cur) of- Just x -> return True- Nothing -> do- imps <- gets importedModules- case M.lookup name (constrTags imps) of- Nothing -> return False- Just x -> return True--getForcedArgs :: QName -> Compile TCM ForcedArgs-getForcedArgs q = lookInterface (M.lookup q . forcedArgs) __IMPOSSIBLE__--putForcedArgs :: QName -> ForcedArgs -> Compile TCM ()-putForcedArgs n f = do- b <- lift $ gets (optForcing . stPersistentOptions . stPersistent)- let f' | b = f- | otherwise = replicate (length f) NotForced- modifyEI $ \s -> s {forcedArgs = M.insert n f' $ forcedArgs s}--replaceAt :: Int -- ^ replace at- -> [a] -- ^ to replace- -> [a] -- ^ replace with- -> [a] -- ^ result?-replaceAt n xs inserts = let (as, _:bs) = splitAt n xs in as ++ inserts ++ bs---- | Copy pasted from MAlonzo, HAHA!!!--- Move somewhere else!-constructorArity :: Num a => QName -> TCM a-constructorArity q = do- def <- getConstInfo q- a <- normalise $ defType def- case theDef def of- TM.Constructor{ TM.conPars = np } -> return . fromIntegral $ arity a - np- _ -> internalError $ "constructorArity: non constructor: " ++ show q---- | Bind an expression to a fresh variable name-bindExpr :: Expr -> (Var -> Compile TCM Expr) -> Compile TCM Expr-bindExpr expr f = case expr of- AuxAST.Var v -> f v- _ -> do- v <- newName- lett v expr <$> f v
@@ -1,265 +0,0 @@-{-# LANGUAGE CPP #-}--- | Epic compiler backend.-module Agda.Compiler.Epic.Compiler(compilerMain) where--import Control.Applicative-import Control.Monad-import Control.Monad.Reader-import Control.Monad.State-import qualified Data.ByteString.Lazy as BS-import qualified Data.Map as M-import Data.Set(Set)-import qualified Data.Set as S-import Data.Maybe-import Data.Monoid-import qualified Language.Haskell.Exts.Syntax as Haskell-import System.Directory-import System.Exit-import System.FilePath hiding (normalise)-import System.Process hiding (env)--import Paths_Agda-import Agda.Compiler.MAlonzo.Pretty -- TODO: Move shared code to Compiler.*-import Agda.Compiler.MAlonzo.Primitives (checkTypeOfMain)-import Agda.Interaction.FindFile-import Agda.Interaction.Options-import Agda.Interaction.Imports-import qualified Agda.Syntax.Concrete.Name as CN-import Agda.Syntax.Internal hiding (Term(..))-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Serialise-import Agda.Utils.FileName--import qualified Agda.TypeChecking.Pretty as P--import Agda.Compiler.Epic.CompileState-import qualified Agda.Compiler.Epic.CaseOpts as COpts-import qualified Agda.Compiler.Epic.ForceConstrs as ForceC-import Agda.Compiler.Epic.Epic-import Agda.Compiler.Epic.Interface-import qualified Agda.Compiler.Epic.Erasure as Eras-import qualified Agda.Compiler.Epic.FromAgda as FAgda-import qualified Agda.Compiler.Epic.Forcing as Forcing-import qualified Agda.Compiler.Epic.Injection as ID-import qualified Agda.Compiler.Epic.NatDetection as ND-import qualified Agda.Compiler.Epic.Primitive as Prim-import qualified Agda.Compiler.Epic.Smashing as Smash--#include "../../undefined.h"-import Agda.Utils.Impossible--compilePrelude :: Compile TCM ()-compilePrelude = do- dataDir <- (</> "EpicInclude") <$> liftIO getDataDir- pwd <- liftIO $ getCurrentDirectory- liftIO $ setCurrentDirectory dataDir- let prelude = "AgdaPrelude"- uptodate <- liftIO $ (prelude <.> "ei") `isNewerThan` (prelude <.> "e")- when (not uptodate) $ callEpic False [ "-c" , prelude <.> "e" ]- liftIO $ setCurrentDirectory pwd---- | Compile an interface into an executable using Epic-compilerMain :: Interface -> TCM ()-compilerMain inter = do- epic_exist <- liftIO $ rawSystem "ghc-pkg" ["-v0", "field", "epic", "id"]- case epic_exist of- ExitSuccess -> flip evalStateT initCompileState $ do- compilePrelude- setEpicDir inter- (_, imports) <- compileModule inter- main <- getMain- runEpicMain main (S.toList imports) (iModuleName inter)-- ExitFailure _ -> internalError $ unlines- [ "Agda cannot find the Epic compiler."- , "This can perhaps be fixed by running `cabal install epic'."- , "See the README for more information."- ]--outFile :: CN.TopLevelModuleName -> Compile TCM FilePath-outFile mod = do- let (dir, fn) = splitFileName . foldl1 (</>) $ CN.moduleNameParts mod- fp | dir == "./" = "src" </> fn- | otherwise = "src" </> dir </> fn- liftIO $ createDirectoryIfMissing True ("src" </> dir)- return $ fp- where- repldot c = map (\c' -> if c' == '.' then c else c')--readEInterface :: FilePath -> Compile TCM EInterface-readEInterface file = fromMaybe __IMPOSSIBLE__- <$> lift (decode =<< liftTCM (liftIO (BS.readFile file)))--compileModule :: Interface -> Compile TCM (EInterface, Set FilePath)-compileModule i = do- cm <- gets compiledModules- let moduleName = toTopLevelModuleName $ iModuleName i- file <- outFile moduleName- case M.lookup moduleName cm of- Just eifs -> return eifs- Nothing -> do- imports <- map miInterface . catMaybes- <$> mapM (lift . getVisitedModule . toTopLevelModuleName)- (iImportedModules i)- (ifaces, limps) <- mapAndUnzipM compileModule imports- let imps = S.unions limps- modify $ \s -> s { importedModules = importedModules s `mappend` mconcat ifaces }- ifile <- maybe __IMPOSSIBLE__ filePath <$> lift (findInterfaceFile moduleName)- let eifFile = file <.> "aei"- uptodate <- liftIO $ isNewerThan eifFile ifile- (eif, imps') <- case uptodate of- True -> do- lift $ reportSLn "" 1 $- show (iModuleName i) ++ " : no compilation is needed."- eif <- readEInterface eifFile- modify $ \s -> s { curModule = eif }- return (eif, S.insert file imps)- False -> do- lift $ reportSLn "" 1 $- "Compiling: " ++ show (iModuleName i)- resetNameSupply- initialAnalysis i- let defns = M.toList $ sigDefinitions $ iSignature i- -- Epic cannot parse files with no definitions- if (not $ null defns) then do- code <- compileDefns defns- runEpic file (S.toList imps) code- eif <- gets curModule- lift $ do- bif <- encode eif- liftIO $ BS.writeFile eifFile bif- return (eif, S.insert file imps)- else- flip (,) imps <$> gets curModule- modify $ \s -> s { compiledModules = (M.insert moduleName (eif, imps') (compiledModules s))}- return (eif, imps')---- | Before running the compiler, we need to store some things in the state,--- namely constructor tags, constructor irrelevancies and the delayed field--- in functions (for coinduction).-initialAnalysis :: Interface -> Compile TCM ()-initialAnalysis inter = do- Prim.initialPrims- modify $ \s -> s {curModule = mempty}- let defs = M.toList $ sigDefinitions $ iSignature inter- forM_ defs $ \(q, def) -> do- addDefName q- case theDef def of- d@(Datatype {}) -> do- saker <- ND.isNatish q d- case saker of- Just (_, [zer, suc]) -> do- putConstrTag zer (PrimTag "primZero")- putConstrTag suc (PrimTag "primSuc")- _ -> return ()- Constructor {conPars = np} -> do- putForcedArgs q . drop (fromIntegral np) . ForceC.makeForcedArgs $ defType def- putConArity q =<< lift (constructorArity q)- f@(Function{}) -> do- when ("main" == show (qnameName q)) $ do- -- lift $ liftTCM $ checkTypeOfMain q (defType def)- putMain q- putDelayed q $ case funDelayed f of- Delayed -> True- NotDelayed -> False- a@(Axiom {}) -> do- case defEpicDef def of- Nothing -> putDelayed q True- _ -> return ()- _ -> return ()--idPrint s m x = do- -- liftIO $ putStrLn s- m x---- | Perform the chain of compilation stages, from definitions to epic code-compileDefns :: [(QName, Definition)] -> Compile TCM EpicCode-compileDefns defs = do- -- We need to handle sharp (coinduction) differently, so we get it here.- msharp <- lift $ getBuiltin' builtinSharp- emits <- return defs- >>= idPrint "findInjection" ID.findInjection- >>= idPrint "fromAgda" (FAgda.fromAgda msharp)- >>= idPrint "forcing" Forcing.remForced- >>= idPrint "irr" ForceC.forceConstrs- >>= idPrint "primitivise" Prim.primitivise- >>= idPrint "smash" Smash.smash'em- >>= idPrint "erasure" Eras.erasure- >>= idPrint "caseOpts" COpts.caseOpts- >>= idPrint "done" return- unlines <$> mapM prettyEpicFun emits---- | Change the current directory to Epic folder, create it if it doesn't already--- exist.-setEpicDir :: Interface -> Compile (TCMT IO) ()-setEpicDir mainI = do- let tm = toTopLevelModuleName $ iModuleName mainI- f <- lift $ findFile tm- compileDir' <- lift $ gets (fromMaybe (filePath $ CN.projectRoot f tm) .- optCompileDir . stPersistentOptions . stPersistent)- compileDir <- liftIO $ canonicalizePath compileDir'- liftIO $ setCurrentDirectory compileDir- liftIO $ createDirectoryIfMissing False "Epic"- liftIO $ setCurrentDirectory $ compileDir </> "Epic"---- | Make a program from the given Epic code.------ The program is written to the file @../m@, where m is the last--- component of the given module name.-runEpic :: FilePath -> [FilePath] -> EpicCode -> Compile TCM ()-runEpic fp imports code = do- dataDir <- (</> "EpicInclude") <$> liftIO getDataDir- let imports' = unlines ["include \"" ++ imp ++ "\""- | imp <- (dataDir </> "AgdaPrelude.ei")- : map (<.> "ei") imports]- code' = imports' ++ code- liftIO $ writeFile (fp <.> "e") code'- callEpic True $- [ "-c", fp <.> "e" ]---- | Create the Epic main file, which calls the Agda main function-runEpicMain :: Var -> [FilePath] -> ModuleName -> Compile TCM ()-runEpicMain mainName imports m = do- dataDir <- (</> "EpicInclude") <$> liftIO getDataDir- let imports' = (dataDir </> "AgdaPrelude") : imports- let code = unlines ["include \"" ++ imp <.> "ei" ++ "\""- | imp <- imports'- ] ++ "main() -> Unit = init() ; " ++ mainName ++ "(unit)"- liftIO $ writeFile ("main" <.> "e") code- let outputName = case mnameToList m of- [] -> __IMPOSSIBLE__- ms -> last ms- callEpic' $ \epic ->- [ "main" <.> "e"- , "-o", ".." </> show outputName- ]- ++ epic ++ map (<.> "o") imports'---- | Call epic, with a given set of flags, if the |Bool| is True then include--- the command line flags at the end-callEpic :: Bool -> [String] -> Compile TCM ()-callEpic incEFlags flags = callEpic' $ \epicFlags ->- flags ++ if incEFlags then epicFlags else []---- | Call epic with a given set of flags, the argument function receives the flags given--- at the command line-callEpic' :: ([String] -> [String]) -> Compile TCM ()-callEpic' flags = do- epicFlags <- optEpicFlags <$> lift commandLineOptions- dataDir <- (</> "EpicInclude") <$> liftIO getDataDir- let epic = "epic"- epicCommand =- [ "-keepc"- -- , "-g"- -- , "-checking", "0"- -- , "-trace"- , "-i", dataDir </> "stdagda" <.> "c"- ] ++ flags epicFlags- lift $ reportSLn "" 1 $- "calling: " ++ unwords (epic : epicCommand)- res <- liftIO $ system (unwords (epic : epicCommand))- -- rawSystem epic epicCommand- case res of- ExitSuccess -> return ()- ExitFailure i -> epicError $ "Epic returned " ++ show res ++ ", which should not happen. Please report this as a bug."
@@ -1,110 +0,0 @@-{-# LANGUAGE CPP #-}---- | Pretty-print the AuxAST to valid Epic code.-module Agda.Compiler.Epic.Epic- ( prettyEpicFun- , prettyEpic- ) where--import Control.Monad.State--import Data.Char-import Data.List--import Data.Map (Map)-import qualified Data.Map as M--import Agda.TypeChecking.Monad-import Agda.TypeChecking.Pretty (prettyTCM)-import Agda.TypeChecking.Reduce--#include "../../undefined.h"-import Agda.Utils.Impossible---import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface---- * Some auxilliary pretty-printer functions-(<+>) :: String -> String -> String-x <+> y = x ++ " " ++ y-infixr 6 <+>--($$) :: String -> String -> String-x $$ y = x ++ "\n" ++ y-infixr 5 $$--many :: [String] -> String-many vs = paren $ intercalate ", " vs--many' :: [String] -> String-many' [] = ""-many' vs = paren $ intercalate ", " vs--paren :: String -> String-paren s = "(" <+> s <+> ")"--curly :: String -> String-curly s = "{-" <+> s <+> "-}"---- * Pretty-printer--- | Print a function to an Epic string-prettyEpicFun :: MonadTCM m => Fun -> Compile m String-prettyEpicFun (Fun inline name mqname comment vars e) = do- {-- defs <- lift (gets (sigDefinitions . stImports))- typ <- case mqname >>= flip M.lookup defs of- Nothing -> return "-"- Just def -> do- doc <- lift $ prettyTCM =<< normalise (defType def)- return $ show doc- -}- return $- "--" <+> comment $$- -- unlines (map ("-- " <+>) (lines typ)) $$- (if inline then "%inline " else "") ++ name- <+> many (map typVar vars) <+> "-> Any" <+> "=" <+> prettyEpic e--prettyEpicFun (EpicFun name _mqname comment def) = return $- "--" <+> comment $$- {-"%inline" <+> -} name <+> def---- | Print expression to Epic expression-prettyEpic :: Expr -> String-prettyEpic expr = case expr of- Var v -> v- Lit l -> prettyEpicLit l- Lam x e -> paren $ "\\" <+> typVar x <+> "." <+> paren (prettyEpic e)-- __IMPOSSIBLE__ -- We have lambda lifted away all λs- Con (Tag t) q args -> curly (show q) <+> paren ("Con" <+> show t <+> many (map prettyEpic args))- If a b c -> "if" <+> prettyEpic a <+> "then" <+> prettyEpic b <+> "else" <+> prettyEpic c- Let v e e' -> "let" <+> typVar v <+> "=" <+> prettyEpic (id e) <+> "in" <+> prettyEpic e'- App "proj" (Lit (LInt n) : e : es) -> paren (prettyEpic e <+> "!" <+> show n) <+> many' (map prettyEpic es)- App v es -> v <+> many' (map (prettyEpic . id) es)- Case e brs -> "case" <+> prettyEpic e <+> "of {"- <+> intercalate "\n | " (map prettyEpicBr brs) <+> "}"- Lazy e -> "lazy" <+> paren (prettyEpic e)- UNIT -> "unit"- IMPOSSIBLE -> "impossible"- _ -> __IMPOSSIBLE__--prettyEpicBr :: Branch -> String-prettyEpicBr br = case br of- Branch (Tag c) q vs e ->- curly (show q) <+>- "Con" <+> show c- <+> many (map typVar vs)- <+> "->" <+> prettyEpic e- BrInt n e -> show n <+> "->" <+> prettyEpic e- Default e -> "Default ->" <+> prettyEpic e- _ -> __IMPOSSIBLE__--prettyEpicLit :: Lit -> String-prettyEpicLit l = case l of- LInt n -> show n ++ "L"- LChar c -> show (ord c)- LString s -> "Con 1" <+> many [show s, "Con 0 ()"]- LFloat f -> show f--typVar :: Var -> String-typVar v = v <+> ":" <+> "Any"
@@ -1,215 +0,0 @@-{-# LANGUAGE CPP #-}--- | Some arguments to functions (types in particular) will not be used in the--- body. Wouldn't it be useful if these wasn't passed around at all?--- Fear not, we here perform some analysis and try to remove as many of these--- occurences as possible.------ We employ the worker/wrapper transform, so if f x1 .. xn = e--- and we notice that some is not needed we create: f' xj .. xk = e [xi := unit]--- and f x1 .. xn = f' xj .. xk.--- i.e we erase them in f' and replace by unit, and the original f function--- calls the new f'. The idea is that f should be inlined and then peace on earth.-module Agda.Compiler.Epic.Erasure where--import Control.Applicative-import Control.Monad.State-import Data.Map(Map)-import qualified Data.Map as M-import Data.Maybe--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface--import Agda.TypeChecking.Monad.Base (TCM)-import qualified Agda.Syntax.Internal as SI-import qualified Agda.Syntax.Common as SC-import Agda.TypeChecking.Monad (MonadTCM, reportSDoc)-import Agda.TypeChecking.Pretty as P--#include "../../undefined.h"-import Agda.Utils.Impossible--isIrr :: Relevance -> Bool-isIrr Irr = True-isIrr Rel = False--isRel :: Relevance -> Bool-isRel = not . isIrr---- | Relevance "or"-(||-) :: Relevance -> Relevance -> Relevance-Irr ||- b = b-_ ||- _ = Rel-infixr 2 ||----- | Relevance "and"-(&&-) :: Relevance -> Relevance -> Relevance-Rel &&- b = b-_ &&- _ = Irr-infixr 3 &&---data ErasureState = ErasureState- { relevancies :: Map Var [Relevance]- , funs :: Map Var Fun- }--type Erasure = StateT ErasureState---- | Try to find as many unused variables as possible-erasure :: [Fun] -> Compile TCM [Fun]-erasure fs = do- orgRel <- gets (relevantArgs . importedModules)- (rels, erasureState) <- flip runStateT (ErasureState orgRel M.empty) $ do- mapM_ initiate fs- fu <- gets funs- M.mapKeys (fromMaybe __IMPOSSIBLE__ . flip M.lookup fu) <$> step 1- modifyEI $ \s -> s { relevantArgs = M.mapKeys funName rels }- concat <$> mapM (\f -> map (rem (relevancies erasureState)) <$> check f (M.lookup f rels)) fs- where-- rem rels f@Fun{} = f { funExpr = removeUnused rels (funExpr f) }- rem _ f = f- -- | Perform the worker//wrapper transform- check :: Fun -> Maybe [Relevance] -> Compile TCM [Fun]- -- If the function is already marked as to inline we don't need to create a- -- new function. Also If all arguments are relevant there is nothing to do.- check f@Fun{} (Just rs) | any isIrr rs && not (funInline f) = do- f' <- (funName f ++) <$> newName- let args' = pairwiseFilter (map isRel rs) (funArgs f)- subs = pairwiseFilter (map isIrr rs) (funArgs f)- e' = foldr (\v e -> subst v "primUnit" e) (funExpr f) subs- return [ Fun { funInline = True- , funName = funName f- , funQName = funQName f- , funComment = funComment f- , funArgs = funArgs f- , funExpr = App f' $ map Var args'- }- , Fun { funInline = False- , funName = f'- , funQName = Nothing- , funComment = funComment f ++ " [ERASED]"- , funArgs = args'- , funExpr = e'- }- ]- check f _ = return [f]--removeUnused :: Map Var [Relevance] -> Expr -> Expr-removeUnused rels t = let rem = removeUnused rels- in case t of- Var _ -> t- Lit _ -> t- Lam v e -> Lam v (rem e)- Con tag qn es -> Con tag qn (map rem es)- App v es -> case M.lookup v rels of- Just re -> App v $ zipWith (\r x -> if isIrr r then UNIT else rem x)- (re ++ repeat Rel) es- Nothing -> App v $ map rem es- Case e brs -> Case (rem e) (map (\br -> br {brExpr = rem $ brExpr br}) brs)- If a b c -> If (rem a) (rem b) (rem c)- Let v e1 e2 -> lett v (rem e1) (rem e2)- Lazy e -> lazy (rem e)- UNIT -> t- IMPOSSIBLE -> t---- | Initiate a function's relevancies-initiate :: Fun -> Erasure (Compile TCM) ()-initiate f@(Fun _ name mqname _ args _) = do- let rels = replicate (length args) Irr- modify $ \s -> s { relevancies = M.insert name rels (relevancies s)- , funs = M.insert name f (funs s)- }-initiate f@(EpicFun {funName = name, funQName = mqname}) = case mqname of- Just qn -> do- ty <- lift $ getType qn- let rels = initialRels ty Rel- return ()- modify $ \s -> s { relevancies = M.insert name rels (relevancies s)- , funs = M.insert name f (funs s)- }- Nothing -> return ()--initialRels :: SI.Type -> Relevance -> [Relevance]-initialRels ty rel =- case SI.unEl ty of- SI.Pi a b -> mkRel a : initialRels (SI.unAbs b) rel- _ -> []- where- mkRel :: SC.Arg SI.Type -> Relevance- mkRel a | ignoreForced (SC.argRelevance a) = Irr- mkRel a = case SI.unEl (SC.unArg a) of- SI.Sort _ -> Irr- _ -> rel--ignoreForced :: SC.Relevance -> Bool-ignoreForced SC.Relevant = False-ignoreForced _ = True---- | Calculate if a variable is relevant in an expression-relevant :: (Functor m, Monad m) => Var -> Expr -> Erasure m Relevance-relevant var expr = case expr of- Var v | v == var -> return Rel- | otherwise -> return Irr- Lit _l -> return Irr- Lam _ e -> relevant var e- Con _ _ es -> relevants var es- App v es | v == var -> return Rel- | otherwise -> do- -- The variable is relevant if it is used in a relevant position- mvrs <- gets (M.lookup v . relevancies)- case mvrs of- Nothing -> relevants var es- Just vrs ->- relevants var- $ map snd- $ filter ((==) Rel . fst)- $ zip (vrs ++ repeat Rel) es- -- foldr (||-) Irr <$> zipWith (&&-) (vrs ++ repeat Rel) <$> mapM (relevant var) es- -- {-- Case e [br@Branch{}] -> do- cvars <- foldr (||-) Irr <$> mapM (flip relevant $ brExpr br) (brVars br)- vare <- relevant var e- varbr <- relevant var (brExpr br)- return ((vare &&- cvars) ||- varbr)- -- -}- Case e brs -> (||-) <$> relevant var e <*> relevants var (map brExpr brs)- If a b c -> relevants var [a,b,c]- Let x e1 e2 -> (||-) <$> ((&&-) <$> relevant var e1 <*> relevant x e2) <*> relevant var e2- Lazy e -> relevant var e- UNIT -> return Irr- IMPOSSIBLE -> return Irr- where- relevants :: (Functor m, Monad m) => Var -> [Expr] -> Erasure m Relevance- relevants v [] = return Irr- relevants v (e : es) = do- r <- relevant v e- case r of- Rel -> return r- _ -> relevants v es- -- relevants v es = return . foldr (\x y -> x ||- y) Irr =<< mapM (relevant v) es---- | Try to find a fixpoint for all the functions relevance.-step :: Integer -> Erasure (Compile TCM) (Map Var [Relevance])-step nrOfLoops = do- s <- get- newRels <- (M.fromList <$>) $ forM (M.toList (funs s)) $ \(v, f) -> ((,) v <$>) $ do- let funRels = fromMaybe __IMPOSSIBLE__ $ M.lookup v (relevancies s)- case f of- EpicFun{} -> return funRels- Fun{} -> do- forM (zip (funArgs f) (funRels ++ repeat Rel)) $ \ (x, rel) -> case rel of- Rel -> return Rel- Irr -> do- lift $ lift $ reportSDoc "epic.erasure" 10 $ P.text "running erasure:" P.<+> (P.text . show) (funQName f)- relevant x (funExpr f)- let relsm = newRels `M.union` relevancies s- if relevancies s == relsm- then return newRels- else do- put s {relevancies = relsm}- step (nrOfLoops + 1)--diff :: (Ord k, Eq a) => Map k a -> Map k a -> [(k,(a,a))]-diff m1 m2 = catMaybes $ zipWith (\(k, x) (_, y) -> if x == y then Nothing else Just (k, (x, y))) (M.toList m1) (M.toList m2)
@@ -1,75 +0,0 @@--- | Remove forced arguments from constructors.-{-# LANGUAGE CPP #-}-module Agda.Compiler.Epic.ForceConstrs where--import Control.Applicative-import Control.Monad.Trans--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface--import qualified Agda.Syntax.Common as S-import qualified Agda.Syntax.Internal as T-import Agda.TypeChecking.Monad (TCM, reportSDoc)-import Agda.TypeChecking.Pretty--#include "../../undefined.h"-import Agda.Utils.Impossible---- | Check which arguments are forced-makeForcedArgs :: T.Type -> ForcedArgs-makeForcedArgs (T.El _ term) = case term of- T.Pi arg ab -> isRel arg : makeForcedArgs (T.unAbs ab)- _ -> []- where- isRel :: S.Arg T.Type -> Forced- isRel arg = case S.argRelevance arg of- S.Relevant -> NotForced- S.Irrelevant -> Forced- S.NonStrict -> Forced -- can never be executed- S.Forced -> Forced -- It can be inferred---- | Remove forced arguments from constructors and branches-forceConstrs :: [Fun] -> Compile TCM [Fun]-forceConstrs fs = mapM forceFun fs--forceFun :: Fun -> Compile TCM Fun-forceFun e@(EpicFun{}) = return e-forceFun (Fun inline name qname comment args expr) =- Fun inline name qname comment args <$> forceExpr expr- where- -- | Remove all arguments to constructors that we don't need to store in an- -- expression.- forceExpr :: Expr -> Compile TCM Expr- forceExpr expr = case expr of- Var v -> return $ Var v- Lit l -> return $ Lit l- Lam v e -> Lam v <$> forceExpr e- Con tag q es -> do- -- We only need to apply the non-forced arguments- forcArgs <- getForcedArgs q- return $ Con tag q $ notForced forcArgs es- App v es -> App v <$> mapM forceExpr es- Case e bs -> Case <$> forceExpr e <*> mapM forceBranch bs- Let v e e' -> lett v <$> forceExpr e <*> forceExpr e'- If a b c -> If <$> forceExpr a <*> forceExpr b <*> forceExpr c- Lazy e -> Lazy <$> forceExpr e- UNIT -> return expr- IMPOSSIBLE -> return expr-- -- | Remove all the arguments that don't need to be stored in the constructor- -- For the branch- forceBranch :: Branch -> Compile TCM Branch- forceBranch br = case br of- Branch tag name vars e -> do- ir <- getForcedArgs name- let vs = notForced ir vars- subs = forced ir vars-- e'' <- if all (`notElem` fv e) subs- then return e- else __IMPOSSIBLE__ -- If so, the removal of forced args has gone wrong- Branch tag name vs <$> forceExpr e''- BrInt i e -> BrInt i <$> forceExpr e- Default e -> Default <$> forceExpr e
@@ -1,309 +0,0 @@-{-# LANGUAGE CPP, ScopedTypeVariables #-}-module Agda.Compiler.Epic.Forcing where--import Control.Applicative-import Control.Arrow (first, second)-import Control.Monad-import Control.Monad.State-import Control.Monad.Trans--import Data.Char-import Data.List hiding (sort)-import qualified Data.Map as M-import Data.Maybe--import Agda.Syntax.Common-import qualified Agda.Syntax.Internal as SI-import Agda.Syntax.Literal-import Agda.Syntax.Position(noRange)-import Agda.Syntax.Internal(Tele(..), Telescope, Term, Abs(..), unAbs, absName, Type, Args, QName, unEl)-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Rules.LHS.Unify-import Agda.TypeChecking.Rules.LHS.Instantiate-import Agda.TypeChecking.Substitute (raiseFrom, raise, substs, apply, TelV(..))-import qualified Agda.TypeChecking.Substitute as S-import Agda.TypeChecking.Pretty as P-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Telescope-import Agda.Utils.List-import Agda.Utils.Monad-import Agda.Utils.Permutation-import Agda.Utils.Size--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Epic-import Agda.Compiler.Epic.Interface-import qualified Agda.Compiler.Epic.FromAgda as FA--#include "../../undefined.h"-import Agda.Utils.Impossible----- | Returns how many parameters a datatype has-dataParameters :: QName -> Compile TCM Nat-dataParameters = lift . dataParametersTCM---- | Returns how many parameters a datatype has-dataParametersTCM :: QName -> TCM Nat-dataParametersTCM name = do- m <- (gets (sigDefinitions . stImports))- return $ maybe __IMPOSSIBLE__ (defnPars . theDef) (M.lookup name m)- where- defnPars :: Defn -> Nat- defnPars (Datatype {dataPars = p}) = p- defnPars (Record {recPars = p}) = p- defnPars d = 0 -- error (show d) -- __IMPOSSIBLE__ -- Not so sure about this.--report n s = do- lift $ reportSDoc "epic.forcing" n s--piApplyM' :: Type -> Args -> TCM Type-piApplyM' t as = do- {- reportSDoc "" 10 $ vcat- [ text "piApplyM'"- , text "type: " <+> prettyTCM t- , text "args: " <+> prettyTCM as- ]-}- piApplyM t as--{- |-insertTele i xs t tele- tpos- tele := Gamma ; (i : T as) ; Delta- n := parameters T- xs' := xs `apply` (take n as)-becomes- tpos- ( Gamma ; xs' ; Delta[i := t] --note that Delta still reference Gamma correctly- , T as ^ (size xs')- )--we raise the type since we have added xs' new bindings before Gamma, and as can-only bind to Gamma.--}-insertTele ::(QName, Args) -> Int -- ^ ABS `pos` in tele- -> Maybe Type -- ^ If Just, it is the type to insert patterns from- -- is nothing if we only want to delete a binding.- -> Term -- ^ Term to replace at pos- -> Telescope -- ^ The telescope `tele` where everything is at- -> Compile TCM ( Telescope -- Resulting telescope- , ( Telescope- , Type -- The type at pos in tele- , Type -- The return Type of the inserted type- )- )-insertTele x 0 ins term (ExtendTel t to) = do- t' <- lift $ normalise t- report 12 $ vcat- [ text "t' :" <+> prettyTCM t'- , text "term:" <+> prettyTCM term- , text "to:" <+> prettyTCM (unAbs to)- ]- (st, arg) <- case SI.unEl . unArg $ t' of- SI.Def st arg -> return (st, arg)- s -> do- report 10 $ vcat- [ text "ERROR!!!"- , text "found: " <+> (text . show) s- , text "ins" <+> (prettyTCM . fromMaybe __IMPOSSIBLE__) ins- ]- return x- -- Apply the parameters of the type of t- -- Because: parameters occurs in the type of constructors but are not bound by it.- pars <- dataParameters st- report 10 $ text "apply in insertTele"- TelV ctele ctyp <- lift $ telView =<< maybe (return $ unArg t')- (`piApplyM'` take (fromIntegral pars) arg) ins-- () <- if length (take (fromIntegral pars) arg) == fromIntegral pars- then return ()- else __IMPOSSIBLE__- -- we deal with absBody to directly since we remove t- return ( ctele +:+ (S.subst term $ S.raiseFrom 1 (size ctele) (unAbs to))- , (ctele, S.raise (size ctele) $ unArg t , ctyp)- )- where- -- Append the telescope, we raise since we add a new binding and all the previous- -- bindings need to be preserved- (+:+) :: Telescope -> Telescope -> Telescope- EmptyTel +:+ t2 = t2- ExtendTel t t1 +:+ t2 = ExtendTel t (Abs (absName t1) $ unAbs t1 +:+ {-raise 1-} t2 )--- This case is impossible since we are trying to split a variable outside the tele-insertTele x n ins term EmptyTel = __IMPOSSIBLE__-insertTele er n ins term (ExtendTel x xs) = do- (xs', typ) <- insertTele er (n - 1) ins term (unAbs xs)- return (ExtendTel x $ Abs (absName xs) xs' , typ)--mkCon c n = SI.Con c [ defaultArg $ SI.Var (fromIntegral i) [] | i <- [n - 1, n - 2 .. 0] ]--unifyI :: Telescope -> [Nat] -> Type -> Args -> Args -> Compile TCM [Maybe Term]-unifyI tele flex typ a1 a2 = lift $ addCtxTel tele $ unifyIndices_ flex typ a1 a2--takeTele 0 _ = EmptyTel-takeTele n (ExtendTel t ts) = ExtendTel t $ Abs (absName ts) $ takeTele (n-1) (unAbs ts)-takeTele _ _ = __IMPOSSIBLE__---- | Main function for removing pattern matching on forced variables-remForced :: [Fun] -> Compile TCM [Fun]-remForced fs = do- defs <- lift (gets (sigDefinitions . stImports))- forM fs $ \f -> case f of- Fun{} -> case funQName f >>= flip M.lookup defs of- Nothing -> __IMPOSSIBLE__- Just def -> do- TelV tele _ <- lift $ telView (defType def)- report 10 $ vcat- [ text "compiling fun" <+> (text . show) (funQName f)- ]- e <- forcedExpr (funArgs f) tele (funExpr f)- report 10 $ vcat- [ text "compilied fun" <+> (text . show) (funQName f)- , text "before:" <+> (text . prettyEpic) (funExpr f)- , text "after:" <+> (text . prettyEpic) e- ]- return $ f { funExpr = e}- EpicFun{} -> return f---- | For a given expression, in a certain telescope (the list of Var) is a mapping--- of variable name to the telescope.-forcedExpr :: [Var] -> Telescope -> Expr -> Compile TCM Expr-forcedExpr vars tele expr = case expr of- Var _ -> return expr- Lit _ -> return expr- Lam x e -> Lam x <$> rec e -- necessary?- Con t q es -> Con t q <$> mapM rec es- App v es -> App v <$> mapM rec es- If a b c -> If <$> rec a <*> rec b <*> rec c- Let v e1 e2 -> Let v <$> rec e1 <*> rec e2- Lazy e -> Lazy <$> rec e- UNIT -> return expr- IMPOSSIBLE -> return expr- Case v@(Var x) brs -> do- let n = fromMaybe __IMPOSSIBLE__ $ elemIndex x vars- (Case v <$>) . forM brs $ \ br -> case br of- BrInt i e -> do- (tele'', _) <- insertTele __IMPOSSIBLE__ n Nothing (SI.Lit (LitChar noRange (chr i))) tele- BrInt i <$> forcedExpr (replaceAt n vars []) tele'' e-- Default e -> Default <$> rec e- Branch t constr as e -> do- typ <- getType constr- forc <- getForcedArgs constr- (tele'', (_, ntyp, ctyp)) <- insertTele __IMPOSSIBLE__ n (Just typ)- (mkCon constr (length as)) tele- ntyp <- lift $ reduce ntyp- ctyp <- lift $ reduce ctyp-- if null (forced forc as)- then Branch t constr as <$> forcedExpr (replaceAt n vars as) tele'' e- else do- -- unify the telescope type with the return type of the constructor- unif <- case (unEl ntyp, unEl ctyp) of- (SI.Def st a1, SI.Def st' a2) | st == st' -> do- typPars <- fromIntegral <$> dataParameters st- setType <- getType st- report 10 $ vcat- [ text "ntyp:" <+> prettyTCM ntyp- , text "ctyp:" <+> prettyTCM ctyp- ]- unifyI (takeTele (n + length as) tele'')- (map fromIntegral $ [0 .. n + length as])- (setType `apply` take typPars a1)- (drop typPars a1)- (drop typPars a2)- _ -> __IMPOSSIBLE__- let- lower = map (raise (-1)) . drop 1- isOk t = case t of- SI.Var n xs | n >= 0 -> all (isOk . unArg) xs- SI.Con _ xs -> all (isOk . unArg) xs- SI.Def f xs -> all (isOk . unArg) xs- _ -> error $ show t- subT 0 tel = let ss = [fromMaybe (SI.Var n []) t- | (n , t) <- zip [0..] (unif ++ repeat Nothing)]- in (S.substs ss tel, lower ss)- subT n (ExtendTel a t) = let- (tb' , ss) = subT (n - 1) (unAbs t)- a' | all isOk (take 100 ss) = S.substs ss a- | True = __IMPOSSIBLE__- in (ExtendTel a $ Abs (absName t) tb', lower ss)- subT _ _ = __IMPOSSIBLE__- (tele'''', _) = subT (n + length as) tele''- report 10 $ nest 2 $ vcat- [ text "remforced"- , text "tele=" <+> prettyTCM tele''- , text "tele'=" <+> prettyTCM tele''''- , text "unif=" <+> (text . show) unif- , text "forced=" <+> (text . show) (forced forc as)- , text "constr" <+> prettyTCM constr- ]- -- replace all forced variables found using the unification- Branch t constr as <$>- replaceForced (replaceAt n vars as, reverse $ take n vars ++ as)- (tele'''') (forced forc as) unif e- _ -> __IMPOSSIBLE__- where- rec = forcedExpr vars tele---- | replace the forcedVar with pattern matching from the outside.-replaceForced :: ([Var],[Var]) -> Telescope -> [Var] -> [Maybe SI.Term] -> Expr -> Compile TCM Expr-replaceForced (vars,_) tele [] _ e = forcedExpr vars tele e-replaceForced (vars,uvars) tele (fvar : fvars) unif e = do- let n = fromMaybe __IMPOSSIBLE__ $ elemIndex fvar uvars- mpos <- findPosition (fromIntegral n) unif- case mpos of- Nothing -> case unif !! n of- Nothing | fvar `notElem` fv e ->- replaceForced (vars, uvars) tele fvars unif e- Nothing -> do- report 10 $ vcat- [ text "failure comming!"- , text "unif" <+> (text . show) unif- , text "n" <+> (text . show) n- , text "fvar" <+> (text fvar)- , text "fv" <+> (text . show) (fv e)- ]- __IMPOSSIBLE__- Just t -> do- v <- newName- te <- FA.substTerm uvars t- subst fvar v <$> replaceForced (vars, uvars)- tele fvars unif (Let v te e)- Just (pos , term) -> do- (build, v) <- buildTerm (uvars !! fromInteger pos) (fromIntegral n) term- build . subst fvar v <$> replaceForced (vars, uvars) tele fvars unif- e- where- sub fvar v = map $ \x -> if x == fvar then v else x---- | Given a term containg the forced var, dig out the variable by inserting--- the proper case-expressions.-buildTerm :: Var -> Nat -> Term -> Compile TCM (Expr -> Expr, Var)-buildTerm var idx (SI.Var i _) | idx == i = return (id, var)-buildTerm var idx (SI.Con c args) = do- vs <- replicateM (length args) newName- (pos , arg) <- fromMaybe __IMPOSSIBLE__ <$> findPosition idx (map (Just . unArg) args)- (fun' , v) <- buildTerm (vs !! fromInteger pos) idx arg- tag <- getConstrTag c- let fun e = casee (Var var) [Branch tag c vs e]- return (fun . fun' , v)-buildTerm _ _ _ = __IMPOSSIBLE__----- | Find the location where a certain Variable index is by searching the constructors--- aswell. i.e find a term that can be transformed into a pattern that contains the--- same value the index. This fails if no such term is present.-findPosition :: Nat -> [Maybe SI.Term] -> Compile TCM (Maybe (Nat, SI.Term))-findPosition var ts = (listToMaybe . catMaybes <$>) . forM (zip [0..] ts) $ \ (n, mt) -> do- ifM (maybe (return False) pred mt)- (return (Just (n, fromMaybe __IMPOSSIBLE__ mt)))- (return Nothing)- where- pred :: Term -> Compile TCM Bool- pred t = case t of- SI.Var i _ | var == i -> return True- SI.Con c args -> do- forc <- getForcedArgs c- or <$> mapM (pred . unArg) (notForced forc args)- _ -> return False
@@ -1,257 +0,0 @@-{-# LANGUAGE CPP #-}---- | Convert from Agda's internal representation to our auxiliary AST.-module Agda.Compiler.Epic.FromAgda where--import Control.Applicative-import Control.Monad-import Control.Monad.State-import Data.Char-import Data.Map(Map)-import qualified Data.Map as M-import Data.Maybe--import Agda.Interaction.Options-import Agda.Syntax.Common-import Agda.Syntax.Internal hiding (Term(..))-import qualified Agda.Syntax.Internal as T-import qualified Agda.Syntax.Literal as TL-import qualified Agda.TypeChecking.CompiledClause as CC-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Level (reallyUnLevelView)-import qualified Agda.TypeChecking.Substitute as S-import Agda.TypeChecking.Pretty--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface-import Agda.Compiler.Epic.Static--import Agda.Compiler.Epic.Epic--#include "../../undefined.h"-import Agda.Utils.Impossible---- | Convert from Agda's internal representation to our auxiliary AST.-fromAgda :: Maybe T.Term -> [(QName, Definition)] -> Compile TCM [Fun]-fromAgda msharp defs = catMaybes <$> mapM (translateDefn msharp) defs---- | Translate an Agda definition to an Epic function where applicable-translateDefn :: Maybe T.Term -> (QName, Definition) -> Compile TCM (Maybe Fun)-translateDefn msharp (n, defini) =- let n' = unqname n- epDef = compiledEpic $ defCompiledRep defini- in case theDef defini of- d@(Datatype {}) -> do -- become functions returning unit- vars <- replicateM (fromIntegral $ dataPars d + dataIxs d) newName- return . return $ Fun True n' (Just n) ("datatype: " ++ show n) vars UNIT- f@(Function{}) -> do- let projArgs = maybe 0 (pred . snd) (funProjection f)- ccs <- reverseCCBody projArgs <$> normaliseStatic (funCompiled f)- let len = (+ projArgs) . length . clausePats . head . funClauses $ f- toEta = fromIntegral (arity (defType defini)) - len- -- forcing <- lift $ gets (optForcing . stPersistentOptions)- lift $ reportSDoc "epic.fromagda" 5 $ text "compiling fun:" <+> prettyTCM n- lift $ reportSDoc "epic.fromagda" 5 $ text "len:" <+> (text . show) len- lift $ reportSDoc "epic.fromagda" 5 $ text "pats:" <+> (text . show) (clausePats- $ head $ funClauses f)- modify $ \s -> s {curFun = show n}- lift $ reportSDoc "epic.fromagda" 5 $ text "ccs: " <+> (text . show) ccs- res <- return <$> (etaExpand toEta =<< compileClauses n len ccs)- pres <- case res of- Nothing -> return Nothing- Just c -> return <$> prettyEpicFun c- lift $ reportSDoc "" 5 $ text $ show pres -- (fmap prettyEpicFun res)- return res- Constructor{} -> do -- become functions returning a constructor with their tag- arit <- lift $ constructorArity n- tag <- getConstrTag n- -- Sharp has to use the primSharp function from AgdaPrelude.e- case msharp of- Just (T.Def sharp []) | sharp == n -> return <$> mkFun n n' "primSharp" 3- _ -> return <$> mkCon n tag arit- r@(Record{}) -> do- vars <- replicateM (fromIntegral $ recPars r) newName- return . return $ Fun True n' (Just n) ("record: " ++ show n) vars UNIT- a@(Axiom{}) -> do -- Axioms get their code from COMPILED_EPIC pragmas- case epDef of- Nothing -> return . return $ EpicFun n' (Just n) ("AXIOM_UNDEFINED: " ++ show n)- $ "() -> Any = lazy(error \"Axiom " ++ show n ++ " used but has no computation\")"- Just x -> return . return $ EpicFun n' (Just n) ("COMPILED_EPIC: " ++ show n) x- p@(Primitive{}) -> do -- Primitives use primitive functions from AgdaPrelude.e of the same name.- -- Hopefully they are defined!- let ar = fromIntegral $ arity $ defType defini- return <$> mkFun n n' (primName p) ar- where- mkFun q = mkFunGen q apps ("primitive: " ++)- mkCon q tag ari = do- let name = unqname q- mkFunGen q (flip Con q) (const $ "constructor: " ++ show q) name tag ari- mkFunGen :: QName -- ^ Original name- -> (name -> [Expr] -> Expr) -- ^ combinator- -> (name -> String) -- ^ make comment- -> Var -- ^ Name of the function- -> name -- ^ Primitive function name- -> Int -- ^ Arity ofthe function- -> Compile TCM Fun -- ^ Result?- mkFunGen qn comb sh name primname arit = do- vars <- replicateM arit newName- return $ Fun True name (Just qn) (sh primname) vars (comb primname (map Var vars))-- etaExpand :: Int -> Fun -> Compile TCM Fun- etaExpand num fun = return fun -- do-{- names <- replicateM num newName- return $ fun- { funExpr = funExpr fun @@ names- , funArgs = funArgs fun ++ names- }--}- (@@) :: Expr -> [Var] -> Expr- e @@ [] = e- e @@ vs = let ts = map Var vs in case e of- Var var -> apps var ts- Lam var expr -> case vs of- v:vs' -> subst var v expr @@ vs'- [] -> __IMPOSSIBLE__- Con tag qName es -> Con tag qName (es ++ ts)- App var es -> App var (es ++ ts)- Case expr bs -> Case expr (map (flip appBranch vs) bs)- If ea eb ec -> If ea (eb @@ vs) (ec @@ vs)- Let var el e' -> lett var el (e' @@ vs)- Lazy e' -> Lazy (e' @@ vs)- Lit _lit -> IMPOSSIBLE -- Right?- UNIT -> IMPOSSIBLE- IMPOSSIBLE -> IMPOSSIBLE-- appBranch :: Branch -> [Var] -> Branch- appBranch b vs = b {brExpr = brExpr b @@ vs}--reverseCCBody :: Int -> CC.CompiledClauses -> CC.CompiledClauses-reverseCCBody c cc = case cc of- CC.Case n (CC.Branches cbr lbr cabr) -> CC.Case (c+n)- $ CC.Branches (M.map (reverseCCBody c) cbr)- (M.map (reverseCCBody c) lbr)- (fmap (reverseCCBody c) cabr)- CC.Done i t -> CC.Done i (S.substs (map (flip T.Var [])- (reverse $ take (length i) [fromIntegral c..])) t)- CC.Fail -> CC.Fail---- | Translate from Agda's desugared pattern matching (CompiledClauses) to our AuxAST.--- This is all done by magic. It uses 'substTerm' to translate the actual--- terms when the cases have been gone through.--- The case expressions that we get use de Bruijn indices that change after--- each case in the following way.--- Say we have this pattern:------ > f (X x y) (Y z) = term------ Initially, the variables have these indexes:------ > f 0@(X x y) 1@(Y z) = term------ The first case will be on @0@, and the variables bound inside the @X@--- pattern will replace the outer index, so we get something like this:------ > f 0 2@(Y z) = case 0 of X 0 1 -> term------ Notice how @(Y z)@ now has index @2@.--- Then the second pattern is desugared in the same way:------ > f 0 2 = case 0 of X 0 1 -> case 2 of Y 2 -> term------ This replacement is what is done using the replaceAt function.------ CompiledClauses also have default branches for when all branches fail (even--- inner branches), the catchAllBranch. Epic does not support this, so--- we have to add the catchAllBranch to each inner case (here we are calling--- it omniDefault). To avoid code duplication it is first bound by a let--- expression.-compileClauses :: QName- -> Int -- ^ Number of arguments in the definition- -> CC.CompiledClauses -> Compile TCM Fun-compileClauses name nargs c = do- let n' = unqname name- vars <- replicateM nargs newName- e <- compileClauses' vars Nothing c- return $ Fun False n' (Just name) ("function: " ++ show name) vars e- where- compileClauses' :: [Var] -> Maybe Var -> CC.CompiledClauses -> Compile TCM Expr- compileClauses' env omniDefault cc = case cc of- CC.Case n nc -> case length env <= n of- True -> __IMPOSSIBLE__- False -> case CC.catchAllBranch nc of- Nothing -> Case (Var (env !! n)) <$> compileCase env omniDefault n nc- Just de -> do- def <- compileClauses' env omniDefault de- bindExpr (lazy def) $ \ var ->- Case (Var (env !! n)) <$> compileCase env (Just var) n nc- CC.Done _ t -> substTerm ({- reverse -} env) t- CC.Fail -> return IMPOSSIBLE-- compileCase :: [Var] -> Maybe Var -> Int -> CC.Case CC.CompiledClauses- -> Compile TCM [Branch]- compileCase env omniDefault casedvar nc = do- cb <- if M.null (CC.conBranches nc)- -- Lit branch- then forM (M.toList (CC.litBranches nc)) $ \(l, cc) -> do- cc' <- compileClauses' (replaceAt casedvar env []) omniDefault cc- case l of- TL.LitChar _ cha -> return $ BrInt (ord cha) cc'- -- TODO: Handle other literals- _ -> epicError $ "case on literal not supported: " ++ show l- -- Con branch- else forM (M.toList (CC.conBranches nc)) $ \(b, cc) -> do- arit <- getConArity b- tag <- getConstrTag b- vars <- replicateM arit newName- cc' <- compileClauses' (replaceAt casedvar env vars) omniDefault cc- return $ Branch tag b vars cc'-- case omniDefault of- Nothing -> return cb- Just cc -> do- return $ cb ++ [Default (Var cc)]---- | Translate the actual Agda terms, with an environment of all the bound variables--- from patternmatching. Agda terms are in de Bruijn so we just check the new--- names in the position.-substTerm :: [Var] -> T.Term -> Compile TCM Expr-substTerm env term = case term of- T.Var ind args -> case length env <= fromIntegral ind of- True -> __IMPOSSIBLE__- False -> apps (env !! fromIntegral ind) <$> mapM (substTerm env . unArg) args- T.Lam _ (Abs _ te) -> do- name <- newName- Lam name <$> substTerm (name : env) te- T.Lam _ (NoAbs _ te) -> do- name <- newName- Lam name <$> substTerm env te- T.Lit l -> Lit <$> substLit l- T.Level l -> substTerm env =<< lift (reallyUnLevelView l)- T.Def q args -> do- let name = unqname q- del <- getDelayed q- def <- theDef <$> lift (getConstInfo q)- let nr = case def of- Function{funProjection = Just (_ , x)} -> pred x- _ -> 0- f <- apps name . (replicate nr UNIT ++) <$> mapM (substTerm env . unArg) args- return $ case del of- True -> Lazy f- False -> f- T.Con q args -> do- let con = unqname q- apps con <$> mapM (substTerm env . unArg) args- T.Pi _ _ -> return UNIT- T.Sort _ -> return UNIT- T.MetaV _ _ -> return UNIT- T.DontCare _ -> return UNIT---- | Translate Agda literals to our AUX definition-substLit :: TL.Literal -> Compile TCM Lit-substLit lit = case lit of- TL.LitInt _ i -> return $ LInt i- TL.LitString _ s -> return $ LString s- TL.LitChar _ c -> return $ LChar c- TL.LitFloat _ f -> return $ LFloat f- _ -> epicError $ "literal not supported: " ++ show lit
@@ -1,323 +0,0 @@-{-# LANGUAGE CPP, TypeOperators, PatternGuards #-}-module Agda.Compiler.Epic.Injection where--import Control.Monad.State--import Data.Function-import Data.Ix-import Data.List-import Data.Map(Map)-import qualified Data.Map as M-import Data.Maybe-import Data.Set(Set)-import qualified Data.Set as S--import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.Syntax.Literal-import Agda.TypeChecking.CompiledClause-import Agda.TypeChecking.Monad hiding ((!!!))-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Telescope-import Agda.Utils.Monad-import Agda.Utils.Size--import Agda.Compiler.Epic.CompileState-import qualified Agda.Compiler.Epic.FromAgda as FA-import Agda.Compiler.Epic.Interface as Interface--#include "../../undefined.h"-import Agda.Utils.Impossible---- | Find potentially injective functions, solve constraints to fix some constructor--- tags and make functions whose constraints are fulfilled injections-findInjection :: [(QName, Definition)] -> Compile TCM [(QName, Definition)]-findInjection defs = do- funs <- forM defs $ \(name, def) -> case theDef def of- f@(Function{}) -> isInjective name (funClauses f)- _ -> return Nothing- newNames <- M.keys <$> gets (Interface.conArity . curModule)- injFuns <- solve newNames (catMaybes funs)- defs' <- forM defs $ \(q, def) -> case q `isIn` injFuns of- Nothing -> return (q, def)- Just inj@(InjectiveFun var arity) -> case theDef def of- f@(Function{}) -> do- modifyEI $ \s -> s { injectiveFuns = M.insert q inj (injectiveFuns s) }- let ns = replicate (fromIntegral arity) (Arg NotHidden Relevant "")- return $ (,) q $ def {theDef = f { funCompiled = Done ns- (Var (arity - var - 1) []) } }- _ -> __IMPOSSIBLE__-- lift $ reportSLn "epic.injection" 10 $ "injfuns: " ++ show injFuns- return defs'- where- q `isIn` funs = case filter (\(nam, _) -> q == nam) funs of- [] -> Nothing- (_,x):_ -> Just x--replaceFunCC :: QName -> CompiledClauses -> Compile TCM ()-replaceFunCC name cc = do- lift $ modify $ \s ->- s { stSignature = (stSignature s) { sigDefinitions = M.adjust replaceDef name (sigDefinitions (stSignature s)) }- , stImports = (stImports s) { sigDefinitions = M.adjust replaceDef name (sigDefinitions (stImports s)) }- }- where- replaceDef :: Definition -> Definition- replaceDef def = case theDef def of- f@(Function{}) -> def {theDef = f { funCompiled = cc } }- x -> __IMPOSSIBLE__---- | If the pairs of constructor names have the same tags, the function is--- injective. If Nothing, the function is not injective.-type InjConstraints = Maybe [(QName,QName)]---isInjective :: QName -- ^ Name of the function being tested- -> [Clause] -- ^ The function's clauses- -> Compile TCM (Maybe ((QName, InjectiveFun)- , [(QName, QName)] -- These construtors should have the same name- ))-isInjective nam [] = return Nothing-isInjective nam cls@(cl : _) = do- let total = genericLength . clausePats $ cl- (listToMaybe . catMaybes <$>) . forM [0 .. total - 1] $ \i -> do- cli <- forM cls $ \ cl -> isInjectiveHere nam i cl- let cli' = catMaybes cli- return $ if length cli == length cli'- then Just ((nam, InjectiveFun (fromIntegral i) (fromIntegral total)), concat cli')- else Nothing--remAbs :: ClauseBody -> Term-remAbs b = case b of- Body t -> t- Bind ab -> remAbs $ absBody ab- NoBody -> __IMPOSSIBLE__--isNoBody :: ClauseBody -> Bool-isNoBody b = case b of- Body t -> False- Bind ab -> isNoBody $ absBody ab- NoBody -> True--patternToTerm :: Nat -> Pattern -> Term-patternToTerm n p = case p of- VarP v -> Var n []- DotP t -> t- ConP c typ args -> Con c $ zipWith (\ arg t -> arg {unArg = t}) args- $ snd- $ foldr (\ arg (n, ts) -> (n + nrBinds arg, patternToTerm n arg : ts))- (n , [])- $ map unArg args- LitP l -> Lit l--nrBinds :: Num i => Pattern -> i-nrBinds p = case p of- VarP v -> 1- DotP t -> 0- ConP c typ args -> sum $ map (nrBinds . unArg) args- LitP l -> 0--substForDot :: [Arg Pattern] -> Substitution-substForDot ps = map (flip Var []) (makeSubst 0 0 $ reverse $ calcDots ps)- where- makeSubst i accum [] = [i + accum ..]- makeSubst i accum (True : ps) = makeSubst i (accum +1) ps- makeSubst i accum (False : ps) = i + accum : makeSubst (i+1) accum ps-- calcDots = concatMap calcDots' . map unArg- calcDots' p = case p of- VarP v -> [False]- DotP t -> [True]- ConP c typ args -> calcDots args- LitP l -> [False]--isInjectiveHere :: QName -- ^ Name of the function being tested- -> Int -- ^ The current argument- -> Clause- -> Compile TCM InjConstraints-isInjectiveHere nam idx Clause {clauseBody = body} | isNoBody body = return emptyC-isInjectiveHere nam idx clause = do- let t = patternToTerm idxR $ unArg $ clausePats clause !! idx- t' = substs (substForDot $ clausePats clause) t- idxR = sum . map (nrBinds . unArg) . genericDrop (idx + 1) $ clausePats clause- body = remAbs $ clauseBody clause- body' <- lift $ reduce body- injFs <- gets (injectiveFuns . importedModules)- res <- (t' <: body') (M.insert nam (InjectiveFun (fromIntegral idx)- (genericLength (clausePats clause))) injFs)- lift $ reportSDoc "epic.injection" 20 $ vcat- [ text "isInjective:" <+> text (show nam)- , text "at Index :" <+> text (show idx)- , nest 2 $ vcat- [ text "clause :" <+> text (show clause)- , text "t :" <+> prettyTCM t- , text "idxR :" <+> (text . show) idxR- , text "body' :" <+> (text . show) body'- ]- , text "res :" <+> text (show res)- ]- return res--litToCon :: Literal -> TCM Term-litToCon l = case l of- LitInt r n | n > 0 -> do- inner <- litToCon (LitInt r (n - 1))- suc <- primSuc- return $ suc `apply` [defaultArg inner]- | otherwise -> primZero--- LitLevel _ n -> -- Does not really matter- lit -> return $ Lit lit--litCon :: Literal -> Bool-litCon (LitInt _ _) = True-litCon _ = False--insertAt :: (Nat,Term) -> Term -> Term-insertAt (index, ins) = substs [if i == index then ins else Var i [] | i <- [0 .. ]]---solve :: [QName] -> [((QName, InjectiveFun), [(QName,QName)])] -> Compile TCM [(QName, InjectiveFun)]-solve newNames xs = do- -- Only primitive lists should be in the current module at this point,- -- but we still want them- conGraph <- M.union <$> gets (constrTags . curModule) <*> gets (constrTags . importedModules)- (funs, mconstr) <- ($ xs) $ flip foldM ([] , Just $ initialTags conGraph newNames) $ \ (xs , prev) (fun , con) -> do- m <- foldM solvable prev con- return $ case m of- Nothing -> (xs, prev)- Just next -> (fun : xs, m)- case mconstr of- Nothing -> __IMPOSSIBLE__- Just constr -> updateTags constr- return funs- where- solvable :: Maybe Tags -> (QName, QName)- -> Compile TCM (Maybe Tags)- solvable Nothing _ = return Nothing- solvable (Just st) (c1, c2) = unify c1 c2 st-- updateTags :: Tags -> Compile TCM ()- updateTags tags = do- let (hasTags, eqs) = M.partition isTag (constrGroup tags)- isTag (IsTag _) = True- isTag _ = False- forM (M.toList hasTags) $ \ (c, tagged) -> case tagged of- IsTag tag -> putCon c tag- _ -> __IMPOSSIBLE__- case M.toList eqs of- (c, Same n) : _ -> do- let grp = eqGroups tags !!! n- tag <- assignConstrTag' c (S.toList grp)- updateTags . fromMaybe __IMPOSSIBLE__ =<< setTag n tag tags { constrGroup = eqs }- _ -> return ()- putCon :: QName -> Tag -> Compile TCM ()- putCon con tag = do- m <- gets (constrTags . importedModules)- case M.lookup con m of- Nothing -> putConstrTag con tag- Just _ -> return () -- old--emptyC :: InjConstraints-emptyC = Just []--addConstraint :: QName -> QName -> InjConstraints -> InjConstraints-addConstraint q1 q2 Nothing = Nothing-addConstraint q1 q2 (Just xs) = Just (if q1 == q2 then xs else (q1,q2) : xs)--unionConstraints :: [InjConstraints] -> InjConstraints-unionConstraints [] = Just []-unionConstraints (Nothing : _) = Nothing-unionConstraints (Just c : cs) = do- cs' <- unionConstraints cs- return (c ++ cs')---- | Are two terms injectible?--- Precondition: t1 is normalised, t2 is in WHNF--- When reducing t2, it may become a literal, which makes this not work in some cases...-(<:) :: Term -> Term -> (QName :-> InjectiveFun) -> Compile TCM InjConstraints-(Lit l <: t1) injs | litCon l = do- l' <- lift $ litToCon l- (l' <: t1) injs-(t1 <: Lit l) injs | litCon l = do- l' <- lift $ litToCon l- (t1 <: l') injs-(t1 <: Def n2 args2) injs | Just (InjectiveFun argn arit) <- M.lookup n2 injs =- if genericLength args2 /= arit- then return Nothing- else do- arg <- lift $ reduce $ unArg $ args2 !! fromIntegral argn- (t1 <: arg) injs--- (Var n1 [] <: Var n2 []) nam idx = return $ if n1 == n2 then emptyC else Nothing-(Var n1 args1 <: Var n2 args2) injs | n1 == n2 && length args1 == length args2 = do- args1' <- map unArg <$> mapM (lift . reduce) args1- args2' <- map unArg <$> mapM (lift . reduce) args2- unionConstraints <$> zipWithM (\a b -> (a <: b) injs) args1' args2'-(Def q1 args1 <: Def q2 args2) injs | q1 == q2 && length args1 == length args2 = do- args1' <- map unArg <$> mapM (lift . reduce) args1- args2' <- map unArg <$> mapM (lift . reduce) args2- unionConstraints <$> zipWithM (\a b -> (a <: b) injs) args1' args2'-(Con c1 args1 <: Con c2 args2) injs = do- args1' <- map unArg <$> flip notForced args1 <$> getForcedArgs c1- args2' <- map unArg <$> (mapM (lift . reduce) =<< flip notForced args2 <$> getForcedArgs c2)- if length args1' == length args2'- then addConstraint c1 c2 <$> unionConstraints <$> zipWithM (\a b -> (a <: b) injs) args1' args2'- else return Nothing-(_ <: _) _ = return Nothing--data TagEq- = Same Int- | IsTag Tag- deriving Eq--data Tags = Tags- { eqGroups :: Int :-> Set QName- , constrGroup :: QName :-> TagEq- }--initialTags :: Map QName Tag -> [QName] -> Tags-initialTags setTags newNames = Tags- { eqGroups = M.fromList $ zip [0..] (map S.singleton newNames)- , constrGroup = M.map IsTag setTags `M.union` M.fromList (zip newNames (map Same [0..]))- }--unify :: QName -> QName -> Tags -> Compile TCM (Maybe Tags)-unify c1 c2 ts = do- let g1 = constrGroup ts !!! c1- g2 = constrGroup ts !!! c2- case (g1, g2) of- (Same n1, Same n2) | n1 == n2 -> return $ Just ts- (IsTag t1, IsTag t2) | t1 == t2 -> return $ Just ts- (Same n1, Same n2) -> mergeGroups n1 n2 ts- (Same n1, IsTag t2) -> setTag n1 t2 ts- (IsTag t1 , Same n2) -> setTag n2 t1 ts- _ -> return $ Nothing--setTag :: Int -> Tag -> Tags -> Compile TCM (Maybe Tags)-setTag gid tag ts = return $ Just $ ts- { constrGroup = foldr (\c -> M.insert c (IsTag tag)) (constrGroup ts) (S.toList $ eqGroups ts !!! gid)}--mergeGroups :: Int -> Int -> Tags -> Compile TCM (Maybe Tags)-mergeGroups n1 n2 ts = do- let g1s = eqGroups ts !!! n1- g2s = eqGroups ts !!! n2- gs = S.union g1s g2s- ifM (not . and <$> sequence [unifiable e1 e2 | e1 <- S.toList g1s, e2 <- S.toList g2s])- (return Nothing) $- return $ Just $ ts- { eqGroups = M.delete n2 $ M.insert n1 gs (eqGroups ts)- , constrGroup = M.fromList [(e2, Same n1) | e2 <- S.toList g2s] `M.union` constrGroup ts- }--unifiable :: QName -> QName -> Compile TCM Bool-unifiable c1 c2 = do- d1 <- getConData c1- d2 <- getConData c2- return $ d1 /= d2--(!!!) :: Ord k => k :-> v -> k -> v-m !!! k = case M.lookup k m of- Nothing -> __IMPOSSIBLE__- Just x -> x
@@ -1,87 +0,0 @@-{-# LANGUAGE DeriveDataTypeable #-}--- | Epic interface data structure, which is serialisable and stored for each--- compiled file-module Agda.Compiler.Epic.Interface where--import Control.Monad--import Data.Function-import qualified Data.Map as M-import Data.Map(Map)-import Data.Monoid-import qualified Data.Set as S-import Data.Set(Set)-import Data.Typeable--import Agda.Syntax.Common (Nat)-import Agda.Syntax.Internal--type Var = String-data Tag = Tag Int- | PrimTag Var- deriving (Show, Eq, Ord, Typeable)--data Forced = NotForced | Forced- deriving (Show, Typeable, Eq)---- | Filter a list using a list of Bools specifying what to keep.-pairwiseFilter :: [Bool] -> [a] -> [a]-pairwiseFilter (True :bs) (a:as) = a : pairwiseFilter bs as-pairwiseFilter (False:bs) (_:as) = pairwiseFilter bs as-pairwiseFilter _ _ = []--notForced :: ForcedArgs -> [a] -> [a]-notForced = pairwiseFilter . map (== NotForced)--forced :: ForcedArgs -> [a] -> [a]-forced = pairwiseFilter . map (== Forced)--data Relevance- = Irr- | Rel- deriving (Eq, Ord, Show, Typeable)--type ForcedArgs = [Forced]-type RelevantArgs = [Relevance]--data InjectiveFun = InjectiveFun- { injArg :: Nat- , injArity :: Nat- }- deriving (Show, Typeable, Eq)--data EInterface = EInterface- { constrTags :: Map QName Tag- , definitions :: Set Var- , defDelayed :: Map QName Bool- , conArity :: Map QName Int- , mainName :: Maybe QName- , relevantArgs :: Map Var RelevantArgs- , forcedArgs :: Map QName ForcedArgs- , injectiveFuns :: Map QName InjectiveFun- } deriving (Typeable, Show)--instance Monoid EInterface where- mempty = EInterface- { constrTags = mempty- , definitions = mempty- , defDelayed = mempty- , conArity = mempty- , mainName = Nothing- , relevantArgs = mempty- , forcedArgs = mempty- , injectiveFuns = mempty- }- mappend x y = EInterface- { constrTags = comb constrTags- , definitions = comb definitions- , defDelayed = comb defDelayed- , conArity = comb conArity- , mainName = mainName x `mplus` mainName y- , relevantArgs = comb relevantArgs- , forcedArgs = comb forcedArgs- , injectiveFuns = comb injectiveFuns- }- where- comb :: Monoid a => (EInterface -> a) -> a- comb f = (mappend `on` f) x y
@@ -1,77 +0,0 @@-{-# LANGUAGE CPP #-}--- | Detect if a datatype could be represented as a primitive integer.--- If it has one constructor with no arguments and one with a recursive--- argument this is true. This is done using IrrFilters which filter out--- forced arguments, so for example Fin becomes primitive.-module Agda.Compiler.Epic.NatDetection where--import Control.Applicative-import Control.Monad-import Control.Monad.State-import Data.Function-import Data.List-import qualified Data.Map as M-import Data.Maybe--import Agda.TypeChecking.Monad-import Agda.Syntax.Internal-import Agda.TypeChecking.Substitute-import Agda.Syntax.Common--import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface--#include "../../undefined.h"-import Agda.Utils.Impossible---- | Get a list of all the datatypes that look like nats. The [QName] is on the--- form [zeroConstr, sucConstr]-getNatish :: Compile TCM [(ForcedArgs, [QName])]-getNatish = do- sig <- lift (gets (sigDefinitions . stImports))- let defs = M.toList sig- fmap catMaybes $ forM defs $ \(q, def) ->- case theDef def of- d@(Datatype {}) -> isNatish q d-- _ -> return Nothing--isNatish :: QName -> Defn -> Compile TCM (Maybe (ForcedArgs, [QName]))-isNatish q d = do -- A datatype ...- case dataCons d of- constrs | length constrs == 2 -> do -- with two constructors ...- b <- and <$> mapM constrInScope constrs- if b- then do- z <- zip constrs <$> mapM getForcedArgs constrs- case sortBy (compare `on` nrRel . snd) z of- [(cz,fz), (cs,fs)] -> do- sig <- lift (gets (sigDefinitions . stImports))- let ts = defType $ sig M.! cs- nr = fromIntegral $ dataPars d- return $ do- guard (nrRel fz == 0) -- where one constructor has zero arguments ...- guard (nrRel fs == 1) -- and the other one one argument ...- guard (isRec ((fromMaybe __IMPOSSIBLE__ $ elemIndex NotForced fs) + nr) ts q) -- which is recursive.- return (fs, [cz, cs]) -- It's natish!- _ -> return Nothing- else return Nothing- _ -> return Nothing---- | Count the number of relevant arguments-nrRel :: ForcedArgs -> Integer-nrRel = sum . map (const 1) . filter (== NotForced)---- | Check if argument n is recursive-isRec :: Int -> Type -> QName -> Bool-isRec 0 (El _ t) dat = case t of- Pi arg _ -> argIsDef (unArg arg) dat- _ -> False-isRec n (El _ t) dat = case t of- Pi _ ab -> isRec (n - 1) (unAbs ab) dat- _ -> False--argIsDef :: Type -> QName -> Bool-argIsDef (El _ t) dat = case t of- Def q _ -> q == dat- _ -> False
@@ -1,211 +0,0 @@-{-# LANGUAGE CPP #-}---- | Change constructors and cases on builtins and natish datatypes to use--- primitive data-module Agda.Compiler.Epic.Primitive where--import Control.Applicative-import Control.Monad-import Control.Monad.Trans-import Data.Map(Map)-import qualified Data.Map as M-import Data.Maybe--import Agda.Syntax.Internal(QName)-import qualified Agda.Syntax.Internal as T-import Agda.TypeChecking.Monad hiding (defName)-import Agda.TypeChecking.Monad.Builtin--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface-import Agda.Compiler.Epic.NatDetection--#include "../../undefined.h"-import Agda.Utils.Impossible--{- Stacken, Heapen -- Optimizern -}--data PrimTransform = PrimTF- { mapCon :: Map QName Var- , translateCase :: Expr -> [Branch] -> Expr- }--prZero, prSuc, prTrue, prFalse, prPred, prNatEquality :: Var-prZero = "primZero"-prSuc = "primSuc"-prTrue = "primTrue"-prFalse = "primFalse"-prPred = "primPred"-prNatEquality = "primNatEquality"---- | Change constructors and cases on builtins and natish datatypes to use--- primitive data-primitivise :: [Fun] -> Compile TCM [Fun]-primitivise funs = do- ptfs <- getBuiltins- natish <- getNatish- mapM (primFun $ ptfs ++ map (uncurry natPrimTF) natish) funs---- | Map primitive constructors to primitive tags-initialPrims :: Compile TCM () -- [Fun]-initialPrims = do- -- TODO: Natishness is calculated here and could be stored so it does not have- -- to be recalculated in primitivise- natish <- getNatish- -- This has to be done because injection detection may otherwise flag injections- -- between non-primitive and primitive datatypes in the wrong way- sequence_ [zipWithM_ putConstrTag [zc, sc] (prim [prZero, prSuc])- | (_, [zc, sc]) <- natish]- sequence_- [ [builtinNil, builtinCons] ~> tags [0, 1]- , [builtinZero, builtinSuc ] ~> prim [prZero, prSuc]- , [builtinLevelZero, builtinLevelSuc] ~> prim [prZero, prSuc]- , [builtinTrue, builtinFalse] ~> prim [prTrue, prFalse]- , [builtinRefl] ~> tags [0]- ]- where- prim = map PrimTag- tags = map Tag- constrs ~> tags = do- builtins <- lift $ mapM getBuiltin' constrs- if all isJust builtins- then do- let names = map (defName . fromMaybe __IMPOSSIBLE__) builtins- -- b <- and <$> mapM constrInScope names- -- if b then return $ Just (transf names) else return Nothing- zipWithM_ putConstrTag names tags- else return ()---- | Build transforms using the names of builtins-getBuiltins :: Compile TCM [PrimTransform]-getBuiltins =- catMaybes <$> sequence- [ [builtinZero, builtinSuc ] ~> natPrimTF [NotForced]- -- ? is this ok to have [NotForced]- , [builtinLevelZero, builtinLevelSuc] ~> natPrimTF [NotForced]- , [builtinTrue, builtinFalse] ~> boolPrimTF- ]- where- constrs ~> transf = do- builtins <- lift $ mapM getBuiltin' constrs- if all isJust builtins- then do- let names = map (defName . fromMaybe __IMPOSSIBLE__) builtins- b <- and <$> mapM constrInScope names- if b then return $ Just (transf names) else return Nothing- else return Nothing--defName (T.Def q []) = q-defName (T.Con q []) = q-defName _ = __IMPOSSIBLE__--head'' (x:xs) e = x-head'' _ e = e---- | Translation to primitive integer functions-natPrimTF :: ForcedArgs -> [QName] -> PrimTransform-natPrimTF filt [zero, suc] = PrimTF- { mapCon = M.fromList [(zero, prZero), (suc, prSuc)]- , translateCase = \ce brs -> case brs of- -- Assuming only the first two branches are relevant when casing on Nats- (Branch _ n vs e:Branch _ _n' vs'' e'':_) ->- if n == zero- then primNatCaseZS ce e (head'' vs'' __IMPOSSIBLE__) e''- else primNatCaseZS ce e'' (head'' vs __IMPOSSIBLE__) e- (Branch _ n vs e:Default e'':_) ->- if n == zero- then primNatCaseZD ce e e'' -- zero- else primNatCaseZS ce e'' (head'' vs __IMPOSSIBLE__) e -- suc- [ Branch _ n vs e ] ->- if n == zero- then e- else lett (head'' vs __IMPOSSIBLE__) (App prPred [ce]) e- _ -> __IMPOSSIBLE__- }-natPrimTF _ _ = __IMPOSSIBLE__---- | Corresponds to a case for natural numbers-primNatCaseZS :: Expr -- ^ Expression that is cased on- -> Expr -- ^ Expression for the zero branch- -> Var -- ^ Variable that is bound in suc branch- -> Expr -- ^ Expression used for suc branch- -> Expr -- ^ Result?-primNatCaseZS n zeroBr v sucBr =- If (App prNatEquality [n, Var prZero]) zeroBr (lett v (App prPred [n]) sucBr)---- | Corresponds to a case with a zero and default branch-primNatCaseZD :: Expr -- ^ Expression that is cased on- -> Expr -- ^ Zero branch- -> Expr -- ^ Default branch- -> Expr -- ^ Result?-primNatCaseZD n zeroBr defBr = If (App prNatEquality [n, Var prZero]) zeroBr defBr---- | Translation to primitive bool functions-boolPrimTF :: [QName] -> PrimTransform-boolPrimTF [true, false] = PrimTF- { mapCon = M.fromList [(true, prTrue), (false, prFalse)]- , translateCase = \ce brs ->- case brs of- (Branch _ n _vs e:b':_) ->- (if n == true- then If ce e (brExpr b')- else If ce (brExpr b') e)- _ -> __IMPOSSIBLE__- }-boolPrimTF _ = __IMPOSSIBLE__---- | Change all the primitives in the function using the PrimTransform-primFun :: [PrimTransform] -> Fun -> Compile TCM Fun-primFun ptfs (Fun i n qn c args e) =- Fun i n qn c args <$> primExpr ptfs e-primFun _ e@(EpicFun {}) = return e----- | Change all the primitives in an expression using PrimTransform-primExpr :: [PrimTransform] -> Expr -> Compile TCM Expr-primExpr prim ex = case ex of- Var{} -> return ex- Lit{} -> return ex- Lam v e1 -> Lam v <$> primExpr prim e1- Con c n es -> case testCon prim n of- Just pn -> do- filt <- getForcedArgs n- apps pn <$> mapM (primExpr prim) es- Nothing -> Con c n <$> mapM (primExpr prim) es- App v es -> App v <$> mapM (primExpr prim) es- Case e brs -> case testBranch prim brs of- Just p -> primExpr prim $ translateCase p e brs- Nothing -> Case <$> primExpr prim e <*> mapM primBranch brs- If a b c -> If <$> primExpr prim a <*> primExpr prim b <*> primExpr prim c- Let v e e' -> Let v <$> primExpr prim e <*> primExpr prim e'- Lazy e -> Lazy <$> primExpr prim e- UNIT -> return ex- IMPOSSIBLE -> return ex- where- -- | Test if any PrimTransform have any primitive function for- -- a constructor, gives the name of that primitive function in that- -- case, otherwise Nothing.- testCon :: [PrimTransform] -> QName -> Maybe Var- testCon [] _ = Nothing- testCon (p : ps) k = M.lookup k (mapCon p) `mplus` testCon ps k-- -- | Test if we should transform the case, based on the branches. Returns- -- the (first) PrimTransform that is applicable.- testBranch :: [PrimTransform] -> [Branch] -> Maybe PrimTransform- testBranch [] _ = Nothing- testBranch (p:ps) brs = msum (map (check p) brs) `mplus` testBranch ps brs-- -- | Check if a particular PrimTransform can be used on a particular Branch- -- Returns the PrimTransform in that case.- check :: PrimTransform -> Branch -> Maybe PrimTransform- check p br = case br of- Branch _ n _ _ -> fmap (const p) $ M.lookup n (mapCon p)- BrInt _ _ -> Nothing- Default _ -> Nothing-- -- | Change all primitives in a branch- primBranch :: Branch -> Compile TCM Branch- primBranch br = do- e' <- primExpr prim (brExpr br)- return br {brExpr = e'}
@@ -1,135 +0,0 @@-{-# LANGUAGE CPP #-}--- | Smash functions which return something that can be inferred--- (something of a type with only one element)--module Agda.Compiler.Epic.Smashing where--import Control.Arrow((&&&))-import Control.Monad-import Control.Monad.State-import Control.Monad.Trans--import Data.List-import qualified Data.Map as M-import Data.Map (Map)-import Data.Maybe--import qualified Data.Set as S-import Data.Set (Set)--import Agda.Syntax.Common-import Agda.Syntax.Internal as SI-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Telescope-import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Rules.LHS.Unify--import Agda.Compiler.Epic.AuxAST as AA-import Agda.Compiler.Epic.CompileState-import Agda.Compiler.Epic.Interface--import Agda.Utils.Monad-import Agda.Utils.Size--#include "../../undefined.h"-import Agda.Utils.Impossible--defnPars :: Integral n => Defn -> n-defnPars (Record {recPars = p}) = fromIntegral p-defnPars (Constructor {conPars = p}) = fromIntegral p-defnPars d = 0---- | Main function, smash as much as possible-smash'em :: [Fun] -> Compile TCM [Fun]-smash'em funs = do- defs <- lift (gets (sigDefinitions . stImports))- funs' <- forM funs $ \f -> case f of- AA.Fun{} -> case funQName f >>= flip M.lookup defs of- Nothing -> do- lift $ reportSDoc "epic.smashing" 10 $ vcat- [ (text . show) f <+> text " was not found"]- return f-- Just def -> do- lift $ reportSLn "epic.smashing" 10 $ "running on:" ++ (show (funQName f))- minfered <- smashable (length (funArgs f) + defnPars (theDef def)) (defType def)- case minfered of- Just infered -> do- lift $ reportSDoc "smashing" 5 $ vcat- [ prettyTCM (defName def) <+> text "is smashable"]- return f { funExpr = infered- , funInline = True- , funComment = funComment f ++ " [SMASHED]"- }- Nothing -> return f- _ -> do- lift $ reportSLn "epic.smashing" 10 $ "smashing!"- return f- return funs'--(+++) :: Telescope -> Telescope -> Telescope-xs +++ ys = unflattenTel names $ map (raise (size ys)) (flattenTel xs) ++ flattenTel ys- where names = teleNames xs ++ teleNames ys---- | Can a datatype be inferred? If so, return the only possible value.-inferable :: Set QName -> QName -> [Arg Term] -> Compile TCM (Maybe Expr)-inferable visited dat args | dat `S.member` visited = return Nothing-inferable visited dat args = do- lift $ reportSLn "epic.smashing" 10 $ " inferring:" ++ (show dat)- defs <- lift (gets (sigDefinitions . stImports))- let def = fromMaybe __IMPOSSIBLE__ $ M.lookup dat defs- case theDef def of- d@Datatype{} -> do- case dataCons d of- [c] -> inferableArgs c (dataPars d)- _ -> return Nothing- r@Record{} -> inferableArgs (recCon r) (recPars r)- f@Function{} -> do- term <- lift $ normalise $ Def dat args- inferableTerm visited' term- d -> do- lift $ reportSLn "epic.smashing" 10 $ " failed (inferable): " ++ (show d)- return Nothing- where- inferableArgs c pars = do- defs <- lift (gets (sigDefinitions . stImports))- let def = fromMaybe __IMPOSSIBLE__ $ M.lookup c defs- forc <- getForcedArgs c- TelV tel _ <- lift $ telView (defType def `apply` genericTake pars args)- tag <- getConstrTag c- lift $ reportSDoc "epic.smashing" 10 $ nest 2 $ vcat- [ text "inferableArgs!"- , text "tele" <+> prettyTCM tel- , text "constr:" <+> prettyTCM c- ]- (AA.Con tag c <$>) <$> sequence <$> forM (notForced forc $ flattenTel tel) (inferableTerm visited' . unEl . unArg)- visited' = S.insert dat visited--inferableTerm visited t = case t of- Def q as -> inferable visited q as- Pi _ b -> (AA.Lam "_" <$>) <$> inferableTerm visited (unEl $ unAbs b)- Sort {} -> return . return $ AA.UNIT- t -> do- lift $ reportSLn "epic.smashing" 10 $ " failed to infer: " ++ show t- return Nothing---- | Find the only possible value for a certain type. If we fail return Nothing-smashable :: Int -> Type -> Compile TCM (Maybe Expr)-smashable origArity typ = do- defs <- lift (gets (sigDefinitions . stImports))- TelV tele retType <- lift $ telView typ- retType' <- return retType -- lift $ reduce retType-- inf <- inferableTerm S.empty (unEl retType')- lift $ reportSDoc "epic.smashing" 10 $ nest 2 $ vcat- [ text "Result is"- , text "inf: " <+> (text . show) inf- , text "type: " <+> prettyTCM retType'- ]- return $ buildLambda (size tele - origArity) <$> inf--buildLambda :: (Ord n, Num n) => n -> Expr -> Expr-buildLambda n e | n <= 0 = e-buildLambda n e | otherwise = AA.Lam "_" (buildLambda (n - 1) e)
@@ -1,101 +0,0 @@--- | Find the places where the builtin static is used and do some normalisation--- there.--{-# LANGUAGE CPP #-}--module Agda.Compiler.Epic.Static where--import Control.Applicative-import Control.Monad-import Control.Monad.State-import Control.Monad.Trans--import qualified Data.Map as M--import Agda.Syntax.Common-import Agda.Syntax.Internal--import Agda.TypeChecking.CompiledClause-import Agda.TypeChecking.Monad.Base-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Monad.Options-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Pretty--import Agda.Utils.Monad--import Agda.Compiler.Epic.CompileState--#include "../../undefined.h"-import Agda.Utils.Impossible--normaliseStatic :: CompiledClauses -> Compile TCM CompiledClauses-normaliseStatic = evaluateCC--evaluateCC :: CompiledClauses -> Compile TCM CompiledClauses-evaluateCC ccs = case ccs of- Case n brs -> do- cbrs <- forM (M.toList $ conBranches brs) $ \(c, cc) -> (,) c <$> evaluateCC cc- lbrs <- forM (M.toList $ litBranches brs) $ \(l, cc) -> (,) l <$> evaluateCC cc- cab <- case catchAllBranch brs of- Nothing -> return Nothing- Just cc -> Just <$> evaluateCC cc- return $ Case n Branches- { conBranches = M.fromList cbrs- , litBranches = M.fromList lbrs- , catchAllBranch = cab- }- Done n t -> Done n <$> evaluateTerm t- Fail -> return Fail--etaExpand :: Term -> Compile TCM Term-etaExpand def@(Def n ts) = do- defs <- lift (gets (sigDefinitions . stImports))- let f = maybe __IMPOSSIBLE__ theDef (M.lookup n defs)- len = length . clausePats . head . funClauses $ f- toEta :: Num a => a- toEta = fromIntegral $ len - length ts- term = raise toEta def `apply` [ defaultArg $ Var i [] | i <- [toEta - 1, toEta - 2 .. 0]]- return $ foldr (\ v t -> Lam NotHidden (Abs v t)) term $ replicate toEta "staticVar"-etaExpand x = return x--evaluateTerm :: Term -> Compile TCM Term-evaluateTerm term = case term of- Var x as -> Var x <$> evaluateTerms as- Lam h ab -> do- ab' <- evaluateTerm (unAbs ab)- return $ Lam h $ Abs (absName ab) ab'- Lit l -> return $ Lit l- Def n ts -> do- ifM (not <$> isStatic n)- (Def n <$> evaluateTerms ts) $ do- feta <- return term -- etaExpand term- f <- lift $ normalise feta- lift $ reportSDoc "epic.static" 10 $ vcat- [ text "STATIC pragma fired"- , nest 2 $ vcat- [ text "before :" <+> prettyTCM term- , text "after :" <+> prettyTCM f- ]- ]- return f- Con c args -> Con c <$> evaluateTerms args- Pi arg abs -> return $ Pi arg abs- Sort s -> return $ Sort s- MetaV i args -> return $ MetaV i args- Level l -> return $ Level l- DontCare i -> return $ DontCare i- where- evaluateTerms :: Args -> Compile TCM Args- evaluateTerms as = forM as $ \x -> do- y <- evaluateTerm (unArg x)- return x { unArg = y }-- isStatic :: QName -> Compile TCM Bool- isStatic q = do- defs <- lift (gets (sigDefinitions . stImports))- return $ case fmap theDef $ M.lookup q defs of- Nothing -> False- Just (f@Function{}) -> funStatic f- Just _ -> False
@@ -1,132 +0,0 @@-{-# LANGUAGE CPP #-}---- | Translating Agda types to Haskell types. Used to ensure that imported--- Haskell functions have the right type.--module Agda.Compiler.HaskellTypes where--import Control.Applicative-import Control.Monad.Error-import Data.Char--import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Rules.Builtin.Coinduction-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Free-import Agda.Utils.Monad-import Agda.Utils.Impossible--#include "../undefined.h"--type HaskellKind = String--hsStar :: HaskellKind-hsStar = "*"--hsKFun :: HaskellKind -> HaskellKind -> HaskellKind-hsKFun k l = "(" ++ k ++ " -> " ++ l ++ ")"--hsFun :: HaskellKind -> HaskellKind -> HaskellKind-hsFun a b = "(" ++ a ++ " -> " ++ b ++ ")"--hsUnit :: HaskellType-hsUnit = "()"--hsVar :: Name -> HaskellType-hsVar x = "x" ++ concatMap encode (show x)- where- okChars = ['a'..'z'] ++ ['A'..'Y'] ++ "_'"- encode 'Z' = "ZZ"- encode c- | c `elem` okChars = [c]- | otherwise = "Z" ++ show (fromEnum c)---hsApp :: String -> [HaskellType] -> HaskellType-hsApp d [] = d-hsApp d as = "(" ++ unwords (d : as) ++ ")"--hsForall :: String -> HaskellType -> HaskellType-hsForall x a = "(forall " ++ x ++ ". " ++ a ++ ")"--notAHaskellKind :: Type -> TCM a-notAHaskellKind a = do- err <- fsep $ pwords "The type" ++ [prettyTCM a] ++- pwords "cannot be translated to a Haskell kind."- typeError $ GenericError $ show err--notAHaskellType :: Type -> TCM a-notAHaskellType a = do- err <- fsep $ pwords "The type" ++ [prettyTCM a] ++- pwords "cannot be translated to a Haskell type."- typeError $ GenericError $ show err--getHsType :: QName -> TCM HaskellType-getHsType x = do- d <- compiledHaskell . defCompiledRep <$> getConstInfo x- case d of- Just (HsType t) -> return t- Just (HsDefn t c) -> return hsUnit- _ -> notAHaskellType (El Prop $ Def x [])--getHsVar :: Nat -> TCM HaskellCode-getHsVar i = hsVar <$> nameOfBV i--isHaskellKind :: Type -> TCM Bool-isHaskellKind a =- (const True <$> haskellKind a) `catchError` \_ -> return False--haskellKind :: Type -> TCM HaskellKind-haskellKind a = do- a <- reduce a- case unEl a of- Sort _ -> return hsStar- Pi a b -> hsKFun <$> haskellKind (unArg a) <*> underAbstraction a b haskellKind- Def d _ -> do- d <- compiledHaskell . defCompiledRep <$> getConstInfo d- case d of- Just (HsType t) -> return hsStar- _ -> notAHaskellKind a- _ -> notAHaskellKind a---- | Note that @Inf a b@, where @Inf@ is the INFINITY builtin, is--- translated to @<translation of b>@ (assuming that all coinductive--- builtins are defined).------ Note that if @haskellType@ supported universe polymorphism then the--- special treatment of INFINITY might not be needed.--haskellType :: Type -> TCM HaskellType-haskellType = liftTCM . fromType- where- fromArgs = mapM (fromTerm . unArg)- fromType = fromTerm . unEl- fromTerm v = do- v <- reduce v- reportSLn "compile.haskell.type" 50 $ "toHaskellType " ++ show v- kit <- liftTCM coinductionKit- let err = notAHaskellType (El Prop v)- case v of- Var x args -> hsApp <$> getHsVar x <*> fromArgs args- Def d args | Just d == (nameOfInf <$> kit) ->- case args of- [a, b] -> fromTerm (unArg b)- _ -> err- Def d args -> hsApp <$> getHsType d <*> fromArgs args- Pi a b ->- if isBinderUsed b- then underAbstraction a b $ \b ->- hsForall <$> getHsVar 0 <*>- (hsFun <$> fromType (unArg a) <*> fromType b)- else hsFun <$> fromType (unArg a) <*> fromType (absApp b __IMPOSSIBLE__)- Con c args -> hsApp <$> getHsType c <*> fromArgs args- Lam{} -> err- Level{} -> return hsUnit- Lit{} -> return hsUnit- Sort{} -> return hsUnit- MetaV{} -> err- DontCare{} -> err
@@ -1,127 +0,0 @@-{-# LANGUAGE CPP #-}--module Agda.Compiler.JS.Case where--import Prelude hiding ( null )-import Data.Map ( Map, empty, null, mapWithKey, fromListWith, unionWith )-import Data.List ( genericLength, genericTake, intercalate )--import Agda.Syntax.Common ( Nat )-import Agda.Utils.Impossible ( Impossible(Impossible), throwImpossible )--import Agda.Compiler.JS.Pretty ( Pretty, pretty, pretties )-import Agda.Compiler.JS.Syntax- ( Exp(Undefined,Local,Lambda,Object,Apply,Lookup),- LocalId(LocalId), MemberId )-import Agda.Compiler.JS.Substitution ( shiftFrom )--#include "../../undefined.h"---- ECMAScript doesn't support pattern-mathching case, so--- we translate to a visitor pattern. We use a decision-tree--- translation, as that seems to fit visitor objects better.--data Case = Case { pats :: [Patt], body :: Exp }- deriving (Show)--instance Pretty Case where- pretty n i (Case ps e) =- intercalate " " (pretties n i ps) ++ " -> " ++ pretty (n + numVars ps) i e---- Not handling literal patterns yet--- Note that all patterns introduce binders, in depth-first prefix order,--- for example Tagged l [ VarPatt , VarPatt ] should be thought--- of as "x2 @ l (x1, x0)".--data Patt =- VarPatt |- Tagged Tag [Patt]- deriving (Show)--instance Pretty Patt where- pretty n i VarPatt = "x"- pretty n i (Tagged (Tag l _ _) ps) =- "(" ++ intercalate " " (pretty n i l : pretties n i ps) ++ ")"---- With each tag, we record its name, and the names of the--- other constructors of the datatype (e.g. we'd represent--- zero as Tag "zero" ["suc","zero"]). We also record the--- the function which accepts a visitor (by default Apply,--- but can be over-ridden by the FFI).--data Tag = Tag MemberId [MemberId] (Exp -> [Exp] -> Exp)--instance Show Tag where- show (Tag i is _) = show i---- Number of bound variables in a pattern--numVars :: [Patt] -> Nat-numVars = sum . map numVars'--numVars' :: Patt -> Nat-numVars' (VarPatt) = 1-numVars' (Tagged l ps) = 1 + numVars ps---- Compile a case statement to a function--- in lambda n cs, n is the number of parameters--lambda :: [Case] -> Exp-lambda [] = Undefined-lambda (c:cs) = lambda' 0 0 (genericLength (pats c)) (c:cs)---- In lambda' l m n cs,--- l is the number of free variables,--- m is the number of already read parameters, with m <= l, and--- n is the number of unread parameters.--- Each case should be of the form (Case ps e) where ps has length m+n.--- e can have (l - m + #bv ps) variables free.--- lambda' l m n cs can have l variables free.--lambda' :: Nat -> Nat -> Nat -> [Case] -> Exp-lambda' l m n [] = Undefined-lambda' l 0 0 (c : cs) = body c-lambda' l 0 n cs = Lambda 1 (lambda' (l+1) 1 (n-1) cs)-lambda' l m n cs =- case null ts of- True -> lambda' l (m-1) n (map pop cs)- False -> visit cs (Local (LocalId (m-1))) [Object (mapWithKey (match l (m-1) n cs) ts)]- where- ts = tags cs---- Pop cases--pop :: Case -> Case-pop (Case (VarPatt : ps) e) = (Case ps e)-pop _ = __IMPOSSIBLE__---- Cases which match a given tag/arity--match :: Nat -> Nat -> Nat -> [Case] -> MemberId -> Nat -> Exp-match l m n cs t x = Lambda x (lambda' (l + x) (m + x) n (concat (map (refine t x) cs)))---- Refine a case statement by a given tag/arity--refine :: MemberId -> Nat -> Case -> [Case]-refine t x (Case (VarPatt : qs) e) =- [Case (genericTake x (repeat VarPatt) ++ qs) (shiftFrom (numVars qs) x e)]-refine t x (Case (Tagged (Tag u _ _) ps : qs) e) | t == u =- [Case (ps ++ qs) e]-refine _ _ _ = []---- Extract the visit function--visit :: [Case] -> Exp -> [Exp] -> Exp-visit (Case (Tagged (Tag _ _ v) _ : _) _ : _ ) = v-visit (Case (VarPatt : _) _ : cs) = visit cs-visit _ = Apply---- Extract the list of possible tags, and their arity.--tags :: [Case] -> Map MemberId Nat-tags = foldl (unionWith max) empty . map tag--tag :: Case -> Map MemberId Nat-tag (Case (Tagged (Tag t us _) ps : qs) e) =- fromListWith max ((t, genericLength ps) : [ (u, 0) | u <- us ])-tag _ = empty
@@ -1,448 +1,990 @@-{-# LANGUAGE CPP #-}--module Agda.Compiler.JS.Compiler where--import Prelude hiding ( null, writeFile )-import Control.Monad.Reader ( liftIO )-import Control.Monad.State ( get, put )-import Data.List ( intercalate, map, filter, isPrefixOf, concat, genericDrop, genericLength )-import Data.Set ( Set, empty, null, insert, difference, delete )-import Data.Map ( Map, fold, singleton, fromList, toList, toAscList, insertWith, elems )-import System.Directory ( createDirectoryIfMissing )-import System.FilePath ( pathSeparator, splitFileName, (</>) )--import Agda.Interaction.FindFile ( findFile, findInterfaceFile )-import Agda.Interaction.Imports ( isNewerThan )-import Agda.Interaction.Options ( optCompileDir )-import Agda.Syntax.Common ( Nat, Arg, unArg )-import Agda.Syntax.Concrete.Name ( projectRoot )-import Agda.Syntax.Abstract.Name- ( ModuleName(MName), QName(QName),- mnameToList, qnameName, qnameModule, isInModule, nameId )-import Agda.Syntax.Internal- ( Name, Args, Type,- Clause(Clause), Pattern(VarP,DotP,LitP,ConP), Abs(Abs),- ClauseBody(Body,NoBody,Bind),- Term(Var,Lam,Lit,Level,Def,Con,Pi,Sort,MetaV,DontCare),- toTopLevelModuleName, clausePats, clauseBody, arity, unEl, unAbs )-import Agda.TypeChecking.Substitute ( absBody )-import Agda.Syntax.Literal ( Literal(LitInt,LitFloat,LitString,LitChar,LitQName) )-import Agda.TypeChecking.Level ( reallyUnLevelView )-import Agda.TypeChecking.Monad- ( TCM, Definition(Defn), Definitions, Interface,- JSCode, Defn(Record,Datatype,Constructor,Primitive,Function,Axiom),- iModuleName, iImportedModules, theDef, getConstInfo, typeOfConst,- ignoreAbstractMode, miInterface, getVisitedModules,- defName, defType, funClauses, funProjection,- dataPars, dataIxs, dataClause, dataCons,- conPars, conData, conSrcCon,- recClause, recCon, recFields, recPars, recNamedCon,- primClauses, defJSDef )-import Agda.TypeChecking.Monad.Options ( setCommandLineOptions, commandLineOptions, reportSLn )-import Agda.TypeChecking.Reduce ( instantiateFull, normalise )-import Agda.Utils.FileName ( filePath )-import Agda.Utils.Function ( iterate' )-import Agda.Utils.Monad ( (<$>), (<*>), bracket, ifM )-import Agda.Utils.IO.UTF8 ( writeFile )-import Agda.Utils.Impossible ( Impossible(Impossible), throwImpossible )-import Agda.Compiler.MAlonzo.Misc ( curDefs, curIF, curMName, setInterface )-import Agda.Compiler.MAlonzo.Primitives ( repl )--import Agda.Compiler.JS.Syntax- ( Exp(Self,Local,Global,Undefined,String,Char,Integer,Double,Lambda,Object,Apply,Lookup),- LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId), Export(Export), Module(Module),- modName, expName, uses )-import Agda.Compiler.JS.Substitution- ( curriedLambda, curriedApply, fix, emp, object, subst, apply )-import Agda.Compiler.JS.Case ( Tag(Tag), Case(Case), Patt(VarPatt,Tagged), lambda )-import Agda.Compiler.JS.Pretty ( pretty )--#include "../../undefined.h"------------------------------------------------------- Entry point into the compiler-----------------------------------------------------compilerMain :: Interface -> TCM ()-compilerMain mainI =- -- Preserve the state (the compiler modifies the state).- bracket get put $ \_ -> do-- -- Compute the output directory.- opts <- commandLineOptions- compileDir <- case optCompileDir opts of- Just dir -> return dir- Nothing -> do- -- The default output directory is the project root.- let tm = toTopLevelModuleName $ iModuleName mainI- f <- findFile tm- return $ filePath $ projectRoot f tm- setCommandLineOptions $- opts { optCompileDir = Just compileDir }-- ignoreAbstractMode $ do- mapM_ (compile . miInterface) =<< (elems <$> getVisitedModules)--compile :: Interface -> TCM ()-compile i = do- setInterface i- ifM uptodate noComp $ (yesComp >>) $ do- writeModule =<< curModule- where- uptodate = liftIO =<< (isNewerThan <$> outFile_ <*> ifile)- ifile = maybe __IMPOSSIBLE__ filePath <$>- (findInterfaceFile . toTopLevelModuleName =<< curMName)- noComp = reportSLn "" 1 . (++ " : no compilation is needed.").show =<< curMName- yesComp = reportSLn "" 1 . (`repl` "Compiling <<0>> in <<1>> to <<2>>") =<<- sequence [show <$> curMName, ifile, outFile_] :: TCM ()------------------------------------------------------- Naming-----------------------------------------------------prefix = "jAgda"--jsMod :: ModuleName -> GlobalId-jsMod m = GlobalId (prefix : map show (mnameToList m))--jsFileName :: GlobalId -> String-jsFileName (GlobalId ms) = intercalate "." ms ++ ".js"--jsMember :: Name -> MemberId-jsMember n =- -- Anonymous fields are used for where clauses,- -- and they're all given the concrete name "_",- -- so we disambiguate them using their name id.- case show n of- "_" -> MemberId ("_" ++ show (nameId n))- l -> MemberId l---- Rather annoyingly, the anonymous construtor of a record R in module M--- is given the name M.recCon, but a named constructor C--- is given the name M.R.C, sigh. This causes a lot of hoop-jumping--- in the map from Agda names to JS names, which we patch by renaming--- anonymous constructors to M.R.record.--global' :: QName -> TCM (Exp,[MemberId])-global' q = do- i <- iModuleName <$> curIF- is <- filter (isInModule q) <$> map (iModuleName . miInterface) <$> elems <$> getVisitedModules- case is of- [] -> __IMPOSSIBLE__- _ -> let- seg = maximum (map (length . mnameToList) is)- ms = mnameToList (qnameModule q)- m = MName (take seg ms)- ls = map jsMember (drop seg ms ++ [qnameName q])- in case (m == i) of- True -> return (Self, ls)- False -> return (Global (jsMod m), ls)--global :: QName -> TCM (Exp,[MemberId])-global q = do- d <- getConstInfo q- case d of- Defn { theDef = Constructor { conData = p } } -> do- e <- getConstInfo p- case e of- Defn { theDef = Record { recNamedCon = False } } -> do- (m,ls) <- global' p- return (m, ls ++ [MemberId "record"])- _ -> global' (defName d)- _ -> global' (defName d)---- Reorder a list of exports to ensure def-before-use.--- Note that this can diverge in the case when there is no such reordering.--reorder :: [Export] -> [Export]-reorder = reorder' empty--reorder' :: Set [MemberId] -> [Export] -> [Export]-reorder' defs [] = []-reorder' defs (e : es) =- let us = uses e `difference` defs in- case null us of- True -> e : (reorder' (insert (expName e) defs) es)- False -> reorder' defs (insertAfter us e es)--insertAfter :: Set [MemberId] -> Export -> [Export] -> [Export]-insertAfter us e [] = [e]-insertAfter us e (f:fs) | null us = e : f : fs-insertAfter us e (f:fs) | otherwise = f : insertAfter (delete (expName f) us) e fs------------------------------------------------------- Main compiling clauses-----------------------------------------------------curModule :: TCM Module-curModule = do- m <- (jsMod <$> curMName)- is <- map jsMod <$> (iImportedModules <$> curIF)- es <- mapM definition =<< (toList <$> curDefs)- return (Module m (reorder es))--definition :: (QName,Definition) -> TCM Export-definition (q,d) = do- (_,ls) <- global q- d <- instantiateFull d- e <- defn q ls (defType d) (defJSDef d) (theDef d)- return (Export ls e)--defn :: QName -> [MemberId] -> Type -> Maybe JSCode -> Defn -> TCM Exp-defn q ls t (Just e) Axiom =- return e-defn q ls t Nothing Axiom = do- t <- normalise t- s <- isSingleton t- case s of- -- Inline and eta-expand postulates of singleton type- Just e ->- return (curriedLambda (arity t) e)- -- Everything else we leave undefined- Nothing ->- return Undefined-defn q ls t (Just e) (Function {}) =- return e-defn q ls t Nothing (Function { funProjection = proj, funClauses = cls }) = do- t <- normalise t- s <- isSingleton t- cs <- mapM clause cls- case s of- -- Inline and eta-expand expressions of singleton type- Just e ->- return (curriedLambda (arity t) e)- Nothing -> case proj of- Just (p,i) -> do- d <- getConstInfo p- case theDef d of- -- For projections from records we use a field lookup- Record { recFields = flds } | q `elem` map unArg flds ->- return (curriedLambda (numPars cls)- (Lookup (Local (LocalId 0)) (last ls)))- _ ->- -- For anything else we generate code, after adding (i-1) dummy lambdas- return (dummyLambda (i-1) (lambda cs))- Nothing ->- return (lambda cs)-defn q ls t (Just e) (Primitive {}) =- return e-defn q ls t _ (Primitive {}) =- return Undefined-defn q ls t _ (Datatype {}) =- return emp-defn q ls t (Just e) (Constructor {}) =- return e-defn q ls t _ (Constructor { conData = p, conPars = nc }) = do- np <- return (arity t - nc)- d <- getConstInfo p- case theDef d of- Record { recFields = flds } ->- return (curriedLambda np (Object (fromList- ( (last ls , Lambda 1- (Apply (Lookup (Local (LocalId 0)) (last ls))- [ Local (LocalId (np - i)) | i <- [0 .. np-1] ]))- : (zip [ jsMember (qnameName (unArg fld)) | fld <- flds ]- [ Local (LocalId (np - i)) | i <- [1 .. np] ])))))- _ ->- return (curriedLambda (np + 1)- (Apply (Lookup (Local (LocalId 0)) (last ls))- [ Local (LocalId (np - i)) | i <- [0 .. np-1] ]))-defn q ls t _ (Record {}) =- return emp---- Number of params in a function declaration--numPars :: [Clause] -> Nat-numPars [] = 0-numPars (c : _) = genericLength (clausePats c)---- One clause in a function definition--clause :: Clause -> TCM Case-clause c = do- ps <- mapM (pattern . unArg) (clausePats c)- (av,bv,es) <- return (mapping (map unArg (clausePats c)))- e <- body (clauseBody c)- return (Case ps (subst av es e))---- Mapping from Agda variables to JS variables in a pattern.--- If mapping ps = (av,bv,es) then av is the number of Agda variables,--- bv is the number of JS variables, and es is a list of expressions,--- where es[i] is the JS variable corresponding to Agda variable i.--mapping :: [Pattern] -> (Nat,Nat,[Exp])-mapping = foldr mapping' (0,0,[])--mapping' :: Pattern -> (Nat,Nat,[Exp]) -> (Nat,Nat,[Exp])-mapping' (VarP _) (av,bv,es) = (av+1, bv+1, Local (LocalId bv) : es)-mapping' (DotP _) (av,bv,es) = (av+1, bv+1, Local (LocalId bv) : es)-mapping' (ConP _ _ ps) (av,bv,es) = (av',bv'+1,es') where- (av',bv',es') = foldr mapping' (av,bv,es) (map unArg ps)-mapping' (LitP _) (av,bv,es) = (av, bv+1, es)---- Not doing literal patterns yet--pattern :: Pattern -> TCM Patt-pattern (ConP q _ ps) = do- l <- tag q- ps <- mapM (pattern . unArg) ps- return (Tagged l ps)-pattern _ = return VarPatt--tag :: QName -> TCM Tag-tag q = do- l <- visitorName q- c <- getConstInfo q- case theDef c of- (Constructor { conData = p }) -> do- d <- getConstInfo p- case (defJSDef d, theDef d) of- (Just e, Datatype { dataCons = qs }) -> do- ls <- mapM visitorName qs- return (Tag l ls (\ x xs -> apply e (x:xs)))- (Nothing, Datatype { dataCons = qs }) -> do- ls <- mapM visitorName qs- return (Tag l ls Apply)- (Just e, Record {}) -> do- return (Tag l [l] (\ x xs -> apply e (x:xs)))- (Nothing, Record {}) -> do- return (Tag l [l] Apply)- _ -> __IMPOSSIBLE__- _ -> __IMPOSSIBLE__--visitorName :: QName -> TCM MemberId-visitorName q = do (m,ls) <- global q; return (last ls)--body :: ClauseBody -> TCM Exp-body (Body e) = term e-body (Bind b) = body (unAbs b)-body (NoBody) = return Undefined--term :: Term -> TCM Exp-term (Var i as) = do- e <- return (Local (LocalId i))- es <- args Nothing as- return (curriedApply e es)-term (Lam _ at) = Lambda 1 <$> term (absBody at)-term (Lit l) = return (literal l)-term (Level l) = term =<< reallyUnLevelView l-term (Def q as) = do- d <- getConstInfo q- case theDef d of- -- Datatypes and records are erased- Datatype {} -> return (String "*")- Record {} -> return (String "*")- _ -> case defJSDef d of- -- Inline functions with an FFI definition- Just e -> do- es <- args (defProjection d) as- return (curriedApply e es)- Nothing -> do- t <- normalise (defType d)- s <- isSingleton t- case s of- -- Inline and eta-expand singleton types- Just e ->- return (curriedLambda (arity t) e)- -- Everything else we leave non-inline- Nothing -> do- e <- qname q- es <- args (defProjection d) as- return (curriedApply e es)-term (Con q as) = do- d <- getConstInfo q- case defJSDef d of- -- Inline functions with an FFI definition- Just e -> do- es <- args Nothing as- return (curriedApply e es)- -- Everything else we leave non-inline- Nothing -> do- e <- qname q- es <- args Nothing as- return (curriedApply e es)-term (Pi _ _) = return (String "*")-term (Sort _) = return (String "*")-term (MetaV _ _) = return (Undefined)-term (DontCare _) = return (Undefined)---- Check to see if a type is a singleton, and if so, return its only--- member. Singleton types are of the form T1 -> ... -> Tn -> T where--- T is either a record with no fields, a datatype with one--- no-argument constructor, a datatype with no constructors,--- or (since this is a type-erasing translation) Set.--isSingleton :: Type -> TCM (Maybe Exp)-isSingleton t = case unEl t of- Pi _ b -> isSingleton (unAbs b)- Sort _ -> return (Just (String "*"))- Def q as -> do- d <- getConstInfo q- case (theDef d) of- Datatype { dataPars = np, dataCons = [] } ->- return (Just Undefined)- Datatype { dataPars = np, dataCons = [p] } -> do- c <- getConstInfo p- case (arity (defType c) == np) of- True -> Just <$> qname p- False -> return (Nothing)- Record { recCon = p, recFields = [] } ->- Just <$> qname p- _ -> return (Nothing)- _ -> return (Nothing)--defProjection :: Definition -> Maybe (QName, Int)-defProjection Defn { theDef = Function { funProjection = p } } = p-defProjection _ = Nothing--args :: Maybe(QName, Int) -> Args -> TCM [Exp]-args Nothing as =- mapM (term . unArg) as-args (Just (q,i)) as = do- es <- mapM (term . unArg) as- return (replicate (i-1) Undefined ++ es)--qname :: QName -> TCM Exp-qname q = do- (e,ls) <- global q- return (foldl Lookup e ls)--literal :: Literal -> Exp-literal (LitInt _ x) = Integer x-literal (LitFloat _ x) = Double x-literal (LitString _ x) = String x-literal (LitChar _ x) = Char x-literal (LitQName _ x) = String (show x)--dummyLambda :: Int -> Exp -> Exp-dummyLambda n = iterate' n (Lambda 0)------------------------------------------------------- Writing out an ECMAScript module-----------------------------------------------------writeModule :: Module -> TCM ()-writeModule m = do- out <- outFile (modName m)- liftIO (writeFile out (pretty 0 0 m))--compileDir :: TCM FilePath-compileDir = do- mdir <- optCompileDir <$> commandLineOptions- case mdir of- Just dir -> return dir- Nothing -> __IMPOSSIBLE__--outFile :: GlobalId -> TCM FilePath-outFile m = do- mdir <- compileDir- let (fdir, fn) = splitFileName (jsFileName m)- let dir = mdir </> fdir- fp = dir </> fn- liftIO $ createDirectoryIfMissing True dir- return fp--outFile_ :: TCM FilePath-outFile_ = do- m <- curMName- outFile (jsMod m)+{-# OPTIONS_GHC -Wunused-binds #-}++-- | Main module for JS backend.++module Agda.Compiler.JS.Compiler where++import Prelude hiding ( null, writeFile )++import Control.DeepSeq+import Control.Monad.Trans++import Data.Char ( isSpace )+import Data.Foldable ( forM_, foldrM )+import Data.Functor ( (<&>) )+import Data.List ( dropWhileEnd, elemIndex, intercalate, partition )+import Data.Maybe ( listToMaybe )+import Data.Set ( Set )++import qualified Data.Set as Set+import qualified Data.Map as Map+import qualified Data.Text as T++import GHC.Generics (Generic)++import System.Directory ( createDirectoryIfMissing )+import System.Environment ( setEnv )+import System.FilePath ( splitFileName, (</>) )+import System.Process ( callCommand )++import Agda.Setup ( getDataDir )++import Agda.Interaction.Options++import Agda.Syntax.Common+import Agda.Syntax.Concrete.Name ( isNoName )+import Agda.Syntax.Abstract.Name+ ( QName,+ mnameToList, qnameName, qnameModule, nameId )+import Agda.Syntax.Internal+ ( Name, Type+ , nameFixity, unDom, telToList )+import Agda.Syntax.Literal ( Literal(..) )+import Agda.Syntax.TopLevelModuleName (TopLevelModuleName, TopLevelModuleName'(..))+import Agda.Syntax.Treeless ( ArgUsage(..), filterUsed )+import qualified Agda.Syntax.Treeless as T++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce ( instantiateFull )+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Warnings ( warning )++import Agda.Utils.FileName ( isNewerThan )+import Agda.Utils.Function ( iterate' )+import Agda.Utils.List ( downFrom, headWithDefault )+import Agda.Utils.List1 ( List1, pattern (:|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe ( boolToMaybe, catMaybes, caseMaybeM, fromMaybe, whenNothing )+import Agda.Utils.Monad ( ifM, when, whenM )+import Agda.Utils.Null ( null )+import Agda.Syntax.Common.Pretty (prettyShow, render)+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Utils.IO.Directory+import Agda.Utils.IO.UTF8 ( writeFile )+import Agda.Utils.Singleton ( singleton )+import Agda.Utils.Size (size)++import Agda.Compiler.Common as CC+import Agda.Compiler.Backend (Backend,Backend_boot(..), Backend',Backend'_boot(..), Recompile(..))++import qualified Agda.Compiler.ToTreeless as T+import qualified Agda.Compiler.Treeless.EliminateDefaults as T+import qualified Agda.Compiler.Treeless.EliminateLiteralPatterns as T+import qualified Agda.Compiler.Treeless.GuardsToPrims as T+import qualified Agda.Compiler.Treeless.Erase as T+import qualified Agda.Compiler.Treeless.Subst as T++import Agda.Compiler.JS.Syntax+ ( Exp(Self,Local,Global,Undefined,Null,String,Char,Integer,Double,Lambda,Object,Array,Apply,Lookup,If,BinOp,PlainJS, MemberIdInString, Ternary),+ LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId, MemberIndex), Export(Export), Module(Module, modName, callMain),+ modName, expName, uses, JSQName+ )+import Agda.Compiler.JS.Substitution+ ( curriedLambda, curriedApply, emp, apply, substShift, subst', subst, shiftFrom)+import qualified Agda.Compiler.JS.Pretty as JSPretty+import Agda.Compiler.JS.Pretty (JSModuleStyle(..))++import Agda.Utils.Impossible (__IMPOSSIBLE__)++--------------------------------------------------+-- Entry point into the compiler+--------------------------------------------------++jsBackend :: Backend+jsBackend = Backend jsBackend'++jsBackend' :: Backend' JSOptions JSOptions JSModuleEnv Module (Maybe Export)+jsBackend' = Backend'+ { backendName = jsBackendName+ , backendVersion = Nothing+ , options = defaultJSOptions+ , commandLineFlags = jsCommandLineFlags+ , isEnabled = optJSCompile+ , preCompile = jsPreCompile+ , postCompile = jsPostCompile+ , preModule = jsPreModule+ , postModule = jsPostModule+ , compileDef = jsCompileDef+ , scopeCheckingSuffices = False+ , mayEraseType = const $ return True+ -- Andreas, 2019-05-09, see issue #3732.+ -- If you want to use JS data structures generated from Agda+ -- @data@/@record@, you might want to tell the treeless compiler+ -- not to erase these types even if they have no content,+ -- to get a stable interface.+ , backendInteractTop = Nothing+ , backendInteractHole = Nothing+ }++--- Options ---++data JSOptions = JSOptions+ { optJSCompile :: Bool+ , optJSOptimize :: Bool+ , optJSMinify :: Bool+ -- ^ Remove spaces etc. See https://en.wikipedia.org/wiki/Minification_(programming).+ , optJSVerify :: Bool+ -- ^ Run generated code through interpreter.+ , optJSModuleStyle :: JSModuleStyle+ }+ deriving Generic++instance NFData JSModuleStyle++instance NFData JSOptions++defaultJSOptions :: JSOptions+defaultJSOptions = JSOptions+ { optJSCompile = False+ , optJSOptimize = False+ , optJSMinify = False+ , optJSVerify = False+ , optJSModuleStyle = JSCJS+ }++jsCommandLineFlags :: [OptDescr (Flag JSOptions)]+jsCommandLineFlags =+ [ Option [] ["js"] (NoArg enable) "compile program using the JS backend"+ , Option [] ["js-optimize"] (NoArg enableOpt) "turn on optimizations during JS code generation"+ -- Minification is described at https://en.wikipedia.org/wiki/Minification_(programming)+ , Option [] ["js-minify"] (NoArg enableMin) "minify generated JS code"+ , Option [] ["js-verify"] (NoArg enableVerify) "except for main module, run generated JS modules through `node` (needs to be in PATH)"+ , Option [] ["js-es6"] (NoArg setES6) "use ES6 module style for JS (recommended)"+ , Option [] ["js-cjs"] (NoArg setCJS) "use CommonJS module style (default) (deprecated)"+ , Option [] ["js-amd"] (NoArg setAMD) "use AMD module style for JS (deprecated)"+ ]+ where+ enable o = pure o{ optJSCompile = True }+ enableOpt o = pure o{ optJSOptimize = True }+ enableMin o = pure o{ optJSMinify = True }+ enableVerify o = pure o{ optJSVerify = True }+ setES6 o = pure o{ optJSModuleStyle = JSES6 }+ setCJS o = pure o{ optJSModuleStyle = JSCJS }+ setAMD o = pure o{ optJSModuleStyle = JSAMD }++--- Top-level compilation ---++jsPreCompile :: JSOptions -> TCM JSOptions+jsPreCompile opts = opts <$ do+ mapM_ (typeError . CubicalCompilationNotSupported) =<< cubicalOption+ case optJSModuleStyle opts of+ JSCJS -> warning $ DeprecationWarning "JavaScript CommonJS module style" (Just "ES6 module style (via --js-es6)") "Agda version 2.10.0"+ JSAMD -> warning $ DeprecationWarning "JavaScript AMD module style" (Just "ES6 module style (via --js-es6)") "Agda version 2.10.0"+ JSES6 -> return ()++-- | After all modules have been compiled, copy RTE modules and verify compiled modules.++jsPostCompile ::+ JSOptions -> IsMain -> Map.Map TopLevelModuleName Module -> TCM ()+jsPostCompile opts _ ms = do++ -- Copy RTE modules.++ compDir <- compileDir+ liftIO $ do+ dataDir <- getDataDir+ let fname = case optJSModuleStyle opts of+ JSCJS -> "agda-rts.js"+ JSAMD -> "agda-rts.amd.js"+ JSES6 -> "agda-rts.mjs"+ srcPath = dataDir </> "JS" </> fname+ compPath = compDir </> fname+ copyIfChanged srcPath compPath++ -- Verify generated JS modules (except for main).++ reportSLn "compile.js.verify" 10 $ "Considering to verify generated JS modules"+ when (optJSVerify opts) $ do++ reportSLn "compile.js.verify" 10 $ "Verifying generated JS modules"+ liftIO $ setEnv "NODE_PATH" compDir++ forM_ ms $ \ Module{ modName, callMain } -> do+ jsFile <- outFile (optJSModuleStyle opts) modName+ reportSLn "compile.js.verify" 30 $ unwords [ "Considering JS module:" , jsFile ]++ -- Since we do not run a JS program for real, we skip all modules that could+ -- have a call to main.+ -- Atm, modules whose compilation was skipped are also skipped during verification+ -- (they appear here as main modules).+ whenNothing callMain $ do+ -- node needs to see whether the extension is .js or .mjs,+ -- so we pass input explicitly, not via stdin+ let cmd = unwords [ "node", jsFile ]+ reportSLn "compile.js.verify" 20 $ unwords [ "calling:", cmd ]+ liftIO $ callCommand cmd++--- Module compilation ---++data JSModuleEnv = JSModuleEnv+ { jsCoinductionKit :: Maybe CoinductionKit+ , jsCompile :: Bool+ -- ^ Should this module be compiled?+ }++jsPreModule ::+ JSOptions -> IsMain -> TopLevelModuleName -> Maybe FilePath ->+ TCM (Recompile JSModuleEnv Module)+jsPreModule opts _ m mifile = do+ cubical <- cubicalOption+ let compile = case cubical of+ -- Code that uses --cubical is not compiled.+ Just CFull -> False+ Just CErased -> True+ Just CWithoutGlue -> True+ Nothing -> True+ ifM uptodate noComp (yesComp compile)+ where+ outFile_ = do+ m <- curMName+ outFile (optJSModuleStyle opts) (jsMod m)++ uptodate = case mifile of+ Nothing -> pure False+ Just ifile -> liftIO =<< isNewerThan <$> outFile_ <*> pure ifile+ ifileDesc = fromMaybe "(memory)" mifile++ noComp = do+ reportSLn "compile.js" 2 . (++ " : no compilation is needed.") . prettyShow =<< curMName+ return $ Skip skippedModule++ -- A skipped module acts as a fake main module, to be skipped by --js-verify as well.+ skippedModule = Module (jsMod m) mempty mempty (Just __IMPOSSIBLE__)++ yesComp compile = do+ m <- prettyShow <$> curMName+ out <- outFile_+ alwaysReportSLn "compile.js" 1 $ repl [m, ifileDesc, out] "Compiling <<0>> in <<1>> to <<2>>"+ kit <- coinductionKit+ return $ Recompile $ JSModuleEnv+ { jsCoinductionKit = kit+ , jsCompile = compile+ }++jsPostModule ::+ JSOptions -> JSModuleEnv -> IsMain -> TopLevelModuleName ->+ [Maybe Export] -> TCM Module+jsPostModule opts _ isMain _ defs = do+ m <- jsMod <$> curMName+ is <- map (jsMod . fst) . iImportedModules <$> curIF+ let mod = Module m is (reorder es) callMain+ writeModule (optJSMinify opts) (optJSModuleStyle opts) mod+ return mod+ where+ es = catMaybes defs+ main = MemberId "main"+ -- Andreas, 2020-10-27, only add invocation of "main" if such function is defined.+ -- This allows loading of generated .js files into an interpreter+ -- even if they do not define "main".+ hasMain = isMain == IsMain && any ((singleton main ==) . expName) es+ callMain :: Maybe Exp+ callMain = boolToMaybe hasMain $ Apply (Lookup Self main) [Lambda 1 emp]+++jsCompileDef :: JSOptions -> JSModuleEnv -> IsMain -> Definition -> TCM (Maybe Export)+jsCompileDef opts kit _isMain def = do+ definition (opts, kit) (defName def, def)++--------------------------------------------------+-- Naming+--------------------------------------------------++prefix :: [Char]+prefix = "jAgda"++jsMod :: TopLevelModuleName -> GlobalId+jsMod m =+ GlobalId (prefix : map T.unpack (List1.toList (moduleNameParts m)))++jsFileName :: JSModuleStyle -> GlobalId -> String+jsFileName JSES6 (GlobalId ms) = intercalate "." ms ++ ".mjs" -- Hint that file is ES6, not old js+jsFileName _ (GlobalId ms) = intercalate "." ms ++ ".js"++jsMember :: Name -> MemberId+jsMember n+ -- Anonymous fields are used for where clauses,+ -- and they're all given the concrete name "_",+ -- so we disambiguate them using their name id.+ | isNoName n = MemberId ("_" ++ show (nameId n))+ | otherwise = MemberId $ prettyShow n++global' :: QName -> TCM (Exp, JSQName)+global' q = do+ i <- iTopLevelModuleName <$> curIF+ top <- CC.topLevelModuleName (qnameModule q)+ let+ -- Global module prefix+ qms = mnameToList $ qnameModule q+ -- File-local module prefix+ localms = drop (size top) qms+ nm = fmap jsMember $ List1.snoc localms $ qnameName q+ if top == i+ then return (Self, nm)+ else return (Global (jsMod top), nm)++global :: QName -> TCM (Exp, JSQName)+global q = do+ d <- getConstInfo q+ case d of+ Defn { theDef = Constructor { conData = p } } -> do+ getConstInfo p >>= \case+ -- Lawrence 2026-08-14: TODO: switch to "constructor" now the encoding is changing anyway?+ -- Andreas, 2020-10-27, comment quotes outdated fact.+ -- anon. constructors are now M.R.constructor.+ -- We could simplify/remove the workaround by switching "record"+ -- to "constructor", but this changes the output of the JS compiler+ -- maybe in ways that break user's developments+ -- (if they link to Agda-generated JS).+ -- -- Rather annoyingly, the anonymous constructor of a record R in module M+ -- -- is given the name M.recCon, but a named constructor C+ -- -- is given the name M.R.C, sigh. This causes a lot of hoop-jumping+ -- -- in the map from Agda names to JS names, which we patch by renaming+ -- -- anonymous constructors to M.R.record.+ Defn { theDef = Record { recNamedCon = False } } -> do+ (m,ls) <- global' p+ return (m, ls <> singleton (MemberId "record"))+ _ -> global' (defName d)+ _ -> global' (defName d)++-- Reorder a list of exports to ensure def-before-use.+-- Note that this can diverge in the case when there is no such reordering.++-- Only top-level values are evaluated before definitions are added to the+-- module, so we put those last, ordered in dependency order. There can't be+-- any recursion between top-level values (unless termination checking has been+-- disabled and someone's written a non-sensical program), so reordering will+-- terminate.++reorder :: [Export] -> [Export]+reorder es = datas ++ funs ++ reorder' (Set.fromList $ map expName $ datas ++ funs) vals+ where+ (vs, funs) = partition isTopLevelValue es+ (datas, vals) = partition isEmptyObject vs++reorder' :: Set JSQName -> [Export] -> [Export]+reorder' defs [] = []+reorder' defs (e : es) =+ let us = uses e `Set.difference` defs+ in if null us+ then e : (reorder' (Set.insert (expName e) defs) es)+ else reorder' defs (insertAfter us e es)++isTopLevelValue :: Export -> Bool+isTopLevelValue (Export _ e) = case e of+ Object m | flatName `Map.member` m -> False+ Lambda{} -> False+ _ -> True++isEmptyObject :: Export -> Bool+isEmptyObject (Export _ e) = case e of+ Object m -> null m+ Lambda{} -> True+ _ -> False++insertAfter :: Set JSQName -> Export -> [Export] -> [Export]+insertAfter us e [] = [e]+insertAfter us e (f : fs) | null us = e : f : fs+insertAfter us e (f : fs) | otherwise =+ f : insertAfter (Set.delete (expName f) us) e fs++--------------------------------------------------+-- Main compiling clauses+--------------------------------------------------++type EnvWithOpts = (JSOptions, JSModuleEnv)++definition :: EnvWithOpts -> (QName,Definition) -> TCM (Maybe Export)+definition kit (q,d) = do+ reportSDoc "compile.js" 10 $ "compiling def:" <+> prettyTCM q+ (_,ls) <- global q+ d <- instantiateFull d++ definition' kit q d (defType d) ls++-- | Ensure that there is at most one pragma for a name.+checkCompilerPragmas :: QName -> TCM ()+checkCompilerPragmas q =+ caseMaybeM (getUniqueCompilerPragma jsBackendName q) (return ()) $ \ (CompilerPragma r s) -> do+ setCurrentRange r do+ -- Issue #3545: Warn user about ignored COMPILE pragma for defined functions.+ getConstInfo q <&> theDef >>= \case+ FunctionDefn{} -> whenM (T.isErasable q) $ warning $ PragmaCompileErased jsBackendName q+ _ -> return()+ -- If the pragma is not of the form "q = bla", complain.+ when (listToMaybe (words s) /= Just "=") do+ typeError $ JSBackendError BadCompilePragma++defJSDef :: Definition -> Maybe String+defJSDef def =+ case defCompilerPragmas jsBackendName def of+ [CompilerPragma _ s] -> Just (dropEquals s)+ [] -> Nothing+ _:_:_ -> __IMPOSSIBLE__+ where+ dropEquals = dropWhile $ \ c -> isSpace c || c == '='++definition' :: EnvWithOpts -> QName -> Definition -> Type -> JSQName -> TCM (Maybe Export)+definition' kit q d t ls =+ if not (jsCompile (snd kit)) || not (usableModality d)+ then return Nothing+ else do+ checkCompilerPragmas q+ case theDef d of+ -- coinduction+ Constructor{}+ | Just q == (nameOfSharp <$> jsCoinductionKit (snd kit)) -> do+ return Nothing+ Function{}+ | Just q == (nameOfFlat <$> jsCoinductionKit (snd kit)) -> do+ ret $ Lambda 1 $ Apply (Lookup (local 0) flatName) []++ DataOrRecSig{} -> __IMPOSSIBLE__++ Axiom{} | Just e <- defJSDef d -> plainJS e+ Axiom{} | otherwise -> ret Undefined++ GeneralizableVar{} -> return Nothing++ Function{} | Just e <- defJSDef d -> plainJS e+ Function{} | otherwise -> do++ reportSDoc "compile.js" 5 $ "compiling fun:" <+> prettyTCM q+ let mTreeless = T.toTreeless T.EagerEvaluation q+ caseMaybeM mTreeless (pure Nothing) $ \ funBody -> do+ used <- fromMaybe [] <$> getCompiledArgUse q+ reportSDoc "compile.js" 30 $ " compiled treeless fun:" <+> pretty funBody+ reportSDoc "compile.js" 40 $ " argument usage:" <+> (text . show) used++ funBody' <- compileTerm kit funBody++ reportSDoc "compile.js" 30 $ " compiled JS fun:" <+> (text . show) funBody'+ return $+ if funBody' == Null then Nothing+ else Just $ Export ls funBody'++ Primitive{primName = p}+ | p == builtin_glueU ->+ -- The string prim^glueU is not a valid JS name.+ plainJS "agdaRTS.prim_glueU"+ | p == builtin_unglueU ->+ -- The string prim^unglueU is not a valid JS name.+ plainJS "agdaRTS.prim_unglueU"+ | p `Set.member` primitives ->+ plainJS $ "agdaRTS." ++ getBuiltinId p+ | Just e <- defJSDef d ->+ plainJS e+ | p `Set.member` undefinedPrimitives ->+ ret Undefined+ | otherwise -> do+ warning $ UnknownJSPrimitive $ getBuiltinId p+ ret Undefined+ PrimitiveSort{} -> return Nothing++ Datatype{} -> do+ T.computeErasedConstructorArgs q+ ret emp+ Record{} -> do+ T.computeErasedConstructorArgs q+ return Nothing++ Constructor{} | Just e <- defJSDef d -> plainJS e+ -- Encode constructor definitions to JS functions that construct Tagged Arrays+ -- (see the note "Implementing data types")+ Constructor+ { conArity = conArity -- Number of fields stored in the constructor+ } -> do+ let l = List1.last ls+ ret+ $ curriedLambda conArity+ $ Array $ MemberIdInString l : [Local (LocalId i) | i <- reverse [0..conArity-1]]++ AbstractDefn{} -> __IMPOSSIBLE__+ where+ ret = return . Just . Export ls+ plainJS = ret . PlainJS++-- Implementing data types+--------------------------++-- Data constructors are compiled to arrays where the 0th element is a string tag.+-- Such arrays are called 'Tagged Arrays'+--+-- For example, given the data type+--+-- data Foo (A : Set) : Set where+-- c1 : Foo A+-- c2 : X -> Y -> Foo A+-- c3 : Foo A -> Foo A+--+-- here is how "Foo" is compiled:+--+-- * A constructor definition, e.g.+--+-- c2 : X -> Y -> Foo A+--+-- compiles to+--+-- exports["Foo"]["c2"] = x => y => ["c2", x, y]+--+-- notice how the data-type parameter A does not become a parameter of the constructor c2.+-- Nor do any module parameters.+--+-- * A constructor application, e.g.+--+-- c2 E1 E2+--+-- compiles to+--+-- exports["Foo"]["c2"](E1)(E2)+--+-- * A case split, e.g.+--+-- case p of+-- (c1 ) -> E1+-- (c2 x y) -> E2 (where E2 = ...x ... y ...)+-- (c3 f ) -> E3 (where E3 = ... f ... )+--+-- compiles to+--+-- (p[0] == "c1") ? E1+-- : (p[0] == "c2") ? E2 (where E2 = ... p[1] ... p[2] ...)+-- : (p[0] == "c3") ? E3 (where E3 = ... p[1] ... )+-- : undefined+--+-- unless a there is a {-# COMPILE JS Foo = <split> #-} pragma,+-- in which case this case split compiles to+--+-- <split>+-- { "c1": () => E1+-- , "c2": (x,y) => E2 (where E2 = ... x ... y ... )+-- , "c3": (f) => E3 (where E3 = ... f ...)+-- }+--+-- Record types are compiled like single-argument data types++compileTerm :: EnvWithOpts -> T.TTerm -> TCM Exp+compileTerm kit = go+ where+ go :: T.TTerm -> TCM Exp+ go = \case+ T.TVar x -> return $ Local $ LocalId x+ T.TDef q -> do+ d <- getConstInfo q+ case theDef d of+ -- Datatypes and records are erased+ Datatype {} -> return (String "*")+ Record {} -> return (String "*")+ _ -> qname q+ T.TApp (T.TCon q) [x]+ | Just q == (nameOfSharp <$> jsCoinductionKit (snd kit)) -> do+ x <- go x+ let evalThunk = unlines+ [ "function() {"+ , " delete this.flat;"+ , " var result = this.__flat_helper();"+ , " delete this.__flat_helper;"+ , " this.flat = function() { return result; };"+ , " return result;"+ , "}"+ ]+ return $ Object $ Map.fromListWith __IMPOSSIBLE__+ [(flatName, PlainJS evalThunk)+ ,(MemberId "__flat_helper", Lambda 0 x)]+ T.TApp t xs -> do+ -- Lawrence 2026-08: evaluating version hangs on Issue7595:+ -- curriedApply' <$> go t <*> mapM go xs+ curriedApply <$> go t <*> mapM go xs+ T.TLam t -> Lambda 1 <$> go t+ T.TLet T.Strict t e -> do+ t' <- go t+ e' <- go e+ return $ Apply (Lambda 1 e') [t']+ -- `let x = t in e` is compiled to `(x => e[x()/x])(() => t)` so that `t`+ -- is only evaluated inside the body+ T.TLet T.NonStrict t e -> do+ t' <- Lambda 0 <$> go t+ e' <- substShift 1 1 [Apply (Local (LocalId 0)) []] <$> go e+ return $ Apply (Lambda 1 e') [t']+ T.TLit l -> return $ literal l+ -- Encode constructor applications to Tagged Arrays+ -- (see the note "Implementing data types")+ T.TCon q -> qname q+ t@(T.TCase sc ci@(T.CaseInfo{caseType = T.CTData dt}) def alts) -> do+ pragma <- defJSDef <$> getConstInfo dt+ let isReachable = not (T.isUnreachable def)+ case (pragma, isReachable) of+ -- Recursive case (COMPILE JS pragma present, inexhaustive match): make exhautive & try again+ (Just _, True) -> go =<< T.eliminateCaseDefaultAtTopLevelIfPresent t+ -- Base case (COMPILE JS pragma present, all cases handled): emit call to pragma+ (Just e, False) -> compileCaseWithPragma e kit sc alts+ -- Base case (no COMPILE JS pragma): compile as usual+ (Nothing, _) -> compileCaseNoPragma kit sc def alts+ T.TCase sc ci def alts -> compileCaseNoPragma kit sc def alts+ T.TPrim p -> return $ compilePrim p+ T.TUnit -> unit+ T.TSort -> unit+ T.TErased -> unit+ T.TError T.TUnreachable -> return Undefined+ T.TError T.TMeta{} -> return Undefined+ T.TCoerce t -> go t++ unit = return Null++-- Compiles a case split, without consulting any COMPILE JS pragmas+-- Returns a chain of ternary expressions+-- (see the note "Implementing data types")+compileCaseNoPragma :: EnvWithOpts -> Int -> T.TTerm -> [T.TAlt] -> TCM Exp+compileCaseNoPragma kit sc def alts = do+ def' <- compileTerm kit def+ foldrM (compileAlt kit sc) def' alts++-- Compile a case split, using a COMPILE JS pragma on the data type.+-- Precondition: cases present for all constructors of data type+-- Returns a call to the pragma+-- (see the note "Implementing data types")+compileCaseWithPragma :: String -> EnvWithOpts -> Int -> [T.TAlt] -> TCM Exp+compileCaseWithPragma pragmaContents kit sc alts = do+ let scrutinee = Local (LocalId sc)+ alts' <- alts & traverse \case+ T.TACon con nargs body -> do+ mid <- visitorName con+ body <- Lambda nargs <$> compileTerm kit body+ return (mid, body)+ _ -> __IMPOSSIBLE__+ return $ apply (PlainJS pragmaContents) [scrutinee, Object $ Map.fromListWith __IMPOSSIBLE__ alts']++-- Compiles a single treeless alternative (+ default case),+-- to a Ternary expression (see the note "Implementing data types")+compileAlt :: EnvWithOpts -> Int -> T.TAlt -> Exp -> TCM Exp+compileAlt kit sc (T.TACon {aCon = aCon, aArity = aArity, aBody = aBody}) def = do+ let scrutinee = Local (LocalId sc)+ body <- compileTerm kit aBody+ -- Lawrence 2026-08: evaluating versions hang on Issue7595:+ -- let body' = shiftFrom aArity 0 $ subst' aArity [Lookup scrutinee (MemberIndex i) | i <- [1 .. aArity]] body+ -- let body' = curriedApply' (curriedLambda aArity body) [Lookup scrutinee (MemberIndex i) | i <- [1 .. aArity]]+ -- but non-evalauting versions OK:+ -- let body' = curriedApply (curriedLambda aArity body) [Lookup scrutinee (MemberIndex i) | i <- [1 .. aArity]]+ let body' = shiftFrom aArity 0 $ subst aArity [Lookup scrutinee (MemberIndex i) | i <- [1 .. aArity]] body+ mid <- visitorName aCon+ pure $ Ternary (BinOp (Lookup scrutinee (MemberIndex 0)) "==" (MemberIdInString mid)) body' def+compileAlt kit _ (T.TAGuard {aGuard = aGuard, aBody = aBody}) def = do+ guard <- compileTerm kit aGuard+ body <- compileTerm kit aBody+ pure $ Ternary guard body def+compileAlt kit sc (T.TALit {aLit = LitQName q, aBody = aBody}) def = do+ let scrutinee = Local (LocalId sc)+ body <- compileTerm kit aBody+ pure $ Ternary (BinOp (Lookup scrutinee (MemberId "name")) "==" (String $ T.pack $ prettyShow q)) body def+-- Lawrence 2026-08: I suspect the lack of special case for LitMeta is buggy,+-- but it does not break the existing tests+compileAlt kit sc (T.TALit {aLit = aLit, aBody = aBody}) def = do+ let scrutinee = Local (LocalId sc)+ body <- compileTerm kit aBody+ pure $ Ternary (BinOp scrutinee "==" (literal aLit)) body def++compilePrim :: T.TPrim -> Exp+compilePrim p =+ case p of+ T.PIf -> curriedLambda 3 $ If (local 2) (local 1) (local 0)+ T.PEqI -> binOp "agdaRTS.uprimIntegerEqual"+ T.PEqF -> binOp "agdaRTS.uprimFloatEquality"+ T.PEqQ -> binOp "agdaRTS.uprimQNameEquality"+ T.PEqS -> primEq+ T.PEqC -> primEq+ T.PGeq -> binOp "agdaRTS.uprimIntegerGreaterOrEqualThan"+ T.PLt -> binOp "agdaRTS.uprimIntegerLessThan"+ T.PAdd -> binOp "agdaRTS.uprimIntegerPlus"+ T.PSub -> binOp "agdaRTS.uprimIntegerMinus"+ T.PMul -> binOp "agdaRTS.uprimIntegerMultiply"+ T.PRem -> binOp "agdaRTS.uprimIntegerRem"+ T.PQuot -> binOp "agdaRTS.uprimIntegerQuot"+ T.PAdd64 -> binOp "agdaRTS.uprimWord64Plus"+ T.PSub64 -> binOp "agdaRTS.uprimWord64Minus"+ T.PMul64 -> binOp "agdaRTS.uprimWord64Multiply"+ T.PRem64 -> binOp "agdaRTS.uprimIntegerRem" -- -|+ T.PQuot64 -> binOp "agdaRTS.uprimIntegerQuot" -- > These can use the integer functions+ T.PEq64 -> binOp "agdaRTS.uprimIntegerEqual" -- |+ T.PLt64 -> binOp "agdaRTS.uprimIntegerLessThan" -- -|+ T.PITo64 -> unOp "agdaRTS.primWord64FromNat"+ T.P64ToI -> unOp "agdaRTS.primWord64ToNat"+ T.PSeq -> binOp "agdaRTS.primSeq"+ where binOp js = curriedLambda 2 $ apply (PlainJS js) [local 1, local 0]+ unOp js = curriedLambda 1 $ apply (PlainJS js) [local 0]+ primEq = curriedLambda 2 $ BinOp (local 1) "===" (local 0)++visitorName :: QName -> TCM MemberId+visitorName q = List1.last . snd <$> global q++flatName :: MemberId+flatName = MemberId "flat"++local :: Nat -> Exp+local = Local . LocalId++qname :: QName -> TCM Exp+qname q = do+ (e,ls) <- global q+ return (foldl Lookup e ls)++literal :: Literal -> Exp+literal = \case+ (LitNat x) -> Integer x+ (LitWord64 x) -> Integer (fromIntegral x)+ (LitFloat x) -> Double x+ (LitString x) -> String x+ (LitChar x) -> Char x+ (LitQName x) -> litqname x+ (LitMeta _ m) -> litmeta m++litqname :: QName -> Exp+litqname q =+ Object $ Map.fromListWith __IMPOSSIBLE__+ [ (mem "id", Integer $ fromIntegral n)+ , (mem "moduleId", Integer $ fromIntegral m)+ , (mem "name", String $ T.pack $ prettyShow q)+ , (mem "fixity", litfixity fx)]+ where+ mem = MemberId+ NameId n (ModuleNameHash m) = nameId q+ fx = theFixity $ nameFixity $ qnameName q++ litfixity :: Fixity -> Exp+ litfixity fx = Object $ Map.fromListWith __IMPOSSIBLE__+ [ (mem "assoc", litAssoc $ fixityAssoc fx)+ , (mem "prec", litPrec $ fixityLevel fx)]++ -- TODO this will probably not work well together with the necessary FFI bindings+ litAssoc NonAssoc = String "non-assoc"+ litAssoc LeftAssoc = String "left-assoc"+ litAssoc RightAssoc = String "right-assoc"++ litPrec Unrelated = String "unrelated"+ litPrec (Related l) = Double l++litmeta :: MetaId -> Exp+litmeta (MetaId m h) =+ Object $ Map.fromListWith __IMPOSSIBLE__+ [ (MemberId "id", Integer $ fromIntegral m)+ , (MemberId "module", Integer $ fromIntegral $ moduleNameHash h) ]+++--------------------------------------------------+-- Writing out an ECMAScript module+--------------------------------------------------++writeModule :: Bool -> JSModuleStyle -> Module -> TCM ()+writeModule minify ms m = do+ out <- outFile ms (modName m)+ liftIO (writeFile out (JSPretty.prettyShow minify ms m))++outFile :: JSModuleStyle -> GlobalId -> TCM FilePath+outFile ms m = do+ mdir <- compileDir+ let (fdir, fn) = splitFileName (jsFileName ms m)+ let dir = mdir </> fdir+ fp = dir </> fn+ liftIO $ createDirectoryIfMissing True dir+ return fp++-- | Primitives implemented in the JS Agda RTS.+primitives :: Set PrimitiveId+primitives = Set.fromList+ [ PrimShowInteger++ -- Natural number functions+ -- , PrimNatPlus -- missing+ , PrimNatMinus+ -- , PrimNatTimes -- missing+ -- , PrimNatDivSucAux -- missing+ -- , PrimNatModSucAux -- missing+ -- , PrimNatEquality -- missing+ -- , PrimNatLess -- missing+ -- , PrimShowNat -- missing++ -- Machine words+ , PrimWord64ToNat+ , PrimWord64FromNat+ -- , PrimWord64ToNatInjective -- missing++ -- Level functions+ -- , PrimLevelZero -- missing+ -- , PrimLevelSuc -- missing+ -- , PrimLevelMax -- missing++ -- Floating point functions+ , PrimFloatEquality+ , PrimFloatInequality+ , PrimFloatLess+ , PrimFloatIsInfinite+ , PrimFloatIsNaN+ , PrimFloatIsNegativeZero+ , PrimFloatIsSafeInteger+ , PrimFloatToWord64+ -- , PrimFloatToWord64Injective -- missing+ , PrimNatToFloat+ , PrimIntToFloat+ -- , PrimFloatRound -- in Agda.Builtin.Float+ -- , PrimFloatFloor -- in Agda.Builtin.Float+ -- , PrimFloatCeiling -- in Agda.Builtin.Float+ -- , PrimFloatToRatio -- in Agda.Builtin.Float+ , PrimRatioToFloat+ -- , PrimFloatDecode -- in Agda.Builtin.Float+ -- , PrimFloatEncode -- in Agda.Builtin.Float+ , PrimShowFloat+ , PrimFloatPlus+ , PrimFloatMinus+ , PrimFloatTimes+ , PrimFloatNegate+ , PrimFloatDiv+ , PrimFloatSqrt+ , PrimFloatExp+ , PrimFloatLog+ , PrimFloatSin+ , PrimFloatCos+ , PrimFloatTan+ , PrimFloatASin+ , PrimFloatACos+ , PrimFloatATan+ , PrimFloatATan2+ , PrimFloatSinh+ , PrimFloatCosh+ , PrimFloatTanh+ , PrimFloatASinh+ , PrimFloatACosh+ , PrimFloatATanh+ , PrimFloatPow++ -- Character functions+ -- , PrimCharEquality -- in Agda.Builtin.Char+ -- , PrimIsLower -- in Agda.Builtin.Char+ -- , PrimIsDigit -- in Agda.Builtin.Char+ -- , PrimIsAlpha -- in Agda.Builtin.Char+ -- , PrimIsSpace -- in Agda.Builtin.Char+ -- , PrimIsAscii -- in Agda.Builtin.Char+ -- , PrimIsLatin1 -- in Agda.Builtin.Char+ -- , PrimIsPrint -- in Agda.Builtin.Char+ -- , PrimIsHexDigit -- in Agda.Builtin.Char+ -- , PrimToUpper -- in Agda.Builtin.Char+ -- , PrimToLower -- in Agda.Builtin.Char+ -- , PrimCharToNat -- in Agda.Builtin.Char+ -- , PrimCharToNatInjective -- missing+ -- , PrimNatToChar -- in Agda.Builtin.Char+ -- , PrimShowChar -- in Agda.Builtin.String++ -- String functions+ -- , PrimStringToList -- in Agda.Builtin.String+ -- , PrimStringToListInjective -- missing+ -- , PrimStringFromList -- in Agda.Builtin.String+ -- , PrimStringFromListInjective -- missing+ -- , PrimStringAppend -- in Agda.Builtin.String+ -- , PrimStringEquality -- in Agda.Builtin.String+ -- , PrimShowString -- in Agda.Builtin.String+ -- , PrimStringUncons -- in Agda.Builtin.String++ -- Other stuff+ -- , PrimEraseEquality -- missing+ -- , PrimForce -- missing+ -- , PrimForceLemma -- missing+ , PrimQNameEquality+ , PrimQNameLess+ , PrimShowQName+ , PrimQNameFixity+ -- , PrimQNameToWord64s -- missing+ -- , PrimQNameToWord64sInjective -- missing+ , PrimMetaEquality+ , PrimMetaLess+ , PrimShowMeta+ , PrimMetaToNat+ -- , PrimMetaToNatInjective -- missing+ , PrimQrec+ , builtinIMin+ , builtinIMax+ , builtinINeg+ , PrimPartial+ , PrimPartialP+ , builtinPOr+ , builtinComp+ , builtinTrans+ , builtinHComp+ , builtinSubOut+ , builtin_glueU+ , builtin_unglueU+ , builtinFaceForall+ -- , builtinGlue -- missing+ -- , builtin_glue -- missing+ -- , builtin_unglue -- missing+ ]++-- | Primitives that are intentionally compiled to @Undefined@ by the+-- JS backend (e.g. because they are erased, they are type-level only,+-- or they are implemented in Agda). Any primitive not in 'primitives',+-- 'undefinedPrimitives', or handled via 'defJSDef' will trigger an+-- 'UnknownJSPrimitive' warning.+undefinedPrimitives :: Set PrimitiveId+undefinedPrimitives = Set.fromList+ [ -- Natural number functions+ PrimNatPlus+ , PrimNatTimes+ , PrimNatDivSucAux+ , PrimNatModSucAux+ , PrimNatEquality+ , PrimNatLess+ , PrimShowNat++ -- Machine words+ , PrimWord64ToNatInjective++ -- Level functions+ , PrimLevelZero+ , PrimLevelSuc+ , PrimLevelMax++ -- Floating point functions (implemented in Agda.Builtin.Float)+ , PrimFloatRound+ , PrimFloatFloor+ , PrimFloatCeiling+ , PrimFloatToRatio+ , PrimFloatDecode+ , PrimFloatEncode+ , PrimFloatToWord64Injective++ -- Character functions (implemented in Agda.Builtin.Char)+ , PrimCharEquality+ , PrimIsLower+ , PrimIsDigit+ , PrimIsAlpha+ , PrimIsSpace+ , PrimIsAscii+ , PrimIsLatin1+ , PrimIsPrint+ , PrimIsHexDigit+ , PrimToUpper+ , PrimToLower+ , PrimCharToNat+ , PrimCharToNatInjective+ , PrimNatToChar+ , PrimShowChar++ -- String functions (implemented in Agda.Builtin.String)+ , PrimStringToList+ , PrimStringToListInjective+ , PrimStringFromList+ , PrimStringFromListInjective+ , PrimStringAppend+ , PrimStringEquality+ , PrimShowString+ , PrimStringUncons++ -- Other+ , PrimEraseEquality+ , PrimForce+ , PrimForceLemma+ , PrimQNameToWord64s+ , PrimQNameToWord64sInjective+ , PrimMetaToNatInjective++ -- Cubical (missing)+ , builtinGlue+ , builtin_glue+ , builtin_unglue+ ]
@@ -1,187 +0,0 @@-module Agda.Compiler.JS.Parser where---- This is a simple parser for the ECMAScript FFI, which parses a--- subset of ECMAscript expressions. We do this so that we can--- optimize code that contains FFI expressions, for example--- {-# COMPILED_JS _+_ function (x) { return function (y) { return x+y; }; } #-}--- will generate ECMAScript "1 + 2" from Agda "1 + 2".--import Prelude hiding ( exp, lookup )-import Control.Monad.Identity ( Identity )-import Data.List ( genericLength )-import Data.Char ( isSpace, isLetter, isAlphaNum, isDigit )-import Data.Map ( Map, fromList, union, empty )-import qualified Data.Map as M-import qualified Data.Map as M--import Agda.Utils.ReadP- ( ReadP, (+++), (<++), between, chainl1, char, choice, look, many, many1,- munch, munch1, parse', pfail, satisfy, sepBy, string, skipSpaces )--import Agda.Syntax.Common ( Nat )-import Agda.Compiler.JS.Syntax- ( LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId),- Exp(Self,Local,Global,Undefined,String,Integer,Lambda,Apply,Object,Lookup,If,BinOp,PreOp,Const) )--type Parser = ReadP Char--identifier :: Parser String-identifier = do- c <- satisfy isLetter- cs <- munch isAlphaNum- skipSpaces- return (c : cs)--wordBoundary :: Parser ()-wordBoundary = do- cs <- look- case cs of- (c:_) | isAlphaNum c -> pfail- _ -> return ()--token :: String -> Parser ()-token s = string s >> wordBoundary >> skipSpaces--punct :: Char -> Parser ()-punct c = char c >> skipSpaces--parened :: Parser a -> Parser a-parened = between (punct '(') (punct ')')--braced :: Parser a -> Parser a-braced = between (punct '{') (punct '}')--bracketed :: Parser a -> Parser a-bracketed = between (punct '[') (punct ']')--quoted :: Parser a -> Parser a-quoted = between (char '"') (punct '"')--stringLit :: Parser Exp-stringLit = do s <- stringStr; return (String s)--stringStr :: Parser String-stringStr = quoted (many stringChr)--stringChr :: Parser Char-stringChr = satisfy (`notElem` "\\\"") +++ escChr---- Not handling all escape sequences-escChr :: Parser Char-escChr = char '\\' >> (- (char 'n' >> return '\n') +++- (char 'r' >> return '\r') +++- (char 't' >> return '\t') +++- (char '"' >> return '"') +++- (char '\\' >> return '\\')- )---- Not handling all integer constants-intLit :: Parser Exp-intLit = do s <- munch1 isDigit; skipSpaces; return (Integer (read s))--undef :: Parser Exp-undef = token "undefined" >> return Undefined--localid :: (Map String Nat) -> Parser Exp-localid m = do- s <- identifier- case M.lookup s m of- Nothing -> return (Const s)- Just i -> return (Local (LocalId i))--globalid :: Parser Exp-globalid = do- token "require"- i <- parened (quoted (sepBy (munch1 isAlphaNum) (char '.')))- return (Global (GlobalId i))--preop :: Parser String-preop = do- op <- choice (map string [ "+", "-", "!" ])- skipSpaces- return op--binop :: Parser String-binop = do- op <- choice (map string [- "<", ">", "<=", ">=", "==", "===", "<<", ">>",- "<<<", ">>>", "!=", "!==", "+", "-", "*", "%", "/",- "&", "&&", "|", "||", "^"- ])- skipSpaces- return op--field :: (Map String Nat) -> Parser (MemberId,Exp)-field m = do- l <- stringStr- punct ':'- e <- exp m- return (MemberId l, e)--object :: (Map String Nat) -> Parser Exp-object m = do- o <- braced (sepBy (field m) (punct ','))- return (Object (fromList o))--function :: (Map String Nat) -> Parser Exp-function m = do- token "function"- xs <- parened (sepBy identifier (punct ','))- n <- return (genericLength xs)- m' <- return (union (fromList (zip xs [n-1,n-2..0])) (M.map (+n) m))- e <- bracedBlock m'- return (Lambda n e)--bracedBlock :: (Map String Nat) -> Parser Exp-bracedBlock m = braced (returnBlock m +++ ifBlock m +++ bracedBlock m)--returnBlock :: (Map String Nat) -> Parser Exp-returnBlock m = between (token "return") (punct ';') (exp m)--ifBlock :: (Map String Nat) -> Parser Exp-ifBlock m = do- token "if"- e <- parened (exp m)- f <- bracedBlock m- token "else"- g <- (ifBlock m +++ bracedBlock m)- return (If e f g)--exp0 :: (Map String Nat) -> Parser Exp-exp0 m = function m <++ undef <++ globalid <++ localid m <++- object m <++ stringLit <++ intLit <++ parened (exp m)--exp1 :: (Map String Nat) -> Parser Exp-exp1 m =- (do op <- preop; e <- exp1 m; return (PreOp op e)) <++- (exp0 m)--exp2 :: (Map String Nat) -> Parser Exp-exp2 m = exp1 m >>= exp2' m---- Not handling operator fixity or precedence-exp2' :: (Map String Nat) -> Exp -> Parser Exp-exp2' m e =- (do es <- parened (sepBy (exp m) (punct ',')); exp2' m (Apply e es)) <++- (do i <- bracketed stringStr; exp2' m (Lookup e (MemberId i))) <++- (do punct '.'; i <- identifier; exp2' m (Lookup e (MemberId i))) <++- (do op <- binop; f <- exp0 m; exp2' m (BinOp e op f)) <++- (return e)--exp3 :: (Map String Nat) -> Parser Exp-exp3 m = exp2 m >>= exp3' m--exp3' :: (Map String Nat) -> Exp -> Parser Exp-exp3' m e =- (do punct '?'; f <- exp2 m; punct ':'; g <- exp2 m; return (If e f g)) <++- (return e)--exp :: (Map String Nat) -> Parser Exp-exp = exp3--topLevel :: Parser Exp-topLevel = skipSpaces >> exp empty--parse :: String -> Either Exp String-parse = parse' topLevel
@@ -1,26 +1,192 @@ module Agda.Compiler.JS.Pretty where -import Prelude hiding ( null )+import GHC.Generics (Generic)++import Data.Char ( isAsciiLower, isAsciiUpper, isDigit ) import Data.List ( intercalate )-import Data.Set ( Set, toList, singleton, insert, member )-import Data.Map ( Map, toAscList, empty, null )+import Data.String ( IsString (fromString) )+import Data.Set ( Set, toList, insert, member )+import qualified Data.Set as Set+import Data.Map ( Map, toAscList )+import qualified Data.Text as T import Agda.Syntax.Common ( Nat ) -import Agda.Compiler.JS.Syntax- ( Exp(Self,Local,Global,Undefined,String,Char,Integer,Double,Lambda,Object,Apply,Lookup,If,BinOp,PreOp,Const),- LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId), Module(Module), Export(Export),- globals )+import Agda.Utils.Function ( applyWhen )+import Agda.Utils.Hash+import Agda.Utils.List ( indexWithDefault )+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import qualified Agda.Utils.List1 as List1 +import Agda.Utils.Impossible++import Agda.Compiler.JS.Syntax hiding (exports)+ -- Pretty-print a lambda-calculus expression as ECMAScript. --- Since ECMAScript is C-like rather than Haskell-like, it's easier to--- do the pretty-printing directly than use the Pretty library, which--- assumes Haskell-like indentation.+--- The indentation combinators of the pretty library does not fit C-like languages+--- like ECMAScript.+--- A simple pretty printer is implemented with a better `indent` and punctuation compaction.+---+--- More explanation:+---+--- I have struggled with different pretty printers, and at the end it was much easier+--- to implement and use this ~100 SLOC code pretty printer library.+--- It produces really better quality indentation than I could achieve with the+-- standard pretty printers.+--- This library code is only used in this module, and it is specialized to pretty+--- print JavaScript code for the Agda backend, so I think its best place is in this module.+data JSModuleStyle = JSES6 | JSCJS | JSAMD+ deriving Generic -br :: Int -> String-br i = "\n" ++ take (2*i) (repeat ' ')+data Doc+ = Doc String+ | Indent Int Doc+ | Group Doc+ | Beside Doc Doc+ | Above Doc Doc+ | Enclose Doc Doc Doc+ | Space+ | Empty +minifiedCodeLinesLength :: Int+minifiedCodeLinesLength = 500++render :: Bool -> Doc -> String+render minify = intercalate "\n" . joinLines . map (uncurry mkIndent) . go 0+ where+ joinLines :: [String] -> [String]+ joinLines = applyWhen minify $ chunks 0 []+ where+ chunks len acc [] = [concat (reverse acc)]+ chunks len acc (s: ss)+ | len + n <= minifiedCodeLinesLength = chunks (len + n) (s: acc) ss+ | otherwise = concat (reverse acc): chunks n [s] ss+ where+ n = length s++ joinBy f [x] (y: ys) = f x y ++ ys+ joinBy f (x:xs) ys = x: joinBy f xs ys+ joinBy f xs ys = xs ++ ys++ mkIndent n s | minify = s+ mkIndent n "" = ""+ mkIndent n s = replicate n ' ' ++ s++ overlay (i, s) (j, s') | all punctuation (s ++ s') && n > 0 = [(i, s ++ mkIndent n s')]+ where n = j - (i + length s)+ overlay (j, s') (i, s) | all punctuation (s ++ s') && n > 0 = [(i, s' ++ mkIndent n s)]+ where n = j - (i + length s)+ overlay a b = [a, b]++ punctuation = (`elem` ("(){}[];:, " :: String))++ go i Space = [(i, " ") | not minify]+ go i Empty = []+ go i (Doc s) = [(i, s)]+ go i (Beside d d') = joinBy (\(i, s) (_, s') -> [(i, s ++ s')]) (go i d) (go i d')+ go i (Above d d') = joinBy overlay (go i d) (go i d')+ go i (Indent j d) = go (i + j) d+ go i (Enclose open close d) = go i $ Group $ Above open $ Above d close+ go i (Group d)+ | size ss < 40 = compact ss+ | otherwise = ss+ where+ ss = go i d+ size = sum . map (length . snd)+ compact [] = []+ compact ((i, x): xs) = [(i, x ++ concatMap snd xs)]++instance IsString Doc where+ fromString = Doc++instance Semigroup Doc where+ Empty <> d = d+ d <> Empty = d+ d <> d' = Beside d d'++instance Monoid Doc where+ mempty = Empty+ mappend = (<>)++infixr 5 $+$+infixr 5 $++$+infixr 6 <+> -- fixity has to match the one of Semigroup.(<>)++($+$) :: Doc -> Doc -> Doc+Empty $+$ d = d+d $+$ Empty = d+d $+$ d' = Above d d'++-- | Separate by blank line.++($++$) :: Doc -> Doc -> Doc+Empty $++$ d = d+d $++$ Empty = d+d $++$ d' = d `Above` "" `Above` d'++-- | Separate by space that will be removed by minify.+--+-- For non-removable space, use @d <> " " <> d'@.++(<+>) :: Doc -> Doc -> Doc+Empty <+> d = d+d <+> Empty = d+d <+> d' = d `Beside` Space `Beside` d'++text :: String -> Doc+text = Doc++group :: Doc -> Doc+group = Group++indentBy :: Int -> Doc -> Doc+indentBy i Empty = Empty+indentBy i (Indent j d) = Indent (i + j) d+indentBy i d = Indent i d++enclose :: Doc -> Doc -> Doc -> Doc+enclose open close (Enclose o c d) = Enclose (open <> o) (c <> close) d+enclose open close (Indent _ (Enclose o c d)) = Enclose (open <> o) (c <> close) d+enclose open close d = Enclose open close d++----------------------------------------------------------------------------------------------++space :: Doc+space = Space++indent :: Doc -> Doc+indent = indentBy 2++hcat :: [Doc] -> Doc+hcat = foldr (<>) mempty++vcat :: [Doc] -> Doc+vcat = foldr ($+$) mempty++-- | Concatenate vertically, separated by blank lines.++vsep :: [Doc] -> Doc+vsep = foldr ($++$) mempty++punctuate :: Doc -> [Doc] -> Doc+punctuate _ [] = mempty+punctuate p (x:xs) = indent $ vcat $ go x xs+ where go y [] = [y]+ go y (z:zs) = (y <> p) : go z zs++parens, brackets, braces :: Doc -> Doc+parens = enclose "(" ")"+brackets = enclose "[" "]"+braces = enclose "{" "}"++-- | Apply 'parens' to 'Doc' if boolean is true.+mparens :: Bool -> Doc -> Doc+mparens True d = parens d+mparens False d = d++----------------------------------------------------------------------------------------------+ unescape :: Char -> String unescape '"' = "\\\"" unescape '\\' = "\\\\"@@ -30,89 +196,172 @@ unescape '\x2029' = "\\u2029" unescape c = [c] -unescapes :: String -> String-unescapes s = concat (map unescape s)+unescapes :: String -> Doc+unescapes s = text $ concatMap unescape s --- pretty n i e pretty-prints e, under n levels of de Bruijn binding,--- with i levels of indentation.+-- pretty (n,b) i e pretty-prints e, under n levels of de Bruijn binding+-- if b is true then the output is minified class Pretty a where- pretty :: Nat -> Int -> a -> String+ pretty :: (Nat, Bool, JSModuleStyle) -> a -> Doc+ prettyPrec :: Int -> (Nat, Bool, JSModuleStyle) -> a -> Doc + pretty = prettyPrec 0+ prettyPrec = const pretty++ {-# MINIMAL pretty | prettyPrec #-}++prettyShow :: Pretty a => Bool -> JSModuleStyle -> a -> String+prettyShow minify ms = render minify . pretty (0, minify, ms)++instance Pretty a => Pretty (Maybe a) where+ prettyPrec p n = maybe mempty (prettyPrec p n)+ instance (Pretty a, Pretty b) => Pretty (a,b) where- pretty n i (x,y) = pretty n i x ++ ": " ++ pretty n (i+1) y+ pretty n (x,y) = pretty n x <> ":" <+> pretty n y -- Pretty-print collections class Pretties a where- pretties :: Nat -> Int -> a -> [String]+ pretties :: (Nat, Bool, JSModuleStyle) -> a -> [Doc] instance Pretty a => Pretties [a] where- pretties n i = map (pretty n i)+ pretties n = map (pretty n) +instance Pretty a => Pretties (List1 a) where+ pretties n = pretties n . List1.toList+ instance (Pretty a, Pretty b) => Pretties (Map a b) where- pretties n i o = pretties n i (toAscList o)+ pretties n = pretties n . toAscList -- Pretty print identifiers instance Pretty LocalId where- pretty n i (LocalId x) = "x" ++ show (n - x - 1)+ pretty (n, _, _) (LocalId x) = text $ indexWithDefault __IMPOSSIBLE__ vars (n - x - 1)+ where+ vars = ("": map show [0..]) >>= \s -> map (:s) ['a'..'z'] instance Pretty GlobalId where- pretty n i (GlobalId m) = intercalate "_" m+ pretty n (GlobalId m) = text $ variableName $ intercalate "_" m instance Pretty MemberId where- pretty n i (MemberId s) = "\"" ++ unescapes s ++ "\""+ pretty _ (MemberId s) = "\"" <> unescapes s <> "\""+ pretty n (MemberIndex i) = text (show i) -- Pretty print expressions instance Pretty Exp where- pretty n i (Self) = "exports"- pretty n i (Local x) = pretty n i x- pretty n i (Global m) = pretty n i m- pretty n i (Undefined) = "undefined"- pretty n i (String s) = "\"" ++ unescapes s ++ "\""- pretty n i (Char c) = "\"" ++ unescape c ++ "\""- pretty n i (Integer x) = show x- pretty n i (Double x) = show x- pretty n i (Lambda x e) =- "function (" ++- intercalate ", " (pretties (n+x) i (map LocalId [x-1, x-2 .. 0])) ++- ") " ++ block (n+x) i e- pretty n i (Object o) | null o = "{}"- pretty n i (Object o) | otherwise =- "{" ++ br (i+1) ++ intercalate ("," ++ br (i+1)) (pretties n i o) ++ br i ++ "}"- pretty n i (Apply f es) = pretty n i f ++ "(" ++ intercalate ", " (pretties n i es) ++ ")"- pretty n i (Lookup e l) = pretty n i e ++ "[" ++ pretty n i l ++ "]"- pretty n i (If e f g) =- "(" ++ pretty n i e ++ "? " ++ pretty n i f ++ ": " ++ pretty n i g ++ ")"- pretty n i (PreOp op e) = "(" ++ op ++ " " ++ pretty n i e ++ ")"- pretty n i (BinOp e op f) = "(" ++ pretty n i e ++ " " ++ op ++ " " ++ pretty n i f ++ ")"- pretty n i (Const c) = c+ prettyPrec p n (Self) = "exports"+ prettyPrec p n (Local x) = pretty n x+ prettyPrec p n (Global m) = pretty n m+ prettyPrec p n (Undefined) = "undefined"+ prettyPrec p n (Null) = "null"+ prettyPrec p n (String s) = "\"" <> unescapes (T.unpack s) <> "\""+ prettyPrec p n (Char c) = "\"" <> unescapes [c] <> "\""+ prettyPrec p n (Integer x) = text (show x) <> "n"+ prettyPrec p n (Double x) = text $ show x+ prettyPrec p (n, min, ms) (Lambda x e) = mparens (p > 2) $+ mparens (x /= 1) (punctuate "," (pretties (n + x, min, ms) (map LocalId [x-1, x-2 .. 0])))+ <+> "=>" <+> block (n + x, min, ms) e+ prettyPrec p n (Object o) = braces $ punctuate "," $ pretties n o+ prettyPrec p n (Array es) = brackets $ punctuate "," [pretty n e | e <- es]+ prettyPrec p n (MemberIdInString mid) = pretty n mid+ prettyPrec p n (Ternary eCond eThen eElse) = (prettyPrec 17 n eCond <+> text "?" <+> prettyPrec 17 n eThen)+ $+$ text ":" <+> prettyPrec 17 n eElse+ prettyPrec p n (Apply f es) = prettyPrec 17 n f <> parens (punctuate "," $ pretties n es)+ prettyPrec p n (Lookup e l) = prettyPrec 17 n e <> brackets (pretty n l)+ prettyPrec p n (If e f g) = mparens (p > 2) $+ prettyPrec 3 n e <> "?" <+> prettyPrec 3 n f <> ":" <+> prettyPrec 2 n g+ prettyPrec p n (PreOp op e) = parens $ text op <> " " <> prettyPrec 17 n e+ prettyPrec p n (BinOp e op f) = parens $ prettyPrec 17 n e <> " " <> text op <> " " <> prettyPrec 17 n f+ prettyPrec p n (PlainJS js) = text js -block :: Nat -> Int -> Exp -> String-block n i (If e f g) = "{" ++ br (i+1) ++ block' n (i+1) (If e f g) ++ br i ++ "}"-block n i e = "{" ++ br (i+1) ++ "return " ++ pretty n (i+1) e ++ ";" ++ br i ++ "}"+block :: (Nat, Bool, JSModuleStyle) -> Exp -> Doc+block n e = mparens (doNest e) $ prettyPrec 2 n e+ where+ doNest Object{} = True+ doNest _ = False -block' :: Nat -> Int -> Exp -> String-block' n i (If e f g) = "if (" ++ pretty n i e ++ ") " ++ block n i f ++ " else " ++ block' n i g-block' n i e = block n i e+modname :: GlobalId -> Doc+modname (GlobalId ms) = text $ intercalate "." ms -modname :: GlobalId -> String-modname (GlobalId ms) = "\"" ++ intercalate "." ms ++ "\""+exports :: (Nat, Bool, JSModuleStyle) -> Set JSQName -> [Export] -> Doc+exports n lss [] = Empty+exports n lss es0@(Export ls e : es)+ -- If the parent of @ls@ is already defined (or no parent exists), @ls@ can be defined+ | maybe True (`member` lss) parent =+ "exports" <> hcat (map brackets (pretties n ls)) <+> "=" <+> indent (pretty n e) <> ";" $+$+ exports n (insert ls lss) es+ -- If the parent is not yet defined, first define it as empty object, and then continue with @ls@.+ | otherwise =+ exports n lss $ maybe es0 (\ ls' -> Export ls' (Object mempty) : es0) parent+ where+ parent = List1.nonEmpty $ List1.init ls -exports :: Nat -> Int -> Set [MemberId] -> [Export] -> String-exports n i lss [] = ""-exports n i lss (Export ls e : es) | member (init ls) lss =- "exports[" ++ intercalate "][" (pretties n i ls) ++ "] = " ++ pretty n (i+1) e ++ ";" ++ br i ++- exports n i (insert ls lss) es-exports n i lss (Export ls e : es) | otherwise =- exports n i lss (Export (init ls) (Object empty) : Export ls e : es)+instance Pretty [(GlobalId, Export)] where+ pretty n es+ = vcat [ pretty n g <> hcat (map brackets (pretties n ls)) <+> "=" <+> indent (pretty n e) <> ";"+ | (g, Export ls e) <- es ] instance Pretty Module where- pretty n i (Module m es) =- "define([" ++ intercalate "," ("\"exports\"" : map modname js) ++ "]," ++- "function(" ++ intercalate "," ("exports" : pretties n i js) ++ ") {" ++ br (i+1) ++- exports n (i+1) (singleton []) es ++- "});" ++ br i- where js = toList (globals es)+ pretty opt@(n, min, JSES6) (Module m is es callMain) = vsep+ [ "import agdaRTS from \"./agda-rts.mjs\";"+ , imports+ , "const exports = {};"+ , exports opt Set.empty es+ , pretty opt callMain+ , ";export default exports;"+ ]+ $+$ ""+ where+ imports = vcat [+ "import " <> indent (pretty opt e) <+> " from \"./" <> modname e <> ".mjs\";"+ | e <- toList (globals es <> Set.fromList is)+ ]+ les = toList (globals es <> Set.fromList is)+ pretty opt@(n, min, JSCJS) (Module m is es callMain) = vsep+ [ "var agdaRTS" <+> "=" <+> "require(\"agda-rts\");"+ , imports+ , exports opt Set.empty es+ , pretty opt callMain+ ]+ $+$ ""+ where+ imports = vcat [+ "var " <> indent (pretty opt e) <+> "=" <+> "require(\"" <> modname e <> "\");"+ | e <- toList (globals es <> Set.fromList is)+ ]+ les = toList (globals es <> Set.fromList is)+ pretty opt@(n, min, JSAMD) (Module m is es callMain) = vsep+ [ "define(['agda-rts'"+ <+> hcat [ ", " <+> ("\"" <> modname e <> "\"") | e <- les ]+ <+> "],"+ , "function(agdaRTS"+ <+> hcat [ ", " <+> pretty opt e | e <- les ]+ <+> ") {"+ , "var exports = {};"+ , exports opt Set.empty es+ , pretty opt callMain+ , "; return exports; });"+ ]+ $+$ "" -- Final newline+ where+ les = toList (globals es <> Set.fromList is)+++variableName :: String -> String+variableName s = if isValidJSIdent s then "z_" ++ s else "h_" ++ show (hashString s)++-- | Check if a string is a valid JS identifier. The check ignores keywords+-- as we prepend z_ to our identifiers. The check+-- is conservative and may not admit all valid JS identifiers.++isValidJSIdent :: String -> Bool+isValidJSIdent [] = False+isValidJSIdent (c:cs) = validFirst c && all validOther cs+ where+ validFirst :: Char -> Bool+ validFirst c = isAsciiUpper c || isAsciiLower c || c == '_' || c == '$'++ validOther :: Char -> Bool+ validOther c = validFirst c || isDigit c
@@ -1,31 +1,41 @@ module Agda.Compiler.JS.Substitution where import Prelude hiding ( map, lookup )-import Data.Generics ( Data, Typeable )-import Data.Map ( Map, empty, toList, unionWith, singleton, findWithDefault )-import qualified Data.Map as M ( map )-import Data.Map ( Map )-import Data.List ( genericIndex )-import qualified Data.List as L ( map )+import Data.Map ( empty, unionWith, singleton, findWithDefault )+import qualified Data.Map as Map+import Data.Maybe ( fromMaybe )+import qualified Data.List as List import Agda.Syntax.Common ( Nat ) import Agda.Compiler.JS.Syntax- ( Exp(Self,Undefined,Local,Lambda,Object,Apply,Lookup,If,BinOp,PreOp),- MemberId, LocalId(LocalId), GlobalId(GlobalId) )+ ( Exp(..),+ MemberId, LocalId(LocalId) ) import Agda.Utils.Function ( iterate' )+import Agda.Utils.List ( (!!!) ) -- Map for expressions map :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp+map m f (Self) = Self map m f (Local i) = f m i+map m f (Global g) = Global g+map m f (Undefined) = Undefined+map m f (Null) = Null+map m f (String s) = String s+map m f (Char c) = Char c+map m f (Integer i) = Integer i+map m f (Double d) = Double d map m f (Lambda i e) = Lambda i (map (m + i) f e)-map m f (Object o) = Object (M.map (map m f) o)-map m f (Apply e es) = Apply (map m f e) (L.map (map m f) es)+map m f (Object o) = Object (Map.map (map m f) o)+map m f (Array es) = Array (List.map (map m f) es)+map m f (MemberIdInString mid) = MemberIdInString mid+map m f (Ternary e1 e2 e3) = Ternary (map m f e1) (map m f e2) (map m f e3)+map m f (Apply e es) = Apply (map m f e) (List.map (map m f) es) map m f (Lookup e l) = Lookup (map m f e) l map m f (If e e' e'') = If (map m f e) (map m f e') (map m f e'') map m f (PreOp op e) = PreOp op (map m f e) map m f (BinOp e op e') = BinOp (map m f e) op (map m f e')-map m f e = e+map m f (PlainJS str) = PlainJS str -- Shifting @@ -48,22 +58,37 @@ substituter :: Nat -> [Exp] -> Nat -> LocalId -> Exp substituter n es m (LocalId i) | i < m = Local (LocalId i)-substituter n es m (LocalId i) | (i - m) < n = shift m (genericIndex (es ++ repeat Undefined) (n - (i + 1 - m)))+substituter n es m (LocalId i) | (i - m) < n = shift m $ fromMaybe Undefined $ es !!! (n - (i + 1 - m)) substituter n es m (LocalId i) | otherwise = Local (LocalId (i - n)) +substShift :: Nat -> Nat -> [Exp] -> Exp -> Exp+substShift m n es = subst m es . shiftFrom m n+ -- A variant on substitution which performs beta-reduction map' :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp+map' m f (Self) = Self map' m f (Local i) = f m i+map' m f (Global g) = Global g+map' m f (Undefined) = Undefined+map' m f (Null) = Null+map' m f (String s) = String s+map' m f (Char c) = Char c+map' m f (Integer i) = Integer i+map' m f (Double d) = Double d map' m f (Lambda i e) = Lambda i (map' (m + i) f e)-map' m f (Object o) = Object (M.map (map' m f) o)-map' m f (Apply e es) = apply (map' m f e) (L.map (map' m f) es)+map' m f (Object o) = Object (Map.map (map' m f) o)+map' m f (Array es) = Array (List.map (map' m f) es)+map' m f (MemberIdInString mid) = MemberIdInString mid+map' m f (Ternary e1 e2 e3) = Ternary (map' m f e1) (map' m f e2) (map' m f e3)+map' m f (Apply e es) = apply (map' m f e) (List.map (map' m f) es) map' m f (Lookup e l) = lookup (map' m f e) l map' m f (If e e' e'') = If (map' m f e) (map' m f e') (map' m f e'') map' m f (PreOp op e) = PreOp op (map' m f e) map' m f (BinOp e op e') = BinOp (map' m f e) op (map' m f e')-map' m f e = e+map' m f (PlainJS str) = PlainJS str + subst' :: Nat -> [Exp] -> Exp -> Exp subst' 0 es e = e subst' n es e = map' 0 (substituter n es) e@@ -86,10 +111,11 @@ self :: Exp -> Exp -> Exp self e (Self) = e-self e (Object o) = Object (M.map (self e) o)+self e (Object o) = Object (Map.map (self e) o)+self e (Array es) = Array (List.map (self e) es) self e (Apply f es) = case (self e f) of (Lambda n g) -> self e (subst' n es g)- g -> Apply g (L.map (self e) es)+ g -> Apply g (List.map (self e) es) self e (Lookup f l) = lookup (self e f) l self e (If f g h) = If (self e f) (self e g) (self e h) self e (BinOp f op g) = BinOp (self e f) op (self e g)@@ -105,20 +131,13 @@ -- Some helper functions curriedApply :: Exp -> [Exp] -> Exp-curriedApply = foldl (\ f e -> apply f [e])+curriedApply = foldl (\ f e -> Apply f [e]) +curriedApply' :: Exp -> [Exp] -> Exp+curriedApply' = foldl (\ f e -> apply f [e])+ curriedLambda :: Nat -> Exp -> Exp curriedLambda n = iterate' n (Lambda 1) emp :: Exp emp = Object (empty)--union :: Exp -> Exp -> Exp-union (Object o) (Object p) = Object (unionWith union o p)-union e f = e--vine :: [MemberId] -> Exp -> Exp-vine ls e = foldr (\ l e -> Object (singleton l e)) e ls--object :: [([MemberId],Exp)] -> Exp-object = foldr (\ (ls,e) -> (union (vine ls e))) emp
@@ -1,13 +1,17 @@-{-# LANGUAGE DeriveDataTypeable- #-}+ module Agda.Compiler.JS.Syntax where -import Data.Generics ( Data, Typeable )-import Data.Map ( Map, fold )-import Data.Set ( Set, empty, singleton, union )+import Data.Map (Map)+import Data.Set (Set)+import qualified Data.Set as Set +import Data.Text (Text)+ import Agda.Syntax.Common ( Nat ) +import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import qualified Agda.Utils.List1 as List1+ -- An untyped lambda calculus with records, -- and a special self-binder for recursive declarations @@ -16,95 +20,154 @@ Local LocalId | Global GlobalId | Undefined |- String String |+ Null |+ String Text | Char Char | Integer Integer | Double Double | Lambda Nat Exp | Object (Map MemberId Exp) |+ Array [Exp] |+ MemberIdInString MemberId |+ Ternary Exp Exp Exp | Apply Exp [Exp] | Lookup Exp MemberId | If Exp Exp Exp | BinOp Exp String Exp | PreOp String Exp |- Const String- deriving (Typeable, Data, Show)+ PlainJS String -- ^ Arbitrary JS code.+ deriving (Show, Eq)+-- Code style:+-- All recursive Exp-traversing functions should list every constructor explicitly.+-- Do not write a catch-all case to cover all the trivial constructors.+-- This policy helps catch subtle bugs (randomly failing substitution, missing imports etc.)+-- due to newly-added constructors silently hitting the catch-all case. -- Local identifiers are named by De Bruijn indices. -- Global identifiers are named by string lists. -- Object members are named by strings. newtype LocalId = LocalId Nat- deriving (Typeable, Data, Eq, Ord, Show)+ deriving (Eq, Ord, Show) newtype GlobalId = GlobalId [String]- deriving (Typeable, Data, Eq, Ord, Show)+ deriving (Eq, Ord, Show) -newtype MemberId = MemberId String- deriving (Typeable, Data, Eq, Ord, Show)+data MemberId+ = MemberId String+ | MemberIndex Int+ deriving (Eq, Ord, Show) -- The top-level compilation unit is a module, which names -- the GId of its exports, and a list of definitions -data Export = Export { expName :: [MemberId], defn :: Exp }- deriving (Typeable, Data, Show)+data Export = Export { expName :: JSQName, defn :: Exp }+ deriving Show -data Module = Module { modName :: GlobalId, exports :: [Export] }- deriving (Typeable, Data, Show)+type JSQName = List1 MemberId +data Module = Module+ { modName :: GlobalId+ , imports :: [GlobalId]+ , exports :: [Export]+ , callMain :: Maybe Exp+ }+ deriving Show+ -- Note that modules are allowed to be recursive, via the Self expression, -- which is bound to the exported module. -- Top-level uses of the form exports.l1....lN. class Uses a where- uses :: a -> Set [MemberId]+ uses :: a -> Set JSQName -instance Uses a => Uses [a] where- uses = foldr (union . uses) empty+ default uses :: (a ~ t b, Foldable t, Uses b) => a -> Set JSQName+ uses = foldMap uses -instance Uses a => Uses (Map k a) where- uses = fold (union . uses) empty+instance Uses a => Uses [a]+instance Uses a => Uses (Map k a) +instance (Uses a, Uses b) => Uses (a, b) where+ uses (a, b) = uses a `Set.union` uses b++instance (Uses a, Uses b, Uses c) => Uses (a, b, c) where+ uses (a, b, c) = uses a `Set.union` uses b `Set.union` uses c+ instance Uses Exp where- uses (Object o) = fold (union . uses) empty o- uses (Apply e es) = foldr (union . uses) (uses e) es- uses (Lookup e l) = uses' e [l] where- uses' Self ls = singleton ls- uses' (Lookup e l) ls = uses' e (l : ls)+ uses (Self) = Set.empty+ uses (Local _) = Set.empty+ uses (Global _) = Set.empty+ uses (Undefined) = Set.empty+ uses (Null) = Set.empty+ uses (String _) = Set.empty+ uses (Integer _) = Set.empty+ uses (Char _) = Set.empty+ uses (Double _) = Set.empty+ uses (Lambda n _) = Set.empty+ -- Lawrence 2026-08: I suspect returning Set.empty for lambdas is a bug,+ -- but it does not break existing tests+ uses (Object o) = uses o+ uses (Array es) = uses es+ uses (MemberIdInString mid) = Set.empty -- special case of string literals+ uses (Ternary e1 e2 e3) = Set.unions [uses e1, uses e2, uses e3]+ uses (Apply e es) = uses (e, es)+ uses (Lookup e l) = uses' e (List1.singleton l)+ where+ uses' :: Exp -> JSQName -> Set JSQName+ uses' Self ls = Set.singleton ls+ uses' (Lookup e l) ls = uses' e (l <| ls) uses' e ls = uses e- uses (If e f g) = uses e `union` uses f `union` uses g- uses (BinOp e op f) = uses e `union` uses f+ uses (If e f g) = uses (e, f, g)+ uses (BinOp e op f) = uses (e, f) uses (PreOp op e) = uses e- uses e = empty+ uses (PlainJS _) = Set.empty instance Uses Export where- uses (Export ls e) = uses e+ uses (Export _ e) = uses e -- All global ids class Globals a where globals :: a -> Set GlobalId -instance Globals a => Globals [a] where- globals = foldr (union . globals) empty+ default globals :: (a ~ t b, Foldable t, Globals b) => a -> Set GlobalId+ globals = foldMap globals -instance Globals a => Globals (Map k a) where- globals = fold (union . globals) empty+instance Globals a => Globals [a]+instance Globals a => Globals (Maybe a)+instance Globals a => Globals (Map k a) +instance (Globals a, Globals b) => Globals (a, b) where+ globals (a, b) = globals a `Set.union` globals b++instance (Globals a, Globals b, Globals c) => Globals (a, b, c) where+ globals (a, b, c) = globals a `Set.union` globals b `Set.union` globals c+ instance Globals Exp where- globals (Global i) = singleton i+ globals (Self) = Set.empty+ globals (Local _) = Set.empty+ globals (Global i) = Set.singleton i+ globals (Undefined) = Set.empty+ globals (Null) = Set.empty+ globals (String _) = Set.empty+ globals (Integer _) = Set.empty+ globals (Char _) = Set.empty+ globals (Double _) = Set.empty globals (Lambda n e) = globals e globals (Object o) = globals o- globals (Apply e es) = globals e `union` globals es+ globals (Array es) = globals es+ globals (MemberIdInString _) = Set.empty --special case of string literals+ globals (Ternary e1 e2 e3) = Set.unions [globals e1, globals e2, globals e3]+ globals (Apply e es) = globals (e, es) globals (Lookup e l) = globals e- globals (If e f g) = globals e `union` globals f `union` globals g- globals (BinOp e op f) = globals e `union` globals f+ globals (If e f g) = globals (e, f, g)+ globals (BinOp e op f) = globals (e, f) globals (PreOp op e) = globals e- globals _ = empty+ globals (PlainJS _) = Set.empty instance Globals Export where- globals (Export ls e) = globals e+ globals (Export _ e) = globals e instance Globals Module where- globals (Module m es) = globals es+ globals (Module _ _ es me) = globals (es, me)
@@ -0,0 +1,81 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.MAlonzo.Coerce (addCoercions, erasedArity) where++import Agda.Syntax.Common (Nat)+import Agda.Syntax.Treeless++import Agda.TypeChecking.Monad+ ( HasConstInfo+ , getErasedConArgs+ , getTreeless+ )++-- | Insert unsafeCoerce (in the form of 'TCoerce') everywhere it's needed in+-- the right-hand side of a definition.+addCoercions :: HasConstInfo m => TTerm -> m TTerm+addCoercions = coerceTop+ where+ -- Don't coerce top-level lambdas.+ coerceTop (TLam b) = TLam <$> coerceTop b+ coerceTop t = coerce t++ -- Coerce a term `t`. The result (when translated to Haskell) has type+ -- `forall a. a`.+ coerce t =+ case t of+ TVar{} -> return $ TCoerce t+ TPrim{} -> return $ TCoerce t+ TDef{} -> return $ TCoerce t+ TCon{} -> return $ TCoerce t+ TLit{} -> return $ TCoerce t+ TUnit{} -> return $ TCoerce t+ TSort{} -> return $ TCoerce t+ TErased{} -> return t+ TCoerce{} -> return t+ TError{} -> return t+ TApp f vs -> do+ ar <- funArity f+ if length vs > ar+ then TApp (TCoerce f) <$> mapM softCoerce vs+ else TCoerce . TApp f <$> mapM coerce vs+ TLam b -> TCoerce . TLam <$> softCoerce b+ TLet s e b -> TLet s <$> softCoerce e <*> coerce b+ TCase x t d bs -> TCase x t <$> coerce d <*> mapM coerceAlt bs++ coerceAlt (TACon c a b) = TACon c a <$> coerce b+ coerceAlt (TAGuard g b) = TAGuard <$> coerce g <*> coerce b+ coerceAlt (TALit l b) = TALit l <$> coerce b++ -- Insert TCoerce in subterms. When translated to Haskell, the resulting+ -- term is well-typed with some type arbitrary type.+ softCoerce t =+ case t of+ TVar{} -> return t+ TPrim{} -> return t+ TDef{} -> return t+ TCon{} -> return t+ TLit{} -> return t+ TUnit{} -> return t+ TSort{} -> return t+ TErased{} -> return t+ TCoerce{} -> return t+ TError{} -> return t+ TApp f vs -> do+ ar <- funArity f+ if length vs > ar+ then TApp (TCoerce f) <$> mapM softCoerce vs+ else TApp f <$> mapM coerce vs+ TLam b -> TLam <$> softCoerce b+ TLet s e b -> TLet s <$> softCoerce e <*> softCoerce b+ TCase x t d bs -> TCase x t <$> coerce d <*> mapM coerceAlt bs++funArity :: HasConstInfo m => TTerm -> m Nat+funArity (TDef q) = maybe 0 (fst . tLamView) <$> getTreeless q+funArity (TCon q) = erasedArity q+funArity (TPrim _) = return 3 -- max arity of any primitive+funArity _ = return 0++-- | The number of retained arguments after erasure.+erasedArity :: HasConstInfo m => QName -> m Nat+erasedArity q = length . filter not <$> getErasedConArgs q
@@ -1,549 +1,1379 @@-{-# LANGUAGE CPP, PatternGuards #-}--module Agda.Compiler.MAlonzo.Compiler where--import Control.Applicative-import qualified Control.Exception as E-import Control.Monad.Reader-import Control.Monad.State-import Data.Char-import Data.List as L-import Data.Map as M-import Data.Set as S-import qualified Language.Haskell.Exts.Extension as HS-import qualified Language.Haskell.Exts.Parser as HS-import qualified Language.Haskell.Exts.Syntax as HS-import System.Cmd-import System.Directory-import System.Exit-import System.IO-import System.Time-import System.Process-import System.FilePath hiding (normalise, (<.>))--import Agda.Compiler.MAlonzo.Misc-import Agda.Compiler.MAlonzo.Pretty-import Agda.Compiler.MAlonzo.Primitives-import Agda.Interaction.FindFile-import Agda.Interaction.Imports-import Agda.Interaction.Options-import Agda.Syntax.Common-import qualified Agda.Syntax.Concrete.Name as CN-import Agda.Syntax.Internal-import Agda.Syntax.Literal-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Monad.Options-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Rules.Builtin.Coinduction-import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Level (reallyUnLevelView)-import Agda.Utils.FileName-import Agda.Utils.Monad-import qualified Agda.Utils.IO.Locale as LocIO-import qualified Agda.Utils.IO.UTF8 as UTF8-import Agda.Utils.Impossible--#include "../../undefined.h"--compilerMain :: Interface -> TCM ()-compilerMain mainI =- -- Preserve the state (the compiler modifies the state).- bracket get put $ \_ -> do-- -- Compute the output directory.- opts <- commandLineOptions- compileDir <- case optCompileDir opts of- Just dir -> return dir- Nothing -> do- -- The default output directory is the project root.- let tm = toTopLevelModuleName $ iModuleName mainI- f <- findFile tm- return $ filePath $ CN.projectRoot f tm- setCommandLineOptions $- opts { optCompileDir = Just compileDir }-- ignoreAbstractMode $ do- mapM_ (compile . miInterface) =<< (M.elems <$> getVisitedModules)- writeModule rteModule- callGHC mainI--compile :: Interface -> TCM ()-compile i = do- setInterface i- ifM uptodate noComp $ (yesComp >>) $ do- writeModule =<< decl <$> curHsMod <*> (definitions =<< curDefs) <*> imports- where- decl mn ds imp = HS.Module dummy mn [] Nothing Nothing imp ds- uptodate = liftIO =<< (isNewerThan <$> outFile_ <*> ifile)- ifile = maybe __IMPOSSIBLE__ filePath <$>- (findInterfaceFile . toTopLevelModuleName =<< curMName)- noComp = reportSLn "" 1 . (++ " : no compilation is needed.").show =<< curMName- yesComp = reportSLn "" 1 . (`repl` "Compiling <<0>> in <<1>> to <<2>>") =<<- sequence [show <$> curMName, ifile, outFile_] :: TCM ()------------------------------------------------------- imported modules--- I use stImportedModules in a non-standard way,--- accumulating in it what are acutally used in Misc.xqual-----------------------------------------------------imports :: TCM [HS.ImportDecl]-imports = (++) <$> hsImps <*> imps where- hsImps = (L.map decl . S.toList .- S.insert mazRTE . S.map HS.ModuleName) <$>- getHaskellImports- imps = L.map decl . uniq <$>- ((++) <$> importsForPrim <*> (L.map mazMod <$> mnames))- decl m = HS.ImportDecl dummy m True False Nothing Nothing Nothing- mnames = (++) <$> (S.elems <$> gets stImportedModules)- <*> (iImportedModules <$> curIF)- uniq = L.map head . group . L.sort------------------------------------------------------- Main compiling clauses-----------------------------------------------------definitions :: Definitions -> TCM [HS.Decl]-definitions defs = do- kit <- coinductionKit- M.fold (liftM2 (++) . (definition kit <.> instantiateFull))- declsForPrim- defs---- | Note that the INFINITY, SHARP and FLAT builtins are translated as--- follows (if a 'CoinductionKit' is given):------ @--- type Infinity a b = b------ sharp :: a -> a--- sharp x = x------ flat :: forall a. () -> forall b. () -> b -> b--- flat _ _ x = x--- @--definition :: Maybe CoinductionKit -> Definition -> TCM [HS.Decl]--- ignore irrelevant definitions-definition kit (Defn Forced _ _ _ _ _ _) = __IMPOSSIBLE__-definition kit (Defn NonStrict _ _ _ _ _ _) = __IMPOSSIBLE__-definition kit (Defn Irrelevant _ _ _ _ _ _) = return []-definition kit (Defn Relevant q ty _ _ compiled d) = do- checkTypeOfMain q ty- (infodecl q :) <$> case d of-- _ | Just (HsDefn ty hs) <- compiledHaskell compiled ->- return $ fbWithType ty (fakeExp hs)-- -- Special treatment of coinductive builtins.- Datatype{} | Just q == (nameOfInf <$> kit) -> do- let infT = unqhname "T" q- infV = unqhname "d" q- a = ihname "a" 0- b = ihname "a" 1- vars = [a, b]- return [ HS.TypeDecl dummy infT- (L.map HS.UnkindedVar vars)- (HS.TyVar b)- , HS.FunBind [HS.Match dummy infV- (L.map HS.PVar vars) Nothing- (HS.UnGuardedRhs HS.unit_con)- (HS.BDecls [])]- ]- Constructor{} | Just q == (nameOfSharp <$> kit) -> do- let sharp = unqhname "d" q- x = ihname "x" 0- return $- [ HS.TypeSig dummy [sharp] $ fakeType $- "forall a. a -> a"- , HS.FunBind [HS.Match dummy sharp- [HS.PVar x]- Nothing- (HS.UnGuardedRhs (HS.Var (HS.UnQual x)))- (HS.BDecls [])]- ]- Function{} | Just q == (nameOfFlat <$> kit) -> do- let flat = unqhname "d" q- x = ihname "x" 0- return $- [ HS.TypeSig dummy [flat] $ fakeType $- "forall a. () -> forall b. () -> b -> b"- , HS.FunBind [HS.Match dummy flat- [HS.PWildCard, HS.PWildCard, HS.PVar x]- Nothing- (HS.UnGuardedRhs (HS.Var (HS.UnQual x)))- (HS.BDecls [])]- ]-- Axiom{} -> return $ fb axiomErr- Function{ funClauses = cls } -> function cls- Primitive{ primClauses = Just cls } -> function cls- Primitive{ primClauses = Nothing, primName = s } -> fb <$> primBody s- Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, dataCons = cs }- | Just (HsType ty) <- compiledHaskell compiled -> do- ccs <- concat <$> mapM checkConstructorType cs- cov <- checkCover q ty np cs- return $ tvaldecl q (dataInduction d) 0 (np + ni) [] (Just __IMPOSSIBLE__) ++ ccs ++ cov- Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, dataCons = cs } -> do- (ars, cds) <- unzip <$> mapM condecl cs- return $ tvaldecl q (dataInduction d) (maximum (np:ars) - np) (np + ni) cds cl- Constructor{} -> return []- Record{ recClause = cl, recCon = c, recFields = flds } -> do- let noFields = genericLength flds- let ar = arity ty- cd <- snd <$> condecl c--- cd <- case c of--- Nothing -> return $ cdecl q noFields--- Just c -> snd <$> condecl c- return $ tvaldecl q Inductive noFields ar [cd] cl- where- function cls = mkwhere <$> mapM (clause q) (tag 0 cls)- tag _ [] = []- tag i [cl] = (i, True , cl): []- tag i (cl:cls) = (i, False, cl): tag (i + 1) cls- mkwhere (HS.FunBind [m0, HS.Match _ dn ps mt rhs (HS.BDecls [])] :- fbs@(_:_)) =- [HS.FunBind [m0, HS.Match dummy dn ps mt rhs (HS.BDecls fbs)]]- mkwhere fbs = fbs- fbWithType ty e =- [ HS.TypeSig dummy [unqhname "d" q] $ fakeType ty ] ++ fb e- fb e = [HS.FunBind [HS.Match dummy (unqhname "d" q) [] Nothing- (HS.UnGuardedRhs $ e) (HS.BDecls [])]]- axiomErr = rtmError $ "postulate evaluated: " ++ show q--checkConstructorType :: QName -> TCM [HS.Decl]-checkConstructorType q = do- Just (HsDefn ty hs) <- compiledHaskell . defCompiledRep <$> getConstInfo q- return [ HS.TypeSig dummy [unqhname "check" q] $ fakeType ty- , HS.FunBind [HS.Match dummy (unqhname "check" q) [] Nothing- (HS.UnGuardedRhs $ fakeExp hs) (HS.BDecls [])]- ]--checkCover :: QName -> HaskellType -> Nat -> [QName] -> TCM [HS.Decl]-checkCover q ty n cs = do- let tvs = [ "a" ++ show i | i <- [1..n] ]- makeClause c = do- (a, _) <- conArityAndPars c- Just (HsDefn _ hsc) <- compiledHaskell . defCompiledRep <$> getConstInfo c- let pat = HS.PApp (HS.UnQual $ HS.Ident hsc) $ genericReplicate a HS.PWildCard- return $ HS.Alt dummy pat (HS.UnGuardedAlt $ HS.Tuple []) (HS.BDecls [])- cs <- mapM makeClause cs- let rhs = case cs of- [] -> fakeExp "()" -- There is no empty case statement in Haskell- _ -> HS.Case (HS.Var $ HS.UnQual $ HS.Ident "x") cs-- return [ HS.TypeSig dummy [unqhname "cover" q] $ fakeType $ unwords (ty : tvs) ++ " -> ()"- , HS.FunBind [HS.Match dummy (unqhname "cover" q) [HS.PVar $ HS.Ident "x"]- Nothing (HS.UnGuardedRhs rhs) (HS.BDecls [])]- ]---- | Move somewhere else!-conArityAndPars :: QName -> TCM (Nat, Nat)-conArityAndPars q = do- def <- getConstInfo q- TelV tel _ <- telViewM $ defType def- let Constructor{ conPars = np } = theDef def- n = genericLength (telToList tel)- return (n - np, np)--clause :: QName -> (Nat, Bool, Clause) -> TCM HS.Decl-clause q (i, isLast, Clause{ clausePats = ps, clauseBody = b }) =- HS.FunBind . (: cont) <$> main where- main = match <$> argpatts ps (bvars b (0::Nat)) <*> clausebody b- cont | isLast && any isCon ps = [match (L.map HS.PVar cvs) failrhs]- | isLast = []- | otherwise = [match (L.map HS.PVar cvs) crhs]- cvs = L.map (ihname "v") [0 .. genericLength ps - 1]- crhs = hsCast$ L.foldl HS.App (hsVarUQ $ dsubname q (i + 1)) (L.map hsVarUQ cvs)- failrhs = rtmIncompleteMatch q -- Andreas, 2011-11-16 call to RTE instead of inlined error--- failrhs = rtmError $ "incomplete pattern matching: " ++ show q- match hps rhs = HS.Match dummy (dsubname q i) hps Nothing- (HS.UnGuardedRhs rhs) (HS.BDecls [])- bvars (Body _) _ = []- bvars (Bind (Abs _ b')) n = HS.PVar (ihname "v" n) : bvars b' (n + 1)- bvars (Bind (NoAbs _ b)) n = HS.PWildCard : bvars b n- bvars NoBody _ = repeat HS.PWildCard -- ?-- isCon (Arg _ _ ConP{}) = True- isCon _ = False---- argpatts aps xs = hps--- xs is alist of haskell *variables* in form of patterns (because of wildcard)-argpatts :: [Arg Pattern] -> [HS.Pat] -> TCM [HS.Pat]-argpatts ps0 bvs = evalStateT (mapM pat' ps0) bvs- where- pat (VarP _ ) = do v <- gets head; modify tail; return v- pat (DotP _ ) = pat (VarP dummy) -- WHY NOT: return HS.PWildCard -- SEE ABOVE- pat (LitP l ) = return $ HS.PLit $ hslit l- pat p@(ConP q _ ps) = do- -- Note that irr is applied once for every subpattern, so in the- -- worst case it is quadratic in the size of the pattern. I- -- suspect that this will not be a problem in practice, though.- irrefutable <- lift $ irr p- let tilde = if tildesEnabled && irrefutable- then HS.PParen . HS.PIrrPat- else id- (tilde . HS.PParen) <$>- (HS.PApp <$> lift (conhqn q) <*> mapM pat' ps)-- -- Andreas, 2010-09-29- -- do not match against irrelevant stuff- pat' (Arg _ Irrelevant _) = return $ HS.PWildCard- pat' (Arg _ _ p) = pat p-- tildesEnabled = False-- -- | Is the pattern irrefutable?- irr :: Pattern -> TCM Bool- irr (VarP {}) = return True- irr (DotP {}) = return True- irr (LitP {}) = return False- irr (ConP q _ ps) =- (&&) <$> singleConstructorType q- <*> (and <$> mapM irr' ps)-- -- | Irrelevant patterns are naturally irrefutable.- irr' (Arg _ Irrelevant _) = return $ True- irr' (Arg _ _ p) = irr p--clausebody :: ClauseBody -> TCM HS.Exp-clausebody b0 = runReaderT (go b0) 0 where- go (Body tm ) = hsCast <$> term tm- go (Bind (Abs _ b)) = local (1+) $ go b- go (Bind (NoAbs _ b)) = go b- go NoBody = return $ rtmError $ "Impossible Clause Body"---- | Extract Agda term to Haskell expression.--- Irrelevant arguments are extracted as @()@.--- Types are extracted as @()@.--- @DontCare@ outside of irrelevant arguments is extracted as @error@.-term :: Term -> ReaderT Nat TCM HS.Exp-term tm0 = case tm0 of- Var i as -> do n <- ask; apps (hsVarUQ $ ihname "v" (n - i - 1)) as- Lam _ at -> do n <- ask; HS.Lambda dummy [HS.PVar $ ihname "v" n] <$>- local (1+) (term $ absBody at)- Lit l -> lift $ literal l- Def q as -> (`apps` as) . HS.Var =<< lift (xhqn "d" q)- Con q as -> do- kit <- lift coinductionKit- if Just q == (nameOfSharp <$> kit)- then (`apps` as) . HS.Var =<< lift (xhqn "d" q)- else (`apps` as) . HS.Con =<< lift (conhqn q)- Level l -> term =<< lift (reallyUnLevelView l)- Pi _ _ -> return HS.unit_con- Sort _ -> return HS.unit_con- MetaV _ _ -> mazerror "hit MetaV"- DontCare _ -> return $ rtmError $ "hit DontCare"- where apps = foldM (\h a -> HS.App h <$> term' a)---- | Irrelevant arguments are replaced by Haskells' ().-term' :: Arg Term -> ReaderT Nat TCM HS.Exp-term' (Arg _ Irrelevant _) = return HS.unit_con-term' (Arg _ _ t) = term t--literal :: Literal -> TCM HS.Exp-literal l = case l of- LitInt _ _ -> do toN <- bltQual "NATURAL" mazIntegerToNat- return $ HS.Var toN `HS.App` typed "Integer"- LitFloat _ _ -> return $ typed "Double"- LitQName _ x -> litqname x- _ -> return $ l'- where l' = HS.Lit $ hslit l- typed = HS.ExpTypeSig dummy l' . HS.TyCon . rtmQual--hslit :: Literal -> HS.Literal-hslit l = case l of LitInt _ x -> HS.Int x- LitFloat _ x -> HS.Frac (toRational x)- LitString _ x -> HS.String x- LitChar _ x -> HS.Char x- LitQName _ x -> __IMPOSSIBLE__--litqname :: QName -> TCM HS.Exp-litqname x = return $- HS.Con (HS.Qual mazRTE $ HS.Ident "QName") `HS.App`- HS.Lit (HS.Int n) `HS.App`- HS.Lit (HS.Int m) `HS.App`- (rtmError "primQNameType: not implemented") `HS.App`- (rtmError "primQNameDefinition: not implemented")- where- NameId n m = nameId $ qnameName x--condecl :: QName -> TCM (Nat, HS.ConDecl)-condecl q = do- (ar, np) <- conArityAndPars q- return $ (ar + np, cdecl q ar)--cdecl :: QName -> Nat -> HS.ConDecl-cdecl q n = HS.ConDecl (unqhname "C" q)- [ HS.UnBangedTy $ HS.TyVar $ ihname "a" i | i <- [0 .. n - 1]]--tvaldecl :: QName- -> Induction- -- ^ Is the type inductive or coinductive?- -> Nat -> Nat -> [HS.ConDecl] -> Maybe Clause -> [HS.Decl]-tvaldecl q ind ntv npar cds cl =- HS.FunBind [HS.Match dummy vn pvs Nothing- (HS.UnGuardedRhs HS.unit_con) (HS.BDecls [])] :- maybe [HS.DataDecl dummy kind [] tn tvs- (L.map (HS.QualConDecl dummy [] []) cds) []]- (const []) cl- where- (tn, vn) = (unqhname "T" q, unqhname "d" q)- tvs = [ HS.UnkindedVar $ ihname "a" i | i <- [0 .. ntv - 1]]- pvs = [ HS.PVar $ ihname "a" i | i <- [0 .. npar - 1]]-- -- Inductive data types consisting of a single constructor with a- -- single argument are translated into newtypes.- kind = case (ind, cds) of- (Inductive, [HS.ConDecl _ [_]]) -> HS.NewType- (Inductive, [HS.RecDecl _ [_]]) -> HS.NewType- _ -> HS.DataType--infodecl :: QName -> HS.Decl-infodecl q = fakeD (unqhname "name" q) $ show (show q)------------------------------------------------------- Inserting unsafeCoerce-----------------------------------------------------hsCast :: HS.Exp -> HS.Exp-{--hsCast = addcast . go where- addcast [e@(HS.Var(HS.UnQual(HS.Ident(c:ns))))] | c == 'v' && all isDigit ns = e- addcast es = foldl HS.App mazCoerce es- -- this need to be extended if you generate other kinds of exps.- go (HS.App e1 e2 ) = go e1 ++ [hsCast e2]- go (HS.Lambda _ ps e) = [ HS.Lambda dummy ps (hsCast e) ]- go e = [e]--}--hsCast e = mazCoerce `HS.App` hsCast' e-hsCast' (HS.App e1 e2) = hsCast' e1 `HS.App` (hsCoerce $ hsCast' e2)-hsCast' (HS.Lambda _ ps e) = HS.Lambda dummy ps $ hsCast' e-hsCast' e = e---- No coercion for literal integers-hsCoerce e@(HS.ExpTypeSig _ (HS.Lit (HS.Int{})) _) = e-hsCoerce e = HS.App mazCoerce e-------------------------------------------------------- Writing out a haskell module-----------------------------------------------------writeModule :: HS.Module -> TCM ()-writeModule (HS.Module l m ps w ex imp ds) = do- -- Note that GHC assumes that sources use ASCII or UTF-8.- out <- outFile m- liftIO $ UTF8.writeFile out $ prettyPrint $- HS.Module l m (p : ps) w ex imp ds- where- p = HS.LanguagePragma dummy $ L.map HS.Ident $- [ "EmptyDataDecls"- , "ExistentialQuantification"- , "ScopedTypeVariables"- , "NoMonomorphismRestriction"- ]--rteModule :: HS.Module-rteModule = ok $ parse $ unlines- [ "module " ++ prettyPrint mazRTE ++ " where"- , "import Unsafe.Coerce"- , ""- , "-- Special version of coerce that plays well with rules."- , "{-# INLINE [1] mazCoerce #-}"- , "mazCoerce = Unsafe.Coerce.unsafeCoerce"- , "{-# RULES \"coerce-id\" forall (x :: a) . mazCoerce x = x #-}"- , ""- , "-- Builtin QNames, the third field is for the type."- , "data QName a b = QName { nameId, moduleId :: Integer, qnameType :: a, qnameDefinition :: b }"- , "instance Eq (QName a b) where"- , " QName a b _ _ == QName c d _ _ = (a, b) == (c, d)"- , ""- , "mazIncompleteMatch :: String -> a"- , "mazIncompleteMatch s = error (\"MAlonzo Runtime Error: incomplete pattern matching: \" ++ s)"- ]- where- parse = HS.parseWithMode- HS.defaultParseMode{HS.extensions = [HS.ExplicitForall]}-- ok (HS.ParseOk d) = d- ok HS.ParseFailed{} = __IMPOSSIBLE__---compileDir :: TCM FilePath-compileDir = do- mdir <- optCompileDir <$> commandLineOptions- case mdir of- Just dir -> return dir- Nothing -> __IMPOSSIBLE__--outFile' m = do- mdir <- compileDir- let (fdir, fn) = splitFileName $ repldot pathSeparator $- prettyPrint m- let dir = mdir </> fdir- fp = dir </> replaceExtension fn "hs"- liftIO $ createDirectoryIfMissing True dir- return (mdir, fp)- where- repldot c = L.map (\c' -> if c' == '.' then c else c')--outFile :: HS.ModuleName -> TCM FilePath-outFile m = snd <$> outFile' m--outFile_ :: TCM FilePath-outFile_ = outFile =<< curHsMod--callGHC :: Interface -> TCM ()-callGHC i = do- setInterface i- mdir <- compileDir- hsmod <- prettyPrint <$> curHsMod- MName agdaMod <- curMName- let outputName = case agdaMod of- [] -> __IMPOSSIBLE__- ms -> last ms- (mdir, fp) <- outFile' =<< curHsMod- opts <- optGhcFlags <$> commandLineOptions-- let overridableArgs =- [ "-O"- , "-o", mdir </> show outputName- ]- otherArgs =- [ "-i" ++ mdir- , "-main-is", hsmod- , fp- , "--make"- , "-fwarn-incomplete-patterns"- , "-fno-warn-overlapping-patterns"- , "-Werror"- ]- args = overridableArgs ++ opts ++ otherArgs- compiler = "ghc"-- -- Note: Some versions of GHC use stderr for progress reports. For- -- those versions of GHC we don't print any progress information- -- unless an error is encountered.-- reportSLn "" 1 $ "calling: " ++ L.intercalate " " (compiler : args)- (_, _, err, p) <-- liftIO $ createProcess (proc compiler args){ std_err = CreatePipe }-- errors <- liftIO $ case err of- Nothing -> __IMPOSSIBLE__- Just err -> do- -- The handle should be in text mode.- hSetBinaryMode err False- liftIO $ LocIO.hGetContents err-- exitcode <- liftIO $ do- -- Ensure that the output has been read before waiting for the- -- process.- E.evaluate (length errors)- waitForProcess p- case exitcode of- ExitFailure _ -> typeError (CompilationError errors)- _ -> return ()++module Agda.Compiler.MAlonzo.Compiler+ ( ghcBackend+ , ghcInvocationStrings+ )+ where++import Prelude hiding ( zip, zipWith )++import Control.DeepSeq+import Control.Monad.Except ( throwError )+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.Reader ( MonadReader(..), asks, ReaderT, runReaderT, withReaderT )+import Control.Monad.Trans ( lift )+import Control.Monad.Writer ( MonadWriter(..), WriterT, runWriterT )++import qualified Data.HashSet as HashSet+import qualified Data.List as List+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Text (Text)+import qualified Data.Text as Text+import Data.Monoid (Monoid, mempty, mappend)++import GHC.Generics (Generic)++import System.Directory (createDirectoryIfMissing)+import System.Environment (setEnv)+import System.FilePath hiding (normalise)+import System.IO (utf8)++import Agda.Compiler.CallCompiler+import Agda.Compiler.Common+import Agda.Compiler.MAlonzo.Coerce+import Agda.Compiler.MAlonzo.Misc+import Agda.Compiler.MAlonzo.Pretty+import Agda.Compiler.MAlonzo.Primitives+import Agda.Compiler.MAlonzo.HaskellTypes+import Agda.Compiler.MAlonzo.Pragmas+import Agda.Compiler.MAlonzo.Strict+import Agda.Compiler.ToTreeless+import Agda.Compiler.Treeless.Unused+import Agda.Compiler.Treeless.Erase+import Agda.Compiler.Backend++import Agda.Interaction.Options++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty (prettyShow, render)+import Agda.Syntax.Internal as I+import Agda.Syntax.Internal.Names (namesIn)+import qualified Agda.Syntax.Treeless as T+import Agda.Syntax.Literal+import Agda.Syntax.TopLevelModuleName++import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Primitive (getBuiltinName)+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Warnings++import Agda.Utils.FileName (isNewerThan)+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.Float+import qualified Agda.Utils.Haskell.Syntax as HS+import Agda.Utils.IO.Directory+import Agda.Utils.Lens+import Agda.Utils.List+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.ListInf as ListInf+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Singleton+import Agda.Utils.Tuple (second)+import qualified Agda.Utils.IO.UTF8 as UTF8+import Agda.Utils.Zip++import Agda.Setup ( getDataDir )++import Agda.Utils.Impossible++-- The backend callbacks --------------------------------------------------++ghcBackend :: Backend+ghcBackend = Backend ghcBackend'++ghcBackend' :: Backend' GHCFlags GHCEnv GHCModuleEnv GHCModule GHCDefinition+ghcBackend' = Backend'+ { backendName = "GHC"+ , backendVersion = Nothing+ , options = defaultGHCFlags+ , commandLineFlags = ghcCommandLineFlags+ , isEnabled = flagGhcCompile+ , preCompile = ghcPreCompile+ , postCompile = ghcPostCompile+ , preModule = ghcPreModule+ , postModule = ghcPostModule+ , compileDef = ghcCompileDef+ , scopeCheckingSuffices = False+ , mayEraseType = ghcMayEraseType+ , backendInteractTop = Nothing+ , backendInteractHole = Nothing+ }++--- Command-line flags ---++data GHCFlags = GHCFlags+ { flagGhcCompile :: Bool+ , flagGhcCallGhc :: Bool+ , flagGhcBin :: Maybe FilePath+ -- ^ Use the compiler at PATH instead of "ghc"+ , flagGhcFlags :: [String]+ , flagGhcStrictData :: Bool+ -- ^ Make inductive constructors strict?+ , flagGhcStrict :: Bool+ -- ^ Make functions strict?+ , flagGhcTrace :: Bool+ -- ^ Print function name upon entry using 'Debug.Trace.trace'?+ }+ deriving Generic++instance NFData GHCFlags++defaultGHCFlags :: GHCFlags+defaultGHCFlags = GHCFlags+ { flagGhcCompile = False+ , flagGhcCallGhc = True+ , flagGhcBin = Nothing+ , flagGhcFlags = []+ , flagGhcStrictData = False+ , flagGhcStrict = False+ , flagGhcTrace = False+ }++-- | The option to activate the GHC backend.+--+ghcInvocationFlag :: OptDescr (Flag GHCFlags)+ghcInvocationFlag =+ Option ['c'] ["compile", "ghc"] (NoArg enable)+ "compile program using the GHC backend"+ where+ enable o = pure o{ flagGhcCompile = True }++ghcCommandLineFlags :: [OptDescr (Flag GHCFlags)]+ghcCommandLineFlags =+ [ ghcInvocationFlag+ , Option [] ["ghc-dont-call-ghc"] (NoArg dontCallGHC)+ "don't call GHC, just write the GHC Haskell files."+ , Option [] ["ghc-flag"] (ReqArg ghcFlag "GHC-FLAG")+ "give the flag GHC-FLAG to GHC"+ , Option [] ["with-compiler"] (ReqArg withCompilerFlag "PATH")+ "use the compiler available at PATH"+ , Option [] ["ghc-strict-data"] (NoArg strictData)+ "make inductive constructors strict"+ , Option [] ["ghc-strict"] (NoArg strict)+ "make functions strict"+ , Option [] ["ghc-trace"] (NoArg trace)+ "instrument code to debug print trace of function calls"+ ]+ where+ dontCallGHC o = pure o{ flagGhcCallGhc = False }+ ghcFlag f o = pure o{ flagGhcFlags = flagGhcFlags o ++ [f] }+ strictData o = pure o{ flagGhcStrictData = True }+ strict o = pure o{ flagGhcStrictData = True+ , flagGhcStrict = True+ }+ trace o = pure o{ flagGhcTrace = True }++withCompilerFlag :: FilePath -> Flag GHCFlags+withCompilerFlag fp o = case flagGhcBin o of+ Nothing -> pure o { flagGhcBin = Just fp }+ Just{} -> throwError "only one compiler path allowed"++-- | Option strings to activate the GHC backend.+--+ghcInvocationStrings :: [String]+ghcInvocationStrings = optionStrings ghcInvocationFlag++-- | Get all flags that activate the given option.+--+optionStrings :: OptDescr a -> [String]+optionStrings (Option short long _ _) = map (\ c -> '-' : c : []) short ++ long++--- Context types ---++-- | Monads that can read @GHCOptions@+class Monad m => ReadGHCOpts m where+ askGhcOpts :: m GHCOptions++instance Monad m => ReadGHCOpts (ReaderT GHCOptions m) where+ askGhcOpts = ask++instance Monad m => ReadGHCOpts (ReaderT GHCEnv m) where+ askGhcOpts = withReaderT ghcEnvOpts askGhcOpts++instance Monad m => ReadGHCOpts (ReaderT GHCModuleEnv m) where+ askGhcOpts = withReaderT ghcModEnv askGhcOpts++data GHCModule = GHCModule+ { ghcModModuleEnv :: GHCModuleEnv+ , ghcModMainFuncs :: [MainFunctionDef]+ -- ^ The `main` function definition(s), if both the module is+ -- the @IsMain@ module (root/focused) and a suitable `main`+ -- function was defined.+ }++instance Monad m => ReadGHCOpts (ReaderT GHCModule m) where+ askGhcOpts = withReaderT ghcModModuleEnv askGhcOpts++instance Monad m => ReadGHCModuleEnv (ReaderT GHCModule m) where+ askGHCModuleEnv = withReaderT ghcModModuleEnv askGHCModuleEnv++data GHCDefinition = GHCDefinition+ { ghcDefUsesFloat :: UsesFloat+ , ghcDefDecls :: [HS.Decl]+ , ghcDefDefinition :: Definition+ , ghcDefMainDef :: Maybe MainFunctionDef+ , ghcDefImports :: Set TopLevelModuleName+ }++--- Top-level compilation ---++ghcPreCompile :: GHCFlags -> TCM GHCEnv+ghcPreCompile flags = do+ whenJustM cubicalOption \case+ CWithoutGlue -> pure ()+ CErased -> pure ()+ CFull -> typeError $ CubicalCompilationNotSupported CFull++ outDir <- compileDir+ let ghcOpts = GHCOptions+ { optGhcCallGhc = flagGhcCallGhc flags+ , optGhcBin = fromMaybe "ghc" (flagGhcBin flags)+ , optGhcFlags = flagGhcFlags flags+ , optGhcCompileDir = outDir+ , optGhcStrictData = flagGhcStrictData flags+ , optGhcStrict = flagGhcStrict flags+ , optGhcTrace = flagGhcTrace flags+ }++ mbool <- getBuiltinName builtinBool+ mtrue <- getBuiltinName builtinTrue+ mfalse <- getBuiltinName builtinFalse+ mlist <- getBuiltinName builtinList+ mnil <- getBuiltinName builtinNil+ mcons <- getBuiltinName builtinCons+ mmaybe <- getBuiltinName builtinMaybe+ mnothing <- getBuiltinName builtinNothing+ mjust <- getBuiltinName builtinJust+ mnat <- getBuiltinName builtinNat+ minteger <- getBuiltinName builtinInteger+ mword64 <- getBuiltinName builtinWord64+ minf <- getBuiltinName builtinInf+ msharp <- getBuiltinName builtinSharp+ mflat <- getBuiltinName builtinFlat+ minterval <- getBuiltinName builtinInterval+ mizero <- getBuiltinName builtinIZero+ mione <- getBuiltinName builtinIOne+ misone <- getBuiltinName builtinIsOne+ mitisone <- getBuiltinName builtinItIsOne+ misone1 <- getBuiltinName builtinIsOne1+ misone2 <- getBuiltinName builtinIsOne2+ misoneempty <- getBuiltinName builtinIsOneEmpty+ mpathp <- getBuiltinName builtinPathP+ msub <- getBuiltinName builtinSub+ msubin <- getBuiltinName builtinSubIn++ istcbuiltin <- do+ builtins <- mapM getBuiltinName+ [ builtinAgdaTCMReturn+ , builtinAgdaTCMBind+ , builtinAgdaTCMUnify+ , builtinAgdaTCMTypeError+ , builtinAgdaTCMInferType+ , builtinAgdaTCMCheckType+ , builtinAgdaTCMNormalise+ , builtinAgdaTCMReduce+ , builtinAgdaTCMCatchError+ , builtinAgdaTCMQuoteTerm+ , builtinAgdaTCMUnquoteTerm+ , builtinAgdaTCMQuoteOmegaTerm+ , builtinAgdaTCMGetContext+ , builtinAgdaTCMExtendContext+ , builtinAgdaTCMInContext+ , builtinAgdaTCMFreshName+ , builtinAgdaTCMDeclareDef+ , builtinAgdaTCMDeclarePostulate+ , builtinAgdaTCMDeclareData+ , builtinAgdaTCMDefineData+ , builtinAgdaTCMDefineFun+ , builtinAgdaTCMGetType+ , builtinAgdaTCMGetDefinition+ , builtinAgdaTCMBlock+ , builtinAgdaTCMCommit+ , builtinAgdaTCMIsMacro+ , builtinAgdaTCMWithNormalisation+ , builtinAgdaTCMWithReconstructed+ , builtinAgdaTCMWithExpandLast+ , builtinAgdaTCMWithReduceDefs+ , builtinAgdaTCMAskNormalisation+ , builtinAgdaTCMAskReconstructed+ , builtinAgdaTCMAskExpandLast+ , builtinAgdaTCMAskReduceDefs+ , builtinAgdaTCMFormatErrorParts+ , builtinAgdaTCMDebugPrint+ , builtinAgdaTCMNoConstraints+ , builtinAgdaTCMWorkOnTypes+ , builtinAgdaTCMRunSpeculative+ , builtinAgdaTCMExec+ , builtinAgdaTCMCheckFromString+ , builtinAgdaTCMGetInstances+ , builtinAgdaTCMSolveInstances+ , builtinAgdaTCMPragmaForeign+ , builtinAgdaTCMPragmaCompile+ , builtinAgdaBlocker+ , builtinAgdaBlockerAll+ , builtinAgdaBlockerAny+ , builtinAgdaBlockerMeta+ ]+ return $+ flip HashSet.member $+ HashSet.fromList $+ catMaybes builtins++ let defArity q = arity . defType <$> getConstInfo q+ listArity <- traverse defArity mlist+ maybeArity <- traverse defArity mmaybe++ return $ GHCEnv+ { ghcEnvOpts = ghcOpts+ , ghcEnvBool = mbool+ , ghcEnvTrue = mtrue+ , ghcEnvFalse = mfalse+ , ghcEnvMaybe = mmaybe+ , ghcEnvNothing = mnothing+ , ghcEnvJust = mjust+ , ghcEnvList = mlist+ , ghcEnvNil = mnil+ , ghcEnvCons = mcons+ , ghcEnvNat = mnat+ , ghcEnvInteger = minteger+ , ghcEnvWord64 = mword64+ , ghcEnvInf = minf+ , ghcEnvSharp = msharp+ , ghcEnvFlat = mflat+ , ghcEnvInterval = minterval+ , ghcEnvIZero = mizero+ , ghcEnvIOne = mione+ , ghcEnvIsOne = misone+ , ghcEnvItIsOne = mitisone+ , ghcEnvIsOne1 = misone1+ , ghcEnvIsOne2 = misone2+ , ghcEnvIsOneEmpty = misoneempty+ , ghcEnvPathP = mpathp+ , ghcEnvSub = msub+ , ghcEnvSubIn = msubin+ , ghcEnvIsTCBuiltin = istcbuiltin+ , ghcEnvListArity = listArity+ , ghcEnvMaybeArity = maybeArity+ }++ghcPostCompile ::+ GHCEnv -> IsMain -> Map TopLevelModuleName GHCModule -> TCM ()+ghcPostCompile _cenv _isMain mods = do+ -- FIXME: @curMName@ and @curIF@ are evil TCM state, but there does not appear to be+ --------- another way to retrieve the compilation root ("main" module or interaction focused).+ rootModuleName <- curMName+ -- Mario, 2024-10-16: cannot trigger this error:+ -- genericError $ "Module " <> prettyShow rootModuleName <> " was not compiled!"+ let rootModule = Map.findWithDefault __IMPOSSIBLE__ rootModuleName mods+ flip runReaderT rootModule $ do+ copyRTEModules+ callGHC++--- Module compilation ---++ghcPreModule+ :: GHCEnv+ -> IsMain -- ^ Are we looking at the main module?+ -> TopLevelModuleName+ -> Maybe FilePath -- ^ Path to the @.agdai@ file.+ -> TCM (Recompile GHCModuleEnv GHCModule)+ -- ^ Could we confirm the existence of a main function?+ghcPreModule cenv isMain m mifile =+ (do let check = ifM uptodate noComp yesComp+ cubical <- cubicalOption+ case cubical of+ -- Code that uses --cubical is not compiled.+ Just CFull -> noComp+ Just CErased -> check+ Just CWithoutGlue -> check+ Nothing -> check)+ `runReaderT` GHCModuleEnv cenv (HsModuleEnv m (isMain == IsMain))+ where+ uptodate = case mifile of+ Nothing -> pure False+ Just ifile -> liftIO =<< isNewerThan <$> curOutFile <*> pure ifile+ ifileDesc = fromMaybe "(memory)" mifile++ noComp = do+ reportSLn "compile.ghc" 2 .+ (++ " : no compilation is needed.") . prettyShow =<< curMName+ menv <- ask+ mainDefs <- ifM curIsMainModule+ (mainFunctionDefs <$> curIF)+ (pure [])+ return . Skip $ GHCModule menv mainDefs++ yesComp = do+ m <- prettyShow <$> curMName+ out <- curOutFile+ alwaysReportSLn "compile.ghc" 1 $ repl [m, ifileDesc, out] "Compiling <<0>> in <<1>> to <<2>>"+ asks Recompile++ghcPostModule+ :: GHCEnv+ -> GHCModuleEnv+ -> IsMain -- ^ Are we looking at the main module?+ -> TopLevelModuleName+ -> [GHCDefinition] -- ^ Compiled module content.+ -> TCM GHCModule+ghcPostModule cenv menv _isMain _moduleName ghcDefs = do+ builtinThings <- getsTC stBuiltinThings+ i <- curIF++ let+ -- Accumulate all of the modules, definitions, declarations, etc.+ (usedFloat, decls, defs, mainDefs, usedModules) = mconcat $ ghcDefs <&>+ \ (GHCDefinition useFloat' decls' def' md' imps') ->+ (useFloat', decls', [def'], maybeToList md', imps')++ -- Builtins used in the definitions.+ actuallyUsedBuiltins = usedBuiltins builtinThings defs+ useBuiltinFloat = any (`Set.member` actuallyUsedBuiltins) floatBuiltins+ useBuiltinChar = any (`Set.member` actuallyUsedBuiltins) charBuiltins++ -- Get content of FOREIGN pragmas.+ (headerPragmas, hsImps, code) = foreignHaskell i++ -- MAlonzo.* imports+ mazImports :: [HS.ImportDecl]+ mazImports = concat+ [ rteImports+ , mazRTEFloatImport (usedFloat <> UsesFloat useBuiltinFloat)+ , moduleImports usedModules+ ]++ -- Other imports, from FOREIGN pragmas and builtins.+ -- The needed Haskell modules might be duplicated by FOREIGN imports+ -- so we render them as strings and merge them with the latter,+ -- to remove duplicates.+ haskellImports :: [GHCImport]+ haskellImports = Set.toAscList $ Set.union hsImps $ Set.fromList $ map prettyPrint $ concat+ [ [ hsImportDebugTrace | optGhcTrace (ghcEnvOpts cenv) ]+ , [ HS.qualifiedImport $ HS.ModuleName "Data.Char" | useBuiltinChar ]+ , [ HS.qualifiedImport $ HS.ModuleName "Data.Text" ]+ ]++ flip runReaderT menv $ do+ hsModuleName <- curHsMod+ writeModule $ HS.Module+ hsModuleName+ (map HS.OtherPragma $ Set.toAscList headerPragmas)+ -- The MAlonzo.Code modules make proper import declarations in the AST.+ mazImports+ -- The other imports are already rendered to strings.+ (map fakeDecl (haskellImports ++ code) ++ decls)++ return $ GHCModule menv mainDefs++-- Imports ---------------------------------------------------------------++-- | Imports for the runtime environment (RTE).++rteImports :: [HS.ImportDecl]+rteImports = [unqualRTE, HS.qualifiedImport mazRTE]+ where+ unqualRTE :: HS.ImportDecl+ unqualRTE = HS.ImportDecl mazRTE False $ Just $ (False,) $ map (HS.IVar . HS.Ident) $+ [mazCoerceName, mazErasedName, mazAnyTypeName] +++ map treelessPrimName+ [T.PAdd, T.PSub, T.PMul, T.PQuot, T.PRem, T.PGeq, T.PLt, T.PEqI,+ T.PAdd64, T.PSub64, T.PMul64, T.PQuot64, T.PRem64, T.PLt64, T.PEq64,+ T.PITo64, T.P64ToI] -- Excludes T.PEqF, which is defined in MAlonzo.RTE.Float++-- | Imports of the compiled Agda modules, ordered alphabetically.++moduleImports :: Set TopLevelModuleName -> [HS.ImportDecl]+moduleImports = map (HS.qualifiedImport . mazMod') . List.sort . map prettyShow . Set.elems++-- | Should we import @MAlonzo.RTE.Float@?+newtype UsesFloat = UsesFloat Bool deriving (Eq, Show)++pattern YesFloat :: UsesFloat+pattern YesFloat = UsesFloat True++pattern NoFloat :: UsesFloat+pattern NoFloat = UsesFloat False++instance Semigroup UsesFloat where+ UsesFloat a <> UsesFloat b = UsesFloat (a || b)++instance Monoid UsesFloat where+ mempty = NoFloat+ mappend = (<>)++mazRTEFloatImport :: UsesFloat -> [HS.ImportDecl]+mazRTEFloatImport (UsesFloat b) = [ HS.qualifiedImport mazRTEFloat | b ]++hsImportDebugTrace :: HS.ImportDecl+hsImportDebugTrace = HS.ImportDecl+ { importModule = HS.ModuleName "Debug.Trace"+ , importQualified = True+ , importSpecs = Just (False, [ HS.IVar $ HS.Ident "trace" ])+ }++-- Compilation ------------------------------------------------------------++ghcCompileDef :: GHCEnv -> GHCModuleEnv -> IsMain -> Definition -> TCM GHCDefinition+ghcCompileDef _cenv menv _isMain def = do+ ((usesFloat, decls, mainFuncDef), (HsCompileState imps)) <-+ definition def `runHsCompileT` menv+ return $ GHCDefinition usesFloat decls def (checkedMainDef <$> mainFuncDef) imps++-- | We do not erase types that have a 'HsData' pragma.+-- This is to ensure a stable interface to third-party code.+ghcMayEraseType :: QName -> TCM Bool+ghcMayEraseType q = getHaskellPragma q <&> \case+ -- Andreas, 2019-05-09, issue #3732.+ -- We restrict this to 'HsData' since types like @Size@, @Level@+ -- should be erased although they have a 'HsType' binding to the+ -- Haskell unit type.+ Just HsData{} -> False+ _ -> True++--------------------------------------------------+-- Main compiling clauses+--------------------------------------------------++definition :: Definition -> HsCompileM (UsesFloat, [HS.Decl], Maybe CheckedMainFunctionDef)+-- ignore irrelevant definitions+definition Defn{defArgInfo = info, defName = q} | not $ usableModality info = do+ reportSDoc "compile.ghc.definition" 10 $+ ("Not compiling" <+> prettyTCM q) <> "."+ return (mempty, mempty, Nothing)+definition def@Defn{defName = q, defType = ty, theDef = d} = do+ reportSDoc "compile.ghc.definition" 10 $ vcat+ [ ("Compiling" <+> prettyTCM q) <> ":"+ , nest 2 $ pretty d+ ]+ pragma <- liftTCM $ getHaskellPragma q+ env <- askGHCEnv+ let is p = Just q == p env+ typeCheckedMainDef <- checkTypeOfMain def+ let mainDecl = maybeToList $ checkedMainDecl <$> typeCheckedMainDef+ let retDecls ds = return (mempty, ds)+ (uncurry (,,typeCheckedMainDef)) . second ((mainDecl ++) . infodecl q) <$>+ case d of++ _ | Just (HsDefn r hs) <- pragma -> setCurrentRange r $ do+ -- Make sure we have imports for all names mentioned in the type.+ hsty <- haskellType q+ mapM_ (`xqual` HS.Ident "_") (namesIn ty :: Set QName)++ -- Check that the function isn't INLINE (since that will make this+ -- definition pointless).+ inline <- (^. funInline) . theDef <$> getConstInfo q+ when inline $ warning $ UselessInline q++ retDecls $ fbWithType hsty (fakeExp hs)++ -- Compiling Bool+ Datatype{} | is ghcEnvBool -> do+ sequence_ [primTrue, primFalse] -- Just to get the proper error for missing TRUE/FALSE+ let d = dname q+ Just true <- getBuiltinName builtinTrue+ Just false <- getBuiltinName builtinFalse+ cs <- mapM (compiledcondecl Nothing) [false, true]+ retDecls $ [ compiledTypeSynonym q "Bool" 0+ , HS.FunBind [HS.Match d [] (HS.UnGuardedRhs HS.unit_con) emptyBinds] ] +++ cs++ -- Compiling List+ Datatype{ dataPars = np } | is ghcEnvList -> do+ sequence_ [primNil, primCons] -- Just to get the proper error for missing NIL/CONS+ whenJust pragma $ \ p -> setCurrentRange p $ warning PragmaCompileList+ let d = dname q+ t = unqhname TypeK q+ Just nil <- getBuiltinName builtinNil+ Just cons <- getBuiltinName builtinCons+ let vars f n = map (f . ihname A) [0 .. n - 1]+ cs <- mapM (compiledcondecl Nothing) [nil, cons]+ retDecls $ [ HS.TypeDecl t (vars HS.UnkindedVar (np - 1)) (HS.FakeType "[]")+ , HS.FunBind [HS.Match d (vars HS.PVar np) (HS.UnGuardedRhs HS.unit_con) emptyBinds] ] +++ cs++ -- Compiling Maybe+ Datatype{ dataPars = np } | is ghcEnvMaybe -> do+ sequence_ [primNothing, primJust] -- Just to get the proper error for missing NOTHING/JUST+ whenJust pragma $ \ p -> setCurrentRange p $ warning PragmaCompileMaybe+ let d = dname q+ t = unqhname TypeK q+ Just nothing <- getBuiltinName builtinNothing+ Just just <- getBuiltinName builtinJust+ let vars f n = map (f . ihname A) [0 .. n - 1]+ cs <- mapM (compiledcondecl Nothing) [nothing, just]+ retDecls $ [ HS.TypeDecl t (vars HS.UnkindedVar (np - 1)) (HS.FakeType "Maybe")+ , HS.FunBind [HS.Match d (vars HS.PVar np) (HS.UnGuardedRhs HS.unit_con) emptyBinds] ] +++ cs++ -- Compiling Inf+ _ | is ghcEnvInf -> do+ _ <- primSharp -- To get a proper error for missing SHARP.+ Just sharp <- getBuiltinName builtinSharp+ sharpC <- (compiledcondecl Nothing) sharp+ let d = dname q+ err = "No term-level implementation of the INFINITY builtin."+ retDecls $ [ compiledTypeSynonym q "MAlonzo.RTE.Infinity" 2+ , HS.FunBind [HS.Match d [HS.PVar (ihname A 0)]+ (HS.UnGuardedRhs (HS.FakeExp ("error " ++ show err)))+ emptyBinds]+ , sharpC+ ]++ -- The interval is compiled as the type of booleans: 0 is+ -- compiled as False and 1 as True.+ Axiom{} | is ghcEnvInterval -> do+ sequence_ [primIZero, primIOne]+ Just i0 <- getBuiltinName builtinIZero+ Just i1 <- getBuiltinName builtinIOne+ cs <- mapM (compiledcondecl (Just 0)) [i0, i1]+ retDecls $+ [ compiledTypeSynonym q "Bool" 0+ , HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs HS.unit_con) emptyBinds]+ ] +++ cs++ -- IsOne is compiled as the constant function to the unit type.+ -- Partial/PartialP are compiled as functions from the unit type+ -- to the underlying type.+ Axiom{} | is ghcEnvIsOne -> do+ retDecls $+ [ HS.TypeDecl (unqhname TypeK q) [HS.UnkindedVar (ihname A 0)]+ (HS.FakeType "()")+ , HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs HS.unit_con) emptyBinds]+ ]++ -- itIsOne.+ Axiom{} | is ghcEnvItIsOne -> do+ retDecls $+ [ HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs HS.unit_con) emptyBinds]+ ]++ -- IsOne1/IsOne2.+ Axiom{} | is ghcEnvIsOne1 || is ghcEnvIsOne2 -> do+ retDecls $+ [ HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs (HS.FakeExp "\\_ _ _ -> ()"))+ emptyBinds]+ ]++ -- isOneEmpty.+ Axiom{} | is ghcEnvIsOneEmpty -> do+ retDecls $+ [ HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs (HS.FakeExp "\\_ x _ -> x ()"))+ emptyBinds]+ ]++ -- PathP is compiled as a function from the interval (booleans)+ -- to the underlying type.+ Axiom{} | is ghcEnvPathP -> do+ sequence_ [primInterval]+ Just int <- getBuiltinName builtinInterval+ int <- xhqn TypeK int+ retDecls $+ [ HS.TypeDecl (unqhname TypeK q)+ [HS.UnkindedVar (ihname A i) | i <- [0..3]]+ (HS.TyFun (HS.TyCon int) mazAnyType)+ , HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs (HS.FakeExp "\\_ _ _ _ -> ()"))+ emptyBinds]+ ]++ -- Sub is compiled as the underlying type.+ Axiom{} | is ghcEnvSub -> do+ retDecls $+ [ HS.TypeDecl (unqhname TypeK q)+ [HS.UnkindedVar (ihname A i) | i <- [0..3]]+ (HS.TyVar (ihname A 1))+ , HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs (HS.FakeExp "\\_ _ _ _ -> ()"))+ emptyBinds]+ ]++ -- subIn.+ Axiom{} | is ghcEnvSubIn -> do+ retDecls $+ [ HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs (HS.FakeExp "\\_ _ _ x -> x"))+ emptyBinds]+ ]++ -- TC builtins are compiled to erased, which is a non-strict+ -- ∞-ary function.+ Axiom{} | ghcEnvIsTCBuiltin env q -> do+ retDecls $+ [ HS.FunBind+ [HS.Match (dname q) []+ (HS.UnGuardedRhs (HS.FakeExp mazErasedName))+ emptyBinds]+ ]++ DataOrRecSig{} -> __IMPOSSIBLE__++ Axiom{} -> do+ ar <- liftTCM $ typeArity ty+ retDecls $ [ compiledTypeSynonym q ty ar | Just (HsType r ty) <- [pragma] ] +++ fb axiomErr+ Primitive{ primName = s } -> (mempty,) . fb <$> (liftTCM . primBody) s++ PrimitiveSort{} -> retDecls []++ Function{} -> function pragma $ functionViaTreeless def q++ Datatype{ dataPars = np, dataIxs = ni, dataClause = cl+ } | Just hsdata@(HsData r ty hsCons) <- pragma ->+ setCurrentRange r $ do+ reportSDoc "compile.ghc.definition" 40 $ hsep $+ [ "Compiling data type with COMPILE pragma ...", pretty hsdata ]+ liftTCM $ computeErasedConstructorArgs q+ cs <- liftTCM $ getNotErasedConstructors q+ ccscov <- constructorCoverageCode q (np + ni) cs ty hsCons+ cds <- mapM (compiledcondecl Nothing) cs+ let result = concat $+ [ tvaldecl q Inductive (np + ni) [] (Just __IMPOSSIBLE__)+ , [ compiledTypeSynonym q ty np ]+ , cds+ , ccscov+ ]+ retDecls result+ Datatype{ dataPars = np, dataIxs = ni, dataClause = cl+ } -> do+ liftTCM $ computeErasedConstructorArgs q+ cs <- liftTCM $ getNotErasedConstructors q+ cds <- mapM (flip condecl Inductive) cs+ retDecls $ tvaldecl q Inductive (np + ni) cds cl+ Constructor{} -> retDecls []+ GeneralizableVar{} -> retDecls []+ Record{ recPars = np, recClause = cl, recConHead = con,+ recInduction = ind } ->+ let -- Non-recursive record types are treated as being+ -- inductive.+ inductionKind = fromMaybe Inductive ind+ in case pragma of+ Just (HsData r ty hsCons) -> setCurrentRange r $ do+ let cs = [conName con]+ liftTCM $ computeErasedConstructorArgs q+ ccscov <- constructorCoverageCode q np cs ty hsCons+ cds <- mapM (compiledcondecl Nothing) cs+ retDecls $+ tvaldecl q inductionKind np [] (Just __IMPOSSIBLE__) +++ [compiledTypeSynonym q ty np] ++ cds ++ ccscov+ _ -> do+ liftTCM $ computeErasedConstructorArgs q+ cd <- condecl (conName con) inductionKind+ retDecls $ tvaldecl q inductionKind (I.arity ty) [cd] cl+ AbstractDefn{} -> __IMPOSSIBLE__+ where+ function :: Maybe HaskellPragma -> HsCompileM (UsesFloat, [HS.Decl]) -> HsCompileM (UsesFloat, [HS.Decl])+ function mhe fun = do+ (imp, ccls) <- fun+ case mhe of+ Just (HsExport r name) -> do+ t <- setCurrentRange r $ haskellType q+ let tsig :: HS.Decl+ tsig = HS.TypeSig [HS.Ident name] t++ def :: HS.Decl+ def = HS.FunBind [HS.Match (HS.Ident name) [] (HS.UnGuardedRhs (hsCoerce $ hsVarUQ $ dname q)) emptyBinds]+ return (imp, [tsig,def] ++ ccls)+ _ -> return (imp, ccls)++ functionViaTreeless :: Definition -> QName -> HsCompileM (UsesFloat, [HS.Decl])+ functionViaTreeless def q = do+ strict <- optGhcStrict <$> askGhcOpts+ strictData <- optGhcStrictData <$> askGhcOpts+ let eval =+ if strict then EagerEvaluation+ else LazyEvaluation (if strictData then Strict else NonStrict)+ caseMaybeM (liftTCM $ toTreeless eval q) (pure mempty) $ \ treeless -> do++ used <- fromMaybe [] <$> getCompiledArgUse q+ let dostrip = ArgUnused `elem` used++ -- Compute the type approximation+ (argTypes0, resType) <- hsTelApproximation $ defType def+ let pars = case theDef def of+ Function{ funProjection = Right Projection{ projIndex = i } } | i > 0 -> i - 1+ _ -> 0+ argTypes = drop pars argTypes0+ argTypesS = filterUsed used argTypes++ (e, useFloat) <- if dostrip then closedTerm (stripUnusedArguments used treeless)+ else closedTerm treeless+ let (ps, b) = lamView e+ lamView e =+ case e of+ HS.Lambda ps b -> (ps, b)+ b -> ([], b)++ tydecl f ts t = HS.TypeSig [f] (foldr HS.TyFun t ts)+ funbind f ps b = HS.FunBind [HS.Match f ps (HS.UnGuardedRhs b) emptyBinds]+ tyfunbind f ts t ps b =+ let ts' = ts ++ (replicate (length ps - length ts) mazAnyType)+ in [tydecl f ts' t, funbind f ps b]++ -- The definition of the non-stripped function+ (ps0, _) <- lamView <$> closedTerm_ (foldr ($) T.TErased $ replicate (length used) T.TLam)+ let b0 = foldl HS.App (hsVarUQ $ duname q) [ hsVarUQ x | (~(HS.PVar x), ArgUsed) <- zip ps0 used ]+ ps0' = zipWith (\p u -> case u of+ ArgUsed -> p+ ArgUnused -> HS.PIrrPat p)+ ps0 used++ -- Trace entering functions when --ghc-trace is on.+ b <- ifM (pure (isProperProjection $ theDef def) `or2M` (not . optGhcTrace <$> askGhcOpts))+ {-then-} (pure b)+ {-else-} do+ x <- render <$> prettyTCM q+ pure $ HS.App (HS.App hsDebugTrace $ HS.Lit $ HS.String $ Text.pack x) b++ return (useFloat,+ if dostrip+ then tyfunbind (dname q) argTypes resType ps0' b0 +++ tyfunbind (duname q) argTypesS resType ps b+ else tyfunbind (dname q) argTypes resType ps b)++ fbWithType :: HS.Type -> HS.Exp -> [HS.Decl]+ fbWithType ty e =+ HS.TypeSig [dname q] ty : fb e++ fb :: HS.Exp -> [HS.Decl]+ fb e = [HS.FunBind [HS.Match (dname q) []+ (HS.UnGuardedRhs e) emptyBinds]]++ axiomErr :: HS.Exp+ axiomErr = rtmError $ Text.pack $ "postulate evaluated: " ++ prettyShow q++-- | The Haskell function 'Debug.Trace.trace'.+hsDebugTrace :: HS.Exp+hsDebugTrace = HS.Var $ HS.Qual (HS.ModuleName "Debug.Trace") $ HS.Ident "trace"++constructorCoverageCode :: QName -> Int -> [QName] -> HaskellType -> [HaskellCode] -> HsCompileM [HS.Decl]+constructorCoverageCode q np cs hsTy hsCons = do+ -- Check that number of constructors matches up.+ unless (length cs == length hsCons) $+ ghcBackendError $ ConstructorCountMismatch q cs hsCons+ ifM (liftTCM $ noCheckCover q) (return []) $ do+ ccs <- List.concat <$> zipWithM checkConstructorType cs hsCons+ cov <- liftTCM $ checkCover q hsTy np cs hsCons+ return $ ccs ++ cov++-- | Environment for naming of local variables.+-- Invariant: @reverse ccCxt ++ ccNameSupply@+data CCEnv = CCEnv+ { _ccNameSupply :: NameSupply -- ^ Supply of fresh names+ , _ccContext :: CCContext -- ^ Names currently in scope+ }++type NameSupply = [HS.Name]+type CCContext = [HS.Name]++ccNameSupply :: Lens' CCEnv NameSupply+ccNameSupply f e = (\ ns' -> e { _ccNameSupply = ns' }) <$> f (_ccNameSupply e)++ccContext :: Lens' CCEnv CCContext+ccContext f e = (\ cxt -> e { _ccContext = cxt }) <$> f (_ccContext e)++-- | Initial environment for expression generation.+initCCEnv :: CCEnv+initCCEnv = CCEnv+ { _ccNameSupply = map (ihname V) [0..] -- DON'T CHANGE THESE NAMES!+ , _ccContext = []+ }++-- | Term variables are de Bruijn indices.+lookupIndex :: Int -> CCContext -> HS.Name+lookupIndex i xs = fromMaybe __IMPOSSIBLE__ $ xs !!! i++-- | Constructor coverage monad transformer+type CCT m = ReaderT CCEnv (WriterT UsesFloat (HsCompileT m))++-- | Constructor coverage monad+type CC = CCT TCM++liftCC :: Monad m => HsCompileT m a -> CCT m a+liftCC = lift . lift++freshNames :: Monad m => Int -> ([HS.Name] -> CCT m a) -> CCT m a+freshNames n _ | n < 0 = __IMPOSSIBLE__+freshNames n cont = do+ (xs, rest) <- splitAt n <$> view ccNameSupply+ local (over ccNameSupply (const rest)) $ cont xs++-- | Introduce n variables into the context.+intros :: Monad m => Int -> ([HS.Name] -> CCT m a) -> CCT m a+intros n cont = freshNames n $ \xs ->+ local (over ccContext (reverse xs ++)) $ cont xs++checkConstructorType :: QName -> HaskellCode -> HsCompileM [HS.Decl]+checkConstructorType q hs = do+ ty <- haskellType q+ return [ HS.TypeSig [unqhname CheckK q] ty+ , HS.FunBind [HS.Match (unqhname CheckK q) []+ (HS.UnGuardedRhs $ fakeExp hs) emptyBinds]+ ]++checkCover :: HasConstInfo m => QName -> HaskellType -> Nat -> [QName] -> [HaskellCode] -> m [HS.Decl]+checkCover q ty n cs hsCons = do+ let tvs = [ "a" ++ show i | i <- [1..n] ]+ makeClause c hsc = do+ a <- erasedArity c+ let pat = HS.PApp (HS.UnQual $ HS.Ident hsc) $ replicate a HS.PWildCard+ return $ HS.Alt pat (HS.UnGuardedRhs $ HS.unit_con) emptyBinds++ cs <- zipWithM makeClause cs hsCons+ let rhs = HS.Case (HS.Var $ HS.UnQual $ HS.Ident "x") cs++ return [ HS.TypeSig [unqhname CoverK q] $ fakeType $ unwords (ty : tvs) ++ " -> ()"+ , HS.FunBind [HS.Match (unqhname CoverK q) [HS.PVar $ HS.Ident "x"]+ (HS.UnGuardedRhs rhs) emptyBinds]+ ]++closedTerm_ :: T.TTerm -> HsCompileM HS.Exp+closedTerm_ t = fst <$> closedTerm t++closedTerm :: T.TTerm -> HsCompileM (HS.Exp, UsesFloat)+closedTerm v = do+ v <- liftTCM $ addCoercions v+ runWriterT (term v `runReaderT` initCCEnv)++-- Translate case on bool to if+mkIf :: T.TTerm -> CC T.TTerm+mkIf t@(TCase e _ d [TACon c1 0 b1, TACon c2 0 b2]) | T.isUnreachable d = do+ env <- liftCC askGHCEnv+ let isTrue c = Just c == ghcEnvTrue env+ isFalse c = Just c == ghcEnvFalse env+ if | isTrue c1, isFalse c2 -> return $ T.tIfThenElse (TCoerce $ TVar e) b1 b2+ | isTrue c2, isFalse c1 -> return $ T.tIfThenElse (TCoerce $ TVar e) b2 b1+ | otherwise -> return t+mkIf t = return t++-- | Extract Agda term to Haskell expression.+-- Erased arguments are extracted as @()@.+-- Types are extracted as @()@.+term :: T.TTerm -> CC HS.Exp+term tm0 = mkIf tm0 >>= \ tm0 -> do+ let ((hasCoerce, t), ts) = coerceAppView tm0+ -- let (t0, ts) = tAppView tm0+ -- let (hasCoerce, t) = coerceView t0+ let coe = applyWhen hasCoerce hsCoerce+ case (t, ts) of+ (T.TPrim T.PIf, [c, x, y]) -> coe <$> do HS.If <$> term c <*> term x <*> term y++ (T.TDef f, ts) -> do+ used <- liftCC $ fromMaybe [] <$> getCompiledArgUse f+ -- #2248: no unused argument pruning for COMPILE'd functions+ isCompiled <- liftTCM $ isJust <$> getHaskellPragma f+ let given = length ts+ needed = length used+ missing = drop given used+ if not isCompiled && ArgUnused `elem` used+ then if ArgUnused `elem` missing then term (etaExpand (needed - given) tm0) else do+ f <- liftCC $ HS.Var <$> xhqn (FunK NoUnused) f+ -- use stripped function+ -- Andreas, 2019-11-07, issue #4169.+ -- Insert coercion unconditionally as erasure of arguments+ -- that are matched upon might remove the unfolding of codomain types.+ -- (Hard to explain, see test/Compiler/simple/Issue4169.)+ hsCoerce f `apps` filterUsed used ts+ else do+ f <- liftCC $ HS.Var <$> xhqn (FunK PossiblyUnused) f+ -- use original (non-stripped) function+ coe f `apps` ts++ (T.TCon c, ts) -> do+ erased <- liftCC $ getErasedConArgs c+ let missing = drop (length ts) erased+ notErased = not+ if all notErased missing+ then do+ f <- liftCC $ HS.Con <$> conhqn c+ hsCoerce f `apps` [ t | (t, False) <- zip ts erased ]+ else do+ let n = length missing+ unless (n >= 1) __IMPOSSIBLE__ -- We will add at least on TLam, not getting a busy loop here.+ term $ etaExpand (length missing) tm0++ -- Other kind of application: fall back to apps.+ (t, ts) -> noApplication t >>= \ t' -> coe t' `apps` ts+ where+ apps = foldM (\ h a -> HS.App h <$> term a)+ etaExpand n t = mkTLam n $ raise n t `T.mkTApp` map T.TVar (downFrom n)++-- | Translate a non-application, non-coercion, non-constructor, non-definition term.+noApplication :: T.TTerm -> CC HS.Exp+noApplication = \case+ T.TApp{} -> __IMPOSSIBLE__+ T.TCoerce{} -> __IMPOSSIBLE__+ T.TCon{} -> __IMPOSSIBLE__+ T.TDef{} -> __IMPOSSIBLE__++ T.TVar i -> hsVarUQ . lookupIndex i <$> view ccContext+ T.TLam t -> intros 1 $ \ [x] -> hsLambda [HS.PVar x] <$> term t++ T.TLet s t1 t2 -> do+ t1' <- term t1+ s' <- case s of+ T.Strict -> return HS.Strict+ T.NonStrict -> return HS.Lazy+ intros 1 $ \[x] -> do+ hsLet s' x t1' . hsCoerce <$> term t2++ T.TCase sc ct def alts -> do+ sc' <- term $ T.TVar sc+ alts' <- traverse (alt sc) alts+ def' <- term def+ let defAlt = HS.Alt HS.PWildCard (HS.UnGuardedRhs def') emptyBinds+ return $ HS.Case (hsCoerce sc') (alts' ++ [defAlt])++ T.TLit l -> literal l+ T.TPrim p -> return $ compilePrim p+ T.TUnit -> return $ HS.unit_con+ T.TSort -> return $ HS.unit_con+ T.TErased -> return $ hsVarUQ $ HS.Ident mazErasedName+ T.TError e -> return $ case e of+ T.TUnreachable -> rtmUnreachableError+ T.TMeta s -> rtmHole s++hsCoerce :: HS.Exp -> HS.Exp+hsCoerce t = HS.App mazCoerce t++compilePrim :: T.TPrim -> HS.Exp+compilePrim s = HS.Var $ hsName $ treelessPrimName s++alt :: Int -> T.TAlt -> CC HS.Alt+alt sc a = do+ case a of+ T.TACon {T.aCon = c} -> do+ intros (T.aArity a) $ \ xs -> do+ erased <- liftCC $ getErasedConArgs c+ env <- liftCC askGHCEnv+ hConNm <-+ if | Just c == ghcEnvNil env ->+ return $ HS.UnQual $ HS.Ident "[]"+ | Just c == ghcEnvCons env ->+ return $ HS.UnQual $ HS.Symbol ":"+ | otherwise -> liftCC $ conhqn c+ mkAlt (HS.PApp hConNm $ [HS.PVar x | (x, False) <- zip xs erased])+ T.TAGuard g b -> do+ g <- term g+ b <- term b+ return $ HS.Alt HS.PWildCard+ (HS.GuardedRhss [HS.GuardedRhs [HS.Qualifier g] b])+ emptyBinds+ T.TALit { T.aLit = LitQName q } -> mkAlt (litqnamepat q)+ T.TALit { T.aLit = LitMeta _ m } -> mkAlt (litmetapat m)+ T.TALit { T.aLit = l@LitFloat{}, T.aBody = b } -> do+ tell YesFloat+ l <- literal l+ mkGuarded (treelessPrimName T.PEqF) l b+ T.TALit { T.aLit = LitString s , T.aBody = b } -> mkGuarded "(==)" (litString s) b+ T.TALit {} -> mkAlt (HS.PLit $ hslit $ T.aLit a)+ where+ mkGuarded eq lit b = do+ b <- term b+ let varName = HS.Ident "l" -- only used locally in the guard+ pv = HS.PVar varName+ v = hsVarUQ varName+ guard =+ HS.Var (HS.UnQual (HS.Ident eq)) `HS.App`+ v `HS.App` lit+ return $ HS.Alt pv+ (HS.GuardedRhss [HS.GuardedRhs [HS.Qualifier guard] b])+ emptyBinds++ mkAlt :: HS.Pat -> CC HS.Alt+ mkAlt pat = do+ body' <- term $ T.aBody a+ let body'' = case body' of+ HS.Lambda{} -> hsCoerce body'+ _ -> body'+ return $ HS.Alt pat (HS.UnGuardedRhs body'') emptyBinds++literal :: forall m. Monad m => Literal -> CCT m HS.Exp+literal l = case l of+ LitNat _ -> return $ typed "Integer"+ LitWord64 _ -> return $ typed "MAlonzo.RTE.Word64"+ LitFloat x -> floatExp x "Double"+ LitQName x -> return $ litqname x+ LitString s -> return $ litString s+ LitMeta _ m ->+ return $ HS.FakeExp "(,)" `HS.App`+ hsTypedInt (metaId m) `HS.App`+ (hsTypedInt (moduleNameHash $ metaModule m))+ _ -> return $ l'+ where+ l' = HS.Lit $ hslit l+ typed = HS.ExpTypeSig l' . HS.TyCon . rtmQual++ -- ASR (2016-09-14): See Issue #2169.+ -- Ulf, 2016-09-28: and #2218.+ floatExp :: Double -> String -> CCT m HS.Exp+ floatExp x s+ | isPosInf x = rte "positiveInfinity"+ | isNegInf x = rte "negativeInfinity"+ | isNegZero x = rte "negativeZero"+ | isNaN x = rte "nan"+ | otherwise = return $ typed s+ where+ rte s = do tell YesFloat; return $ HS.Var $ HS.Qual mazRTEFloat $ HS.Ident s++hslit :: Literal -> HS.Literal+hslit = \case+ LitNat x -> HS.Int x+ LitWord64 x -> HS.Int (fromIntegral x)+ LitFloat x -> HS.Frac (toRational x)+ LitChar x -> HS.Char x+ LitQName x -> __IMPOSSIBLE__+ LitString _ -> __IMPOSSIBLE__+ LitMeta{} -> __IMPOSSIBLE__++litString :: Text -> HS.Exp+litString s = HS.Ann (HS.Lit (HS.String s))+ (HS.TyCon (HS.Qual (HS.ModuleName "Data.Text") (HS.Ident "Text")))++litqname :: QName -> HS.Exp+litqname x =+ rteCon "QName" `apps`+ [ hsTypedInt n+ , hsTypedInt m+ , HS.Lit $ HS.String $ Text.pack $ prettyShow x+ , rteCon "Fixity" `apps`+ [ litAssoc (fixityAssoc fx)+ , litPrec (fixityLevel fx)+ ]+ ]+ where+ apps = foldl HS.App+ rteCon name = HS.Con $ HS.Qual mazRTE $ HS.Ident name+ NameId n (ModuleNameHash m) = nameId x+ fx = theFixity $ nameFixity $ qnameName x++ litAssoc NonAssoc = rteCon "NonAssoc"+ litAssoc LeftAssoc = rteCon "LeftAssoc"+ litAssoc RightAssoc = rteCon "RightAssoc"++ litPrec Unrelated = rteCon "Unrelated"+ litPrec (Related l) = rteCon "Related" `HS.App` hsTypedDouble l++litqnamepat :: QName -> HS.Pat+litqnamepat x =+ HS.PApp (HS.Qual mazRTE $ HS.Ident "QName")+ [ HS.PLit (HS.Int $ fromIntegral n)+ , HS.PLit (HS.Int $ fromIntegral m)+ , HS.PWildCard, HS.PWildCard ]+ where+ NameId n (ModuleNameHash m) = nameId x++litmetapat :: MetaId -> HS.Pat+litmetapat (MetaId m h) =+ HS.PApp (hsName "(,)")+ [ HS.PLit (HS.Int $ fromIntegral m)+ , HS.PLit (HS.Int $ fromIntegral $ moduleNameHash h) ]++condecl :: QName -> Induction -> HsCompileM HS.ConDecl+condecl q _ind = do+ opts <- askGhcOpts+ def <- getConstInfo q+ let Constructor{ conPars = np, conSrcCon, conErased = erased } = theDef def+ (argTypes0, _) <- hsTelApproximation (defType def)+ let strict = if conInductive conSrcCon == Inductive &&+ optGhcStrictData opts+ then HS.Strict+ else HS.Lazy+ argTypes = [ (Just strict, t)+ | (t, False) <- zip (drop np argTypes0)+ (ListInf.pad (fromMaybe [] erased) False)+ ]+ return $ HS.ConDecl (unqhname ConK q) argTypes++compiledcondecl+ :: Maybe Nat -- ^ The constructor's arity (after erasure).+ -> QName -> HsCompileM HS.Decl+compiledcondecl mar q = do+ ar <- case mar of+ Nothing -> liftTCM $ erasedArity q+ Just ar -> return ar+ hsCon <- fromMaybe __IMPOSSIBLE__ <$> getHaskellConstructor q+ let patVars = map (HS.PVar . ihname A) [0 .. ar - 1]+ return $ HS.PatSyn (HS.PApp (HS.UnQual $ unqhname ConK q) patVars)+ (HS.PApp (hsName hsCon) patVars)++compiledTypeSynonym :: QName -> String -> Nat -> HS.Decl+compiledTypeSynonym q hsT arity =+ HS.TypeDecl (unqhname TypeK q) (map HS.UnkindedVar vs)+ (foldl HS.TyApp (HS.FakeType hsT) $ map HS.TyVar vs)+ where+ vs = [ ihname A i | i <- [0 .. arity - 1]]++-- | Produce Haskell code for a data type declaration.+tvaldecl ::+ QName+ -- ^ Name of the data/record type.+ -> Induction+ -- ^ Is the type inductive or coinductive?+ -> Nat+ -- ^ Number of parameters.+ -> [HS.ConDecl]+ -- ^ Constructors.+ -> Maybe a+ -- ^ The definition of this type if it is a copy created by a+ -- module application (see 'defCopyClause'); such a type is a mere+ -- alias, so no data declaration is emitted for it.+ -> [HS.Decl]+tvaldecl q ind npar cds body =+ HS.FunBind [HS.Match vn pvs (HS.UnGuardedRhs HS.unit_con) emptyBinds] :+ maybe [HS.DataDecl kind tn [] cds' []]+ (const []) body+ where+ (tn, vn) = (unqhname TypeK q, dname q)+ pvs = [ HS.PVar $ ihname A i | i <- [0 .. npar - 1]]++ -- Inductive data types consisting of a single constructor with a+ -- single argument are translated into newtypes.+ (kind, cds') = case (ind, cds) of+ (Inductive, [HS.ConDecl c [(_, t)]]) ->+ (HS.NewType, [HS.ConDecl c [(Nothing, t)]])+ -- The strictness annotations are removed for newtype+ -- constructors.+ _ -> (HS.DataType, cds)++infodecl :: QName -> [HS.Decl] -> [HS.Decl]+infodecl _ [] = []+infodecl q ds = HS.Comment (prettyShow q) : ds++--------------------------------------------------+-- Writing out a haskell module+--------------------------------------------------++type MonadGHCIO m = (MonadIO m, ReadGHCOpts m)++copyRTEModules :: MonadGHCIO m => m ()+copyRTEModules = do+ dataDir <- liftIO getDataDir+ let srcDir = dataDir </> "MAlonzo" </> "src"+ dstDir <- optGhcCompileDir <$> askGhcOpts+ liftIO $ copyDirContent srcDir dstDir++writeModule :: MonadGHCIO m => HS.Module -> m ()+writeModule (HS.Module m ps imp ds) = do+ -- Note that GHC assumes that sources use ASCII or UTF-8.+ out <- snd <$> outFileAndDir m+ strict <- optGhcStrict <$> askGhcOpts+ let languagePragmas =+ List.map (HS.LanguagePragma . singleton . HS.Ident) $+ List.sort $+ [ "QualifiedDo" | strict ] +++ -- If --ghc-strict is used, then the language extension+ -- QualifiedDo is activated. At the time of writing no+ -- code is generated that depends on this extension+ -- (except for the pragmas), but --ghc-strict is broken+ -- with at least some versions of GHC prior to version 9,+ -- and QualifiedDo was introduced with GHC 9.+ [ "BangPatterns"+ , "EmptyDataDecls"+ , "EmptyCase"+ , "ExistentialQuantification"+ , "ScopedTypeVariables"+ , "NoMonomorphismRestriction"+ , "RankNTypes"+ , "PatternSynonyms"+ , "OverloadedStrings"+ ]+ let ghcOptions =+ List.map HS.OtherPragma+ [ "" -- to separate from LANGUAGE pragmas+ , "{-# OPTIONS_GHC -Wno-overlapping-patterns #-}"+ -- Andreas, 2022-01-26, issue #5758:+ -- Place this in generated file rather than+ -- passing it only when calling GHC from within Agda.+ -- This will silence the warning for the Agda-generated .hs+ -- files while it can be on for other .hs files in the same+ -- project. (E.g., when using cabal/stack to compile.)+ ]+ liftIO $ UTF8.writeFile out $ (++ "\n") $ prettyPrint $+ -- TODO: It might make sense to skip bang patterns for the unused+ -- arguments of the "non-stripped" functions.+ applyWhen strict makeStrict $+ HS.Module m (concat [languagePragmas, ghcOptions, ps]) imp ds++outFileAndDir :: MonadGHCIO m => HS.ModuleName -> m (FilePath, FilePath)+outFileAndDir m = do+ mdir <- optGhcCompileDir <$> askGhcOpts+ let (fdir, fn) = splitFileName $ repldot pathSeparator $+ prettyPrint m+ let dir = mdir </> fdir+ fp = dir </> replaceExtension fn "hs"+ liftIO $ createDirectoryIfMissing True dir+ return (mdir, fp)+ where+ repldot c = List.map $ \ c' -> if c' == '.' then c else c'++curOutFileAndDir :: (MonadGHCIO m, ReadGHCModuleEnv m) => m (FilePath, FilePath)+curOutFileAndDir = outFileAndDir =<< curHsMod++curOutFile :: (MonadGHCIO m, ReadGHCModuleEnv m) => m FilePath+curOutFile = snd <$> curOutFileAndDir++callGHC :: ReaderT GHCModule TCM ()+callGHC = do+ opts <- askGhcOpts+ agdaOpts <- lift commandLineOptions+ hsmod <- prettyPrint <$> curHsMod+ agdaMod <- curAgdaMod+ let outputName = Text.unpack $ List1.last $ moduleNameParts agdaMod+ (mdir, fp) <- curOutFileAndDir+ let ghcopts = optGhcFlags opts++ modIsMain <- curIsMainModule+ modHasMainFunc <- asks (not . null . ghcModMainFuncs)+ let isMain = modIsMain && modHasMainFunc -- both need to be IsMain++ -- Warn if no main function and not --no-main+ when (modIsMain /= isMain) $ warning $ NoMain agdaMod++ let overridableArgs =+ [ "-O"] +++ (if isMain then ["-o", mdir </> outputName] else []) +++ [ "-Werror"]+ otherArgs =+ [ "-i" ++ mdir] +++ (if isMain then ["-main-is", hsmod] else []) +++ [ fp+ , "--make"+ , "-fwarn-incomplete-patterns"+ ]+ args = overridableArgs ++ ghcopts ++ otherArgs++ let ghcBin = optGhcBin opts++ -- Make GHC use UTF-8 when writing to stdout and stderr.+ liftIO $ setEnv "GHC_CHARENC" "UTF-8"+ -- Note: Some versions of GHC use stderr for progress reports. For+ -- those versions of GHC we don't print any progress information+ -- unless an error is encountered.+ let doCall = optGhcCallGhc opts+ cwd = if optGHCiInteraction agdaOpts ||+ optJSONInteraction agdaOpts+ then Just mdir+ else Nothing+ liftTCM $ callCompiler doCall ghcBin args cwd (Just utf8)
@@ -1,10 +0,0 @@-module Agda.Compiler.MAlonzo.Compiler where--import Control.Monad.Reader (ReaderT)-import qualified Language.Haskell.Exts.Syntax as HS--import Agda.Syntax.Common (Nat)-import Agda.Syntax.Internal (Term)-import Agda.TypeChecking.Monad (TCM)--term :: Term -> ReaderT Nat TCM HS.Exp
@@ -1,31 +1,19 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ ------------------------------------------------------------------------ -- Module name encoding ------------------------------------------------------------------------ module Agda.Compiler.MAlonzo.Encode ( encodeModuleName- , tests ) where import Data.Char-import Data.Function-import Data.List-import qualified Language.Haskell.Exts.Syntax as HS-import Test.QuickCheck+import qualified Data.List as List+import qualified Agda.Utils.Haskell.Syntax as HS import Agda.Compiler.MAlonzo.Misc -import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers---- | Can the character be used in a Haskell module name part--- (@conid@)? This function is more restrictive than what the Haskell--- report allows.--isModChar :: Char -> Bool-isModChar c =- isLower c || c == '_' || isUpper c || isDigit c || c == '\''- -- | Haskell module names have to satisfy the Haskell (including the -- hierarchical module namespace extension) lexical syntax: --@@ -39,86 +27,43 @@ -- @.@s may be adjacent. encodeModuleName :: HS.ModuleName -> HS.ModuleName-encodeModuleName (HS.ModuleName s) = HS.ModuleName $ case splitUp s of- ps | mazstr' `isPrefixOf` ps ->- concat (mazstr' ++ map encNamePart (drop (length mazstr') ps))- _ -> s+encodeModuleName (HS.ModuleName s) = HS.ModuleName $ case List.stripPrefix mazstr s of+ Just s' -> mazstr ++ foldr encNamePart "" (splitUp' s')+ Nothing -> s where -- splitUp ".apa.bepa." == [".","apa",".","bepa","."]- splitUp = groupBy ((&&) `on` (/= '.'))+ -- splitUp = groupBy ((&&) `on` (/= '.')) - mazstr' = splitUp mazstr+ -- Since comparison against "." is wasteful, and modules name components are nonempty,+ -- we can use "" as the separator.+ -- Since modules name components are nonempty,+ -- this is more efficient than adding a Maybe wrapper:+ -- We are effectively using ``String = Maybe NEString''.+ --+ -- splitUp' ".apa.bepa." == ["","apa","","bepa",""]+ splitUp' :: String -> [String]+ splitUp' = h+ where+ h [] = []+ h (c : cs) = case c of+ '.' -> "" : h cs+ _ -> g (c :) cs+ g acc [] = [acc []]+ g acc (c : cs) = case c of+ '.' -> acc [] : "" : h cs+ _ -> g (acc . (c :)) cs - encNamePart "." = "."- encNamePart s = ensureFirstCharLarge s ++ concatMap enc s+ encNamePart "" r = '.' : r+ encNamePart s r = ensureFirstCharLarge s $ foldr enc r s - ensureFirstCharLarge s = case s of- c : cs | isUpper c && c /= largeChar -> ""- _ -> [largeChar]+ ensureFirstCharLarge s r = case s of+ c : cs | isUpper c && c /= largeChar -> r+ _ -> largeChar : r largeChar = 'Q' escapeChar = 'Z' isOK c = c /= escapeChar && isModChar c - enc c | isOK c = [c]- | otherwise = [escapeChar] ++ show (fromEnum c) ++ [escapeChar]---- Note: This injectivity test is quite weak. A better, dedicated--- generator could strengthen it.--prop_encodeModuleName_injective (M s1) (M s2) =- if encodeModuleName (HS.ModuleName s1) ==- encodeModuleName (HS.ModuleName s2) then- s1 == s2- else- True--prop_encodeModuleName_OK (M s') =- s ~= unM (encodeModuleName (HS.ModuleName s))- where- s = mazstr ++ "." ++ s'-- "" ~= "" = True- ('.' : s) ~= ('.' : s') = s ~= s'- s ~= (c : s') = isUpper c && all isModChar s1' &&- dropWhile (/= '.') s ~= s2'- where (s1', s2') = span (/= '.') s'- _ ~= _ = False-- unM (HS.ModuleName s) = s--prop_encodeModuleName_preserved (M m) =- shouldBePreserved m ==>- encodeModuleName (HS.ModuleName m) == HS.ModuleName m- where- shouldBePreserved m =- not (m == mazstr || (mazstr ++ ".") `isPrefixOf` m)---- | Agda module names. Used to test 'encodeModuleName'.--newtype M = M String deriving (Show)--instance Arbitrary M where- arbitrary = do- ms <- choose (0, 2)- m <- vectorOf ms namePart- return $ M (intercalate "." m)- where- namePart =- oneof [ return mazstr- , do cs <- choose (1, 2)- vectorOf cs (elements "a_AQZ0'-∀")- ]----------------------------------------------------------------------------- All tests---- | All the properties.--tests :: IO Bool-tests = runTests "Agda.Compiler.MAlonzo.Encode"- [ quickCheck' prop_encodeModuleName_injective- , quickCheck' prop_encodeModuleName_OK- , quickCheck' prop_encodeModuleName_preserved- ]+ enc c r | isOK c = c : r+ | otherwise = escapeChar : shows (fromEnum c) (escapeChar : r)
@@ -0,0 +1,252 @@++-- | Translating Agda types to Haskell types. Used to ensure that imported+-- Haskell functions have the right type.++module Agda.Compiler.MAlonzo.HaskellTypes+ ( haskellType+ , hsTelApproximation, hsTelApproximation'+ ) where++import Control.Monad ( zipWithM )+import Control.Monad.Except ( ExceptT(ExceptT), runExceptT, mapExceptT, catchError, throwError )+import Control.Monad.Trans ( lift )++import Data.Maybe (fromMaybe)+import Data.List (intercalate)++import Agda.Syntax.Position+import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Free+import Agda.TypeChecking.Telescope++import Agda.Compiler.MAlonzo.Pragmas+import Agda.Compiler.MAlonzo.Misc+import Agda.Compiler.MAlonzo.Pretty () --instance only++import qualified Agda.Utils.Haskell.Syntax as HS+import Agda.Utils.List+import Agda.Utils.ListInf ( pattern (:<) )+import Agda.Utils.ListInf qualified as ListInf+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty (prettyShow)++import Agda.Utils.Impossible++hsQCon :: String -> String -> HS.Type+hsQCon m f = HS.TyCon $ HS.Qual (HS.ModuleName m) (HS.Ident f)++hsCon :: String -> HS.Type+hsCon = HS.TyCon . HS.UnQual . HS.Ident++hsUnit :: HS.Type+hsUnit = hsCon "()"++hsVar :: HS.Name -> HS.Type+hsVar = HS.TyVar++hsApp :: HS.Type -> [HS.Type] -> HS.Type+hsApp d ds = foldl HS.TyApp d ds++hsForall :: HS.Name -> HS.Type -> HS.Type+hsForall x = HS.TyForall [HS.UnkindedVar x]++-- Issue #5207: From ghc-9.0 we have to be careful with nested foralls.+hsFun :: HS.Type -> HS.Type -> HS.Type+hsFun a (HS.TyForall vs b) = HS.TyForall vs $ hsFun a b+hsFun a b = HS.TyFun a b++type ToHs = ExceptT WhyNotAHaskellType HsCompileM++runToHs :: Term -> ToHs a -> HsCompileM a+runToHs top m = either (ghcBackendError . NotAHaskellType top) return =<< runExceptT m++liftE1' :: (forall b. (a -> m b) -> m b) -> (a -> ExceptT e m b) -> ExceptT e m b+liftE1' f k = ExceptT (f (runExceptT . k))++-- Only used in hsTypeApproximation below, and in that case we catch the error.+getHsType' :: QName -> HsCompileM HS.Type+getHsType' q = runToHs (Def q []) (getHsType q)++getHsType :: QName -> ToHs HS.Type+getHsType x = do+ unlessM (isCompiled x) $ throwError $ NotCompiled x++ d <- liftTCM $ getHaskellPragma x+ env <- askGHCEnv+ let is t p = Just t == p env++ namedType = do+ -- For these builtin types, the type name (xhqn ...) refers to the+ -- generated, but unused, datatype and not the primitive type.+ if | x `is` ghcEnvNat ||+ x `is` ghcEnvInteger -> return $ hsCon "Integer"+ | x `is` ghcEnvBool -> return $ hsCon "Bool"+ | otherwise ->+ lift $ hsCon . prettyShow <$> xhqn TypeK x+ mapExceptT (setCurrentRange d) $ case d of+ _ | x `is` ghcEnvList ->+ lift $ hsCon . prettyShow <$> xhqn TypeK x+ -- we ignore Haskell pragmas for List+ _ | x `is` ghcEnvMaybe ->+ lift $ hsCon . prettyShow <$> xhqn TypeK x+ -- we ignore Haskell pragmas for Maybe+ _ | x `is` ghcEnvInf ->+ return $ hsQCon "MAlonzo.RTE" "Infinity"+ Just HsDefn{} -> throwError $ WrongPragmaFor (getRange d) x+ Just HsType{} -> namedType+ Just HsData{} -> namedType+ _ -> throwError $ NoPragmaFor x++-- | Is the given thing compiled?++isCompiled :: HasConstInfo m => QName -> m Bool+isCompiled q = usableModality <$> getConstInfo q++-- | Does the name stand for a data or record type?++isData :: HasConstInfo m => QName -> m Bool+isData q = do+ def <- theDef <$> getConstInfo q+ return $ case def of+ Datatype{} -> True+ Record{} -> True+ _ -> False++getHsVar :: (MonadDebug tcm, MonadTCM tcm) => Nat -> tcm HS.Name+getHsVar i =+ HS.Ident . encodeString (VarK X) . prettyShow <$> nameOfBV i++haskellType' :: Type -> HsCompileM HS.Type+haskellType' t = runToHs (unEl t) (fromType t)+ where+ fromArgs = mapM fromArg+ fromArg v+ | usableModality v = fromTerm (unArg v)+ | otherwise = pure hsUnit+ fromDom dom+ | usableModality dom = fromType (unDom dom)+ | otherwise = pure hsUnit+ fromType = fromTerm . unEl+ fromTerm v = do+ v <- liftTCM $ unSpine <$> reduce v+ reportSDoc "compile.haskell.type" 25 $ "toHaskellType " <+> prettyTCM v+ reportSDoc "compile.haskell.type" 50 $ "toHaskellType " <+> pretty v+ kit <- liftTCM coinductionKit+ case v of+ Var x es -> do+ let args = mustAllApplyElims es+ hsApp . hsVar <$> getHsVar x <*> fromArgs args+ Def d es -> do+ let args = mustAllApplyElims es+ hsApp <$> getHsType d <*> fromArgs args+ Pi a b ->+ if isBinderUsed b -- Andreas, 2012-04-03. Q: could we rely on Abs/NoAbs instead of again checking freeness of variable?+ then do+ hsA <- fromDom a+ liftE1' (underAbstraction a b) $ \ b ->+ hsForall <$> getHsVar 0 <*> (hsFun hsA <$> fromType b)+ else hsFun <$> fromDom a <*> fromType (noabsApp __IMPOSSIBLE__ b)+ Con c ci es -> do+ let args = mustAllApplyElims es+ hsApp <$> getHsType (conName c) <*> fromArgs args+ Lam{} -> throwError (BadLambda v)+ Level{} -> return hsUnit+ Lit{} -> return hsUnit+ Sort{} -> return hsUnit+ MetaV{} -> throwError (BadMeta v)+ DontCare{} -> throwError (BadDontCare v)+ Dummy s _ -> __IMPOSSIBLE_VERBOSE__ (show s)++haskellType :: QName -> HsCompileM HS.Type+haskellType q = do+ def <- getConstInfo q+ let (np, erased) =+ case theDef def of+ Constructor{ conPars, conErased }+ -> (conPars, ListInf.pad (fromMaybe [] conErased) False)+ _ -> (0, ListInf.repeat False)+ stripErased (True :< es) (HS.TyFun _ t) = stripErased es t+ stripErased (False :< es) (HS.TyFun s t) = HS.TyFun s $ stripErased es t+ stripErased es (HS.TyForall xs t) = HS.TyForall xs $ stripErased es t+ stripErased _ t = t+ underPars 0 a = stripErased erased <$> haskellType' a+ underPars n a = do+ a <- reduce a+ case unEl a of+ Pi a (NoAbs _ b) -> underPars (n - 1) b+ Pi a b -> underAbstraction a b $ \b -> hsForall <$> getHsVar 0 <*> underPars (n - 1) b+ _ -> __IMPOSSIBLE__+ ty <- underPars np $ defType def+ reportSDoc "tc.pragma.compile" 10 $ (("Haskell type for" <+> prettyTCM q) <> ":") <?> pretty ty+ return ty++-- Type approximations ----------------------------------------------------++data PolyApprox = PolyApprox | NoPolyApprox+ deriving (Eq)++hsTypeApproximation :: PolyApprox -> Int -> Dom Type -> HsCompileM HS.Type+hsTypeApproximation poly fv dom+ | not (usableModality dom) = pure hsUnit+ | otherwise = do+ env <- askGHCEnv+ let is q b = Just q == b env+ tyCon = HS.TyCon . HS.UnQual . HS.Ident+ rteCon = HS.TyCon . HS.Qual mazRTE . HS.Ident+ tyVar n i = HS.TyVar $ HS.Ident $ "a" ++ show (n - i)+ let go n t = do+ reportSDoc "compile.haskell.type" 25 $ "hsTypeApproximation " <+> prettyTCM t+ reportSDoc "compile.haskell.type" 50 $ "hsTypeApproximation " <+> pretty t+ t <- unSpine <$> reduce t+ case t of+ Var i _ | poly == PolyApprox -> return $ tyVar n i+ Pi a b -> hsFun <$> goDom n a <*> go (n + k) (unEl $ unAbs b)+ where k = case b of Abs{} -> 1; NoAbs{} -> 0+ Def q els+ | q `is` ghcEnvList+ , Just k <- ghcEnvListArity env+ , [Apply t] <- drop (k-1) els ->+ HS.TyApp (tyCon "[]") <$> goArg n t+ | q `is` ghcEnvMaybe+ , Just k <- ghcEnvMaybeArity env+ , [Apply t] <- drop (k-1) els ->+ HS.TyApp (tyCon "Maybe") <$> goArg n t+ | q `is` ghcEnvBool -> return $ tyCon "Bool"+ | q `is` ghcEnvInteger -> return $ tyCon "Integer"+ | q `is` ghcEnvNat -> return $ tyCon "Integer"+ | q `is` ghcEnvWord64 -> return $ rteCon "Word64"+ | otherwise -> do+ let args = mustAllApplyElims els+ foldl HS.TyApp <$> getHsType' q <*> mapM (goArg n) args+ `catchError` \ _ -> -- Not a Haskell type+ ifM (and2M (isCompiled q) (isData q))+ (HS.TyCon <$> xhqn TypeK q)+ (return mazAnyType)+ Sort{} -> return $ HS.FakeType "()"+ _ -> return mazAnyType+ goArg n v+ | usableModality v = go n (unArg v)+ | otherwise = pure hsUnit+ goDom n dom+ | usableModality dom = go n (unEl $ unDom dom)+ | otherwise = pure hsUnit+ goDom fv dom++-- Approximating polymorphic types is not actually a good idea unless we+-- actually keep track of type applications in recursive functions, and+-- generate parameterised datatypes. Otherwise we'll just coerce all type+-- variables to `Any` at the first `unsafeCoerce`.+hsTelApproximation :: Type -> HsCompileM ([HS.Type], HS.Type)+hsTelApproximation = hsTelApproximation' NoPolyApprox++hsTelApproximation' :: PolyApprox -> Type -> HsCompileM ([HS.Type], HS.Type)+hsTelApproximation' poly t = do+ TelV tel res <- telViewPath t+ let doms = map (fmap snd) (telToList tel)+ (,) <$> zipWithM (hsTypeApproximation poly) [0..] doms <*> hsTypeApproximation poly (length doms) (defaultDom res)
@@ -1,166 +1,387 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Compiler.MAlonzo.Misc where -import Control.Monad.State-import Data.Generics-import Data.List as L-import Data.Map as M-import Data.Set as S-import Data.Maybe-import Data.Function-import qualified Language.Haskell.Exts.Syntax as HS-import System.IO-import System.Time+import Control.Monad.Reader ( ask )+import Control.Monad.State ( modify )+import Control.Monad.Trans ( MonadTrans(lift) )+import Control.Monad.Trans.Except ( ExceptT )+import Control.Monad.Trans.Identity ( IdentityT )+import Control.Monad.Trans.Maybe ( MaybeT )+import Control.Monad.Trans.Reader ( ReaderT(runReaderT) )+import Control.Monad.Trans.State ( StateT(runStateT) ) -import Agda.Interaction.Imports+import Data.Char+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Text (Text)+import qualified Data.Text as T++import qualified Agda.Utils.Haskell.Syntax as HS++import Agda.Compiler.Common as CC+ import Agda.Syntax.Common-import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Internal-import Agda.Syntax.Position-import Agda.Syntax.Scope.Base-import Agda.Syntax.Translation.ConcreteToAbstract+import Agda.Syntax.TopLevelModuleName+ import Agda.TypeChecking.Monad-import Agda.TypeChecking.Monad.Builtin-import Agda.Utils.FileName-import Agda.Utils.Monad-import Agda.Utils.Pretty +import Agda.Syntax.Common.Pretty++import Agda.Utils.CallStack ( HasCallStack ) import Agda.Utils.Impossible-#include "../../undefined.h" -------------------------------------------------- -- Setting up Interface before compile -------------------------------------------------- -setInterface :: Interface -> TCM ()-setInterface i = modify $ \s -> s- { stImportedModules = S.empty- , stCurrentModule = Just $ iModuleName i+data HsModuleEnv = HsModuleEnv+ { mazModuleName :: TopLevelModuleName+ -- ^ The name of the Agda module+ , mazIsMainModule :: Bool+ -- ^ Whether this is the compilation root and therefore should have the `main` function.+ -- This corresponds to the @IsMain@ flag provided to the backend,+ -- not necessarily whether the GHC module has a `main` function defined. } -curIF :: TCM Interface-curIF = do- mName <- stCurrentModule <$> get- case mName of- Nothing -> __IMPOSSIBLE__- Just name -> do- mm <- getVisitedModule (toTopLevelModuleName name)- case mm of- Nothing -> __IMPOSSIBLE__- Just mi -> return $ miInterface mi+-- | The options derived from+-- 'Agda.Compiler.MAlonzo.Compiler.GHCFlags' and other shared options. -curSig :: TCM Signature-curSig = iSignature <$> curIF+data GHCOptions = GHCOptions+ { optGhcCallGhc :: Bool+ , optGhcBin :: FilePath+ -- ^ Use the compiler at PATH instead of "ghc"+ , optGhcFlags :: [String]+ , optGhcCompileDir :: FilePath+ , optGhcStrictData :: Bool+ -- ^ Make inductive constructors strict?+ , optGhcStrict :: Bool+ -- ^ Make functions strict?+ , optGhcTrace :: Bool+ -- ^ Print function name upon entry using 'Debug.Trace.trace'?+ } -curMName :: TCM ModuleName-curMName = sigMName <$> curSig+-- | A static part of the GHC backend's environment that does not+-- change from module to module. -curHsMod :: TCM HS.ModuleName-curHsMod = mazMod <$> curMName+data GHCEnv = GHCEnv+ { ghcEnvOpts :: GHCOptions+ , ghcEnvBool+ , ghcEnvTrue+ , ghcEnvFalse+ , ghcEnvMaybe+ , ghcEnvNothing+ , ghcEnvJust+ , ghcEnvList+ , ghcEnvNil+ , ghcEnvCons+ , ghcEnvNat+ , ghcEnvInteger+ , ghcEnvWord64+ , ghcEnvInf+ , ghcEnvSharp+ , ghcEnvFlat+ , ghcEnvInterval+ , ghcEnvIZero+ , ghcEnvIOne+ , ghcEnvIsOne+ , ghcEnvItIsOne+ , ghcEnvIsOne1+ , ghcEnvIsOne2+ , ghcEnvIsOneEmpty+ , ghcEnvPathP+ , ghcEnvSub+ , ghcEnvSubIn+ :: Maybe QName+ -- Various (possibly) builtin names.+ , ghcEnvIsTCBuiltin :: QName -> Bool+ , ghcEnvListArity :: Maybe Int+ , ghcEnvMaybeArity :: Maybe Int+ } -curDefs :: TCM Definitions-curDefs = sigDefinitions <$> curSig+-- | Module compilation environment, bundling the overall+-- backend session options along with the module's basic+-- readable properties.+data GHCModuleEnv = GHCModuleEnv+ { ghcModEnv :: GHCEnv+ , ghcModHsModuleEnv :: HsModuleEnv+ } -sigMName :: Signature -> ModuleName-sigMName sig = case M.keys (sigSections sig) of- [] -> __IMPOSSIBLE__- m : _ -> m+-- | Monads that can produce a 'GHCModuleEnv'.+class Monad m => ReadGHCModuleEnv m where+ askGHCModuleEnv :: m GHCModuleEnv + default askGHCModuleEnv+ :: (MonadTrans t, m ~ (t n), ReadGHCModuleEnv n)+ => m GHCModuleEnv+ askGHCModuleEnv = lift askGHCModuleEnv++ askHsModuleEnv :: m HsModuleEnv+ askHsModuleEnv = ghcModHsModuleEnv <$> askGHCModuleEnv++ askGHCEnv :: m GHCEnv+ askGHCEnv = ghcModEnv <$> askGHCModuleEnv++instance Monad m => ReadGHCModuleEnv (ReaderT GHCModuleEnv m) where+ askGHCModuleEnv = ask++instance ReadGHCModuleEnv m => ReadGHCModuleEnv (ExceptT e m)+instance ReadGHCModuleEnv m => ReadGHCModuleEnv (IdentityT m)+instance ReadGHCModuleEnv m => ReadGHCModuleEnv (MaybeT m)+instance ReadGHCModuleEnv m => ReadGHCModuleEnv (StateT s m)++newtype HsCompileState = HsCompileState+ { mazAccumlatedImports :: Set TopLevelModuleName+ } deriving (Eq, Semigroup, Monoid)++-- | Transformer adding read-only module info and a writable set of imported modules+type HsCompileT m = ReaderT GHCModuleEnv (StateT HsCompileState m)++-- | The default compilation monad is the entire TCM (☹️) enriched with our state and module info+type HsCompileM = HsCompileT TCM++runHsCompileT' :: HsCompileT m a -> GHCModuleEnv -> HsCompileState -> m (a, HsCompileState)+runHsCompileT' t e s = (flip runStateT s) . (flip runReaderT e) $ t++runHsCompileT :: HsCompileT m a -> GHCModuleEnv -> m (a, HsCompileState)+runHsCompileT t e = runHsCompileT' t e mempty++ghcBackendError :: (HasCallStack, MonadTCError m) => GHCBackendError -> m a+ghcBackendError = locatedTypeError GHCBackendError+ -------------------------------------------------- -- utilities for haskell names -------------------------------------------------- --- The following naming scheme seems to be used:------ * Types coming from Agda are named "T\<number\>".------ * Other definitions coming from Agda are named "d\<number\>".--- Exception: the main function is named "main".+-- | Whether the current module is expected to have the `main` function.+-- This corresponds to the @IsMain@ flag provided to the backend,+-- not necessarily whether the GHC module actually has a `main` function defined.+curIsMainModule :: ReadGHCModuleEnv m => m Bool+curIsMainModule = mazIsMainModule <$> askHsModuleEnv++-- | This is the same value as @curMName@, but does not rely on the TCM's state.+-- (@curMName@ and co. should be removed, but the current @Backend@ interface+-- is not sufficient yet to allow that)+curAgdaMod :: ReadGHCModuleEnv m => m TopLevelModuleName+curAgdaMod = mazModuleName <$> askHsModuleEnv++-- | Get the Haskell module name of the currently-focused Agda module+curHsMod :: ReadGHCModuleEnv m => m HS.ModuleName+curHsMod = mazMod <$> curAgdaMod++-- | There are two kinds of functions: those definitely without unused+-- arguments, and those that might have unused arguments.++data FunctionKind = NoUnused | PossiblyUnused++-- | Different kinds of variables: those starting with @a@, those+-- starting with @v@, and those starting with @x@.++data VariableKind = A | V | X++-- | Different kinds of names.++data NameKind+ = TypeK+ -- ^ Types.+ | ConK+ -- ^ Constructors.+ | VarK VariableKind+ -- ^ Variables.+ | CoverK+ -- ^ Used for coverage checking.+ | CheckK+ -- ^ Used for constructor type checking.+ | FunK FunctionKind+ -- ^ Other functions.++-- | Turns strings into valid Haskell identifiers. ----- * Names coming from Haskell must always be used qualified.--- Exception: names from the Prelude.+-- In order to avoid clashes with names of regular Haskell definitions+-- (those not generated from Agda definitions), make sure that the+-- Haskell names are always used qualified, with the exception of+-- names from the prelude. -ihname :: String -> Nat -> HS.Name-ihname s i = HS.Ident $ s ++ show i+encodeString :: NameKind -> String -> String+encodeString k s = prefix ++ concatMap encode s+ where+ encode '\'' = "''"+ encode c+ | isLower c || isUpper c || c == '_' ||+ generalCategory c == DecimalNumber =+ [c]+ | otherwise =+ "'" ++ show (fromEnum c) ++ "'" -unqhname :: String -> QName -> HS.Name-unqhname s q | ("d", "main") == (s, show(qnameName q)) = HS.Ident "main"- | otherwise = ihname s (idnum $ nameId $ qnameName $ q)- where idnum (NameId x _) = fromIntegral x+ prefix = case k of+ TypeK -> "T"+ ConK -> "C"+ VarK A -> "a"+ VarK V -> "v"+ VarK X -> "x"+ CoverK -> "cover"+ CheckK -> "check"+ FunK NoUnused -> "du"+ FunK PossiblyUnused -> "d" +ihname :: VariableKind -> Nat -> HS.Name+ihname k i = HS.Ident $ encodeString (VarK k) (show i)++unqhname :: NameKind -> QName -> HS.Name+unqhname k q =+ HS.Ident $ encodeString k $+ "_" ++ prettyShow (nameCanonical n) ++ "_" ++ idnum (nameId n)+ where+ n = qnameName q++ idnum (NameId x _) = show (fromIntegral x)+ -- the toplevel module containing the given one-tlmodOf :: ModuleName -> TCM HS.ModuleName-tlmodOf = fmap mazMod . tlmname+tlmodOf :: ReadTCState m => ModuleName -> m HS.ModuleName+tlmodOf = fmap mazMod . CC.topLevelModuleName -tlmname :: ModuleName -> TCM ModuleName-tlmname m = do- ms <- sortBy (compare `on` (length . mnameToList)) .- L.filter (flip (isPrefixOf `on` mnameToList) m) <$>- L.map (iModuleName . miInterface) . M.elems <$>- getVisitedModules- return $ case ms of (m' : _) -> m'; _ -> __IMPOSSIBLE__ -- qualify HS.Name n by the module of QName q, if necessary; -- accumulates the used module in stImportedModules at the same time.-xqual :: QName -> HS.Name -> TCM HS.QName-xqual q n = do m1 <- tlmname (qnameModule q)- m2 <- curMName- if m1 == m2 then return (HS.UnQual n)- else addImport m1 >> return (HS.Qual (mazMod m1) n)+xqual :: QName -> HS.Name -> HsCompileM HS.QName+xqual q n = do+ m1 <- CC.topLevelModuleName (qnameModule q)+ m2 <- curAgdaMod+ if m1 == m2+ then return (HS.UnQual n)+ else do+ modify (HsCompileState . Set.insert m1 . mazAccumlatedImports)+ return (HS.Qual (mazMod m1) n) -xhqn :: String -> QName -> TCM HS.QName-xhqn s q = xqual q (unqhname s q)+xhqn :: NameKind -> QName -> HsCompileM HS.QName+xhqn k q = xqual q (unqhname k q) +hsName :: String -> HS.QName+hsName s = HS.UnQual (HS.Ident s)+ -- always use the original name for a constructor even when it's redefined.-conhqn :: QName -> TCM HS.QName-conhqn q = do- cq <- canonicalName q- def <- getConstInfo cq- hsr <- compiledHaskell . defCompiledRep <$> getConstInfo cq- case (compiledHaskell (defCompiledRep def), theDef def) of- (Just (HsDefn _ hs), Constructor{}) -> return $ HS.UnQual $ HS.Ident hs- _ -> xhqn "C" cq+conhqn :: QName -> HsCompileM HS.QName+conhqn q = xhqn ConK =<< canonicalName q -- qualify name s by the module of builtin b-bltQual :: String -> String -> TCM HS.QName-bltQual b s = do (Def q _) <- getBuiltin b; xqual q (HS.Ident s)+bltQual :: BuiltinId -> String -> HsCompileM HS.QName+bltQual b s = do+ Def q _ <- getBuiltin b+ xqual q (HS.Ident s) --- sub-naming for cascaded definitions for concsecutive clauses-dsubname q i | i == 0 = unqhname "d" q- | otherwise = unqhname ("d_" ++ show i ++ "_") q+dname :: QName -> HS.Name+dname q = unqhname (FunK PossiblyUnused) q +-- | Name for definition stripped of unused arguments+duname :: QName -> HS.Name+duname q = unqhname (FunK NoUnused) q++hsPrimOp :: String -> HS.QOp+hsPrimOp s = HS.QVarOp $ HS.UnQual $ HS.Symbol s++hsPrimOpApp :: String -> HS.Exp -> HS.Exp -> HS.Exp+hsPrimOpApp op e e1 = HS.InfixApp e (hsPrimOp op) e1++hsInt :: Integer -> HS.Exp+hsInt n = HS.Lit (HS.Int n)++hsTypedInt :: Integral a => a -> HS.Exp+hsTypedInt n = HS.ExpTypeSig (HS.Lit (HS.Int $ fromIntegral n)) (HS.TyCon (hsName "Integer"))++hsTypedDouble :: Real a => a -> HS.Exp+hsTypedDouble n = HS.ExpTypeSig (HS.Lit (HS.Frac $ toRational n)) (HS.TyCon (hsName "Double"))++hsLet :: HS.Strictness -> HS.Name -> HS.Exp -> HS.Exp -> HS.Exp+hsLet s x e b =+ HS.Let (HS.BDecls [HS.LocalBind s x (HS.UnGuardedRhs e)]) b+ hsVarUQ :: HS.Name -> HS.Exp hsVarUQ = HS.Var . HS.UnQual +hsAppView :: HS.Exp -> [HS.Exp]+hsAppView = reverse . view+ where+ view (HS.App e e1) = e1 : view e+ view (HS.InfixApp e1 op e2) = [e2, e1, hsOpToExp op]+ view e = [e]++hsOpToExp :: HS.QOp -> HS.Exp+hsOpToExp (HS.QVarOp x) = HS.Var x++hsLambda :: [HS.Pat] -> HS.Exp -> HS.Exp+hsLambda ps (HS.Lambda ps1 e) = HS.Lambda (ps ++ ps1) e+hsLambda ps e = HS.Lambda ps e++hsMapAlt :: (HS.Exp -> HS.Exp) -> HS.Alt -> HS.Alt+hsMapAlt f (HS.Alt p rhs wh) = HS.Alt p (hsMapRHS f rhs) wh++hsMapRHS :: (HS.Exp -> HS.Exp) -> HS.Rhs -> HS.Rhs+hsMapRHS f (HS.UnGuardedRhs def) = HS.UnGuardedRhs (f def)+hsMapRHS f (HS.GuardedRhss es) = HS.GuardedRhss [ HS.GuardedRhs g (f e) | HS.GuardedRhs g e <- es ]+ -------------------------------------------------- -- Hard coded module names -------------------------------------------------- -mazstr = "MAlonzo.Code"-mazName = mkName_ dummy mazstr+mazstr :: String+mazstr = "MAlonzo.Code"++mazName :: Name+mazName = mkName_ __IMPOSSIBLE__ mazstr++mazMod' :: String -> HS.ModuleName mazMod' s = HS.ModuleName $ mazstr ++ "." ++ s-mazMod :: ModuleName -> HS.ModuleName-mazMod = mazMod' . show-mazerror msg = error $ mazstr ++ ": " ++ msg++mazMod :: TopLevelModuleName -> HS.ModuleName+mazMod = mazMod' . prettyShow++mazCoerceName :: String+mazCoerceName = "coe"++mazErasedName :: String+mazErasedName = "erased"++mazAnyTypeName :: String+mazAnyTypeName = "AgdaAny"++mazCoerce :: HS.Exp -- mazCoerce = HS.Var $ HS.Qual unsafeCoerceMod (HS.Ident "unsafeCoerce")-mazCoerce = HS.Var $ HS.Qual mazRTE $ HS.Ident "mazCoerce"+-- mazCoerce = HS.Var $ HS.Qual mazRTE $ HS.Ident mazCoerceName+mazCoerce = HS.Var $ HS.UnQual $ HS.Ident mazCoerceName --- Andreas, 2011-11-16: error incomplete match now RTE-call-mazIncompleteMatch = HS.Var $ HS.Qual mazRTE $ HS.Ident "mazIncompleteMatch"-rtmIncompleteMatch :: QName -> HS.Exp-rtmIncompleteMatch q = mazIncompleteMatch `HS.App` hsVarUQ (unqhname "name" q)+mazUnreachableError :: HS.Exp+mazUnreachableError = HS.Var $ HS.Qual mazRTE $ HS.Ident "mazUnreachableError" +rtmUnreachableError :: HS.Exp+rtmUnreachableError = mazUnreachableError++mazHole :: HS.Exp+mazHole = HS.Var $ HS.Qual mazRTE $ HS.Ident "mazHole"++rtmHole :: String -> HS.Exp+rtmHole s = mazHole `HS.App` HS.Lit (HS.String $ T.pack s)++mazAnyType :: HS.Type+mazAnyType = HS.TyCon (hsName mazAnyTypeName)+ mazRTE :: HS.ModuleName mazRTE = HS.ModuleName "MAlonzo.RTE" --- for Runtime module: Not really used (Runtime modules has been abolished).-rtmMod = mazMod' "Runtime"+mazRTEFloat :: HS.ModuleName+mazRTEFloat = HS.ModuleName "MAlonzo.RTE.Float"++rtmQual :: String -> HS.QName rtmQual = HS.UnQual . HS.Ident++rtmVar :: String -> HS.Exp rtmVar = HS.Var . rtmQual++rtmError :: Text -> HS.Exp rtmError s = rtmVar "error" `HS.App`- (HS.Lit $ HS.String $ "MAlonzo Runtime Error: " ++ s)+ HS.Lit (HS.String $ T.append "MAlonzo Runtime Error: " s) +unsafeCoerceMod :: HS.ModuleName unsafeCoerceMod = HS.ModuleName "Unsafe.Coerce" --------------------------------------------------@@ -168,45 +389,38 @@ -------------------------------------------------- fakeD :: HS.Name -> String -> HS.Decl-fakeD v s = HS.FunBind [ HS.Match dummy v [] Nothing- (HS.UnGuardedRhs $ hsVarUQ $ HS.Ident $ s)- (HS.BDecls [])- ]+fakeD v s = HS.FunBind [HS.Match v [] (HS.UnGuardedRhs $ fakeExp s) emptyBinds] fakeDS :: String -> String -> HS.Decl fakeDS = fakeD . HS.Ident fakeDQ :: QName -> String -> HS.Decl-fakeDQ = fakeD . unqhname "d"+fakeDQ = fakeD . dname fakeType :: String -> HS.Type-fakeType = HS.TyVar . HS.Ident+fakeType = HS.FakeType fakeExp :: String -> HS.Exp-fakeExp = HS.Var . HS.UnQual . HS.Ident+fakeExp = HS.FakeExp -dummy :: a-dummy = error "MAlonzo : this dummy value should not have been eval'ed."+fakeDecl :: String -> HS.Decl+fakeDecl = HS.FakeDecl +--------------------------------------------------+-- Auxiliary definitions+-------------------------------------------------- +emptyBinds :: Maybe HS.Binds+emptyBinds = Nothing+ ----------------------------------------------------- For Debugging+-- Utilities for Haskell modules names ---------------------------------------------------gshow' :: Data a => a -> String-gshow' = ( \t ->- "("- ++ showConstr (toConstr t)- ++ concat (gmapQ ((++) " " . gshow') t)- ++ ")" )- `extQ` (show :: String -> String)- `extQ` (show :: Name -> String)- `extQ` (show :: QName -> String)- `extQ` (show :: ModuleName -> String)- `extQ` (gshow' . M.toList :: M.Map QName [AbstractName] -> String)- `extQ` (gshow' . M.toList :: M.Map QName [AbstractModule] -> String)- `extQ` (gshow' . M.toList :: M.Map ModuleName Section -> String)- `extQ` (gshow' . M.toList :: M.Map QName Definition -> String)- `extQ` (gshow' . M.toList :: M.Map TermHead [Pattern] -> String)- `extQ` (gshow' . M.toList :: M.Map TermHead [Arg Pattern] -> String)- `extQ` (gshow' . M.toList :: M.Map String (Builtin String) -> String)- `extQ` (show :: Scope -> String)++-- | Can the character be used in a Haskell module name part+-- (@conid@)? This function is more restrictive than what the Haskell+-- report allows.++isModChar :: Char -> Bool+isModChar c =+ isLower c || isUpper c || isDigit c || c == '_' || c == '\''
@@ -0,0 +1,266 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.MAlonzo.Pragmas where++import Control.Monad.Trans.Maybe++import Data.Maybe+import Data.Char+import qualified Data.List as List+import qualified Data.Map as Map+import Data.Set (Set)+import Data.Set qualified as Set++import Text.ParserCombinators.ReadP++import Agda.Syntax.Position+import Agda.Syntax.Abstract.Name+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Warnings+import Agda.TypeChecking.Primitive++import Agda.Compiler.MAlonzo.Misc+import Agda.Compiler.Treeless.Erase (isErasable)++import Agda.Syntax.Common.Pretty hiding (char)+import Agda.Utils.Functor+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.String ( ltrim )+import Agda.Utils.Three++import Agda.Utils.Impossible++-- | Raw Haskell pragma (something enclosed in @{-# ... #-}@).+type GHCPragma = String++-- | Raw Haskell import (something starting with @import @).+type GHCImport = String++type HaskellCode = String+type HaskellType = String++-- | GHC backend translation pragmas.+data HaskellPragma+ = HsDefn Range HaskellCode+ -- ^ @COMPILE GHC x = <code>@+ | HsType Range HaskellType+ -- ^ @COMPILE GHC X = type <type>@+ | HsData Range HaskellType [HaskellCode]+ -- ^ @COMPILE GHC X = data D (c₁ | ... | cₙ)+ | HsExport Range HaskellCode+ -- ^ @COMPILE GHC x as f@+ deriving (Show, Eq)++instance HasRange HaskellPragma where+ getRange (HsDefn r _) = r+ getRange (HsType r _) = r+ getRange (HsData r _ _) = r+ getRange (HsExport r _) = r++instance Pretty HaskellPragma where+ pretty = \case+ HsDefn _r hsCode -> equals <+> text hsCode+ HsType _r hsType -> equals <+> text hsType+ HsData _r hsType hsCons -> hsep $+ [ equals, "data", text hsType+ , parens $ hsep $ map text $ List.intersperse "|" hsCons+ ]+ HsExport _r hsCode -> "as" <+> text hsCode++-- | Retrieve and parse a @COMPILE GHC@ pragma stored for a name.+--+getHaskellPragma :: QName -> TCM (Maybe HaskellPragma)+getHaskellPragma q = runMaybeT do+ p <- MaybeT $ getUniqueCompilerPragma ghcBackendName q+ setCurrentRange p do+ pragma <- MaybeT $ parseHaskellPragma p+ MaybeT $ sanityCheckPragma q pragma++-- Syntax for Haskell pragmas:+-- HsDefn CODE "= CODE"+-- HsType TYPE "= type TYPE"+-- HsData NAME CONS "= data NAME (CON₁ | .. | CONₙ)"+-- HsExport NAME "as NAME"+parsePragma :: CompilerPragma -> Maybe HaskellPragma+parsePragma (CompilerPragma r s) =+ case [ p | (p, "") <- readP_to_S pragmaP s ] of+ [] -> Nothing+ [p] -> Just p+ ps -> -- shouldn't happen+ -- trace ("Ambiguous parse of pragma '" ++ s ++ "':\n" ++ unlines (map show ps)) $+ __IMPOSSIBLE__+ where+ pragmaP :: ReadP HaskellPragma+ pragmaP = choice [ exportP, typeP, dataP, defnP ]++ whitespace = many1 (satisfy isSpace)++ wordsP [] = return ()+ wordsP (w:ws) = skipSpaces *> string w *> wordsP ws++ barP = skipSpaces *> char '|'++ -- quite liberal+ isIdent c = isAlphaNum c || elem c ("_.':[]" :: String)+ isOp c = not $ isSpace c || elem c ("()" :: String)+ hsIdent = fst <$> gather (choice+ [ string "()"+ , many1 (satisfy isIdent)+ , between (char '(') (char ')') (many1 (satisfy isOp))+ ])+ hsCode = many1 get -- very liberal++ paren = between (skipSpaces *> char '(') (skipSpaces *> char ')')++ isPrefixSpaceOf pre s = case List.stripPrefix pre s of+ Just (x:_) -> isSpace x+ _ -> False++ notTypeOrData = do+ s <- look+ guard $ not $ any (`isPrefixSpaceOf` s) ["type", "data"]++ exportP = HsExport r <$ wordsP ["as"] <* whitespace <*> hsIdent <* skipSpaces+ typeP = HsType r <$ wordsP ["=", "type"] <* whitespace <*> hsCode+ dataP = HsData r <$ wordsP ["=", "data"] <* whitespace <*> hsIdent <*>+ paren (sepBy (skipSpaces *> hsIdent) barP) <* skipSpaces+ defnP = HsDefn r <$ wordsP ["="] <* whitespace <* notTypeOrData <*> hsCode++parseHaskellPragma :: CompilerPragma -> TCM (Maybe HaskellPragma)+parseHaskellPragma p@(CompilerPragma _ s) = do+ let p' = parsePragma p+ () <- whenNothing p' $ warning $ PragmaCompileUnparsable s+ return p'++-- | Check whether the parsed @COMPILE GHC@ pragma matches the kind of identifier it attaches to.+--+sanityCheckPragma :: QName -> HaskellPragma -> TCM (Maybe HaskellPragma)+sanityCheckPragma x pragma = do+ reportSLn "compile.haskell.pragma" 40 $ unwords ["sanityCheckPragma" , prettyShow x]+ def <- getConstInfo x+ case pragma of++ HsDefn{} -> case theDef def of+ Axiom{} -> ok+ Function{} -> functionCheck+ AbstractDefn{} -> __IMPOSSIBLE__+ Datatype{} -> recOrDataErr "data"+ Record{} -> recOrDataErr "record"+ _ -> bad "Haskell definitions can only be given for postulates and functions."++ HsData{} -> case theDef def of+ Datatype{} -> ok+ Record{} -> ok+ _ -> bad "Haskell data types can only be given for data or record types."++ HsType{} -> case theDef def of+ Axiom{} -> ok+ Datatype{} -> do+ -- We use HsType pragmas for Nat, Int and Bool+ ifM (anyM ((Just (defName def) ==) <.> getBuiltinName) [builtinNat, builtinInteger, builtinBool])+ {-then-} ok+ {-else-} notPostulate+ _ -> notPostulate++ HsExport{} -> case theDef def of+ Function{} -> functionCheck+ _ -> bad "Only functions can be exported to Haskell using {-# COMPILE GHC <Name> as <HsName> #-}"++ where+ ok = return $ Just pragma+ bad = (Nothing <$) . warning . PragmaCompileWrong x+ recOrDataErr which = bad $ unwords+ [ "Bad COMPILE GHC pragma for", which, "type. Use"+ , "{-# COMPILE GHC <Name> = data <HsData> (<HsCon1> | .. | <HsConN>) #-}"+ ]+ notPostulate = bad "Haskell types can only be given for postulates."+ notBuiltinFlat = do+ mflat <- getBuiltinName builtinFlat+ reportSLn "compile.haskell.pragma" 40 $ render $ vcat+ [ "Checking pragma for FLAT"+ , hsep [ "x =", pretty x ]+ , hsep [ "mflat =", pretty mflat ]+ ]+ if Just x == mflat+ then bad "COMPILE GHC pragmas are not allowed for the FLAT builtin."+ else ok+ notErasable = isErasable x >>= \case+ True -> Nothing <$ do warning $ PragmaCompileErased ghcBackendName x+ False -> ok+ functionCheck = runMaybeT do+ _ <- MaybeT notErasable+ MaybeT notBuiltinFlat++-- TODO: cache this to avoid parsing the pragma for every constructor+-- occurrence!+getHaskellConstructor :: QName -> HsCompileM (Maybe HaskellCode)+getHaskellConstructor c = do+ c <- canonicalName c+ cDef <- theDef <$> getConstInfo c+ env <- askGHCEnv+ let is c p = Just c == p env+ case cDef of+ _ | c `is` ghcEnvTrue -> return $ Just "True"+ | c `is` ghcEnvFalse -> return $ Just "False"+ | c `is` ghcEnvNil -> return $ Just "[]"+ | c `is` ghcEnvCons -> return $ Just "(:)"+ | c `is` ghcEnvNothing -> return $ Just "Nothing"+ | c `is` ghcEnvJust -> return $ Just "Just"+ | c `is` ghcEnvSharp -> return $ Just "MAlonzo.RTE.Sharp"+ | c `is` ghcEnvIZero -> return $ Just "False"+ | c `is` ghcEnvIOne -> return $ Just "True"+ Constructor{conData = d} -> do+ mp <- liftTCM $ getHaskellPragma d+ case mp of+ Just (HsData _ _ hsCons) -> do+ cons <- defConstructors . theDef <$> getConstInfo d+ return $ Just $ fromMaybe __IMPOSSIBLE__ $ lookup c $ zip cons hsCons+ _ -> return Nothing+ _ -> return Nothing++-- | Get content of @FOREIGN GHC@ pragmas, sorted by 'KindOfForeignCode':+-- file header pragmas, import statements, rest.+foreignHaskell :: Interface -> (Set GHCPragma, Set GHCImport, [HaskellCode])+foreignHaskell i = (Set.fromList pragmas, Set.fromList imports, reverse revCode)+ where+ getCode (ForeignCode _ code) = code+ (pragmas, imports, revCode) = partitionByKindOfForeignCode classifyForeign+ . map getCode . maybe [] getForeignCodeStack . Map.lookup ghcBackendName . iForeignCode $ i++-- | Classify @FOREIGN@ Haskell code.+data KindOfForeignCode+ = ForeignFileHeaderPragma+ -- ^ A pragma that must appear before the module header.+ | ForeignImport+ -- ^ An import statement. Must appear right after the module header.+ | ForeignOther+ -- ^ The rest. To appear after the import statements.++-- | Classify a @FOREIGN GHC@ declaration.+classifyForeign :: String -> KindOfForeignCode+classifyForeign s0 = case ltrim s0 of+ s | "import " `List.isPrefixOf` s -> ForeignImport+ s | "{-#" `List.isPrefixOf` s -> classifyPragma $ drop 3 s+ _ -> ForeignOther++-- | Classify a Haskell pragma into whether it is a file header pragma or not.+classifyPragma :: String -> KindOfForeignCode+classifyPragma s0 = case ltrim s0 of+ s | any (`List.isPrefixOf` s) fileHeaderPragmas -> ForeignFileHeaderPragma+ _ -> ForeignOther+ where+ fileHeaderPragmas =+ [ "LANGUAGE"+ , "OPTIONS_GHC"+ , "INCLUDE"+ ]++-- | Partition a list by 'KindOfForeignCode' attribute.+partitionByKindOfForeignCode :: (a -> KindOfForeignCode) -> [a] -> ([a], [a], [a])+partitionByKindOfForeignCode f = partition3 $ toThree . f+ where+ toThree = \case+ ForeignFileHeaderPragma -> One+ ForeignImport -> Two+ ForeignOther -> Three
@@ -1,17 +1,243 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ ------------------------------------------------------------------------ -- Pretty-printing of Haskell modules ------------------------------------------------------------------------ module Agda.Compiler.MAlonzo.Pretty where -import Data.Generics-import qualified Language.Haskell.Exts.Pretty as Pretty+import qualified Agda.Utils.Haskell.Syntax as HS import Agda.Compiler.MAlonzo.Encode+import Agda.Syntax.Common.Pretty --- | Inserts disambiguating parentheses and encodes module names just--- before pretty-printing.+import Agda.Utils.Null (empty)+import Agda.Utils.Function (applyWhen) -prettyPrint :: (Pretty.Pretty a, Data a) => a -> String-prettyPrint = Pretty.prettyPrint .- everywhere (mkT encodeModuleName)++prettyPrint :: Pretty a => a -> String+prettyPrint = show . pretty++instance Pretty HS.Module where+ pretty (HS.Module m pragmas imps decls) =+ vcat $ concat+ [ map pretty pragmas+ , [ "" | not $ null pragmas ]+ , [ "module" <+> pretty m <+> "where" ]+ , [ "" ]+ , map pretty imps+ , [ "" ]+ , map pretty decls+ ]++instance Pretty HS.ModulePragma where+ pretty (HS.LanguagePragma ps) =+ "{-#" <+> "LANGUAGE" <+> fsep (punctuate comma $ map pretty ps) <+> "#-}"+ pretty (HS.OtherPragma p) =+ text p++instance Pretty HS.ImportDecl where+ pretty HS.ImportDecl{ HS.importModule = m+ , HS.importQualified = q+ , HS.importSpecs = specs } =+ hsep [ "import"+ , if q then "qualified" else empty+ , pretty m+ , maybe empty prSpecs specs ]+ where prSpecs (hide, specs) =+ hsep [ if hide then "hiding" else empty+ , parens $ fsep $ punctuate comma $ map pretty specs ]++instance Pretty HS.ImportSpec where+ pretty (HS.IVar x) = pretty x++instance Pretty HS.Decl where+ pretty = \case+ HS.TypeDecl f xs t ->+ sep [ "type" <+> pretty f <+> fsep (map pretty xs) <+> "="+ , nest 2 $ pretty t ]+ HS.DataDecl newt d xs cons derv ->+ sep [ pretty newt <+> pretty d <+> fsep (map pretty xs)+ , nest 2 $ if null cons then empty+ else "=" <+> fsep (punctuate " |" $ map pretty cons)+ , nest 2 $ prDeriving derv ]+ where+ prDeriving [] = empty+ prDeriving ds = "deriving" <+> parens (fsep $ punctuate comma $ map prDer ds)+ prDer (d, ts) = pretty (foldl HS.TyApp (HS.TyCon d) ts)+ HS.TypeSig fs t ->+ sep [ hsep (punctuate comma (map pretty fs)) <+> "::"+ , nest 2 $ pretty t ]+ HS.FunBind ms -> vcat $ map pretty ms+ HS.LocalBind s f rhs ->+ sep [ pretty s <> pretty f+ , nest 2 $ prettyRhs "=" rhs+ ]+ HS.PatSyn p1 p2 -> sep [ "pattern" <+> pretty p1 <+> "=" <+> pretty p2 ]+ HS.FakeDecl s -> text s+ HS.Comment s -> vcat $ map (("--" <+>) . text) (lines s)++instance Pretty HS.ConDecl where+ pretty (HS.ConDecl c sts) =+ pretty c <+>+ fsep (map (\(s, t) -> maybe empty pretty s <> prettyPrec 10 t) sts)++instance Pretty HS.Strictness where+ pretty HS.Strict = "!"+ pretty HS.Lazy = empty++instance Pretty HS.Match where+ pretty (HS.Match f ps rhs wh) =+ prettyWhere wh $+ sep [ pretty f <+> fsep (map (prettyPrec 10) ps)+ , nest 2 $ prettyRhs "=" rhs ]++prettyWhere :: Maybe HS.Binds -> Doc -> Doc+prettyWhere Nothing doc = doc+prettyWhere (Just b) doc =+ vcat [ doc, nest 2 $ sep [ "where", nest 2 $ pretty b ] ]++instance Pretty HS.Pat where+ prettyPrec pr pat =+ case pat of+ HS.PVar x -> pretty x+ HS.PLit l -> prettyPrec pr l+ HS.PAsPat x p -> mparens (pr > 10) $ pretty x <> "@" <> prettyPrec 11 p+ HS.PWildCard -> "_"+ HS.PBangPat p -> "!" <> prettyPrec 11 p+ HS.PApp c ps -> mparens (pr > 9) $ pretty c <+> hsep (map (prettyPrec 10) ps)+ HS.PatTypeSig p t -> mparens (pr > 0) $ sep [ pretty p <+> "::", nest 2 $ pretty t ]+ HS.PIrrPat p -> mparens (pr > 10) $ "~" <> prettyPrec 11 p++prettyRhs :: String -> HS.Rhs -> Doc+prettyRhs eq (HS.UnGuardedRhs e) = text eq <+> pretty e+prettyRhs eq (HS.GuardedRhss rhss) = vcat $ map (prettyGuardedRhs eq) rhss++prettyGuardedRhs :: String -> HS.GuardedRhs -> Doc+prettyGuardedRhs eq (HS.GuardedRhs ss e) =+ sep [ "|" <+> sep (punctuate comma $ map pretty ss) <+> text eq+ , nest 2 $ pretty e ]++instance Pretty HS.Binds where+ pretty (HS.BDecls ds) = vcat $ map pretty ds++instance Pretty HS.DataOrNew where+ pretty HS.DataType = "data"+ pretty HS.NewType = "newtype"++instance Pretty HS.TyVarBind where+ pretty (HS.UnkindedVar x) = pretty x++instance Pretty HS.Type where+ prettyPrec pr t =+ case t of+ HS.TyForall xs t ->+ mparens (pr > 0) $+ sep [ ("forall" <+> fsep (map pretty xs)) <> "."+ , nest 2 $ pretty t ]+ HS.TyFun a b ->+ mparens (pr > 4) $+ sep [ prettyPrec 5 a <+> "->", prettyPrec 4 b ]+ HS.TyCon c -> pretty c+ HS.TyVar x -> pretty x+ HS.TyApp (HS.TyCon (HS.UnQual (HS.Ident "[]"))) t ->+ brackets $ pretty t+ t@HS.TyApp{} ->+ mparens (pr > 9) $+ sep [ prettyPrec 9 f+ , nest 2 $ fsep $ map (prettyPrec 10) ts ]+ where+ f : ts = appView t []+ appView (HS.TyApp a b) as = appView a (b : as)+ appView t as = t : as+ HS.FakeType s -> text s++instance Pretty HS.Stmt where+ pretty (HS.Qualifier e) = pretty e+ pretty (HS.Generator p e) = sep [ pretty p <+> "<-", nest 2 $ pretty e ]++instance Pretty HS.Literal where+ prettyPrec pr = \case+ HS.Int n -> parensIfNeg n $ integer n+ HS.Frac x -> parensIfNeg d $ double d+ where+ d = fromRational x+ HS.Char c -> text (show c)+ HS.String s -> text (show s)+ where+ parensIfNeg :: (Ord n, Num n) => n -> Doc -> Doc+ parensIfNeg x = applyWhen (x < 0) $ mparens (pr > 10)++instance Pretty HS.Exp where+ prettyPrec pr e =+ case e of+ HS.Var x -> pretty x+ HS.Con c -> pretty c+ HS.Lit l -> pretty l+ HS.InfixApp a qop b -> mparens (pr > 0) $+ sep [ prettyPrec 1 a+ , pretty qop <+> prettyPrec 1 b ]+ HS.Ann e ty -> mparens (pr > 0) $+ sep [ prettyPrec 1 e+ , "::"+ , prettyPrec 1 ty+ ]+ HS.App{} -> mparens (pr > 9) $+ sep [ prettyPrec 9 f+ , nest 2 $ fsep $ map (prettyPrec 10) es ]+ where+ f : es = appView e []+ appView (HS.App f e) es = appView f (e : es)+ appView f es = f : es+ HS.Lambda ps e -> mparens (pr > 0) $+ sep [ "\\" <+> fsep (map (prettyPrec 10) ps) <+> "->"+ , nest 2 $ pretty e ]+ HS.Let bs e -> mparens (pr > 0) $+ sep [ "let" <+> pretty bs <+> "in"+ , pretty e ]+ HS.If a b c -> mparens (pr > 0) $+ sep [ "if" <+> pretty a+ , nest 2 $ "then" <+> pretty b+ , nest 2 $ "else" <+> prettyPrec 1 c ]+ HS.Case e bs -> mparens (pr > 0) $+ vcat [ "case" <+> pretty e <+> "of"+ , nest 2 $ vcat $ map pretty bs ]+ HS.ExpTypeSig e t -> mparens (pr > 0) $+ sep [ pretty e <+> "::"+ , nest 2 $ pretty t ]+ HS.NegApp exp -> parens $ "-" <> pretty exp+ HS.FakeExp s -> text s++instance Pretty HS.Alt where+ pretty (HS.Alt pat rhs wh) =+ prettyWhere wh $+ sep [ pretty pat, nest 2 $ prettyRhs "->" rhs ]++instance Pretty HS.ModuleName where+ pretty m = text s+ where HS.ModuleName s = encodeModuleName m++instance Pretty HS.QName where+ pretty q = mparens (isOperator q) (prettyQName q)++instance Pretty HS.Name where+ pretty (HS.Ident s) = text s+ pretty (HS.Symbol s) = text s++instance Pretty HS.QOp where+ pretty (HS.QVarOp x)+ | isOperator x = prettyQName x+ | otherwise = "`" <> prettyQName x <> "`"++isOperator :: HS.QName -> Bool+isOperator q =+ case q of+ HS.Qual _ x -> isOp x+ HS.UnQual x -> isOp x+ where+ isOp HS.Symbol{} = True+ isOp HS.Ident{} = False++prettyQName :: HS.QName -> Doc+prettyQName (HS.Qual m x) = pretty m <> "." <> pretty x+prettyQName (HS.UnQual x) = pretty x
@@ -1,249 +1,332 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ module Agda.Compiler.MAlonzo.Primitives where -import Control.Monad.Reader-import Control.Monad.State-import Data.Char-import Data.List as L-import Data.Map as M-import qualified Language.Haskell.Exts.Syntax as HS+import Control.Monad.Trans.Maybe ( MaybeT(MaybeT, runMaybeT) ) -import {-# SOURCE #-} Agda.Compiler.MAlonzo.Compiler (term)+import Data.HashMap.Strict qualified as HMap+import Data.List qualified as List+import Data.Map qualified as Map+import Data.Maybe+import Data.Set (Set)+import Data.Set qualified as Set++import Agda.Compiler.Common import Agda.Compiler.MAlonzo.Misc-import Agda.Compiler.MAlonzo.Pretty import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty ( prettyShow ) import Agda.Syntax.Internal+import Agda.Syntax.Treeless import Agda.TypeChecking.Monad-import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Primitive import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Pretty-import Agda.Utils.Monad +import Agda.Utils.Either+import Agda.Utils.List ( hasElem )+import Agda.Utils.Haskell.Syntax qualified as HS++import Agda.Utils.Impossible++---------------------------------------------------------------------------+-- * Entrypoint (@main@)++newtype MainFunctionDef = MainFunctionDef Definition++data CheckedMainFunctionDef = CheckedMainFunctionDef+ { checkedMainDef :: MainFunctionDef+ , checkedMainDecl :: HS.Decl+ }++-- Andreas, 2019-04-29, issue #3731: exclude certain kinds of names, like constructors.+-- TODO: Also only consider top-level definition (not buried inside a module).+asMainFunctionDef :: Definition -> Maybe MainFunctionDef+asMainFunctionDef d = case (theDef d) of+ Axiom{} -> perhaps+ Function{ funProjection = Left _ } -> perhaps+ Function{ funProjection = Right{} } -> no+ AbstractDefn{} -> no+ GeneralizableVar{} -> no+ DataOrRecSig{} -> no+ Datatype{} -> no+ Record{} -> no+ Constructor{} -> no+ Primitive{} -> no+ PrimitiveSort{} -> no+ where+ isNamedMain = "main" == prettyShow (nameConcrete . qnameName . defName $ d) -- ignores the qualification!?+ perhaps | isNamedMain = Just $ MainFunctionDef d+ | otherwise = no+ no = Nothing++mainFunctionDefs :: Interface -> [MainFunctionDef]+mainFunctionDefs i = catMaybes $ asMainFunctionDef <$> defs+ where+ defs = HMap.elems $ iSignature i ^. sigDefinitions+ -- | Check that the main function has type IO a, for some a.-checkTypeOfMain :: QName -> Type -> TCM ()-checkTypeOfMain q ty- | show (qnameName q) /= "main" = return ()- | otherwise = do+checkTypeOfMain :: Definition -> HsCompileM (Maybe CheckedMainFunctionDef)+checkTypeOfMain def = runMaybeT $ do+ -- Only indicate main functions in the main module.+ isMainModule <- curIsMainModule+ mainDef <- MaybeT $ pure $ if isMainModule then asMainFunctionDef def else Nothing+ liftTCM $ checkTypeOfMain' mainDef++checkTypeOfMain' :: MainFunctionDef -> TCM CheckedMainFunctionDef+checkTypeOfMain' m@(MainFunctionDef def) = CheckedMainFunctionDef m <$> do Def io _ <- primIO- ty <- normalise ty+ ty <- reduce $ defType def case unEl ty of- Def d _ | d == io -> return ()- _ -> do- err <- fsep $- pwords "The type of main should be" ++- [prettyTCM io] ++ pwords " A, for some A. The given type is" ++ [prettyTCM ty]- typeError $ GenericError $ show err+ Def d _ | d == io -> return mainAlias+ _ -> ghcBackendError $ WrongTypeOfMain io ty+ where+ mainAlias = HS.FunBind [HS.Match mainLHS [] mainRHS emptyBinds ]+ mainLHS = HS.Ident "main"+ mainRHS = HS.UnGuardedRhs $ HS.App mazCoerce (HS.Var $ HS.UnQual $ dname $ defName def) --- Haskell modules to be imported for BUILT-INs-importsForPrim :: TCM [HS.ModuleName]-importsForPrim =- xForPrim $- L.map (\(s, ms) -> (s, return (L.map HS.ModuleName ms))) $- [ "CHAR" |-> ["Data.Char"]- -- , "IO" |-> ["System.IO"]+---------------------------------------------------------------------------+-- * Primitives and builtins++-- | These builtins need a qualified import of "Data.Char".+charBuiltins :: [SomeBuiltin]+charBuiltins =+ [ someBuiltin BuiltinChar+ , someBuiltin PrimIsAlpha+ , someBuiltin PrimIsAscii+ , someBuiltin PrimIsDigit+ , someBuiltin PrimIsHexDigit+ , someBuiltin PrimIsLatin1+ , someBuiltin PrimIsLower+ , someBuiltin PrimIsPrint+ , someBuiltin PrimIsSpace+ , someBuiltin PrimToLower+ , someBuiltin PrimToUpper ]- where (|->) = (,) --- Declarations of helper functions for BUILT-INs-declsForPrim :: TCM [HS.Decl]-declsForPrim = xForPrim $- [ "NATURAL" |-> (++) <$> natToFrom "Integer" mazNatToInteger mazIntegerToNat- <*> natToFrom "Int" mazNatToInt mazIntToNat- , "LIST" |-> forList mazListToHList mazHListToList- , "STRING" |-> forList mazListToString mazStringToList- , "BOOL" |-> decls ["TRUE", "FALSE"]- mazBoolToHBool "let { f <<0>> = True; f <<1>> = False; } in f"- mazHBoolToBool "let { f True = <<0>>; f False = <<1>>; } in f"- , "CHAR" |-> return- [ fakeDS mazCharToInteger- "(fromIntegral . Data.Char.ord :: Char -> Integer)"- ]+-- | These builtins need a qualified import of "MAlonzo.RTE.Float".+floatBuiltins :: [SomeBuiltin]+floatBuiltins =+ [ someBuiltin PrimFloatCeiling+ , someBuiltin PrimFloatDecode+ , someBuiltin PrimFloatEncode+ , someBuiltin PrimFloatEquality+ , someBuiltin PrimFloatFloor+ , someBuiltin PrimFloatInequality+ , someBuiltin PrimFloatIsSafeInteger+ , someBuiltin PrimFloatLess+ , someBuiltin PrimFloatRound+ , someBuiltin PrimFloatToRatio+ , someBuiltin PrimFloatToWord64+ , someBuiltin PrimRatioToFloat ]- where- infix 1 |->- (|->) = (,)- forList toH toA = decls ["NIL", "CONS"]- toH (concat- ["let { f <<0>> = [];"- ," f (<<1>> x xs) = x : f (" ++ prettyPrint mazCoerce ++ " xs)"- ,"} in f"])- toA (concat- ["let { f [] = <<0>>;"- ," f (c:cs) = <<1>> c (" ++ prettyPrint mazCoerce ++ " (f cs));"- ,"} in f"])- natToFrom hty to from = let- totxt = repl ["<<0>>", "<<1>>", hty, to] $ concat- [ "\\ x -> case x of { <<0>> -> 0 :: <<2>>; "- , "<<1>> x -> 1 + (<<3>> (" ++ prettyPrint mazCoerce ++ " x)) }" ]- fromtxt = repl ["<<0>>", "<<1>>", hty, from] $ concat- [ "\\ x -> if x <= (0 :: <<2>>) then <<0>> "- , "else <<1>> (" ++ prettyPrint mazCoerce ++ " (<<3>> (x - 1)))" ]- in do- ds <- decls ["ZERO", "SUC"] to totxt from fromtxt- let rule name = HS.Rule name HS.AlwaysActive (Just [HS.RuleVar $ HS.Ident "x"])- var = HS.Var . HS.UnQual . HS.Ident- (%) = HS.App- return $ [HS.RulePragmaDecl dummy- [ rule (to ++ "-" ++ from) (var to % (var from % var "x")) (var "x")- , rule (from ++ "-" ++ to) (var from % (var to % var "x")) (var "x")- ]] ++ ds- decls cs n1 b1 n2 b2 =- do cs' <- mapM pconName cs- return $ zipWith (\ n -> fakeDS n . repl cs') [n1, n2] [b1, b2] -mazNatToInteger = "mazNatToInteger"-mazIntegerToNat = "mazIntegerToNat"-mazNatToInt = "mazNatToInt"-mazIntToNat = "mazIntToNat"-mazCharToInteger = "mazCharToInteger"-mazListToHList = "mazListToHList"-mazHListToList = "mazHListToList"-mazListToString = "mazListToString"-mazStringToList = "mazStringToList"-mazBoolToHBool = "mazBoolToHBool"-mazHBoolToBool = "mazHBoolToBool"+-- | Which builtins are actually used in the definitions?+usedBuiltins :: BuiltinThings -> [Definition] -> Set SomeBuiltin+usedBuiltins builtinThings defs = Set.fromList+ [ s+ | (s, def) <- Map.toList builtinThings+ , maybe False elemDefs $ getName def+ ]+ where+ elemDefs = hasElem $ map defName defs+ getName = \case+ Builtin t -> Just $ getPrimName t+ Prim (PrimFun q _ _ _) -> Just q+ BuiltinRewriteRelations _ -> Nothing ---------------+-- ** Translating primitives -xForPrim :: [(String, TCM [a])] -> TCM [a]-xForPrim table = do- qs <- keys <$> curDefs- bs <- toList <$> gets stBuiltinThings- concat <$> sequence [ maybe (return []) id $ L.lookup s table- | (s, Builtin (Def q _)) <- bs, q `elem` qs ]+treelessPrimName :: TPrim -> String+treelessPrimName p =+ case p of+ PQuot -> "quotInt"+ PRem -> "remInt"+ PSub -> "subInt"+ PAdd -> "addInt"+ PMul -> "mulInt"+ PGeq -> "geqInt"+ PLt -> "ltInt"+ PEqI -> "eqInt"+ PQuot64 -> "quot64"+ PRem64 -> "rem64"+ PSub64 -> "sub64"+ PAdd64 -> "add64"+ PMul64 -> "mul64"+ PLt64 -> "lt64"+ PEq64 -> "eq64"+ PITo64 -> "word64FromNat"+ P64ToI -> "word64ToNat"+ PEqF -> "MAlonzo.RTE.Float.doubleDenotEq"+ -- MAlonzo uses literal patterns, so we don't need equality for the other primitive types+ PEqC -> __IMPOSSIBLE__+ PEqS -> __IMPOSSIBLE__+ PEqQ -> __IMPOSSIBLE__+ PSeq -> "seq"+ -- primitives only used by GuardsToPrims transformation, which MAlonzo doesn't use+ PIf -> __IMPOSSIBLE__ --- Definition bodies for primitive functions-primBody :: String -> TCM HS.Exp-primBody s = maybe unimplemented (either (hsVarUQ . HS.Ident) id <$>) $- L.lookup s $+-- | Definition bodies for primitive functions+primBody :: MonadTCError m => PrimitiveId -> m HS.Exp+primBody s = maybe unimplemented (fromRight (hsVarUQ . HS.Ident) <$>) $ List.lookup s $ [ -- Integer functions- "primIntegerPlus" |-> binAsis "(+)" "Integer"- , "primIntegerMinus" |-> binAsis "(-)" "Integer"- , "primIntegerTimes" |-> binAsis "(*)" "Integer"- , "primIntegerDiv" |-> binAsis "div" "Integer"- , "primIntegerMod" |-> binAsis "mod" "Integer"- , "primIntegerEquality"|-> rel "(==)" "Integer"- , "primIntegerLess" |-> rel "(<)" "Integer"- , "primIntegerAbs" |-> do toN <- bltQual' "NATURAL" mazIntegerToNat- return $ repl [toN] $ "\\ x -> <<0>> (abs x)"- , "primNatToInteger" |-> bltQual' "NATURAL" mazNatToInteger- , "primShowInteger" |-> return "(show :: Integer -> String)"+ PrimShowInteger |-> return "(Data.Text.pack . show :: Integer -> Data.Text.Text)" + -- Levels+ , PrimLevelZero |-> return "()"+ , PrimLevelSuc |-> return "(\\ _ -> ())"+ , PrimLevelMax |-> return "(\\ _ _ -> ())"+ -- Natural number functions- , "primNatPlus" |-> binNat "(+)"- , "primNatMinus" |-> binNat "(-)"- , "primNatTimes" |-> binNat "(*)"- , "primNatDivSuc" |-> binNat "(\\ x y -> div x (y + 1))"- , "primNatModSuc" |-> binNat "(\\ x y -> mod x (y + 1))"- , "primNatEquality" |-> relNat "(==)"- , "primNatLess" |-> relNat "(<)"+ , PrimNatPlus |-> binNat "(+)"+ , PrimNatMinus |-> binNat "(\\ x y -> max 0 (x - y))"+ , PrimNatTimes |-> binNat "(*)"+ , PrimNatDivSucAux |-> binNat4 "(\\ k m n j -> k + div (max 0 $ n + m - j) (m + 1))"+ , PrimNatModSucAux |-> binNat4 "(\\ k m n j -> if n > j then mod (n - j - 1) (m + 1) else (k + n))"+ , PrimNatEquality |-> relNat "(==)"+ , PrimNatLess |-> relNat "(<)"+ , PrimShowNat |-> return "(Data.Text.pack . show :: Integer -> Data.Text.Text)" + -- Machine word functions+ , PrimWord64ToNat |-> return "MAlonzo.RTE.word64ToNat"+ , PrimWord64FromNat |-> return "MAlonzo.RTE.word64FromNat"+ , PrimWord64ToNatInjective |-> return mazErasedName+ -- Floating point functions- , "primIntegerToFloat" |-> return "(fromIntegral :: Integer -> Double)"- , "primFloatPlus" |-> return "((+) :: Double -> Double -> Double)"- , "primFloatMinus" |-> return "((-) :: Double -> Double -> Double)"- , "primFloatTimes" |-> return "((*) :: Double -> Double -> Double)"- , "primFloatDiv" |-> return "((/) :: Double -> Double -> Double)"- , "primFloatLess" |-> rel "(<)" "Double"- , "primRound" |-> return "(round :: Double -> Integer)"- , "primFloor" |-> return "(floor :: Double -> Integer)"- , "primCeiling" |-> return "(ceiling :: Double -> Integer)"- , "primExp" |-> return "(exp :: Double -> Double)"- , "primLog" |-> return "(log :: Double -> Double)" -- partial- , "primSin" |-> return "(sin :: Double -> Double)"- , "primShowFloat" |-> return "(show :: Double -> String)"- , "primRound" |-> return "(round :: Double -> Integer)"+ , PrimFloatEquality |-> return "MAlonzo.RTE.Float.doubleEq"+ , PrimFloatInequality |-> return "MAlonzo.RTE.Float.doubleLe"+ , PrimFloatLess |-> return "MAlonzo.RTE.Float.doubleLt"+ , PrimFloatIsInfinite |-> return "(isInfinite :: Double -> Bool)"+ , PrimFloatIsNaN |-> return "(isNaN :: Double -> Bool)"+ , PrimFloatIsNegativeZero |-> return "(isNegativeZero :: Double -> Bool)"+ , PrimFloatIsSafeInteger |-> return "MAlonzo.RTE.Float.isSafeInteger"+ , PrimFloatToWord64 |-> return "MAlonzo.RTE.Float.doubleToWord64"+ , PrimFloatToWord64Injective |-> return mazErasedName+ , PrimNatToFloat |-> return "(MAlonzo.RTE.Float.intToDouble :: Integer -> Double)"+ , PrimIntToFloat |-> return "(MAlonzo.RTE.Float.intToDouble :: Integer -> Double)"+ , PrimFloatRound |-> return "MAlonzo.RTE.Float.doubleRound"+ , PrimFloatFloor |-> return "MAlonzo.RTE.Float.doubleFloor"+ , PrimFloatCeiling |-> return "MAlonzo.RTE.Float.doubleCeiling"+ , PrimFloatToRatio |-> return "MAlonzo.RTE.Float.doubleToRatio"+ , PrimRatioToFloat |-> return "MAlonzo.RTE.Float.ratioToDouble"+ , PrimFloatDecode |-> return "MAlonzo.RTE.Float.doubleDecode"+ , PrimFloatEncode |-> return "MAlonzo.RTE.Float.doubleEncode"+ , PrimShowFloat |-> return "(Data.Text.pack . show :: Double -> Data.Text.Text)"+ , PrimFloatPlus |-> return "MAlonzo.RTE.Float.doublePlus"+ , PrimFloatMinus |-> return "MAlonzo.RTE.Float.doubleMinus"+ , PrimFloatTimes |-> return "MAlonzo.RTE.Float.doubleTimes"+ , PrimFloatNegate |-> return "MAlonzo.RTE.Float.doubleNegate"+ , PrimFloatDiv |-> return "MAlonzo.RTE.Float.doubleDiv"+ , PrimFloatPow |-> return "MAlonzo.RTE.Float.doublePow"+ , PrimFloatSqrt |-> return "MAlonzo.RTE.Float.doubleSqrt"+ , PrimFloatExp |-> return "MAlonzo.RTE.Float.doubleExp"+ , PrimFloatLog |-> return "MAlonzo.RTE.Float.doubleLog"+ , PrimFloatSin |-> return "MAlonzo.RTE.Float.doubleSin"+ , PrimFloatCos |-> return "MAlonzo.RTE.Float.doubleCos"+ , PrimFloatTan |-> return "MAlonzo.RTE.Float.doubleTan"+ , PrimFloatASin |-> return "MAlonzo.RTE.Float.doubleASin"+ , PrimFloatACos |-> return "MAlonzo.RTE.Float.doubleACos"+ , PrimFloatATan |-> return "MAlonzo.RTE.Float.doubleATan"+ , PrimFloatATan2 |-> return "MAlonzo.RTE.Float.doubleATan2"+ , PrimFloatSinh |-> return "MAlonzo.RTE.Float.doubleSinh"+ , PrimFloatCosh |-> return "MAlonzo.RTE.Float.doubleCosh"+ , PrimFloatTanh |-> return "MAlonzo.RTE.Float.doubleTanh"+ , PrimFloatASinh |-> return "MAlonzo.RTE.Float.doubleASinh"+ , PrimFloatACosh |-> return "MAlonzo.RTE.Float.doubleACosh"+ , PrimFloatATanh |-> return "MAlonzo.RTE.Float.doubleATanh" -- Character functions- , "primCharEquality" |-> rel "(==)" "Char"- , "primIsLower" |-> pred "Data.Char.isLower"- , "primIsDigit" |-> pred "Data.Char.isDigit"- , "primIsAlpha" |-> pred "Data.Char.isAlpha"- , "primIsSpace" |-> pred "Data.Char.isSpace"- , "primIsAscii" |-> pred "Data.Char.isAscii"- , "primIsLatin1" |-> pred "Data.Char.isLatin1"- , "primIsPrint" |-> pred "Data.Char.isPrint"- , "primIsHExDigit" |-> pred "Data.Char.isHexDigit"- , "primToUpper" |-> return "Data.Char.toUpper"- , "primToLower" |-> return "Data.Char.toLower"- , "primCharToNat" |-> do toN <- bltQual' "NATURAL" mazIntToNat- return $ repl [toN] $- "(\\ x -> <<0>> ((fromEnum :: Char -> Int) x))"- , "primNatToChar" |-> do toI <- bltQual' "NATURAL" mazNatToInt- return $ repl[toI] $- "(\\ x -> (toEnum :: Int -> Char) (<<0>> x))"- , "primShowChar" |-> return "(show :: Char -> String)"+ , PrimCharEquality |-> rel "(==)" "Char"+ , PrimIsLower |-> return "Data.Char.isLower"+ , PrimIsDigit |-> return "Data.Char.isDigit"+ , PrimIsAlpha |-> return "Data.Char.isAlpha"+ , PrimIsSpace |-> return "Data.Char.isSpace"+ , PrimIsAscii |-> return "Data.Char.isAscii"+ , PrimIsLatin1 |-> return "Data.Char.isLatin1"+ , PrimIsPrint |-> return "Data.Char.isPrint"+ , PrimIsHexDigit |-> return "Data.Char.isHexDigit"+ , PrimToUpper |-> return "Data.Char.toUpper"+ , PrimToLower |-> return "Data.Char.toLower"+ , PrimCharToNat |-> return "(fromIntegral . fromEnum :: Char -> Integer)"+ , PrimNatToChar |-> return "MAlonzo.RTE.natToChar"+ , PrimShowChar |-> return "(Data.Text.pack . show :: Char -> Data.Text.Text)"+ , PrimCharToNatInjective |-> return mazErasedName -- String functions- , "primStringToList" |-> bltQual' "STRING" mazStringToList- , "primStringFromList" |-> bltQual' "STRING" mazListToString- , "primStringAppend" |-> binAsis "(++)" "String"- , "primStringEquality" |-> rel "(==)" "String"- , "primShowString" |-> return "(show :: String -> String)"+ , PrimStringUncons |-> return "Data.Text.uncons"+ , PrimStringToList |-> return "Data.Text.unpack"+ , PrimStringFromList |-> return "Data.Text.pack"+ , PrimStringAppend |-> binAsis "Data.Text.append" "Data.Text.Text"+ , PrimStringEquality |-> rel "(==)" "Data.Text.Text"+ , PrimShowString |-> return "(Data.Text.pack . show :: Data.Text.Text -> Data.Text.Text)"+ , PrimStringToListInjective |-> return mazErasedName+ , PrimStringFromListInjective |-> return mazErasedName -- Reflection- , "primQNameEquality" |-> rel "(==)" "MAlonzo.RTE.QName () ()"- , "primQNameType" |-> return "MAlonzo.RTE.qnameType"- , "primQNameDefinition" |-> return "MAlonzo.RTE.qnameDefinition"+ , PrimQNameEquality |-> rel "(==)" "MAlonzo.RTE.QName"+ , PrimQNameLess |-> rel "(<)" "MAlonzo.RTE.QName"+ , PrimShowQName |-> return "Data.Text.pack . MAlonzo.RTE.qnameString"+ , PrimQNameFixity |-> return "MAlonzo.RTE.qnameFixity"+ , PrimQNameToWord64s |-> return "\\ qn -> (MAlonzo.RTE.nameId qn, MAlonzo.RTE.moduleId qn)"+ , PrimQNameToWord64sInjective |-> return mazErasedName+ , PrimMetaEquality |-> rel "(==)" "(Integer, Integer)"+ , PrimMetaLess |-> rel "(<)" "(Integer, Integer)"+ -- Should be kept in sync with version in `primitiveFunctions` in+ -- Agda.TypeChecking.Primitive+ , PrimShowMeta |-> return "\\ (m, h) -> Data.Text.pack (\"_\" ++ show (m :: Integer) ++ \"@\" ++ show (h :: Integer))"+ -- Should be kept in sync with `metaToNat` in Agda.TypeChecking.Primitive+ , PrimMetaToNat |-> return "\\ (m, h) -> (h :: Integer) * 2^64 + (m :: Integer)"+ , PrimMetaToNatInjective |-> return mazErasedName - , "primDataConstructors" |-> return "(error \"primDataConstructors: not implemented\")"+ -- Seq+ , PrimForce |-> return "\\ _ _ _ _ x f -> f $! x"+ , PrimForceLemma |-> return mazErasedName - -- Trust me- , ("primTrustMe" , Right <$> do- refl <- primRefl- flip runReaderT 0 $- term $ lam "a" (lam "A" (lam "x" (lam "y" refl))))+ -- Lock universe+ , PrimLockUniv |-> return "()"++ -- Erase+ , PrimEraseEquality |-> return mazErasedName++ -- Rewriting+ , PrimRewriteNoMatch |-> return "\\ _ _ x -> x"++ -- Quotients+ , PrimQrec |-> return "\\_ _ _ _ _ _ f _ _ x -> f x"++ -- Cubical+ , PrimIMin |-> return "(&&)"+ , PrimIMax |-> return "(||)"+ , PrimINeg |-> return "not"+ , PrimPartial |-> return "\\_ _ x -> x"+ , PrimPartialP |-> return "\\_ _ x -> x"+ , PrimPOr |-> return "\\_ i _ _ x y -> if i then x else y"+ , PrimComp |-> return "\\_ _ _ _ x -> x"+ , PrimTrans |-> return "\\_ _ _ x -> x"+ , PrimHComp |-> return "\\_ _ _ _ x -> x"+ , PrimSubOut |-> return "\\_ _ _ _ x -> x"+ , Prim_glueU |-> return "\\_ _ _ _ _ x -> x"+ , Prim_unglueU |-> return "\\_ _ _ _ x -> x"+ , PrimFaceForall |-> return+ "\\f -> f True == True && f False == True" ] where x |-> s = (x, Left <$> s)- bin blt op ty from to = do- from' <- bltQual' blt from- to' <- bltQual' blt to- return $ repl [op, opty ty, from', to'] $- "\\ x y -> <<3>> ((<<0>> :: <<1>>) (<<2>> x) (<<2>> y))"- binNat op = bin "NATURAL" op "Integer" mazNatToInteger mazIntegerToNat+ binNat op = return $ repl [op] "(<<0>> :: Integer -> Integer -> Integer)"+ binNat4 op = return $ repl [op] "(<<0>> :: Integer -> Integer -> Integer -> Integer -> Integer)" binAsis op ty = return $ repl [op, opty ty] $ "((<<0>>) :: <<1>>)" rel' toTy op ty = do- toHB <- bltQual' "BOOL" mazHBoolToBool- return $ repl [op, ty, toHB, toTy] $- "(\\ x y -> <<2>> ((<<0>> :: <<1>> -> <<1>> -> Bool) (<<3>> x) (<<3>> y)))"- relNat op = do toHI <- bltQual' "NATURAL" mazNatToInteger- rel' toHI op "Integer"+ return $ repl [op, ty, toTy] $+ "(\\ x y -> (<<0>> :: <<1>> -> <<1>> -> Bool) (<<2>> x) (<<2>> y))"+ relNat op = do+ return $ repl [op] $+ "(<<0>> :: Integer -> Integer -> Bool)" rel op ty = rel' "" op ty- pred p = do toHB <- bltQual' "BOOL" mazHBoolToBool- return $ repl [p, toHB] $ "(\\ x -> <<1>> (<<0>> x))" opty t = t ++ "->" ++ t ++ "->" ++ t- unimplemented = typeError $ NotImplemented s-- lam x t = Lam Hidden (Abs x t)- var x = Arg Hidden Relevant (Var x [])--------------------------repl subs = go where- go ('<':'<':c:'>':'>':s) | 0 <= i && i < length subs = subs !! i ++ go s- where i = ord c - ord '0'- go (c:s) = c : go s- go [] = []--pconName :: String -> TCM String-pconName s = toS =<< getBuiltin s where- toS (Con q _) = prettyPrint <$> conhqn q- toS (Lam _ t) = toS (unAbs t)- toS _ = mazerror $ "pconName" ++ s--hasCompiledData :: [String] -> TCM Bool-hasCompiledData (s:_) = toB =<< getBuiltin s where- toB (Con q _) = do- def <- getConstInfo =<< ignoreAbstractMode (canonicalName q)- return $ case compiledHaskell $ defCompiledRep def of- Just{} -> True- Nothing -> False- toB (Lam _ t) = toB (unAbs t)- toB _ = return False-hasCompiledData _ = return False+ unimplemented = typeError $ NotImplemented (getBuiltinId s) + hLam x t = Lam (setHiding Hidden defaultArgInfo) (Abs x t)+ nLam x t = Lam (setHiding NotHidden defaultArgInfo) (Abs x t) -bltQual' b s = prettyPrint <$> bltQual b s+noCheckCover :: (HasBuiltins m, MonadReduce m) => QName -> m Bool+noCheckCover q = (||) <$> isBuiltin q builtinNat <*> isBuiltin q builtinInteger
@@ -0,0 +1,91 @@+{-# OPTIONS_GHC -Wunused-imports #-}++------------------------------------------------------------------------+-- | Strictification of Haskell code+------------------------------------------------------------------------++module Agda.Compiler.MAlonzo.Strict where++import Agda.Utils.Haskell.Syntax++-- | The function 'makeStrict' makes every function argument and case+-- and generator pattern strict (except for those patterns that are+-- marked as irrefutable, and anything in a 'FakeDecl' or 'FakeExp').+-- Note that only the outermost patterns are made strict, and that+-- 'LocalBind' bindings are not made strict.++class MakeStrict a where+ makeStrict :: a -> a++instance MakeStrict a => MakeStrict [a] where+ makeStrict = map makeStrict++instance MakeStrict a => MakeStrict (Maybe a) where+ makeStrict = fmap makeStrict++instance MakeStrict Module where+ makeStrict (Module m pragmas imps decls) =+ Module m pragmas imps (makeStrict decls)++instance MakeStrict Decl where+ makeStrict = \case+ d@TypeDecl{} -> d+ d@DataDecl{} -> d+ d@TypeSig{} -> d+ FunBind ms -> FunBind (makeStrict ms)+ LocalBind s f rhs -> LocalBind s f (makeStrict rhs)+ d@PatSyn{} -> d+ d@FakeDecl{} -> d+ d@Comment{} -> d++instance MakeStrict Match where+ makeStrict (Match f ps rhs wh) =+ Match f (makeStrict ps) (makeStrict rhs) (makeStrict wh)++instance MakeStrict Pat where+ makeStrict = \case+ p@PVar{} -> PBangPat p+ p@PLit{} -> PBangPat p+ PAsPat x p -> PAsPat x (makeStrict p)+ p@PWildCard{} -> PBangPat p+ p@PBangPat{} -> p+ p@PApp{} -> PBangPat p+ PatTypeSig p t -> PatTypeSig (makeStrict p) t+ p@PIrrPat{} -> p++instance MakeStrict Binds where+ makeStrict (BDecls ds) = BDecls (makeStrict ds)++instance MakeStrict Rhs where+ makeStrict (UnGuardedRhs e) = UnGuardedRhs (makeStrict e)+ makeStrict (GuardedRhss rs) = GuardedRhss (makeStrict rs)++instance MakeStrict GuardedRhs where+ makeStrict (GuardedRhs ss e) =+ GuardedRhs (makeStrict ss) (makeStrict e)++instance MakeStrict Stmt where+ makeStrict = \case+ Qualifier e -> Qualifier (makeStrict e)+ Generator p e -> Generator (makeStrict p) (makeStrict e)++instance MakeStrict Exp where+ makeStrict e =+ case e of+ Var{} -> e+ Con{} -> e+ Lit{} -> e+ InfixApp a op b -> InfixApp (makeStrict a) op (makeStrict b)+ Ann e ty -> Ann (makeStrict e) ty+ App a b -> App (makeStrict a) (makeStrict b)+ Lambda ps e -> Lambda (makeStrict ps) (makeStrict e)+ Let bs e -> Let (makeStrict bs) (makeStrict e)+ If a b c -> If (makeStrict a) (makeStrict b) (makeStrict c)+ Case e bs -> Case (makeStrict e) (makeStrict bs)+ ExpTypeSig e t -> ExpTypeSig (makeStrict e) t+ NegApp e -> NegApp (makeStrict e)+ FakeExp s -> FakeExp s++instance MakeStrict Alt where+ makeStrict (Alt pat rhs wh) =+ Alt (makeStrict pat) (makeStrict rhs) (makeStrict wh)
@@ -0,0 +1,677 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.ToTreeless+ ( toTreelessWith+ , closedTermToTreeless+ , Pipeline(..)+ , CompilerPass(..)+ , compilerPass+ , CCConfig+ , CCSubst(..)+ -- * Default pipeline+ , compilerPipeline+ , mkDefaultCCConfig+ , toTreeless+ ) where++import Prelude hiding ((!!))++import Control.Monad.Reader ( MonadReader(..), asks, ReaderT, runReaderT )++import Data.Maybe+import Data.Map (Map)+import qualified Data.Map as Map++import Agda.Syntax.Common+import Agda.Syntax.Internal as I+import Agda.Syntax.Literal+import qualified Agda.Syntax.Treeless as C+import Agda.Syntax.Treeless (TTerm, EvaluationStrategy, ArgUsage(..))++import Agda.TypeChecking.CompiledClause as CC+import qualified Agda.TypeChecking.CompiledClause.Compile as CC+import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.EtaContract (binAppView, BinAppView(..))+import Agda.TypeChecking.Monad as TCM+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Records (getRecordConstructor)+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute++import Agda.Compiler.Treeless.AsPatterns+import Agda.Compiler.Treeless.Builtin+import Agda.Compiler.Treeless.Erase+import Agda.Compiler.Treeless.Identity+import Agda.Compiler.Treeless.Simplify+import Agda.Compiler.Treeless.Uncase+import Agda.Compiler.Treeless.Unused++import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Syntax.Common.Pretty (prettyShow)+import qualified Agda.Syntax.Common.Pretty as P+import qualified Agda.Utils.SmallSet as SmallSet++import Agda.Utils.Impossible++prettyPure :: P.Pretty a => a -> TCM Doc+prettyPure = return . P.pretty++-- | Recompile clauses with forcing translation turned on.+getCompiledClauses :: QName -> TCM CC.CompiledClauses+getCompiledClauses q = do+ def <- getConstInfo q+ let cs = defClauses def+ isProj | Function{ funProjection = Right x } <- theDef def = isJust (projProper x)+ | otherwise = False+ translate | isProj = CC.DontRunRecordPatternTranslation+ | otherwise = CC.RunRecordPatternTranslation+ reportSDoc "treeless.convert" 40 $ "-- before clause compiler" $$ (pretty q <+> "=") <?> vcat (map pretty cs)+ let mst = funSplitTree $ theDef def+ reportSDoc "treeless.convert" 70 $+ caseMaybe mst "-- not using split tree" $ \st ->+ "-- using split tree" $$ pretty st+ CC.compileClauses' q translate cs mst++-- ** Types of pipelines; different backends might use their own custom pipeline.+type BuildPipeline = Int -> QName -> Pipeline++data Pipeline = FixedPoint Int Pipeline+ | Sequential [Pipeline]+ | SinglePass CompilerPass++data CompilerPass = CompilerPass+ { passTag :: String+ , passVerbosity :: Int+ , passName :: String+ , passCode :: EvaluationStrategy -> TTerm -> TCM TTerm+ }++type CC = ReaderT CCEnv TCM+type CCContext = [Int]+data CCSubst = EraseUnused | IgnoreUnused deriving Eq++-- | Environment for treeless conversion.+data CCEnv = CCEnv+ { ccCxt :: CCContext+ -- ^ Maps case tree de-bruijn indices to TTerm de-bruijn indices.+ , ccCatchall :: Maybe Int+ -- ^ TTerm de-bruijn index of the current catch all.+ -- If an inner case has no catch-all clause, we use the one from its parent.+ , ccEvaluation :: EvaluationStrategy+ -- ^ Which evaluation strategy does the backend assume.+ , ccPipeline :: BuildPipeline+ -- ^ Which pipeline does the backend use.+ , ccSubstUnused :: CCSubst+ -- ^ Whether to erase unused arguments.+ }++type CCConfig = (EvaluationStrategy, CCSubst, BuildPipeline)++-- | Initial environment for expression generation.+initCCEnv :: CCConfig -> CCEnv+initCCEnv (eval, su, pl) = CCEnv+ { ccCxt = []+ , ccCatchall = Nothing+ , ccEvaluation = eval+ , ccSubstUnused = su+ , ccPipeline = pl+ }++ccCCConfig :: CCEnv -> CCConfig+ccCCConfig e = (ccEvaluation e, ccSubstUnused e, ccPipeline e)++-- | Converts compiled clauses to treeless syntax.+--+-- Note: Do not use any of the concrete names in the returned+-- term for identification purposes! If you wish to do so,+-- first apply the Agda.Compiler.Treeless.NormalizeNames+-- transformation.+toTreelessWith :: CCConfig -> QName -> TCM (Maybe C.TTerm)+toTreelessWith cfg q+ = ifM (alwaysInline q) (pure Nothing)+ $ Just <$> toTreelessWith' cfg q++toTreelessWith' :: CCConfig -> QName -> TCM C.TTerm+toTreelessWith' cfg q =+ flip fromMaybeM (getTreeless q) $ verboseBracket "treeless.convert" 20 ("compiling " ++ prettyShow q) $ do+ cc <- getCompiledClauses q+ unlessM (alwaysInline q) $ setTreeless q (C.TDef q)+ -- so recursive inlining doesn't loop, but not for always inlined+ -- functions, since that would risk inlining to fail.+ ccToTreelessWith cfg q cc++ccToTreelessWith :: CCConfig -> QName -> CC.CompiledClauses -> TCM C.TTerm+ccToTreelessWith cfg@(eval, su, pl) q cc = do+ let pbody b = pbody' "" b+ pbody' suf b = sep [ text (prettyShow q ++ suf) <+> "=", nest 2 $ prettyPure b ]+ v <- ifM (alwaysInline q) (return 20) (return 0)+ reportSDoc "treeless.convert" (30 + v) $ "-- compiled clauses of" <+> prettyTCM q $$ nest 2 (prettyPure cc)+ body <- casetreeTop cfg cc+ reportSDoc "treeless.opt.converted" (30 + v) $ "-- converted" $$ pbody body+ body <- runPipeline eval q (pl v q) body+ used <- usedArguments q body+ when (su == EraseUnused && ArgUnused `elem` used) $+ reportSDoc "treeless.opt.unused" (30 + v) $+ "-- used args:" <+> hsep [ if u == ArgUsed then text [x] else "_" | (x, u) <- zip ['a'..] used ] $$+ pbody' "[stripped]" (stripUnusedArguments used body)+ reportSDoc "treeless.opt.final" (20 + v) $ pbody body+ setTreeless q body+ setCompiledArgUse q used+ return body++compilerPass :: String -> Int -> String -> (EvaluationStrategy -> TTerm -> TCM TTerm) -> Pipeline+compilerPass tag v name code = SinglePass (CompilerPass tag v name code)++runPipeline :: EvaluationStrategy -> QName -> Pipeline -> TTerm -> TCM TTerm+runPipeline eval q pipeline t = case pipeline of+ SinglePass p -> runCompilerPass eval q p t+ Sequential ps -> foldM (flip $ runPipeline eval q) t ps+ FixedPoint n p -> runFixedPoint n eval q p t++runCompilerPass :: EvaluationStrategy -> QName -> CompilerPass -> TTerm -> TCM TTerm+runCompilerPass eval q p t = do+ t' <- passCode p eval t+ let dbg f = reportSDoc ("treeless.opt." ++ passTag p) (passVerbosity p) $ f $ text ("-- " ++ passName p)+ pbody b = sep [ text (prettyShow q) <+> "=", nest 2 $ prettyPure b ]+ dbg $ if | t == t' -> (<+> "(No effect)")+ | otherwise -> ($$ pbody t')+ return t'++runFixedPoint :: Int -> EvaluationStrategy -> QName -> Pipeline -> TTerm -> TCM TTerm+runFixedPoint n eval q pipeline = go 1+ where+ go i t | i > n = do+ reportSLn "treeless.opt.loop" 20 $ "++ Optimisation loop reached maximum iterations (" ++ show n ++ ")"+ return t+ go i t = do+ reportSLn "treeless.opt.loop" 30 $ "++ Optimisation loop iteration " ++ show i+ t' <- runPipeline eval q pipeline t+ if | t == t' -> do+ reportSLn "treeless.opt.loop" 30 $ "++ Optimisation loop terminating after " ++ show i ++ " iterations"+ return t'+ | otherwise -> go (i + 1) t'++closedTermToTreeless :: CCConfig -> I.Term -> TCM C.TTerm+closedTermToTreeless cfg t = do+ substTerm t `runReaderT` initCCEnv cfg++alwaysInline :: QName -> TCM Bool+alwaysInline q = do+ def <- theDef <$> getConstInfo q+ pure $ case def of -- always inline with functions and pattern lambdas+ Function{funClauses = cs} -> (isJust (funExtLam def) && not recursive) || isWithFunction def+ where+ recursive = any (couldBeRecursive . clauseRecursive) cs+ _ -> False++shift :: Int -> CCContext -> CCContext+shift n = map (+ n)++-- | Term variables are de Bruijn indices.+lookupIndex :: Int -- ^ Case tree de bruijn index.+ -> CCContext+ -> Int -- ^ TTerm de bruijn index.+lookupIndex i xs = fromMaybe __IMPOSSIBLE__ $ xs !!! i++-- | Case variables are de Bruijn levels.+lookupLevel :: Int -- ^ case tree de bruijn level+ -> CCContext+ -> Int -- ^ TTerm de bruijn index+lookupLevel l xs = fromMaybe __IMPOSSIBLE__ $ xs !!! (length xs - 1 - l)++-- | Compile a case tree into nested case and record expressions.+casetreeTop :: CCConfig -> CC.CompiledClauses -> TCM C.TTerm+casetreeTop cfg cc = flip runReaderT (initCCEnv cfg) $ do+ let a = commonArity cc+ lift $ reportSLn "treeless.convert.arity" 40 $ "-- common arity: " ++ show a+ lambdasUpTo a $ casetree cc++casetree :: CC.CompiledClauses -> CC C.TTerm+casetree cc = do+ case cc of+ CC.Fail xs -> withContextSize (length xs) $ return C.tUnreachable+ CC.Done _ _ xs v -> withContextSize (length xs) $ do+ -- Issue 2469: Body context size (`length xs`) may be smaller than current context size+ -- if some arguments are not used in the body.+ v <- lift (putAllowedReductions (SmallSet.fromList [ProjectionReductions, CopatternReductions]) $ normalise v)+ cxt <- asks ccCxt+ v' <- substTerm v+ reportS "treeless.convert.casetree" 40 $+ [ "-- casetree, calling substTerm:"+ , "-- cxt =" <+> prettyPure cxt+ , "-- v =" <+> prettyPure v+ , "-- v' =" <+> prettyPure v'+ ]+ return v'+ CC.Case _ (CC.Branches True _ _ _ Just{} _ _) -> __IMPOSSIBLE__+ CC.Case (Arg _ n) (CC.Branches True conBrs _ _ Nothing _ _) -> lambdasUpTo n $ do+ mkRecord =<< traverse casetree (CC.content <$> conBrs)+ CC.Case (Arg i n) (CC.Branches False conBrs etaBr litBrs catchall _ lazy) -> lambdasUpTo (n + 1) $ do+ -- re #3733 TODO: revise when compiling --cubical+ conBrs <- fmap Map.fromList $ filterM (isConstructor . fst) (Map.toList conBrs)+ -- We can treat eta-matches as regular matches here.+ let conBrs' = caseMaybe etaBr conBrs $ \ (c, br) -> Map.insertWith (\ new old -> old) (conName c) br conBrs+ if Map.null conBrs' && Map.null litBrs then do+ -- there are no branches, just return default+ updateCatchall catchall fromCatchall+ else do+ -- Get the type of the scrutinee.+ (caseTy, ind) <-+ case (Map.keys conBrs', Map.keys litBrs) of+ (cs, []) -> lift $ go cs+ where+ go (c:cs) = canonicalName c >>= getConstInfo <&> theDef >>= \case+ Constructor{conData} -> do+ def <- theDef <$> getConstInfo conData+ return+ ( C.CTData conData+ , case def of+ Datatype{} -> Inductive+ Record{ recInduction } -> case recInduction of+ Just i -> i+ Nothing -> Inductive+ _ -> __IMPOSSIBLE__+ )+ _ -> go cs+ go [] = __IMPOSSIBLE__+ ([], LitChar _ : _) -> return (C.CTChar, Inductive)+ ([], LitString _ : _) -> return (C.CTString, Inductive)+ ([], LitFloat _ : _) -> return (C.CTFloat, Inductive)+ ([], LitQName _ : _) -> return (C.CTQName, Inductive)+ _ -> __IMPOSSIBLE__++ updateCatchall catchall $ do+ x <- asks (lookupLevel n . ccCxt)+ eval <- asks ccEvaluation+ def <- fromCatchall+ let -- Lazy matches are made strict in strict backends.+ lazy' = lazy && case eval of+ C.LazyEvaluation _ -> True+ C.EagerEvaluation -> False+ caseInfo = C.CaseInfo+ { caseType = caseTy+ , caseLazy = lazy'+ , caseInduction = ind+ , caseErased = fromMaybe __IMPOSSIBLE__ $+ erasedFromQuantity (getQuantity i)+ }+ C.TCase x caseInfo def <$> do+ br1 <- conAlts n conBrs'+ br2 <- litAlts n litBrs+ return (br1 ++ br2)+ where+ -- normally, Agda should make sure that a pattern match is total,+ -- so we set the default to unreachable if no default has been provided.+ fromCatchall :: CC C.TTerm+ fromCatchall = asks (maybe C.tUnreachable C.TVar . ccCatchall)++commonArity :: CC.CompiledClauses -> Int+commonArity cc =+ case arities 0 cc of+ [] -> 0+ as -> minimum as+ where+ arities cxt (Case (Arg _ x) (Branches False cons eta lits def _ _)) =+ concatMap (wArities cxt') (Map.elems cons) +++ concatMap ((wArities cxt') . snd) (maybeToList eta) +++ concatMap (wArities cxt' . WithArity 0) (Map.elems lits) +++ concat [ arities cxt' c | Just c <- [def] ] -- ??+ where cxt' = max (x + 1) cxt+ arities cxt (Case _ Branches{projPatterns = True}) = [cxt]+ arities cxt (Done _ _ xs _) = [max cxt (length xs)]+ arities cxt (Fail xs) = [max cxt (length xs)]+++ wArities cxt (WithArity k c) = map (\ x -> x - k + 1) $ arities (cxt - 1 + k) c++updateCatchall :: Maybe CC.CompiledClauses -> (CC C.TTerm -> CC C.TTerm)+updateCatchall Nothing cont = cont+updateCatchall (Just cc) cont = do+ def <- casetree cc+ cxt <- asks ccCxt+ reportS "treeless.convert.lambdas" 40 $+ [ "-- updateCatchall:"+ , "-- cxt =" <+> prettyPure cxt+ , "-- def =" <+> prettyPure def+ ]+ local (\ e -> e { ccCatchall = Just 0, ccCxt = shift 1 cxt }) $ do+ -- This binding is non-strict, see issue #8759.+ C.mkLet C.NonStrict def <$> cont++-- | Shrinks or grows the context to the given size.+-- Does not update the catchall expression, the catchall expression+-- MUST NOT be used inside `cont`.+withContextSize :: Int -> CC C.TTerm -> CC C.TTerm+withContextSize n cont = do+ diff <- asks (((n -) . length) . ccCxt)+ if diff >= 1 then createLambdas diff cont else do+ let diff' = -diff+ cxt <- -- shift diff .+ -- Andreas, 2021-04-10, issue #5288+ -- The @shift diff@ is wrong, since we are returning to the original+ -- context from @cont@, and then we would have to reverse+ -- the effect of @shift diff@.+ -- We need to make sure that the result of @cont@ make sense+ -- in the **present** context, not the changed context+ -- where it is constructed.+ --+ -- Ulf, 2021-04-12, https://github.com/agda/agda/pull/5311/files#r611452551+ --+ -- This looks correct, but I can't quite follow the explanation. Here's my understanding:+ --+ -- We are building a `TTerm` case tree from `CompiledClauses`. In order+ -- to be able to match we bind all variables we'll need in a top-level+ -- lambda `λ a b c d → ..` (say). As we compute the `TTerm` we keep a+ -- context (list) of `TTerm` deBruijn indices for each `CompiledClause`+ -- variable. This is a renaming from the *source* context of the+ -- `CompiledClause` to the *target* context of the `TTerm`.+ --+ -- After some pattern matching we might have+ -- ```+ -- λ a b c d →+ -- case c of+ -- e :: f → {cxt = [d, f, e, b, a]}+ -- ```+ -- Now, what's causing the problems here is that `CompiledClauses` can be+ -- underapplied, so you might have matched on a variable only to find+ -- that in the catch-all the variable you matched on is bound in a lambda+ -- in the right-hand side! Extending the example, we might have+ -- `CompiledClauses` looking like this:+ -- ```+ -- case 2 of+ -- _::_ → done[d, f, e, b, a] ...+ -- _ → done[b, a] (λ c d → ...)+ -- ```+ -- When we get to the catch-all, the context will be `[d, c, b, a]` but+ -- the right-hand side is only expecting `a` and `b` to be bound. What we+ -- need to do is compile the right-hand side and then apply it to the+ -- variables `c` and `d` that we already bound. This is what+ -- `withContextSize` does.+ --+ -- Crucially (and this is where the bug was), we are not changing the+ -- target context, only the source context (we want a `TTerm` that makes+ -- sense at this point). This means that the correct move is to drop the+ -- entries for the additional source variables, but not change what+ -- target variables the remaining source variables map to. Hence, `drop`+ -- but no `shift`.+ --+ drop diff' <$> asks ccCxt+ local (\ e -> e { ccCxt = cxt }) $ do+ reportS "treeless.convert.lambdas" 40 $+ [ "-- withContextSize:"+ , "-- n =" <+> prettyPure n+ , "-- diff=" <+> prettyPure diff+ , "-- cxt =" <+> prettyPure cxt+ ]+ cont <&> (`C.mkTApp` map C.TVar (downFrom diff'))++-- | Prepend the given positive number of lambdas.+-- Does not update the catchall expression,+-- the catchall expression must be updated separately (or not be used).+createLambdas :: Int -> CC C.TTerm -> CC C.TTerm+createLambdas diff cont = do+ unless (diff >= 1) __IMPOSSIBLE__+ cxt <- ([0 .. diff-1] ++) . shift diff <$> asks ccCxt+ local (\ e -> e { ccCxt = cxt }) $ do+ reportS "treeless.convert.lambdas" 40 $+ [ "-- createLambdas:"+ , "-- diff =" <+> prettyPure diff+ , "-- cxt =" <+> prettyPure cxt+ ]+ -- Prepend diff lambdas+ iterate' diff C.TLam <$> cont++-- | Adds lambdas until the context has at least the given size.+-- Updates the catchall expression to take the additional lambdas into account.+lambdasUpTo :: Int -> CC C.TTerm -> CC C.TTerm+lambdasUpTo n cont = do+ diff <- asks (((n -) . length) . ccCxt)++ if diff <= 0 then cont -- no new lambdas needed+ else do+ createLambdas diff $ do+ asks ccCatchall >>= \case+ Just catchall -> do+ cxt <- asks ccCxt+ reportS "treeless.convert.lambdas" 40 $+ [ "lambdasUpTo: n =" <+> (text . show) n+ , " diff =" <+> (text . show) n+ , " catchall =" <+> prettyPure catchall+ , " ccCxt =" <+> prettyPure cxt+ ]+ -- the catch all doesn't know about the additional lambdas, so just directly+ -- apply it again to the newly introduced lambda arguments.+ -- we also bind the catch all to a let, to avoid code duplication+ local (\e -> e { ccCatchall = Just 0+ , ccCxt = shift 1 cxt }) $ do+ let catchallArgs = map C.TVar $ downFrom diff+ -- This binding is non-strict, see issue #8759.+ C.mkLet C.NonStrict+ (C.mkTApp (C.TVar $ catchall + diff) catchallArgs)+ <$> cont+ Nothing -> cont++conAlts :: Int -> Map QName (CC.WithArity CC.CompiledClauses) -> CC [C.TAlt]+conAlts x br = forM (Map.toList br) $ \ (c, CC.WithArity n cc) -> do+ c' <- lift $ canonicalName c+ replaceVar x n $ do+ branch (C.TACon c' n) cc++litAlts :: Int -> Map Literal CC.CompiledClauses -> CC [C.TAlt]+litAlts x br = forM (Map.toList br) $ \ (l, cc) ->+ -- Issue1624: we need to drop the case scrutinee from the environment here!+ replaceVar x 0 $ do+ branch (C.TALit l ) cc++branch :: (C.TTerm -> C.TAlt) -> CC.CompiledClauses -> CC C.TAlt+branch alt cc = alt <$> casetree cc++-- | Replace de Bruijn Level @x@ by @n@ new variables.+replaceVar :: Int -> Int -> CC a -> CC a+replaceVar x n cont = do+ let upd cxt = shift n ys ++ ixs ++ shift n zs+ where+ -- compute the de Bruijn index+ i = length cxt - 1 - x+ -- discard index i+ (ys, _:zs) = splitAt i cxt+ -- compute the de-bruijn indexes of the newly inserted variables+ ixs = [0..(n - 1)]+ local (\e -> e { ccCxt = upd (ccCxt e) , ccCatchall = (+ n) <$> ccCatchall e }) $+ cont+++-- | Precondition: Map not empty.+mkRecord :: Map QName C.TTerm -> CC C.TTerm+mkRecord fs = lift $ do+ -- Get the name of the first field+ let p1 = fst $ headWithDefault __IMPOSSIBLE__ $ Map.toList fs+ -- Use the field name to get the record constructor and the field names.+ I.ConHead c IsRecord{} _ind _hit xs <- conSrcCon . theDef <$> (getConstInfo =<< canonicalName . I.conName =<< recConFromProj p1)+ reportSDoc "treeless.convert.mkRecord" 60 $ vcat+ [ text "record constructor fields: xs = " <+> (text . show) xs+ , text "to be filled with content: keys fs = " <+> (text . show) (Map.keys fs)+ ]+ -- Convert the constructor+ let (args :: [C.TTerm]) = for xs $ \ x -> Map.findWithDefault __IMPOSSIBLE__ (unArg x) fs+ return $ C.mkTApp (C.TCon c) args+++recConFromProj :: QName -> TCM I.ConHead+recConFromProj q = do+ caseMaybeM (isProjection q) __IMPOSSIBLE__ $ \ proj -> do+ -- Get the record type name @d@ from the projection.+ let d = unArg $ projFromType proj+ getRecordConstructor d+++-- | Translate the actual Agda terms, with an environment of all the bound variables+-- from patternmatching. Agda terms are in de Bruijn indices, but the expected+-- TTerm de bruijn indexes may differ. This is due to additional let-bindings+-- introduced by the catch-all machinery, so we need to lookup casetree de bruijn+-- indices in the environment as well.+substTerm :: I.Term -> CC C.TTerm+substTerm term = normaliseStatic term >>= \ term ->+ case I.unSpine $ etaContractErased term of+ I.Var ind es -> do+ ind' <- asks (lookupIndex ind . ccCxt)+ let args = I.mustAllApplyElims es+ C.mkTApp (C.TVar ind') <$> substArgs args+ I.Lam _ ab ->+ C.TLam <$>+ local (\e -> e { ccCxt = 0 : shift 1 (ccCxt e) })+ (substTerm $ I.unAbs ab)+ I.Lit l -> return $ C.TLit l+ I.Level _ -> return C.TUnit+ I.Def q es -> do+ let args = I.mustAllApplyElims es+ maybeInlineDef q args+ I.Con c ci es -> do+ let args = I.mustAllApplyElims es+ c' <- lift $ canonicalName $ I.conName c+ C.mkTApp (C.TCon c') <$> substArgs args+ I.Pi _ _ -> return C.TUnit+ I.Sort _ -> return C.TSort+ I.MetaV x _ -> return $ C.TError $ C.TMeta $ prettyShow x+ I.DontCare _ -> return C.TErased+ I.Dummy{} -> __IMPOSSIBLE__++-- Andreas, 2019-07-10, issue #3792+-- | Eta-contract erased lambdas.+--+-- Should also be fine for strict backends:+--+-- * eta-contraction is semantics-preserving for total, effect-free languages.+-- * should a user rely on thunking, better not used an erased abstraction!+--+-- A live-or-death issue for the GHC 8.0 backend. Consider:+-- @+-- foldl : ∀ {A} (B : Nat → Set)+-- → (f : ∀ {@0 n} → B n → A → B (suc n))+-- → (z : B 0)+-- → ∀ {@0 n} → Vec A n → B n+-- foldl B f z (x ∷ xs) = foldl (λ n → B (suc n)) (λ{@0 x} → f {suc x}) (f z x) xs+-- foldl B f z [] = z+-- @+-- The hidden composition of @f@ with @suc@, term @(λ{@0 x} → f {suc x})@,+-- can be eta-contracted to just @f@ by the compiler, since the first argument+-- of @f@ is erased.+--+-- GHC >= 8.2 seems to be able to do the optimization himself, but not 8.0.+--+etaContractErased :: I.Term -> I.Term+etaContractErased = trampoline etaErasedOnce+ where+ etaErasedOnce :: I.Term -> Either I.Term I.Term -- Left = done, Right = jump again+ etaErasedOnce t =+ case t of++ -- If the abstraction is void, we don't have to strengthen.+ I.Lam _ (NoAbs _ v) ->+ case binAppView v of+ -- If the body is an application ending with an erased argument, eta-reduce!+ App u arg | not (usableModality arg) -> Right u+ _ -> done++ -- If the abstraction is non-void, only eta-contract if erased.+ I.Lam ai (Abs _ v) | not (usableModality ai) ->+ case binAppView v of+ -- If the body is an application ending with an erased argument, eta-reduce!+ -- We need to strengthen the function part then.+ App u arg | not (usableModality arg) -> Right $ subst 0 (DontCare __DUMMY_TERM__) u+ _ -> done++ _ -> done+ where+ done = Left t++normaliseStatic :: I.Term -> CC I.Term+normaliseStatic v@(I.Def f es) = lift $ do+ static <- isStaticFun . theDef <$> getConstInfo f+ if static then normalise v else pure v+normaliseStatic v = pure v++-- | Does not require the name to refer to a function.+cacheTreeless :: CCConfig -> QName -> TCM ()+cacheTreeless cfg q = do+ def <- theDef <$> getConstInfo q+ case def of+ Function{} -> () <$ toTreelessWith' cfg q+ _ -> return ()++maybeInlineDef :: I.QName -> I.Args -> CC C.TTerm+maybeInlineDef q vs = do+ cfg <- asks ccCCConfig+ ifM (lift $ alwaysInline q) (doinline cfg) $ do+ lift $ cacheTreeless cfg q+ def <- lift $ getConstInfo q+ case theDef def of+ fun@Function{}+ | fun ^. funInline -> doinline cfg+ | otherwise -> do+ -- If ArgUsage hasn't been computed yet, we assume all arguments are used.+ used <- lift $ fromMaybe [] <$> getCompiledArgUse q+ su <- asks ccSubstUnused+ let substUsed arg used+ | used == ArgUnused && su == EraseUnused+ = pure C.TErased+ | otherwise+ = substArg arg+ C.mkTApp (C.TDef q) <$> zipWithM substUsed vs (used ++ repeat ArgUsed)+ _ -> C.mkTApp (C.TDef q) <$> substArgs vs+ where+ doinline cfg = C.mkTApp <$> inline cfg q <*> substArgs vs+ inline cfg q = lift $ toTreelessWith' cfg q++substArgs :: [Arg I.Term] -> CC [C.TTerm]+substArgs = traverse substArg++substArg :: Arg I.Term -> CC C.TTerm+substArg x | usableModality x = substTerm (unArg x)+ | otherwise = return C.TErased+++-------------------------------------+-- Default pipeline+-------------------------------------++-- | Default compiler pipeline+--+-- Backends may use different pipelines+compilerPipeline :: BuildPipeline+compilerPipeline v q =+ Sequential+ -- Issue #4967: No simplification step before builtin translation! Simplification relies+ -- on either all or no builtins being translated. Since we might have inlined+ -- functions that have had the builtin translation applied, we need to apply it+ -- first.+ -- [ compilerPass "simpl" (35 + v) "simplification" $ const simplifyTTerm+ [ compilerPass "builtin" (30 + v) "builtin translation" $ const translateBuiltins+ , FixedPoint 5 $ Sequential+ [ compilerPass "simpl" (30 + v) "simplification" $ simplifyTTerm+ , compilerPass "erase" (30 + v) "erasure" $ eraseTerms q+ , compilerPass "uncase" (30 + v) "uncase" $ const caseToSeq+ , compilerPass "aspat" (30 + v) "@-pattern recovery" $ const recoverAsPatterns+ ]+ , compilerPass "id" (30 + v) "identity function detection" $ const (detectIdentityFunctions q)+ ]++-- | Create default CCConfig using default pipeline+mkDefaultCCConfig :: EvaluationStrategy -> CCConfig+mkDefaultCCConfig eval = (eval, EraseUnused, compilerPipeline)++-- | Convert to treeless using default pipeline+toTreeless :: EvaluationStrategy -> QName -> TCM (Maybe C.TTerm)+toTreeless = toTreelessWith . mkDefaultCCConfig++-- | Convert to treeless using default pipeline+toTreeless' :: EvaluationStrategy -> QName -> TCM C.TTerm+toTreeless' = toTreelessWith' . mkDefaultCCConfig++-- | Convert clauses to treeless using default pipeline+ccToTreeless :: EvaluationStrategy -> QName -> CC.CompiledClauses -> TCM C.TTerm+ccToTreeless = ccToTreelessWith . mkDefaultCCConfig
@@ -0,0 +1,76 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.AsPatterns (recoverAsPatterns) where++import Control.Monad.Reader++import Agda.Syntax.Treeless++data AsPat = AsPat Int QName [Int] -- x@(c ys)+ deriving (Show)++wk :: Int -> AsPat -> AsPat+wk n (AsPat x c ys) = AsPat (n + x) c (map (n +) ys)++type S = Reader [AsPat]++runS :: S a -> a+runS m = runReader m []++underBinds :: Int -> S a -> S a+underBinds 0 = id+underBinds n = local (map $ wk n)++bindAsPattern :: AsPat -> S a -> S a+bindAsPattern p = local (p :)++lookupAsPattern :: QName -> [TTerm] -> S TTerm+lookupAsPattern c vs+ | Just xs <- allVars vs = do+ ps <- ask+ case [ x | AsPat x c' ys <- ps, c == c', xs == ys ] of+ x : _ -> pure $ TVar x+ _ -> pure $ mkTApp (TCon c) vs+ | otherwise = pure $ mkTApp (TCon c) vs+ where+ allVars = mapM getVar+ getVar (TVar x) = Just x+ getVar _ = Nothing -- what about erased?++-- | We lose track of @-patterns in the internal syntax. This pass puts them+-- back.+recoverAsPatterns :: Monad m => TTerm -> m TTerm+recoverAsPatterns t = return $ runS (recover t)++recover :: TTerm -> S TTerm+recover t =+ case t of+ TApp f vs -> do+ f <- recover f+ vs <- mapM recover vs+ tApp f vs+ TLam b -> TLam <$> underBinds 1 (recover b)+ TCon{} -> tApp t [] -- need to recover nullary constructors as well (to make deep @-patterns work)+ TLet s v b -> TLet s <$> recover v <*> underBinds 1 (recover b)+ TCase x ct d bs -> TCase x ct <$> recover d <*> mapM (recoverAlt x) bs+ TCoerce t -> TCoerce <$> recover t+ TLit{} -> pure t+ TVar{} -> pure t+ TPrim{} -> pure t+ TDef{} -> pure t+ TUnit{} -> pure t+ TSort{} -> pure t+ TErased{} -> pure t+ TError{} -> pure t++recoverAlt :: Int -> TAlt -> S TAlt+recoverAlt x b =+ case b of+ TACon c n b -> TACon c n <$> underBinds n (bindAsPattern (AsPat (x + n) c [n - 1, n - 2..0]) $ recover b)+ TAGuard g b -> TAGuard <$> recover g <*> recover b+ TALit l b -> TALit l <$> recover b++tApp :: TTerm -> [TTerm] -> S TTerm+tApp (TCon c) vs = lookupAsPattern c vs+tApp f vs = pure $ mkTApp f vs+
@@ -0,0 +1,211 @@+{-# LANGUAGE RecordWildCards #-}++{-# OPTIONS_GHC -Wunused-imports #-}++-- | Translates the Agda builtin nat datatype to arbitrary-precision integers.+--+-- Philipp, 20150921:+-- At the moment, this optimization is the reason that there is a+-- TAPlus alternative. For Haskell, this can easily be translated to guards. However, in+-- the long term it would be easier for the backends if these things were translated+-- directly to a less-than primitive and if-then-else expressions or similar. This would+-- require us to add some internal Bool-datatype as compiler-internal type and+-- a primitive less-than function, which will be much easier once Treeless+-- is used for whole modules.+--+-- Ulf, 2015-09-21: No, actually we need the n+k patterns, or at least guards.+-- Representing them with if-then-else would make it a lot harder to do+-- optimisations that analyse case tree, like impossible case elimination.+--+-- Ulf, 2015-10-30: Guards are actually a better primitive. Fixed that.+module Agda.Compiler.Treeless.Builtin (translateBuiltins) where++import qualified Agda.Syntax.Internal as I+import Agda.Syntax.Treeless+import Agda.Syntax.Literal++import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Monad++import Agda.Compiler.Treeless.Subst () --instance only+import Agda.Utils.Impossible+++data BuiltinKit = BuiltinKit+ { isZero :: QName -> Bool+ , isSuc :: QName -> Bool+ , isPos :: QName -> Bool+ , isNegSuc :: QName -> Bool+ , isPlus :: QName -> Bool+ , isTimes :: QName -> Bool+ , isLess :: QName -> Bool+ , isEqual :: QName -> Bool+ , isForce :: QName -> Bool+ , isWord64FromNat :: QName -> Bool+ , isWord64ToNat :: QName -> Bool+ }++builtinKit :: TCM BuiltinKit+builtinKit =+ BuiltinKit <$> isB con builtinZero+ <*> isB con builtinSuc+ <*> isB con builtinIntegerPos+ <*> isB con builtinIntegerNegSuc+ <*> isB def builtinNatPlus+ <*> isB def builtinNatTimes+ <*> isB def builtinNatLess+ <*> isB def builtinNatEquals+ <*> isP pf PrimForce+ <*> isP pf PrimWord64FromNat+ <*> isP pf PrimWord64ToNat+ where+ con (I.Con c _ _) = pure $ I.conName c+ con _ = Nothing+ def (I.Def d _) = pure d+ def _ = Nothing++ pf = Just . primFunName++ is a b = maybe (const False) (==) . (a =<<) <$> b+ isB a b = is a (getBuiltin' b)+ isP a p = is a (getPrimitive' p)++translateBuiltins :: TTerm -> TCM TTerm+translateBuiltins t = do+ kit <- builtinKit+ return $ transform kit t++transform :: BuiltinKit -> TTerm -> TTerm+transform BuiltinKit{..} = tr+ where+ tr = \case++ TCon c | isZero c -> tInt 0+ | isSuc c -> TLam (tPlusK 1 (TVar 0))+ | isPos c -> TLam (TVar 0)+ | isNegSuc c -> TLam $ tNegPlusK 1 (TVar 0)++ TDef f | isPlus f -> TPrim PAdd+ | isTimes f -> TPrim PMul+ | isLess f -> TPrim PLt+ | isEqual f -> TPrim PEqI+ | isWord64ToNat f -> TPrim P64ToI+ | isWord64FromNat f -> TPrim PITo64+ -- Note: Don't do this for builtinNatMinus! PSub is integer minus and+ -- builtin minus is monus. The simplifier will do it if it can see+ -- that it won't underflow.++ -- Replace calls to primForce with the primitive seq, by binding the+ -- forced expression to a fresh variable and weaken appropriately.+ --+ -- primForce e f es+ -- >>>+ -- let e (seq x⁰ ((raise 1 f) x⁰) (raise 1 es))+ --+ -- Now that there are strict let bindings one might think that+ -- PSeq could be removed, but the "unchainCase" transformation+ -- implemented by Agda.Compiler.Treeless.Simplify.simplify can+ -- make strict bindings non-strict. If PSeq is removed, then it+ -- might make sense to have strict bindings that cannot be made+ -- non-strict.+ TApp (TDef q) (_ : _ : _ : _ : e : f : es)+ | isForce q ->+ tr $ TLet Strict e $+ mkTApp (tOp PSeq (TVar 0) $ mkTApp (raise 1 f) [TVar 0]) $+ raise 1 es++ TApp (TCon s) [e] | isSuc s ->+ case tr e of+ TLit (LitNat n) -> tInt (n + 1)+ e | Just (i, e) <- plusKView e -> tPlusK (i + 1) e+ e -> tPlusK 1 e++ TApp (TCon c) [e]+ | isPos c -> tr e+ | isNegSuc c ->+ case tr e of+ TLit (LitNat n) -> tInt (-n - 1)+ e | Just (i, e) <- plusKView e -> tNegPlusK (i + 1) e+ e -> tNegPlusK 1 e++ TCase e t d bs -> TCase e (inferCaseType t bs) (tr d) $ concatMap trAlt bs+ where+ trAlt = \case+ TACon c 0 b | isZero c -> [TALit (LitNat 0) (tr b)]+ TACon c 1 b | isSuc c ->+ case tr b of+ -- Collapse nested n+k patterns+ TCase 0 _ d bs' -> map sucBranch bs' ++ [nPlusKAlt 1 d]+ b -> [nPlusKAlt 1 b]+ where+ sucBranch (TALit (LitNat i) b) =+ TALit (LitNat (i + 1)) $ TLet Strict (tInt i) b+ sucBranch alt | Just (k, b) <- nPlusKView alt =+ nPlusKAlt (k + 1) $+ TLet Strict (tOp PAdd (TVar 0) (tInt 1)) $+ applySubst ([TVar 1, TVar 0] ++# wkS 2 idS) b+ sucBranch _ = __IMPOSSIBLE__++ nPlusKAlt k b =+ TAGuard (tOp PGeq (TVar e) (tInt k)) $+ TLet Strict (tOp PSub (TVar e) (tInt k)) b+ TACon c 1 b | isPos c ->+ case tr b of+ -- collapse nested nat patterns+ TCase 0 _ d bs -> map sub bs ++ [posAlt d]+ b -> [posAlt b]+ where+ -- subst scrutinee for the pos argument+ sub :: SubstWith TTerm a => a -> a+ sub = applySubst (TVar e :# IdS)++ posAlt b = TAGuard (tOp PGeq (TVar e) (tInt 0)) $ sub b++ TACon c 1 b | isNegSuc c ->+ case tr b of+ -- collapse nested nat patterns+ TCase 0 _ d bs -> map negsucBranch bs ++ [negAlt d]+ b -> [negAlt b]+ where+ body b = TLet Strict (tNegPlusK 1 (TVar e)) b+ negAlt b = TAGuard (tOp PLt (TVar e) (tInt 0)) $ body b++ negsucBranch (TALit (LitNat i) b) = TALit (LitNat (-i - 1)) $ body b+ negsucBranch alt | Just (k, b) <- nPlusKView alt =+ TAGuard (tOp PLt (TVar e) (tInt (-k))) $+ body $+ TLet Strict (tNegPlusK (k + 1) (TVar $ e + 1)) b+ negsucBranch _ = __IMPOSSIBLE__++ TACon c a b -> [TACon c a (tr b)]+ TALit l b -> [TALit l (tr b)]+ TAGuard g b -> [TAGuard (tr g) (tr b)]++ t@TVar{} -> t+ t@TDef{} -> t+ t@TCon{} -> t+ t@TPrim{} -> t+ t@TLit{} -> t+ t@TUnit{} -> t+ t@TSort{} -> t+ t@TErased{} -> t+ t@TError{} -> t++ TCoerce a -> TCoerce (tr a)++ TLam b -> TLam (tr b)+ TApp a bs -> TApp (tr a) (map tr bs)+ TLet s e b -> TLet s (tr e) (tr b)++ inferCaseType t (TACon c _ _ : _)+ | isZero c = t { caseType = CTNat }+ | isSuc c = t { caseType = CTNat }+ | isPos c = t { caseType = CTInt }+ | isNegSuc c = t { caseType = CTInt }+ inferCaseType t _ = t++ nPlusKView+ (TAGuard (TApp (TPrim PGeq) [TVar 0, (TLit (LitNat k))])+ (TLet _ (TApp (TPrim PSub) [TVar 0, (TLit (LitNat j))]) b))+ | k == j = Just (k, b)+ nPlusKView _ = Nothing
@@ -0,0 +1,66 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.Compare (equalTerms) where++import Agda.Syntax.Treeless+import Agda.TypeChecking.Substitute+import Agda.Compiler.Treeless.Subst () --instance only++equalTerms :: TTerm -> TTerm -> Bool+equalTerms u v =+ case (evalPrims u, evalPrims v) of+ (TLet _ s u@(TCase 0 _ _ _), TLet _ t v@(TCase 0 _ _ _)) ->+ equalTerms s t && equalTerms u v+ (TLet _ _ (TCase 0 _ _ _), _) -> False+ (_, TLet _ _ (TCase 0 _ _ _)) -> False+ (TLet _ t u, v) -> equalTerms (subst 0 t u) v+ (u, TLet _ t v) -> equalTerms u (subst 0 t v)+ (u, v) | u == v -> True+ (TApp f us, TApp g vs) -> eqList equalTerms (f : us) (g : vs)+ (TCase x _ d as, TCase y _ e bs) -> x == y && equalTerms d e && eqList equalAlts as bs+ (TLam u, TLam v) -> equalTerms u v+ _ -> False++equalAlts :: TAlt -> TAlt -> Bool+equalAlts (TACon c a b) (TACon c1 a1 b1) = (c, a) == (c1, a1) && equalTerms b b1+equalAlts (TALit l b) (TALit l1 b1) = l == l1 && equalTerms b b1+equalAlts (TAGuard g b) (TAGuard g1 b1) = equalTerms g g1 && equalTerms b b1+equalAlts _ _ = False++eqList :: (a -> a -> Bool) -> [a] -> [a] -> Bool+eqList eq xs ys = length xs == length ys && and (zipWith eq xs ys)++evalPrims :: TTerm -> TTerm+evalPrims (TApp (TPrim op) [a, b])+ | Just n <- intView (evalPrims a),+ Just m <- intView (evalPrims b),+ Just r <- applyPrim op n m = tInt r+evalPrims t = t++applyPrim :: TPrim -> Integer -> Integer -> Maybe Integer+applyPrim PAdd a b = Just (a + b)+applyPrim PSub a b = Just (a - b)+applyPrim PMul a b = Just (a * b)+applyPrim PQuot a b | b /= 0 = Just (quot a b)+ | otherwise = Nothing+applyPrim PRem a b | b /= 0 = Just (rem a b)+ | otherwise = Nothing+applyPrim PGeq _ _ = Nothing+applyPrim PLt _ _ = Nothing+applyPrim PEqI _ _ = Nothing+applyPrim PEqF _ _ = Nothing+applyPrim PEqC _ _ = Nothing+applyPrim PEqS _ _ = Nothing+applyPrim PEqQ _ _ = Nothing+applyPrim PIf _ _ = Nothing+applyPrim PSeq _ _ = Nothing+applyPrim PAdd64 _ _ = Nothing+applyPrim PSub64 _ _ = Nothing+applyPrim PMul64 _ _ = Nothing+applyPrim PQuot64 _ _ = Nothing+applyPrim PRem64 _ _ = Nothing+applyPrim PLt64 _ _ = Nothing+applyPrim PEq64 _ _ = Nothing+applyPrim PITo64 _ _ = Nothing+applyPrim P64ToI _ _ = Nothing+
@@ -0,0 +1,62 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Eliminates case defaults by adding an alternative for all possible+-- constructors. Literal cases are preserved as-is.+module Agda.Compiler.Treeless.EliminateDefaults where++import Control.Monad+import qualified Data.List as List++import Agda.Syntax.Treeless++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Substitute++import Agda.Compiler.Treeless.Subst () --instance only++-- Eliminate a case default.+-- Leaves its argument unchanged if:+-- * it not a data-type case split.+-- * the default case is unreachable (this makes the function idempotent)+eliminateCaseDefaultAtTopLevelIfPresent :: TTerm -> TCM TTerm+eliminateCaseDefaultAtTopLevelIfPresent (TCase sc ci@CaseInfo{caseType = CTData qn} def alts)+ | not (isUnreachable def) = do+ dtCons <- defConstructors . theDef <$> getConstInfo qn+ let missingCons = dtCons List.\\ map aCon alts+ newAlts <- forM missingCons $ \con -> do+ Constructor {conArity = ar} <- theDef <$> getConstInfo con+ return $ TACon con ar (TVar ar)++ alts' <- (++ newAlts) <$> mapM (trAlt . raise 1) alts++ -- This binding is non-strict, see issue #8759.+ return $ TLet NonStrict def $ TCase (sc + 1) ci tUnreachable alts'+eliminateCaseDefaultAtTopLevelIfPresent t = pure t++trAlt :: TAlt -> TCM TAlt+trAlt = \case+ TAGuard g b -> TAGuard <$> eliminateCaseDefaults g <*> eliminateCaseDefaults b+ TACon q a b -> TACon q a <$> eliminateCaseDefaults b+ TALit l b -> TALit l <$> eliminateCaseDefaults b++eliminateCaseDefaults :: TTerm -> TCM TTerm+eliminateCaseDefaults = tr+ where+ tr :: TTerm -> TCM TTerm+ tr = eliminateCaseDefaultAtTopLevelIfPresent >=> \case+ TCase sc ct def alts -> TCase sc ct <$> tr def <*> mapM trAlt alts++ t@TVar{} -> return t+ t@TDef{} -> return t+ t@TCon{} -> return t+ t@TPrim{} -> return t+ t@TLit{} -> return t+ t@TUnit{} -> return t+ t@TSort{} -> return t+ t@TErased{} -> return t+ t@TError{} -> return t++ TCoerce a -> TCoerce <$> tr a+ TLam b -> TLam <$> tr b+ TApp a bs -> TApp <$> tr a <*> mapM tr bs+ TLet s e b -> TLet s <$> tr e <*> tr b
@@ -0,0 +1,77 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Converts case matches on literals to if cascades with equality comparisons.+module Agda.Compiler.Treeless.EliminateLiteralPatterns where++import Data.Maybe++import Agda.Syntax.Treeless+import Agda.Syntax.Literal++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Primitive++import Agda.Utils.Impossible+++eliminateLiteralPatterns :: TTerm -> TCM TTerm+eliminateLiteralPatterns t = do+ kit <- BuiltinKit <$> getBuiltinName builtinNat <*> getBuiltinName builtinInteger+ return $ transform kit t++data BuiltinKit = BuiltinKit+ { nat :: Maybe QName+ , int :: Maybe QName+ }++transform :: BuiltinKit -> TTerm -> TTerm+transform kit = tr+ where+ tr :: TTerm -> TTerm+ tr = \case+ TCase sc t def alts | caseType t `elem` [CTChar, CTString, CTQName, CTNat, CTInt, CTFloat] ->+ foldr litAlt (tr def) alts+ where+ litAlt :: TAlt -> TTerm -> TTerm+ litAlt (TALit l body) cont =+ tIfThenElse+ (tOp (eqFromLit l) (TLit l) (TVar sc))+ (tr body)+ cont+ litAlt _ _ = __IMPOSSIBLE__+ TCase sc t@CaseInfo{caseType = CTData dt} def alts ->+ TCase sc t (tr def) (map trAlt alts)+ where+ trAlt = \case+ TAGuard g b -> TAGuard (tr g) (tr b)+ TACon q a b -> TACon q a (tr b)+ TALit l b -> TALit l (tr b)+ TCase _ _ _ _ -> __IMPOSSIBLE__++ t@TVar{} -> t+ t@TDef{} -> t+ t@TCon{} -> t+ t@TPrim{} -> t+ t@TLit{} -> t+ t@TUnit{} -> t+ t@TSort{} -> t+ t@TErased{} -> t+ t@TError{} -> t++ TCoerce a -> TCoerce (tr a)+ TLam b -> TLam (tr b)+ TApp a bs -> TApp (tr a) (map tr bs)+ TLet s e b -> TLet s (tr e) (tr b)++ -- TODO:: Defined but not used+ isCaseOn (CTData dt) xs = dt `elem` mapMaybe ($ kit) xs+ isCaseOn _ _ = False++ eqFromLit :: Literal -> TPrim+ eqFromLit = \case+ LitNat _ -> PEqI+ LitFloat _ -> PEqF+ LitString _ -> PEqS+ LitChar _ -> PEqC+ LitQName _ -> PEqQ+ _ -> __IMPOSSIBLE__
@@ -0,0 +1,385 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE PatternSynonyms #-}++module Agda.Compiler.Treeless.Erase+ ( eraseTerms+ , computeErasedConstructorArgs+ , isErasable+ ) where++import Control.Monad.State ( StateT, evalStateT )++import qualified Data.List as List+import Data.Map (Map)+import qualified Data.Map as Map++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Syntax.Internal as I+import Agda.Syntax.Treeless+import Agda.Syntax.Literal++import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Monad as I+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Primitive++import Agda.Compiler.Treeless.Pretty ()+import Agda.Compiler.Treeless.Subst+import Agda.Compiler.Treeless.Unused++import Agda.Utils.Functor+import Agda.Utils.IntSet.Infinite ( IntSet )+import Agda.Utils.IntSet.Infinite qualified as IntSet+import Agda.Utils.Maybe+import Agda.Utils.Memo+import Agda.Utils.Monad+import Agda.Utils.Tuple ( first, second )++import Agda.Utils.Impossible++-- | State of the eraser.+data ESt = ESt+ { _funMap :: Map QName FunInfo+ -- ^ Memoize computed `FunInfo` for functions/constructors/... `QName`.+ , _typeMap :: Map QName TypeInfo+ -- ^ Memoize computed `TypeInfo` for data/record types `QName`.+ }++funMap :: Lens' ESt (Map QName FunInfo)+funMap f r = f (_funMap r) <&> \ a -> r { _funMap = a }++typeMap :: Lens' ESt (Map QName TypeInfo)+typeMap f r = f (_typeMap r) <&> \ a -> r { _typeMap = a }++-- | Eraser monad.+type E = StateT ESt TCM++runE :: E a -> TCM a+runE m = evalStateT m (ESt Map.empty Map.empty)++-- | Takes the name of the data/record type.+computeErasedConstructorArgs :: QName -> TCM ()+computeErasedConstructorArgs d = do+ cs <- getNotErasedConstructors d+ runE $ mapM_ getFunInfo cs++eraseTerms :: QName -> EvaluationStrategy -> TTerm -> TCM TTerm+eraseTerms q eval t = do+ t' <- usedArguments q t *> runE (eraseTop q t)+ reportSDoc "treeless.opt.erase" 40 $+ "Term before erasure:" $$ nest 2 (pretty t) $$+ "Term after erasure:" $$ nest 2 (pretty t')+ return t'+ where+ eraseTop q t = do+ (_, h) <- getFunInfo q+ case h of+ Erasable -> pure TErased+ Empty -> pure TErased+ _ -> erase t++ erase t = case tAppView t of++ (TCon c, vs) -> do+ (rs, h) <- getFunInfo c+ when (length rs < length vs) __IMPOSSIBLE__+ case h of+ Erasable -> pure TErased+ Empty -> pure TErased+ _ -> tApp (TCon c) <$> zipWithM eraseRel rs vs++ (TDef f, vs) -> do+ (rs, h) <- getFunInfo f+ case h of+ Erasable -> pure TErased+ Empty -> pure TErased+ _ -> tApp (TDef f) <$> zipWithM eraseRel (rs ++ repeat NotErasable) vs++ _ -> case t of+ TVar{} -> pure t+ TDef{} -> pure t+ TPrim{} -> pure t+ TLit{} -> pure t+ TCon{} -> pure t+ TApp f es -> tApp <$> erase f <*> mapM erase es+ TLam b -> tLam <$> erase b+ TLet s e b -> do+ e <- erase e+ if isErased e+ then case b of+ TCase 0 _ _ _ -> tLet s TErased <$> erase b+ _ -> erase $ subst 0 TErased b+ else tLet s e <$> erase b+ TCase x t d bs -> do+ (d, bs) <- pruneUnreachable x (caseErased t) (caseType t) d bs+ d <- erase d+ bs <- mapM eraseAlt bs+ tCase x t d bs++ TUnit -> pure t+ TSort -> pure t+ TErased -> pure t+ TError{} -> pure t+ TCoerce e -> TCoerce <$> erase e++ -- #3380: this is not safe for strict backends+ tLam TErased = case eval of+ LazyEvaluation _ -> TErased+ EagerEvaluation -> TLam TErased+ tLam t = TLam t++ tLet s e b+ | freeIn 0 b = TLet s e b+ | otherwise = strengthen impossible b++ tApp f [] = f+ tApp TErased _ = TErased+ tApp f _ | isUnreachable f = tUnreachable+ tApp f es = mkTApp f es++ tCase x t d bs+ | isErased d && all (isErased . aBody) bs = pure TErased+ | otherwise = case bs of+ [b@(TACon c _ _)] -> do+ h <- snd <$> getFunInfo c+ case h of+ NotErasable -> fallback+ Empty -> pure TErased+ Erasable -> erasedBody b+ _ -> fallback+ where+ noerase = pure $ TCase x t d bs++ erasedBody = \case+ TACon _ arity body ->+ (if arity == 0 then pure else erase) $+ -- might enable more erasure+ applySubst (replicate arity TErased ++# idS) body+ TALit _ body -> pure body+ TAGuard _ body -> pure body++ fallback = case (caseErased t, bs) of+ (Erased{}, [b]) ->+ -- The case variable is erased, and there is exactly one+ -- case: use the case's body.+ erasedBody b+ (Erased{}, []) ->+ -- The case variable is erased, and there is no case: use+ -- the default.+ pure $ if isErased d then TErased else d+ (Erased{}, _ : _ : _) ->+ -- The case variable is erased, and there are at least two+ -- cases: crash.+ __IMPOSSIBLE__+ _ ->+ -- The case variable is not erased: do not erase anything.+ noerase++ isErased t = t == TErased || isUnreachable t++ eraseRel r t | erasable r = pure TErased+ | otherwise = erase t++ eraseAlt = \case+ TALit l b -> TALit l <$> erase b+ TACon c a b -> do+ rs <- map erasable . fst <$> getFunInfo c+ let sub = foldr (\ e -> if e then (TErased :#) . wkS 1 else liftS 1) idS $ reverse rs+ TACon c a <$> erase (applySubst sub b)+ TAGuard g b -> TAGuard <$> erase g <*> erase b++pruneUnreachable ::+ Int -> Erased -> CaseType -> TTerm -> [TAlt] -> E (TTerm, [TAlt])+pruneUnreachable x erased t d bs = case erased of+ NotErased{} -> pruneUnreachable' x erased t d bs+ Erased{} ->+ -- If the match is on an erased argument, then the first branch+ -- should match.+ case bs of+ [] -> pruneUnreachable' x erased t d []+ b : _ -> pruneUnreachable' x erased t tUnreachable [b]++-- | Doesn't have any type information (other than the name of the data type),+-- so we can't do better than checking if all constructors are present.+pruneUnreachable' ::+ Int -> Erased -> CaseType -> TTerm -> [TAlt] -> E (TTerm, [TAlt])+pruneUnreachable' _ erased (CTData q) d bs' = do+ -- Erased constructors are pruned iff the match is made on a+ -- non-erased argument.+ cs <- lift $+ if isErased erased+ then getConstructors q+ else getNotErasedConstructors q+ let (bs, pruned)+ | isErased erased = (bs', [])+ | otherwise =+ flip List.partition bs' $ \case+ a@TACon{} -> (aCon a) `elem` cs+ TAGuard{} -> True+ TALit{} -> True+ lift $ reportSDoc "treeless.opt.erase.prune" 50 $+ ("The match is" <+>+ (if isErased erased then id else ("not" <+>)) "erased.") $$+ "Kept branches:" $$ nest 2 (vcat (map pretty bs)) $$+ "Pruned branches:" $$ nest 2 (vcat (map pretty pruned))+ let -- In the case of a match on an erased argument the value d is+ -- equal to tUnreachable, except perhaps if bs is empty. In the+ -- latter case complete is True exactly when the type has zero+ -- constructors (erased or not), in which case it makes sense to+ -- replace d with tUnreachable.+ complete = length cs == length [ b | b@TACon{} <- bs ]+ d' | complete = tUnreachable+ | otherwise = d+ return (d', bs)+pruneUnreachable' x _ CTNat d bs =+ return $ pruneIntCase x d bs (IntSet.below 0)+pruneUnreachable' x _ CTInt d bs =+ return $ pruneIntCase x d bs IntSet.empty+pruneUnreachable' _ _ _ d bs =+ pure (d, bs)++-- These are the guards we generate for Int/Nat pattern matching+pattern Below :: Int -> Integer -> TTerm+pattern Below x n = TApp (TPrim PLt) [TVar x, TLit (LitNat n)]++pattern Above :: Int -> Integer -> TTerm+pattern Above x n = TApp (TPrim PGeq) [TVar x, TLit (LitNat n)]++-- | Strip unreachable clauses (replace by tUnreachable for the default).+-- Fourth argument is the set of ints covered so far.+pruneIntCase :: Int -> TTerm -> [TAlt] -> IntSet -> (TTerm, [TAlt])+pruneIntCase x d bs cover = go bs cover+ where+ go [] cover+ | cover == IntSet.full = (tUnreachable, [])+ | otherwise = (d, [])+ go (b : bs) cover =+ case b of+ TAGuard (Below y n) _ | x == y -> rec (IntSet.below n)+ TAGuard (Above y n) _ | x == y -> rec (IntSet.above n)+ TALit (LitNat n) _ -> rec (IntSet.singleton n)+ _ -> second (b :) $ go bs cover+ where+ rec this = second addAlt $ go bs cover'+ where+ this' = IntSet.difference this cover+ cover' = this' <> cover+ addAlt = case IntSet.toFiniteList this' of+ Just [] -> id -- unreachable case+ Just [n] -> (TALit (LitNat n) (aBody b) :) -- possibly refined case+ _ -> (b :) -- unchanged case++data TypeInfo = Empty | Erasable | NotErasable+ deriving (Eq, Show)++sumTypeInfo :: [TypeInfo] -> TypeInfo+sumTypeInfo is = foldr plus Empty is+ where+ plus Empty r = r+ plus r Empty = r+ plus Erasable r = r+ plus r Erasable = r+ plus NotErasable NotErasable = NotErasable++erasable :: TypeInfo -> Bool+erasable Erasable = True+erasable Empty = True+erasable NotErasable = False++type FunInfo = ([TypeInfo], TypeInfo)++getFunInfo :: QName -> E FunInfo+getFunInfo q = memo (funMap . key q) $ getInfo q+ where+ getInfo :: QName -> E FunInfo+ getInfo q = do+ (rs, t) <- do+ (tel, t) <- lift $ typeWithoutParams q+ is <- mapM (getTypeInfo . snd . dget) tel+ used <- lift $ (++ repeat ArgUsed) . fromMaybe [] <$> getCompiledArgUse q+ forced <- lift $ (++ repeat NotForced) <$> getForcedArgs q+ return (zipWith3 (uncurry . mkR . getModality) tel (zip forced used) is, t)+ h <- if isAbsurdLambdaName q then pure Erasable else getTypeInfo t+ lift $ reportSLn "treeless.opt.erase.info" 50 $ "type info for " ++ prettyShow q ++ ": " ++ show rs ++ " -> " ++ show h+ lift $ setErasedConArgs q $ map erasable rs+ return (rs, h)++ -- Treat empty, erasable, or unused arguments as Erasable+ mkR :: Modality -> IsForced -> ArgUsage -> TypeInfo -> TypeInfo+ mkR m f u i+ | not (usableModality m) = Erasable+ | ArgUnused <- u = Erasable+ | Forced <- f = Erasable+ | otherwise = i++isErasable :: QName -> TCM Bool+isErasable qn =+ erasable . snd <$> runE (getFunInfo qn)++telListView :: Type -> TCM (ListTel, Type)+telListView t = do+ TelV tel t <- telViewPath t+ return (telToList tel, t)++typeWithoutParams :: QName -> TCM (ListTel, Type)+typeWithoutParams q = do+ def <- getConstInfo q+ let d = case I.theDef def of+ Function{ funProjection = Right Projection{ projIndex = i } } -> i - 1+ Constructor{ conPars = n } -> n+ _ -> 0+ first (drop d) <$> telListView (defType def)++getTypeInfo :: Type -> E TypeInfo+getTypeInfo t0 = do+ (tel, t) <- lift $ telListView t0+ et <- case I.unEl t of+ I.Def d _ -> do+ -- #2916: Only update the memo table for d. Results for other types are+ -- under the assumption that d is erasable!+ oldMap <- use typeMap+ dInfo <- typeInfo d+ typeMap .= Map.insert d dInfo oldMap+ return dInfo+ Sort{} -> return Erasable+ _ -> return NotErasable+ is <- mapM (getTypeInfo . snd . dget) tel+ let e | Empty `elem` is = Erasable+ | null is = et -- TODO: guard should really be "all inhabited is"+ | et == Empty = Erasable+ | otherwise = et+ lift $ reportSDoc "treeless.opt.erase.type" 50 $ prettyTCM t0 <+> text ("is " ++ show e)+ return e+ where+ typeInfo :: QName -> E TypeInfo+ typeInfo q = ifM (erasureForbidden q) (return NotErasable) $ {-else-} do+ memoRec (typeMap . key q) Erasable $ do -- assume recursive occurrences are erasable+ msizes <- lift $ mapM getBuiltinName+ [builtinSize, builtinSizeLt]+ def <- lift $ getConstInfo q+ let mcs = case I.theDef def of+ I.Datatype{ dataCons = cs } -> Just cs+ I.Record{ recConHead = c } -> Just [conName c]+ _ -> Nothing+ case mcs of+ _ | Just q `elem` msizes -> return Erasable+ Just [c] -> do+ (ts, _) <- lift $ typeWithoutParams c+ let rs = map getModality ts+ is <- mapM (getTypeInfo . snd . dget) ts+ let er = and [ erasable i || not (usableModality r) | (i, r) <- zip is rs ]+ return $ if er then Erasable else NotErasable+ Just [] -> return Empty+ Just (_:_:_) -> return NotErasable+ Nothing ->+ case I.theDef def of+ I.Function{ funClauses = cs } ->+ sumTypeInfo <$> mapM (maybe (return Empty) (getTypeInfo . El __DUMMY_SORT__) . clauseBody) cs+ _ -> return NotErasable+ -- The backend also has a say whether a type is eraseable or not.+ erasureForbidden :: QName -> E Bool+ erasureForbidden q = lift $ not <$> activeBackendMayEraseType q
@@ -0,0 +1,8 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.Erase where++import Agda.TypeChecking.Monad.Base (TCM)+import Agda.Syntax.Abstract.Name (QName)++isErasable :: QName -> TCM Bool
@@ -0,0 +1,56 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Translates guard alternatives to if-then-else cascades.+--+-- The builtin translation must be run before this transformation.+module Agda.Compiler.Treeless.GuardsToPrims ( convertGuards ) where++import qualified Data.List as List++import Agda.Syntax.Treeless++import Agda.Utils.Impossible+++convertGuards :: TTerm -> TTerm+convertGuards = tr+ where+ tr = \case+ TCase sc t def alts ->+ if null otherAlts+ then+ def'+ else+ TCase sc t def' (fmap trAlt otherAlts)+ where+ (plusAlts, otherAlts) = splitAlts alts++ guardedAlt :: TAlt -> TTerm -> TTerm+ guardedAlt (TAGuard g body) cont = tIfThenElse (tr g) (tr body) (tr cont)+ guardedAlt _ _ = __IMPOSSIBLE__++ def' = foldr guardedAlt (tr def) plusAlts++ trAlt (TAGuard{}) = __IMPOSSIBLE__+ trAlt a = a { aBody = tr (aBody a) }++ t@TVar{} -> t+ t@TDef{} -> t+ t@TCon{} -> t+ t@TPrim{} -> t+ t@TLit{} -> t+ t@TUnit{} -> t+ t@TSort{} -> t+ t@TErased{} -> t+ t@TError{} -> t++ TCoerce a -> TCoerce (tr a)+ TLam b -> TLam (tr b)+ TApp a bs -> TApp (tr a) (map tr bs)+ TLet s e b -> TLet s (tr e) (tr b)++-- | Split alts into TAGuard alts and other alts.+splitAlts :: [TAlt] -> ([TAlt], [TAlt])+splitAlts = List.partition isGuardAlt+ where isGuardAlt (TAGuard _ _) = True+ isGuardAlt _ = False
@@ -0,0 +1,106 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.Identity+ ( detectIdentityFunctions ) where++import Prelude hiding ((!!)) -- don't use partial functions++import Control.Applicative ( Alternative((<|>), empty) )+import Data.Semigroup ( sconcat )+import qualified Data.List as List++import Agda.Syntax.Treeless+import Agda.TypeChecking.Monad++import Agda.Utils.List+import Agda.Utils.List1 (pattern (:|))++import Agda.Utils.Impossible++detectIdentityFunctions :: QName -> TTerm -> TCM TTerm+detectIdentityFunctions q t =+ case isIdentity q t of+ Nothing -> return t+ Just (n, k) -> do+ markInline True q+ def <- theDef <$> getConstInfo q+ return $ mkTLam n $ TVar k++-- If isIdentity f t = Just (n, k) then+-- f = t is equivalent to f = λ xn₋₁ .. x₀ → xk+isIdentity :: QName -> TTerm -> Maybe (Int, Int)+isIdentity q t =+ trivialIdentity q t <|> recursiveIdentity q t++-- Does the function recurse on an argument, rebuilding the same value again.+recursiveIdentity :: QName -> TTerm -> Maybe (Int, Int)+recursiveIdentity q t =+ case b of+ TCase x _ (TError TUnreachable) bs+ | all (identityBranch x) bs -> pure (n, x)+ _ -> empty -- TODO: lets?+ where+ (n, b) = tLamView t++ identityBranch _ TALit{} = False+ identityBranch _ TAGuard{} = False+ identityBranch x (TACon c a b) =+ case b of+ TApp (TCon c') args -> c == c' && identityArgs a args+ TVar y -> y == x + a -- from @-pattern recovery+ _ -> False -- TODO: nested cases+ where+ identityArgs a args =+ length args == a && and (zipWith match (reverse args) [0..])++ proj x args = indexWithDefault __IMPOSSIBLE__ (reverse args) x++ match TErased _ = True+ match (TVar z) y = z == y+ match (TApp (TDef f) args) y = f == q && length args == n && match (proj x args) y+ match _ _ = False++data IdentityIn = IdIn [Int]++notId :: IdentityIn+notId = IdIn []++instance Semigroup IdentityIn where+ IdIn xs <> IdIn ys = IdIn $ List.intersect xs ys++-- Does the function always return one of its arguments unchanged (possibly+-- through recursive calls).+trivialIdentity :: QName -> TTerm -> Maybe (Int, Int)+trivialIdentity q t =+ case go 0 b of+ IdIn [x] -> pure (n, x)+ IdIn [] -> Nothing+ IdIn (_:_:_) -> Nothing -- only happens for empty functions (which will never be called)+ where+ (n, b) = tLamView t++ go :: Int -> TTerm -> IdentityIn+ go k t =+ case t of+ TVar x | x >= k -> IdIn [x - k]+ | otherwise -> notId+ TLet _ _ b -> go (k + 1) b+ TCase _ _ d bs -> sconcat (go k d :| map (goAlt k) bs)+ TApp (TDef f) args+ | f == q -> IdIn [ y | (TVar x, y) <- zip (reverse args) [0..], y + k == x ]+ TCoerce v -> go k v+ TApp{} -> notId+ TLam{} -> notId+ TLit{} -> notId+ TDef{} -> notId+ TCon{} -> notId+ TPrim{} -> notId+ TUnit{} -> notId+ TSort{} -> notId+ TErased{} -> notId+ TError{} -> notId++ goAlt :: Int -> TAlt -> IdentityIn+ goAlt k (TALit _ b) = go k b+ goAlt k (TAGuard _ b) = go k b+ goAlt k (TACon _ n b) = go (k + n) b
@@ -0,0 +1,43 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Ensures that all occurences of an abstract name share+-- the same concrete name.+--+-- Apply this transformation if your backend uses concrete names+-- for identification purposes!+--+-- The identity of an abstract name is only the nameId, the concrete+-- name is only a naming suggestion. If renaming imports are used,+-- the concrete name may change. This transformation makes sure+-- that all occurences of an abstract name share the same+-- concrete name.+--+-- This transfomation should be run as the last transformation.+module Agda.Compiler.Treeless.NormalizeNames ( normalizeNames ) where++import Agda.TypeChecking.Monad+import Agda.Syntax.Treeless++normalizeNames :: TTerm -> TCM TTerm+normalizeNames = tr+ where+ tr = \case+ TDef q -> TDef . defName <$> getConstInfo q+ t@TVar{} -> return t+ t@TCon{} -> return t+ t@TPrim{} -> return t+ t@TLit{} -> return t+ t@TUnit{} -> return t+ t@TSort{} -> return t+ t@TErased{} -> return t+ t@TError{} -> return t+ TLam b -> TLam <$> tr b+ TApp a bs -> TApp <$> tr a <*> mapM tr bs+ TLet s e b -> TLet s <$> tr e <*> tr b+ TCase sc t def alts -> TCase sc t <$> tr def <*> mapM trAlt alts+ TCoerce a -> TCoerce <$> tr a++ trAlt = \case+ TAGuard g b -> TAGuard <$> tr g <*> tr b+ TACon q a b -> TACon q a <$> tr b+ TALit l b -> TALit l <$> tr b
@@ -0,0 +1,216 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# OPTIONS_GHC -fno-warn-orphans #-}++module Agda.Compiler.Treeless.Pretty () where++import Prelude hiding ((!!)) -- don't use partial functions!++import Control.Monad.Reader+import Data.Maybe+import qualified Data.IntMap as IntMap++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Treeless++import Agda.Compiler.Treeless.Subst++import Agda.Utils.Function+import Agda.Utils.List+import Agda.Utils.Null (empty)+import Agda.Utils.Tuple (first)++import Agda.Utils.Impossible++instance Pretty Compiled where+ pretty Compiled {cTreeless, cArgUsage} =+ "Compiled {" <?> vcat+ [ "cTreeless =" <?> pretty cTreeless+ , "funCompiled =" <?> pshow cArgUsage+ ] <?> "}"++data PEnv = PEnv { pPrec :: Int+ , pFresh :: [String]+ , pBound :: [String] }++type P = Reader PEnv++--UNUSED Liang-Ting Chen 2019-07-16+--withName :: (String -> P a) -> P a+--withName k = withNames 1 $ \[x] -> k x++withNames :: Int -> ([String] -> P a) -> P a+withNames n k = do+ (xs, ys) <- asks $ splitAt n . pFresh+ local (\ e -> e { pFresh = ys }) (k xs)++-- | Don't generate fresh names for unused variables.+withNames' :: HasFree a => Int -> a -> ([String] -> P b) -> P b+withNames' n tm k = withNames n' $ k . insBlanks+ where+ fv = freeVars tm+ n' = length $ filter (< n) $ IntMap.keys fv+ insBlanks = go n+ where+ go 0 _ = []+ go i xs0@(~(x : xs))+ | IntMap.member (i - 1) fv = x : go (i - 1) xs+ | otherwise = "_" : go (i - 1) xs0++bindName :: String -> P a -> P a+bindName x = local $ \ e -> e { pBound = x : pBound e }++bindNames :: [String] -> P a -> P a+bindNames xs p = foldr bindName p xs++paren :: Int -> P Doc -> P Doc+paren p doc = do+ n <- asks pPrec+ applyWhen (p < n) parens <$> doc++prec :: Int -> P a -> P a+prec p = local $ \ e -> e { pPrec = p }++name :: Int -> P String+name x = asks+ $ (\ xs -> indexWithDefault __IMPOSSIBLE__ xs x)+ . (++ map (("^" ++) . show) [1..])+ . pBound++runP :: P a -> a+runP p = runReader p PEnv{ pPrec = 0, pFresh = names, pBound = [] }+ where+ names = [ x ++ i | i <- "" : map show [1..], x <- map (:[]) ['a'..'z'] ]++instance Pretty TTerm where+ prettyPrec p t = runP $ prec p (pTerm t)++instance Pretty TAlt where+ prettyPrec p b = runP $ prec p (pAlt b)++opName :: TPrim -> String+opName PAdd = "+"+opName PSub = "-"+opName PMul = "*"+opName PQuot = "quot"+opName PRem = "rem"+opName PGeq = ">="+opName PLt = "<"+opName PEqI = "==I"+opName PAdd64 = "+64"+opName PSub64 = "-64"+opName PMul64 = "*64"+opName PQuot64 = "quot64"+opName PRem64 = "rem64"+opName PLt64 = "<64"+opName PEq64 = "==64"+opName PEqF = "==F"+opName PEqS = "==S"+opName PEqC = "==C"+opName PEqQ = "==Q"+opName PIf = "if_then_else_"+opName PSeq = "seq"+opName PITo64 = "toWord64"+opName P64ToI = "fromWord64"+++isInfix :: TPrim -> Maybe (Int, Int, Int)+isInfix op =+ case op of+ PMul -> l 7+ PAdd -> l 6+ PSub -> l 6+ PGeq -> non 4+ PLt -> non 4+ PMul64 -> l 7+ PAdd64 -> l 6+ PSub64 -> l 6+ PLt64 -> non 4+ p | isPrimEq p -> non 4+ _ -> Nothing+ where+ l n = Just (n, n, n + 1)+ r n = Just (n, n + 1, n) -- NB:: Defined but not used+ non n = Just (n, n + 1, n + 1)++pTerm' :: Int -> TTerm -> P Doc+pTerm' p = prec p . pTerm++pTerm :: TTerm -> P Doc+pTerm = \case+ TVar x -> text <$> name x+ TApp (TPrim op) [a, b] | Just (c, l, r) <- isInfix op ->+ paren c $ sep <$> sequence [ pTerm' l a+ , pure $ text $ opName op+ , pTerm' r b ]+ TApp (TPrim PIf) [a, b, c] ->+ paren 0 $ (\ a b c -> sep [ "if" <+> a+ , nest 2 $ "then" <+> b+ , nest 2 $ "else" <+> c ])+ <$> pTerm' 0 a+ <*> pTerm' 0 b+ <*> pTerm c+ TDef f -> pure $ pretty f+ TCon c -> pure $ pretty c+ TLit l -> pure $ pretty l+ TPrim op | isJust (isInfix op) -> pure $ text ("_" ++ opName op ++ "_")+ | otherwise -> pure $ text (opName op)+ TApp f es ->+ paren 9 $ (\a bs -> sep [a, nest 2 $ fsep bs])+ <$> pTerm' 9 f+ <*> mapM (pTerm' 10) es+ t@TLam{} -> paren 0 $ withNames' n b $ \ xs -> bindNames xs $+ (\b -> sep [ text ("λ " ++ unwords xs ++ " →")+ , nest 2 b ]) <$> pTerm' 0 b+ where+ (n, b) = tLamView t+ t@TLet{} -> paren 0 $ withNames (length es) $ \ xs ->+ (\(binds, b) ->+ sep [ "let" <+>+ vcat [ sep [(strictness s <> text x) <+> "=", nest 2 e]+ | (s, x, e) <- binds+ ] <+>+ "in"+ , b+ ])+ <$> pLets (zip xs es) b+ where+ (es, b) = tLetView t++ pLets [] b = ([],) <$> pTerm' 0 b+ pLets ((x, (s, e)) : bs) b = do+ e <- pTerm' 0 e+ first ((s, x, e) :) <$> bindName x (pLets bs b)++ strictness Strict = "!"+ strictness NonStrict = "~"++ TCase x i def alts -> paren 0 $+ (\ sc alts defd ->+ sep [ "case" <+>+ (if isErased (caseErased i) then "(erased)" else empty) <+>+ sc <+> "of"+ , nest 2 $ vcat (alts ++ [ "_ →" <+> defd | null alts || def /= TError TUnreachable ]) ]+ ) <$> pTerm' 0 (TVar x)+ <*> mapM pAlt alts+ <*> pTerm' 0 def++ TUnit -> pure "()"+ TSort -> pure "Set"+ TErased -> pure "_"+ TError err -> paren 9 $ pure $ "error" <+> text (show (show err))+ TCoerce t -> paren 9 $ ("coe" <+>) <$> pTerm' 10 t++pAlt' :: Doc -> Doc -> Doc+pAlt' p b = sep [p <+> "→", nest 2 b]++pAlt :: TAlt -> P Doc+pAlt (TALit l b) = pAlt' <$> pTerm' 0 (TLit l) <*> pTerm' 0 b+pAlt (TAGuard g b) =+ pAlt' <$> (("_" <+> "|" <+>) <$> pTerm' 0 g)+ <*> (pTerm' 0 b)+pAlt (TACon c a b) =+ withNames' a b $ \ xs -> bindNames xs $+ pAlt' <$> pTerm' 0 (TApp (TCon c) [TVar i | i <- reverse [0..a - 1]])+ <*> pTerm' 0 b
@@ -0,0 +1,7 @@++module Agda.Compiler.Treeless.Pretty () where++import Agda.Syntax.Treeless+import Agda.Syntax.Common.Pretty++instance Pretty Compiled
@@ -0,0 +1,650 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.Simplify (simplifyTTerm) where++import Control.Applicative+import Control.Monad ( (>=>), guard )+import Control.Monad.Reader ( MonadReader(..), asks, Reader, runReader )+import Control.Monad.Trans+import Control.Monad.Trans.Maybe+import qualified Data.List as List++import Agda.Syntax.Internal (termSize)+import Agda.Syntax.Treeless+import Agda.Syntax.Literal++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Primitive+import Agda.TypeChecking.Substitute++import Agda.Compiler.Treeless.Compare++import Agda.Utils.IndexMap (IndexMap)+import qualified Agda.Utils.IndexMap as IndexMap+import Agda.Utils.List+import Agda.Utils.Maybe+import Agda.Utils.Tuple ( (***), second )++import Agda.Utils.Impossible++data SEnv = SEnv+ { envSubst :: Substitution' TTerm+ , envStrictness :: IndexMap Strictness+ -- ^ What strictness was the given variable bound with?+ , envRewrite :: [(TTerm, TTerm)] }++type S = Reader SEnv++runS :: S a -> a+runS m = runReader m $ SEnv IdS IndexMap.nil []++lookupVar :: Int -> S (Strictness, TTerm)+lookupVar i = do+ env <- ask+ return (IndexMap.index i (envStrictness env), lookupS (envSubst env) i)++onSubst :: (Substitution' TTerm -> Substitution' TTerm) -> S a -> S a+onSubst f = local $ \ env -> env { envSubst = f (envSubst env) }++onStrictness :: (IndexMap Strictness -> IndexMap Strictness) -> S a -> S a+onStrictness f =+ local (\env -> env { envStrictness = f (envStrictness env) })++onRewrite :: Substitution' TTerm -> S a -> S a+onRewrite rho = local $ \ env -> env { envRewrite = map (applySubst rho *** applySubst rho) (envRewrite env) }++addRewrite :: TTerm -> TTerm -> S a -> S a+addRewrite lhs rhs = local $ \ env -> env { envRewrite = (lhs, rhs) : envRewrite env }++-- | There is one strictness per binding, and the first element in the+-- list corresponds to the first new binding.++underLams :: [Strictness] -> S a -> S a+underLams ss =+ onRewrite (raiseS i) . onSubst (liftS i) .+ onStrictness (flip IndexMap.append ss)+ where+ i = length ss++underLam :: Strictness -> S a -> S a+underLam s = underLams [s]++underLet :: Strictness -> TTerm -> S a -> S a+underLet s u =+ onRewrite (raiseS 1) . onSubst (\rho -> wkS 1 $ u :# rho) .+ onStrictness (flip IndexMap.snoc s)++bindVar :: Int -> Strictness -> TTerm -> S a -> S a+bindVar x s u =+ onSubst (inplaceS x u `composeS`) .+ onStrictness (IndexMap.update x s)++rewrite :: TTerm -> S TTerm+rewrite t = do+ rules <- asks envRewrite+ case [ rhs | (lhs, rhs) <- rules, equalTerms t lhs ] of+ rhs : _ -> pure rhs+ [] -> pure t++data FunctionKit = FunctionKit+ { modAux, divAux, natMinus, true, false :: Maybe QName }++simplifyTTerm :: EvaluationStrategy -> TTerm -> TCM TTerm+simplifyTTerm eval t = do+ kit <- FunctionKit <$> getBuiltinName builtinNatModSucAux+ <*> getBuiltinName builtinNatDivSucAux+ <*> getBuiltinName builtinNatMinus+ <*> getBuiltinName builtinTrue+ <*> getBuiltinName builtinFalse+ return $ runS $ simplify eval kit t++simplify :: EvaluationStrategy -> FunctionKit -> TTerm -> S TTerm+simplify eval FunctionKit{ divAux, modAux, natMinus, true, false } =+ simpl+ where+ simpl = rewrite' >=> unchainCase >=> \case++ t@TDef{} -> pure t+ t@TPrim{} -> pure t+ t@TVar{} -> pure t++ TApp (TDef f) [TLit (LitNat 0), m, n, m']+ -- div/mod are equivalent to quot/rem on natural numbers.+ | m == m', Just f == divAux -> simpl $ tOp PQuot n (tPlusK 1 m)+ | m == m', Just f == modAux -> simpl $ tOp PRem n (tPlusK 1 m)++ -- Word64 primitives --++ -- toWord (a ∙ b) == toWord a ∙64 toWord b+ TPFn PITo64 (TPOp op a b)+ | Just op64 <- opTo64 op -> simpl $ tOp op64 (TPFn PITo64 a) (TPFn PITo64 b)+ where+ opTo64 op = lookup op [(PAdd, PAdd64), (PSub, PSub64), (PMul, PMul64),+ (PQuot, PQuot64), (PRem, PRem64)]++ t@(TApp (TPrim _) _) -> pure t -- taken care of by rewrite'++ TCoerce t -> TCoerce <$> simpl t++ TApp f es -> do+ f <- simpl f+ es <- traverse simpl es+ maybeMinusToPrim f es+ TLam b -> TLam <$> underLam (defaultStrictness eval) (simpl b)+ t@TLit{} -> pure t+ t@TCon{} -> pure t+ TLet s e b -> do+ simpl e >>= \case+ TPFn P64ToI a -> do+ -- Inline calls to P64ToI since these trigger optimisations.+ -- Ideally, the optimisations would trigger anyway, but at the+ -- moment they only do if inlining the entire let looks like a+ -- good idea.+ let rho = inplaceS 0 (TPFn P64ToI (TVar 0))+ tLet s a <$> underLet s a (simpl (applySubst rho b))+ e -> tLet s e <$> underLet s e (simpl b)++ TCase x t d bs -> do+ (_, v) <- lookupVar x+ let (lets, u) = tLetView v+ (d, bs) <-+ pruneBoolGuards d <$>+ traverse (simplAlt x (caseInduction t)) bs+ case u of -- TODO: also for literals+ _ | Just (c, as) <- conView u ->+ simpl $ matchCon lets c as (caseInduction t) d bs+ | Just (k, TVar y) <- plusKView u -> simpl . mkLets lets . TCase y t d =<< mapM (matchPlusK y x k) bs+ -- We are not normalizing the case-of-case commuting converison+ -- since it can lead to major code duplication without join points+ -- or continuations. See issue #7595.+ | otherwise -> do+ d <- simpl d+ tCase x t d bs++ t@TUnit -> pure t+ t@TSort -> pure t+ t@TErased -> pure t+ t@TError{} -> pure t++ conView (TCon c) = Just (c, [])+ conView (TApp f as) = second (++ as) <$> conView f+ conView e = Nothing++ -- Collapse chained cases (case x of bs -> vs; _ -> case x of bs' -> vs' ==>+ -- case x of bs -> vs; bs' -> vs')+ unchainCase :: TTerm -> S TTerm+ unchainCase e@(TCase x t d bs) = do+ let (lets, u) = tLetView d+ k = length lets+ case u of+ TCase y _ d' bs' | x + k == y -> do+ lets <- runMaybeT (mapM safeLet lets)+ return $ case lets of+ Just lets ->+ mkLets lets $ TCase y t d' $+ raise k bs ++ filter (`noOverlap` bs) bs'+ Nothing -> e+ _ -> return e+ unchainCase e = return e++ -- If chained cases of the following form are collapsed, and the+ -- lets moved to the outside, then performance could take a hit+ -- (see issue #8767):+ --+ -- case x of+ -- ⋮+ -- _ -> let … in case y of …+ --+ -- If strict evaluation is used, then this transformation is only+ -- allowed if all let bindings are "safe", i.e. non-strict or+ -- (heuristically) cheap to compute. If non-strict evaluation is+ -- used, then "unsafe" bindings are made non-strict.++ safeLet :: (Strictness, TTerm) -> MaybeT S (Strictness, TTerm)+ safeLet l@(NonStrict, _) =+ return l+ safeLet l@(Strict, t) = MaybeT $ do+ t' <- runMaybeT (do+ -- The number 30 does not have any special significance other+ -- than being "not too small, but not very large".+ guard (termSize t < 30)+ cheap t)+ return $ case t' of+ Just t -> Just (Strict, t)+ Nothing -> case eval of+ LazyEvaluation _ -> Just (NonStrict, t)+ EagerEvaluation -> Nothing+ where+ cheap :: TTerm -> MaybeT S TTerm+ cheap t = case t of+ -- Error calls should definitely not be evaluated prematurely.+ TError{} -> empty+ -- Case expressions and top-level definitions are treated as+ -- expensive.+ TCase{} -> empty+ TDef{} -> empty+ -- Strictly bound variables are treated as cheap.+ TVar x -> do+ (s, _) <- lift (lookupVar x)+ case s of+ NonStrict -> empty+ Strict -> return t+ -- Lets, coercions and applications of primitives are handled+ -- recursively.+ TLet s t1 t2 -> uncurry TLet <$> safeLet (s, t1) <*> cheap t2+ TCoerce t -> TCoerce <$> cheap t+ TApp t args -> case t of+ TPrim p -> TApp <$> (if cheapPrim p then return (TPrim p)+ else empty)+ <*> mapM cheap args+ _ -> empty+ -- Things that are known to be (basically) values are treated+ -- as cheap.+ TPrim{} -> return t+ TLam{} -> return t+ TLit{} -> return t+ TCon{} -> return t+ TUnit{} -> return t+ TSort{} -> return t+ TErased{} -> return t++ cheapPrim = \case+ -- String comparison might be expensive.+ PEqS -> False+ -- If expressions are treated as expensive, just like case+ -- expressions.+ PIf -> False+ -- All other primitives are treated as cheap, including PSeq.+ PSeq -> True+ PAdd -> True+ PAdd64 -> True+ PSub -> True+ PSub64 -> True+ PMul -> True+ PMul64 -> True+ PQuot -> True+ PQuot64 -> True+ PRem -> True+ PRem64 -> True+ PGeq -> True+ PLt -> True+ PLt64 -> True+ PEqI -> True+ PEq64 -> True+ PEqF -> True+ PEqC -> True+ PEqQ -> True+ PITo64 -> True+ P64ToI -> True++ mkLets es b = foldr (uncurry TLet) b es++ matchCon _ _ _ _ d [] = d+ matchCon lets c as i d (TALit{} : bs) = matchCon lets c as i d bs+ matchCon lets c as i d (TAGuard{} : bs) = matchCon lets c as i d bs+ matchCon lets c as i d (TACon c' a b : bs)+ | c == c' = flip (foldr (uncurry TLet)) lets $+ mkLet 0 as (raiseFrom a (length lets) b)+ | otherwise = matchCon lets c as i d bs+ where+ s = defaultConstructorStrictness eval i++ mkLet _ [] b = b+ mkLet i (a : as) b = TLet s (raise i a) $ mkLet (i + 1) as b++ -- Simplify let y = x + k in case y of j -> u; _ | g[y] -> v+ -- to let y = x + k in case x of j - k -> u; _ | g[x + k] -> v+ matchPlusK :: Int -> Int -> Integer -> TAlt -> S TAlt+ matchPlusK x y k (TALit (LitNat j) b) = return $ TALit (LitNat (j - k)) b+ matchPlusK x y k (TAGuard g b) = flip TAGuard b <$> simpl (applySubst (inplaceS y (tPlusK k (TVar x))) g)+ matchPlusK x y k TACon{} = __IMPOSSIBLE__+ matchPlusK x y k TALit{} = __IMPOSSIBLE__++ simplPrim (TApp f@TPrim{} args) = do+ args <- mapM simpl args+ inlined <- mapM inline args+ let u = TApp f args+ v = simplPrim' (TApp f inlined)+ pure $ if v `betterThan` u then v else u+ where+ inline (TVar x) = do+ (_, v) <- lookupVar x+ if v == TVar x then pure v else inline v+ inline (TApp f@TPrim{} args) = TApp f <$> mapM inline args+ inline u@(TLet _ _ (TCase 0 _ _ _)) = pure u+ inline (TLet _ e b) = inline (subst 0 e b)+ inline u = pure u+ simplPrim t = pure t++ simplPrim' :: TTerm -> TTerm+ simplPrim' (TApp (TPrim PSeq) (u : v : vs))+ | u == v = mkTApp v vs+ | TApp TCon{} _ <- u = mkTApp v vs+ | TApp TLit{} _ <- u = mkTApp v vs+ simplPrim' (TApp (TPrim PLt) [u, v])+ | Just (PAdd, k, u) <- constArithView u,+ Just (PAdd, j, v) <- constArithView v,+ k == j = tOp PLt u v+ | Just (PSub, k, u) <- constArithView u,+ Just (PSub, j, v) <- constArithView v,+ k == j = tOp PLt v u+ | Just (PAdd, k, v) <- constArithView v,+ TApp (TPrim P64ToI) [u] <- u,+ k >= 2 ^ 64, Just trueCon <- true = TCon trueCon+ | Just k <- intView u+ , Just j <- intView v+ , Just trueCon <- true+ , Just falseCon <- false = if k < j then TCon trueCon else TCon falseCon+ simplPrim' (TApp (TPrim PGeq) [u, v])+ | Just (PAdd, k, u) <- constArithView u,+ Just (PAdd, j, v) <- constArithView v,+ k == j = tOp PGeq u v+ | Just (PSub, k, u) <- constArithView u,+ Just (PSub, j, v) <- constArithView v,+ k == j = tOp PGeq v u+ | Just k <- intView u+ , Just j <- intView v+ , Just trueCon <- true+ , Just falseCon <- false = if k >= j then TCon trueCon else TCon falseCon+ simplPrim' (TApp (TPrim op) [u, v])+ | op `elem` [PGeq, PLt, PEqI]+ , Just (PAdd, k, u) <- constArithView u+ , Just j <- intView v = TApp (TPrim op) [u, tInt (j - k)]+ simplPrim' (TApp (TPrim PEqI) [u, v])+ | Just (op1, k, u) <- constArithView u,+ Just (op2, j, v) <- constArithView v,+ op1 == op2, k == j,+ op1 `elem` [PAdd, PSub] = tOp PEqI u v+ simplPrim' (TPOp op u v)+ | zeroL, isMul || isDiv = tInt 0+ | zeroL, isAdd = v+ | zeroR, isMul = tInt 0+ | zeroR, isAdd || isSub = u+ where zeroL = Just 0 == intView u || Just 0 == word64View u+ zeroR = Just 0 == intView v || Just 0 == word64View v+ isAdd = op `elem` [PAdd, PAdd64]+ isSub = op `elem` [PSub, PSub64]+ isMul = op `elem` [PMul, PMul64]+ isDiv = op `elem` [PQuot, PQuot64, PRem, PRem64]+ simplPrim' (TApp (TPrim op) [u, v])+ | Just u <- negView u,+ Just v <- negView v,+ op `elem` [PMul, PQuot] = tOp op u v+ | Just u <- negView u,+ op `elem` [PMul, PQuot] = simplArith $ tOp PSub (tInt 0) (tOp op u v)+ | Just v <- negView v,+ op `elem` [PMul, PQuot] = simplArith $ tOp PSub (tInt 0) (tOp op u v)+ simplPrim' (TApp (TPrim PRem) [u, v])+ | Just u <- negView u = simplArith $ tOp PSub (tInt 0) (tOp PRem u (unNeg v))+ | Just v <- negView v = tOp PRem u v++ -- (fromWord a == fromWord b) = (a ==64 b)+ simplPrim' (TPOp op (TPFn P64ToI a) (TPFn P64ToI b))+ | Just op64 <- opTo64 op = tOp op64 a b+ where+ opTo64 op = lookup op [(PEqI, PEq64), (PLt, PLt64)]++ -- toWord/fromWord k == fromIntegral k+ simplPrim' (TPFn PITo64 (TLit (LitNat n))) = TLit (LitWord64 (fromIntegral n))+ simplPrim' (TPFn P64ToI (TLit (LitWord64 n))) = TLit (LitNat (fromIntegral n))++ -- toWord (fromWord a) == a+ simplPrim' (TPFn PITo64 (TPFn P64ToI a)) = a++ simplPrim' (TApp f@(TPrim op) [u, v]) = simplArith $ TApp f [simplPrim' u, simplPrim' v]+ simplPrim' u = u++ unNeg u | Just v <- negView u = v+ | otherwise = u++ negView (TApp (TPrim PSub) [a, b])+ | Just 0 <- intView a = Just b+ negView _ = Nothing++ -- Count arithmetic operations+ betterThan u v = operations u <= operations v+ where+ operations (TApp (TPrim _) [a, b]) = 1 + operations a + operations b+ operations (TApp (TPrim PSeq) (a : _))+ | notVar a = 1000000 -- only seq on variables!+ operations (TApp (TPrim _) [a]) = 1 + operations a+ operations TVar{} = 0+ operations TLit{} = 0+ operations TCon{} = 0+ operations TDef{} = 0+ operations _ = 1000++ notVar TVar{} = False+ notVar _ = True++ rewrite' t = rewrite =<< simplPrim t++ constArithView :: TTerm -> Maybe (TPrim, Integer, TTerm)+ constArithView (TApp (TPrim op) [TLit (LitNat k), u])+ | op `elem` [PAdd, PSub] = Just (op, k, u)+ constArithView (TApp (TPrim op) [u, TLit (LitNat k)])+ | op == PAdd = Just (op, k, u)+ | op == PSub = Just (PAdd, -k, u)+ constArithView _ = Nothing++ simplAlt x i (TACon c a b) =+ TACon c a <$>+ underLams (replicate a (defaultConstructorStrictness eval i))+ (maybeAddRewrite (x + a) conTerm $ simpl b)+ where+ conTerm = mkTApp (TCon c) $ map TVar $ downFrom a+ simplAlt x _ (TALit l b) =+ TALit l <$> maybeAddRewrite x (TLit l) (simpl b)+ simplAlt x _ (TAGuard g b) =+ TAGuard <$> simpl g <*> simpl b++ -- If x is already bound we add a rewrite, otherwise we bind x to rhs.+ maybeAddRewrite x rhs cont = do+ (s, v) <- lookupVar x+ case v of+ TVar y | x == y -> bindVar x s rhs $ cont+ _ -> addRewrite v rhs cont++ isTrue (TCon c) = Just c == true+ isTrue _ = False++ isFalse (TCon c) = Just c == false+ isFalse _ = False++ maybeMinusToPrim f@(TDef minus) es@[a, b]+ | Just minus == natMinus = do+ leq <- checkLeq b a+ if leq then pure $ tOp PSub a b+ else tApp f es++ maybeMinusToPrim f es = tApp f es++ tLet _ (TVar x) b = subst 0 (TVar x) b+ tLet _ e (TVar 0) = e+ tLet s e b = TLet s e b++ tCase :: Int -> CaseInfo -> TTerm -> [TAlt] -> S TTerm+ tCase x t d [] = pure d+ tCase x t d bs+ | isUnreachable d =+ case reverse bs' of+ [] -> pure d+ TALit _ b : as -> tCase x t b (reverse as)+ TAGuard _ b : as -> tCase x t b (reverse as)+ TACon c a b : _ -> tCase' x t d bs'+ | otherwise = do+ d' <- lookupIfVar d+ case d' of+ TCase y _ d bs'' | x == y ->+ tCase x t d (bs' ++ filter (`noOverlap` bs') bs'')+ _ -> tCase' x t d bs'+ where+ bs' = filter (not . isUnreachable) bs++ lookupIfVar (TVar i) = snd <$> lookupVar i+ lookupIfVar t = pure t++ noOverlap b bs = not $ any (overlapped b) bs++ overlapped (TACon c _ _) (TACon c' _ _) = c == c'+ overlapped (TALit l _) (TALit l' _) = l == l'+ overlapped _ _ = False++ -- Drop unreachable cases for Nat and Int cases.+ pruneLitCases :: Int -> CaseInfo -> TTerm -> [TAlt] -> S TTerm+ pruneLitCases x t d bs | CTNat == caseType t =+ case complete bs [] Nothing of+ Just bs' -> tCase x t tUnreachable bs'+ Nothing -> return $ TCase x t d bs+ where+ complete bs small (Just upper)+ | null $ [0..upper - 1] List.\\ small = Just []+ complete (b@(TALit (LitNat n) _) : bs) small upper =+ (b :) <$> complete bs (n : small) upper+ complete (b@(TAGuard (TApp (TPrim PGeq) [TVar y, TLit (LitNat j)]) _) : bs) small upper | x == y =+ (b :) <$> complete bs small (Just $ maybe j (min j) upper)+ complete _ _ _ = Nothing++ pruneLitCases x t d bs+ | CTInt == caseType t = return $ TCase x t d bs -- TODO+ | otherwise = return $ TCase x t d bs++ -- Drop 'false' branches and drop everything after 'true' branches (including the default+ -- branch)+ pruneBoolGuards d [] = (d, [])+ pruneBoolGuards d (b@(TAGuard (TCon c) _) : bs)+ | Just c == true = (tUnreachable, [b])+ | Just c == false = pruneBoolGuards d bs+ pruneBoolGuards d (b : bs) =+ second (b :) $ pruneBoolGuards d bs++ tCase' x t d [] = return d+ tCase' x t d bs = pruneLitCases x t d bs++ tApp :: TTerm -> [TTerm] -> S TTerm+ tApp (TLet s e b) es = TLet s e <$> underLet s e (tApp b (raise 1 es))+ tApp (TCase x t d bs) es = do+ d <- tApp d es+ bs <- mapM (flip (tAppAlt (caseInduction t)) es) bs+ simpl $ TCase x t d bs -- will resimplify branches+ tApp (TVar x) es = do+ (_, v) <- lookupVar x+ case v of+ _ | v /= TVar x && isAtomic v -> tApp v es+ TLam{} -> tApp v es -- could blow up the code+ _ -> pure $ mkTApp (TVar x) es+ tApp f [] = pure f+ tApp (TLam b) (TVar i : es) = tApp (subst 0 (TVar i) b) es+ tApp (TLam b) (e : es) =+ tApp (TLet (defaultStrictness eval) e b) es+ -- Applications are strict in strict backends and non-strict in+ -- non-strict backends.+ tApp f es = pure $ TApp f es++ tAppAlt i (TACon c a b) es =+ TACon c a <$>+ underLams (replicate a (defaultConstructorStrictness eval i))+ (tApp b (raise a es))+ tAppAlt _ (TALit l b) es = TALit l <$> tApp b es+ tAppAlt _ (TAGuard g b) es = TAGuard g <$> tApp b es++ isAtomic = \case+ TVar{} -> True+ TCon{} -> True+ TPrim{} -> True+ TDef{} -> True+ TLit{} -> True+ TSort{} -> True+ TErased{} -> True+ TError{} -> True+ _ -> False++ checkLeq a b = do+ rho <- asks envSubst+ rwr <- asks envRewrite+ let nf = toArith . applySubst rho+ less = [ (nf a, nf b) | (TPOp PLt a b, rhs) <- rwr, isTrue rhs ]+ leq = [ (nf b, nf a) | (TPOp PLt a b, rhs) <- rwr, isFalse rhs ]++ match (j, as) (k, bs)+ | as == bs = Just (j - k)+ | otherwise = Nothing++ -- Do we have x ≤ y given x' < y' + d ?+ matchEqn d x y (x', y') = isJust $ do+ k <- match x x' -- x = x' + k+ j <- match y y' -- y = y' + j+ guard (k <= j + d) -- x ≤ y if k ≤ j + d++ matchLess = matchEqn 1+ matchLeq = matchEqn 0++ literal (j, []) (k, []) = j <= k+ literal _ _ = False++ -- k + fromWord x ≤ y if k + 2^64 - 1 ≤ y+ wordUpperBound (k, [Pos (TApp (TPrim P64ToI) _)]) y = go (k + 2 ^ 64 - 1, []) y+ wordUpperBound _ _ = False++ -- x ≤ k + fromWord y if x ≤ k+ wordLowerBound a (k, [Pos (TApp (TPrim P64ToI) _)]) = go a (k, [])+ wordLowerBound _ _ = False++ go x y = or+ [ literal x y+ , wordUpperBound x y+ , wordLowerBound x y+ , any (matchLess x y) less+ , any (matchLeq x y) leq ]++ return $ go (nf a) (nf b)++type Arith = (Integer, [Atom])++data Atom = Pos TTerm | Neg TTerm+ deriving (Show, Eq, Ord)++aNeg :: Atom -> Atom+aNeg (Pos a) = Neg a+aNeg (Neg a) = Pos a++aCancel :: [Atom] -> [Atom]+aCancel (a : as)+ | (aNeg a) `elem` as = aCancel (List.delete (aNeg a) as)+ | otherwise = a : aCancel as+aCancel [] = []++sortR :: Ord a => [a] -> [a]+sortR = List.sortBy (flip compare)++aAdd :: Arith -> Arith -> Arith+aAdd (a, xs) (b, ys) = (a + b, aCancel $ sortR $ xs ++ ys)++aSub :: Arith -> Arith -> Arith+aSub (a, xs) (b, ys) = (a - b, aCancel $ sortR $ xs ++ map aNeg ys)++fromArith :: Arith -> TTerm+fromArith (n, []) = tInt n+fromArith (0, xs)+ | (ys, Pos a : zs) <- break isPos xs = foldl addAtom a (ys ++ zs)+fromArith (n, xs)+ | n < 0, (ys, Pos a : zs) <- break isPos xs =+ tOp PSub (foldl addAtom a (ys ++ zs)) (tInt (-n))+fromArith (n, xs) = foldl addAtom (tInt n) xs++isPos :: Atom -> Bool+isPos Pos{} = True+isPos Neg{} = False++addAtom :: TTerm -> Atom -> TTerm+addAtom t (Pos a) = tOp PAdd t a+addAtom t (Neg a) = tOp PSub t a++toArith :: TTerm -> Arith+toArith t | Just n <- intView t = (n, [])+toArith (TApp (TPrim PAdd) [a, b]) = aAdd (toArith a) (toArith b)+toArith (TApp (TPrim PSub) [a, b]) = aSub (toArith a) (toArith b)+toArith t = (0, [Pos t])++simplArith :: TTerm -> TTerm+simplArith = fromArith . toArith
@@ -0,0 +1,153 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Agda.Compiler.Treeless.Subst where++import qualified Data.IntMap as IntMap+import Data.IntMap (IntMap)+import Data.Maybe+import Data.Semigroup ( All(..), Any(..) )++import Agda.Syntax.Treeless+import Agda.TypeChecking.Substitute++import Agda.Utils.Impossible++instance DeBruijn TTerm where+ deBruijnVar = TVar+ deBruijnView (TVar i) = Just i+ deBruijnView _ = Nothing++instance Subst TTerm where+ type SubstArg TTerm = TTerm++ applySubst IdS = id+ applySubst rho = \case+ t@TDef{} -> t+ t@TLit{} -> t+ t@TCon{} -> t+ t@TPrim{} -> t+ t@TUnit{} -> t+ t@TSort{} -> t+ t@TErased{} -> t+ t@TError{} -> t+ TVar i -> lookupS rho i+ TApp f ts -> tApp (applySubst rho f) (applySubst rho ts)+ TLam b -> TLam (applySubst (liftS 1 rho) b)+ TLet s e b -> TLet s (applySubst rho e)+ (applySubst (liftS 1 rho) b)+ TCase i t d bs ->+ case applySubst rho (TVar i) of+ TVar j -> TCase j t (applySubst rho d) (applySubst rho bs)+ e -> TLet s e $+ TCase 0 t (applySubst rho' d) (applySubst rho' bs)+ where+ rho' = wkS 1 rho+ -- If the match is lazy, use a non-strict let, otherwise a+ -- strict let. Note that, if the backend is strict, then+ -- 'Agda.Compiler.ToTreeless.casetree' makes all matches+ -- strict.+ s = if caseLazy t then NonStrict else Strict+ TCoerce e -> TCoerce (applySubst rho e)+ where+ tApp (TPrim PSeq) [TErased, b] = b+ tApp f ts = TApp f ts++instance Subst TAlt where+ type SubstArg TAlt = TTerm+ applySubst rho (TACon c i b) = TACon c i (applySubst (liftS i rho) b)+ applySubst rho (TALit l b) = TALit l (applySubst rho b)+ applySubst rho (TAGuard g b) = TAGuard (applySubst rho g) (applySubst rho b)++newtype UnderLambda = UnderLambda Any+ deriving (Eq, Ord, Show, Semigroup, Monoid)++newtype SeqArg = SeqArg All+ deriving (Eq, Ord, Show, Semigroup, Monoid)++data Occurs = Occurs Int UnderLambda SeqArg+ deriving (Eq, Ord, Show)++once :: Occurs+once = Occurs 1 mempty (SeqArg $ All False)++inSeq :: Occurs -> Occurs+inSeq (Occurs n l _) = Occurs n l mempty++underLambda :: Occurs -> Occurs+underLambda o = o <> Occurs 0 (UnderLambda $ Any True) mempty++instance Semigroup Occurs where+ Occurs a k s <> Occurs b l t = Occurs (a + b) (k <> l) (s <> t)++instance Monoid Occurs where+ mempty = Occurs 0 mempty mempty+ mappend = (<>)+++-- Andreas, 2019-07-10: this free variable computation should be rewritten+-- in the style of TypeChecking.Free.Lazy.+-- https://github.com/agda/agda/commit/03eb3945114a4ccdb449f22d69db8d6eaa4699b8#commitcomment-34249120+-- András, 2026-02-13: now called TypeChecking.Free.Generic++class HasFree a where+ freeVars :: a -> IntMap Occurs++freeIn :: HasFree a => Int -> a -> Bool+freeIn i x = IntMap.member i (freeVars x)++occursIn :: HasFree a => Int -> a -> Occurs+occursIn i x = fromMaybe mempty $ IntMap.lookup i (freeVars x)++instance HasFree Int where+ freeVars x = IntMap.singleton x once++instance HasFree a => HasFree [a] where+ freeVars xs = IntMap.unionsWith mappend $ map freeVars xs++instance (HasFree a, HasFree b) => HasFree (a, b) where+ freeVars (x, y) = IntMap.unionWith mappend (freeVars x) (freeVars y)++data Binder a = Binder Int a++instance HasFree a => HasFree (Binder a) where+ freeVars (Binder 0 x) = freeVars x+ freeVars (Binder k x) = dropNeg $ IntMap.mapKeysMonotonic (subtract k) $ freeVars x+ where+ -- keep only elements > -1+ dropNeg = snd . IntMap.split (-1)++newtype InSeq a = InSeq a++instance HasFree a => HasFree (InSeq a) where+ freeVars (InSeq x) = inSeq <$> freeVars x++instance HasFree TTerm where+ freeVars = \case+ TDef{} -> IntMap.empty+ TLit{} -> IntMap.empty+ TCon{} -> IntMap.empty+ TPrim{} -> IntMap.empty+ TUnit{} -> IntMap.empty+ TSort{} -> IntMap.empty+ TErased{} -> IntMap.empty+ TError{} -> IntMap.empty+ TVar i -> freeVars i+ TApp (TPrim PSeq) [TVar x, b] -> freeVars (InSeq x, b)+ TApp f ts -> freeVars (f, ts)+ TLam b -> underLambda <$> freeVars (Binder 1 b)+ TLet _ e b -> freeVars (e, Binder 1 b)+ TCase i _ d bs -> freeVars (i, (d, bs))+ TCoerce t -> freeVars t++instance HasFree TAlt where+ freeVars = \case+ TACon _ i b -> freeVars (Binder i b)+ TALit _ b -> freeVars b+ TAGuard g b -> freeVars (g, b)++-- | Strenghtening.+tryStrengthen :: (HasFree a, Subst a) => Int -> a -> Maybe a+tryStrengthen n t =+ case IntMap.minViewWithKey (freeVars t) of+ Just ((i, _), _) | i < n -> Nothing+ _ -> Just $ applySubst (strengthenS impossible n) t
@@ -0,0 +1,70 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.Uncase (caseToSeq) where++import Agda.Syntax.Treeless+import Agda.TypeChecking.Substitute+import Agda.Compiler.Treeless.Subst+import Agda.Compiler.Treeless.Compare++import Agda.Utils.List++import Agda.Utils.Impossible++caseToSeq :: Monad m => TTerm -> m TTerm+caseToSeq t = return $ uncase t++uncase :: TTerm -> TTerm+uncase t = case t of+ TVar{} -> t+ TPrim{} -> t+ TDef{} -> t+ TApp f es -> tApp (uncase f) (map uncase es)+ TLam b -> TLam $ uncase b+ TLit{} -> t+ TCon{} -> t+ TLet s e b -> tLet s (uncase e) (uncase b)+ TCase x t d bs -> doCase x t (uncase d) (map uncaseAlt bs)+ TUnit{} -> t+ TSort{} -> t+ TErased{} -> t+ TError{} -> t+ TCoerce t -> TCoerce (uncase t)+ where+ uncaseAlt (TACon c a b) = TACon c a $ uncase b+ uncaseAlt (TALit l b) = TALit l $ uncase b+ uncaseAlt (TAGuard g b) = TAGuard (uncase g) (uncase b)++ doCase x t d bs+ | Just u <- mu,+ all (equalTo x u) bs = maybeSeq u+ | otherwise = fallback+ where+ maybeSeq u | caseLazy t = u+ | otherwise = tApp (TPrim PSeq) [TVar x, u]+ fallback = TCase x t d bs+ (fv, mu)+ | isUnreachable d =+ case lastWithDefault __IMPOSSIBLE__ bs of+ TACon _ a b -> (a, tryStrengthen a b)+ TALit l b -> (0, Just b)+ TAGuard _ b -> (0, Just b)+ | otherwise = (0, Just d)++ equalTo :: Int -> TTerm -> TAlt -> Bool+ equalTo x t (TACon c a b)+ | Just b' <- tryStrengthen a b = equalTerms (subst x v t) (subst x v b')+ | otherwise = False+ where v = mkTApp (TCon c) (replicate a TErased)+ equalTo x t (TALit l b) = equalTerms (subst x (TLit l) t) (subst x (TLit l) b)+ equalTo x t (TAGuard _ b) = equalTerms t b++ tLet s e b =+ case occursIn 0 b of+ Occurs 0 _ _ -> strengthen impossible b+ _ -> TLet s e b++ -- Primitive operations are already strict+ tApp (TPrim PSeq) [_, b@(TApp (TPrim op) _)]+ | op `elem` [PAdd, PSub, PMul, PLt, PGeq, PRem, PQuot] || isPrimEq op = b+ tApp f es = TApp f es
@@ -0,0 +1,101 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Compiler.Treeless.Unused+ ( usedArguments+ , stripUnusedArguments+ ) where++import Prelude hiding (null, zip, zipWith)++import Data.Maybe++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty ( prettyShow )+import Agda.Syntax.Treeless+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Substitute++import Agda.Compiler.Treeless.Pretty () -- instance only++import Agda.Utils.Function ( iterateUntilM )+import Agda.Utils.List ( downFrom, takeExactly )+import Agda.Utils.ListInf qualified as ListInf+import Agda.Utils.Null+import Agda.Utils.Singleton+import qualified Agda.Utils.VarSet as VarSet+import Agda.Utils.Zip++usedArguments :: QName -> TTerm -> TCM [ArgUsage]+usedArguments q t = computeUnused q b (replicate n ArgUnused)+ where (n, b) = tLamView t++-- | Saturation algorithm, starting with all unused arguments+-- and adding usages until fixed-point has been reached.++computeUnused :: QName -> TTerm -> [ArgUsage] -> TCM [ArgUsage]+computeUnused q t = iterateUntilM (==) $ \ used -> do++ reportSLn "treeless.opt.unused" 50 $ concat+ [ "Unused approximation for ", prettyShow q, ": "+ , unwords [ if u == ArgUsed then [x] else "_" | (x, u) <- zip (ListInf.upFrom 'a') used ]+ ]+ -- Update usage information q to so far "best" value.+ setCompiledArgUse q used++ -- The new usage information is the free variables of @t@,+ -- computed under the current usage assumptions of the functions it calls.+ fv <- go t+ return $ [ if VarSet.member i fv then ArgUsed else ArgUnused+ | i <- downFrom (length used)+ ]+ where+ go = \case+ TVar x -> pure $ singleton x+ TPrim{} -> pure empty+ TDef{} -> pure empty+ TLit{} -> pure empty+ TCon{} -> pure empty++ TApp (TDef f) ts -> do+ used <- fromMaybe [] <$> getCompiledArgUse f+ VarSet.unions <$> sequence [ go t | (t, ArgUsed) <- zip ts $ ListInf.pad used ArgUsed ]++ TApp f ts -> VarSet.unions <$> mapM go (f : ts)+ TLam b -> underBinder <$> go b+ TLet _ e b -> do+ uses <- go b+ if | VarSet.member 0 uses -> VarSet.union (underBinder uses) <$> go e+ | otherwise -> pure (underBinder uses)+ TCase x i d bs ->+ let e = caseErased i+ cont = VarSet.unions <$> ((:) <$> go d <*> mapM (goAlt e) bs) in+ case e of+ Erased{} -> cont+ NotErased{} -> VarSet.insert x <$> cont+ TUnit{} -> pure empty+ TSort{} -> pure empty+ TErased{} -> pure empty+ TError{} -> pure empty+ TCoerce t -> go t++ goAlt _ (TALit _ b) = go b+ goAlt e (TAGuard g b) = case e of+ NotErased{} -> VarSet.union <$> go g <*> go b+ Erased{} -> -- The guard will not be executed if the match+ -- is on an erased argument.+ go b+ goAlt _ (TACon _ a b) = underBinders a <$> go b++ underBinder = underBinders 1+ underBinders n = VarSet.strengthen n++stripUnusedArguments :: [ArgUsage] -> TTerm -> TTerm+stripUnusedArguments used t = mkTLam m $ applySubst rho b+ where+ (n, b) = tLamView t+ m = length $ filter (== ArgUsed) used'+ used' = reverse $ takeExactly ArgUsed n used+ rho = computeSubst used'+ computeSubst (ArgUnused : bs) = TErased :# computeSubst bs+ computeSubst (ArgUsed : bs) = liftS 1 $ computeSubst bs+ computeSubst [] = idS
@@ -1,8 +1,22 @@-{-# LANGUAGE CPP #-}+-- | Facility to test throwing internal errors.+ module Agda.ImpossibleTest where -import Agda.Utils.Impossible+import Agda.TypeChecking.Monad.Base ( TCM, ReduceM, runReduceM )+import Agda.TypeChecking.Monad.Debug ( MonadDebug, __IMPOSSIBLE_VERBOSE__ )+import Agda.TypeChecking.Reduce.Monad () -#include "undefined.h"+import Agda.Utils.CallStack ( HasCallStack )+import Agda.Utils.Impossible ( __IMPOSSIBLE__ ) -impossibleTest = __IMPOSSIBLE__+-- | If the given list of words is non-empty, print them as debug message+-- (using '__IMPOSSIBLE_VERBOSE__') before raising the internal error.+impossibleTest :: (MonadDebug m, HasCallStack) => [String] -> m a+impossibleTest = \case+ [] -> __IMPOSSIBLE__+ strs -> __IMPOSSIBLE_VERBOSE__ $ unwords strs++impossibleTestReduceM :: (HasCallStack) => [String] -> TCM a+impossibleTestReduceM = runReduceM . \case+ [] -> __IMPOSSIBLE__+ strs -> __IMPOSSIBLE_VERBOSE__ $ unwords strs
@@ -0,0 +1,87 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.AgdaTop+ ( repl+ ) where++import Control.Monad ( unless )+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.State ( evalStateT, runStateT )+import Control.Monad.Trans ( lift )++import Data.Char++import System.IO++import Agda.Interaction.Base+import Agda.Interaction.ExitCode+import Agda.Interaction.Response as R+import Agda.Interaction.InteractionTop+import Agda.Interaction.Options+import Agda.Interaction.Command ( CommandM )++import Agda.TypeChecking.Monad+import qualified Agda.TypeChecking.Monad.Benchmark as Bench++----------------------------------++-- | 'repl' is a fake ghci interpreter for both the Emacs the JSON frontend+repl :: InteractionOutputCallback -> String -> TCM () -> TCM ()+repl callback prompt setup = do+ liftIO $ do+ hSetBuffering stdout LineBuffering+ hSetBuffering stdin LineBuffering+ hSetEncoding stdout utf8+ hSetEncoding stdin utf8++ setInteractionOutputCallback callback++ commands <- liftIO $ initialiseCommandQueue readCommand++ handleCommand_ (lift setup) `evalStateT` initCommandState commands++ opts <- commandLineOptions+ _ <- interact' `runStateT`+ (initCommandState commands)+ { optionsOnReload = opts{ optAbsoluteIncludePaths = [] } }+ return ()+ where+ interact' :: CommandM ()+ interact' = do+ Bench.reset+ done <- Bench.billTo [] $ do++ liftIO $ do+ putStr prompt+ hFlush stdout+ r <- maybeAbort runInteraction+ case r of+ Done -> return True -- Done.+ Command _ -> return False+ Error s -> do+ exit <- optExitOnError <$> commandLineOptions+ if exit+ then liftIO (exitAgdaWith CommandError)+ else do+ liftIO (putStrLn s)+ return False++ lift Bench.print+ unless done interact'++ -- Reads the next command from stdin.++ readCommand :: IO Command+ readCommand = do+ done <- isEOF+ if done then+ return Done+ else do+ r <- getLine+ _ <- return $! length r -- force to read the full input line+ case dropWhile isSpace r of+ "" -> readCommand+ ('-':'-':_) -> readCommand+ _ -> case parseIOTCM r of+ Right cmd -> return $ Command cmd+ Left err -> return $ Error err
@@ -0,0 +1,542 @@+{-# OPTIONS_GHC -fno-cse #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Agda.Interaction.Base where++import Control.Applicative ( liftA3 )+import Control.Concurrent.STM.TChan+import Control.Concurrent.STM.TVar+import Control.Monad ( mplus, liftM2, liftM4 )+import Control.Monad.Except+import Control.Monad.Identity+import Control.Monad.State++import qualified Data.List as List+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe (listToMaybe)+import qualified Data.Text as T++import Agda.TypeChecking.Monad.Base.Types+ (HighlightingLevel, HighlightingMethod, Comparison, Polarity)++import Agda.Syntax.Abstract (QName)+import Agda.Syntax.Common (BackendName, InteractionId (..), Modality)+import Agda.Syntax.Internal (ProblemId, Blocker)+import Agda.Syntax.Position+import Agda.Syntax.Scope.Base (ScopeInfo)+import Agda.Syntax.TopLevelModuleName++import Agda.Interaction.Options (CommandLineOptions,+ defaultOptions)++import Agda.Utils.FileName (AbsolutePath, mkAbsolute)+import Agda.Syntax.Common.Pretty (Pretty(..), prettyShow, text)+import Agda.Utils.Time (ClockTime)++------------------------------------------------------------------------+-- The CommandM monad++-- | Auxiliary state of an interactive computation.++data CommandState = CommandState+ { theInteractionPoints :: [InteractionId]+ -- ^ The interaction points of the buffer, in the order in which+ -- they appear in the buffer. The interaction points are+ -- recorded in 'theTCState', but when new interaction points are+ -- added by give or refine Agda does not ensure that the ranges+ -- of later interaction points are updated.+ --+ -- For example, consider a term @cons ?0 ?1@ with some ranges @r0@ @r1@@+ -- for the two interaction points.+ -- We refine @?0 := cons ?2 ?3@.+ -- The new interaction points will get ranges @r2 = r3 = r0@.+ -- We cannot do much better than that, as they are constrained by+ -- @r0 ≤ r2 ≤ r3 < r1@.+ -- At this point @('Range','InteractionId')@ still orders the IPs correctly.+ -- Now we refine @?2 := cons ?4 ?5@ with @r4 = r5 = r2@;+ -- this breaks the order maintained by @('Range','InteractionId')@.+ --+ -- So we need some other structure to remember the correct order of IPs.+ -- The list 'theInteractionPoints' serves this purpose.+ --+ -- Alternatively, we could maintain for entries in 'InteractionPoints'+ -- a path @p : Genesis = [Int]@ into their genesis tree.+ -- E.g. for @?2@ we would have @p2 = [0]@ (the first child of @?0@)+ -- and @p3 = [1]@ (the second child of @?0@).+ -- Then @p4 = [0,0]@ and @p5 = [0,1]@.+ -- The order @('Range','Genesis')@ would be correct then.+ , theCurrentFile :: Maybe CurrentFile+ -- ^ The file which the state applies to. Only stored if the+ -- module was successfully type checked (potentially with+ -- warnings).+ , theCurrentFilePath :: Maybe AbsolutePath+ -- ^ The path supplied by the current interaction command. Unlike+ -- 'theCurrentFile', this is available while a file is being loaded,+ -- even if loading fails.+ , optionsOnReload :: CommandLineOptions+ -- ^ Reset the options on each reload to these.+ , oldInteractionScopes :: !OldInteractionScopes+ -- ^ We remember (the scope of) old interaction points to make it+ -- possible to parse and compute highlighting information for the+ -- expression that it got replaced by.+ , commandQueue :: !CommandQueue+ -- ^ The command queue.+ --+ -- This queue should only be manipulated by+ -- 'initialiseCommandQueue' and 'maybeAbort'.+ }++type OldInteractionScopes = Map InteractionId ScopeInfo++-- | Initial auxiliary interaction state++initCommandState :: CommandQueue -> CommandState+initCommandState commandQueue =+ CommandState+ { theInteractionPoints = []+ , theCurrentFile = Nothing+ , theCurrentFilePath = Nothing+ , optionsOnReload = defaultOptions+ , oldInteractionScopes = Map.empty+ , commandQueue = commandQueue+ }++-- | Information about the current main module.+data CurrentFile = CurrentFile+ { currentFilePath :: AbsolutePath+ -- ^ The file currently loaded into interaction.+ , currentFileModule :: TopLevelModuleName+ -- ^ The top-level module name of the currently loaded file.+ , currentFileArgs :: [String]+ -- ^ The arguments to Agda used for loading the file.+ , currentFileStamp :: ClockTime+ -- ^ The modification time stamp of the file when it was loaded.+ } deriving (Show)++type CommandM' = StateT CommandState++------------------------------------------------------------------------+-- Command queues++-- | A generalised command type.++data Command' a+ = Command !a+ -- ^ A command.+ | Done+ -- ^ Stop processing commands.+ | Error String+ -- ^ An error message for a command that could not be parsed.+ deriving Show++-- | IOTCM commands.++type Command = Command' IOTCM++-- | IOTCM commands.+--+-- The commands are obtained by applying the functions to the current+-- top-level module name, if any. Note that the top-level module name+-- is not used by independent commands. For other commands the+-- top-level module name should be known.++type IOTCM = Maybe TopLevelModuleName -> IOTCM' Range++-- | Command queues.++data CommandQueue = CommandQueue+ { commands :: !(TChan (Integer, Command))+ -- ^ Commands that should be processed, in the order in which they+ -- should be processed. Each command is associated with a number,+ -- and the numbers are strictly increasing. Abort commands are not+ -- put on this queue.+ , abort :: !(TVar (Maybe Integer))+ -- ^ When this variable is set to @Just n@ an attempt is made to+ -- abort all commands with a command number that is at most @n@.+ }+++----------------------------------------------------------------------------+-- | An interactive computation.++type Interaction = Interaction' Range++data Interaction' range+ -- | @cmd_load m argv@ loads the module in file @m@, using+ -- @argv@ as the command-line options.+ = Cmd_load FilePath [String]++ -- | Show constraints on goals.+ | Cmd_constraints Rewrite++ -- | Show unsolved metas. If there are no unsolved metas but unsolved constraints+ -- show those instead.+ | Cmd_metas Rewrite++ -- | Load a file and fail if there are any unsolved+ -- meta-variables. By default no output is generated if the+ -- command is successful.+ -- (This command was previously used in Agda's installation script (Setup.hs)).+ | Cmd_load_no_metas FilePath++ -- | Shows all the top-level names in the given module, along with+ -- their types. Uses the top-level scope.+ | Cmd_show_module_contents_toplevel Rewrite String++ -- | Shows all the top-level names in scope which mention all the given+ -- identifiers in their type.+ | Cmd_search_about_toplevel Rewrite String++ -- | Solve (all goals / the goal at point) whose values are determined by+ -- the constraints.+ | Cmd_solveAll Rewrite+ | Cmd_solveOne Rewrite InteractionId range String++ -- | Solve (all goals / the goal at point) by using Mimer proof search.+ | Cmd_autoOne Rewrite InteractionId range String+ | Cmd_autoAll Rewrite++ -- | Parse the given expression (as if it were defined at the+ -- top-level of the current module) and infer its type.+ | Cmd_infer_toplevel Rewrite -- Normalise the type?+ String++ -- | Parse and type check the given expression (as if it were defined+ -- at the top-level of the current module) and normalise it.+ | Cmd_compute_toplevel ComputeMode String++ ------------------------------------------------------------------------+ -- Backend commands++ -- | @cmd_compile b m argv@ compiles the module in file @m@ using+ -- the backend @b@, using @argv@ as the command-line options.+ | Cmd_compile CompilerBackend FilePath [String]++ -- | Custom top-level command for backends.+ | Cmd_backend_top+ CompilerBackend -- ^ which backend+ String -- ^ arbitrary user payload++ -- | Custom hole-level command for backends.+ | Cmd_backend_hole+ InteractionId -- ^ the hole's ID+ range -- ^ range of the hole+ String -- ^ text inside the hole+ CompilerBackend -- ^ which backend+ String -- ^ arbitrary payload++ ------------------------------------------------------------------------+ -- Syntax highlighting++ -- | @cmd_load_highlighting_info source@ loads syntax highlighting+ -- information for the module in @source@, and asks Emacs to apply+ -- highlighting info from this file.+ --+ -- If the module does not exist, or its module name is malformed or+ -- cannot be determined, or the module has not already been visited,+ -- or the cached info is out of date, then no highlighting information+ -- is printed.+ --+ -- This command is used to load syntax highlighting information when a+ -- new file is opened, and it would probably be annoying if jumping to+ -- the definition of an identifier reset the proof state, so this+ -- command tries not to do that. One result of this is that the+ -- command uses the current include directories, whatever they happen+ -- to be.+ | Cmd_load_highlighting_info FilePath++ -- | Tells Agda to compute token-based highlighting information+ -- for the file.+ --+ -- This command works even if the file's module name does not+ -- match its location in the file system, or if the file is not+ -- scope-correct. Furthermore no file names are put in the+ -- generated output. Thus it is fine to put source code into a+ -- temporary file before calling this command. However, the file+ -- extension should be correct.+ --+ -- If the second argument is 'Remove', then the (presumably+ -- temporary) file is removed after it has been read.+ | Cmd_tokenHighlighting FilePath Remove++ -- | Tells Agda to compute highlighting information for the expression just+ -- spliced into an interaction point.+ | Cmd_highlight InteractionId range String++ ------------------------------------------------------------------------+ -- Implicit arguments++ -- | Tells Agda whether or not to show implicit arguments.+ | ShowImplicitArgs Bool-- Show them?+++ -- | Toggle display of implicit arguments.+ | ToggleImplicitArgs++ ------------------------------------------------------------------------+ -- Irrelevant arguments++ -- | Tells Agda whether or not to show irrelevant arguments.+ | ShowIrrelevantArgs Bool -- Show them?++ -- | Toggle display of irrelevant arguments.+ | ToggleIrrelevantArgs++ ------------------------------------------------------------------------+ -- | Goal commands+ --+ -- If the range is 'noRange', then the string comes from the+ -- minibuffer rather than the goal.++ | Cmd_give UseForce InteractionId range String++ | Cmd_refine InteractionId range String++ | Cmd_intro Bool InteractionId range String++ | Cmd_refine_or_intro Bool InteractionId range String++ | Cmd_context Rewrite InteractionId range String++ | Cmd_helper_function Rewrite InteractionId range String++ | Cmd_infer Rewrite InteractionId range String++ | Cmd_goal_type Rewrite InteractionId range String++ -- | Grabs the current goal's type and checks the expression in the hole+ -- against it. Returns the elaborated term.+ | Cmd_elaborate_give+ Rewrite InteractionId range String++ -- | Displays the current goal and context.+ | Cmd_goal_type_context Rewrite InteractionId range String++ -- | Displays the current goal and context /and/ infers the type of an+ -- expression.+ | Cmd_goal_type_context_infer+ Rewrite InteractionId range String++ -- | Grabs the current goal's type and checks the expression in the hole+ -- against it.+ | Cmd_goal_type_context_check+ Rewrite InteractionId range String++ -- | Shows all the top-level names in the given module, along with+ -- their types. Uses the scope of the given goal.+ | Cmd_show_module_contents+ Rewrite InteractionId range String++ | Cmd_make_case InteractionId range String++ | Cmd_compute ComputeMode+ InteractionId range String++ | Cmd_why_in_scope InteractionId range String+ | Cmd_why_in_scope_toplevel String+ -- | Displays version of the running Agda+ | Cmd_show_version+ | Cmd_abort+ -- ^ Abort the current computation.+ --+ -- Does nothing if no computation is in progress.+ | Cmd_exit+ -- ^ Exit the program.+ deriving (Show, Read, Functor, Foldable, Traversable)++data IOTCM' range+ = IOTCM+ FilePath+ -- -^ The current file. If this file does not match+ -- 'theCurrentFile, and the 'Interaction' is not+ -- \"independent\", then an error is raised.+ HighlightingLevel+ HighlightingMethod+ (Interaction' range)+ -- -^ What to do+ deriving (Show, Read, Functor, Foldable, Traversable)++-- | Used to indicate whether something should be removed or not.++data Remove+ = Remove+ | Keep+ deriving (Show, Read)+++++---------------------------------------------------------+-- Read instances++-- | An 'IOTCM' parser.+--+-- If the parse fails, then an error message is returned.++parseIOTCM ::+ String -> Either String IOTCM+parseIOTCM s = case listToMaybe $ reads s of+ Just (x, "") -> Right $ \top -> case x of+ IOTCM f l m i -> IOTCM f l m $+ (fmap . fmap . fmap) (\rf -> mkRangeFile (rangeFilePath rf) top) i+ Just (_, rem) -> Left $ "not consumed: " ++ rem+ _ -> Left $ "cannot read: " ++ s++-- | The 'Parse' monad.+-- 'StateT' state holds the remaining input.++type Parse a = ExceptT String (StateT String Identity) a++-- | Converter from the type of 'reads' to 'Parse'+-- The first paramter is part of the error message+-- in case the parse fails.++readsToParse :: String -> (String -> Maybe (a, String)) -> Parse a+readsToParse s f = do+ st <- lift get+ case f st of+ Nothing -> throwError s+ Just (a, st) -> do+ lift $ put st+ return a++parseToReadsPrec :: Parse a -> Int -> String -> [(a, String)]+parseToReadsPrec p i s = case runIdentity . flip runStateT s . runExceptT $ parens' p of+ (Right a, s) -> [(a,s)]+ _ -> []++-- | Demand an exact string.++exact :: String -> Parse ()+exact s = readsToParse (show s) $ fmap ((),) . List.stripPrefix s . dropWhile (== ' ')++readParse :: Read a => Parse a+readParse = readsToParse "read failed" $ listToMaybe . reads++parens' :: Parse a -> Parse a+parens' p = do+ exact "("+ x <- p+ exact ")"+ return x+ `mplus`+ p++instance Read InteractionId where+ readsPrec = parseToReadsPrec $+ fmap InteractionId readParse++-- | Note that the grammar implemented by this instance does not+-- necessarily match the current representation of ranges.++instance Read a => Read (Range' a) where+ readsPrec = parseToReadsPrec $+ (exact "intervalsToRange" >>+ liftM2 intervalsToRange readParse readParse)+ `mplus`+ (exact "noRange" >> return noRange)++instance Read a => Read (Interval' a) where+ readsPrec = parseToReadsPrec $ do+ exact "Interval"+ liftA3 Interval readParse readParse readParse++instance Read AbsolutePath where+ readsPrec = parseToReadsPrec $ do+ exact "mkAbsolute"+ fmap mkAbsolute readParse++-- | This instance fills in the 'TopLevelModuleName's using 'Nothing'.+-- Note that these occurrences of 'Nothing' are \"overwritten\" by+-- 'parseIOTCM'.++instance Read RangeFile where+ readsPrec = parseToReadsPrec $+ fmap (flip mkRangeFile Nothing) readParse++instance Read a => Read (Position' a) where+ readsPrec = parseToReadsPrec $ do+ exact "Pn"+ liftM4 Pn readParse readParse readParse readParse++---------------------------------------------------------+-- | Available backends.++data CompilerBackend = LaTeX | QuickLaTeX | OtherBackend BackendName+ deriving (Eq)++-- TODO 2021-08-25 get rid of custom Show instance+instance Show CompilerBackend where+ show = prettyShow++instance Pretty CompilerBackend where+ pretty = \case+ LaTeX -> "LaTeX"+ QuickLaTeX -> "QuickLaTeX"+ OtherBackend s -> pretty s++instance Read CompilerBackend where+ readsPrec _ s = do+ (t, s) <- lex s+ let b = case t of+ "LaTeX" -> LaTeX+ "QuickLaTeX" -> QuickLaTeX+ _ -> OtherBackend $ T.pack t+ return (b, s)++-- | Ordered ascendingly by degree of normalization.+data Rewrite = AsIs | Instantiated | HeadNormal | Simplified | Normalised+ deriving (Show, Read, Eq, Ord)++-- | Modifier for the interactive computation command,+-- specifying the mode of computation and result display.+--+data ComputeMode+ = DefaultCompute+ -- ^ Fully 'normalise'.+ | HeadCompute+ -- ^ 'reduce' to weak head normal form.+ | IgnoreAbstract+ -- ^ 'normalise', unfolding even @abstract@ and @NON_TERMINATING@ definitions.+ | UseShowInstance+ -- ^ 'normalise' to a string literal and wrap it in a @show@.+ deriving (Show, Read, Eq)++data UseForce+ = WithForce -- ^ Ignore additional checks, like termination/positivity...+ | WithoutForce -- ^ Don't ignore any checks.+ deriving (Eq, Read, Show)++data OutputForm_boot tcErr a b = OutputForm Range [ProblemId] Blocker (OutputConstraint_boot tcErr a b)+ deriving (Functor)++data OutputConstraint_boot tcErr a b+ = OfType b a | CmpInType Comparison a b b+ | CmpElim [Polarity] a [b] [b]+ | JustType b | CmpTypes Comparison b b+ | CmpLevels Comparison b b+ | CmpTeles Comparison b b+ | JustSort b | CmpSorts Comparison b b+ | Assign b a | TypedAssign b a a | PostponedCheckArgs b [a] a a+ | IsEmptyType a+ | SizeLtSat a+ | FindInstanceOF b a [(a,a,a)]+ | ResolveInstanceOF QName+ | PTSInstance b b+ | PostponedCheckFunDef QName a tcErr+ | CheckLock b b+ | DataSort QName b+ | UsableAtMod Modality b+ deriving (Functor)++-- | A subset of 'OutputConstraint'.++data OutputConstraint' a b = OfType'+ { ofName :: b+ , ofExpr :: a+ }++data OutputContextEntry name ty val+ = ContextVar name ty+ | ContextLet name ty val
@@ -1,551 +1,1514 @@-{-# LANGUAGE CPP, MultiParamTypeClasses, FlexibleInstances,- UndecidableInstances, DeriveFunctor- #-}--module Agda.Interaction.BasicOps where--import Control.Applicative-import Control.Monad.Error-import Control.Monad.Reader-import Control.Monad.State-import qualified Data.Map as Map-import Data.Map (Map)-import Data.List-import Data.Maybe--import qualified Agda.Syntax.Concrete as C -- ToDo: Remove with instance of ToConcrete-import Agda.Syntax.Position-import Agda.Syntax.Abstract as A hiding (Open)-import Agda.Syntax.Common-import Agda.Syntax.Info(ExprInfo(..),MetaInfo(..))-import Agda.Syntax.Internal as I-import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Translation.AbstractToConcrete-import Agda.Syntax.Translation.ConcreteToAbstract-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad-import Agda.Syntax.Fixity(Precedence(..))-import Agda.Syntax.Parser--import Agda.TypeChecker-import Agda.TypeChecking.Conversion-import Agda.TypeChecking.Monad as M-import Agda.TypeChecking.MetaVars-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Telescope-import Agda.TypeChecking.EtaContract (etaContract)-import Agda.TypeChecking.Coverage-import Agda.TypeChecking.Records-import Agda.TypeChecking.Irrelevance (wakeIrrelevantVars)-import Agda.TypeChecking.Pretty (prettyTCM)-import Agda.TypeChecking.Eliminators (unElim)-import qualified Agda.TypeChecking.Pretty as TP--import Agda.Utils.List-import Agda.Utils.Monad-import Agda.Utils.Pretty-import Agda.Utils.Permutation-import Agda.Utils.Size--#include "../undefined.h"-import Agda.Utils.Impossible---- | Parses an expression.--parseExpr :: Range -> String -> TCM C.Expr-parseExpr rng s = liftIO $ parsePosString exprParser pos s- where- pos = case rStart rng of- Just pos -> pos- Nothing -> startPos Nothing--parseExprIn :: InteractionId -> Range -> String -> TCM Expr-parseExprIn ii rng s = do- mId <- lookupInteractionId ii- updateMetaVarRange mId rng- mi <- getMetaInfo <$> lookupMeta mId- e <- parseExpr rng s- concreteToAbstract (clScope mi) e--giveExpr :: MetaId -> Expr -> TCM Expr--- When translator from internal to abstract is given, this function might return--- the expression returned by the type checker.-giveExpr mi e =- do mv <- lookupMeta mi- withMetaInfo (getMetaInfo mv) $ metaTypeCheck' mi e mv-- where metaTypeCheck' mi e mv =- case mvJudgement mv of- HasType _ t -> do- ctx <- getContextArgs- let t' = t `piApply` ctx- v <- checkExpr e t'- case mvInstantiation mv of- InstV v' -> equalTerm t' v (v' `apply` ctx)- _ -> updateMeta mi v- reify v- IsSort{} -> __IMPOSSIBLE__--give :: InteractionId -> Maybe Range -> Expr -> TCM (Expr,[InteractionId])-give ii mr e = liftTCM $ do- mi <- lookupInteractionId ii- mis <- getInteractionPoints- r <- getInteractionRange ii- updateMetaVarRange mi $ maybe r id mr- giveExpr mi e `catchError` \err -> case errError err of- PatternErr _ -> do- err <- withInteractionId ii $ TP.text "Failed to give" TP.<+> prettyTCM e- typeError $ GenericError $ show err- _ -> throwError err- removeInteractionPoint ii- mis' <- getInteractionPoints- return (e, mis' \\ mis)---addDecl :: Declaration -> TCM ([InteractionId])-addDecl d = do- mis <- getInteractionPoints- checkDecl d- mis' <- getInteractionPoints- return (mis' \\ mis)---refine :: InteractionId -> Maybe Range -> Expr -> TCM (Expr,[InteractionId])-refine ii mr e =- do mi <- lookupInteractionId ii- mv <- lookupMeta mi- let range = maybe (getRange mv) id mr- let scope = M.getMetaScope mv- tryRefine 10 range scope e- where tryRefine :: Int -> Range -> ScopeInfo -> Expr -> TCM (Expr,[InteractionId])- tryRefine nrOfMetas r scope e = try nrOfMetas e- where try 0 e = throwError (strMsg "Can not refine")- try n e = give ii (Just r) e `catchError` (\_ -> try (n-1) (appMeta e))- appMeta :: Expr -> Expr- appMeta e =- let metaVar = QuestionMark- $ Agda.Syntax.Info.MetaInfo- { Agda.Syntax.Info.metaRange = r- , Agda.Syntax.Info.metaScope = scope { scopePrecedence = ArgumentCtx }- , metaNumber = Nothing- }- in App (ExprRange $ r) e (defaultArg $ unnamed metaVar)- --ToDo: The position of metaVar is not correct- --ToDo: The fixity of metavars is not correct -- fixed? MT--{-| Evaluate the given expression in the current environment -}-evalInCurrent :: Expr -> TCM Expr-evalInCurrent e =- do (v, t) <- inferExpr e- v' <- {- etaContract =<< -} normalise v- reify v'---evalInMeta :: InteractionId -> Expr -> TCM Expr-evalInMeta ii e =- do m <- lookupInteractionId ii- mi <- getMetaInfo <$> lookupMeta m- withMetaInfo mi $- evalInCurrent e---data Rewrite = AsIs | Instantiated | HeadNormal | Normalised----rewrite :: Rewrite -> Term -> TCM Term-rewrite AsIs t = return t-rewrite Instantiated t = return t -- reify does instantiation-rewrite HeadNormal t = {- etaContract =<< -} reduce t-rewrite Normalised t = {- etaContract =<< -} normalise t---data OutputForm a b = OutputForm ProblemId (OutputConstraint a b)- deriving (Functor)--data OutputConstraint a b- = OfType b a | CmpInType Comparison a b b- | CmpElim [Polarity] a [b] [b]- | JustType b | CmpTypes Comparison b b- | CmpLevels Comparison b b- | CmpTeles Comparison b b- | JustSort b | CmpSorts Comparison b b- | Guard (OutputConstraint a b) ProblemId- | Assign b a | TypedAssign b a a- | IsEmptyType a | FindInScopeOF b- deriving (Functor)---- | A subset of 'OutputConstraint'.--data OutputConstraint' a b = OfType' { ofName :: b- , ofExpr :: a- }--outputFormId :: OutputForm a b -> b-outputFormId (OutputForm _ o) = out o- where- out o = case o of- OfType i _ -> i- CmpInType _ _ i _ -> i- CmpElim _ _ (i:_) _ -> i- CmpElim _ _ [] _ -> __IMPOSSIBLE__- JustType i -> i- CmpLevels _ i _ -> i- CmpTypes _ i _ -> i- CmpTeles _ i _ -> i- JustSort i -> i- CmpSorts _ i _ -> i- Guard o _ -> out o- Assign i _ -> i- TypedAssign i _ _ -> i- IsEmptyType _ -> __IMPOSSIBLE__ -- Should never be used on IsEmpty constraints- FindInScopeOF _ -> __IMPOSSIBLE__--instance Reify ProblemConstraint (Closure (OutputForm Expr Expr)) where- reify (PConstr pid cl) = enterClosure cl $ \c -> buildClosure =<< (OutputForm pid <$> reify c)--instance Reify Constraint (OutputConstraint Expr Expr) where- reify (ValueCmp cmp t u v) = CmpInType cmp <$> reify t <*> reify u <*> reify v- reify (ElimCmp cmp t v es1 es2) =- CmpElim cmp <$> reify t <*> reify es1- <*> reify es2- reify (LevelCmp cmp t t') = CmpLevels cmp <$> reify t <*> reify t'- reify (TypeCmp cmp t t') = CmpTypes cmp <$> reify t <*> reify t'- reify (TelCmp a b cmp t t') = CmpTeles cmp <$> (ETel <$> reify t) <*> (ETel <$> reify t')- reify (SortCmp cmp s s') = CmpSorts cmp <$> reify s <*> reify s'- reify (Guarded c pid) = do- o <- reify c- return $ Guard o pid- reify (UnBlock m) = do- mi <- mvInstantiation <$> lookupMeta m- case mi of- BlockedConst t -> do- e <- reify t- m' <- reify (MetaV m [])- return $ Assign m' e- PostponedTypeCheckingProblem cl -> enterClosure cl $ \(e, a, _) -> do- a <- reify a- m' <- reify (MetaV m [])- return $ TypedAssign m' e a- Open{} -> __IMPOSSIBLE__- OpenIFS{} -> __IMPOSSIBLE__- InstS{} -> __IMPOSSIBLE__- InstV{} -> __IMPOSSIBLE__- reify (FindInScope m) = do- m' <- reify (MetaV m [])- return $ FindInScopeOF m' -- IFSTODO- reify (IsEmpty a) = IsEmptyType <$> reify a--showComparison :: Comparison -> String-showComparison CmpEq = " = "-showComparison CmpLeq = " =< "--instance (Show a,Show b) => Show (OutputForm a b) where- show (OutputForm 0 c) = show c- show (OutputForm pid c) = "[" ++ show pid ++ "] " ++ show c--instance (Show a,Show b) => Show (OutputConstraint a b) where- show (OfType e t) = show e ++ " : " ++ show t- show (JustType e) = "Type " ++ show e- show (JustSort e) = "Sort " ++ show e- show (CmpInType cmp t e e') = show e ++ showComparison cmp ++ show e' ++ " : " ++ show t- show (CmpElim cmp t e e') = show e ++ " == " ++ show e' ++ " : " ++ show t- show (CmpTypes cmp t t') = show t ++ showComparison cmp ++ show t'- show (CmpLevels cmp t t') = show t ++ showComparison cmp ++ show t'- show (CmpTeles cmp t t') = show t ++ showComparison cmp ++ show t'- show (CmpSorts cmp s s') = show s ++ showComparison cmp ++ show s'- show (Guard o pid) = show o ++ " [blocked by problem " ++ show pid ++ "]"- show (Assign m e) = show m ++ " := " ++ show e- show (TypedAssign m e a) = show m ++ " := " ++ show e ++ " :? " ++ show a- show (IsEmptyType a) = "Is empty: " ++ show a- show (FindInScopeOF s) = "Find in Scope: " ++ show s--instance (ToConcrete a c, ToConcrete b d) =>- ToConcrete (OutputForm a b) (OutputForm c d) where- toConcrete (OutputForm pid c) = OutputForm pid <$> toConcrete c--instance (ToConcrete a c, ToConcrete b d) =>- ToConcrete (OutputConstraint a b) (OutputConstraint c d) where- toConcrete (OfType e t) = OfType <$> toConcrete e <*> toConcreteCtx TopCtx t- toConcrete (JustType e) = JustType <$> toConcrete e- toConcrete (JustSort e) = JustSort <$> toConcrete e- toConcrete (CmpInType cmp t e e') =- CmpInType cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx ArgumentCtx e- <*> toConcreteCtx ArgumentCtx e'- toConcrete (CmpElim cmp t e e') =- CmpElim cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx TopCtx e <*> toConcreteCtx TopCtx e'- toConcrete (CmpTypes cmp e e') = CmpTypes cmp <$> toConcreteCtx ArgumentCtx e- <*> toConcreteCtx ArgumentCtx e'- toConcrete (CmpLevels cmp e e') = CmpLevels cmp <$> toConcreteCtx ArgumentCtx e- <*> toConcreteCtx ArgumentCtx e'- toConcrete (CmpTeles cmp e e') = CmpTeles cmp <$> toConcrete e <*> toConcrete e'- toConcrete (CmpSorts cmp e e') = CmpSorts cmp <$> toConcreteCtx ArgumentCtx e- <*> toConcreteCtx ArgumentCtx e'- toConcrete (Guard o pid) = Guard <$> toConcrete o <*> pure pid- toConcrete (Assign m e) = noTakenNames $ Assign <$> toConcrete m <*> toConcreteCtx TopCtx e- toConcrete (TypedAssign m e a) = TypedAssign <$> toConcrete m <*> toConcreteCtx TopCtx e- <*> toConcreteCtx TopCtx a- toConcrete (IsEmptyType a) = IsEmptyType <$> toConcreteCtx TopCtx a- toConcrete (FindInScopeOF s) = FindInScopeOF <$> toConcrete s--instance (Pretty a, Pretty b) => Pretty (OutputConstraint' a b) where- pretty (OfType' e t) = pretty e <+> text ":" <+> pretty t--instance (ToConcrete a c, ToConcrete b d) =>- ToConcrete (OutputConstraint' a b) (OutputConstraint' c d) where- toConcrete (OfType' e t) = OfType' <$> toConcrete e <*> toConcreteCtx TopCtx t----ToDo: Move somewhere else-instance ToConcrete InteractionId C.Expr where- toConcrete (InteractionId i) = return $ C.QuestionMark noRange (Just i)-instance ToConcrete MetaId C.Expr where- toConcrete (MetaId i) = return $ C.Underscore noRange (Just i)--judgToOutputForm :: Judgement a c -> OutputConstraint a c-judgToOutputForm (HasType e t) = OfType e t-judgToOutputForm (IsSort s t) = JustSort s--getConstraints :: TCM [OutputForm C.Expr C.Expr]-getConstraints = liftTCM $ do- cs <- M.getAllConstraints- cs <- forM cs $ \c -> do- cl <- reify c- enterClosure cl abstractToConcrete_- ss <- mapM toOutputForm =<< getSolvedInteractionPoints- return $ ss ++ cs- where- toOutputForm (ii, mi, e) = do- mv <- getMetaInfo <$> lookupMeta mi- withMetaInfo mv $ do- let m = QuestionMark $ MetaInfo noRange emptyScopeInfo (Just $ fromIntegral ii)- abstractToConcrete_ $ OutputForm 0 $ Assign m e--getSolvedInteractionPoints :: TCM [(InteractionId, MetaId, Expr)]-getSolvedInteractionPoints = do- is <- getInteractionPoints- concat <$> mapM solution is- where- solution i = do- m <- lookupInteractionId i- mv <- lookupMeta m- withMetaInfo (getMetaInfo mv) $ do- args <- getContextArgs- scope <- getScope- let sol v = do e <- reify v; return [(i, m, ScopedExpr scope e)]- unsol = return []- case mvInstantiation mv of- InstV{} -> sol (MetaV m args)- InstS{} -> sol (Level $ Max [Plus 0 $ MetaLevel m args])- Open{} -> unsol- OpenIFS{} -> unsol- BlockedConst{} -> unsol- PostponedTypeCheckingProblem{} -> unsol--typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputConstraint Expr MetaId)-typeOfMetaMI norm mi =- do mv <- lookupMeta mi- withMetaInfo (getMetaInfo mv) $- rewriteJudg mv (mvJudgement mv)- where- rewriteJudg mv (HasType i t) = do- t <- rewrite norm t- vs <- getContextArgs- reportSDoc "interactive.meta" 10 $ TP.vcat- [ TP.text $ unwords ["permuting", show i, "with", show $ mvPermutation mv]- , TP.nest 2 $ TP.vcat- [ TP.text "len =" TP.<+> TP.text (show $ length vs)- , TP.text "args =" TP.<+> prettyTCM vs- , TP.text "t =" TP.<+> prettyTCM t- ]- ]- OfType i <$> reify (t `piApply` permute (takeP (size vs) $ mvPermutation mv) vs)- rewriteJudg mv (IsSort i t) = return $ JustSort i---typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputConstraint Expr InteractionId)-typeOfMeta norm ii =- do mi <- lookupInteractionId ii- out <- typeOfMetaMI norm mi- return $ fmap (\_ -> ii) out--typesOfVisibleMetas :: Rewrite -> TCM [OutputConstraint Expr InteractionId]-typesOfVisibleMetas norm =- liftTCM $ mapM (typeOfMeta norm) =<< getInteractionPoints--typesOfHiddenMetas :: Rewrite -> TCM [OutputConstraint Expr MetaId]-typesOfHiddenMetas norm = liftTCM $ do- is <- getInteractionMetas- store <- Map.filterWithKey (openAndImplicit is) <$> getMetaStore- mapM (typeOfMetaMI norm) $ Map.keys store- where- openAndImplicit is x (MetaVar{mvInstantiation = M.Open}) = x `notElem` is- openAndImplicit is x (MetaVar{mvInstantiation = M.BlockedConst _}) = True- openAndImplicit _ _ _ = False---- Gives a list of names and corresponding types.--contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputConstraint' Expr Name]-contextOfMeta ii norm = do- info <- getMetaInfo <$> (lookupMeta =<< lookupInteractionId ii)- let localVars = map ctxEntry . envContext . clEnv $ info- withMetaInfo info $ gfilter visible <$> reifyContext localVars- where gfilter p = catMaybes . map p- visible (OfType x y) | show x /= "_" = Just (OfType' x y)- | otherwise = Nothing- visible _ = __IMPOSSIBLE__- reifyContext xs = reverse <$> zipWithM out [1..] xs-- out i (Arg h _ (x, t)) = escapeContext i $ do- t' <- reify =<< rewrite norm t- return $ OfType x t'----- | Returns the type of the expression in the current environment--- We wake up irrelevant variables just in case the user want to--- invoke that command in an irrelevant context.-typeInCurrent :: Rewrite -> Expr -> TCM Expr-typeInCurrent norm e =- do (_,t) <- wakeIrrelevantVars $ inferExpr e- v <- rewrite norm t- reify v----typeInMeta :: InteractionId -> Rewrite -> Expr -> TCM Expr-typeInMeta ii norm e =- do m <- lookupInteractionId ii- mi <- getMetaInfo <$> lookupMeta m- withMetaInfo mi $- typeInCurrent norm e--withInteractionId :: InteractionId -> TCM a -> TCM a-withInteractionId i ret = do- m <- lookupInteractionId i- withMetaId m ret--withMetaId :: MetaId -> TCM a -> TCM a-withMetaId m ret = do- info <- lookupMeta m- withMetaInfo (mvInfo info) ret---- The intro tactic---- Returns the terms (as strings) that can be--- used to refine the goal. Uses the coverage checker--- to find out which constructors are possible.-introTactic :: InteractionId -> TCM [String]-introTactic ii = do- mi <- lookupInteractionId ii- mv <- lookupMeta mi- withMetaInfo (getMetaInfo mv) $ case mvJudgement mv of- HasType _ t -> do- t <- reduce =<< piApply t <$> getContextArgs- case unEl t of- I.Def d _ -> do- def <- getConstInfo d- case theDef def of- Datatype{} -> introData t- Record{ recNamedCon = name }- | name -> introData t- | otherwise -> introRec d- _ -> return []- _ -> do- TelV tel _ <- telView t- case tel of- EmptyTel -> return []- tel -> introFun tel- `catchError` \_ -> return []- _ -> __IMPOSSIBLE__- where- conName [Arg _ _ (I.ConP c _ _)] = [c]- conName [_] = []- conName _ = __IMPOSSIBLE__-- showTCM v = show <$> prettyTCM v-- introFun tel = addCtxTel tel' $ do- imp <- showImplicitArguments- let okHiding h = imp || h == NotHidden- vars <- mapM showTCM [ Arg h Relevant (I.Var i [])- | (h, i) <- zip hs $ reverse [0..n - 1]- , okHiding h- ]- return [ unwords $ ["λ"] ++ vars ++ ["→", "?"] ]- where- n = size tel- hs = map argHiding $ telToList tel- tel' = telFromList [ fmap makeName b | b <- telToList tel ]- makeName ("_", t) = ("x", t)- makeName (x, t) = (x, t)-- introData t = do- let tel = telFromList [defaultArg ("_", t)]- perm = idP 1- pat = [defaultArg (I.VarP "c")]- r <- split CoInductive tel perm pat 0- case r of- Left err -> return []- Right cs -> mapM showTCM $ concatMap (conName . scPats) cs-- introRec d = do- hfs <- getRecordFieldNames d- fs <- ifM showImplicitArguments- (return $ map unArg hfs)- (return [ f | (Arg NotHidden _ f) <- hfs ])- return- [ concat $- "record {" :- intersperse ";" (map (\ f -> show f ++ " = ?") fs) ++- ["}"]- ]---- | Runs the given computation as if in an anonymous goal at the end--- of the top-level module.--atTopLevel :: TCM a -> TCM a-atTopLevel m = inConcreteMode $ do- mCurrent <- stCurrentModule <$> get- case mCurrent of- Nothing -> typeError $- GenericError "The file has not been loaded yet."- Just current -> do- r <- getVisitedModule (toTopLevelModuleName current)- case r of- Nothing -> __IMPOSSIBLE__- Just mi -> do- let scope = iInsideScope $ miInterface mi- tel <- lookupSection current- M.withCurrentModule current $- withScope_ scope $- addContext (zipWith' (fmap . (,))- (map snd $ scopeLocals scope)- (map (fmap snd) $ telToList tel)) $- m---- | Returns the contents of the given module.--moduleContents :: Range- -- ^ The range of the next argument.- -> String- -- ^ The module name.- -> TCM ([C.Name], [(C.Name, Type)])- -- ^ Module names, names paired up with- -- corresponding types.-moduleContents rng s = do- m <- parseExpr rng s- m <- case m of- C.Ident m -> return m- C.RawApp _ [C.Ident m] -> return m- _ -> typeError $- GenericError $ "Not a module name: " ++ show m ++ "."- modScope <- getNamedScope . amodName =<< resolveModule m- let modules :: ThingsInScope AbstractModule- modules = exportedNamesInScope modScope- names :: ThingsInScope AbstractName- names = exportedNamesInScope modScope- types <- mapM (\(x, n) -> do- d <- getConstInfo $ anameName n- t <- defType <$> instantiateDef d- return (x, t))- (concatMap (\(x, ns) -> map ((,) x) ns) $- Map.toList names)- return (Map.keys modules, types)+{-# LANGUAGE NondecreasingIndentation #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Agda.Interaction.BasicOps where++import Prelude hiding (null)++import Control.Monad.Except ( MonadError(..) )+import Control.Monad.State ( MonadState(..), evalState )+import Control.Monad.Identity ( runIdentity )+import Control.Monad.Trans.Maybe++import qualified Data.Map as Map+import qualified Data.IntMap as IntMap+import qualified Data.Map.Strict as MapS+import qualified Data.Set as Set+import qualified Data.List as List+import Data.Bifunctor (first, second)+import Data.Maybe+import Data.Monoid+import Data.Function (on)+import Data.Text (Text)+import qualified Data.Text as T++import Agda.Interaction.Base+import Agda.Interaction.Output+import Agda.Interaction.Options+import Agda.Interaction.Response (Goals, ResponseContextEntry(..))++import qualified Agda.Syntax.Concrete as C -- ToDo: Remove with instance of ToConcrete+import Agda.Syntax.Position+import Agda.Syntax.Abstract as A hiding (Open, Apply, Assign)+import Agda.Syntax.Abstract.Views as A+import Agda.Syntax.Abstract.Pretty+import Agda.Syntax.Common+import Agda.Syntax.Concrete.Operators (parseApplication)+import Agda.Syntax.Info (MetaInfo(..),emptyMetaInfo,exprNoRange,defaultAppInfo_,defaultAppInfo)+import qualified Agda.Syntax.Info as Info+import Agda.Syntax.Internal as I+import Agda.Syntax.Literal+import Agda.Syntax.Translation.InternalToAbstract+import Agda.Syntax.Translation.AbstractToConcrete+import Agda.Syntax.Translation.ConcreteToAbstract+import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Monad+import Agda.Syntax.Fixity(Precedence(..), argumentCtx_)+import Agda.Syntax.Parser++import Agda.TheTypeChecker+import Agda.TypeChecking.Conversion.Errors+import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Conversion+import Agda.TypeChecking.Errors ( getAllWarnings, Verbalize(..) )+import Agda.TypeChecking.Monad as M hiding (MetaInfo)+import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.MetaVars.Mention+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope.Path+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.With+import Agda.TypeChecking.Coverage+import Agda.TypeChecking.Coverage.SplitPattern ( SplitPattern )+import Agda.TypeChecking.Records+import Agda.TypeChecking.Pretty ( PrettyTCM, prettyTCM )+import Agda.TypeChecking.Pretty.Constraint (prettyRangeConstraint)+import Agda.TypeChecking.IApplyConfluence+import Agda.TypeChecking.Primitive+import Agda.TypeChecking.ProjectionLike (reduceProjectionLike)+import Agda.TypeChecking.Names+import Agda.TypeChecking.Free+import Agda.TypeChecking.CheckInternal+import Agda.TypeChecking.SizedTypes.Solve+import qualified Agda.TypeChecking.Pretty as TP+import Agda.TypeChecking.Warnings+ ( warning, WhichWarnings(..), classifyWarnings, isMetaTCWarning+ , WarningsAndNonFatalErrors )++import Agda.Termination.TermCheck (termMutual)++import Agda.Utils.Function (applyWhen)+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|))+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty as P+import Agda.Utils.Permutation+import Agda.Utils.Size+import Agda.Utils.String+import Agda.Utils.WithDefault ( WithDefault'(Value) )+import Agda.Utils.Tuple.Strict (Pair(..))+import Agda.Utils.Tuple.Strict qualified as Strict+import Agda.Utils.Maybe.Strict qualified as Strict++import Agda.Utils.Impossible++-- | Parses an expression.++parseExpr :: Range -> String -> TCM C.Expr+parseExpr rng s = do+ (C.ExprWhere e wh, attrs) <-+ runPM $ parseRangeString exprWhereParser rng s+ checkAttributes attrs+ unless (null wh) $ interactionError UnexpectedWhere+ return e++parseExprIn :: InteractionId -> Range -> String -> TCM Expr+parseExprIn ii rng s = do+ e <- parseExpr rng s+ -- Andreas, 2019-08-19, issue #4007+ -- We need to be in the TCEnv of the meta variable+ -- such that the scope checker can label the clause+ -- of a parsed extended lambda as IsAbstract if the+ -- interaction point was created in AbstractMode.+ withInteractionId ii $ concreteToAbstract_ e++-- Type check the given expression and assign its value to the meta+-- Precondition: we are in the context where the given meta was created.+giveExpr :: UseForce -> Maybe InteractionId -> MetaId -> Expr -> TCM Term+giveExpr force mii mi e = do+ mv <- lookupLocalMeta mi+ let t = case mvJudgement mv of+ IsSort{} -> __IMPOSSIBLE__+ HasType _ _ t -> t+ reportSDoc "interaction.give" 20 $+ "give: meta type =" TP.<+> prettyTCM t+ -- Here, we must be in the same context where the meta was created.+ -- Thus, we can safely apply its type to the context variables.+ ctx <- getContextArgs+ t' <- t `piApplyM` permute (takeP (length ctx) $ mvPermutation mv) ctx+ traceCall (CheckExprCall CmpLeq e t') $ do+ reportSDoc "interaction.give" 20 $ do+ a <- viewTC eAbstractMode+ TP.hsep+ [ TP.text ("give(" ++ show a ++ "): instantiated meta type =")+ , prettyTCM t'+ ]+ -- Andreas, 2020-05-27 AIM XXXII, issue #4679+ -- Clear envMutualBlock since cubical only executes+ -- certain checks (checkIApplyConfluence) for an extended lambda+ -- when not in a mutual block.+ v <- locallyTC eMutualBlock (const Nothing) $+ checkExpr e t'+ reportSDoc "interaction.give" 40 $ "give: checked expression:" TP.<+> pure (pretty v)+ case mvInstantiation mv of++ InstV{} -> unlessM (isIrrelevant <$> viewTC eRelevance) $ do+ v' <- instantiate $ MetaV mi $ map Apply ctx+ reportSDoc "interaction.give" 20 $ TP.sep+ [ "meta was already set to value v' = " TP.<+> prettyTCM v'+ , "now comparing it to given value v = " TP.<+> prettyTCM v+ , "in context " TP.<+> inTopContext (prettyTCM ctx)+ ]+ equalTerm t' v v'++ _ -> do -- updateMeta mi v+ reportSLn "interaction.give" 20 "give: meta unassigned, assigning..."+ args <- getContextArgs+ nowSolvingConstraints $ assign DirEq mi args v (AsTermsOf t')++ reportSDoc "interaction.give" 20 $ "give: meta variable updated!"+ unless (force == WithForce) $ redoChecks mii+ wakeupConstraints mi+ solveSizeConstraints DontDefaultToInfty+ cubical <- isJust <$> cubicalOption+ -- don't double check with cubical, because it gets in the way too often.+ unless (cubical || force == WithForce) $ do+ -- Double check.+ reportSDoc "interaction.give" 20 $ "give: double checking"+ vfull <- instantiateFull v+ checkInternal vfull CmpLeq t'+ return v++-- | After a give, redo termination etc. checks for function which was complemented.+redoChecks :: Maybe InteractionId -> TCM ()+redoChecks Nothing = return ()+redoChecks (Just ii) = do+ reportSLn "interaction.give" 20 $+ "give: redoing termination check for function surrounding " ++ show ii+ ip <- lookupInteractionPoint ii+ case ipClause ip of+ IPNoClause -> return ()+ IPClause{ipcQName = f} -> do+ mb <- defMutual <$> getConstInfo f+ terErrs <- localTC (set eMutualBlock (Just mb)) $ termMutual []+ List1.unlessNull terErrs $ warning . TerminationIssue+ -- TODO redo positivity check!++-- | Auxiliary definition for 'give' and 'elaborate_give'.+give_ ::+ Bool -- ^ Elaborating?+ -> UseForce -- ^ Skip safety checks?+ -> InteractionId -- ^ Hole.+ -> Expr -- ^ The expression to give.+ -> TCM Term -- ^ Value of the expression+give_ elaborating force ii e = do+ mi <- lookupInteractionId ii+ reportSDoc "interaction.give" 10 $ "giving expression" TP.<+> prettyTCM e+ reportSDoc "interaction.give" 50 $ TP.text $ show $ deepUnscope e+ -- Try to give mi := e+ withInteractionId ii do+ setMetaOccursCheck mi DontRunMetaOccursCheck -- #589, #2710: Allow giving recursive solutions.+ applyWhen elaborating (locallyTC eCurrentlyElaborating $ const True) do+ -- Andreas, 2025-05-02, issue #7842 reproduces this error+ let err _blocker = typeError $ InteractionError $ CannotGive e+ catchPatternErr err do+ giveExpr force (Just ii) mi e++-- | Try to fill hole by expression.+--+-- Returns the given expression unchanged+-- (for convenient generalization to @'refine'@).+give ::+ UseForce -- ^ Skip safety checks?+ -> InteractionId -- ^ Hole.+ -> Expr -- ^ The expression to give.+ -> TCM Expr -- ^ If successful, the very expression is returned unchanged.+give force ii e = do+ _ <- give_ False force ii e+ removeInteractionPoint ii+ return e++-- | Try to fill hole by elaborated expression.+elaborate_give+ :: Rewrite -- ^ Normalise result?+ -> UseForce -- ^ Skip safety checks?+ -> InteractionId -- ^ Hole.+ -> Expr -- ^ The expression to give.+ -> TCM Expr -- ^ If successful, return the elaborated expression.+elaborate_give norm force ii e = withInteractionId ii $ do+ v <- give_ True force ii e+ reportSDoc "interaction.give" 40 $ "v = " TP.<+> pure (pretty v)+ -- Reduce projection-likes before quoting, otherwise instance+ -- selection may fail on reload (see #6203).+ nv <- reduceProjectionLike =<< normalForm norm v+ locallyTC ePrintMetasBare (const True) $ reify nv++-- | Try to refine hole by expression @e@.+--+-- This amounts to successively try to give @e@, @e ?@, @e ? ?@, ...+-- Returns the successfully given expression.+refine+ :: UseForce -- ^ Skip safety checks when giving?+ -> InteractionId -- ^ Hole.+ -> Expr -- ^ The expression to refine the hole with.+ -- Precondition: it was parsed in the context of the hole+ -- so its ranges are correct.+ -> TCM Expr -- ^ The successfully given expression.+refine force ii e = do+ reportSDoc "interaction.refine" 10 $+ "refining with expression" TP.<+> prettyTCM e+ reportSDoc "interaction.refine" 50 $+ TP.text $ show $ deepUnscope e+ -- Andreas, 2025-11-12, issue #8197+ -- We use the range of @e@ which might contain questionmarks+ -- so that the new questionmarks appended to @e@+ -- can receive a 'Range' relatively correct to the ranges+ -- of the questionmarks withing @e@.+ -- If @e@ has no range information, fall back to the current interaction+ -- point range so appended metas still get a real file range.+ holeRange <- getInteractionRange ii+ let exprRange = getRange e+ range = if null exprRange then holeRange else exprRange+ scope <- getInteractionScope ii+ -- We try to append up to 10 meta variables+ tryRefine 10 range scope e+ where+ -- This wrapper around 'try' makes 'range' and 'scope' available there.+ tryRefine :: Int -> Range -> ScopeInfo -> Expr -> TCM Expr+ tryRefine nrOfMetas range scope = try nrOfMetas Nothing+ where+ try :: Int -> Maybe TCErr -> Expr -> TCM Expr+ try 0 err e = do+ reportSDoc "interaction.refine" 30 $ "final error:" TP.$$ prettyTCM err+ interactionError $ CannotRefine $ case err of+ Just (TypeError _ _ cl) | ConversionError_ (ConversionError _ _ I.Pi{} _ _) <- clValue cl ->+ "functions with 10 or more arguments"+ _ -> ""+ try n _ e = give force ii e `catchError` \err -> do+ reportSDoc "interaction.refine" 30 $ "retrying because of error:" TP.$$ prettyTCM err+ try (n - 1) (Just err) =<< appMeta e++ -- Apply A.Expr to a new meta+ appMeta :: Expr -> TCM Expr+ appMeta e = do+ -- Andreas, 2013-05-01 conflate range to its right margin to ensure that appended metas are last in numbering.+ -- This fixes issue 841.+ let rng = rightMargin range+ -- Make new interaction point+ ii <- registerInteractionPoint False rng Nothing+ let info = Info.MetaInfo+ { Info.metaRange = rng+ , Info.metaScope = set scopePrecedence [argumentCtx_] scope+ -- Ulf, 2017-09-07: The `argumentCtx_` above is causing #737.+ -- If we're building an operator application the precedence+ -- should be something else.+ , metaNumber = Nothing -- in order to print just as ?, not ?n+ , metaNameSuggestion = ""+ , metaKind = Info.UnificationMeta+ }+ metaVar = QuestionMark info ii++ count x e = getSum $ foldExpr isX e+ where isX (A.Var y) | x == y = Sum 1+ isX _ = mempty++ lamView (A.Lam _ (DomainFree _ x) e) = Just (namedArg x, e)+ lamView (A.Lam i (DomainFull (TBind r t (x :| xs) a)) e) =+ List1.ifNull xs {-then-} (Just (namedArg x, e)) {-else-} $ \ xs ->+ Just (namedArg x, A.Lam i (DomainFull $ TBind r t xs a) e)+ lamView _ = Nothing++ -- reduce beta-redexes where the argument is used at most once+ smartApp i e arg =+ case fmap (first A.binderName) (lamView $ unScope e) of+ Just (A.BindName{unBind = x}, e) | count x e < 2 -> mapExpr subX e+ where subX (A.Var y) | x == y = namedArg arg+ subX e = e+ _ -> App i e arg+ return $ smartApp (defaultAppInfo range) e $ defaultNamedArg metaVar++{-| Evaluate the given expression in the current environment -}+evalInCurrent :: ComputeMode -> Expr -> TCM Expr+evalInCurrent cmode e = do+ (v, _t) <- inferExpr e+ vb <- reduceB v+ reportSDoc "interaction.eval" 30 $ "evaluated to" TP.<+> TP.pretty vb+ v <- pure $ ignoreBlocking vb+ reify =<< if cmode == HeadCompute then pure v else normalise v+++evalInMeta :: InteractionId -> ComputeMode -> Expr -> TCM Expr+evalInMeta ii cmode e =+ do m <- lookupInteractionId ii+ mi <- getMetaInfo <$> lookupLocalMeta m+ withMetaInfo mi $+ evalInCurrent cmode e++-- | Modifier for interactive commands,+-- specifying the amount of normalization in the output.+--+normalForm :: (Reduce t, Simplify t, Instantiate t, Normalise t) => Rewrite -> t -> TCM t+normalForm = \case+ AsIs -> instantiate -- #4975: reify will also instantiate by for goal-type-and-context-and-check+ Instantiated -> instantiate -- we get a top-level fresh meta which has disappeared from state by the+ HeadNormal -> reduce -- time we get to reification. Hence instantiate here.+ Simplified -> simplify+ Normalised -> normalise++-- | Evaluate the given expression in the current environment+-- with allowed reductions modified according to 'ComputeMode'.+computeInCurrent :: ComputeMode -> Expr -> TCM Expr+computeInCurrent cmode e =+ withComputeIgnoreAbstract cmode $ evalInCurrent cmode e++-- | Modify the allowed reductions according to 'ComputeMode'.+{-# SPECIALIZE withComputeIgnoreAbstract :: ComputeMode -> TCM a -> TCM a #-}+withComputeIgnoreAbstract :: MonadTCEnv m => ComputeMode -> m a -> m a+withComputeIgnoreAbstract cmode =+ applyWhen (computeIgnoreAbstract cmode) $+ allowNonTerminatingReductions . ignoreAbstractMode++computeIgnoreAbstract :: ComputeMode -> Bool+computeIgnoreAbstract DefaultCompute = False+computeIgnoreAbstract HeadCompute = False+computeIgnoreAbstract IgnoreAbstract = True+computeIgnoreAbstract UseShowInstance = False+ -- WRONG: UseShowInstance requires the result to be a string literal so respecting abstract can+ -- only ever break things.+ -- See #7191. Abstract definitions can come with rewrite rules to give nice show behaviour that+ -- breaks if we don't respect abstract.++computeWrapInput :: ComputeMode -> String -> String+computeWrapInput UseShowInstance s = "show (" ++ s ++ ")"+computeWrapInput _ s = s++showComputed :: ComputeMode -> Expr -> TCM Doc+showComputed UseShowInstance e =+ case e of+ A.Lit _ (LitString s) -> pure (text $ T.unpack s)+ _ -> ("Expected applying `show` to the given value to produce a string literal, but got:" $$) <$> prettyATop e+showComputed _ e = prettyATop e++-- | Modifier for interactive commands,+-- specifying whether safety checks should be ignored.+outputFormId :: OutputForm a b -> b+outputFormId (OutputForm _ _ _ o) = out o+ where+ out = \case+ OfType i _ -> i+ CmpInType _ _ i _ -> i+ CmpElim _ _ (i:_) _ -> i+ CmpElim _ _ [] _ -> __IMPOSSIBLE__+ JustType i -> i+ CmpLevels _ i _ -> i+ CmpTypes _ i _ -> i+ CmpTeles _ i _ -> i+ JustSort i -> i+ CmpSorts _ i _ -> i+ Assign i _ -> i+ TypedAssign i _ _ -> i+ PostponedCheckArgs i _ _ _ -> i+ IsEmptyType _ -> __IMPOSSIBLE__ -- Should never be used on IsEmpty constraints+ SizeLtSat{} -> __IMPOSSIBLE__+ FindInstanceOF _ _ _ -> __IMPOSSIBLE__+ ResolveInstanceOF _ -> __IMPOSSIBLE__+ PTSInstance i _ -> i+ PostponedCheckFunDef{} -> __IMPOSSIBLE__+ DataSort _ i -> i+ CheckLock i _ -> i+ UsableAtMod _ i -> i++instance Reify ProblemConstraint where+ type ReifiesTo ProblemConstraint = Closure (OutputForm Expr Expr)+ reify (PConstr pids unblock cl) = withClosure cl $ \ c ->+ OutputForm (getRange c) (Set.toList pids) unblock <$> reify c++reifyElimToExpr :: MonadReify m => I.Elim -> m Expr+reifyElimToExpr = \case+ I.IApply _ _ v -> appl "iapply" <$> reify (defaultArg $ v) -- TODO Andrea: endpoints?+ I.Apply v -> appl "apply" <$> reify v+ I.Proj _o f -> appl "proj" <$> reify ((defaultArg $ I.Def f []) :: Arg Term)+ where+ appl :: Text -> Arg Expr -> Expr+ appl s v = A.App defaultAppInfo_ (A.Lit empty (LitString s)) $ fmap unnamed v++instance Reify Constraint where+ type ReifiesTo Constraint = OutputConstraint Expr Expr++ reify (ValueCmp cmp (AsTermsOf t) u v) = CmpInType cmp <$> reify t <*> reify u <*> reify v+ reify (ValueCmp cmp AsSizes u v) = CmpInType cmp <$> (reify =<< sizeType) <*> reify u <*> reify v+ reify (ValueCmp cmp AsTypes u v) = CmpTypes cmp <$> reify u <*> reify v+ reify (ValueCmpOnFace cmp p t u v) = CmpInType cmp <$> (reify =<< ty) <*> reify (lam_o u) <*> reify (lam_o v)+ where+ lam_o = I.Lam defaultIrrelevantArgInfo . NoAbs "_"+ ty = runNamesT [] $ do+ p <- open p+ t <- open t+ pPi' "o" p (\ o -> t)+ reify (ElimCmp cmp _ t v es1 es2) =+ CmpElim cmp <$> reify t <*> mapM reifyElimToExpr es1+ <*> mapM reifyElimToExpr es2+ reify (LevelCmp cmp t t') = CmpLevels cmp <$> reify t <*> reify t'+ reify (SortCmp cmp s s') = CmpSorts cmp <$> reify s <*> reify s'+ reify (UnquoteTactic tac _ goal) = do+ tac <- A.App defaultAppInfo_ (A.Unquote exprNoRange) . defaultNamedArg <$> reify tac+ OfType tac <$> reify goal+ reify (UnBlock m) = do+ mi <- lookupMetaInstantiation m+ m' <- reify (MetaV m [])+ case mi of+ BlockedConst t -> do+ e <- reify t+ return $ Assign m' e+ PostponedTypeCheckingProblem cl -> enterClosure cl $ \case+ CheckExpr cmp e a -> do+ a <- reify a+ return $ TypedAssign m' e a+ CheckLambda cmp (Arg ai (xs, mt)) body target -> do+ domType <- maybe (return underscore) reify mt+ target <- reify target+ let mkN (WithHiding h x) = setHiding h $ defaultNamedArg $ A.mkBinder_ x+ bs = mkTBind noRange (fmap mkN xs) domType+ e = A.Lam Info.exprNoRange (DomainFull bs) body+ return $ TypedAssign m' e target+ CheckArgs _ _ _ args t0 t1 _ -> do+ t0 <- reify t0+ t1 <- reify t1+ return $ PostponedCheckArgs m' (map (namedThing . unArg) args) t0 t1+ CheckProjAppToKnownPrincipalArg cmp e _ _ _ _ t _ _ _ _ -> TypedAssign m' e <$> reify t+ DoQuoteTerm cmp v t -> do+ tm <- A.App defaultAppInfo_ (A.QuoteTerm exprNoRange) . defaultNamedArg <$> reify v+ OfType tm <$> reify t+ DisambiguateConstructor (ConstructorDisambiguationData c0 _cands args t) _cont -> do+ t <- reify t+ return $ TypedAssign m' (foldl (A.App empty) (A.Con $ unambiguous c0) args) t+ OpenMeta{} -> __IMPOSSIBLE__+ InstV{} -> __IMPOSSIBLE__+ reify (FindInstance _ m mcands) = FindInstanceOF+ <$> reify (MetaV m [])+ <*> (reify =<< getMetaType m)+ <*> forM (fromMaybe [] mcands) (\ (Candidate q tm ty _) -> do+ (,,) <$> reify tm <*> reify tm <*> reify ty)+ reify (ResolveInstanceHead kwr q) = return $ ResolveInstanceOF q+ reify (IsEmpty r a) = IsEmptyType <$> reify (unDom a)+ reify (CheckSizeLtSat a) = SizeLtSat <$> reify a+ reify (CheckFunDef i q cs err) = do+ a <- reify =<< defType <$> getConstInfo q+ return $ PostponedCheckFunDef q a err+ reify (HasBiggerSort a) = OfType <$> reify a <*> reify (UnivSort a)+ reify (HasPTSRule a b) = do+ (a,(x,b)) <- reify (unDom a,b)+ return $ PTSInstance a b+ reify (CheckDataSort q s) = DataSort q <$> reify s+ reify (CheckLockedVars t _ lk _) = CheckLock <$> reify t <*> reify (unArg lk)+ reify (CheckMetaInst m) = do+ t <- jMetaType . mvJudgement <$> lookupLocalMeta m+ OfType <$> reify (MetaV m []) <*> reify t+ reify (CheckType t) = JustType <$> reify t+ reify (UsableAtModality _ _ mod t) = UsableAtMod mod <$> reify t+ reify (RewConstraint (LocalEquation g t u a)) = do+ -- I think reifying rewrite constraints to 'CmpInType' should be fine+ -- (ultimately 'RewConstraint' is basically just 'ValueCmp' with a nicer+ -- error message)+ t' <- addContext g $ reify t+ u' <- addContext g $ reify u+ a' <- addContext g $ reify a+ return $ CmpInType CmpEq t' u' a'+ {-# SPECIALIZE reify :: Constraint -> TCM (ReifiesTo Constraint) #-}++instance (Pretty a, Pretty b) => PrettyTCM (OutputForm a b) where+ prettyTCM (OutputForm r pids unblock c) =+ prettyRangeConstraint r pids unblock (pretty c)+ {-# SPECIALIZE prettyTCM :: (Pretty a, Pretty b) => (OutputForm a b) -> TCM Doc #-}++instance (Pretty a, Pretty b) => Pretty (OutputForm a b) where+ pretty (OutputForm r pids unblock c) =+ pretty c <?>+ sep [ prange r, parensNonEmpty (sep [blockedOn unblock, prPids pids]) ]+ where+ prPids [] = empty+ prPids [pid] = "belongs to problem" <+> pretty pid+ prPids pids = "belongs to problems" <+> fsep (punctuate "," $ map pretty pids)++ comma | null pids = empty+ | otherwise = ","++ blockedOn (UnblockOnAll bs) | Set.null bs = empty+ blockedOn (UnblockOnAny bs) | Set.null bs = "stuck" <> comma+ blockedOn u = "blocked on" <+> (pretty u <> comma)++ prange r | null s = empty+ | otherwise = text $ " [ at " ++ s ++ " ]"+ where s = prettyShow r++instance (Pretty a, Pretty b) => Pretty (OutputConstraint a b) where+ pretty oc =+ case oc of+ OfType e t -> pretty e .: t+ JustType e -> "Type" <+> pretty e+ JustSort e -> "Sort" <+> pretty e+ CmpInType cmp t e e' -> pcmp cmp e e' .: t+ CmpElim cmp t e e' -> pcmp cmp e e' .: t+ CmpTypes cmp t t' -> pcmp cmp t t'+ CmpLevels cmp t t' -> pcmp cmp t t'+ CmpTeles cmp t t' -> pcmp cmp t t'+ CmpSorts cmp s s' -> pcmp cmp s s'+ Assign m e -> bin (pretty m) ":=" (pretty e)+ TypedAssign m e a -> bin (pretty m) ":=" $ bin (pretty e) ":?" (pretty a)+ PostponedCheckArgs m es t0 t1 ->+ bin (pretty m) ":=" $ (parens ("_" .: t0) <+> fsep (map (paren . pretty) es)) .: t1+ where paren d = mparens (any (`elem` [' ', '\n']) $ show d) d+ IsEmptyType a -> "Is empty:" <+> pretty a+ SizeLtSat a -> "Not empty type of sizes:" <+> pretty a+ FindInstanceOF s t cs -> vcat+ [ "Resolve instance argument" <?> (pretty s .: t)+ , nest 2 $ "Candidate:"+ , nest 4 $ vcat [ bin (pretty q) "=" (pretty v) .: t | (q, v, t) <- cs ] ]+ ResolveInstanceOF q ->+ "Resolve output type of instance" <?> pretty q+ PTSInstance a b -> "PTS instance for" <+> pretty (a, b)+ PostponedCheckFunDef q a _err ->+ vcat [ "Check definition of" <+> pretty q <+> ":" <+> pretty a ]+ -- , nest 2 "stuck because" <?> pretty err ] -- We don't have Pretty for TCErr+ DataSort q s -> "Sort" <+> pretty s <+> "allows data/record definitions"+ CheckLock t lk -> "Check lock" <+> pretty lk <+> "allows" <+> pretty t+ UsableAtMod mod t -> "Is usable at" <+> text (verbalize mod) <+> "modality:" <+> pretty t+ where+ bin a op b = sep [a, nest 2 $ op <+> b]+ pcmp cmp a b = bin (pretty a) (pretty cmp) (pretty b)+ val .: ty = bin val ":" (pretty ty)+++instance (ToConcrete a, ToConcrete b) => ToConcrete (OutputForm a b) where+ type ConOfAbs (OutputForm a b) = OutputForm (ConOfAbs a) (ConOfAbs b)+ toConcrete (OutputForm r pid u c) = OutputForm r pid u <$> toConcrete c++instance (ToConcrete a, ToConcrete b) => ToConcrete (OutputConstraint a b) where+ type ConOfAbs (OutputConstraint a b) = OutputConstraint (ConOfAbs a) (ConOfAbs b)++ toConcrete (OfType e t) = OfType <$> toConcrete e <*> toConcreteCtx TopCtx t+ toConcrete (JustType e) = JustType <$> toConcrete e+ toConcrete (JustSort e) = JustSort <$> toConcrete e+ toConcrete (CmpInType cmp t e e') =+ CmpInType cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx TopCtx e+ <*> toConcreteCtx TopCtx e'+ toConcrete (CmpElim cmp t e e') =+ CmpElim cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx TopCtx e <*> toConcreteCtx TopCtx e'+ toConcrete (CmpTypes cmp e e') = CmpTypes cmp <$> toConcreteCtx TopCtx e+ <*> toConcreteCtx TopCtx e'+ toConcrete (CmpLevels cmp e e') = CmpLevels cmp <$> toConcreteCtx TopCtx e+ <*> toConcreteCtx TopCtx e'+ toConcrete (CmpTeles cmp e e') = CmpTeles cmp <$> toConcrete e <*> toConcrete e'+ toConcrete (CmpSorts cmp e e') = CmpSorts cmp <$> toConcreteCtx TopCtx e+ <*> toConcreteCtx TopCtx e'+ toConcrete (Assign m e) = noTakenNames $ Assign <$> toConcrete m <*> toConcreteCtx TopCtx e+ toConcrete (TypedAssign m e a) = TypedAssign <$> toConcrete m <*> toConcreteCtx TopCtx e+ <*> toConcreteCtx TopCtx a+ toConcrete (PostponedCheckArgs m args t0 t1) =+ PostponedCheckArgs <$> toConcrete m <*> toConcrete args <*> toConcrete t0 <*> toConcrete t1+ toConcrete (IsEmptyType a) = IsEmptyType <$> toConcreteCtx TopCtx a+ toConcrete (SizeLtSat a) = SizeLtSat <$> toConcreteCtx TopCtx a+ toConcrete (FindInstanceOF s t cs) =+ FindInstanceOF <$> toConcrete s <*> toConcrete t+ <*> mapM (\(q,tm,ty) -> (,,) <$> toConcrete q <*> toConcrete tm <*> toConcrete ty) cs+ toConcrete (ResolveInstanceOF q) = return $ ResolveInstanceOF q+ toConcrete (PTSInstance a b) = PTSInstance <$> toConcrete a <*> toConcrete b+ toConcrete (DataSort a b) = DataSort a <$> toConcrete b+ toConcrete (CheckLock a b) = CheckLock <$> toConcrete a <*> toConcrete b+ toConcrete (PostponedCheckFunDef q a err) = PostponedCheckFunDef q <$> toConcrete a <*> pure err+ toConcrete (UsableAtMod a b) = UsableAtMod a <$> toConcrete b++instance (Pretty a, Pretty b) => Pretty (OutputConstraint' a b) where+ pretty (OfType' e t) = pretty e <+> ":" <+> pretty t++instance (ToConcrete a, ToConcrete b) => ToConcrete (OutputConstraint' a b) where+ type ConOfAbs (OutputConstraint' a b) = OutputConstraint' (ConOfAbs a) (ConOfAbs b)+ toConcrete (OfType' e t) = OfType' <$> toConcrete e <*> toConcreteCtx TopCtx t++instance Reify a => Reify (IPBoundary' a) where+ type ReifiesTo (IPBoundary' a) = IPBoundary' (ReifiesTo a)+ reify = traverse reify++instance ToConcrete a => ToConcrete (IPBoundary' a) where+ type ConOfAbs (IPBoundary' a) = IPBoundary' (ConOfAbs a)++ toConcrete = traverse (toConcreteCtx TopCtx)++instance Pretty c => Pretty (IPFace' c) where+ pretty (IPFace' eqs val) = do+ let+ xs = map (\ (l,r) -> pretty l <+> "=" <+> pretty r) eqs+ -- rhs = case over of+ -- Overapplied -> "=" <+> pretty meta+ -- NotOverapplied -> mempty+ prettyList_ xs <+> "⊢" <+> pretty val -- <+> rhs++prettyConstraints :: [Closure Constraint] -> TCM [OutputForm C.Expr C.Expr]+prettyConstraints cs = do+ forM cs $ \ c -> do+ cl <- reify (PConstr Set.empty alwaysUnblock c)+ enterClosure cl abstractToConcrete_++namedMetaOf :: OutputConstraint A.Expr a -> a+namedMetaOf (OfType i _) = i+namedMetaOf (JustType i) = i+namedMetaOf (JustSort i) = i+namedMetaOf (Assign i _) = i+namedMetaOf _ = __IMPOSSIBLE__++getConstraintsMentioning :: Rewrite -> MetaId -> TCM [OutputForm C.Expr C.Expr]+getConstraintsMentioning norm m = getConstrs instantiateBlockingFull (mentionsMeta m)+ -- could be optimized by not doing a full instantiation up front, with a more clever mentionsMeta.+ where+ instantiateBlockingFull p+ = locallyTCState stInstantiateBlocking (const True) $+ instantiateFull p++ nay :: MaybeT TCM Elims+ nay = MaybeT $ pure Nothing++ -- Trying to find the actual meta application, as long as it's not+ -- buried too deep.+ -- We could look further but probably not under binders as that would mess with+ -- the call to @unifyElimsMeta@ below.+ hasHeadMeta c =+ case c of+ ValueCmp _ _ u v -> isMeta u `mplus` isMeta v+ ValueCmpOnFace cmp p t u v -> isMeta u `mplus` isMeta v+ -- TODO: extend to other comparisons?+ ElimCmp cmp fs t v as bs -> Nothing+ LevelCmp cmp u v -> Nothing+ SortCmp cmp a b -> Nothing+ UnBlock{} -> Nothing+ FindInstance{} -> Nothing+ ResolveInstanceHead{} -> Nothing+ IsEmpty r t -> isMeta (unEl (unDom t))+ CheckSizeLtSat t -> isMeta t+ CheckFunDef{} -> Nothing+ HasBiggerSort a -> Nothing+ HasPTSRule a b -> Nothing+ UnquoteTactic{} -> Nothing+ CheckDataSort _ s -> isMetaS s+ CheckMetaInst{} -> Nothing+ CheckType t -> isMeta (unEl t)+ CheckLockedVars t _ _ _ -> isMeta t+ UsableAtModality _ ms _ t -> caseMaybe ms (isMeta t) $ \ s -> isMetaS s `mplus` isMeta t+ RewConstraint (LocalEquation g t u a) -> isMeta t `mplus` isMeta u++ isMeta :: Term -> Maybe Elims+ isMeta (MetaV m' es_m) | m == m' = pure es_m+ isMeta _ = Nothing++ isMetaS :: I.Sort -> Maybe Elims+ isMetaS (MetaS m' es_m)+ | m == m' = pure es_m+ isMetaS _ = Nothing++ getConstrs g f = liftTCM $ do+ cs <- stripConstraintPids . filter f <$> (mapM g =<< M.getAllConstraints)+ cs <- caseMaybeM (traverse lookupInteractionPoint =<< isInteractionMeta m) (pure cs) $ \ip -> do+ let+ boundary = MapS.keysSet (getBoundary (ipBoundary ip))+ isRedundant c = case allApplyElims =<< hasHeadMeta c of+ Just apps -> caseMaybeM (isFaceConstraint m apps) (pure False) $ \(_, endps, _, _) ->+ pure $ Set.member endps boundary+ Nothing -> pure False+ filterM (flip enterClosure (fmap not . isRedundant) . theConstraint) cs++ reportSDoc "tc.constr.mentioning" 20 $ "getConstraintsMentioning"+ forM cs $ \(PConstr s ub c) -> do+ reportSDoc "tc.constr.mentioning" 20 $ "constraint: " TP.<+> prettyTCM c+ c <- normalForm norm c+ let hm = hasHeadMeta (clValue c)+ reportSDoc "tc.constr.mentioning" 20 $ "constraint: " TP.<+> prettyTCM c+ reportSDoc "tc.constr.mentioning" 20 $ "hasHeadMeta: " TP.<+> prettyTCM hm+ case allApplyElims =<< hm of+ Just as_m -> do+ -- unifyElimsMeta tries to move the constraint into+ -- (an extension of) the context where @m@ comes from.+ unifyElimsMeta m as_m c $ \ eqs c -> do+ flip enterClosure abstractToConcrete_ =<< reify . PConstr s ub =<< buildClosure c+ _ -> do+ cl <- reify $ PConstr s ub c+ enterClosure cl abstractToConcrete_++-- Copied from Agda.TypeChecking.Pretty.Warning.prettyConstraints+stripConstraintPids :: Constraints -> Constraints+stripConstraintPids cs = List.sortBy (compare `on` isBlocked) $ map stripPids cs+ where+ isBlocked = not . null . allBlockingProblems . constraintUnblocker+ interestingPids = Set.unions $ map (allBlockingProblems . constraintUnblocker) cs+ stripPids (PConstr pids unblock c) = PConstr (Set.intersection pids interestingPids) unblock c++{-# SPECIALIZE interactionIdToMetaId :: InteractionId -> TCM MetaId #-}+-- | Converts an 'InteractionId' to a 'MetaId'.+interactionIdToMetaId :: ReadTCState m => InteractionId -> m MetaId+interactionIdToMetaId i = do+ h <- currentModuleNameHash+ return MetaId+ { metaId = fromIntegral i+ , metaModule = h+ }++-- | Get meta solutions and constraints.+getConstraints :: Rewrite -> TCM [OutputForm C.Expr C.Expr]+getConstraints norm = do+ cs <- stripConstraintPids <$> M.getAllConstraints+ cs <- forM cs \ (c :: ProblemConstraint) -> do+ cl <- reify =<< normalForm norm c+ enterClosure cl abstractToConcrete_+ ss <- mapM toOutputForm =<< getSolvedInteractionPoints True norm -- get all+ return $ ss ++ cs+ where+ toOutputForm (ii, mi, e) = do+ mv <- getMetaInfo <$> lookupLocalMeta mi+ withMetaInfo mv $ do+ mi <- interactionIdToMetaId ii+ let m = QuestionMark emptyMetaInfo{ metaNumber = Just mi } ii+ let oform :: OutputForm Expr Expr+ oform = OutputForm noRange [] alwaysUnblock $ Assign m e+ abstractToConcrete_ oform++-- | Reify the boundary of an interaction point as something that can be+-- shown to the user.+getIPBoundary :: Rewrite -> InteractionId -> TCM [IPFace' C.Expr]+getIPBoundary norm ii = withInteractionId ii $ do+ ip <- lookupInteractionPoint ii++ io <- primIOne+ iz <- primIZero++ lookupInteractionMeta ii >>= \case+ Just mi -> do+ mv <- lookupLocalMeta mi++ let t = jMetaType $ mvJudgement mv+ telv@(TelV tel a) <- telView t++ reportSDoc "tc.ip.boundary" 30 $ TP.vcat+ [ "reifying interaction point boundary"+ , "tel: " TP.<+> prettyTCM tel+ , "meta: " TP.<+> prettyTCM mi+ ]+ reportSDoc "tc.ip.boundary" 30 $ "boundary: " TP.<+> pure (pretty (getBoundary (ipBoundary ip)))++ withInteractionId ii $ do+ -- The boundary is a map associating terms (lambda abstractions)+ -- to IntMap Bools. The meta solver will wrap each LHS in lambdas+ -- corresponding to the interaction point's context. Each key of+ -- the boundary has a subset of (the interval variables in) the+ -- interaction point's context as a keysSet.+ as <- getContextArgs+ let+ c = abstractToConcrete_ <=< reifyUnblocked <=< normalForm norm+ go (im, rhs) = do+ reportSDoc "tc.ip.boundary" 30 $ TP.vcat+ [ "reifying constraint for face" TP.<+> TP.pretty im+ ]+ reportSDoc "tc.ip.boundary" 30 $ "term " TP.<+> TP.prettyTCM rhs+ -- Since the RHS is a lambda we have to apply it to the+ -- context:+ rhs <- c (rhs `apply` as)++ -- Reify the IntMap Bool as a list of (i = i0) (j = i1) terms:+ eqns <- forM (IntMap.toList im) $ \(a, b) -> do+ a <- c (I.Var a [])+ (,) a <$> c (if b then io else iz)+ pure $ IPFace' eqns rhs+ traverse go $ MapS.toList (getBoundary (ipBoundary ip))+ Nothing -> pure []++typeAndFacesInMeta :: InteractionId -> Rewrite -> Expr -> TCM (Expr, [IPFace' C.Expr])+typeAndFacesInMeta ii norm expr = withInteractionId ii $ do+ (ex, ty) <- inferExpr expr+ ty <- normalForm norm ty+ ip <- lookupInteractionPoint ii++ io <- primIOne+ iz <- primIZero+ let+ go im = do+ let+ c = abstractToConcrete_ <=< reifyUnblocked <=< normalForm norm+ fa = IntMap.toList im+ face (i, m) = inplaceS i $ if m then io else iz+ sub = foldr (\f s -> composeS (face f) s) idS fa+ eqns <- forM fa $ \(a, b) -> do+ a <- c (I.Var a [])+ (,) a <$> c (if b then io else iz)+ fmap (IPFace' eqns) . c =<< simplify (applySubst sub ex)++ faces <- traverse go $ MapS.keys (getBoundary (ipBoundary ip))+ ty <- reifyUnblocked ty+ pure (ty, faces)++-- | Goals and Warnings++getGoals :: TCM Goals+getGoals = getGoals' AsIs Simplified+ -- visible metas (as-is)+ -- hidden metas (unsolved implicit arguments simplified)++getGoals'+ :: Rewrite -- ^ Degree of normalization of goals.+ -> Rewrite -- ^ Degree of normalization of hidden goals.+ -> TCM Goals+getGoals' normVisible normHidden = do+ visibleMetas <- typesOfVisibleMetas normVisible+ hiddenMetas <- typesOfHiddenMetas normHidden+ return (visibleMetas, hiddenMetas)++-- | Print open metas nicely.+prettyGoals :: Goals -> TCM Doc+prettyGoals (ims, hms) = do+ di <- forM ims $ \ i ->+ withInteractionId (outputFormId $ OutputForm noRange [] alwaysUnblock i) $+ prettyATop i+ dh <- mapM pr hms+ return $ vcat $ di ++ dh+ where+ pr :: OutputConstraint A.Expr NamedMeta -> TCM Doc+ pr m = do+ let i = nmid $ namedMetaOf m+ r <- getMetaRange i+ d <- withMetaId i (prettyATop m)+ return $ d <+> "[ at" <+> pretty r <+> "]"++getWarningsAndNonFatalErrors :: TCM WarningsAndNonFatalErrors+getWarningsAndNonFatalErrors = do+ mws <- getAllWarnings AllWarnings+ let notMetaWarnings = filter (not . isMetaTCWarning) $ Set.toList mws+ return $ case notMetaWarnings of+ ws@(_:_) -> classifyWarnings ws+ _ -> empty++-- | Collecting the context of the given meta-variable.+getResponseContext+ :: Rewrite -- ^ Normalise?+ -> InteractionId+ -> TCM [ResponseContextEntry]+getResponseContext norm ii = contextOfMeta ii norm++-- | @getSolvedInteractionPoints True@ returns all solutions,+-- even if just solved by another, non-interaction meta.+--+-- @getSolvedInteractionPoints False@ only returns metas that+-- are solved by a non-meta.++getSolvedInteractionPoints :: Bool -> Rewrite -> TCM [(InteractionId, MetaId, Expr)]+getSolvedInteractionPoints all norm = concat <$> do+ mapM solution =<< getInteractionIdsAndMetas+ where+ solution (i, m) = do+ mv <- lookupLocalMeta m+ withMetaInfo (getMetaInfo mv) $ do+ args <- getContextArgs+ scope <- getScope+ let sol v = do+ -- Andreas, 2014-02-17 exclude metas solved by metas+ v <- instantiate v+ let isMeta = case v of MetaV{} -> True; _ -> False+ if isMeta && not all then return [] else do+ e <- blankNotInScope =<< reify =<< normalForm norm v+ return [(i, m, ScopedExpr scope e)]+ unsol = return []+ case mvInstantiation mv of+ InstV{} -> sol (MetaV m $ map Apply args)+ OpenMeta{} -> unsol+ BlockedConst{} -> unsol+ PostponedTypeCheckingProblem{} -> unsol++typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputConstraint Expr NamedMeta)+typeOfMetaMI norm mi =+ do mv <- lookupLocalMeta mi+ withMetaInfo (getMetaInfo mv) $+ rewriteJudg mv (mvJudgement mv)+ where+ rewriteJudg :: MetaVariable -> Judgement MetaId ->+ TCM (OutputConstraint Expr NamedMeta)+ rewriteJudg mv (HasType i cmp t) = do+ ms <- getMetaNameSuggestion i+ -- Andreas, 2019-03-17, issue #3638:+ -- Need to put meta type into correct context _before_ normalizing,+ -- otherwise rewrite rules in parametrized modules will not fire.+ vs <- getContextArgs+ t <- t `piApplyM` permute (takeP (size vs) $ mvPermutation mv) vs+ t <- normalForm norm t+ let x = NamedMeta ms i+ reportSDoc "interactive.meta" 10 $ TP.vcat+ [ TP.text $ unwords ["permuting", show i, "with", show $ mvPermutation mv]+ , TP.nest 2 $ TP.vcat+ [ "len =" TP.<+> TP.text (show $ length vs)+ , "args =" TP.<+> prettyTCM vs+ , "t =" TP.<+> prettyTCM t+ , "x =" TP.<+> TP.pretty x+ ]+ ]+ reportSDoc "interactive.meta.scope" 90 $ TP.text $ show $ getMetaScope mv+ -- Andreas, 2016-01-19, issue #1783: need piApplyM instead of just piApply+ OfType x <$> reifyUnblocked t+ rewriteJudg mv (IsSort i t) = do+ ms <- getMetaNameSuggestion i+ return $ JustSort $ NamedMeta ms i+++typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputConstraint Expr InteractionId)+typeOfMeta norm ii = typeOfMeta' norm . (ii,) =<< lookupInteractionId ii++typeOfMeta' :: Rewrite -> (InteractionId, MetaId) -> TCM (OutputConstraint Expr InteractionId)+typeOfMeta' norm (ii, mi) = fmap (\_ -> ii) <$> typeOfMetaMI norm mi++typesOfVisibleMetas :: Rewrite -> TCM [OutputConstraint Expr InteractionId]+typesOfVisibleMetas norm =+ liftTCM $ mapM (typeOfMeta' norm) =<< getInteractionIdsAndMetas++typesOfHiddenMetas :: Rewrite -> TCM [OutputConstraint Expr NamedMeta]+typesOfHiddenMetas norm = liftTCM $ do+ is <- getInteractionMetas+ store <- MapS.filterWithKey (implicit is) <$> useR stOpenMetaStore+ mapM (typeOfMetaMI norm) $ MapS.keys store+ where+ implicit is x m | isJust (mvTwin m) = False+ implicit is x m =+ case mvInstantiation m of+ M.InstV{} -> __IMPOSSIBLE__+ M.OpenMeta _ -> x `notElem` is -- OR: True in case of InstanceMeta !?+ M.BlockedConst{} -> False+ M.PostponedTypeCheckingProblem{} -> False++-- | Create type of application of new helper function that would solve the goal.+metaHelperType :: Rewrite -> InteractionId -> Range -> String -> TCM (OutputConstraint' Expr C.Name)+metaHelperType norm ii rng s = withInteractionId ii do+ -- Parse the raw application.+ ce <- parseExpr rng s+ -- Operator-parse into simple application of @h@ to @cargs@.+ (h, cargs) <- applicationView [] ce+ -- Scope check arguments+ args <- mapM (fmap deepUnscope . concreteToAbstract_) cargs+ -- Andreas, 2025-09-14:+ -- The 'deepUnscope' has been taken from the previous version of the implementation.+ -- Removing it changes the way the type of the helper function is printed,+ -- sometimes for the better, sometimes for the worse.+ -- TODO: investigate why and how this 'deepUnscope' affects the printing,+ -- and whether we should remove it here.++ cxtNames <- getContextNames+ reportSDoc "interaction.helper" 30 $ TP.vcat $+ [ "args =" TP.<+> prettyTCM args+ , "cxt =" TP.<+> prettyTCM cxtNames+ ]+ cxtArgs <- getContextArgs+ enclosingFunctionName <- ipcQName . view eClause <$> getEnv+ a0 <- (`piApply` cxtArgs) <$> (getMetaType =<< lookupInteractionId ii)++ -- Konstantin, 2022-10-23: We don't want to print section parameters in helper type.+ freeVars <- getCurrentModuleFreeVars+ ctx <- getContext+ let contextForAbstracting = cxTake (size ctx - freeVars) ctx++ -- Andreas, 2019-10-11: I actually prefer pi-types over ->.+ let runInPrintingEnvironment = localTC (set ePrintDomainFreePi True . set ePrintMetasBare True)+ . escapeContext impossible (length contextForAbstracting)+ . withoutPrintingGeneralization+ . dontFoldLetBindings++ case mapM (isVar . namedArg) args of++ -- Andreas, 2019-10-11+ -- If all arguments are variables, there is no need to abstract.+ -- We simply make exactly the given arguments visible and all other hidden.+ -- Andreas, 2025-10-22, issue #8150:+ -- Also, the arguments need to be in the same order as in the context.+ Just xs | xs `List.isSubsequenceOf` cxtNames -> do+ let inXs = hasElem xs+ let hideButXs ce = setHiding (if inXs (ctxEntryName ce) then NotHidden else Hidden) ce+ let tel = contextToTel . Context . map hideButXs $ contextForAbstracting+ OfType' h <$> do+ runInPrintingEnvironment $ reify $ telePiVisible tel a0++ -- If some arguments are not variables or not in the right order (in this case, @args@ is not empty).+ _ -> do+ -- cleanupType relies on with arguments being named 'w',+ -- so we'd better rename any actual 'w's to avoid confusion.+ let tel = runIdentity . onNamesTel unW . contextToTel . Context $+ contextForAbstracting+ let a = runIdentity . onNames unW $ a0+ vtys <- mapM (\ a -> fmap (Arg (getArgInfo a) . fmap OtherType) $ inferExpr $ namedArg a) $+ List1.fromListSafe __IMPOSSIBLE__ args+ -- Remember the arity of a+ TelV atel _ <- telView a+ let arity = size atel+ (delta1, delta2, _, a', vtys') = splitTelForWith tel a vtys+ a <- runInPrintingEnvironment $ do+ reify =<< cleanupType arity args =<< normalForm norm =<< fst <$> withFunctionType delta1 vtys' delta2 a' empty+ reportSDoc "interaction.helper" 10 do+ let extractOtherType = \case { OtherType a -> a; _ -> __IMPOSSIBLE__ }+ let (vs, as) = List1.unzipWith (fmap extractOtherType . unArg) vtys+ let (vs', as') = List1.unzipWith (fmap extractOtherType . unArg) vtys'+ TP.vcat+ [ "generating helper function"+ , TP.nest 2 $ "tel = " TP.<+> inTopContext (prettyTCM tel)+ , TP.nest 2 $ "a = " TP.<+> prettyTCM a+ , TP.nest 2 $ "vs = " TP.<+> prettyTCM vs+ , TP.nest 2 $ "as = " TP.<+> prettyTCM as+ , TP.nest 2 $ "delta1 = " TP.<+> inTopContext (prettyTCM delta1)+ , TP.nest 2 $ "delta2 = " TP.<+> inTopContext (addContext delta1 $ prettyTCM delta2)+ , TP.nest 2 $ "a' = " TP.<+> inTopContext (addContext delta1 $ addContext delta2 $ prettyTCM a')+ , TP.nest 2 $ "as' = " TP.<+> inTopContext (addContext delta1 $ prettyTCM as')+ , TP.nest 2 $ "vs' = " TP.<+> inTopContext (addContext delta1 $ prettyTCM vs')+ ]+ return $ OfType' h a+ where+ failure = interactionError ExpectedApplication++ -- An application view for concrete expressions that rejects operator applications.+ -- Takes a suffix of the arguments in left-to-right order (e.g. the empty list)+ -- and returns the head and the arguments in left-to-right order.+ applicationView :: [NamedArg C.Expr] -> C.Expr -> TCM (C.Name, [NamedArg C.Expr])+ applicationView args = \case+ C.Ident (C.QName x) -> return (x, args)+ C.App _ e e1 -> applicationView (e1 : args) e+ C.RawApp _ es -> applicationView args =<< parseApplication es+ C.Paren _ e -> applicationView args e+ -- Allowing operator applications would not make sense.+ -- C.OpApp _ x _ args -> failure+ _ -> failure++ isVar :: A.Expr -> Maybe A.Name+ isVar = \case+ A.Var x -> Just x+ _ -> Nothing+ cleanupType arity args t = do+ -- Get the arity of t+ TelV ttel _ <- telView t+ -- Compute the number of pi-types subject to stripping.+ let n = size ttel - arity+ -- It cannot be negative, otherwise we would have performed a+ -- negative number of with-abstractions.+ unless (n >= 0) __IMPOSSIBLE__+ return $ evalState (renameVars $ stripUnused n t) args++ getBody (A.Let _ _ e) = e+ getBody _ = __IMPOSSIBLE__++ -- Strip the non-dependent abstractions from the first n abstractions.+ stripUnused n (El s v) = El s $ strip n v+ strip 0 = id+ strip n = \case+ I.Pi a b -> case stripUnused (n-1) <$> b of+ b | absName b == "w" -> I.Pi a b+ NoAbs _ b -> unEl b+ Abs s b | 0 `freeIn` b -> I.Pi (hide a) (Abs s b)+ | otherwise -> strengthen impossible (unEl b)+ v -> v -- todo: handle if goal type is a Pi++ -- renameVars = onNames (stringToArgName <.> renameVar . argNameToString)+ renameVars = onNames renameVar++ -- onNames :: Applicative m => (ArgName -> m ArgName) -> I.Type -> m I.Type+ onNames :: Applicative m => (String -> m String) -> I.Type -> m I.Type+ onNames f (El s v) = El s <$> onNamesTm f v++ -- onNamesTel :: Applicative f => (ArgName -> f ArgName) -> I.Telescope -> f I.Telescope+ onNamesTel :: Applicative f => (String -> f String) -> I.Telescope -> f I.Telescope+ onNamesTel f I.EmptyTel = pure I.EmptyTel+ onNamesTel f (I.ExtendTel a b) = I.ExtendTel <$> traverse (onNames f) a <*> onNamesAbs f onNamesTel b++ onNamesTm f = \case+ I.Var x es -> I.Var x <$> onNamesElims f es+ I.Def q es -> I.Def q <$> onNamesElims f es+ I.Con c ci args -> I.Con c ci <$> onNamesArgs f args+ I.Lam i b -> I.Lam i <$> onNamesAbs f onNamesTm b+ I.Pi a b -> I.Pi <$> traverse (onNames f) a <*> onNamesAbs f onNames b+ I.DontCare v -> I.DontCare <$> onNamesTm f v+ v@I.Lit{} -> pure v+ v@I.Sort{} -> pure v+ v@I.Level{} -> pure v+ v@I.MetaV{} -> pure v+ v@I.Dummy{} -> pure v+ onNamesElims f = traverse $ traverse $ onNamesTm f+ onNamesArgs f = traverse $ traverse $ onNamesTm f+ onNamesAbs f = onNamesAbs' f (stringToArgName <.> f . argNameToString)+ onNamesAbs' f f' nd (Abs s x) = Abs <$> f' s <*> nd f x+ onNamesAbs' f f' nd (NoAbs s x) = NoAbs <$> f' s <*> nd f x++ unW "w" = return ".w"+ unW s = return s++ renameVar "w" = betterName+ renameVar s = pure s++ betterName = do+ xs <- get+ case xs of+ [] -> __IMPOSSIBLE__+ arg : args -> do+ put args+ return $ if+ | Arg _ (Named _ (A.Var x)) <- arg -> prettyShow $ A.nameConcrete x+ | Just x <- bareNameOf arg -> argNameToString x+ | otherwise -> "w"+++-- | Gives a list of names and corresponding types.+-- This list includes not only the local variables in scope, but also the let-bindings.++contextOfMeta :: InteractionId -> Rewrite -> TCM [ResponseContextEntry]+contextOfMeta ii norm = withInteractionId ii $ do+ info <- getMetaInfo <$> (lookupLocalMeta =<< lookupInteractionId ii)+ withMetaInfo info $ do+ -- List of local variables.+ cxt <- getContext+ let localVars = flattenContext cxt+ -- List of let-bindings.+ letVars <- Map.toAscList <$> viewTC eLetBindings+ -- Reify the types and filter out bindings without a name.+ (++) <$> forMaybeM localVars mkVar+ <*> forMaybeM letVars mkLet++ where+ mkVar :: ContextEntry -> TCM (Maybe ResponseContextEntry)+ mkVar (CtxVar name dom@(unDom -> t)) = do+ let ai = dom ^. dInfo+ if shouldHide ai name then return Nothing else Just <$> do+ let n = nameConcrete name+ x <- abstractToConcrete_ name+ let s = C.isInScope x+ ty <- reifyUnblocked =<< normalForm norm t+ return $ ResponseContextEntry n x (Arg ai ty) Nothing s++ mkLet :: (Name, Open M.LetBinding) -> TCM (Maybe ResponseContextEntry)+ mkLet (name, lb) = do+ LetBinding isAxiom _ tm !dom <- getOpen lb+ if shouldHide (domInfo dom) name then return Nothing else Just <$> do+ let n = nameConcrete name+ x <- abstractToConcrete_ name+ let s = C.isInScope x+ ty <- reifyUnblocked =<< normalForm norm dom+ -- Remove let bindings from x and later, to avoid folding to x = x, or using bindings+ -- not introduced when x was defined.+ mv <- case isAxiom of+ -- Andreas, 2026-01-29, issue #8344: do not print bindings for 'LetAxiom's.+ YesAxiom -> pure Nothing+ NoAxiom -> Just <$> do removeLetBindingsFrom name $ reifyUnblocked =<< normalForm norm tm+ return $ ResponseContextEntry n x ty mv s++ shouldHide :: ArgInfo -> A.Name -> Bool+ shouldHide ai n = not (isInstance ai) && (isNoName n || nameIsRecordName n)++-- | Returns the type of the expression in the current environment+-- We wake up irrelevant variables just in case the user want to+-- invoke that command in an irrelevant context.+typeInCurrent :: Rewrite -> Expr -> TCM Expr+typeInCurrent norm e =+ do (_,t) <- wakeIrrelevantVars $ inferExpr e+ v <- normalForm norm t+ reifyUnblocked v++++typeInMeta :: InteractionId -> Rewrite -> Expr -> TCM Expr+typeInMeta ii norm e =+ do m <- lookupInteractionId ii+ mi <- getMetaInfo <$> lookupLocalMeta m+ withMetaInfo mi $+ typeInCurrent norm e++-- | The intro tactic.+--+-- Returns the terms (as strings) that can be+-- used to refine the goal. Uses the coverage checker+-- to find out which constructors are possible.+--+introTactic :: Bool -> InteractionId -> TCM [String]+introTactic pmLambda ii = do+ mi <- lookupInteractionId ii+ mv <- lookupLocalMeta mi+ withMetaInfo (getMetaInfo mv) $ case mvJudgement mv of+ HasType _ _ t -> do+ t <- reduce =<< piApplyM t =<< getContextArgs+ -- Andreas, 2013-03-05 Issue 810: skip hidden domains in introduction+ -- of constructor.+ TelV tel' t <- telViewUpTo' (-1) notVisible t+ -- if we cannot introduce a constructor, we try a lambda+ let fallback = do+ cubical <- isJust <$> cubicalOption+ TelV tel _ <- (if cubical then telViewPath else telView) t+ reportSDoc "interaction.intro" 20 $ TP.sep+ [ "introTactic/fallback"+ , "tel' = " TP.<+> prettyTCM tel'+ , "tel = " TP.<+> prettyTCM tel+ ]+ case (tel', tel) of+ (EmptyTel, EmptyTel) -> return []+ _ -> introFun (telToList tel' ++ telToList tel)++ case unEl t of+ I.Def d _ -> do+ def <- getConstInfo d+ case theDef def of+ Datatype{} -> addContext tel' $ introData AmbiguousNothing t+ Record{ recNamedCon = name }+ | name -> addContext tel' $ introData AmbiguousConProjs t+ | otherwise -> addContext tel' $ introRec d+ _ -> fallback+ _ -> fallback+ `catchError` \_ -> return []+ _ -> __IMPOSSIBLE__+ where+ conName :: [NamedArg SplitPattern] -> [I.ConHead]+ conName [p] = [ c | I.ConP c _ _ <- [namedArg p] ]+ conName _ = __IMPOSSIBLE__++ showUnambiguousConName :: AllowAmbiguousNames -> ConHead -> TCM String+ showUnambiguousConName amb c = render . pretty <$> do+ abstractToConcreteQName amb $ I.conName c++ showTCM :: PrettyTCM a => a -> TCM String+ showTCM = render <.> prettyTCM++ introFun :: ListTel -> TCM [String]+ introFun tel = addContext tel' $ do+ reportSDoc "interaction.intro" 10 $ do "introFun" TP.<+> prettyTCM (telFromList tel)+ imp <- showImplicitArguments+ let okHiding0 h = imp || h == NotHidden+ -- if none of the vars were displayed, we would get a parse error+ -- thus, we switch to displaying all+ allHidden = not (any okHiding0 hs)+ okHiding = if allHidden then const True else okHiding0+ vars <- -- setShowImplicitArguments (imp || allHidden) $+ applyWhen allHidden withShowAllArguments $+ mapM showTCM [ setHiding h $ defaultArg $ var i :: Arg Term+ | (h, i) <- zip hs $ downFrom n+ , okHiding h+ ]+ if pmLambda+ then return [ unwords $ ["λ", "{"] ++ vars ++ ["→", "?", "}"] ]+ else return [ unwords $ ["λ"] ++ vars ++ ["→", "?"] ]+ where+ n = size tel+ hs = map getHiding tel+ tel' = telFromList [ fmap makeName b | b <- tel ]+ makeName ("_", t) = ("x", t)+ makeName (x, t) = (x, t)++ contextDimensions :: TCM Int+ contextDimensions = do+ let+ go n EmptyTel = pure n+ go n (ExtendTel dom abs) = do+ n' <- isInterval (unDom dom) <&> \case+ True -> n + 1+ False -> n+ underAbstraction dom abs $ go n'+ go 0 =<< getContextTelescope++ introData :: AllowAmbiguousNames -> I.Type -> TCM [String]+ introData amb t = do+ let tel = telFromList [defaultDom ("_", t)]+ pat = [defaultArg $ unnamed $ deBruijnNamedVar "c" 0]+ -- Gallais, 2023-08-24: #6787 we need to locally ignore the+ -- --without-K or --cubical=compatible options to figure out+ -- that refl is a valid constructor for refl ≡ refl.++ cubical <- isJust <$> cubicalOption+ r <- (if cubical then id else+ locallyTCState (stPragmaOptions . lensOptWithoutK) (const (Value False)))+ $ splitLast CoInductive tel pat++ -- If --cubical then we often get ambiguity because the coverage+ -- checker says most path constructors could also fit the hole. In+ -- that case we compute the number of interval variables in the+ -- context and drop any clauses that have more IApply patterns (=+ -- constructors that have a higher dimensionality) than the+ -- context.+ dim <- traverse (const contextDimensions) =<< cubicalOption+ let+ dimension cl = case dim of+ Just n -> length (iApplyVars (scPats cl)) <= n+ Nothing -> True++ case r of+ Left err -> return []+ Right cov ->+ mapM (showUnambiguousConName amb) $ concatMap (conName . scPats) $ filter dimension $ splitClauses cov++ introRec :: QName -> TCM [String]+ introRec d = do+ hfs <- getRecordFieldNames d+ fs <- ifM showImplicitArguments+ (return $ map unDom hfs)+ (return [ unDom a | a <- hfs, visible a ])+ let e = C.Rec empty noRange $ for fs $ \ f ->+ Left $ C.FieldAssignment f $ C.QuestionMark noRange Nothing+ return [ prettyShow e ]+ -- Andreas, 2019-02-25, remark:+ -- prettyShow is ok here since we are just printing something like+ -- record { f1 = ? ; ... ; fn = ?}+ -- which does not involve any qualified names, and the fi are C.Name.++-- | Runs the given computation as if in an anonymous goal at the end+-- of the top-level module.+--+-- Sets up current module, scope, and context.+atTopLevel :: TCM a -> TCM a+atTopLevel m = inConcreteMode $ do+ let err = __IMPOSSIBLE__+ -- Andreas, 2024-08-03: cannot trigger this error:+ -- let err = genericError "The file has not been loaded yet."+ Strict.caseMaybeM (useTC stCurrentModule) err $ \(current :!: topCurrent) -> do+ caseMaybeM (getVisitedModule topCurrent) __IMPOSSIBLE__ $ \ mi -> do+ let scope = iInsideScope $ miInterface mi+ tel <- lookupSection current+ -- Get the names of the local variables from @scope@+ -- and put them into the context.+ --+ -- Andreas, 2017-04-24, issue #2552:+ --+ -- Delete the let-bound ones, since they are not represented+ -- in the module telescope.+ --+ -- This is a temporary fix until a better solution is available,+ -- e.g., when the module telescope represents let-bound variables.+ --+ -- Unfortunately, referring to let-bound variables+ -- from the top level module telescope will for now result in a not-in-scope error.+ let names :: [A.Name]+ names = map localVar $ filter ((LetBound /=) . localBindingSource)+ $ map snd $ reverse $ scope ^. scopeLocals+ -- Andreas, 2016-12-31, issue #2371+ -- The following is an unnecessary complication, as shadowed locals+ -- are not in scope anyway (they are ambiguous).+ -- -- Replace the shadowed names by fresh names (such that they do not shadow imports)+ -- let mnames :: [Maybe A.Name]+ -- mnames = map (notShadowedLocal . snd) $ reverse $ scopeLocals scope+ -- names <- mapM (maybe freshNoName_ return) mnames+ let types :: [Dom I.Type]+ types = map (snd <$>) $ telToList tel+ gamma :: ListTel' A.Name+ gamma = fromMaybe __IMPOSSIBLE__ $+ zipWithSameLen (\ x dom -> (x,) <$> dom) names types+ reportSDoc "interaction.top" 20 $ TP.vcat+ [ "BasicOps.atTopLevel"+ , " names = " TP.<+> TP.sep (map prettyA names)+ , " types = " TP.<+> TP.sep (map prettyTCM types)+ ]+ M.withCurrentModule current $+ evalWithScope scope $ do+ -- András, 2025-08-30: building fresh scope from interface+ recomputeInverseScope+ addContext gamma $ do+ -- We're going inside the top-level module, so we have to set the+ -- checkpoints for it and all its submodules to the new checkpoint.+ cp <- viewTC eCurrentCheckpoint+ setAllModuleCheckpoints cp+ m++-- | Parse a name.+parseName :: Range -> String -> TCM C.QName+parseName r s = do+ e <- parseExpr r s+ maybe (interactionError $ ExpectedIdentifier e) return $ isQName e++-- | Check whether an expression is a (qualified) identifier.+isQName :: C.Expr -> Maybe C.QName+isQName = \case+ C.Ident x -> return x+ _ -> Nothing++isName :: C.Expr -> Maybe C.Name+isName = isQName >=> \case+ C.QName x -> return x+ _ -> Nothing++-- | Returns the contents of the given module or record.++moduleContents+ :: Rewrite+ -- ^ How should the types be presented?+ -> Range+ -- ^ The range of the next argument.+ -> String+ -- ^ The module name.+ -> TCM ([C.Name], I.Telescope, [(C.Name, I.Type)])+ -- ^ Module names,+ -- context extension needed to print types,+ -- names paired up with corresponding types.++moduleContents norm rng s = traceCall ModuleContents $ do+ if null (trim s) then getModuleContents norm Nothing else do+ e <- parseExpr rng s+ case isQName e of+ -- If the expression is not a single identifier, it is not a module name+ -- and treated as a record expression.+ Nothing -> getRecordContents norm e+ -- Otherwise, if it is not in scope as a module name, it is treated+ -- as a record name.+ Just x -> do+ ms :: [AbstractModule] <- scopeLookup x <$> getScope+ if null ms then getRecordContents norm e else getModuleContents norm $ Just x++-- | Returns the contents of the given record identifier.++getRecordContents+ :: Rewrite -- ^ Amount of normalization in types.+ -> C.Expr -- ^ Expression presumably of record type.+ -> TCM ([C.Name], I.Telescope, [(C.Name, I.Type)])+ -- ^ Module names,+ -- context extension,+ -- names paired up with corresponding types.+getRecordContents norm ce = do+ (_, t) <- inferExpr =<< toAbstract ce+ isRecordType t >>= \case+ Nothing -> typeError $ ShouldBeRecordType t+ Just (q, vs, RecordData{ _recFields = fs, _recTel = rtel }) -> do+ let xs = map (nameConcrete . qnameName . unDom) fs+ tel = apply rtel vs+ doms = flattenTel tel+ -- Andreas, 2019-04-10, issue #3687: use flattenTel+ -- to bring types into correct scope.+ reportSDoc "interaction.contents.record" 20 $ TP.vcat+ [ "getRecordContents"+ , " cxt = " TP.<+> (prettyTCM =<< getContextTelescope)+ , " tel = " TP.<+> prettyTCM tel+ , " doms = " TP.<+> prettyTCM doms+ , " doms'= " TP.<+> addContext tel (prettyTCM doms)+ ]+ ts <- mapM (normalForm norm . unDom) doms+ return ([], tel, zip xs ts)++-- | Returns the contents of the given module.++getModuleContents+ :: Rewrite+ -- ^ Amount of normalization in types.+ -> Maybe C.QName+ -- ^ Module name, @Nothing@ if top-level module.+ -> TCM ([C.Name], I.Telescope, [(C.Name, I.Type)])+ -- ^ Module names,+ -- context extension,+ -- names paired up with corresponding types.+getModuleContents norm mm = do+ modScope <- case mm of+ Nothing -> getCurrentScope+ Just m -> getNamedScope . amodName =<< resolveModule m+ let modules :: ThingsInScope AbstractModule+ modules = exportedNamesInScope modScope+ names :: ThingsInScope AbstractName+ names = exportedNamesInScope modScope+ xns = [ (x,n) | (x, ns) <- Map.toList names, n <- List1.toList ns ]+ types <- forMaybeM xns $ \(x, n) -> do+ getConstInfo' (anameName n) >>= \case+ Right d -> do+ t <- normalForm norm =<< (defType <$> instantiateDef d)+ return $ Just (x, t)+ Left{} -> return Nothing+ return (Map.keys modules, EmptyTel, types)+++whyInScope :: FilePath -> String -> TCM WhyInScopeData+whyInScope cwd s = do+ x <- parseName noRange s+ scope <- getScope+ return $ WhyInScopeData+ x+ cwd+ (lookup x $ map (first C.QName) $ scope ^. scopeLocals)+ (scopeLookup x scope)+ (scopeLookup x scope)
@@ -0,0 +1,124 @@+-- | Type-check all files of a library (option @--build-library@).++module Agda.Interaction.BuildLibrary (buildLibrary, printAccumulatedWarnings) where++import Control.Monad.Except (throwError)+import Control.Monad.IO.Class (liftIO)++import Data.Functor (void)+import Data.List (sort)+import qualified Data.Set as Set++import System.Directory (getCurrentDirectory)+import qualified System.FilePath.Find as Find++import Agda.Interaction.FindFile (hasAgdaExtension, checkModuleName)+import Agda.Interaction.Imports (TCWorkers, Source, MainInterface(..))+import qualified Agda.Interaction.Imports as Imp+import Agda.Interaction.Library (pattern AgdaLibFile, _libIncludes, _libPragmas, getAgdaLibFile)+import Agda.Interaction.Options (optOnlyScopeChecking)++import Agda.Syntax.Abstract.Name (noModuleName)+import Agda.Syntax.Position (beginningOfFile)++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty (prettyTCM, text, vsep)+import Agda.TypeChecking.Pretty.Warning (getAllWarnings, tcWarningsToError)+import Agda.TypeChecking.Warnings (pattern AllWarnings, classifyWarnings)++import Agda.Utils.FileName (absolute)+import Agda.Utils.Functor ()+import Agda.Utils.IO.Directory (findWithInfo)+import Agda.Utils.Monad (forM, forM_, unless, bracket_)+import Agda.Utils.Null (unlessNullM)+import Agda.Utils.String (delimiter)++import Agda.Utils.Impossible (__IMPOSSIBLE__)++-- | Find @.agda-lib@ file from current directory+-- and build all modules located in the @include@ paths+-- and their subdirectories of the library.+--+buildLibrary :: TCM ()+buildLibrary = do+ cwd <- liftIO getCurrentDirectory++ -- Read the library file.+ ls <- libToTCM $ getAgdaLibFile cwd+ libFile@AgdaLibFile{ _libIncludes = paths+ , _libPragmas = libOpts } <- case ls of+ [l] -> pure l+ [] -> throwError $ GenericException "No library found to build"+ _ -> __IMPOSSIBLE__++ checkAndSetOptionsFromPragma libOpts++ -- Import the primitive modules+ Imp.importPrimitiveModules++ -- Find all modules in the include paths of the library.+ files <- sort . map Find.infoPath . concat <$> forM paths \ path -> do+ liftIO $ findWithInfo (pure True) (hasAgdaExtension <$> Find.filePath) path++ -- Call the type-checker on all these modules.+ -- (Code copied from Agda.Main.)++ opts <- commandLineOptions+ par <- Imp.wantsParallelChecking++ checks <- forM files \ inputFile -> do++ path :: AbsolutePath+ <- liftIO (absolute inputFile)+ sf :: SourceFile+ <- srcFromPath path++ -- András, 2026-08-19: issue 8627: for some reason, checking+ -- primitive modules in the following throws coinfectivity error,+ -- but since they're already checked by importPrimitiveModules,+ -- there's no point checking them anyway.+ isBuiltinModule (srcFileId sf) >>= \case+ Just b | isPrimitiveModule b ->+ pure $ pure ()+ _ -> do+ src :: Source+ <- Imp.parseSource sf+ let+ m :: TopLevelModuleName+ m = Imp.srcModuleName src+ setCurrentRange (beginningOfFile path) do+ checkModuleName m (Imp.srcOrigin src) Nothing+ withCurrentModule noModuleName+ $ withTopLevelModule m+ $ checkModule par m src++ sequence_ checks+ printAccumulatedWarnings++printAccumulatedWarnings :: TCM ()+printAccumulatedWarnings = do+ unlessNullM (tcWarnings . classifyWarnings . Set.toAscList <$> getAllWarnings AllWarnings) $ \ ws -> do+ let banner = text $ "\n" ++ delimiter "All done; warnings encountered"+ alwaysReportSDoc "warning" 1 $+ vsep $ (banner :) $ map prettyTCM $ Set.toAscList ws++postCheckModule :: TopLevelModuleName -> Source -> ModuleInfo -> TCM ()+postCheckModule m src mi = do+ -- Here we ignore InfectiveImport warnings since we don't have an actual parent module that can+ -- be infected.+ let+ isInfectiveWarning InfectiveImport{} = True+ isInfectiveWarning _ = False+ warns = filter (not . isInfectiveWarning . tcWarning) $ Set.toAscList $ miWarnings mi+ tcWarningsToError (TopLevelModuleNameWithSourceFile m (Imp.srcOrigin src)) warns++checkModule :: Maybe TCWorkers -> TopLevelModuleName -> Source -> TCM (TCM ())+checkModule (Just w) m src = bracket_ (useTC stPragmaOptions) (stPragmaOptions `setTCLens`) do+ Imp.setOptionsFromSourcePragmas True src+ mip <- Imp.chaseModule w m NotMainInterface (Just src)+ pure $ mip >>= postCheckModule m src++checkModule Nothing m src = do+ mi <- Imp.getNonMainModuleInfo m (Just src)+ postCheckModule m src mi+ pure $ pure ()
@@ -0,0 +1,55 @@+module Agda.Interaction.Command+ ( CommandM, localStateCommandM, liftLocalState, revLift, revLiftTC+ ) where++import Control.Monad.State ( MonadState(..), execStateT, lift )++import Agda.TypeChecking.Monad.Base ( TCM,MonadTCState, TCState, getTC, putTC )+import Agda.TypeChecking.Monad.State ( localTCState )++import Agda.Interaction.Base ( CommandM' )++------------------------------------------------------------------------+-- The CommandM monad++type CommandM = CommandM' TCM++-- | Restore both 'TCState' and 'CommandState'.++localStateCommandM :: CommandM a -> CommandM a+localStateCommandM m = do+ cSt <- get+ tcSt <- getTC+ x <- m+ putTC tcSt+ put cSt+ return x++-- | Restore 'TCState', do not touch 'CommandState'.++liftLocalState :: TCM a -> CommandM a+liftLocalState = lift . localTCState++-- | Build an opposite action to 'lift' for state monads.++revLift+ :: MonadState st m+ => (forall c . m c -> st -> k (c, st)) -- ^ run+ -> (forall b . k b -> m b) -- ^ lift+ -> (forall x . (m a -> k x) -> k x) -> m a -- ^ reverse lift in double negative position+revLift run lift' f = do+ st <- get+ (a, st') <- lift' $ f (`run` st)+ put st'+ return a++revLiftTC+ :: MonadTCState m+ => (forall c . m c -> TCState -> k (c, TCState)) -- ^ run+ -> (forall b . k b -> m b) -- ^ lift+ -> (forall x . (m a -> k x) -> k x) -> m a -- ^ reverse lift in double negative position+revLiftTC run lift' f = do+ st <- getTC+ (a, st') <- lift' $ f (`run` st)+ putTC st'+ return a
@@ -0,0 +1,358 @@++module Agda.Interaction.CommandLine+ ( runInteractionLoop+ ) where++import Control.Monad+import Control.Monad.Except+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.State+import Control.Monad.Reader++import qualified Data.List as List+import Data.Maybe++import Text.Read (readMaybe)++import Agda.Interaction.Base hiding (Command)+import Agda.Interaction.BasicOps as BasicOps hiding (parseExpr)+import Agda.Interaction.Imports ( CheckResult, crInterface )+import Agda.Interaction.Monad++import qualified Agda.Syntax.Abstract as A+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Common.Pretty.ANSI (putDocLn)+import Agda.Syntax.Internal (telToList, alwaysUnblock)+import qualified Agda.Syntax.Internal as I+import Agda.Syntax.Parser+import Agda.Syntax.Position+import Agda.Syntax.Scope.Base+import Agda.Syntax.Translation.ConcreteToAbstract+import Agda.Syntax.Abstract.Pretty++import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Errors+import Agda.TypeChecking.Pretty ( PrettyTCM(prettyTCM) )+import Agda.TypeChecking.Substitute++import Agda.Utils.FileName (absolute, AbsolutePath)+import Agda.Utils.Maybe (caseMaybeM)++import Agda.Utils.Impossible++data ReplEnv = ReplEnv+ { replSetupAction :: TCM ()+ , replTypeCheckAction :: AbsolutePath -> TCM CheckResult+ }++data ReplState = ReplState+ { currentFile :: Maybe AbsolutePath+ }++newtype ReplM a = ReplM { unReplM :: ReaderT ReplEnv (StateT ReplState IM) a }+ deriving+ ( Functor, Applicative, Monad, MonadIO+ , HasOptions, MonadTCEnv, ReadTCState, MonadTCState, MonadTCM+ , MonadError TCErr+ , MonadReader ReplEnv, MonadState ReplState+ , MonadFileId+ )++runReplM :: Maybe AbsolutePath -> TCM () -> (AbsolutePath -> TCM CheckResult) -> ReplM () -> TCM ()+runReplM initialFile setup checkInterface+ = runIM+ . flip evalStateT (ReplState initialFile)+ . flip runReaderT replEnv+ . unReplM+ where+ replEnv = ReplEnv+ { replSetupAction = setup+ , replTypeCheckAction = checkInterface+ }++data ExitCode a = Continue | ContinueIn TCEnv | Return a++type Command a = (String, [String] -> ReplM (ExitCode a))++matchCommand :: String -> [Command a] -> Either [String] ([String] -> ReplM (ExitCode a))+matchCommand x cmds =+ case List.filter (List.isPrefixOf x . fst) cmds of+ [(_,m)] -> Right m+ xs -> Left $ List.map fst xs++interaction :: String -> [Command a] -> (String -> TCM (ExitCode a)) -> ReplM a+interaction prompt cmds eval = loop+ where+ go (Return x) = return x+ go Continue = loop+ go (ContinueIn env) = localTC (const env) loop++ loop =+ do ms <- ReplM $ lift $ lift $ readline prompt+ case fmap words ms of+ Nothing -> return $ error "** EOF **"+ Just [] -> loop+ Just ((':':cmd):args) ->+ do case matchCommand cmd cmds of+ Right c -> go =<< (c args)+ Left [] ->+ do liftIO $ putStrLn $ "Unknown command '" ++ cmd ++ "'"+ loop+ Left xs ->+ do liftIO $ putStrLn $ "More than one command match: " +++ List.intercalate ", " xs+ loop+ Just _ ->+ do go =<< liftTCM (eval $ fromJust ms)+ `catchError` \e ->+ do putDocLn =<< prettyError e+ loop++runInteractionLoop :: Maybe AbsolutePath -> TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM ()+runInteractionLoop initialFile setup check = runReplM initialFile setup check interactionLoop++replSetup :: ReplM ()+replSetup = do+ liftTCM =<< asks replSetupAction+ liftIO $ putStr splashScreen++checkCurrentFile :: ReplM (Maybe CheckResult)+checkCurrentFile = traverse checkFile =<< gets currentFile++checkFile :: AbsolutePath -> ReplM CheckResult+checkFile file = liftTCM . ($ file) =<< asks replTypeCheckAction++-- | The interaction loop.+interactionLoop :: ReplM ()+interactionLoop = do+ -- Run the setup action+ replSetup+ reload+ interaction "Main> " commands evalTerm+ where+ reload :: ReplM () = do+ checked <- checkCurrentFile+ liftTCM $ do+ case checked of+ Nothing -> setScope emptyScopeInfo+ Just scope -> do setScope (iInsideScope $ crInterface scope)+ recomputeInverseScope+ -- Andreas, 2021-01-27, issue #5132, make Set and Prop available from Agda.Primitive+ -- if no module is loaded.+ when (isNothing checked) $ do+ -- @open import Agda.Primitive using (Set; Prop)@+ void $ liftTCM importPrimitives+ `catchError` \e -> do+ putDocLn =<< prettyError e+ liftIO $ putStrLn "Failed."++ commands =+ [ "quit" |> \_ -> return $ Return ()+ , "?" |> \_ -> continueAfter $ liftIO $ help commands+ , "reload" |> \_ -> do reload+ ContinueIn <$> askTC+ , "constraints" |> \args -> continueAfter $ liftTCM $ showConstraints args+ , "Context" |> \args -> continueAfter $ liftTCM $ showContext args+ , "give" |> \args -> continueAfter $ liftTCM $ giveMeta args+ , "Refine" |> \args -> continueAfter $ liftTCM $ refineMeta args+ , "metas" |> \args -> continueAfter $ liftTCM $ showMetas args+ , "load" |> \args -> continueAfter $ loadFile reload args+ , "eval" |> \args -> continueAfter $ liftTCM $ evalIn args+ , "typeOf" |> \args -> continueAfter $ liftTCM $ typeOf args+ , "typeIn" |> \args -> continueAfter $ liftTCM $ typeIn args+ , "wakeup" |> \_ -> continueAfter $ liftTCM $ retryConstraints+ , "scope" |> \_ -> continueAfter $ liftTCM $ showScope+ ]+ where+ (|>) = (,)++continueAfter :: ReplM a -> ReplM (ExitCode b)+continueAfter m = withCurrentFile $ do+ m >> return Continue++-- | Set 'envCurrentPath' to the repl's current file+withCurrentFile :: ReplM a -> ReplM a+withCurrentFile cont = do+ mpath <- gets currentFile+ i <- traverse idFromFile mpath+ localTC (set eCurrentPath i) cont++loadFile :: ReplM () -> [String] -> ReplM ()+loadFile reload [file] = do+ absPath <- liftIO $ absolute file+ modify (\(ReplState _prevFile) -> ReplState (Just absPath))+ withCurrentFile reload+loadFile _ _ = liftIO $ putStrLn ":load file"++showConstraints :: [String] -> TCM ()+showConstraints [] =+ do cs <- BasicOps.getConstraints AsIs+ liftIO $ putStrLn $ unlines (List.map prettyShow cs)+showConstraints _ = liftIO $ putStrLn ":constraints [cid]"+++showMetas :: [String] -> TCM ()+showMetas [m] =+ do i <- InteractionId <$> readM m+ withInteractionId i $ do+ s <- typeOfMeta AsIs i+ r <- getInteractionRange i+ d <- prettyA s+ liftIO $ putStrLn $ render d ++ " " ++ prettyShow r+showMetas [m,"normal"] =+ do i <- InteractionId <$> readM m+ withInteractionId i $ do+ s <- prettyA =<< typeOfMeta Normalised i+ r <- getInteractionRange i+ liftIO $ putStrLn $ render s ++ " " ++ prettyShow r+showMetas [] =+ do interactionMetas <- typesOfVisibleMetas AsIs+ hiddenMetas <- typesOfHiddenMetas AsIs+ mapM_ (liftIO . print) =<< mapM showII interactionMetas+ mapM_ print' hiddenMetas+ where+ showII o = withInteractionId (outputFormId $ OutputForm noRange [] alwaysUnblock o) $ prettyA o+ showM o = withMetaId (nmid $ outputFormId $ OutputForm noRange [] alwaysUnblock o) $ prettyA o++ metaId (OfType i _) = i+ metaId (JustType i) = i+ metaId (JustSort i) = i+ metaId (Assign i e) = i+ metaId _ = __IMPOSSIBLE__+ print' x = do+ r <- getMetaRange $ nmid $ metaId x+ d <- showM x+ liftIO $ putStrLn $ render d ++ " [ at " ++ prettyShow r ++ " ]"+showMetas _ = liftIO $ putStrLn $ ":meta [metaid]"+++showScope :: TCM ()+showScope = do+ scope <- getScope+ liftIO $ putStrLn $ prettyShow scope++metaParseExpr :: InteractionId -> String -> TCM A.Expr+metaParseExpr ii s =+ do m <- lookupInteractionId ii+ scope <- getMetaScope <$> lookupLocalMeta m+ r <- getRange <$> lookupLocalMeta m+ -- liftIO $ putStrLn $ prettyShow scope+ let pos = fromMaybe __IMPOSSIBLE__ (rStart r)+ (e, attrs) <- runPM $ parsePosString exprParser pos s+ checkAttributes attrs+ concreteToAbstract scope e++actOnMeta :: [String] -> (InteractionId -> A.Expr -> TCM a) -> TCM a+actOnMeta (is:es) f =+ do i <- readM is+ let ii = InteractionId i+ e <- metaParseExpr ii (unwords es)+ withInteractionId ii $ f ii e+actOnMeta _ _ = __IMPOSSIBLE__+++giveMeta :: [String] -> TCM ()+giveMeta s | length s >= 2 = do+ _ <- actOnMeta s $ \ ii e -> give WithoutForce ii e+ return ()+giveMeta _ = liftIO $ putStrLn $ ": give" ++ " metaid expr"++++refineMeta :: [String] -> TCM ()+refineMeta s | length s >= 2 = do+ _ <- actOnMeta s $ \ ii e -> refine WithoutForce ii e+ return ()+refineMeta _ = liftIO $ putStrLn $ ": refine" ++ " metaid expr"++++retryConstraints :: TCM ()+retryConstraints = wakeupConstraints_+++evalIn :: [String] -> TCM ()+evalIn s | length s >= 2 =+ do d <- actOnMeta s $ \_ e -> prettyA =<< evalInCurrent DefaultCompute e+ liftIO $ print d+evalIn _ = liftIO $ putStrLn ":eval metaid expr"++parseExpr :: String -> TCM A.Expr+parseExpr s = do+ (e, attrs) <- runPM $ parse exprParser s+ checkAttributes attrs+ localToAbstract e return++evalTerm :: String -> TCM (ExitCode a)+evalTerm s =+ do e <- parseExpr s+ v <- evalInCurrent DefaultCompute e+ e <- prettyTCM v+ liftIO $ print e+ return Continue++typeOf :: [String] -> TCM ()+typeOf s =+ do e <- parseExpr (unwords s)+ e0 <- typeInCurrent Normalised e+ e1 <- typeInCurrent AsIs e+ liftIO . print =<< prettyA e1++typeIn :: [String] -> TCM ()+typeIn s@(_:_:_) =+ actOnMeta s $ \i e ->+ do e1 <- typeInMeta i Normalised e+ e2 <- typeInMeta i AsIs e+ liftIO . print =<< prettyA e1+typeIn _ = liftIO $ putStrLn ":typeIn meta expr"++showContext :: [String] -> TCM ()+showContext (meta:args) = do+ i <- InteractionId <$> readM meta+ mi <- lookupLocalMeta =<< lookupInteractionId i+ withMetaInfo (getMetaInfo mi) $ do+ ctx <- List.map I.unDom . telToList <$> getContextTelescope+ zipWithM_ display ctx $ reverse $ zipWith const [1..] ctx+ where+ display (x, t) n = do+ t <- case args of+ ["normal"] -> normalise $ raise n t+ _ -> return $ raise n t+ d <- prettyTCM t+ liftIO $ print $ text (argNameToString x) <+> ":" <+> d+showContext _ = liftIO $ putStrLn ":Context meta"++-- | The logo that prints when Agda is started in interactive mode.+splashScreen :: String+splashScreen = unlines+ [ " _ "+ , " ____ | |"+ , " / __ \\ | |"+ , " | |__| |___ __| | ___"+ , " | __ / _ \\/ _ |/ __\\ Agda Interactive"+ , " | | |/ /_\\ \\/_| / /_| \\"+ , " |_| |\\___ /____\\_____/ Type :? for help."+ , " __/ /"+ , " \\__/"+ , ""+ -- , "The interactive mode is no longer supported. Don't complain if it doesn't work."+ , "The interactive mode is no longer under active development. Use at your own risk."+ ]++-- | The help message+help :: [Command a] -> IO ()+help cs = putStr $ unlines $+ [ "Command overview" ] ++ List.map explain cs +++ [ "<exp> Infer type of expression <exp> and evaluate it." ]+ where+ explain (x,_) = ":" ++ x++-- Read -------------------------------------------------------------------++readM :: Read a => String -> TCM a+readM s = maybe err return $ readMaybe s+ where+ err = throwError $ GenericException $ "Cannot parse: " ++ s
@@ -1,301 +0,0 @@-{-# LANGUAGE CPP #-}--module Agda.Interaction.CommandLine.CommandLine where--import Control.Monad.Error-import Control.Monad.Reader-import Control.Applicative-import Data.Char-import Data.Set as Set-import Data.Map as Map-import Data.List as List-import Data.Maybe-import qualified Agda.Utils.IO.Locale as LocIO--import Agda.Interaction.BasicOps as BasicOps hiding (parseExpr)-import Agda.Interaction.Monad--import qualified Agda.Syntax.Abstract as A-import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.Syntax.Parser-import Agda.Syntax.Position-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad-import Agda.Syntax.Translation.ConcreteToAbstract-import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Abstract.Pretty--import Text.PrettyPrint--import Agda.TypeChecker-import Agda.TypeChecking.Conversion-import Agda.TypeChecking.Constraints-import Agda.TypeChecking.Monad-import Agda.TypeChecking.MetaVars-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Errors-import Agda.TypeChecking.Substitute--import Agda.Utils.Monad-import Agda.Utils.Fresh--#include "../../undefined.h"-import Agda.Utils.Impossible--data ExitCode a = Continue | ContinueIn TCEnv | Return a--type Command a = (String, [String] -> TCM (ExitCode a))--matchCommand :: String -> [Command a] -> Either [String] ([String] -> TCM (ExitCode a))-matchCommand x cmds =- case List.filter (isPrefixOf x . fst) cmds of- [(_,m)] -> Right m- xs -> Left $ List.map fst xs--interaction :: String -> [Command a] -> (String -> TCM (ExitCode a)) -> IM a-interaction prompt cmds eval = loop- where- go (Return x) = return x- go Continue = loop- go (ContinueIn env) = local (const env) loop-- loop =- do ms <- readline prompt- case fmap words ms of- Nothing -> return $ error "** EOF **"- Just [] -> loop- Just ((':':cmd):args) ->- do case matchCommand cmd cmds of- Right c -> go =<< liftTCM (c args)- Left [] ->- do liftIO $ LocIO.putStrLn $ "Unknown command '" ++ cmd ++ "'"- loop- Left xs ->- do liftIO $ LocIO.putStrLn $ "More than one command match: " ++ concat (intersperse ", " xs)- loop- Just _ ->- do go =<< liftTCM (eval $ fromJust ms)- `catchError` \e ->- do s <- liftTCM $ prettyError e- liftIO $ LocIO.putStrLn s- loop---- | The interaction loop.-interactionLoop :: TCM (Maybe Interface) -> IM ()-interactionLoop typeCheck =- do liftTCM reload- interaction "Main> " commands evalTerm- where- reload = do- mi <- typeCheck- -- Note that mi is Nothing if (1) there is no input file or- -- (2) the file type checked with unsolved metas and- -- --allow-unsolved-metas was used. In the latter case the- -- behaviour of agda -I may be surprising. If agda -I ever- -- becomes properly supported again, then this behaviour- -- should perhaps be fixed.- setScope $ case mi of- Just i -> iInsideScope i- Nothing -> emptyScopeInfo- `catchError` \e -> do- s <- prettyError e- liftIO $ LocIO.putStrLn s- liftIO $ LocIO.putStrLn "Failed."-- commands =- [ "quit" |> \_ -> return $ Return ()- , "?" |> \_ -> continueAfter $ liftIO $ help commands- , "reload" |> \_ -> do reload- ContinueIn <$> ask- , "constraints" |> \args -> continueAfter $ showConstraints args- , "Context" |> \args -> continueAfter $ showContext args- , "give" |> \args -> continueAfter $ giveMeta args- , "Refine" |> \args -> continueAfter $ refineMeta args- , "metas" |> \args -> continueAfter $ showMetas args- , "load" |> \args -> continueAfter $ loadFile reload args- , "eval" |> \args -> continueAfter $ evalIn args- , "typeOf" |> \args -> continueAfter $ typeOf args- , "typeIn" |> \args -> continueAfter $ typeIn args- , "wakeup" |> \_ -> continueAfter $ retryConstraints- , "scope" |> \_ -> continueAfter $ showScope- ]- where- (|>) = (,)--continueAfter :: TCM a -> TCM (ExitCode b)-continueAfter m = m >> return Continue--loadFile :: TCM () -> [String] -> TCM ()-loadFile reload [file] =- do setInputFile file- reload-loadFile _ _ = liftIO $ LocIO.putStrLn ":load file"--showConstraints :: [String] -> TCM ()-showConstraints [] =- do cs <- BasicOps.getConstraints- liftIO $ LocIO.putStrLn $ unlines (List.map show cs)-showConstraints _ = liftIO $ LocIO.putStrLn ":constraints [cid]"---showMetas :: [String] -> TCM ()-showMetas [m] =- do i <- InteractionId <$> readM m- withInteractionId i $ do- s <- typeOfMeta AsIs i- r <- getInteractionRange i- d <- showA s- liftIO $ LocIO.putStrLn $ d ++ " " ++ show r-showMetas [m,"normal"] =- do i <- InteractionId <$> readM m- withInteractionId i $ do- s <- showA =<< typeOfMeta Normalised i- r <- getInteractionRange i- liftIO $ LocIO.putStrLn $ s ++ " " ++ show r-showMetas [] =- do interactionMetas <- typesOfVisibleMetas AsIs- hiddenMetas <- typesOfHiddenMetas AsIs- mapM_ (liftIO . LocIO.putStrLn) =<< mapM showII interactionMetas- mapM_ print' hiddenMetas- where- showII o = withInteractionId (outputFormId $ OutputForm 0 o) $ showA o- showM o = withMetaId (outputFormId $ OutputForm 0 o) $ showA o-- metaId (OfType i _) = i- metaId (JustType i) = i- metaId (JustSort i) = i- metaId (Assign i e) = i- metaId _ = __IMPOSSIBLE__- print' x = do- r <- getMetaRange (metaId x)- d <- showM x- liftIO $ LocIO.putStrLn $ d ++ " [ at " ++ show r ++ " ]"-showMetas _ = liftIO $ LocIO.putStrLn $ ":meta [metaid]"---showScope :: TCM ()-showScope = do- scope <- getScope- liftIO $ LocIO.print scope--metaParseExpr :: InteractionId -> String -> TCM A.Expr-metaParseExpr ii s =- do m <- lookupInteractionId ii- scope <- getMetaScope <$> lookupMeta m- r <- getRange <$> lookupMeta m- --liftIO $ LocIO.putStrLn $ show scope- let pos = case rStart r of- Nothing -> __IMPOSSIBLE__- Just pos -> pos- e <- liftIO $ parsePosString exprParser pos s- concreteToAbstract scope e--actOnMeta :: [String] -> (InteractionId -> A.Expr -> TCM a) -> TCM a-actOnMeta (is:es) f =- do i <- readM is- let ii = InteractionId i- e <- metaParseExpr ii (unwords es)- withInteractionId ii $ f ii e-actOnMeta _ _ = __IMPOSSIBLE__---giveMeta :: [String] -> TCM ()-giveMeta s | length s >= 2 =- do actOnMeta s (\ii -> \e -> give ii Nothing e)- return ()-giveMeta _ = liftIO $ LocIO.putStrLn $ ": give" ++ " metaid expr"----refineMeta :: [String] -> TCM ()-refineMeta s | length s >= 2 =- do actOnMeta s (\ii -> \e -> refine ii Nothing e)- return ()-refineMeta _ = liftIO $ LocIO.putStrLn $ ": refine" ++ " metaid expr"----retryConstraints :: TCM ()-retryConstraints = liftTCM wakeupConstraints_---evalIn :: [String] -> TCM ()-evalIn s | length s >= 2 =- do d <- actOnMeta s $ \_ e -> prettyA =<< evalInCurrent e- liftIO $ LocIO.print d-evalIn _ = liftIO $ LocIO.putStrLn ":eval metaid expr"--parseExpr :: String -> TCM A.Expr-parseExpr s = do- e <- liftIO $ parse exprParser s- localToAbstract e return--evalTerm :: String -> TCM (ExitCode a)-evalTerm s =- do e <- parseExpr s- v <- evalInCurrent e- e <- prettyTCM v- liftIO $ LocIO.putStrLn $ show e- return Continue- where- evalInCurrent e = do- (v,t) <- inferExpr e- v' <- normalise v- return v'---typeOf :: [String] -> TCM ()-typeOf s =- do e <- parseExpr (unwords s)- e0 <- typeInCurrent Normalised e- e1 <- typeInCurrent AsIs e- liftIO . LocIO.putStrLn =<< showA e1--typeIn :: [String] -> TCM ()-typeIn s@(_:_:_) =- actOnMeta s $ \i e ->- do e1 <- typeInMeta i Normalised e- e2 <- typeInMeta i AsIs e- liftIO . LocIO.putStrLn =<< showA e1-typeIn _ = liftIO $ LocIO.putStrLn ":typeIn meta expr"--showContext :: [String] -> TCM ()-showContext (meta:args) = do- i <- InteractionId <$> readM meta- mi <- lookupMeta =<< lookupInteractionId i- withMetaInfo (getMetaInfo mi) $ do- ctx <- List.map unArg . telToList <$> getContextTelescope- zipWithM_ display ctx $ reverse $ zipWith const [1..] ctx- where- display (x, t) n = do- t <- case args of- ["normal"] -> normalise $ raise n t- _ -> return $ raise n t- d <- prettyTCM t- liftIO $ LocIO.print $ text x <+> text ":" <+> d-showContext _ = liftIO $ LocIO.putStrLn ":Context meta"---- | The logo that prints when Agda is started in interactive mode.-splashScreen :: String-splashScreen = unlines- [ " _ "- , " ____ | |"- , " / __ \\ | |"- , " | |__| |___ __| | ___"- , " | __ / _ \\/ _ |/ __\\ Agda Interactive"- , " | | |/ /_\\ \\/_| / /_| \\"- , " |_| |\\___ /____\\_____/ Type :? for help."- , " __/ /"- , " \\__/"- , ""- , "The interactive mode is no longer supported. Don't complain if it doesn't work."- ]---- | The help message-help :: [Command a] -> IO ()-help cs = LocIO.putStr $ unlines $- [ "Command overview" ] ++ List.map explain cs ++- [ "<exp> Infer type of expression <exp> and evaluate it." ]- where- explain (x,_) = ":" ++ x
@@ -0,0 +1,52 @@+-- | Abstract elisp syntax.++module Agda.Interaction.Emacs.Lisp+ ( Lisp(..)+ , response+ , putResponse+ ) where++import Agda.Syntax.Common.Pretty++-- | Simple Emacs Lisp expressions.++data Lisp a+ = A a+ -- ^ Atom.+ | Cons (Lisp a) (Lisp a)+ -- Cons cell.+ | L [Lisp a]+ -- ^ List.+ | Q (Lisp a)+ -- Quoted expression.+ deriving Eq++instance Pretty a => Pretty (Lisp a) where+ pretty (A a ) = pretty a+ pretty (Cons a b) = parens (pretty a <+> "." <+> pretty b)+ pretty (L xs) = parens (hsep (map pretty xs))+ pretty (Q x) = "'" <> pretty x++-- instance Show (Lisp String) where+-- showsPrec _ (A a) = showString a+-- showsPrec p (Cons a b) = showString "(" . showsPrec p a . showString " . " .+-- showsPrec p b . showString ")"+-- showsPrec p (L xs) = showString "(" . foldr (.) (showString ")")+-- (List.intersperse (showString " ")+-- (map (showsPrec p) xs))+-- showsPrec p (Q x) = showString "'" . showsPrec p x++-- | Formats a response command.+--+-- Replaces @'\n'@ with spaces to ensure that each command is a+-- single line.+response :: Lisp String -> String+response = (++ "\n") . map replaceNewLines . prettyShow+ where+ replaceNewLines '\n' = ' '+ replaceNewLines c = c++-- | Writes a response command to standard output.++putResponse :: Lisp String -> IO ()+putResponse = putStr . response
@@ -1,45 +1,77 @@+ --------------------------------------------------------------------------- | Low-level code for instructing Emacs to do things+-- | Code for instructing Emacs to do things ------------------------------------------------------------------------ -{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}- module Agda.Interaction.EmacsCommand- ( Lisp(..)- , putResponse+ ( displayInfo+ , clearRunningInfo+ , displayRunningInfo+ , displayVerboseInfo ) where -import qualified Agda.Utils.IO.Locale as LocIO-import Agda.Utils.Pretty+import Prelude hiding (null) --- | Simple Emacs Lisp expressions.+import Data.Bifunctor (second)+import Data.Text qualified as Text -data Lisp a- = A a- -- ^ Atom.- | Cons (Lisp a) (Lisp a)- -- Cons cell.- | L [Lisp a]- -- ^ List.- | Q (Lisp a)- -- Quoted expression.+import Agda.Syntax.Common.Pretty (DocTree) -instance Pretty a => Pretty (Lisp a) where- pretty (A a ) = pretty a- pretty (Cons a b) = parens (pretty a <+> text "." <+> pretty b)- pretty (L xs) = parens (hsep (map pretty xs))- pretty (Q x) = text "'" <> pretty x+import Agda.Interaction.Emacs.Lisp+import Agda.Interaction.Highlighting.Emacs (HighlightingInfo, lispifyHighlightingInfo_) -instance Pretty String where pretty = text+import Agda.TypeChecking.Monad.Base.Types (ModuleToSource) -instance Pretty a => Show (Lisp a) where show = show . pretty+import Agda.Utils.Null+import Agda.Utils.String (quote)+import Agda.Utils.DocTree (treeToTextNoAnn, treeToTextWithAnn) --- | Formats a response command.+-- | @displayInfo header content append m@ displays @content@+-- with header @header@ in some suitable way in the Agda information buffer.+-- If @append@ is @True@, then the content is appended to previous content+-- (if any), otherwise any previous content is deleted.+-- If @m@ is @Just 'ModuleToSource'@ then @content@ is rendered with annotations,+-- otherwise annotations in @content@ are discarded and just the text is displayed. -response :: Lisp String -> String-response l = show (text "agda2_mode_code" <+> pretty l)+displayInfo :: String -> DocTree -> Bool -> Maybe ModuleToSource -> Lisp String+displayInfo header content append m = L $ concat+ [ [ A "agda2-info-action"+ , A (quote header)+ , A (quote $ Text.unpack t)+ , A (if append then "t" else "nil")+ ]+ , map Q ann+ ]+ where+ (t, ann) = processAnnotations content m --- | Writes a response command to standard output.+------------------------------------------------------------------------+-- Running info -putResponse :: Lisp String -> IO ()-putResponse = LocIO.putStrLn . response+-- | Header to display in the Agda information buffer for "running info".++runningInfoHeader :: String+runningInfoHeader = "*Type-checking*"++-- | Clear the running info buffer.++clearRunningInfo :: Lisp String+clearRunningInfo = displayInfo runningInfoHeader empty False Nothing++-- | Display running information about what the type-checker is up to.++displayRunningInfo :: DocTree -> Maybe ModuleToSource -> Lisp String+displayRunningInfo t = displayInfo runningInfoHeader t True++displayVerboseInfo :: DocTree -> Maybe ModuleToSource -> Lisp String+displayVerboseInfo t m = L $ concat+ [ [ A "agda2-verbose"+ , A (quote $ Text.unpack tx)]+ , map Q anns]+ where+ (tx, anns) = processAnnotations t m++processAnnotations :: DocTree -> Maybe ModuleToSource -> (Text.Text, [Lisp String])+processAnnotations t = \case+ Nothing -> (, []) $ treeToTextNoAnn t+ Just m2s -> second (lispifyHighlightingInfo_ m2s) $ treeToTextWithAnn t
@@ -0,0 +1,490 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.EmacsTop+ ( mimicGHCi+ , namedMetaOf+ , showInfoError+ , prettyGoals+ , prettyInfoError+ , explainWhyInScope+ , prettyResponseContext+ , prettyTypeOfMeta+ , prettyNormalForm+ , prettyInferredType+ ) where++import Prelude hiding (null)++import Control.Monad+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.State ( evalStateT )+import Control.Monad.Trans ( lift )++import Data.List qualified as List++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Abstract.Pretty (prettyATop)+import Agda.Syntax.Concrete as C++import Agda.TypeChecking.Errors ( explainWhyInScope, getAllWarningsOfTCErr, verbalize, prettyError )+import Agda.TypeChecking.Pretty qualified as TCP+import Agda.TypeChecking.Pretty (prettyTCM)+import Agda.TypeChecking.Pretty.Warning (prettyTCWarnings')+import Agda.TypeChecking.Monad++import Agda.Interaction.AgdaTop+import Agda.Interaction.Base+import Agda.Interaction.BasicOps as B+import Agda.Interaction.Response as R+import Agda.Interaction.Emacs.Lisp+import Agda.Interaction.EmacsCommand ( displayInfo, clearRunningInfo, displayRunningInfo, displayVerboseInfo)+import Agda.Interaction.Highlighting.Emacs+import Agda.Interaction.Highlighting.Precise (TokenBased(..))+import Agda.Interaction.Command (localStateCommandM)+import Agda.Interaction.Options ( DiagnosticsColours(..), optDiagnosticsColour )++import Agda.Utils.DocTree ( renderToTree )+import Agda.Utils.Function ( applyWhen )+import Agda.Utils.Functor ( (<.>) )+import Agda.Utils.Null+import Agda.Utils.Maybe+import Agda.Utils.String+import Agda.Utils.Time (CPUTime)++import Agda.VersionCommit++----------------------------------++-- | 'mimicGHCi' is a fake ghci interpreter for the Emacs frontend+-- and for interaction tests.+--+-- 'mimicGHCi' reads the Emacs frontend commands from stdin,+-- interprets them and print the result into stdout.+mimicGHCi :: TCM () -> TCM ()+mimicGHCi = repl (liftIO . putStrLn . prettyShow <=< lispifyResponse) "Agda2> "++-- | Convert Response to an elisp value for the interactive emacs frontend.++lispifyResponse :: Response -> TCM (Lisp String)+lispifyResponse = \case++ Resp_HighlightingInfo info remove method modFile file ->+ liftIO (lispifyHighlightingInfo info remove method modFile file)++ Resp_DisplayInfo info ->+ lispifyDisplayInfo info++ Resp_ClearHighlighting tokenBased ->+ return $ L $+ A "agda2-highlight-clear" :+ case tokenBased of+ TokenBased -> [ Q (lispifyTokenBased tokenBased) ]+ NotOnlyTokenBased -> []++ Resp_DoneAborting ->+ return $ L [ A "agda2-abort-done" ]++ Resp_DoneExiting ->+ return $ L [ A "agda2-exit-done" ]++ Resp_ClearRunningInfo ->+ return clearRunningInfo++ Resp_RunningInfo n docTree+ | n <= 1 -> displayRunningInfo docTree <$> wantBufferHighlighting+ | otherwise -> displayVerboseInfo docTree <$> wantBufferHighlighting++ Resp_Status s ->+ return $ L+ [ A "agda2-status-action"+ , A (quote $ List.intercalate "," $ catMaybes [checked, showImpl, showIrr])+ ]+ where+ checked = boolToMaybe (sChecked s) "Checked"+ showImpl = boolToMaybe (sShowImplicitArguments s) "ShowImplicit"+ showIrr = boolToMaybe (sShowIrrelevantArguments s) "ShowIrrelevant"++ Resp_JumpToError f p ->+ return $ lastTag 3 $ L+ [ A "agda2-maybe-goto"+ , Q $ L [ A (quote f), A ".", A (show p) ]+ ]++ Resp_InteractionPoints is ->+ return $ lastTag 1 $ L+ [ A "agda2-goals-action"+ , Q $ L $ map showNumIId is+ ]++ Resp_GiveAction ii s ->+ return $ L+ [ A "agda2-give-action"+ , showNumIId ii+ , A s'+ ]+ where+ s' = case s of+ Give_String str -> quote str+ Give_Paren -> "'paren"+ Give_NoParen -> "'no-paren"++ Resp_MakeCase ii variant pcs ->+ return $ lastTag 2 $ L+ [ A cmd+ , Q $ L $ map (A . quote) pcs+ ]+ where+ cmd = case variant of+ R.Function -> "agda2-make-case-action"+ R.ExtendedLambda -> "agda2-make-case-action-extendlam"++ Resp_SolveAll ps ->+ return $ lastTag 2 $ L+ [ A "agda2-solveAll-action"+ , Q $ L $ concatMap prn ps+ ]+ where+ prn (ii,e)= [showNumIId ii, A $ quote $ prettyShow e]++ Resp_Mimer ii msol ->+ return $ lastTag 1 $ L $ case msol of+ Nothing ->+ [ A "agda2-info-action"+ , A $ quote "*Mimer*"+ , A $ quote "No solution found"+ ]+ Just str ->+ [ A "agda2-solve-action"+ , showNumIId ii+ , A $ quote str+ ]++lispifyDisplayInfo :: DisplayInfo -> TCM (Lisp String)+lispifyDisplayInfo = \case++ Info_CompilationOk backend ws -> do+ warnings <- prettyTCWarnings' (tcWarnings ws)+ errors <- prettyTCWarnings' (nonFatalErrors ws)+ let+ msg = hcat+ [ "The module was successfully compiled with backend "+ , pretty backend+ , ".\n"+ ]+ -- abusing the goals field since we ignore the title+ (_title, body) = formatWarningsAndErrors msg warnings errors+ format "*Compilation result*" body++ Info_Constraints s -> do+ doc <- TCP.vcat $ map prettyTCM s+ format "*Constraints*" doc++ Info_AllGoalsWarnings ms ws -> do+ goals <- prettyGoals ms+ warnings <- prettyTCWarnings' (tcWarnings ws)+ errors <- prettyTCWarnings' (nonFatalErrors ws)+ let (title, body) = formatWarningsAndErrors goals warnings errors+ format ("*All" ++ title ++ "*") body++ Info_Auto s ->+ format "*Auto*" $ P.text s++ Info_Error err -> format' "*Error*" =<< prettyInfoError err++ Info_Time time ->+ format "*Time*" $ prettyTimed time++ Info_NormalForm state cmode time expr -> do+ exprDoc <- prettyNormalForm state cmode expr+ let doc = maybe empty prettyTimed time $$ exprDoc+ lbl | cmode == HeadCompute = "*Head Normal Form*"+ | otherwise = "*Normal Form*"+ format lbl doc++ Info_InferredType state time expr -> do+ exprDoc <- prettyInferredType state expr+ let doc = maybe empty prettyTimed time $$ exprDoc+ format "*Inferred Type*" doc++ Info_ModuleContents modules tel types -> do+ doc <- localTCState $ do+ typeDocs <- addContext tel $ forM types $ \ (x, t) -> do+ doc <- prettyTCM t+ return (prettyShow x, ":" <+> doc)+ return $ vcat+ [ "Modules"+ , nest 2 $ vcat $ map pretty modules+ , "Names"+ , nest 2 $ align 10 typeDocs+ ]+ format "*Module contents*" doc++ Info_SearchAbout hits names -> do+ hitDocs <- forM hits $ \ (x, t) -> do+ doc <- prettyTCM t+ return (prettyShow x, ":" <+> doc)+ let doc = "Definitions about" <+>+ text (List.intercalate ", " $ words names) $$ nest 2 (align 10 hitDocs)+ format "*Search About*" doc++ Info_WhyInScope why -> do+ doc <- explainWhyInScope why+ format "*Scope Info*" doc++ Info_Context ii ctx -> do+ doc <- localTCState (prettyResponseContext ii False ctx)+ format "*Context*" doc++ Info_Intro_NotFound ->+ format "*Intro*" "No introduction forms found."++ Info_Intro_ConstructorUnknown ss -> do+ let doc = sep [ "Don't know which constructor to introduce of"+ , let mkOr [] = []+ mkOr [x, y] = [text x <+> "or" <+> text y]+ mkOr (x:xs) = text x : mkOr xs+ in nest 2 $ fsep $ punctuate comma (mkOr ss)+ ]+ format "*Intro*" doc++ Info_Version ->+ format "*Agda Version*" ("Agda version" <+> text versionWithCommitInfo)++ Info_GoalSpecific ii kind ->+ lispifyGoalSpecificDisplayInfo ii kind++lispifyGoalSpecificDisplayInfo :: InteractionId -> GoalDisplayInfo -> TCM (Lisp String)+lispifyGoalSpecificDisplayInfo ii kind = localTCState $ withInteractionId ii $+ case kind of++ Goal_HelperFunction helperType -> do+ doc <- inTopContext $ prettyATop helperType+ return $ L+ [ A "agda2-info-action-and-copy"+ , A $ quote "*Helper function*"+ , A $ quote (render doc ++ "\n")+ , A "nil"+ ]++ Goal_NormalForm cmode expr -> do+ doc <- showComputed cmode expr+ format "*Normal Form*" doc++ Goal_GoalType norm aux ctx bndry constraints -> do+ ctxDoc <- prettyResponseContext ii True ctx+ goalDoc <- prettyTypeOfMeta norm ii+ let boundaryDoc hd bndry+ | null bndry = []+ | otherwise = [ text $ delimiter hd+ , vcat $ map pretty bndry+ ]+ auxDoc <- case aux of+ GoalOnly -> return empty+ GoalAndHave expr bndry -> do+ doc <- prettyATop expr+ return $ ("Have:" <+> doc) $$ vcat (boundaryDoc ("Boundary (actual)") bndry)+ GoalAndElaboration expr -> do+ doc <- prettyATop expr+ return $ "Elaborates to:" <+> doc+ let constraintsDoc+ | null constraints = []+ | otherwise =+ [ TCP.text $ delimiter "Constraints"+ , TCP.vcat $ map prettyTCM constraints+ ]+ doc <- TCP.vcat $ concat+ [ [ "Goal:" TCP.<+> return goalDoc+ , return (vcat (boundaryDoc "Boundary (wanted)" bndry))+ , return auxDoc+ ]+ , [ TCP.text (delimiter "Context") | not $ null ctxDoc ]+ , [ return ctxDoc ]+ , constraintsDoc+ ]+ format "*Goal type etc.*" doc++ Goal_CurrentGoal norm -> do+ doc <- prettyTypeOfMeta norm ii+ format "*Current Goal*" doc++ Goal_InferredType expr -> do+ doc <- prettyATop expr+ format "*Inferred Type*" doc++format :: String -> Doc -> TCM (Lisp String)+format header = format' header++-- | Format responses of 'DisplayInfo'.+format'+ :: String+ -- ^ String to use as a header.+ -> Doc+ -- ^ The document to print.+ -> TCM (Lisp String)+format' header content = displayInfo header (renderToTree content) False <$>+ wantBufferHighlighting++-- | Do we want highlighting in the Agda information buffer?+-- 'Nothing' with option @--color=never@.+wantBufferHighlighting :: TCM (Maybe ModuleToSource)+wantBufferHighlighting = do+ col <- commandLineOptions <&> optDiagnosticsColour <&> \case+ AutoColour -> True+ AlwaysColour -> True+ NeverColour -> False+ if col+ then Just <$> useSession lensModuleToSource+ else return Nothing++-- | Adds a \"last\" tag to a response.++lastTag :: Integer -> Lisp String -> Lisp String+lastTag n r = Cons (Cons (A "last") (A $ show n)) r++-- | Show an iteraction point identifier as an elisp expression.++showNumIId :: InteractionId -> Lisp String+showNumIId = A . show . interactionId++--------------------------------------------------------------------------------++-- | Given goals, warnings and errors, return a pair of the+-- title and the body for the info buffer.+formatWarningsAndErrors :: Doc -> [Doc] -> [Doc] -> (String, Doc)+formatWarningsAndErrors g ws es = (title, body)+ where+ isG = not $ null g+ isW = not $ null ws+ isE = not $ null es+ title = List.intercalate "," $ concat+ [ [ " Goals" | isG ]+ , [ " Errors" | isE ]+ , [ " Warnings" | isW ]+ , [ " Done" | not (isG || isW || isE) ]+ ]+ body = vcat $ concat+ [ [ g ]+ , [ text $ delimiter "Error" | isE && (isG || isW) ]+ , es+ , [ text $ delimiter "Warnings" | isW && (isG || isE) ]+ , ws+ ]++-- | Serializing 'Info_Error'.+showInfoError :: Info_Error -> TCM String+showInfoError = render <.> prettyInfoError++-- | Turn an 'Info_Error' into a 'Doc'.+prettyInfoError :: Info_Error -> TCM Doc+prettyInfoError = \case+ Info_GenericError err -> do+ e <- prettyError err+ ws <- prettyTCWarnings' =<< getAllWarningsOfTCErr err+ let (_title, body) = formatWarningsAndErrors empty ws [e]+ return body++ Info_CompilationError warnings -> do+ docs <- prettyTCWarnings' warnings+ return $ vcat $+ "You need to fix the following errors before you can compile the module:" :+ "" :+ docs++ Info_HighlightingParseError ii ->+ return $ "Highlighting failed to parse expression in" <+> pretty ii++ Info_HighlightingScopeCheckError ii ->+ return $ "Highlighting failed to scope check expression in" <+> pretty ii++-- | Pretty-prints the context of the given meta-variable.++prettyResponseContext+ :: InteractionId -- ^ Context of this meta-variable.+ -> Bool -- ^ Print the elements in reverse order?+ -> [ResponseContextEntry]+ -> TCM Doc+prettyResponseContext ii rev ctx = withInteractionId ii $ do+ mod <- currentModality+ align 10 . concat . applyWhen rev reverse <$> do+ forM ctx $ \ (ResponseContextEntry n x (Arg ai expr) letv nis) -> do+ let+ prettyCtxName :: String+ prettyCtxName+ | n == x = prettyShow x+ | isInScope n == InScope = prettyShow n ++ " = " ++ prettyShow x+ | otherwise = prettyShow x++ -- Some attributes are useful to report whenever they are not+ -- in the default state.+ attribute :: String+ attribute = c ++ if null c then "" else " "+ where c = prettyShow (getCohesion ai)++ pol :: ModalPolarity+ pol = modPolarityAnn $ getModalPolarity ai++ extras :: [Doc]+ extras = concat $+ [ [ "not in scope" | isInScope nis == C.NotInScope ]+ -- Print "erased" if hypothesis is erased but goal is non-erased.+ , [ "erased" | not $ getQuantity ai `moreQuantity` getQuantity mod ]+ -- Print relevance of hypothesis relative to relevance of the goal. (Issue #6706.)+ , [ text $ verbalize r+ | let r = getRelevance mod `inverseComposeRelevance` getRelevance ai+ , not $ isRelevant r ]+ , [ text $ verbalize pol | not $ pol == MixedPolarity ]+ -- Print "instance" if variable is considered by instance search.+ , [ "instance" | isInstance ai ]+ ]+ ty <- prettyATop expr+ maybeVal <- traverse prettyATop letv++ return $+ (attribute ++ prettyCtxName, ":" <+> ty <+> (parenSep extras)) :+ [ (prettyShow x, "=" <+> val) | val <- maybeToList maybeVal ]++ where+ parenSep :: [Doc] -> Doc+ parenSep docs+ | null docs = empty+ | otherwise = (" " <+>) $ parens $ fsep $ punctuate comma docs+++-- | Pretty-prints the type of the meta-variable.++prettyTypeOfMeta :: Rewrite -> InteractionId -> TCM Doc+prettyTypeOfMeta norm ii = do+ B.typeOfMeta norm ii >>= \case+ OfType _ e -> prettyATop e+ form -> prettyATop form++-- | Pretty-print the result of a compute command in the command state+-- captured when the command completed. Shared with the JSON frontend+-- ("Agda.Interaction.JSONTop") so that both frontends render the+-- expression identically.+prettyNormalForm :: CommandState -> ComputeMode -> A.Expr -> TCM Doc+prettyNormalForm state cmode expr = evalStateT prettyExpr state+ where+ prettyExpr = localStateCommandM+ $ lift+ $ B.atTopLevel+ $ (B.withComputeIgnoreAbstract cmode)+ $ (B.showComputed cmode)+ $ expr++-- | Pretty-print an inferred type in the command state captured when the+-- inference command completed. Shared with the JSON frontend.+prettyInferredType :: CommandState -> A.Expr -> TCM Doc+prettyInferredType state expr = evalStateT prettyExpr state+ where+ prettyExpr = localStateCommandM+ $ lift+ $ B.atTopLevel+ $ TCP.prettyA+ $ expr++-- | Prefix prettified CPUTime with "Time:"+prettyTimed :: CPUTime -> Doc+prettyTimed time = "Time:" <+> pretty time
@@ -1,22 +0,0 @@--{-| This module defines the exception handler.--}-module Agda.Interaction.Exceptions where--import Prelude hiding (catch)-import Control.Exception-import Control.Monad.Trans-import System.Exit--import Agda.Syntax.Position-import Agda.Syntax.Parser ( ParseError(..) )--handleParseException :: (ParseError -> IO a) -> ParseError -> IO a-handleParseException crash e = crash e---- | Note that 'failOnException' only catches 'ParseError's.--failOnException :: (Range -> String -> IO a) -> IO a -> IO a-failOnException h m = m `catch` handleParseException handler- where- handler x = h (getRange x) (show x)
@@ -0,0 +1,37 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.ExitCode (+ AgdaError(..),+ agdaErrorToInt,+ agdaErrorFromInt,+ exitSuccess,+ exitAgdaWith)+ where++import System.Exit (exitSuccess, exitWith, ExitCode(ExitFailure))++data AgdaError = UnknownError -- ^ 1+ | TCMError -- ^ 42+ | OptionError -- ^ 71+ | CommandError -- ^ 113+ | ImpossibleError -- ^ 120+ deriving (Show, Eq, Enum, Bounded)++agdaErrorToInt :: AgdaError -> Int+agdaErrorToInt UnknownError = 1+agdaErrorToInt TCMError = 42+agdaErrorToInt OptionError = 71+agdaErrorToInt CommandError = 113+agdaErrorToInt ImpossibleError = 120++-- ^ Return the error corresponding to an exit code from the+-- Agda process+agdaErrorFromInt :: Int -> Maybe AgdaError+agdaErrorFromInt = -- We implement this in a somewhat more inefficient+ -- way for the sake of consistency+ flip lookup [(agdaErrorToInt error, error)+ | error <- [minBound..maxBound]+ ]++exitAgdaWith :: AgdaError -> IO a+exitAgdaWith = exitWith . ExitFailure . agdaErrorToInt
@@ -7,67 +7,129 @@ ------------------------------------------------------------------------ module Agda.Interaction.FindFile- ( toIFile+ ( SourceFile(..), InterfaceFile(intFilePath)+ , toIFile, mkInterfaceFile , FindError(..), findErrorToTypeError- , findFile, findFile', findFile''- , findInterfaceFile+ , findFile, findFile', findFile'_, findFile''+ , findInterfaceFile', findInterfaceFile , checkModuleName- , moduleName', moduleName- , ModuleToSource- , SourceToModule, sourceToModule- , tests+ , rootNameModule+ , replaceModuleExtension+ , dropAgdaExtension, hasAgdaExtension, stripAgdaExtension ) where -import Control.Applicative+import Prelude hiding (null)+ import Control.Monad-import Control.Monad.State.Class+import Control.Monad.Except+import Control.Monad.State import Control.Monad.Trans-import Data.List-import Data.Map (Map)+import Data.Maybe (catMaybes, fromMaybe, isJust) import qualified Data.Map as Map+import qualified Data.Text as T import System.FilePath-import System.Directory +import Agda.Interaction.Library ( findProjectRoot )+ import Agda.Syntax.Concrete import Agda.Syntax.Parser+import Agda.Syntax.Position+import Agda.Syntax.TopLevelModuleName+ import Agda.TypeChecking.Monad.Base-import {-# SOURCE #-} Agda.TypeChecking.Monad.Options (getIncludeDirs)+import Agda.TypeChecking.Monad.Benchmark (billTo)+import qualified Agda.TypeChecking.Monad.Benchmark as Bench+import {-# SOURCE #-} Agda.TypeChecking.Monad.Options+ (getIncludeDirs, libToTCM)+import Agda.TypeChecking.Monad.State ( registerFileIdWithBuiltin, topLevelModuleName )+import Agda.TypeChecking.Monad.Trace (runPM, setCurrentRange)++import Agda.Version ( version )++import Agda.Utils.Applicative ( (?$>) )+import Agda.Utils.CallStack ( HasCallStack )+import Agda.Utils.FileId import Agda.Utils.FileName+import Agda.Utils.List ( stripSuffix, nubOn )+import Agda.Utils.List1 ( List1, pattern (:|) )+import Agda.Utils.List2 ( List2, pattern List2 )+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2+import Agda.Utils.Monad ( ifM, unlessM )+import Agda.Syntax.Common.Pretty ( Pretty(..), prettyShow )+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Utils.Singleton+import Agda.Utils.Lens +import Agda.Utils.Impossible++-- This instance isn't producing something pretty.+-- instance Pretty SourceFile where+-- pretty = pretty . srcFileId++-- | File must exist.+newtype InterfaceFile = InterfaceFile { intFilePath :: AbsolutePath }++instance Pretty InterfaceFile where+ pretty = pretty . intFilePath++-- | Makes an interface file from an AbsolutePath candidate.+-- If the file does not exist, then fail by returning @Nothing@.++mkInterfaceFile+ :: AbsolutePath -- ^ Path to the candidate interface file+ -> IO (Maybe InterfaceFile) -- ^ Interface file iff it exists+mkInterfaceFile fp = do+ ex <- doesFileExistCaseSensitive $ filePath fp+ pure (ex ?$> InterfaceFile fp)+ -- | Converts an Agda file name to the corresponding interface file--- name.+-- name. Note that we do not guarantee that the file exists. -toIFile :: AbsolutePath -> AbsolutePath-toIFile f = mkAbsolute (replaceExtension (filePath f) ".agdai")+toIFile :: HasCallStack => SourceFile -> TCM AbsolutePath+toIFile (SourceFile fi) = do+ src <- fileFromId fi -- partial function, thus HasCallStack+ let fp = filePath src+ let localIFile = replaceModuleExtension ".agdai" src+ mroot <- libToTCM $ findProjectRoot (takeDirectory fp)+ case mroot of+ Nothing -> pure localIFile+ Just root -> do+ let buildDir = root </> "_build" </> version </> "agda"+ fileName <- liftIO $ makeRelativeCanonical root (filePath localIFile)+ let separatedIFile = mkAbsolute $ buildDir </> fileName+ pure separatedIFile +replaceModuleExtension :: String -> AbsolutePath -> AbsolutePath+replaceModuleExtension ext@('.':_) = mkAbsolute . (++ ext) . dropAgdaExtension . filePath+replaceModuleExtension ext = replaceModuleExtension ('.':ext)+ -- | Errors which can arise when trying to find a source file. -- -- Invariant: All paths are absolute. data FindError- = NotFound [AbsolutePath]- -- ^ The file was not found. It should have had one of the given- -- file names.- | Ambiguous [AbsolutePath]- -- ^ Several matching files were found.- --- -- Invariant: The list of matching files has at least two- -- elements.+ = NotFound (List1 AbsolutePath)+ -- ^ An Agda module was not found.+ -- We were looking for it in one of the given include directories.+ | Ambiguous (List2 AbsolutePath)+ -- ^ Several matching files were found.+ deriving Show -- | Given the module name which the error applies to this function -- converts a 'FindError' to a 'TypeError'. findErrorToTypeError :: TopLevelModuleName -> FindError -> TypeError-findErrorToTypeError m (NotFound files) = FileNotFound m files-findErrorToTypeError m (Ambiguous files) =- AmbiguousTopLevelModuleName m files+findErrorToTypeError m = \case+ NotFound dirs -> FileNotFound m dirs+ Ambiguous files -> AmbiguousTopLevelModuleName m files -- | Finds the source file corresponding to a given top-level module -- name. The returned paths are absolute. -- -- Raises an error if the file cannot be found. -findFile :: TopLevelModuleName -> TCM AbsolutePath+findFile :: TopLevelModuleName -> TCM SourceFile findFile m = do mf <- findFile' m case mf of@@ -75,112 +137,134 @@ Right f -> return f -- | Tries to find the source file corresponding to a given top-level--- module name. The returned paths are absolute.--findFile' :: TopLevelModuleName -> TCM (Either FindError AbsolutePath)+-- module name. The returned paths are absolute.+--+-- SIDE EFFECT: Updates 'stModuleToSource'.+findFile' :: TopLevelModuleName -> TCM (Either FindError SourceFile) findFile' m = do- dirs <- getIncludeDirs- modFile <- stModuleToSource <$> get- (r, modFile) <- liftIO $ findFile'' dirs m modFile- modify $ \s -> s { stModuleToSource = modFile }- return r+ dirs <- getIncludeDirs+ stateSessionLensM lensModuleToSource \modToSrc -> do+ liftIO $ runStateT (findFile'' dirs m) modToSrc +-- | A variant of 'findFile'' which manipulates an extra 'ModuleToSourceId'++findFile'_ ::+ List1 AbsolutePath+ -- ^ Include paths.+ -> TopLevelModuleName+ -> StateT ModuleToSourceId TCM (Either FindError SourceFile)+findFile'_ incs m = stateSessionLensM lensFileDict \dict -> do+ m2s <- get+ (r, ModuleToSource dict' m2s') <- liftIO $+ runStateT (findFile'' incs m) $ ModuleToSource dict m2s+ put m2s'+ return (r, dict')+ -- | A variant of 'findFile'' which does not require 'TCM'. -findFile''- :: [AbsolutePath]- -- ^ Include paths.+findFile'' ::+ List1 AbsolutePath+ -- ^ Include paths. -> TopLevelModuleName- -> ModuleToSource- -- ^ Cached invocations of 'findFile'''. An updated copy is returned.- -> IO (Either FindError AbsolutePath, ModuleToSource)-findFile'' dirs m modFile =- case Map.lookup m modFile of- Just f -> return (Right f, modFile)+ -> StateT ModuleToSource IO (Either FindError SourceFile)+findFile'' dirs m = do+ ModuleToSource dict modToSrc <- get+ case Map.lookup m modToSrc of+ Just sf -> return $ Right sf Nothing -> do- files <- mapM absolute+ files <- liftIO $ fileList agdaFileExtensions+ existingFiles <- liftIO $ filterM (doesFileExistCaseSensitive . filePath) files+ case nubOn id existingFiles of+ [file] -> do+ let (i, dict') = registerFileIdWithBuiltin file dict+ let src = SourceFile i+ put $ ModuleToSource dict' $ Map.insert m src modToSrc+ return (Right src)+ [] -> do+ return (Left (NotFound dirs))+ f0:f1:fs -> return (Left (Ambiguous $ List2 f0 f1 fs))+ where+ fileList exts = mapM absolute [ filePath dir </> file- | dir <- dirs- , file <- map (moduleNameToFileName m)- [".agda", ".lagda"]+ | dir <- List1.toList dirs+ , file <- map (moduleNameToFileName m) exts ]- existingFiles <-- liftIO $ filterM (doesFileExist . filePath) files- return $ case nub existingFiles of- [] -> (Left (NotFound files), modFile)- [file] -> (Right file, Map.insert m file modFile)- files -> (Left (Ambiguous files), modFile) -- | Finds the interface file corresponding to a given top-level--- module name. The returned paths are absolute.+-- module file. The returned paths are absolute. --+-- Raises 'Nothing' if the interface file cannot be found.++findInterfaceFile' :: HasCallStack -- We are calling partial function toIFile, thus want a call stack.+ => SourceFile -- ^ Path to the source file+ -> TCM (Maybe InterfaceFile) -- ^ Maybe path to the interface file+findInterfaceFile' fp = liftIO . mkInterfaceFile =<< toIFile fp+++-- | Finds the interface file corresponding to a given top-level+-- module file. The returned paths are absolute.+-- -- Raises an error if the source file cannot be found, and returns -- 'Nothing' if the source file can be found but not the interface -- file. -findInterfaceFile :: TopLevelModuleName -> TCM (Maybe AbsolutePath)-findInterfaceFile m = do- f <- toIFile <$> findFile m- ex <- liftIO $ doesFileExist $ filePath f- return $ if ex then Just f else Nothing+findInterfaceFile :: HasCallStack -- because of calling a partial function+ => TopLevelModuleName -> TCM (Maybe InterfaceFile)+findInterfaceFile m = findInterfaceFile' =<< findFile m -- | Ensures that the module name matches the file name. The file -- corresponding to the module name (according to the include path) -- has to be the same as the given file name. -checkModuleName :: TopLevelModuleName- -- ^ The name of the module.- -> AbsolutePath- -- ^ The file from which it was loaded.- -> TCM ()-checkModuleName name file = do- moduleShouldBeIn <- findFile' name- case moduleShouldBeIn of- Left (NotFound files) -> typeError $- ModuleNameDoesntMatchFileName name files- Left (Ambiguous files) -> typeError $- AmbiguousTopLevelModuleName name files- Right file' ->- if file === file' then- return ()- else- typeError $ ModuleDefinedInOtherFile name file file'+checkModuleName ::+ TopLevelModuleName+ -- ^ The name of the module.+ -> SourceFile+ -- ^ The file from which it was loaded.+ -> Maybe TopLevelModuleName+ -- ^ The expected name, coming from an import statement.+ -> TCM ()+checkModuleName name src0 mexpected = do+ file <- srcFilePath src0+ findFile' name >>= \case --- | Computes the module name of the top-level module in the given--- file.+ Left (NotFound dirs) -> typeError $+ case mexpected of+ Nothing -> ModuleNameDoesntMatchFileName name dirs+ Just expected -> ModuleNameUnexpected (TopLevelModuleNameWithSourceFile name src0) expected -moduleName' :: AbsolutePath -> TCM TopLevelModuleName-moduleName' file = liftIO $ do- topLevelModuleName <$> parseFile' moduleParser file+ Left (Ambiguous files) -> typeError $+ AmbiguousTopLevelModuleName name files --- | A variant of 'moduleName'' which raises an error if the file name--- does not match the module name.------ The file name is interpreted relative to the current working--- directory (unless it is absolute).+ Right src -> do+ file' <- srcFilePath src+ file <- liftIO $ absolute $ filePath file+ unlessM (liftIO $ sameFile file file') $+ typeError $ ModuleDefinedInOtherFile name file file' -moduleName :: AbsolutePath -> TCM TopLevelModuleName-moduleName file = do- m <- moduleName' file- checkModuleName m file- return m+ -- Andreas, 2020-09-28, issue #4671: In any case, make sure+ -- that we do not end up with a mismatch between expected+ -- and actual module name. --- | Maps top-level module names to the corresponding source file--- names.+ forM_ mexpected \ expected ->+ unless (name == expected) $+ typeError $ OverlappingProjects file name expected+ -- OverlappingProjects is the correct error for+ -- test/Fail/customized/NestedProjectRoots+ -- -- typeError $ ModuleNameUnexpected name expected -type ModuleToSource = Map TopLevelModuleName AbsolutePath+-- | Remove an Agda file extension from a filepath, if possible.+stripAgdaExtension :: FilePath -> Maybe FilePath+stripAgdaExtension = stripAnyOfExtensions agdaFileExtensions --- | Maps source file names to the corresponding top-level module--- names.+-- | Check if a file path has an Agda extension.+hasAgdaExtension :: FilePath -> Bool+hasAgdaExtension = isJust . stripAgdaExtension -type SourceToModule = Map AbsolutePath TopLevelModuleName+-- | Remove an existing Agda file extension from a file path.+dropAgdaExtension :: FilePath -> FilePath+dropAgdaExtension = fromMaybe __IMPOSSIBLE__ . stripAgdaExtension --- | Creates a 'SourceToModule' map based on 'stModuleToSource'. -sourceToModule :: TCM SourceToModule-sourceToModule =- Map.fromList- . map (\(m, f) -> (f, m))- . Map.toList- . stModuleToSource- <$> get+rootNameModule :: AbsolutePath -> String+rootNameModule = dropAgdaExtension . snd . splitFileName . filePath
@@ -1,7 +0,0 @@-module Agda.Interaction.FindFile where--import Data.Map (Map)-import Agda.Syntax.Concrete.Name (TopLevelModuleName)-import Agda.Utils.FileName (AbsolutePath)--type ModuleToSource = Map TopLevelModuleName AbsolutePath
@@ -1,1083 +0,0 @@-{-# LANGUAGE CPP, TypeSynonymInstances, FlexibleInstances #-}-{-# OPTIONS -fno-cse #-}--module Agda.Interaction.GhciTop- ( module Agda.Interaction.GhciTop- , module Agda.TypeChecker- , module Agda.TypeChecking.MetaVars- , module Agda.TypeChecking.Reduce- , module Agda.TypeChecking.Errors-- , module Agda.Syntax.Position- , module Agda.Syntax.Parser--- , module SC -- trivial clash removal: remove all!--- , module SA--- , module SI- , module Agda.Syntax.Scope.Base- , module Agda.Syntax.Scope.Monad- , module Agda.Syntax.Translation.ConcreteToAbstract- , module Agda.Syntax.Translation.AbstractToConcrete- , module Agda.Syntax.Translation.InternalToAbstract- , module Agda.Syntax.Abstract.Name-- , module Agda.Interaction.Exceptions-- , mkAbsolute- )- where--import System.Directory-import qualified System.IO as IO-import System.IO.Unsafe-import Data.Char-import Data.Maybe-import Data.IORef-import Data.Function-import Control.Applicative--import Agda.Utils.Fresh-import Agda.Utils.Monad-import Agda.Utils.Pretty as P-import Agda.Utils.String-import Agda.Utils.FileName-import qualified Agda.Utils.Trie as Trie-import Agda.Utils.Tuple-import qualified Agda.Utils.IO.UTF8 as UTF8--import Control.Monad.Error-import Control.Monad.Reader-import Control.Monad.State hiding (State)-import Control.Exception-import Data.List as List-import qualified Data.Map as Map-import System.Exit-import qualified System.Mem as System-import System.Time-import Text.PrettyPrint--import Agda.TypeChecker-import Agda.TypeChecking.Monad as TM- hiding (initState, setCommandLineOptions)-import qualified Agda.TypeChecking.Monad as TM-import Agda.TypeChecking.MetaVars-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Errors--import Agda.Syntax.Fixity-import Agda.Syntax.Position-import Agda.Syntax.Parser-import qualified Agda.Syntax.Parser.Tokens as T-import Agda.Syntax.Concrete as SC-import Agda.Syntax.Common as SCo-import Agda.Syntax.Concrete.Name as CN-import Agda.Syntax.Concrete.Pretty ()-import Agda.Syntax.Abstract as SA-import Agda.Syntax.Abstract.Pretty-import Agda.Syntax.Internal as SI-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad hiding (bindName, withCurrentModule)-import qualified Agda.Syntax.Info as Info-import Agda.Syntax.Translation.ConcreteToAbstract-import Agda.Syntax.Translation.AbstractToConcrete hiding (withScope)-import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Abstract.Name--import Agda.Interaction.EmacsCommand-import Agda.Interaction.Exceptions-import Agda.Interaction.FindFile-import Agda.Interaction.Options-import Agda.Interaction.MakeCase-import qualified Agda.Interaction.BasicOps as B-import Agda.Interaction.Highlighting.Emacs-import Agda.Interaction.Highlighting.Generate-import qualified Agda.Interaction.Imports as Imp--import Agda.Termination.TermCheck--import qualified Agda.Compiler.Epic.Compiler as Epic-import qualified Agda.Compiler.MAlonzo.Compiler as MAlonzo-import qualified Agda.Compiler.JS.Compiler as JS--import qualified Agda.Auto.Auto as Auto--#include "../undefined.h"-import Agda.Utils.Impossible--data State = State- { theTCState :: TCState- , theInteractionPoints :: [InteractionId]- -- ^ The interaction points of the buffer, in the order in which- -- they appear in the buffer. The interaction points are- -- recorded in 'theTCState', but when new interaction points are- -- added by give or refine Agda does not ensure that the ranges- -- of later interaction points are updated.- , theCurrentFile :: Maybe (AbsolutePath, ClockTime)- -- ^ The file which the state applies to. Only stored if the- -- module was successfully type checked (potentially with- -- warnings). The 'ClockTime' is the modification time stamp of- -- the file when it was last loaded.- }--initState :: State-initState = State- { theTCState = TM.initState- , theInteractionPoints = []- , theCurrentFile = Nothing- }--{-# NOINLINE theState #-}-theState :: IORef State-theState = unsafePerformIO $ newIORef initState---- | Can the command run even if the relevant file has not been loaded--- into the state?--data Independence- = Independent (Maybe [FilePath])- -- ^ Yes. If the argument is @'Just' is@, then @is@ is used as the- -- command's include directories.- | Dependent- -- No.---- | An interactive computation.--data Interaction = Interaction- { independence :: Independence- -- ^ Is the command independent?- , command :: TCM (Maybe ModuleName)- -- ^ If a module name is returned, then syntax highlighting- -- information will be written for the given module (by 'ioTCM').- }---- ^ Is the command independent?--isIndependent :: Interaction -> Bool-isIndependent i = case independence i of- Independent {} -> True- Dependent {} -> False---- | Run a TCM computation in the current state. Should only--- be used for debugging.-ioTCM_ :: TCM a -> IO a-ioTCM_ m = do- tcs <- readIORef theState- result <- runTCM $ do- put $ theTCState tcs- x <- withEnv initEnv m- s <- get- return (x, s)- case result of- Right (x, s) -> do- writeIORef theState $ tcs { theTCState = s }- return x- Left err -> do- Right doc <- runTCM $ prettyTCM err- putStrLn $ render doc- return __IMPOSSIBLE__-{-- Right (x, s) <- runTCM $ do- put $ theTCState tcs- x <- withEnv initEnv m- s <- get- return (x, s)- writeIORef theState $ tcs { theTCState = s }- return x--}---- | Runs a 'TCM' computation. All calls from the Emacs mode should be--- wrapped in this function.--ioTCM :: FilePath- -- ^ The current file. If this file does not match- -- 'theCurrentFile', and the 'Interaction' is not- -- \"independent\", then an error is raised.- -> Maybe FilePath- -- ^ Syntax highlighting information will be written to this- -- file, if any.- -> Interaction- -> IO ()-ioTCM current highlightingFile cmd = infoOnException $ do-#if MIN_VERSION_base(4,2,0)- -- Ensure that UTF-8 is used for communication with the Emacs mode.- IO.hSetEncoding IO.stdout IO.utf8-#endif-- current <- absolute current-- -- Read the state.- State { theTCState = st } <- readIORef theState-- -- Run the computation.- r <- runTCM $ catchError (do- put st- x <- withEnv initEnv $ do- case independence cmd of- Dependent -> ensureFileLoaded current- Independent Nothing ->- -- Make sure that the include directories have- -- been set.- setCommandLineOptions =<< commandLineOptions- Independent (Just is) -> do- ex <- liftIO $ doesFileExist $ filePath current- setIncludeDirs is $- if ex then ProjectRoot current else CurrentDir- command cmd- st <- get- return (Right (x, st))- ) (\e -> do- pers <- stPersistent <$> get- s <- prettyError e- return (Left (pers, s, e))- )-- -- Upon success: update the state. Upon failure: update the- -- persistent state, and, for independent commands, the current- -- file.- case r of- Right (Right (m, st')) ->- modifyIORef theState $ \s ->- s { theTCState = st'- }- Right (Left (pers, _, _)) -> do- modifyIORef theState $ \s ->- s { theTCState = (theTCState s) { stPersistent = pers }- }- Left _ -> return ()- when (isIndependent cmd) $- case r of- Right (Right _) -> return ()- _ ->- modifyIORef theState $ \s ->- s { theCurrentFile = Nothing- }-- -- Write out syntax highlighting info.- case highlightingFile of- Nothing -> return ()- Just f -> do- let errHi e s = errHighlighting e- `mplus`- ((\h -> (h, Map.empty)) <$>- generateErrorInfo (getRange e) s)- UTF8.writeFile f $- showHighlightingInfo $- case r of- Right (Right (mm, st')) -> do- m <- mm- mi <- Map.lookup (SA.toTopLevelModuleName m)- (stVisitedModules st')- return ( iHighlighting $ miInterface mi- , stModuleToSource st'- )- Right (Left (_ , s, e)) -> errHi e (Just s)- Left e -> errHi e Nothing-- -- If an error was encountered, display an error message and exit- -- with an error code; otherwise, inform Emacs about the buffer's- -- goals (if current matches the new current file).- let errStatus = Status { sChecked = False- , sShowImplicitArguments =- optShowImplicit $ stPragmaOptions st- }- case r of- Right (Left (_, s, e)) -> displayErrorAndExit errStatus (getRange e) s- Left e -> displayErrorAndExit errStatus (getRange e) $- tcErrString e- Right (Right _) -> do- f <- theCurrentFile <$> readIORef theState- case f of- Just (f, _) | f === current -> do- is <- theInteractionPoints <$> liftIO (readIORef theState)- liftIO $ putResponse $- L [A "agda2-goals-action", Q $ L $ List.map showNumIId is]- _ -> return ()---- | @cmd_load m includes@ loads the module in file @m@, using--- @includes@ as the include directories.--cmd_load :: FilePath -> [FilePath] -> Interaction-cmd_load m includes =- cmd_load' m includes True (\_ -> command cmd_metas >> return ())---- | @cmd_load' m includes cmd cmd2@ loads the module in file @m@,--- using @includes@ as the include directories.------ If type checking completes without any exceptions having been--- encountered then the command @cmd r@ is executed, where @r@ is the--- result of 'Imp.typeCheck'.--cmd_load' :: FilePath -> [FilePath]- -> Bool -- ^ Allow unsolved meta-variables?- -> ((Interface, Maybe Imp.Warnings) -> TCM ())- -> Interaction-cmd_load' file includes unsolvedOK cmd =- Interaction (Independent (Just includes)) $ do- -- Forget the previous "current file" and interaction points.- liftIO $ modifyIORef theState $ \s ->- s { theInteractionPoints = []- , theCurrentFile = Nothing- }-- f <- liftIO $ absolute file- t <- liftIO $ getModificationTime file-- -- All options (except for the verbosity setting) are reset when a- -- file is reloaded, including the choice of whether or not to- -- display implicit arguments. (At this point the include- -- directories have already been set, so they are preserved.)- opts <- commandLineOptions- setCommandLineOptions $- defaultOptions { optIncludeDirs = optIncludeDirs opts- , optPragmaOptions =- (optPragmaOptions defaultOptions)- { optAllowUnsolved = unsolvedOK- , optVerbose = optVerbose (optPragmaOptions opts)- }- }-- -- Reset the state, preserving options and decoded modules. Note- -- that if the include directories have changed, then the decoded- -- modules are reset when cmd_load' is run by ioTCM.- resetState-- ok <- Imp.typeCheck f-- -- The module type checked. If the file was not changed while the- -- type checker was running then the interaction points and the- -- "current file" are stored.- t' <- liftIO $ getModificationTime file- when (t == t') $ do- is <- sortInteractionPoints =<< getInteractionPoints- liftIO $ modifyIORef theState $ \s ->- s { theInteractionPoints = is- , theCurrentFile = Just (f, t)- }-- cmd ok-- liftIO System.performGC-- return $ Just $ iModuleName (fst ok)---- | Available backends.--data Backend = MAlonzo | Epic | JS---- | @cmd_compile b m includes@ compiles the module in file @m@ using--- the backend @b@, using @includes@ as the include directories.--cmd_compile :: Backend -> FilePath -> [FilePath] -> Interaction-cmd_compile b file includes =- cmd_load' file includes False (\(i, mw) ->- case mw of- Nothing -> do- case b of- MAlonzo -> MAlonzo.compilerMain i- Epic -> Epic.compilerMain i- JS -> JS.compilerMain i- display_info "*Compilation result*"- "The module was successfully compiled."- Just w ->- display_info errorTitle $ unlines- [ "You can only compile modules without unsolved metavariables"- , "or termination checking problems."- ])--cmd_constraints :: Interaction-cmd_constraints = Interaction Dependent $ do- cs <- map show <$> B.getConstraints- display_info "*Constraints*" (unlines cs)- return Nothing---- Show unsolved metas. If there are no unsolved metas but unsolved constraints--- show those instead.-cmd_metas :: Interaction-cmd_metas = Interaction Dependent $ do -- CL.showMetas []- ims <- B.typesOfVisibleMetas B.AsIs- -- Show unsolved implicit arguments normalised.- hms <- B.typesOfHiddenMetas B.Normalised- if not $ null ims && null hms- then do- di <- mapM (\i -> B.withInteractionId (B.outputFormId $ B.OutputForm 0 i) (showATop i)) ims- dh <- mapM showA' hms- display_info "*All Goals*" $ unlines $ di ++ dh- return Nothing- else do- cs <- B.getConstraints- if null cs- then display_info "*All Goals*" "" >> return Nothing- else command cmd_constraints- where- metaId (B.OfType i _) = i- metaId (B.JustType i) = i- metaId (B.JustSort i) = i- metaId (B.Assign i e) = i- metaId _ = __IMPOSSIBLE__- showA' m = do- r <- getMetaRange (metaId m)- d <- B.withMetaId (B.outputFormId $ B.OutputForm 0 m) (showATop m)- return $ d ++ " [ at " ++ show r ++ " ]"---- | If the range is 'noRange', then the string comes from the--- minibuffer rather than the goal.--type GoalCommand = InteractionId -> Range -> String -> Interaction--cmd_give :: GoalCommand-cmd_give = give_gen B.give $ \rng s ce ->- case ce of- ce | rng == noRange -> quote (show ce)- SC.Paren _ _ -> "'paren"- _ -> "'no-paren"--cmd_refine :: GoalCommand-cmd_refine = give_gen B.refine $ \_ s -> quote . show--give_gen give_ref mk_newtxt ii rng s = Interaction Dependent $- give_gen' give_ref mk_newtxt ii rng s--give_gen' give_ref mk_newtxt ii rng s = do- scope <- getInteractionScope ii- (ae, iis) <- give_ref ii Nothing =<< B.parseExprIn ii rng s- let newtxt = A . mk_newtxt rng s $ abstractToConcrete (makeEnv scope) ae- iis <- sortInteractionPoints iis- liftIO $ modifyIORef theState $ \s ->- s { theInteractionPoints =- replace ii iis (theInteractionPoints s) }- liftIO $ putResponse $ L [A "agda2-give-action", showNumIId ii, newtxt]- command cmd_metas- return Nothing- where- -- Substitutes xs for x in ys.- replace x xs ys = concatMap (\y -> if y == x then xs else [y]) ys--cmd_intro :: GoalCommand-cmd_intro ii rng _ = Interaction Dependent $ do- ss <- B.introTactic ii- B.withInteractionId ii $ case ss of- [] -> do- display_infoD "*Intro*" $ text "No introduction forms found."- return Nothing- [s] -> command $ cmd_refine ii rng s- _:_:_ -> do- display_infoD "*Intro*" $- sep [ text "Don't know which constructor to introduce of"- , let mkOr [] = []- mkOr [x, y] = [text x <+> text "or" <+> text y]- mkOr (x:xs) = text x : mkOr xs- in nest 2 $ fsep $ punctuate comma (mkOr ss)- ]- return Nothing--cmd_refine_or_intro :: GoalCommand-cmd_refine_or_intro ii rng s =- (if null s then cmd_intro else cmd_refine) ii rng s--cmd_auto :: GoalCommand-cmd_auto ii rng s = Interaction Dependent $ do- (res, msg) <- Auto.auto ii rng s- case res of- Left xs -> do- mapM_ (\(ii, s) -> do- liftIO $ modifyIORef theState $ \s ->- s { theInteractionPoints = filter (/= ii) (theInteractionPoints s) }- liftIO $ putResponse $ L [A "agda2-give-action", showNumIId ii, A $ quote s]- ) xs- case msg of- Nothing -> command cmd_metas >> return ()- Just msg -> display_info "*Auto*" msg- return Nothing- Right (Left cs) -> do- case msg of- Nothing -> return ()- Just msg -> display_info "*Auto*" msg- liftIO $ putResponse $- Cons (A "last")- (L [ A "agda2-make-case-action",- Q $ L $ List.map (A . quote) cs- ])- return Nothing- Right (Right s) -> give_gen' B.refine (\_ s -> quote . show) ii rng s---- | Sorts interaction points based on their ranges.--sortInteractionPoints :: [InteractionId] -> TCM [InteractionId]-sortInteractionPoints is =- map fst . sortBy (compare `on` snd) <$>- mapM (\i -> (,) i <$> getInteractionRange i) is---- | Pretty-prints the type of the meta-variable.--prettyTypeOfMeta :: B.Rewrite -> InteractionId -> TCM Doc-prettyTypeOfMeta norm ii = do- form <- B.typeOfMeta norm ii- case form of- B.OfType _ e -> prettyATop e- _ -> text <$> showATop form---- | Pretty-prints the context of the given meta-variable.--prettyContext- :: B.Rewrite -- ^ Normalise?- -> Bool -- ^ Print the elements in reverse order?- -> InteractionId- -> TCM Doc-prettyContext norm rev ii = B.withInteractionId ii $ do- ctx <- B.contextOfMeta ii norm- es <- mapM (prettyATop . B.ofExpr) ctx- ns <- mapM (showATop . B.ofName) ctx- let shuffle = if rev then reverse else id- return $ align 10 $ filter (not . null. fst) $ shuffle $ zip ns (map (text ":" <+>) es)--cmd_context :: B.Rewrite -> GoalCommand-cmd_context norm ii _ _ = Interaction Dependent $ do- display_infoD "*Context*" =<< prettyContext norm False ii- return Nothing--cmd_infer :: B.Rewrite -> GoalCommand-cmd_infer norm ii rng s = Interaction Dependent $ do- display_infoD "*Inferred Type*"- =<< B.withInteractionId ii- (prettyATop =<< B.typeInMeta ii norm =<< B.parseExprIn ii rng s)- return Nothing--cmd_goal_type :: B.Rewrite -> GoalCommand-cmd_goal_type norm ii _ _ = Interaction Dependent $ do- s <- B.withInteractionId ii $ prettyTypeOfMeta norm ii- display_infoD "*Current Goal*" s- return Nothing---- | Displays the current goal, the given document, and the current--- context.--cmd_goal_type_context_and doc norm ii _ _ = do- goal <- B.withInteractionId ii $ prettyTypeOfMeta norm ii- ctx <- prettyContext norm True ii- display_infoD "*Goal type etc.*"- (text "Goal:" <+> goal $+$- doc $+$- text (replicate 60 '\x2014') $+$- ctx)- return Nothing---- | Displays the current goal and context.--cmd_goal_type_context :: B.Rewrite -> GoalCommand-cmd_goal_type_context norm ii rng s = Interaction Dependent $- cmd_goal_type_context_and P.empty norm ii rng s---- | Displays the current goal and context /and/ infers the type of an--- expression.--cmd_goal_type_context_infer :: B.Rewrite -> GoalCommand-cmd_goal_type_context_infer norm ii rng s =- Interaction Dependent $ do- typ <- B.withInteractionId ii $- prettyATop =<< B.typeInMeta ii norm =<< B.parseExprIn ii rng s- cmd_goal_type_context_and (text "Have:" <+> typ) norm ii rng s---- | Shows all the top-level names in the given module, along with--- their types.--showModuleContents :: Range -> String -> TCM ()-showModuleContents rng s = do- (modules, types) <- B.moduleContents rng s- types' <- mapM (\(x, t) -> do- t <- prettyTCM t- return (show x, text ":" <+> t))- types- display_infoD "*Module contents*" $- text "Modules" $$- nest 2 (vcat $ map (text . show) modules) $$- text "Names" $$- nest 2 (align 10 types')---- | Shows all the top-level names in the given module, along with--- their types. Uses the scope of the given goal.--cmd_show_module_contents :: GoalCommand-cmd_show_module_contents ii rng s = Interaction Dependent $ do- B.withInteractionId ii $ showModuleContents rng s- return Nothing---- | Shows all the top-level names in the given module, along with--- their types. Uses the top-level scope.--cmd_show_module_contents_toplevel :: String -> Interaction-cmd_show_module_contents_toplevel s = Interaction Dependent $ do- B.atTopLevel $ showModuleContents noRange s- return Nothing---- | Sets the command line options and updates the status information.--setCommandLineOptions :: CommandLineOptions -> TCM ()-setCommandLineOptions opts = do- TM.setCommandLineOptions opts- liftIO . displayStatus =<< status---- | Status information.--data Status = Status- { sShowImplicitArguments :: Bool- -- ^ Are implicit arguments displayed?- , sChecked :: Bool- -- ^ Has the module been successfully type checked?- }---- | Computes some status information.--status :: TCM Status-status = do- showImpl <- showImplicitArguments-- -- Check if the file was successfully type checked, and has not- -- changed since. Note: This code does not check if any dependencies- -- have changed, and uses a time stamp to check for changes.- cur <- theCurrentFile <$> liftIO (readIORef theState)- checked <- case cur of- Nothing -> return False- Just (f, t) -> do- t' <- liftIO $ getModificationTime $ filePath f- case t == t' of- False -> return False- True ->- not . miWarnings . maybe __IMPOSSIBLE__ id <$>- (getVisitedModule =<<- maybe __IMPOSSIBLE__ id .- Map.lookup f <$> sourceToModule)-- return $ Status { sShowImplicitArguments = showImpl- , sChecked = checked- }---- | Shows status information.--showStatus :: Status -> String-showStatus s = intercalate "," $ catMaybes [checked, showImpl]- where- boolToMaybe b x = if b then Just x else Nothing-- checked = boolToMaybe (sChecked s) "Checked"- showImpl = boolToMaybe (sShowImplicitArguments s) "ShowImplicit"---- | Displays\/updates status information.--displayStatus :: Status -> IO ()-displayStatus s =- putResponse $ L [A "agda2-status-action", A (quote $ showStatus s)]---- | @display_info' header content@ displays @content@ (with header--- @header@) in some suitable way.--display_info' :: String -> String -> IO ()-display_info' bufname content =- putResponse $- L [ A "agda2-info-action"- , A (quote bufname)- , A (quote content)- ]---- | @display_info@ does what 'display_info'' does, but additionally--- displays some status information (see 'status' and--- 'displayStatus').--display_info :: String -> String -> TCM ()-display_info bufname content = do- liftIO . displayStatus =<< status- liftIO $ display_info' bufname content---- | Like 'display_info', but takes a 'Doc' instead of a 'String'.--display_infoD :: String -> Doc -> TCM ()-display_infoD bufname content = display_info bufname (render content)--showNumIId = A . tail . show--takenNameStr :: TCM [String]-takenNameStr = do- xss <- sequence [ List.map (fst . unArg) <$> getContext- , Map.keys <$> asks envLetBindings- , List.map qnameName . Map.keys . sigDefinitions <$> getSignature- ]- return $ concat [ parts $ nameConcrete x | x <- concat xss]- where- parts x = [ s | Id s <- nameParts x ]--refreshStr :: [String] -> String -> ([String], String)-refreshStr taken s = go nameModifiers where- go (m:mods) = let s' = s ++ m in- if s' `elem` taken then go mods else (s':taken, s')- go _ = __IMPOSSIBLE__--nameModifiers = "" : "'" : "''" : [show i | i <-[3..]]--cmd_make_case :: GoalCommand-cmd_make_case ii rng s = Interaction Dependent $ do- (casectxt , cs) <- makeCase ii rng s- B.withInteractionId ii $ do- hidden <- showImplicitArguments- pcs <- mapM prettyA $ List.map (extlam_dropLLifted casectxt hidden) cs- liftIO $ putResponse $- Cons (A "last")- (L [ A (emacscmd casectxt)- , Q $ L $ List.map (A . quote . (extlam_dropName casectxt) . render) pcs- ])- return Nothing- where- render = renderStyle (style { mode = OneLineMode })- emacscmd :: CaseContext -> String- emacscmd FunctionDef = "agda2-make-case-action"- emacscmd (ExtendedLambda _ _) = "agda2-make-case-action-extendlam"-- -- Drops pattern added to extended lambda functions when lambda lifting them- extlam_dropLLifted :: CaseContext -> Bool -> SA.Clause -> SA.Clause- extlam_dropLLifted FunctionDef _ x = x- extlam_dropLLifted (ExtendedLambda h nh) hidden (SA.Clause (SA.LHS info name nps ps) rhs decl)- = let n = if hidden then h else nh- in- (SA.Clause (SA.LHS info name (drop n nps) ps) rhs decl)-- -- very dirty hack, string manipulation by dropping the function name- -- and replacing " = " with " -> "- extlam_dropName :: CaseContext -> String -> String- extlam_dropName FunctionDef x = x- extlam_dropName (ExtendedLambda _ _) x = unwords $ map (\ y -> if y == "=" then "→" else y) $ drop 1 $ words x--cmd_solveAll :: Interaction-cmd_solveAll = Interaction Dependent $ do- out <- getInsts- liftIO $ putResponse $- Cons (A "last")- (L [ A "agda2-solveAll-action"- , Q . L $ concatMap prn out- ])- return Nothing- where- getInsts = mapM lowr =<< B.getSolvedInteractionPoints- where- lowr (i, m, e) = do- mi <- getMetaInfo <$> lookupMeta m- e <- withMetaInfo mi $ lowerMeta <$> abstractToConcreteCtx TopCtx e- return (i, e)- prn (ii,e)= [showNumIId ii, A $ quote $ show e]--class LowerMeta a where lowerMeta :: a -> a-instance LowerMeta SC.Expr where- lowerMeta = go where- go e = case e of- Ident _ -> e- SC.Lit _ -> e- SC.QuestionMark _ _ -> preMeta- SC.Underscore _ _ -> preUscore- SC.App r e1 ae2 -> case appView e of- SC.AppView (SC.QuestionMark _ _) _ -> preMeta- SC.AppView (SC.Underscore _ _) _ -> preUscore- _ -> SC.App r (go e1) (lowerMeta ae2)- SC.WithApp r e es -> SC.WithApp r (lowerMeta e) (lowerMeta es)- SC.Lam r bs e1 -> SC.Lam r (lowerMeta bs) (go e1)- SC.AbsurdLam r h -> SC.AbsurdLam r h- SC.ExtendedLam r cs -> SC.ExtendedLam r cs- SC.Fun r ae1 e2 -> SC.Fun r (lowerMeta ae1) (go e2)- SC.Pi tb e1 -> SC.Pi (lowerMeta tb) (go e1)- SC.Set _ -> e- SC.Prop _ -> e- SC.SetN _ _ -> e- SC.ETel tel -> SC.ETel (lowerMeta tel)- SC.Let r ds e1 -> SC.Let r (lowerMeta ds) (go e1)- Paren r e1 -> case go e1 of- q@(SC.QuestionMark _ Nothing) -> q- e2 -> Paren r e2- Absurd _ -> e- As r n e1 -> As r n (go e1)- SC.Dot r e -> SC.Dot r (go e)- SC.RawApp r es -> SC.RawApp r (lowerMeta es)- SC.OpApp r x es -> SC.OpApp r x (lowerMeta es)- SC.Rec r fs -> SC.Rec r (List.map (id -*- lowerMeta) fs)- SC.RecUpdate r e fs -> SC.RecUpdate r (lowerMeta e) (List.map (id -*- lowerMeta) fs)- SC.HiddenArg r e -> SC.HiddenArg r (lowerMeta e)- SC.InstanceArg r e -> SC.InstanceArg r (lowerMeta e)- SC.QuoteGoal r x e -> SC.QuoteGoal r x (lowerMeta e)- e@SC.Quote{} -> e- e@SC.QuoteTerm{} -> e- e@SC.Unquote{} -> e- SC.DontCare e -> SC.DontCare (lowerMeta e)--instance LowerMeta (OpApp SC.Expr) where- lowerMeta (Ordinary e) = Ordinary $ lowerMeta e- lowerMeta (SyntaxBindingLambda r bs e) = SyntaxBindingLambda r (lowerMeta bs) (lowerMeta e)---instance LowerMeta SC.LamBinding where- lowerMeta b@(SC.DomainFree _ _ _) = b- lowerMeta (SC.DomainFull tb) = SC.DomainFull (lowerMeta tb)--instance LowerMeta SC.TypedBindings where- lowerMeta (SC.TypedBindings r bs) = SC.TypedBindings r (lowerMeta bs)--instance LowerMeta SC.TypedBinding where- lowerMeta (SC.TBind r ns e) = SC.TBind r ns (lowerMeta e)- lowerMeta (SC.TNoBind e) = SC.TNoBind (lowerMeta e)--instance LowerMeta SC.RHS where- lowerMeta (SC.RHS e) = SC.RHS (lowerMeta e)- lowerMeta SC.AbsurdRHS = SC.AbsurdRHS--instance LowerMeta (Maybe SC.Expr) where- lowerMeta (Just e) = Just (lowerMeta e)- lowerMeta Nothing = Nothing--instance LowerMeta SC.Declaration where- lowerMeta = go where- go d = case d of- TypeSig rel n e1 -> TypeSig rel n (lowerMeta e1)- SC.Field n e1 -> SC.Field n (lowerMeta e1)- FunClause lhs rhs whcl -> FunClause lhs (lowerMeta rhs) (lowerMeta whcl)- SC.DataSig r ind n tel e1 -> SC.DataSig r ind n- (lowerMeta tel) (lowerMeta e1)- Data r ind n tel e1 cs -> Data r ind n- (lowerMeta tel) (lowerMeta e1) (lowerMeta cs)- SC.RecordSig r n tel e1 -> SC.RecordSig r n- (lowerMeta tel) (lowerMeta e1)- SC.Record r n c tel e1 cs -> SC.Record r n c- (lowerMeta tel) (lowerMeta e1) (lowerMeta cs)- Infix _ _ -> d- Syntax _ _ -> d- SC.Mutual r ds -> SC.Mutual r (lowerMeta ds)- Abstract r ds -> Abstract r (lowerMeta ds)- Private r ds -> Private r (lowerMeta ds)- Postulate r sigs -> Postulate r (lowerMeta sigs)- SC.Primitive r sigs -> SC.Primitive r (lowerMeta sigs)- SC.Open _ _ _ -> d- SC.Import _ _ _ _ _ -> d- SC.Pragma _ -> d- ModuleMacro r n modapp op dir -> ModuleMacro r n- (lowerMeta modapp) op dir- SC.Module r qn tel ds -> SC.Module r qn (lowerMeta tel) (lowerMeta ds)--instance LowerMeta SC.ModuleApplication where- lowerMeta (SC.SectionApp r tel e) = SC.SectionApp r (lowerMeta tel) (lowerMeta e)- lowerMeta (SC.RecordModuleIFS r rec) = SC.RecordModuleIFS r rec--instance LowerMeta SC.WhereClause where- lowerMeta SC.NoWhere = SC.NoWhere- lowerMeta (SC.AnyWhere ds) = SC.AnyWhere $ lowerMeta ds- lowerMeta (SC.SomeWhere m ds) = SC.SomeWhere m $ lowerMeta ds--instance LowerMeta a => LowerMeta [a] where- lowerMeta as = List.map lowerMeta as--instance LowerMeta a => LowerMeta (Arg a) where- lowerMeta aa = fmap lowerMeta aa--instance LowerMeta a => LowerMeta (Named name a) where- lowerMeta aa = fmap lowerMeta aa---preMeta = SC.QuestionMark noRange Nothing-preUscore = SC.Underscore noRange Nothing--cmd_compute :: Bool -- ^ Ignore abstract?- -> GoalCommand-cmd_compute ignore ii rng s = Interaction Dependent $ do- e <- B.parseExprIn ii rng s- d <- B.withInteractionId ii $ do- let c = B.evalInCurrent e- v <- if ignore then ignoreAbstractMode c else c- prettyATop v- display_info "*Normal Form*" (show d)- return Nothing---- | Parses and scope checks an expression (using the \"inside scope\"--- as the scope), performs the given command with the expression as--- input, and displays the result.--parseAndDoAtToplevel- :: (SA.Expr -> TCM SA.Expr)- -- ^ The command to perform.- -> String- -- ^ The name to use for the buffer displaying the output.- -> String- -- ^ The expression to parse.- -> Interaction-parseAndDoAtToplevel cmd title s = Interaction Dependent $ do- e <- liftIO $ parse exprParser s- display_info title =<<- B.atTopLevel (showA =<< cmd =<< concreteToAbstract_ e)- return Nothing---- | Parse the given expression (as if it were defined at the--- top-level of the current module) and infer its type.--cmd_infer_toplevel- :: B.Rewrite -- ^ Normalise the type?- -> String- -> Interaction-cmd_infer_toplevel norm =- parseAndDoAtToplevel (B.typeInCurrent norm) "*Inferred Type*"---- | Parse and type check the given expression (as if it were defined--- at the top-level of the current module) and normalise it.--cmd_compute_toplevel :: Bool -- ^ Ignore abstract?- -> String -> Interaction-cmd_compute_toplevel ignore =- parseAndDoAtToplevel (if ignore then ignoreAbstractMode . c- else inConcreteMode . c)- "*Normal Form*"- where c = B.evalInCurrent----------------------------------------------------------------------------- Syntax highlighting---- | @cmd_write_highlighting_info source target@ writes syntax--- highlighting information for the module in @source@ into @target@.------ If the module does not exist, or its module name is malformed or--- cannot be determined, or the module has not already been visited,--- or the cached info is out of date, then the representation of \"no--- highlighting information available\" is instead written to--- @target@.------ This command is used to load syntax highlighting information when a--- new file is opened, and it would probably be annoying if jumping to--- the definition of an identifier reset the proof state, so this--- command tries not to do that. One result of this is that the--- command uses the current include directories, whatever they happen--- to be.--cmd_write_highlighting_info :: FilePath -> FilePath -> Interaction-cmd_write_highlighting_info source target =- Interaction (Independent Nothing) $ do- liftIO . UTF8.writeFile target . showHighlightingInfo =<< do- ex <- liftIO $ doesFileExist source- case ex of- False -> return Nothing- True -> do- mmi <- (getVisitedModule =<<- moduleName =<< liftIO (absolute source))- `catchError`- \_ -> return Nothing- case mmi of- Nothing -> return Nothing- Just mi -> do- sourceT <- liftIO $ getModificationTime source- if sourceT <= miTimeStamp mi- then do- modFile <- stModuleToSource <$> get- return $ Just (iHighlighting $ miInterface mi, modFile)- else- return Nothing- return Nothing---- | Tells the Emacs mode to go to the first error position (if any).--tellEmacsToJumpToError :: Range -> IO ()-tellEmacsToJumpToError r = do- case rStart r of- Nothing -> return ()- Just (Pn { srcFile = Nothing }) -> return ()- Just (Pn { srcFile = Just f, posPos = p }) ->- putResponse $- L [ A "annotation-goto"- , Q $ L [A (quote $ filePath f), A ".", A (show p)]- ]----------------------------------------------------------------------------- Implicit arguments---- | Tells Agda whether or not to show implicit arguments.--showImplicitArgs :: Bool -- ^ Show them?- -> Interaction-showImplicitArgs showImpl = Interaction Dependent $ do- opts <- commandLineOptions- setCommandLineOptions $- opts { optPragmaOptions =- (optPragmaOptions opts) { optShowImplicit = showImpl } }- return Nothing---- | Toggle display of implicit arguments.--toggleImplicitArgs :: Interaction-toggleImplicitArgs = Interaction Dependent $ do- opts <- commandLineOptions- let ps = optPragmaOptions opts- setCommandLineOptions $- opts { optPragmaOptions =- ps { optShowImplicit = not $ optShowImplicit ps } }- return Nothing----------------------------------------------------------------------------- Error handling---- | When an error message is displayed the following title should be--- used, if appropriate.--errorTitle :: String-errorTitle = "*Error*"---- | Displays an error, instructs Emacs to jump to the site of the--- error, and terminates the program. Because this function may switch--- the focus to another file the status information is also updated.--displayErrorAndExit :: Status- -- ^ The new status information.- -> Range -> String -> IO a-displayErrorAndExit status r s = do- display_info' errorTitle s- tellEmacsToJumpToError r- displayStatus status- exitWith (ExitFailure 1)---- | Outermost error handler.--infoOnException m =- failOnException (displayErrorAndExit s) m `catchImpossible` \e ->- displayErrorAndExit s noRange (show e)- where- s = Status { sChecked = False- , sShowImplicitArguments = False- -- Educated guess... This field is not important, so it- -- does not really matter if it is displayed- -- incorrectly when an unexpected error has occurred.- }---- | Raises an error if the given file is not the one currently--- loaded.--ensureFileLoaded :: AbsolutePath -> TCM ()-ensureFileLoaded current = do- f <- theCurrentFile <$> liftIO (readIORef theState)- when (Just current /= (fst <$> f)) $- typeError $ GenericError "Error: First load the file."---- Helpers for testing ------------------------------------------------------getCurrentFile :: IO FilePath-getCurrentFile = do- mf <- theCurrentFile <$> readIORef theState- case mf of- Nothing -> error "command: No file loaded!"- Just (f, _) -> return (filePath f)---- | Changes the 'Interaction' so that its first action is to turn off--- all debug messages.--makeSilent :: Interaction -> Interaction-makeSilent i = i { command = do- opts <- commandLineOptions- TM.setCommandLineOptions $ opts- { optPragmaOptions =- (optPragmaOptions opts)- { optVerbose = Trie.singleton [] 0 }- }- command i }--top_command' :: FilePath -> Interaction -> IO ()-top_command' f cmd = ioTCM f Nothing $ makeSilent cmd--goal_command :: InteractionId -> GoalCommand -> String -> IO ()-goal_command i cmd s = do- f <- getCurrentFile- -- TODO: Test with other ranges as well.- ioTCM f Nothing $ makeSilent $ cmd i noRange s
@@ -0,0 +1,49 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Common syntax highlighting functions for Emacs and JSON++module Agda.Interaction.Highlighting.Common+ ( toAtoms+ , chooseHighlightingMethod+ ) where++import Agda.Interaction.Highlighting.Precise+import Agda.Syntax.Common+import Agda.TypeChecking.Monad (HighlightingMethod(..))+import Data.Maybe (maybeToList)+import Data.Char (toLower)+import qualified Data.Set as Set++-- | Converts the 'aspect' and 'otherAspects' fields to strings that are+-- friendly to editors.+toAtoms :: Aspects -> [String]+toAtoms m = map toAtom (Set.toList $ otherAspects m)+ ++ toAtoms' (aspect m)+ where++ toAtom :: Show a => a -> String+ toAtom = map toLower . show++ kindToAtom (Constructor Inductive) = "inductiveconstructor"+ kindToAtom (Constructor CoInductive) = "coinductiveconstructor"+ kindToAtom k = toAtom k++ toAtoms' Nothing = []+ toAtoms' (Just (Name mKind op)) =+ map kindToAtom (maybeToList mKind) ++ opAtom+ where opAtom | op = ["operator"]+ | otherwise = []+ toAtoms' (Just a) = [toAtom a]++-- | Choose which method to use based on HighlightingInfo and HighlightingMethod+chooseHighlightingMethod+ :: HighlightingInfo+ -> HighlightingMethod+ -> HighlightingMethod+chooseHighlightingMethod info method = case toList info of+ _ | method == Direct -> Direct+ ((_, mi) : _) | check mi -> Direct+ _ -> Indirect++ where check mi = otherAspects mi == Set.singleton TypeChecks+ || mi == mempty
@@ -1,90 +1,7 @@-{-# LANGUAGE CPP #-}-module Agda.Interaction.Highlighting.Dot where--import Control.Applicative-import Control.Monad.State--import qualified Data.Map as M-import Data.Map(Map)-import Data.Maybe-import Data.Monoid--import qualified Data.Set as S-import Data.Set (Set)--import System.Directory-import System.FilePath--import qualified Agda.Syntax.Concrete.Name as CN-import Agda.Interaction.FindFile-import Agda.Interaction.Options-import Agda.Syntax.Abstract-import Agda.Syntax.Abstract.Name-import Agda.TypeChecking.Monad--import Agda.Utils.FileName---#include "../../undefined.h"-import Agda.Utils.Impossible--data DotState = DotState- { dsModules :: Map ModuleName String- , dsNameSupply :: [String]- , dsConnection :: Set (String, String)- }--initialDotState :: DotState-initialDotState = DotState- { dsModules = mempty- , dsNameSupply = map (('m':) . show) [0..]- , dsConnection = mempty- }--type DotM = StateT DotState TCM--addModule :: ModuleName -> DotM (String, Bool)-addModule m = do- s <- get- case M.lookup m (dsModules s) of- Just r -> return (r, False)- Nothing -> do- let newName:nameSupply = dsNameSupply s- put s- { dsModules = M.insert m newName (dsModules s)- , dsNameSupply = nameSupply- }- return (newName, True)---addConnection :: String -> String -> DotM ()-addConnection m1 m2 = modify $ \s -> s {dsConnection = S.insert (m1,m2) (dsConnection s)}--dottify :: Interface -> DotM String-dottify inter = do- let curModule = iModuleName inter- (name, continue) <- addModule curModule- importsifs <- lift $ map miInterface . catMaybes <$> mapM (getVisitedModule . toTopLevelModuleName) (iImportedModules inter)- when continue $ do- imports <- mapM dottify importsifs- mapM_ (addConnection name) imports- return name+{-# OPTIONS_GHC -Wunused-imports #-} +module Agda.Interaction.Highlighting.Dot+ ( dotBackend+ ) where -generateDot :: Interface -> TCM ()-generateDot inter = do- (top, state) <- flip runStateT initialDotState $ do- dottify inter- mfile <- optDependencyGraph <$> commandLineOptions- case mfile of- Nothing -> __IMPOSSIBLE__- Just fp -> liftIO $ writeFile fp $ mkDot state- where- mkDot :: DotState -> String- mkDot st = unlines $- [ "digraph dependencies {"- ] ++ [" " ++ repr ++ "[label=\"" ++ show modulename ++ "\"];"- | (modulename, repr) <- M.toList (dsModules st)]- ++ [" " ++ r1 ++ " -> " ++ r2 ++ ";"- | (r1 , r2) <- S.toList (dsConnection st) ]- ++ ["}"]+import Agda.Interaction.Highlighting.Dot.Backend ( dotBackend )
@@ -0,0 +1,254 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.Highlighting.Dot.Backend+ ( dotBackend+ ) where++import Prelude hiding (null)++import Agda.Interaction.Highlighting.Dot.Base (renderDotToFile)++import Control.Monad.Except+ ( ExceptT+ , runExceptT+ , MonadError(throwError)+ )+import Control.Monad.IO.Class+ ( MonadIO(..)+ )+import Control.DeepSeq++import Data.HashSet (HashSet)+import Data.Map (Map)+import Data.Set (Set)+import qualified Data.HashSet as HashSet+import qualified Data.Map as Map+import qualified Data.Set as Set+import Data.Maybe+import qualified Data.Text.Lazy as L++import GHC.Generics (Generic)++import Agda.Compiler.Backend (Backend,Backend_boot(..), Backend',Backend'_boot(..), Definition, Recompile(..))+import Agda.Compiler.Common (curIF, IsMain)++import Agda.Interaction.FindFile (findFile)+import Agda.Interaction.Library+import Agda.Interaction.Options+ ( ArgDescr(ReqArg)+ , Flag+ , OptDescr(..)+ )++import Agda.Syntax.Common.Pretty ( prettyShow )+import Agda.Syntax.TopLevelModuleName (TopLevelModuleName)++import Agda.TypeChecking.Monad+ ( Interface(iImportedModules)+ , MonadTCError+ , ReadTCState+ , MonadTCM(..)+ , internalError+ , reportSDoc+ , getAgdaLibFiles+ , srcFilePath+ )+import Agda.TypeChecking.Pretty++import Agda.Utils.Graph.AdjacencyMap.Unidirectional+ (Graph, WithUniqueInt)+import qualified Agda.Utils.Graph.AdjacencyMap.Unidirectional as Graph+import Agda.Utils.Null++-- ------------------------------------------------------------------------++data DotFlags = DotFlags+ { dotFlagDestination :: Maybe FilePath+ , dotFlagLibraries :: HashSet LibName+ -- ^ Only include modules from the given libraries.+ } deriving (Eq, Generic)++instance NFData DotFlags++defaultDotFlags :: DotFlags+defaultDotFlags = DotFlags+ { dotFlagDestination = Nothing+ , dotFlagLibraries = empty+ }++dotFlagsDescriptions :: [OptDescr (Flag DotFlags)]+dotFlagsDescriptions =+ [ Option [] ["dependency-graph"] (ReqArg dependencyGraphFlag "FILE")+ "generate a Dot file with a module dependency graph"+ , Option [] ["dependency-graph-include"]+ (ReqArg includeFlag "LIBRARY")+ "include modules from the given library (default: all modules)"+ ]++dependencyGraphFlag :: FilePath -> Flag DotFlags+dependencyGraphFlag f o = return $ o { dotFlagDestination = Just f }++includeFlag :: String -> Flag DotFlags+includeFlag s o = return $+ o { dotFlagLibraries = HashSet.insert (parseLibName s) $ dotFlagLibraries o+ }++data DotCompileEnv = DotCompileEnv+ { dotCompileEnvDestination :: FilePath+ , dotCompileEnvLibraries :: HashSet LibName+ -- ^ Only include modules from the given libraries.+ -- If the set is empty, include all libraries.+ }++-- Currently unused+data DotModuleEnv = DotModuleEnv++data DotModule = DotModule+ { dotModuleName :: TopLevelModuleName+ , dotModuleImportedNames :: Set TopLevelModuleName+ , dotModuleInclude :: Bool+ -- ^ Include the module in the graph?+ }++-- | Currently unused+data DotDef = DotDef++dotBackend :: Backend+dotBackend = Backend dotBackend'++dotBackend' :: Backend' DotFlags DotCompileEnv DotModuleEnv DotModule DotDef+dotBackend' = Backend'+ { backendName = "Dot"+ , backendVersion = Nothing+ , options = defaultDotFlags+ , commandLineFlags = dotFlagsDescriptions+ , isEnabled = isJust . dotFlagDestination+ , preCompile = asInternalErrors . preCompileDot+ , preModule = preModuleDot+ , compileDef = compileDefDot+ , postModule = postModuleDot+ , postCompile = postCompileDot+ , scopeCheckingSuffices = True+ , mayEraseType = const $ return True+ , backendInteractTop = Nothing+ , backendInteractHole = Nothing+ }++-- | Convert a general "MonadError String m" into "MonadTCError m".+asInternalErrors :: (MonadTCError m) => ExceptT String m b -> m b+asInternalErrors t = either internalError return =<< runExceptT t++preCompileDot+ :: MonadError String m+ => DotFlags+ -> m DotCompileEnv+preCompileDot d = case dotFlagDestination d of+ Just dest -> return $ DotCompileEnv+ { dotCompileEnvDestination = dest+ , dotCompileEnvLibraries = dotFlagLibraries d+ }+ Nothing ->+ throwError "The Dot backend was invoked without being enabled!"+ -- Andreas, 2024-08-03: I suppose this counts as internal error.++preModuleDot+ :: Applicative m+ => DotCompileEnv+ -> IsMain+ -> TopLevelModuleName+ -> Maybe FilePath+ -> m (Recompile DotModuleEnv DotModule)+preModuleDot _cenv _main _moduleName _ifacePath = pure $ Recompile DotModuleEnv++compileDefDot+ :: Applicative m+ => DotCompileEnv+ -> DotModuleEnv+ -> IsMain+ -> Definition+ -> m DotDef+compileDefDot _cenv _menv _main _def = pure DotDef++postModuleDot+ :: (MonadTCM m, ReadTCState m)+ => DotCompileEnv+ -> DotModuleEnv+ -> IsMain+ -> TopLevelModuleName+ -> [DotDef]+ -> m DotModule+postModuleDot cenv DotModuleEnv _main m _defs = do+ i <- curIF+ let importedModuleNames = Set.fromList $ fst <$> (iImportedModules i)+ let ls = dotCompileEnvLibraries cenv+ include <- case null ls of+ True -> return True+ False -> liftTCM do+ sf <- findFile m+ f <- srcFilePath sf+ libs <- getAgdaLibFiles f m++ let incLibs = filter (\l -> _libName l `HashSet.member` ls) libs+ inLib = not (null incLibs)++ reportSDoc "dot.include" 10 $ do+ let name = pretty m+ list = nest 2 . vcat . map (pretty . _libName)+ if inLib then+ fsep+ ([ "Including"+ , name+ ] +++ pwords "because it is in the following libraries:") $$+ list incLibs+ else+ fsep+ (pwords "Not including" +++ [name <> ","] +++ pwords "which is in the following libraries:") $$+ list libs++ return inLib++ return $ DotModule+ { dotModuleName = m+ , dotModuleImportedNames = importedModuleNames+ , dotModuleInclude = include+ }++postCompileDot+ :: (MonadIO m)+ => DotCompileEnv+ -> IsMain+ -> Map TopLevelModuleName DotModule+ -> m ()+postCompileDot cenv _main modulesByName =+ renderDotToFile moduleGraph (dotCompileEnvDestination cenv)+ where+ -- Only the keys of this map are used.+ modulesToInclude =+ Map.filter dotModuleInclude modulesByName++ moduleGraph :: Graph (WithUniqueInt L.Text) ()+ moduleGraph =+ Graph.renameNodesMonotonic (fmap (L.pack . prettyShow)) $+ Graph.transitiveReduction $+ Graph.filterNodesKeepingEdges+ (\n -> Graph.otherValue n `Map.member` modulesToInclude) $+ -- The following use of transitive reduction should not affect the+ -- semantics. It tends to make the graph smaller, so it might+ -- improve the overall performance of the code, but I did not+ -- verify this.+ Graph.transitiveReduction $+ Graph.addUniqueInts $+ Graph.fromEdges $+ concatMap+ (\ (name, m) ->+ [ Graph.Edge+ { source = name+ , target = target+ , label = ()+ }+ | target <- Set.toList $ dotModuleImportedNames m+ ]) $+ Map.toList modulesByName
@@ -0,0 +1,44 @@+-- | Generate an import dependency graph for a given module.++module Agda.Interaction.Highlighting.Dot.Base+ ( renderDotToFile+ , renderDot+ , DotGraph+ ) where++import Control.Monad.IO.Class++import qualified Data.Set as S++import qualified Data.Text.Lazy as L+import qualified Data.Text.Lazy.Encoding as E+import qualified Data.ByteString.Lazy as BS++import Agda.Utils.Graph.AdjacencyMap.Unidirectional+ (Graph, WithUniqueInt)+import qualified Agda.Utils.Graph.AdjacencyMap.Unidirectional as Graph++-- | Graph structure+type DotGraph = Graph (WithUniqueInt L.Text) ()++-- * Graph rendering++renderDot :: DotGraph -> L.Text+renderDot g = L.unlines $ concat+ [ [ "digraph dependencies {" ]+ , [ L.concat [" ", show' nodeId, "[label=\"", label, "\"];"]+ | Graph.WithUniqueInt nodeId label <- S.toList $ Graph.nodes g+ ]+ , [ L.concat [" ", show' r1, " -> ", show' r2, ";"]+ | Graph.Edge+ { source = Graph.WithUniqueInt r1 _+ , target = Graph.WithUniqueInt r2 _+ } <- Graph.edges g+ ]+ , ["}"]+ ]+ where+ show' = L.pack . ("m" ++) . show++renderDotToFile :: MonadIO m => DotGraph -> FilePath -> m ()+renderDotToFile dot fp = liftIO $ BS.writeFile fp $ E.encodeUtf8 $ renderDot dot
@@ -1,97 +1,115 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} -- | Functions which give precise syntax highlighting info to Emacs. module Agda.Interaction.Highlighting.Emacs- ( showHighlightingInfo- , Agda.Interaction.Highlighting.Emacs.tests+ ( HighlightingInfo+ , lispifyHighlightingInfo+ , lispifyHighlightingInfo_+ , lispifyTokenBased ) where -import Agda.Interaction.FindFile-import Agda.Interaction.Highlighting.Precise-import Agda.Interaction.Highlighting.Range-import Agda.Syntax.Abstract (QName)-import Agda.Syntax.Common-import qualified Agda.Syntax.Position as P-import Agda.Syntax.Translation.ConcreteToAbstract (TopLevelInfo)-import Agda.TypeChecking.Errors (prettyError)-import Agda.Utils.FileName-import Agda.Utils.String-import Agda.Utils.TestHelpers--import Agda.Utils.Impossible-#include "../../undefined.h"+import Prelude hiding (null) -import Control.Monad.Trans-import Data.List-import qualified Data.Map as Map-import Data.Char+import qualified Data.List as List import Data.Maybe ---------------------------------------------------------------------------- Read/show functions+import Agda.Syntax.Common.Pretty (prettyShow) --- | Converts the 'aspect' and 'otherAspects' fields to atoms readable--- by the Emacs interface.+import Agda.Interaction.Highlighting.Common+import Agda.Interaction.Highlighting.Precise+import Agda.Utils.Range (Range(..))+import Agda.Interaction.Emacs.Lisp+import Agda.Interaction.Response -toAtoms :: MetaInfo -> [String]-toAtoms m = map toAtom (otherAspects m) ++ toAtoms' (aspect m)- where- toAtom x = map toLower (show x)+import Agda.TypeChecking.Monad (HighlightingMethod(..), ModuleToSource, topLevelModuleFilePath) - kindToAtom (Constructor Inductive) = "inductiveconstructor"- kindToAtom (Constructor CoInductive) = "coinductiveconstructor"- kindToAtom k = toAtom k+import Agda.Utils.CallStack (HasCallStack)+import Agda.Utils.FileName (AbsolutePath, filePath)+import Agda.Utils.IO.TempFile (writeToTempFile)+import Agda.Utils.Null+import Agda.Utils.String (quote) - toAtoms' Nothing = []- toAtoms' (Just (Name mKind op)) =- map kindToAtom (maybeToList mKind) ++ opAtom- where opAtom | op = ["operator"]- | otherwise = []- toAtoms' (Just a) = [toAtom a] -- | Shows meta information in such a way that it can easily be read -- by Emacs. -showMetaInfo :: ModuleToSource- -- ^ Must contain a mapping for the definition site's- -- module, if any.- -> (Range, MetaInfo) -> String-showMetaInfo modFile (r, m) =- "("- ++ show (from r)- ++ " "- ++ show (to r)- ++ " ("- ++ concat (intersperse " " (toAtoms m))- ++ ")"- ++ (maybe " nil" ((" " ++) . quote) $ note m)- ++ defSite- ++ ")"+showAspects+ :: ModuleToSource+ -- ^ Must contain a mapping for the definition site's module, if any.+ -> (Range, Aspects) -> Lisp String+showAspects modFile (r, m) = L $+ (map (A . show) [from r, to r])+ +++ [L $ map A $ toAtoms m]+ +++ dropNils (+ [lispifyTokenBased (tokenBased m)]+ +++ [A $ ifNull (note m) "nil" quote]+ +++ maybeToList (defSite <$> definitionSite m)) where- defSite = case definitionSite m of- Nothing -> ""- Just (m, p) -> case Map.lookup m modFile of- Nothing -> __IMPOSSIBLE__- Just f -> " (" ++ quote (filePath f) ++ " . " ++ show p ++ ")"+ defSite (DefinitionSite m p _ _) =+ Cons (A $ quote $ filePath f) (A $ show p)+ where+ f :: HasCallStack => AbsolutePath+ f = topLevelModuleFilePath modFile m -- partial function, so use CallStack! --- | Shows syntax highlighting information in an Emacsy fashion.+ dropNils = List.dropWhileEnd (== A "nil") -showHighlightingInfo- :: Maybe (HighlightingInfo, ModuleToSource)- -- ^ The 'ModuleToSource' must contain a mapping for every- -- definition site's module.- -> String-showHighlightingInfo Nothing = ""-showHighlightingInfo (Just (h, modFile)) =- "(" ++ unlines (map (showMetaInfo modFile) h) ++ ")"+-- | Formats the 'TokenBased' tag for the Emacs backend. No quotes are+-- added. ---------------------------------------------------------------------------- All tests+lispifyTokenBased :: TokenBased -> Lisp String+lispifyTokenBased TokenBased = A "t"+lispifyTokenBased NotOnlyTokenBased = A "nil" --- TODO: One could check that the show functions are invertible.+-- | Run 'showAspects' on a whole 'RangeMap'.+lispifyHighlightingInfo_ ::+ ModuleToSource+ -- ^ Must contain a mapping for every definition site's module.+ -> HighlightingInfo+ -> [Lisp String]+lispifyHighlightingInfo_ m2s = map (showAspects m2s) . toList --- | All the properties.+-- | Turns syntax highlighting information into a list of+-- S-expressions. -tests :: IO Bool-tests = runTests "Agda.Interaction.Highlighting.Emacs" []+-- TODO: The "go-to-definition" targets can contain long strings+-- (absolute paths to files). At least one of these strings (the path+-- to the current module) can occur many times. Perhaps it would be a+-- good idea to use a more compact format.++lispifyHighlightingInfo+ :: HighlightingInfo+ -> RemoveTokenBasedHighlighting+ -> HighlightingMethod+ -> ModuleToSource+ -- ^ Must contain a mapping for every definition site's module.+ -> Maybe FilePath+ -> IO (Lisp String)+lispifyHighlightingInfo h remove method modFile target =+ case chooseHighlightingMethod h method of+ Direct -> direct+ Indirect -> indirect+ where+ info :: [Lisp String]+ info =+ A (case remove of+ RemoveHighlighting -> "remove"+ KeepHighlighting -> "nil") :+ lispifyHighlightingInfo_ modFile h++ direct :: IO (Lisp String)+ direct = return $ L $+ A "agda2-highlight-add-annotations" :+ A (maybe "nil" quote target) : map Q info++ indirect :: IO (Lisp String)+ indirect = do+ filepath <- writeToTempFile (prettyShow $ L info)+ return $ L [ A "agda2-highlight-load-and-delete-action"+ , A (quote filepath)+ , A (maybe "nil" quote target)+ ]
@@ -0,0 +1,708 @@+-- | Extract highlighting syntax from abstract syntax.+--+-- Implements one big fold over abstract syntax.++{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Interaction.Highlighting.FromAbstract+ ( runHighlighter+ , NameKinds+ ) where++import Prelude hiding (null)++import Control.Monad.Reader ( MonadReader(..), asks, Reader, runReader )++import Data.Maybe+import Data.Void ( Void )++import Agda.Interaction.Highlighting.Precise hiding ( singleton )+import qualified Agda.Interaction.Highlighting.Precise as H+import Agda.Interaction.Highlighting.Range ( rToR ) -- Range is ambiguous++import Agda.Syntax.Abstract ( IsProjP(..), anameName, getAmbiguous, nameBindingSite )+import qualified Agda.Syntax.Abstract as A+import Agda.Syntax.Common as Common+import Agda.Syntax.Concrete ( FieldAssignment'(..), TacticAttribute' )+import qualified Agda.Syntax.Concrete.Name as C+import Agda.Syntax.Info ( ModuleInfo(..) )+import Agda.Syntax.Literal+import qualified Agda.Syntax.Position as P+import Agda.Syntax.Position ( Range, HasRange, getRange, noRange )+import Agda.Syntax.Scope.Base ( ResolvedName(..), exactConName )+import Agda.Syntax.TopLevelModuleName++import Agda.TypeChecking.Monad+ hiding (ModuleInfo, MetaInfo, Primitive, Constructor, Record, Function, Datatype)++import Agda.Utils.Function+import Agda.Utils.List ( initLast1 )+import Agda.Utils.List1 ( List1 )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import qualified Agda.Utils.Maybe.Strict as Strict+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton+import Agda.Utils.Size++-- Entry point:+-- | Create highlighting info for some piece of syntax.+runHighlighter+ :: Hilite a+ => TopLevelModuleName+ -- ^ The current top-level module's name.+ -> NameKinds -> a -> HighlightingInfoBuilder+runHighlighter top kinds x =+ runReader (hilite x) $+ HiliteEnv+ { hleNameKinds = kinds+ , hleCurrentModuleName = top+ }++-- | Environment of the highlighter.+data HiliteEnv = HiliteEnv+ { hleNameKinds :: NameKinds+ -- ^ Function mapping qualified names to their kind.+ , hleCurrentModuleName :: TopLevelModuleName+ -- ^ The current top-level module's name. Used for consistency+ -- checking.+ }++-- | A function mapping names to the kind of name they stand for.+type NameKinds = A.QName -> Maybe NameKind++-- | Highlighting monad.+type HiliteM = Reader HiliteEnv++-- | Highlighter.++type Hiliter = HiliteM HighlightingInfoBuilder++instance Monoid Hiliter where+ mempty = pure mempty+ mappend = (<>)++-- | Traversal to extract highlighting information.++class Hilite a where+ hilite :: a -> Hiliter++ default hilite :: (Foldable t, Hilite b, t b ~ a) => a -> Hiliter+ hilite = foldMap hilite++-- * Generic instances+---------------------------------------------------------------------------++instance Hilite a => Hilite [a]+instance Hilite a => Hilite (List1 a)+instance Hilite a => Hilite (Maybe a)+instance Hilite a => Hilite (Ranged a)+instance Hilite a => Hilite (TacticAttribute' a)+instance Hilite a => Hilite (WithHiding a)++instance Hilite Void where+ hilite _ = mempty++instance (Hilite a, Hilite b) => Hilite (Either a b) where+ hilite = either hilite hilite++instance (Hilite a, Hilite b) => Hilite (a, b) where+ hilite (a, b) = hilite a <> hilite b++-- * Major syntactic categories+---------------------------------------------------------------------------++-- | Reengineered from the old Geniplate-implemented highlighting extraction.+-- This was the old procedure:+--+-- Traversal over declaration in abstract syntax that collects the+-- following hiliting information:+--+-- [1. @constructorInfo@ (highest prio)]+-- 2. @theRest@ (medium prio)+-- 3. @nameInfo@ (lowest prio)+--+-- @nameInfo@:+-- "All names mentioned in the syntax tree (not bound variables)."+-- For each possibly ambiguous name (QName and AmbiguousQName)+-- that not isExtendedLambdaName,+-- do @hiliteAmbiguous@ (used to be called@generate@).+--+-- @constructorInfo@ (only when highlighting level == Full):+-- "After the code has been type checked more information may be+-- available for overloaded constructors, and+-- generateConstructorInfo takes advantage of this information.+-- Note, however, that highlighting for overloaded constructors is+-- included also in nameInfo."+-- This is not computed by recursion over the abstract syntax,+-- but gets the constructor names stDisambiguatedNames+-- that fall within the bounds of the current declaration.+--+-- @theRest@:+-- Bound variables, dotted patterns, record fields, module names,+-- the "as" and "to" symbols and some other things.+--+-- Here is a table what @theRest@ used to collect:+--+-- ---------------------------------------------------------------------+-- | A.Expr+-- ---------------------------------------------------------------------+-- | getVarAndField (Expr) | A.Var | bound+-- | getVarAndField | A.Rec(Update) | field+-- | getExpr (Expr) | A.PatternSyn | patsyn+-- | getExpr | A.Macro | macro+-- ---------------------------------------------------------------------+-- | A.LetBinding+-- ---------------------------------------------------------------------+-- | getLet | A.LetBind | bound+-- ---------------------------------------------------------------------+-- | A.LamBinding+-- ---------------------------------------------------------------------+-- | getLam | A.Binder under A.DomainFree | bound+-- | getTyped | A.Binder under A.TBind | bound+-- ---------------------------------------------------------------------+-- | A.Pattern'+-- ---------------------------------------------------------------------+-- | getPattern(Syn) | A.VarP | bound+-- | getPattern(Syn) | A.AsP | bound+-- | getPattern(Syn) | A.DotP (not isProjP) | DottedPattern+-- | getPattern(Syn) | A.RecP | field+-- | getPattern(Syn) | A.PatternSynP | patsyn+-- ---------------------------------------------------------------------+-- | A.Declaration+-- ---------------------------------------------------------------------+-- | getFieldDecl | A.Field under A.RecDef | field+-- | getPatSynArgs | A.PatternSynDef | bound+-- | getPragma | A.BuiltinPragma... | keyword+-- ---------------------------------------------------------------------+-- | A.NamedArg (polymorphism not supported in geniplate)+-- ---------------------------------------------------------------------+-- | getNamedArg | NamedArg a | nameOf+-- | getNamedArgE | NamedArg Exp | nameOf+-- | getNamedArgP | NamedArg Pattern | nameOf+-- | getNamedArgB | NamedArg BindName | nameOf+-- | getNamedArgL | NamedArg LHSCore | nameOf+--+-- | getModuleName | A.MName | mod+-- | getModuleInfo | ModuleInfo | asName, (range of as,to)+-- | getQuantityAttr | Common.Quantity | Symbol (if range)++instance Hilite A.RecordDirectives where+ hilite (RecordDirectives _ _ _ c) = hilite c++instance Hilite A.RecordConName where+ hilite = \case+ A.NamedRecCon x -> hilite x+ A.FreshRecCon{} -> mempty++instance Hilite A.Declaration where+ hilite = \case+ A.Axiom _ax _di ai _occ x e -> hl ai <> hl x <> hl e+ A.Generalize _names _di ai x e -> hl ai <> hl x <> hl e+ A.Field _di x e -> hlField x <> hl e+ A.Primitive _di x e -> hl x <> hl e+ A.Mutual _mi ds -> hl ds+ A.Section _r er x tel ds -> hl er <> hl x <> hl tel <> hl ds+ A.Apply mi er x a _ci dir -> hl mi <> hl er <> hl x <>+ hl a <> hl dir+ A.Import mi x dir -> hl mi <> hl x <> hl dir+ A.Open mi x dir -> hl mi <> hl x <> hl dir+ A.FunDef _di x cs -> hl x <> hl cs+ A.DataSig _di er x tel e -> hl er <> hl x <> hl tel <> hl e+ A.DataDef _di x _pc _uc pars cs -> hl x <> hl pars <> hl cs+ A.RecSig _di er x tel e -> hl er <> hl x <> hl tel <> hl e+ A.RecDef _di x _pc _uc _eta dir bs e ds-> hl x <> hl dir <> hl bs <> hl e <> hl ds+ A.PatternSynDef x xs p -> hl x <> hl xs <> hl p+ A.UnquoteDecl _mi _di xs e -> hl xs <> hl e+ A.UnquoteDef _di xs e -> hl xs <> hl e+ A.UnquoteData _i xs _uc _j cs e -> hl xs <> hl cs <> hl e+ A.ScopedDecl s ds -> hl ds+ A.Pragma _r pragma -> hl pragma+ A.UnfoldingDecl _r names -> hl names+ where+ hl a = hilite a+ hlField x = hiliteField (concreteQualifier x) (concreteBase x) (Just $ nameBindingSite x)++instance Hilite A.Pragma where+ hilite = \case+ A.OptionsPragma _strings -> mempty+ A.BuiltinPragma b x -> singleAspect Keyword b <> hilite x+ A.BuiltinNoDefPragma b k x -> singleAspect Keyword b <> hiliteQName (Just $ kindOfNameToNameKind k) x+ A.CompilePragma b x _foreign -> singleAspect Keyword b <> hilite x+ A.ForeignPragma b _foreign -> singleAspect Keyword b+ A.RewritePragma r xs -> singleAspect Keyword r <> hilite xs+ A.StaticPragma x -> hilite x+ A.InjectivePragma x -> hilite x+ A.InjectiveForInferencePragma x -> hilite x+ A.NotProjectionLikePragma x -> hilite x+ A.OverlapPragma x _ -> hilite x+ A.InlinePragma _inline x -> hilite x+ A.DisplayPragma x ps e -> hilite x <> hilite ps <> hilite e++instance Hilite A.Expr where+ hilite = \case+ A.Var x -> hl $ A.BindName x -- bound variable like binder+ A.Def' q _ -> hiliteQName Nothing q+ A.Proj _o qs -> hiliteAmbiguousQName Nothing qs -- Issue #4604: not: hiliteProjection qs+ -- Names from @open R r@ should not be highlighted as projections+ A.Con qs -> hiliteAmbiguousQName Nothing qs -- TODO? Con aspect+ A.PatternSyn qs -> hilitePatternSynonym qs+ A.Macro q -> hiliteQName (Just Macro) q+ A.Lit _r l -> hl l+ A.QuestionMark _mi _ii -> mempty+ A.Underscore _mi -> mempty+ A.Dot _r e -> hl e -- TODO? Projection?+ A.App _r e es -> hl e <> hl es+ A.WithApp _r e es -> hl e <> hl es+ A.Lam _r bs e -> hl bs <> hl e+ A.AbsurdLam _r _h -> mempty+ A.ExtendedLam _r _di er _q cs -> hl er <> hl cs -- No hilighting of generated extended lambda name!+ A.Pi _r tel b -> hl tel <> hl b+ A.Generalized _qs e -> hl e+ A.Fun _r a b -> hl a <> hl b+ A.Let _r bs e -> hl bs <> hl e+ A.Rec _kwr _r ass -> hl ass+ A.RecUpdate _kwr _r e ass -> hl e <> hl ass+ A.ScopedExpr _ e -> hl e+ A.Quote _r -> mempty+ A.QuoteTerm _r -> mempty+ A.Unquote _r -> mempty+ A.DontCare e -> hl e+ A.Qualified m e -> hl m <> hl e+ A.Highlighted m e -> pure (H.singleton (rToR $ getRange e) m) <> hl e+ where+ hl a = hilite a++instance (Hilite a, IsProjP a) => Hilite (A.Pattern' a) where+ hilite = \case+ A.VarP x -> hl x+ A.ConP _i qs es -> hiliteInductiveConstructor qs <> hl es+ -- No matching on coinductive constructors, thus, can determine NameKind here.+ A.ProjP _r _o qs -> hiliteProjection qs+ A.DefP _r qs es -> hl qs <> hl es+ A.WildP _r -> mempty+ A.AsP _r x p -> hl x <> hl p+ A.DotP r e -> case isProjP e of+ Nothing -> singleOtherAspect DottedPattern r <> hl e+ Just (_o, qs) -> hiliteProjection qs+ A.AbsurdP _r -> mempty+ A.LitP _r l -> hl l+ A.PatternSynP _r qs es -> hilitePatternSynonym qs <> hl es+ A.RecP _kwr _r ps -> hl ps+ A.EqualP _r ps -> hl ps+ A.WithP _ p -> hl p++ where+ hl a = hilite a++instance Hilite Literal where+ hilite = \case+ LitNat{} -> mempty+ LitWord64{} -> mempty+ LitFloat{} -> mempty+ LitString{} -> mempty+ LitChar{} -> mempty+ LitQName x -> hilite x+ LitMeta _fileName _id -> mempty++-- * Minor syntactic categories+---------------------------------------------------------------------------++instance Hilite A.LHS where+ hilite (A.LHS _r lhs) = hilite lhs++instance (Hilite a, IsProjP a) => Hilite (A.LHSCore' a) where+ hilite = \case+ A.LHSHead q ps -> hilite q <> hilite ps+ A.LHSProj q lhs ps -> hilite lhs <> hilite q <> hilite ps -- TODO? Projection?+ A.LHSWith lhs wps ps -> hilite lhs <> hilite wps <> hilite ps++instance Hilite A.RHS where+ hilite = \case+ A.RHS e _ce -> hl e+ A.AbsurdRHS -> mempty+ A.WithRHS _q es cs -> hl es <> hl cs -- No highlighting for with-function-name!+ A.RewriteRHS eqs strippedPats rhs wh -> hl eqs <> hl strippedPats <> hl rhs <> hl wh+ where+ hl a = hilite a++instance (HasRange n, Hilite p, Hilite e) => Hilite (RewriteEqn' x n p e) where+ hilite = \case+ Rewrite es -> hilite $ fmap snd es+ Invert _x pes -> hilite pes+ LeftLet pes -> hilite pes++instance Hilite a => Hilite (A.Clause' a) where+ hilite (A.Clause lhs strippedPats rhs wh _catchall) =+ hilite lhs <> hilite strippedPats <> hilite rhs <> hilite wh++instance Hilite A.ProblemEq where+ hilite (A.ProblemEq p _t _dom) = hilite p++instance Hilite A.WhereDeclarations where+ hilite (A.WhereDecls m _ ds) = hilite m <> hilite ds++instance Hilite A.GeneralizeTelescope where+ hilite (A.GeneralizeTel _gen tel) = hilite tel++instance Hilite A.DataDefParams where+ hilite (A.DataDefParams _gen pars) = hilite pars++instance Hilite A.ModuleApplication where+ hilite = \case+ A.SectionApp tel x es -> hilite tel <> hilite x <> hilite es+ A.RecordModuleInstance x -> hilite x++instance Hilite A.LetBinding where+ hilite = \case+ A.LetBind _r ai x t e -> hl ai <> hl x <> hl t <> hl e+ A.LetAxiom _r ai x t -> hl ai <> hl x <> hl t+ A.LetPatBind _r ai p e -> hl ai <> hl p <> hl e+ A.LetApply mi er x es _c dir -> hl mi <> hl er <> hl x <>+ hl es <> hl dir+ A.LetOpen mi x dir -> hl mi <> hl x <> hl dir+ where+ hl x = hilite x++instance Hilite A.TypedBindingInfo where+ hilite (A.TypedBindingInfo x _) = hilite x++instance Hilite A.TypedBinding where+ hilite = \case+ A.TBind _r tac binds e -> hilite tac <> hilite binds <> hilite e+ A.TLet _r binds -> hilite binds++instance Hilite A.LamBinding where+ hilite = \case+ A.DomainFree tac binds -> hilite tac <> hilite binds+ A.DomainFull bind -> hilite bind++instance Hilite a => Hilite (A.Binder' a) where+ hilite (A.Binder p _ x) = hilite p <> hilite x++instance Hilite A.BindName where+ hilite (A.BindName x) = hiliteBound x++instance Hilite a => Hilite (FieldAssignment' a) where+ hilite (FieldAssignment x e) = hiliteField [] x Nothing <> hilite e++instance (Hilite a, HasRange n) => Hilite (Named n a) where+ hilite (Named mn e)+ = maybe mempty (singleAspect $ Name (Just Argument) False) mn+ <> hilite e++instance Hilite a => Hilite (Arg a) where+ hilite (Arg ai e) = hilite ai <> hilite e++instance Hilite ArgInfo where+ hilite (ArgInfo _hiding modality _origin _fv _a) = hilite modality++instance Hilite Modality where+ hilite (Modality _relevance quantity _cohesion _polarity) = hilite quantity++-- | If the 'Quantity' attribute comes with a 'Range', highlight the+-- corresponding attribute as 'Symbol'.+instance Hilite Quantity where+ hilite = singleAspect Symbol++-- | Erasure attributes are highlighted as symbols.+instance Hilite Erased where+ hilite = singleAspect Symbol++instance Hilite ModuleInfo where+ hilite (ModuleInfo _r rAsTo asName _open _impDir)+ = singleAspect Symbol rAsTo -- TODO: 'to' already covered by A.ImportDirective+ <> maybe mempty hiliteAsName asName+ -- <> hilite impDir -- Should be covered by A.ImportDirective+ where+ hiliteAsName :: C.Name -> Hiliter+ hiliteAsName n = hiliteCName [] n noRange Nothing $ nameAsp Module++instance (Hilite m, Hilite n, Hilite (RenamingTo m), Hilite (RenamingTo n))+ => Hilite (ImportDirective' m n) where+ hilite (ImportDirective _r using hiding renaming _ropen) =+ hilite using <> hilite hiding <> hilite renaming++instance (Hilite m, Hilite n) => Hilite (Using' m n) where+ hilite = \case+ UseEverything -> mempty+ Using using -> hilite using++instance (Hilite m, Hilite n, Hilite (RenamingTo m), Hilite (RenamingTo n))+ => Hilite (Renaming' m n) where+ hilite (Renaming from to _fixity rangeKwTo)+ = hilite from+ <> singleAspect Symbol rangeKwTo+ -- Currently, the "to" is already highlited by rAsTo above.+ -- TODO: remove the "to" ranges from rAsTo.+ <> hilite (RenamingTo to)++instance (Hilite m, Hilite n) => Hilite (ImportedName' m n) where+ hilite = \case+ ImportedModule m -> hilite m+ ImportedName n -> hilite n++-- * Highlighting of names+---------------------------------------------------------------------------++instance Hilite DisambiguatedName where+ hilite (DisambiguatedName k x) = hiliteQName (Just k) x++instance Hilite ResolvedName where+ hilite = \case+ VarName x _bindSrc -> hiliteBound x+ DefinedName _acc x _suffix -> hilite $ anameName x+ FieldName xs -> hiliteProjection $ A.ambigName xs+ ConstructorName i xs -> hiliteAmbiguousQName k $ A.ambigName xs+ where k = kindOfNameToNameKind <$> exactConName i+ PatternSynResName xs -> hilitePatternSynonym $ A.ambigName xs+ UnknownName -> mempty++instance Hilite A.QName where+ hilite = hiliteQName Nothing++instance Hilite A.AmbiguousQName where+ hilite = hiliteAmbiguousQName Nothing++instance Hilite A.ModuleName where+ hilite m@(A.MName xs) = hiliteModule (isTopLevelModule, m)+ where+ isTopLevelModule =+ case mapMaybe (P.rangeModule . A.nameBindingSite) xs of+ [] -> False+ top : _ ->+ rawTopLevelModuleName top ==+ rawTopLevelModuleNameForModuleName m++ -- Andreas, 2020-09-29, issue #4952.+-- The target of a @renaming@ clause needs to be highlighted in a special way.+newtype RenamingTo a = RenamingTo a++instance Hilite (RenamingTo A.QName) where+ -- Andreas, 2020-09-29, issue #4952.+ -- Do not include the bindingSite, because the HTML backed turns it into garbage.+ hilite (RenamingTo q) = do+ kind <- asks hleNameKinds <&> ($ q)+ hiliteAName q False $ nameAsp' kind++instance Hilite (RenamingTo A.ModuleName) where+ -- Andreas, 2020-09-29, issue #4952.+ -- Do not include the bindingSite, because the HTML backed turns it into garbage.+ hilite (RenamingTo (A.MName ns)) = flip foldMap ns $ \ n ->+ hiliteCName [] (A.nameConcrete n) noRange Nothing $ nameAsp Module++instance (Hilite (RenamingTo m), Hilite (RenamingTo n))+ => Hilite (RenamingTo (ImportedName' m n)) where+ hilite (RenamingTo x) = case x of+ ImportedModule m -> hilite (RenamingTo m)+ ImportedName n -> hilite (RenamingTo n)++hiliteQName+ :: Maybe NameKind -- ^ Is 'NameKind' already known from the context?+ -> A.QName+ -> Hiliter+hiliteQName mkind q+ | isExtendedLambdaName q = mempty+ | isAbsurdLambdaName q = mempty+ | otherwise = do+ kind <- ifJust mkind (pure . Just) {-else-} $ asks hleNameKinds <&> ($ q)+ hiliteAName q True $ nameAsp' kind++-- | Takes the first 'NameKind'. Binding site only included if unique.+hiliteAmbiguousQName+ :: Maybe NameKind -- ^ Is 'NameKind' already known from the context?+ -> A.AmbiguousQName+ -> Hiliter+hiliteAmbiguousQName mkind x = do+ kind <- ifJust mkind (pure . Just) {-else-} $ do+ kinds <- asks hleNameKinds+ pure $ listToMaybe $ List1.catMaybes $ fmap kinds qs+ -- Ulf, 2014-06-03: [issue1064] It's better to pick the first rather+ -- than doing no highlighting if there's an ambiguity between an+ -- inductive and coinductive constructor.+ flip foldMap qs $ \ q ->+ hiliteAName q include $ nameAsp' kind+ where+ qs = getAmbiguous x+ include = List1.allEqual $ fmap nameBindingSite qs++hiliteBound :: A.Name -> Hiliter+hiliteBound x =+ hiliteCName [] (A.nameConcrete x) noRange (Just $ A.nameBindingSite x) $ nameAsp Bound++hiliteInductiveConstructor :: A.AmbiguousQName -> Hiliter+hiliteInductiveConstructor = hiliteAmbiguousQName $ Just $ Constructor Inductive++hilitePatternSynonym :: A.AmbiguousQName -> Hiliter+hilitePatternSynonym = hiliteInductiveConstructor -- There are no coinductive pattern synonyms!?++hiliteProjection :: A.AmbiguousQName -> Hiliter+hiliteProjection = hiliteAmbiguousQName (Just Field)++hiliteField :: [C.Name] -> C.Name -> Maybe Range -> Hiliter+hiliteField xs x bindingR = hiliteCName xs x noRange bindingR $ nameAsp Field++-- For top level modules, we set the binding site to the beginning of the file+-- so that clicking on an imported module will jump to the beginning of the file+-- which defines this module.+hiliteModule :: (Bool, A.ModuleName) -> Hiliter+hiliteModule (isTopLevelModule, A.MName []) = mempty+hiliteModule (isTopLevelModule, A.MName (n:ns)) =+ hiliteCName+ (map A.nameConcrete ms)+ (A.nameConcrete m)+ noRange+ mR+ (nameAsp Module)+ where+ (ms, m) = initLast1 n ns+ mR = Just $+ applyWhen isTopLevelModule P.beginningOfFile $+ A.nameBindingSite m++-- This was Highlighting.Generate.nameToFile:+-- | Converts names to suitable 'File's.+hiliteCName+ :: [C.Name]+ -- ^ The name qualifier (may be empty).+ -> C.Name -- ^ The base name.+ -> Range+ -- ^ The 'Range' of the name in its fixity declaration (if any).+ -> Maybe Range+ -- ^ The definition site of the name. The calculated+ -- meta information is extended with this information, if possible.+ -> (Bool -> Aspects)+ -- ^ Meta information to be associated with the name.+ -- The argument is 'True' iff the name is an operator.+ -> Hiliter+hiliteCName xs x fr mR asp = do+ env <- ask+ -- We don't care if we get any funny ranges.+ if all (== Just (hleCurrentModuleName env)) moduleNames+ then pure $+ frFile <>+ H.singleton (rToR rs) (aspects { definitionSite = mFilePos })+ else mempty+ where+ aspects = asp $ C.isOperator x+ moduleNames = mapMaybe (P.rangeModule' . getRange) (x : xs)+ frFile = H.singleton (rToR fr) $+ aspects { definitionSite = notHere <$> mFilePos }+ rs = getRange (x : xs)++ -- The fixity declaration should not get a symbolic anchor.+ notHere d = d { defSiteHere = False }++ mFilePos :: Maybe DefinitionSite+ mFilePos = do+ r <- mR+ P.Pn (Strict.Just f) p _ _ <- P.rStart r+ mod <- P.rangeFileName f+ -- Andreas, 2017-06-16, Issue #2604: Symbolic anchors.+ -- We drop the file name part from the qualifiers, since+ -- this is contained in the html file name already.+ -- We want to get anchors of the form:+ -- @<a name="TopLevelModule.html#LocalModule.NestedModule.identifier">@+ let qualifiers = drop (size mod) xs+ -- For bound variables, we do not create symbolic anchors.+ local = maybe True isLocalAspect $ aspect aspects+ return $ DefinitionSite+ { defSiteModule = mod+ , defSitePos = fromIntegral p+ -- Is our current position the definition site?+ , defSiteHere = r == getRange x+ -- For bound variables etc. we do not create a symbolic anchor name.+ -- Also not for names that include anonymous modules,+ -- otherwise, we do not get unique anchors.+ , defSiteAnchor = if local || C.isNoName x || any Common.isUnderscore qualifiers+ then Nothing+ else Just $ prettyShow $ foldr C.Qual (C.QName x) qualifiers+ }++ -- Is the name a bound variable or similar? If in doubt, yes.+ isLocalAspect :: Aspect -> Bool+ isLocalAspect = \case+ Name (Just kind) _ -> isLocal kind+ _ -> True+ isLocal :: NameKind -> Bool+ isLocal = \case+ Bound -> True+ Generalizable -> True+ Argument -> True+ Constructor{} -> False+ Datatype -> False+ Field -> False+ Function -> False+ Module -> False+ Postulate -> False+ Primitive -> False+ Record -> False+ Macro -> False++-- This was Highlighting.Generate.nameToFileA:+-- | A variant of 'hiliteCName' for qualified abstract names.+hiliteAName+ :: A.QName+ -- ^ The name.+ -> Bool+ -- ^ Should the binding site be included in the file?+ -> (Bool -> Aspects)+ -- ^ Meta information to be associated with the name.+ -- ^ The argument is 'True' iff the name is an operator.+ -> Hiliter+hiliteAName x include asp = do+ currentModule <- asks hleCurrentModuleName+ hiliteCName (concreteQualifier x)+ (concreteBase x)+ (rangeOfFixityDeclaration currentModule)+ (if include then Just $ nameBindingSite x else Nothing)+ asp+ <> notationFile currentModule+ where+ -- TODO: Currently we highlight fixity and syntax declarations by+ -- producing highlighting something like once per occurrence of the+ -- related name(s) in the file of the declaration (and we explicitly+ -- avoid doing this for other files). Perhaps it would be better to+ -- only produce this highlighting once.++ rangeOfFixityDeclaration currentModule =+ if P.rangeModule r == Just currentModule+ then r else noRange+ where+ r = theNameRange $ A.nameFixity $ A.qnameName x++ notationFile currentModule = pure $+ if P.rangeModule (getRange notation) == Just currentModule+ then mconcat $ map genPartFile notation+ else mempty+ where+ notation = theNotation $ A.nameFixity $ A.qnameName x++ boundAspect = nameAsp Bound False++ genPartFile (VarPart r i) = several [rToR r, rToR $ getRange i] boundAspect+ genPartFile (HolePart r i) = several [rToR r, rToR $ getRange i] boundAspect+ genPartFile WildPart{} = mempty+ genPartFile (IdPart x) = H.singleton (rToR $ getRange x) (asp False)++-- * Short auxiliary functions.+---------------------------------------------------------------------------++singleAspect :: HasRange a => Aspect -> a -> Hiliter+singleAspect a x = pure $ H.singleton (rToR $ getRange x) $ parserBased { aspect = Just a }++singleOtherAspect :: HasRange a => OtherAspect -> a -> Hiliter+singleOtherAspect a x = pure $ H.singleton (rToR $ getRange x) $ parserBased { otherAspects = singleton a }++nameAsp' :: Maybe NameKind -> Bool -> Aspects+nameAsp' k isOp = parserBased { aspect = Just $ Name k isOp }++nameAsp :: NameKind -> Bool -> Aspects+nameAsp = nameAsp' . Just++concreteBase :: A.QName -> C.Name+concreteBase = A.nameConcrete . A.qnameName++concreteQualifier :: A.QName -> [C.Name]+concreteQualifier = map A.nameConcrete . A.mnameToList . A.qnameModule
@@ -1,555 +1,814 @@-{-# LANGUAGE CPP, Rank2Types, RelaxedPolyRec #-}---- | Generates data used for precise syntax highlighting.--module Agda.Interaction.Highlighting.Generate- ( generateSyntaxInfo- , generateErrorInfo- , Agda.Interaction.Highlighting.Generate.tests- )- where--import Agda.Interaction.FindFile-import Agda.Interaction.Highlighting.Precise hiding (tests)-import Agda.Interaction.Highlighting.Range hiding (tests)-import qualified Agda.TypeChecking.Errors as E-import Agda.TypeChecking.MetaVars (isBlockedTerm)-import Agda.TypeChecking.Monad.Options (reportSLn)-import Agda.TypeChecking.Monad- hiding (MetaInfo, Primitive, Constructor, Record, Function, Datatype)-import qualified Agda.TypeChecking.Monad as M-import qualified Agda.TypeChecking.Reduce as R-import qualified Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Common as SC-import qualified Agda.Syntax.Concrete as C-import qualified Agda.Syntax.Info as SI-import qualified Agda.Syntax.Internal as I-import qualified Agda.Syntax.Literal as L-import qualified Agda.Syntax.Parser as Pa-import qualified Agda.Syntax.Parser.Tokens as T-import qualified Agda.Syntax.Position as P-import qualified Agda.Syntax.Scope.Base as S-import qualified Agda.Syntax.Translation.ConcreteToAbstract as CA-import Agda.Utils.List-import Agda.Utils.TestHelpers-import Control.Monad-import Control.Monad.Trans-import Control.Monad.State-import Control.Applicative-import Data.Monoid-import Data.Function-import Agda.Utils.Generics-import Agda.Utils.FileName-import Data.Map (Map)-import qualified Data.Map as Map-import Data.Maybe-import Data.Sequence (Seq, (><))-import Data.List ((\\), isPrefixOf)-import qualified Data.Sequence as Seq-import qualified Data.Foldable as Fold (toList, fold, foldMap)--import Agda.Utils.Impossible-#include "../../undefined.h"---- | Generates syntax highlighting information for an error,--- represented as a range and an optional string. The error range is--- completed so that there are no gaps in it.------ Nothing is generated unless the file name component of the range is--- defined.--generateErrorInfo :: P.Range -> Maybe String -> Maybe HighlightingInfo-generateErrorInfo r s =- case P.rStart r of- Nothing -> Nothing- Just (P.Pn { P.srcFile = Nothing }) -> Nothing- Just (P.Pn { P.srcFile = Just f, P.posPos = p }) ->- Just $ compress $ generateErrorFile r s---- | Generates syntax highlighting information for an error,--- represented as a range and an optional string. The error range is--- completed so that there are no gaps in it.--generateErrorFile :: P.Range -> Maybe String -> File-generateErrorFile r s =- several (rToR $ P.continuousPerLine r)- (mempty { otherAspects = [Error]- , note = s- })---- | Generates syntax highlighting information.--generateSyntaxInfo- :: AbsolutePath -- ^ The module to highlight.- -> Maybe TCErr -- ^ 'Nothing' if the module has been- -- successfully type checked (perhaps- -- with warnings), otherwise the- -- offending error.- --- -- Precondition: The range of the error- -- must match the file name given in the- -- previous argument.- -> CA.TopLevelInfo -- ^ The abstract syntax of the module.- -> [M.TerminationError] -- ^ Termination checking problems.- -> TCM HighlightingInfo-generateSyntaxInfo file mErr top termErrs = do- reportSLn "import.iface.create" 15 $- "Generating syntax info for " ++ filePath file ++ ' ' : maybe "(No TCErr)" (const "(with TCErr)") mErr ++ "."-- M.withScope_ (CA.insideScope top) $ M.ignoreAbstractMode $ do- modMap <- sourceToModule- tokens <- liftIO $ Pa.parseFile' Pa.tokensParser file- kinds <- nameKinds mErr decls- let nameInfo = mconcat $ map (generate modMap file kinds)- (Fold.toList names)- -- Constructors are only highlighted after type checking, since they- -- can be overloaded.- constructorInfo <- case mErr of- Nothing -> generateConstructorInfo modMap file kinds decls- Just _ -> return mempty- metaInfo <- case mErr of- Nothing -> computeUnsolvedMetaWarnings- Just _ -> return mempty- errorInfo <- case mErr of- Nothing -> return mempty- Just e -> let r = P.getRange e in- case P.rStart r of- Just p | P.srcFile p == Just file ->- generateErrorFile r . Just <$> E.prettyError e- _ -> __IMPOSSIBLE__- -- theRest needs to be placed before nameInfo here since record- -- field declarations contain QNames. constructorInfo also needs- -- to be placed before nameInfo since, when typechecking is done,- -- constructors are included in both lists. Finally tokInfo is- -- placed last since token highlighting is more crude than the- -- others.- return $ compress $ mconcat- [ errorInfo- , constructorInfo- , theRest modMap- , nameInfo- , metaInfo- , termInfo- , tokInfo tokens- ]- where- decls = CA.topLevelDecls top-- -- Converts an aspect and a range to a file.- aToF a r = several (rToR r) (mempty { aspect = Just a })-- tokInfo = Fold.foldMap tokenToFile- where- tokenToFile :: T.Token -> File- tokenToFile (T.TokSetN (i, _)) = aToF PrimitiveType (P.getRange i)- tokenToFile (T.TokKeyword T.KwSet i) = aToF PrimitiveType (P.getRange i)- tokenToFile (T.TokKeyword T.KwProp i) = aToF PrimitiveType (P.getRange i)- tokenToFile (T.TokKeyword T.KwForall i) = aToF Symbol (P.getRange i)- tokenToFile (T.TokKeyword _ i) = aToF Keyword (P.getRange i)- tokenToFile (T.TokSymbol _ i) = aToF Symbol (P.getRange i)- tokenToFile (T.TokLiteral (L.LitInt r _)) = aToF Number r- tokenToFile (T.TokLiteral (L.LitFloat r _)) = aToF Number r- tokenToFile (T.TokLiteral (L.LitString r _)) = aToF String r- tokenToFile (T.TokLiteral (L.LitChar r _)) = aToF String r- tokenToFile (T.TokLiteral (L.LitQName r _)) = aToF String r- tokenToFile (T.TokComment (i, _)) = aToF Comment (P.getRange i)- tokenToFile (T.TokTeX (i, _)) = aToF Comment (P.getRange i)- tokenToFile (T.TokId {}) = mempty- tokenToFile (T.TokQId {}) = mempty- tokenToFile (T.TokString {}) = mempty- tokenToFile (T.TokDummy {}) = mempty- tokenToFile (T.TokEOF {}) = mempty-- termInfo = functionDefs `mappend` callSites- where- m = mempty { otherAspects = [TerminationProblem] }- functionDefs = Fold.foldMap (\x -> several (rToR $ bindingSite x) m) $- concatMap M.termErrFunctions termErrs- callSites = Fold.foldMap (\r -> several (rToR r) m) $- concatMap (map M.callInfoRange . M.termErrCalls) termErrs-- -- All names mentioned in the syntax tree (not bound variables).- names = everything' (><) (Seq.empty `mkQ` getName- `extQ` getAmbiguous)- decls- where- getName :: A.QName -> Seq A.AmbiguousQName- getName n | isPrefixOf extendlambdaname $ show $ A.qnameName n = mempty- | otherwise = Seq.singleton (A.AmbQ [n])--- getAmbiguous :: A.AmbiguousQName -> Seq A.AmbiguousQName- getAmbiguous = Seq.singleton-- -- Bound variables, dotted patterns, record fields, module names,- -- the "as" and "to" symbols.- theRest modMap = everything' mappend query decls- where- query :: GenericQ File- query = mempty `mkQ`- getFieldDecl `extQ`- getVarAndField `extQ`- getLet `extQ`- getLam `extQ`- getTyped `extQ`- getPattern `extQ`- getModuleName `extQ`- getModuleInfo-- bound n = nameToFile modMap file []- (A.nameConcrete n)- (\isOp -> mempty { aspect = Just $ Name (Just Bound) isOp })- (Just $ A.nameBindingSite n)- field m n = nameToFile modMap file m n- (\isOp -> mempty { aspect = Just $ Name (Just Field) isOp })- Nothing- asName n = nameToFile modMap file []- n- (\isOp -> mempty { aspect = Just $ Name (Just Module) isOp })- Nothing- mod isTopLevelModule n =- nameToFile modMap file []- (A.nameConcrete n)- (\isOp -> mempty { aspect = Just $ Name (Just Module) isOp })- (Just $ (if isTopLevelModule then P.beginningOfFile else id)- (A.nameBindingSite n))-- getVarAndField :: A.Expr -> File- getVarAndField (A.Var x) = bound x- getVarAndField (A.Rec _ fs) = mconcat $ map (field [] . fst) fs- getVarAndField _ = mempty-- getLet :: A.LetBinding -> File- getLet (A.LetBind _ _ x _ _) = bound x- getLet A.LetApply{} = mempty- getLet A.LetOpen{} = mempty-- getLam :: A.LamBinding -> File- getLam (A.DomainFree _ _ x) = bound x- getLam (A.DomainFull {}) = mempty-- getTyped :: A.TypedBinding -> File- getTyped (A.TBind _ xs _) = mconcat $ map bound xs- getTyped (A.TNoBind {}) = mempty-- getPattern :: A.Pattern -> File- getPattern (A.VarP x) = bound x- getPattern (A.AsP _ x _) = bound x- getPattern (A.DotP pi _) =- several (rToR $ P.getRange pi)- (mempty { otherAspects = [DottedPattern] })- getPattern _ = mempty-- getFieldDecl :: A.Declaration -> File- getFieldDecl (A.RecDef _ _ _ _ _ fs) = Fold.foldMap extractField fs- where- extractField (A.ScopedDecl _ ds) = Fold.foldMap extractField ds- extractField (A.Field _ x _) = field (concreteQualifier x)- (concreteBase x)- extractField _ = mempty- getFieldDecl _ = mempty-- getModuleName :: A.ModuleName -> File- getModuleName m@(A.MName { A.mnameToList = xs }) =- mconcat $ map (mod isTopLevelModule) xs- where- isTopLevelModule =- case catMaybes $- map (join .- fmap P.srcFile .- P.rStart .- A.nameBindingSite) xs of- f : _ -> Map.lookup f modMap ==- Just (C.toTopLevelModuleName $ A.mnameToConcrete m)- [] -> False-- getModuleInfo :: SI.ModuleInfo -> File- getModuleInfo (SI.ModuleInfo { SI.minfoAsTo = asTo- , SI.minfoAsName = name }) =- aToF Symbol asTo `mappend` maybe mempty asName name---- | A function mapping names to the kind of name they stand for.--type NameKinds = A.QName -> Maybe NameKind---- | Builds a 'NameKinds' function.--nameKinds :: Maybe TCErr -- ^ 'Nothing' if type checking completed- -- successfully.- -> [A.Declaration]- -> TCM NameKinds-nameKinds mErr decls = do- imported <- fix . stImports <$> get- local <- case mErr of- Nothing -> fix . stSignature <$> get- Just _ -> return $- -- Traverses the syntax tree and constructs a map from qualified- -- names to name kinds. TODO: Handle open public.- everything' union (Map.empty `mkQ` getDecl) decls- let merged = Map.union local imported- return (\n -> Map.lookup n merged)- where- fix = Map.map (defnToNameKind . theDef) . sigDefinitions-- -- | The 'M.Axiom' constructor is used to represent various things- -- which are not really axioms, so when maps are merged 'Postulate's- -- are thrown away whenever possible. The 'getDef' and 'getDecl'- -- functions below can return several explanations for one qualified- -- name; the 'Postulate's are bogus.- union = Map.unionWith dropPostulates- where- dropPostulates Postulate k = k- dropPostulates k _ = k-- defnToNameKind :: Defn -> NameKind- defnToNameKind (M.Axiom {}) = Postulate- defnToNameKind (M.Function {}) = Function- defnToNameKind (M.Datatype {}) = Datatype- defnToNameKind (M.Record {}) = Record- defnToNameKind (M.Constructor { M.conInd = i }) = Constructor i- defnToNameKind (M.Primitive {}) = Primitive-- getAxiomName :: A.Declaration -> A.QName- getAxiomName (A.Axiom _ _ q _) = q- getAxiomName _ = __IMPOSSIBLE__-- getDecl :: A.Declaration -> Map A.QName NameKind- getDecl (A.Axiom _ _ q _) = Map.singleton q Postulate- getDecl (A.Field _ q _) = Map.singleton q Function- -- Note that the name q can be used both as a field name and as a- -- projection function. Highlighting of field names is taken care- -- of by "theRest" above, which does not use NameKinds.- getDecl (A.Primitive _ q _) = Map.singleton q Primitive- getDecl (A.Mutual {}) = Map.empty- getDecl (A.Section {}) = Map.empty- getDecl (A.Apply {}) = Map.empty- getDecl (A.Import {}) = Map.empty- getDecl (A.Pragma {}) = Map.empty- getDecl (A.ScopedDecl {}) = Map.empty- getDecl (A.Open {}) = Map.empty- getDecl (A.FunDef _ q _) = Map.singleton q Function- getDecl (A.DataSig _ q _ _) = Map.singleton q Datatype- getDecl (A.DataDef _ q _ cs) = Map.singleton q Datatype `union`- (Map.unions $- map (\q -> Map.singleton q (Constructor SC.Inductive)) $- map getAxiomName cs)- getDecl (A.RecSig _ q _ _) = Map.singleton q Record- getDecl (A.RecDef _ q c _ _ _) = Map.singleton q Record `union`- case c of- Nothing -> Map.empty- Just q ->- Map.singleton q (Constructor SC.Inductive)---- | Generates syntax highlighting information for all constructors--- occurring in patterns and expressions in the given declarations.------ This function should only be called after type checking.--- Constructors can be overloaded, and the overloading is resolved by--- the type checker.--generateConstructorInfo- :: SourceToModule -- ^ Maps source file paths to module names.- -> AbsolutePath -- ^ The module to highlight.- -> NameKinds- -> [A.Declaration]- -> TCM File-generateConstructorInfo modMap file kinds decls = do- -- Extract all defined names from the declaration list.- let names = Fold.toList $ Fold.foldMap A.allNames decls-- -- Look up the corresponding declarations in the internal syntax.- defMap <- M.sigDefinitions <$> M.getSignature- let defs = catMaybes $ map (flip Map.lookup defMap) names-- -- Instantiate meta variables.- clauses <- R.instantiateFull $ concatMap M.defClauses defs- types <- R.instantiateFull $ map defType defs-- -- Find all constructors occurring in type signatures or clauses- -- within the given declarations.- constrs <- everything' (liftM2 (><)) query (types, clauses)-- -- Return suitable syntax highlighting information.- return $ Fold.fold $ fmap (generate modMap file kinds . mkAmb) constrs- where- mkAmb q = A.AmbQ [q]-- query :: GenericQ (TCM (Seq A.QName))- query = return mempty `mkQ`- getConstructor `extQ`- getConstructorP-- getConstructor :: I.Term -> TCM (Seq A.QName)- getConstructor (I.Con q _) = return $ Seq.singleton q- getConstructor (I.Def c _)- | fmap P.srcFile (P.rStart (P.getRange c)) == Just (Just file)- = retrieveCoconstructor c- getConstructor _ = return Seq.empty-- getConstructorP :: I.Pattern -> TCM (Seq A.QName)- getConstructorP (I.ConP q _ _) = return $ Seq.singleton q- getConstructorP _ = return Seq.empty-- retrieveCoconstructor :: A.QName -> TCM (Seq A.QName)- retrieveCoconstructor c = do- def <- getConstInfo c- case defDelayed def of- -- Not a coconstructor.- NotDelayed -> return Seq.empty-- Delayed -> do- clauses <- R.instantiateFull $ defClauses def- case clauses of- [I.Clause{ I.clauseBody = body }] -> case getRHS body of- Just (I.Con c args) -> do- s <- everything' (liftM2 (><)) query args- return $ Seq.singleton c >< s-- -- The meta variable could not be instantiated.- Just (I.MetaV {}) -> return Seq.empty-- _ -> __IMPOSSIBLE__-- _ -> __IMPOSSIBLE__- where- getRHS (I.Body v) = Just v- getRHS I.NoBody = Nothing- getRHS (I.Bind b) = getRHS (I.unAbs b)---- | Generates syntax highlighting information for unsolved meta--- variables.--computeUnsolvedMetaWarnings :: TCM File-computeUnsolvedMetaWarnings = do- is <- getInteractionMetas-- -- We don't want to highlight blocked terms, since- -- * there is always at least one proper meta responsible for the blocking- -- * in many cases the blocked term covers the highlighting for this meta- let notBlocked m = not <$> isBlockedTerm m- ms <- filterM notBlocked =<< getOpenMetas-- rs <- mapM getMetaRange (ms \\ is)- return $ several (concatMap (rToR . P.continuousPerLine) rs)- $ mempty { otherAspects = [UnsolvedMeta] }---- | Generates a suitable file for a possibly ambiguous name.--generate :: SourceToModule- -- ^ Maps source file paths to module names.- -> AbsolutePath- -- ^ The module to highlight.- -> NameKinds- -> A.AmbiguousQName- -> File-generate modMap file kinds (A.AmbQ qs) =- mconcat $ map (\q -> nameToFileA modMap file q include m) qs- where- ks = map kinds qs- kind = case (allEqual ks, ks) of- (True, Just k : _) -> Just k- _ -> Nothing- -- Note that all names in an AmbiguousQName should have the same- -- concrete name, so either they are all operators, or none of- -- them are.- m isOp = mempty { aspect = Just $ Name kind isOp }- include = allEqual (map bindingSite qs)---- | Converts names to suitable 'File's.--nameToFile :: SourceToModule- -- ^ Maps source file paths to module names.- -> AbsolutePath- -- ^ The file name of the current module. Used for- -- consistency checking.- -> [C.Name]- -- ^ The name qualifier (may be empty).- -> C.Name- -- ^ The base name.- -> (Bool -> MetaInfo)- -- ^ Meta information to be associated with the name.- -- The argument is 'True' iff the name is an operator.- -> Maybe P.Range- -- ^ The definition site of the name. The calculated- -- meta information is extended with this information,- -- if possible.- -> File-nameToFile modMap file xs x m mR =- -- We don't care if we get any funny ranges.- if all (== Just file) fileNames then- several rs' ((m isOp) { definitionSite = mFilePos })- else- mempty- where- fileNames = catMaybes $ map (fmap P.srcFile . P.rStart . P.getRange) (x : xs)- (rs, isOp) = getRanges x- rs' = rs ++ concatMap (fst . getRanges) xs- mFilePos = do- r <- mR- P.Pn { P.srcFile = Just f, P.posPos = p } <- P.rStart r- mod <- Map.lookup f modMap- return (mod, toInteger p)---- | A variant of 'nameToFile' for qualified abstract names.--nameToFileA :: SourceToModule- -- ^ Maps source file paths to module names.- -> AbsolutePath- -- ^ The file name of the current module. Used for- -- consistency checking.- -> A.QName- -- ^ The name.- -> Bool- -- ^ Should the binding site be included in the file?- -> (Bool -> MetaInfo)- -- ^ Meta information to be associated with the name.- -- ^ The argument is 'True' iff the name is an operator.- -> File-nameToFileA modMap file x include m =- nameToFile modMap- file- (concreteQualifier x)- (concreteBase x)- m- (if include then Just $ bindingSite x else Nothing)--concreteBase = A.nameConcrete . A.qnameName-concreteQualifier = map A.nameConcrete . A.mnameToList . A.qnameModule-bindingSite = A.nameBindingSite . A.qnameName---- | Like 'everything', but modified so that it does not descend into--- everything.--everything' :: (r -> r -> r) -> GenericQ r -> GenericQ r-everything' (+) = everythingBut- (+)- (False `mkQ` isString- `extQ` isAQName `extQ` isAName `extQ` isCName- `extQ` isScope `extQ` isMap1 `extQ` isMap2- `extQ` isAmbiguous)- where- isString :: String -> Bool- isAQName :: A.QName -> Bool- isAName :: A.Name -> Bool- isCName :: C.Name -> Bool- isScope :: S.ScopeInfo -> Bool- isMap1 :: Map A.QName A.QName -> Bool- isMap2 :: Map A.ModuleName A.ModuleName -> Bool- isAmbiguous :: A.AmbiguousQName -> Bool-- isString = const True- isAQName = const True- isAName = const True- isCName = const True- isScope = const True- isMap1 = const True- isMap2 = const True- isAmbiguous = const True----------------------------------------------------------------------------- All tests---- | All the properties.--tests :: IO Bool-tests = runTests "Agda.Interaction.Highlighting.Generate" []++-- | Generates data used for precise syntax highlighting.++-- {-# OPTIONS_GHC -fwarn-unused-imports #-} -- Semigroup import obsolete in later ghcs+-- {-# OPTIONS_GHC -fwarn-unused-binds #-}++module Agda.Interaction.Highlighting.Generate+ ( Level(..)+ , generateAndPrintSyntaxInfo+ , generateTokenInfo, generateTokenInfoFromSource+ , generateTokenInfoFromString+ , printSyntaxInfo+ , printErrorInfo, errorHighlighting+ , printUnsolvedInfo+ , printHighlightingInfo+ , highlightAsTypeChecked+ , highlightWarning, warningHighlighting+ , computeUnsolvedInfo+ , storeDisambiguatedConstructor, storeDisambiguatedProjection+ , disambiguateRecordFields+ ) where++import Prelude hiding (null)++import Control.Monad++import qualified Data.Foldable as Fold+import qualified Data.Map as Map+import Data.Maybe+import Data.List ((\\))+import qualified Data.List as List+import qualified Data.IntMap as IntMap+import Data.HashMap.Strict (HashMap)+import qualified Data.HashMap.Strict as HMap+import Data.Semigroup (sconcat)+import Data.Sequence (Seq)+import qualified Data.Set as Set+import qualified Data.Text.Lazy as Text++import Agda.Interaction.Response+ ( RemoveTokenBasedHighlighting( KeepHighlighting ) )+import Agda.Interaction.Highlighting.Precise as H+import Agda.Interaction.Highlighting.Range+ (rToR, rangeToRange, overlappings, Ranges)+import Agda.Interaction.Highlighting.FromAbstract+import Agda.Interaction.Options.Types (optMdOnlyAgdaBlocks)++import qualified Agda.TypeChecking.Errors as TCM+import Agda.TypeChecking.MetaVars (isBlockedTerm, hasTwinMeta)+import Agda.TypeChecking.Monad+ hiding (ModuleInfo, MetaInfo, Primitive, Constructor, Record, Function, Datatype)+import qualified Agda.TypeChecking.Monad as TCM+import qualified Agda.TypeChecking.Monad.Base.Warning as W+import qualified Agda.TypeChecking.Pretty as TCM+import Agda.TypeChecking.Positivity.Occurrence (Occurrence(..))+import Agda.TypeChecking.Positivity.Warnings+import Agda.TypeChecking.Warnings ( raiseWarningsOnUsage )++import qualified Agda.Syntax.Abstract as A+import Agda.Syntax.Abstract.Name (nameBindingSite)+import Agda.Syntax.Concrete.Definitions as W ( DeclarationWarning(..), DeclarationWarning'(..) )+import Agda.Syntax.Common (Induction(..), pattern Ranged)+import qualified Agda.Syntax.Common.Aspect as Aspect+import qualified Agda.Syntax.Concrete.Name as C+import qualified Agda.Syntax.Internal as I+import qualified Agda.Syntax.Literal as L+import qualified Agda.Syntax.Parser as Pa+import qualified Agda.Syntax.Parser.Tokens as T+import qualified Agda.Syntax.Position as P+import Agda.Syntax.Position+ (RangeFile, Range, HasRange, getRange, noRange)+import Agda.Syntax.TopLevelModuleName++import Agda.Syntax.Scope.Base ( WithKind(..) )+import Agda.Syntax.Abstract.Views ( KName, declaredNames )++import Agda.Utils.FileName+import Agda.Utils.List ( caseList, last1 )+import Agda.Utils.List1 ( List1 )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.List2 ( List2 )+import qualified Agda.Utils.List2 as List2+import Agda.Utils.Maybe+import qualified Agda.Utils.Maybe.Strict as Strict+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton++import Agda.Utils.Impossible++-- | Highlighting levels.++data Level+ = Full+ -- ^ Full highlighting. Should only be used after typechecking has+ -- completed successfully.+ | Partial+ -- ^ Highlighting without disambiguation of overloaded+ -- constructors.++-- | Highlight a warning.+-- We do not generate highlighting for unsolved metas and+-- constraints, as that gets handled in bulk after typechecking.+highlightWarning :: TCWarning -> TCM ()+highlightWarning tcwarn = do+ let h = convert $ warningHighlighting' False tcwarn+ -- Highlighting for warnings coming from the Happy parser is placed+ -- together with token highlighting.+ case tcWarning tcwarn of+ ParseWarning{} -> modifyTCLens stTokens (h <>)+ _ -> modifyTCLens stSyntaxInfo (h <>)+ ifTopLevelAndHighlightingLevelIs NonInteractive $+ printHighlightingInfo KeepHighlighting h++-- | Generate syntax highlighting information for the given+-- declaration, and (if appropriate) print it. If the boolean is+-- 'True', then the state is additionally updated with the new+-- highlighting info (in case of a conflict new info takes precedence+-- over old info).+--+-- The procedure makes use of some of the highlighting info+-- corresponding to 'stTokens' (that corresponding to the interval+-- covered by the declaration). If the boolean is 'True', then this+-- highlighting info is additionally removed from the data structure+-- that 'stTokens' refers to.++generateAndPrintSyntaxInfo+ :: A.Declaration+ -- ^ Declaration to highlight.+ -> Level+ -- ^ Amount of highlighting.+ -> Bool+ -- ^ Update the state?+ -> TCM ()+generateAndPrintSyntaxInfo decl _ _ | null $ getRange decl = return ()+generateAndPrintSyntaxInfo decl hlLevel updateState = do+ top <- fromMaybe __IMPOSSIBLE__ <$> currentTopLevelModule++ reportSDoc "import.iface.create" 15 $+ TCM.fwords+ ("Generating syntax info for the following declaration " +++ case hlLevel of+ Full {} -> "(final):"+ Partial{} -> "(first approximation):")+ TCM.$$+ TCM.prettyA decl++ ignoreAbstractMode $ do+ kinds <- nameKinds hlLevel decl++ -- After the code has been type checked more information may be+ -- available for overloaded constructors, and+ -- @generateConstructorInfo@ takes advantage of this information.+ -- Note, however, that highlighting for overloaded constructors is+ -- included also in @nameInfo@.+ constructorInfo <- case hlLevel of+ Full{} -> generateConstructorInfo top kinds decl+ _ -> return mempty++ -- Main source of scope-checker generated highlighting:+ let nameInfo = runHighlighter top kinds decl++ reportSDoc "highlighting.warning" 60 $ TCM.hcat+ [ "current path = "+ , Strict.maybe "(nothing)" (return . pretty) =<< do+ P.rangeFile <$> viewTC eRange+ ]++ -- Highlighting from the lexer and Happy parser:+ (curTokens, otherTokens) <-+ insideAndOutside (rangeToRange (getRange decl)) <$> useTC stTokens++ -- @constructorInfo@ needs+ -- to be placed before @nameInfo@ since, when typechecking is done,+ -- constructors are included in both lists. Finally the token+ -- information is placed last since token highlighting is more+ -- crude than the others.+ let syntaxInfo = convert (constructorInfo <> nameInfo)+ <>+ curTokens++ when updateState $ do+ stSyntaxInfo `modifyTCLens` mappend syntaxInfo+ stTokens `setTCLens` otherTokens++ ifTopLevelAndHighlightingLevelIs NonInteractive $+ printHighlightingInfo KeepHighlighting syntaxInfo++-- | Generate and return the syntax highlighting information for the+-- tokens in the given file.++generateTokenInfo :: AbsolutePath -> TCM HighlightingInfo+generateTokenInfo file =+ generateTokenInfoFromSource rf . Text.unpack =<<+ runPM (Pa.readFilePM rf)+ where+ -- Note the use of Nothing here. The file might not even parse, but+ -- it should still be possible to obtain token-based highlighting+ -- information. The top-level module names seem to be *mostly*+ -- unused, but one cannot use __IMPOSSIBLE__ instead of Nothing,+ -- because the top-level module names are used by interleaveRanges,+ -- which is used by parseLiterateWithComments, which is used by+ -- generateTokenInfoFromSource.+ rf = P.mkRangeFile file Nothing++-- | Generate and return the syntax highlighting information for the+-- tokens in the given file.++generateTokenInfoFromSource+ :: RangeFile+ -- ^ The module to highlight.+ -> String+ -- ^ The file contents. Note that the file is /not/ read from+ -- disk.+ -> TCM HighlightingInfo+generateTokenInfoFromSource file input = do+ mdOnlyAgdaBlocks <- optMdOnlyAgdaBlocks <$> commandLineOptions+ runPM $ tokenHighlighting . fst . fst <$>+ Pa.parseFile mdOnlyAgdaBlocks Pa.tokensParser file input++-- | Generate and return the syntax highlighting information for the+-- tokens in the given string, which is assumed to correspond to the+-- given range.++generateTokenInfoFromString :: Range -> String -> TCM HighlightingInfo+generateTokenInfoFromString r _ | r == noRange = return mempty+generateTokenInfoFromString r s = do+ runPM $ tokenHighlighting . fst <$>+ Pa.parsePosString Pa.tokensParser p s+ where+ Just p = P.rStart r++-- | Compute syntax highlighting for the given tokens.+tokenHighlighting :: [T.Token] -> HighlightingInfo+tokenHighlighting = convert . mconcat . map tokenToHI+ where+ -- Converts an aspect and a range to a file.+ aToF a r = H.singleton (rToR r) (mempty { aspect = Just a })++ tokenToHI :: T.Token -> HighlightingInfoBuilder+ tokenToHI (T.TokKeyword T.KwForall i) = aToF Symbol (getRange i)+ tokenToHI (T.TokKeyword T.KwREWRITE _) = mempty -- #4361, REWRITE is not always a Keyword+ tokenToHI (T.TokKeyword _ i) = aToF Keyword (getRange i)+ tokenToHI (T.TokSymbol T.SymQuestionMark i) = aToF Hole (getRange i)+ tokenToHI (T.TokSymbol _ i) = aToF Symbol (getRange i)+ tokenToHI (T.TokComment (i, _)) = aToF Comment (getRange i)+ tokenToHI (T.TokTeX (i, _)) = aToF Background (getRange i)+ tokenToHI (T.TokMarkup (i, _)) = aToF Markup (getRange i)+ tokenToHI (T.TokId {}) = mempty+ tokenToHI (T.TokQId {}) = mempty+ tokenToHI (T.TokString (i,s)) = aToF Pragma (getRange i)+ tokenToHI (T.TokDummy {}) = mempty+ tokenToHI (T.TokEOF {}) = mempty+ tokenToHI (T.TokQual cls _ i) = case cls of+ T.QualDo -> aToF Keyword (getRange i)+ T.QualOpenIdiom{} -> aToF Symbol (getRange i)+ T.QualEmptyIdiom{} -> aToF Symbol (getRange i)+ tokenToHI (T.TokLiteral (Ranged r l)) = case l of+ L.LitNat{} -> aToF Number r+ L.LitWord64{} -> aToF Number r+ L.LitFloat{} -> aToF Number r+ L.LitString{} -> aToF String r+ L.LitChar{} -> aToF String r+ L.LitQName{} -> aToF String r+ L.LitMeta{} -> aToF String r++-- | Builds a 'NameKinds' function.++nameKinds :: Level+ -- ^ This should only be @'Full'@ if+ -- type-checking completed successfully (without any+ -- errors).+ -> A.Declaration+ -> TCM NameKinds+nameKinds hlLevel decl = do+ imported <- useTC $ stImports . sigDefinitions+ local <- case hlLevel of+ Full{} -> useTC $ stSignature . sigDefinitions+ _ -> return HMap.empty+ impPatSyns <- useTC stPatternSynImports+ locPatSyns <- case hlLevel of+ Full{} -> useTC stPatternSyns+ _ -> return empty+ -- Traverses the syntax tree and constructs a map from qualified+ -- names to name kinds. TODO: Handle open public.+ let syntax :: NameKindMap+ syntax = runBuilder (declaredNames decl :: NameKindBuilder) HMap.empty+ return $ \ n -> unionsMaybeWith mergeNameKind+ [ TCM.defnToNameKind . theDef <$> HMap.lookup n local+ , con <$ Map.lookup n locPatSyns+ , TCM.defnToNameKind . theDef <$> HMap.lookup n imported+ , con <$ Map.lookup n impPatSyns+ , HMap.lookup n syntax+ ]+ where++ con :: NameKind+ con = Constructor Inductive++-- | The 'TCM.Axiom' constructor is used to represent various things+-- which are not really axioms, so when maps are merged 'Postulate's+-- are thrown away whenever possible. The 'declaredNames' function+-- below can return several explanations for one qualified name; the+-- 'Postulate's are bogus.+mergeNameKind :: NameKind -> NameKind -> NameKind+mergeNameKind Postulate k = k+mergeNameKind _ Macro = Macro -- If the abstract syntax says macro, it's a macro.+mergeNameKind k _ = k++-- Auxiliary types for @nameKinds@ generation++type NameKindMap = HashMap A.QName NameKind+data NameKindBuilder = NameKindBuilder+ { runBuilder :: NameKindMap -> NameKindMap+ }++instance Semigroup (NameKindBuilder) where+ NameKindBuilder f <> NameKindBuilder g = NameKindBuilder $ f . g++instance Monoid (NameKindBuilder) where+ mempty = NameKindBuilder id+ mappend = (<>)++instance Singleton KName NameKindBuilder where+ singleton (WithKind k q) = NameKindBuilder $+ HMap.insertWith mergeNameKind q $ kindOfNameToNameKind k++instance Collection KName NameKindBuilder++-- | Generates syntax highlighting information for all constructors+-- occurring in patterns and expressions in the given declaration.+--+-- This function should only be called after type checking.+-- Constructors can be overloaded, and the overloading is resolved by+-- the type checker.++generateConstructorInfo+ :: TopLevelModuleName+ -- ^ The module to highlight.+ -> NameKinds+ -> A.Declaration+ -> TCM HighlightingInfoBuilder+generateConstructorInfo top kinds decl = do++ -- Get boundaries of current declaration.+ -- @noRange@ should be impossible, but in case of @noRange@+ -- it makes sense to return mempty.+ caseList (P.rangeIntervals $ getRange decl)+ (return mempty) $ \ i is -> do+ let start = fromIntegral $ P.posPos $ P.iStart i+ end = fromIntegral $ P.posPos $ P.iEnd $ last1 i is++ -- Get all disambiguated names that fall within the range of decl.+ m0 <- useTC stDisambiguatedNames+ let (_, m1) = IntMap.split (pred start) m0+ (m2, _) = IntMap.split end m1+ constrs = IntMap.elems m2++ -- Return suitable syntax highlighting information.+ return $ foldMap (runHighlighter top kinds) constrs++printSyntaxInfo :: Range -> TCM ()+printSyntaxInfo r = do+ syntaxInfo <- useTC stSyntaxInfo+ ifTopLevelAndHighlightingLevelIs NonInteractive $+ printHighlightingInfo KeepHighlighting+ (restrictTo (rangeToRange r) syntaxInfo)++-- | Prints syntax highlighting info for an error.++printErrorInfo :: TCErr -> TCM ()+printErrorInfo e =+ printHighlightingInfo KeepHighlighting . convert =<<+ errorHighlighting e++-- | Generate highlighting for error.++errorHighlighting :: TCErr -> TCM HighlightingInfoBuilder+errorHighlighting e = mconcat+ [ extraErrorHighlighting e+ , errorHighlighting' (getRange e) <$> TCM.renderError e+ ]++errorHighlighting'+ :: Range -- ^ Error range.+ -> String -- ^ Error message for tooltip.+ -> HighlightingInfoBuilder+errorHighlighting' r s = mconcat+ [ -- Erase previous highlighting.+ H.singleton (rToR $ P.continuousPerLine r) mempty+ , -- Print new highlighting.+ H.singleton (rToR r)+ $ parserBased { otherAspects = Set.singleton Error+ , note = s+ }+ ]++-- | Some errors point to things out of the errorneous expression/declaration,+-- so we might to highlight these things as well.+extraErrorHighlighting :: TCErr -> TCM HighlightingInfoBuilder+extraErrorHighlighting = \case+ TypeError _ _ cl ->+ case clValue cl of+ -- Andreas, 2025-09-15.+ -- The identifier that would be shadowed by the clashing definition+ -- is highlighted as dead code.+ -- (Not sure how good this is.)+ ClashingDefinition _ y _ -> return $ deadcodeHighlighting $ I.nameBindingSite $ clashingQName y+ ShadowedModule x ms -> deadcodeHighlighting . snd <$> TCM.prettyShadowedModule x ms+ -- 'prettyShadowedModule' mostly duplicates the work done by @'renderError' ('ShadowedModule' x ms)@+ -- in 'errorHighlighting',+ -- but since throwing an error is a once-in-a-run thing we need not worry.+ _ -> mempty+ _ -> mempty++-- | Highlighting for warnings that are considered fatal.++errorWarningHighlighting :: HasRange a => a -> HighlightingInfoBuilder+errorWarningHighlighting w =+ H.singleton (rToR $ P.continuousPerLine $ getRange w) $+ parserBased { otherAspects = Set.singleton ErrorWarning }+-- errorWarningHighlighting w = errorHighlighting' (getRange w) ""+ -- MonadPretty not available here, so, no tooltip.+ -- errorHighlighting' (getRange w) . render <$> TCM.prettyWarning (tcWarning w)++-- | Generate syntax highlighting for warnings.++warningHighlighting :: TCWarning -> HighlightingInfoBuilder+warningHighlighting = warningHighlighting' True++warningHighlighting' :: Bool -- ^ should we generate highlighting for unsolved metas and constrains?+ -> TCWarning -> HighlightingInfoBuilder+warningHighlighting' b w = case tcWarning w of+ TerminationIssue terrs -> terminationErrorHighlighting terrs+ NotStrictlyPositive d ocs -> positivityErrorHighlighting d ocs+ ConstructorDoesNotFitInData _dataOrRecord c _s1 _s2 _err -> errorWarningHighlighting $+ getRange c `catchNull` getRange w+ CoinductiveEtaRecord _x -> deadcodeHighlighting w+ UnguardedEtaRecordW _x -> errorWarningHighlighting w+ -- #3965 highlight each unreachable clause independently: they+ -- may be interleaved with actually reachable clauses!+ UnreachableClauses _ rs -> foldMap deadcodeHighlighting rs+ CoverageIssue{} -> coverageErrorHighlighting $ getRange w+ CoverageNoExactSplit{} -> catchallHighlighting $ getRange w+ InlineNoExactSplit{} -> catchallHighlighting $ getRange w+ UnsolvedConstraints cs -> if b then constraintsHighlighting [] $ Fold.toList cs else mempty+ UnsolvedMetaVariables rs -> if b then metasHighlighting $ Fold.toList rs else mempty+ AbsurdPatternRequiresAbsentRHS{} -> deadcodeHighlighting w+ DuplicateRecordDirective{} -> deadcodeHighlighting w+ ModuleDoesntExport _ _ _ xs -> foldMap deadcodeHighlighting xs+ DuplicateUsing xs -> foldMap deadcodeHighlighting xs+ FixityInRenamingModule rs -> foldMap deadcodeHighlighting rs+ -- expanded catch-all case to get a warning for new constructors+ CantGeneralizeOverSorts{} -> mempty+ UnsolvedInteractionMetas{} -> mempty+ InteractionMetaBoundaries{} -> mempty+ OldBuiltin{} -> deadcodeHighlighting w+ BuiltinDeclaresIdentifier{} -> mempty+ EmptyRewritePragma{} -> deadcodeHighlighting w+ EmptyWhere{} -> deadcodeHighlighting w+ -- TODO: linearity+ -- FixingQuantity _ q _ -> if null r then cosmeticHighlighting w else deadcodeHighlighting r+ -- where r = getRange q+ FixingRelevance _ q _ -> if null r then cosmeticProblemHighlighting w else deadcodeHighlighting r+ where r = getRange q+ FixingCohesion _ q _ -> if null r then cosmeticProblemHighlighting w else deadcodeHighlighting r+ where r = getRange q+ FixingPolarity _ q _ -> if null r then cosmeticProblemHighlighting w else deadcodeHighlighting r+ where r = getRange q+ IgnoringRew _ q -> if null r then cosmeticProblemHighlighting w else deadcodeHighlighting r+ where r = getRange q+ IllformedAsClause{} -> deadcodeHighlighting w+ UnusedImports m Nothing -> deadcodeHighlighting w+ UnusedImports m xs -> cosmeticProblemHighlighting w <> foldMap deadcodeHighlighting xs+ UselessPragma r _ -> deadcodeHighlighting r+ UselessPublic{} -> deadcodeHighlighting w+ UselessHiding xs -> foldMap deadcodeHighlighting xs+ UselessInline{} -> mempty+ UselessPatternDeclarationForRecord{} -> deadcodeHighlighting w+ UselessTactic{} -> deadcodeHighlighting w+ ClashesViaRenaming _ xs -> foldMap deadcodeHighlighting xs+ -- #4154, TODO: clashing renamings are not dead code, but introduce problems.+ -- Should we have a different color?+ WrongInstanceDeclaration kwr -> instanceProblemHighlighting kwr <> instanceProblemHighlighting w+ InstanceWithExplicitArg kwr _ -> instanceProblemHighlighting kwr <> instanceProblemHighlighting w+ InstanceNoOutputTypeName{} -> instanceProblemHighlighting w+ InstanceArgWithExplicitArg{} -> instanceProblemHighlighting w+ InversionDepthReached{} -> mempty+ -- Andreas, 2020-03-21, issue #4456:+ -- Error warnings that do not have dedicated highlighting+ -- are highlighted as errors.+ InvalidCharacterLiteral{} -> errorWarningHighlighting w+ SafeFlagPostulate{} -> errorWarningHighlighting w+ SafeFlagPragma{} -> errorWarningHighlighting w+ SafeFlagWithoutKFlagPrimEraseEquality -> errorWarningHighlighting w+ InfectiveImport{} -> errorWarningHighlighting w+ CoInfectiveImport{} -> errorWarningHighlighting w+ InvalidDisplayForm{} -> deadcodeHighlighting w+ UnusedVariablesInDisplayForm xs -> foldMap deadcodeHighlighting xs+ ShouldBeEtaRecordPattern -> catchallHighlighting $ getRange w+ TooManyArgumentsToSort _ args -> errorWarningHighlighting args+ RewritesNothing -> cosmeticProblemHighlighting w+ RecursiveRecordNeedsInductivity _x -> errorWarningHighlighting w+ WithClauseProjectionFixityMismatch p _ _ _ -> cosmeticProblemHighlighting p+ WithoutKFlagPrimEraseEquality -> mempty+ ConflictingPragmaOptions{} -> mempty+ DeprecationWarning{} -> mempty+ UserWarning{} -> mempty+ LibraryWarning{} -> mempty+ ConfluenceCheckingIncompleteBecauseOfMeta{} -> confluenceErrorHighlighting w+ ConfluenceForCubicalNotSupported{} -> mempty+ RewriteNonConfluent{} -> confluenceErrorHighlighting w+ RewriteMaybeNonConfluent{} -> confluenceErrorHighlighting w+ RewriteAmbiguousRules{} -> confluenceErrorHighlighting w+ RewriteMissingRule{} -> confluenceErrorHighlighting w+ IllegalRewriteRule (GlobalRewrite x) _ -> deadcodeHighlighting x+ IllegalRewriteRule (LocalRewrite _ x _) _ -> deadcodeHighlighting x+ NotARewriteRule x _ -> deadcodeHighlighting x+ InferredLocalRewrite _ _ -> mempty+ PragmaCompileErased{} -> deadcodeHighlighting w+ PragmaCompileList{} -> deadcodeHighlighting w+ PragmaCompileMaybe{} -> deadcodeHighlighting w+ PragmaCompileWrong{} -> deadcodeHighlighting w+ PragmaCompileWrongName{} -> deadcodeHighlighting w+ PragmaCompileUnparsable{} -> deadcodeHighlighting w+ PragmaExpectsDefinedSymbol{}+ -> deadcodeHighlighting w+ PragmaExpectsUnambiguousConstructorOrFunction{}+ -> deadcodeHighlighting w+ PragmaExpectsUnambiguousProjectionOrFunction{}+ -> deadcodeHighlighting w+ UnknownJSPrimitive{} -> mempty+ NoMain{} -> mempty+ NotInScopeW{} -> deadcodeHighlighting w+ UnsupportedIndexedMatch{} -> mempty+ AsPatternShadowsConstructorOrPatternSynonym{}+ -> deadcodeHighlighting w+ PatternShadowsConstructor{}-> errorWarningHighlighting w -- or mempty ?+ PlentyInHardCompileTimeMode o+ -> deadcodeHighlighting o+ RecordFieldWarning w -> recordFieldWarningHighlighting w+ OptionWarning w -> mempty+ ParseWarning w -> case w of+ Pa.MisplacedAttributes{} -> deadcodeHighlighting w+ Pa.UnknownPolarity{} -> deadcodeHighlighting w+ Pa.UnknownAttribute{} -> deadcodeHighlighting w+ Pa.UnsupportedAttribute{} -> deadcodeHighlighting w+ Pa.MultipleAttributes{} -> deadcodeHighlighting w+ Pa.MismatchedBrackets{} -> errorWarningHighlighting w+ Pa.OverlappingTokensWarning{} -> mempty+ MissingTypeSignatureForOpaque{} -> errorWarningHighlighting w+ NotAffectedByOpaque{} -> deadcodeHighlighting w+ UselessOpaque{} -> deadcodeHighlighting w+ UnfoldingWrongName x -> deadcodeHighlighting x+ UnfoldTransparentName r -> deadcodeHighlighting r+ FaceConstraintCannotBeHidden{} -> deadcodeHighlighting w+ FaceConstraintCannotBeNamed{} -> deadcodeHighlighting w++ HiddenNotInArgumentPosition{} -> errorWarningHighlighting w+ InstanceNotInArgumentPosition{} -> errorWarningHighlighting w+ MacroInLetBindings{} -> errorWarningHighlighting w+ AbstractInLetBindings{} -> errorWarningHighlighting w+ IllegalDeclarationInDataDefinition{} -> errorWarningHighlighting w+ DefinitionBeforeDeclaration x -> cosmeticProblemHighlighting w <> cosmeticProblemHighlighting (nameBindingSite x)++ NicifierIssue (DeclarationWarning _ w) -> case w of+ -- we intentionally override the binding of `w` here so that our pattern of+ -- using `getRange w` still yields the most precise range information we+ -- can get.+ NotAllowedInMutual{} -> deadcodeHighlighting w+ DivergentModalityInClause{} -> deadcodeHighlighting w+ EmptyAbstract{} -> deadcodeHighlighting w+ EmptyConstructor{} -> deadcodeHighlighting w+ EmptyInstance{} -> deadcodeHighlighting w+ EmptyMacro{} -> deadcodeHighlighting w+ EmptyMutual{} -> deadcodeHighlighting w+ EmptyPostulate{} -> deadcodeHighlighting w+ EmptyPrimitive{} -> deadcodeHighlighting w+ EmptyPrivate{} -> deadcodeHighlighting w+ EmptyGeneralize{} -> deadcodeHighlighting w+ EmptyField{} -> deadcodeHighlighting w+ EmptyPolarityPragma{} -> deadcodeHighlighting w+ FixityDeclarationForNonOperator{}-> deadcodeHighlighting w+ HiddenGeneralize{} -> mempty+ -- Andreas, 2022-03-25, issue #5850+ -- We would like @deadcodeHighlighting w@ for the braces in+ -- @variable {x} : A@, but these have no range, so we cannot highlight them.+ -- Highlighting the variable instead might be misleading,+ -- suggesting that it is not generalized over.+ UselessAbstract{} -> deadcodeHighlighting w+ UselessImport{} -> deadcodeHighlighting w+ UselessInstance{} -> deadcodeHighlighting w+ UselessMacro{} -> deadcodeHighlighting w+ UselessPrivate{} -> deadcodeHighlighting w+ InvalidCatchallPragma{} -> deadcodeHighlighting w+ InvalidEtaEqualityPragma{} -> deadcodeHighlighting w+ InvalidNoPositivityCheckPragma{} -> deadcodeHighlighting w+ InvalidNoUniverseCheckPragma{} -> deadcodeHighlighting w+ InvalidTerminationCheckPragma{} -> deadcodeHighlighting w+ InvalidCoverageCheckPragma{} -> deadcodeHighlighting w+ InvalidConstructorBlock{} -> deadcodeHighlighting w+ InvalidDataOrRecDefParameter{} -> deadcodeHighlighting w+ InvalidTacticAttribute{} -> deadcodeHighlighting w+ InvalidRewriteAttribute{} -> deadcodeHighlighting w+ OpenImportAbstract{} -> cosmeticProblemHighlighting w+ OpenImportPrivate{} -> cosmeticProblemHighlighting w+ SafeFlagInjective {} -> errorWarningHighlighting w+ SafeFlagNoCoverageCheck {} -> errorWarningHighlighting w+ SafeFlagNoPositivityCheck {} -> errorWarningHighlighting w+ SafeFlagNoUniverseCheck {} -> errorWarningHighlighting w+ SafeFlagNonTerminating {} -> errorWarningHighlighting w+ SafeFlagPolarity {} -> errorWarningHighlighting w+ SafeFlagTerminating {} -> errorWarningHighlighting w+ W.ShadowingInTelescope nrs -> foldMap+ (shadowingTelHighlighting . snd)+ nrs+ MissingDataDeclaration{} -> missingDefinitionHighlighting w+ MissingDefinitions{} -> missingDefinitionHighlighting w+ -- TODO: explore highlighting opportunities here!+ PolarityPragmasButNotPostulates{} -> mempty+ PragmaNoTerminationCheck{} -> mempty+ PragmaCompiled{} -> errorWarningHighlighting w+ UnknownFixityInMixfixDecl{} -> mempty+ UnknownNamesInFixityDecl{} -> errorWarningHighlighting w+ UnknownNamesInPolarityPragmas{} -> errorWarningHighlighting w++ -- Backends+ CustomBackendWarning{} -> mempty++ -- Polarities+ TooManyPolarities _x occs -> deadcodeHighlighting occs+ TopLevelPolarity{} -> errorWarningHighlighting w++recordFieldWarningHighlighting ::+ RecordFieldWarning -> HighlightingInfoBuilder+recordFieldWarningHighlighting = \case+ W.DuplicateFields xrs -> dead xrs+ W.TooManyFields _q _ys xrs -> dead xrs+ where+ dead :: List1 (C.Name, Range) -> HighlightingInfoBuilder+ dead = sconcat . fmap deadcodeHighlighting+ -- Andreas, 2020-03-27 #3684: This variant seems to only highlight @x@:+ -- dead = mconcat . map f+ -- f (x, r) = deadcodeHighlighting (getRange x) `mappend` deadcodeHighlighting r++-- | Generate syntax highlighting for termination errors.++terminationErrorHighlighting ::+ List1 TerminationError -> HighlightingInfoBuilder+terminationErrorHighlighting termErrs = functionDefs `mappend` callSites+ where+ m = parserBased { otherAspects = Set.singleton TerminationProblem }+ functionDefs = foldMap (\x -> H.singleton (rToR $ nameBindingSite x) m) $+ concatMap termErrFunctions termErrs+ callSites = foldMap (\r -> H.singleton (rToR r) m) $+ concatMap (map getRange . termErrCalls) termErrs++-- | Generate syntax highlighting for not-strictly-positive inductive+-- definitions.++positivityErrorHighlighting ::+ I.QName -> Seq OccursWhere -> HighlightingInfoBuilder+positivityErrorHighlighting q os =+ several (rToR <$> getRange q : rs) m+ where+ rs = map (\(OccursWhere r _ _) -> r) (Fold.toList os)+ m = parserBased { otherAspects = Set.singleton PositivityProblem }++deadcodeHighlighting :: HasRange a => a -> HighlightingInfoBuilder+deadcodeHighlighting a = H.singleton (rToR $ P.continuous $ getRange a) m+ where m = parserBased { otherAspects = Set.singleton Deadcode }++coverageErrorHighlighting :: Range -> HighlightingInfoBuilder+coverageErrorHighlighting r = H.singleton (rToR $ P.continuousPerLine r) m+ where m = parserBased { otherAspects = Set.singleton CoverageProblem }++shadowingTelHighlighting :: List2 Range -> HighlightingInfoBuilder+shadowingTelHighlighting =+ -- we do not want to highlight the one variable in scope so we take+ -- the @init@ segment of the ranges in question+ foldMap (\r -> H.singleton (rToR $ P.continuous r) m) . List2.init+ where+ m = parserBased { otherAspects =+ Set.singleton H.ShadowingInTelescope }++catchallHighlighting :: Range -> HighlightingInfoBuilder+catchallHighlighting r = H.singleton (rToR $ P.continuousPerLine r) m+ where m = parserBased { otherAspects = Set.singleton CatchallClause }++cosmeticProblemHighlighting :: HasRange a => a -> HighlightingInfoBuilder+cosmeticProblemHighlighting a = H.singleton (rToR $ P.continuousPerLine r) m+ where+ r = getRange a+ m = parserBased { otherAspects = Set.singleton CosmeticProblem }++confluenceErrorHighlighting ::+ HasRange a => a -> HighlightingInfoBuilder+confluenceErrorHighlighting a = H.singleton (rToR $ P.continuousPerLine $ getRange a) m+ where m = parserBased { otherAspects = Set.singleton ConfluenceProblem }++instanceProblemHighlighting :: HasRange a => a -> HighlightingInfoBuilder+instanceProblemHighlighting a = H.singleton (rToR $ P.continuousPerLine r) m+ where+ r = getRange a+ m = parserBased { otherAspects = Set.singleton InstanceProblem }++missingDefinitionHighlighting ::+ HasRange a => a -> HighlightingInfoBuilder+missingDefinitionHighlighting a = H.singleton (rToR $ P.continuousPerLine $ getRange a) m+ where m = parserBased { otherAspects = Set.singleton Aspect.MissingDefinition }++-- | Generates and prints syntax highlighting information for unsolved+-- meta-variables and certain unsolved constraints.++printUnsolvedInfo :: TCM ()+printUnsolvedInfo = do+ info <- computeUnsolvedInfo++ printHighlightingInfo KeepHighlighting (convert info)++computeUnsolvedInfo :: TCM HighlightingInfoBuilder+computeUnsolvedInfo = do+ (rs, metaInfo) <- computeUnsolvedMetaWarnings+ constraintInfo <- computeUnsolvedConstraints rs++ return $ metaInfo `mappend` constraintInfo++-- | Generates syntax highlighting information for unsolved meta+-- variables.+-- Also returns ranges of unsolved or interaction metas.+computeUnsolvedMetaWarnings :: TCM ([Ranges], HighlightingInfoBuilder)+computeUnsolvedMetaWarnings = do+ is <- getInteractionMetas++ -- We don't want to highlight blocked terms, since+ -- * there is always at least one proper meta responsible for the blocking+ -- * in many cases the blocked term covers the highlighting for this meta+ -- * for the same reason we skip metas with a twin, since the twin will be blocked.+ let notBlocked m = not <$> isBlockedTerm m+ let notHasTwin m = not <$> hasTwinMeta m+ ms <- filterM notHasTwin =<< filterM notBlocked =<< getOpenMetas++ let extend = map (rToR . P.continuousPerLine)++ rs <- extend <$> mapM getMetaRange (ms \\ is)++ rs' <- extend <$> mapM getMetaRange is+ return $ (rs ++ rs', metasHighlighting' rs)++metasHighlighting :: [Range] -> HighlightingInfoBuilder+metasHighlighting = metasHighlighting' . fmap (rToR . P.continuousPerLine)++metasHighlighting' :: [Ranges] -> HighlightingInfoBuilder+metasHighlighting' rs =+ several (List1.toList rs) parserBased{ otherAspects = Set.singleton UnsolvedMeta }++-- | Generates syntax highlighting information for unsolved constraints+-- (ideally: that are not connected to a meta variable).++computeUnsolvedConstraints :: [Ranges] -- ^ does not add ranges that would overlap with these.+ -> TCM HighlightingInfoBuilder+computeUnsolvedConstraints ms = constraintsHighlighting ms <$> getAllConstraints++constraintsHighlighting ::+ [Ranges] -> Constraints -> HighlightingInfoBuilder+constraintsHighlighting ms cs =+ several (filter noOverlap $ map (rToR . P.continuousPerLine) rs)+ (parserBased { otherAspects = Set.singleton UnsolvedConstraint })+ where+ noOverlap r = not $ any (overlappings $ r) $ ms+ -- get ranges of interesting unsolved constraints+ rs = (`mapMaybe` (map theConstraint cs)) $ \case+ Closure{ clValue = IsEmpty r t } -> Just r+ Closure{ clEnv = e, clValue = ValueCmp{} } -> Just $! getRange (view eRange e)+ Closure{ clEnv = e, clValue = ElimCmp{} } -> Just $! getRange (view eRange e)+ Closure{ clEnv = e, clValue = SortCmp{} } -> Just $! getRange (view eRange e)+ Closure{ clEnv = e, clValue = LevelCmp{} } -> Just $! getRange (view eRange e)+ Closure{ clEnv = e, clValue = CheckSizeLtSat{} } -> Just $! getRange (view eRange e)+ _ -> Nothing+++-- * Disambiguation of constructors and projections.++storeDisambiguatedField :: A.QName -> TCM ()+storeDisambiguatedField = storeDisambiguatedName Field++storeDisambiguatedProjection :: A.QName -> TCM ()+storeDisambiguatedProjection = storeDisambiguatedField++storeDisambiguatedConstructor :: Induction -> A.QName -> TCM ()+storeDisambiguatedConstructor i = storeDisambiguatedName $ Constructor i++-- TODO: move the following function to a new module TypeChecking.Overloading+-- that gathers functions concerning disambiguation of overloading.++-- | Remember a name disambiguation (during type checking).+-- To be used later during syntax highlighting.+-- Also: raise user warnings associated with the name.+storeDisambiguatedName :: NameKind -> A.QName -> TCM ()+storeDisambiguatedName k q = do+ raiseWarningsOnUsage q+ whenJust (start $ getRange q) $ \ i ->+ modifyTCLens stDisambiguatedNames $ IntMap.insert i $ DisambiguatedName k q+ where+ start r = fromIntegral . P.posPos <$> P.rStart' r++-- | Store a disambiguation of record field tags for the purpose of highlighting.+disambiguateRecordFields+ :: [C.Name] -- ^ Record field names in a record expression.+ -> [A.QName] -- ^ Record field names in the corresponding record type definition+ -> TCM ()+disambiguateRecordFields cxs axs = forM_ cxs $ \ cx -> do+ caseMaybe (List.find ((cx ==) . A.nameConcrete . A.qnameName) axs) (return ()) $ \ ax -> do+ storeDisambiguatedField ax{ A.qnameName = (A.qnameName ax) { A.nameConcrete = cx } }
@@ -0,0 +1,7 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.Highlighting.Generate where++import Agda.TypeChecking.Monad.Base (TCM, TCWarning)++highlightWarning :: TCWarning -> TCM ()
@@ -1,184 +1,11 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} --- | Function for generating highlighted, hyperlinked HTML from Agda--- sources.+-- | Backend for generating highlighted, hyperlinked HTML from Agda sources. module Agda.Interaction.Highlighting.HTML- ( generateHTML+ ( htmlBackend ) where -import Control.Applicative-import Control.Monad-import Control.Monad.Trans-import Control.Monad.State.Class-import Control.Arrow ((***))-import System.FilePath-import System.Directory-import Text.XHtml.Strict-import Data.Function-import Data.Monoid-import Data.Maybe-import qualified Data.Map as Map-import qualified Data.List as List--import Paths_Agda--import Agda.Interaction.FindFile-import Agda.Interaction.Highlighting.Generate-import Agda.Interaction.Highlighting.Precise-import Agda.Interaction.Highlighting.Range-import Agda.TypeChecking.Monad (TCM)-import qualified Agda.TypeChecking.Monad as TCM-import qualified Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Concrete as C-import Agda.Syntax.Common-import qualified Agda.Syntax.Scope.Monad as Scope-import Agda.Syntax.Translation.ConcreteToAbstract-import Agda.Interaction.Options-import Agda.Utils.FileName (filePath)-import qualified Agda.Utils.IO.UTF8 as UTF8-import Agda.Utils.Pretty--import Agda.Utils.Impossible-#include "../../undefined.h"---- | The name of the default CSS file.--defaultCSSFile :: FilePath-defaultCSSFile = "Agda.css"---- | Generates HTML files from all the sources which the given module--- depends on (including the module itself).------ This function should only be called after type checking has--- completed successfully.--generateHTML :: A.ModuleName -> TCM ()-generateHTML mod = do- options <- TCM.commandLineOptions-- -- There is a default directory given by 'defaultHTMLDir'- let dir = optHTMLDir options- liftIO $ createDirectoryIfMissing True dir-- -- If the default CSS file should be used, then it is copied to- -- the output directory.- liftIO $ when (isNothing $ optCSSFile options) $ do- cssFile <- getDataFileName defaultCSSFile- copyFile cssFile (dir </> defaultCSSFile)-- TCM.reportSLn "html" 1 $ unlines- [ ""- , "Warning: HTML is currently generated for ALL files which can be"- , "reached from the given module, including library files."- ]-- -- Pull highlighting info from the state and generate all the- -- web pages.- mapM_ (\(m, h) -> generatePage dir m h) =<<- map (id *** TCM.iHighlighting . TCM.miInterface) .- Map.toList <$> TCM.getVisitedModules---- | Converts module names to the corresponding HTML file names.--modToFile :: C.TopLevelModuleName -> FilePath-modToFile m = render (pretty m) <.> "html"---- | Generates an HTML file with a highlighted, hyperlinked version of--- the given module.--generatePage- :: FilePath -- ^ Directory in which to create files.- -> C.TopLevelModuleName -- ^ Module to be highlighted.- -> HighlightingInfo -- ^ Syntax highlighting info for the module.- -> TCM ()-generatePage dir mod highlighting = do- mf <- Map.lookup mod . TCM.stModuleToSource <$> get- case mf of- Nothing -> __IMPOSSIBLE__- Just f -> do- contents <- liftIO $ UTF8.readTextFile $ filePath f- css <- maybe defaultCSSFile id . optCSSFile <$>- TCM.commandLineOptions- let html = page css mod contents highlighting- TCM.reportSLn "html" 1 $ "Generating HTML for " ++- render (pretty mod) ++- " (" ++ target ++ ")."- liftIO $ UTF8.writeFile target (renderHtml html)- where target = dir </> modToFile mod---- | Constructs the web page, including headers.--page :: FilePath -- ^ URL to the CSS file.- -> C.TopLevelModuleName -- ^ Module to be highlighted.- -> String -- ^ The contents of the module.- -> CompressedFile -- ^ Highlighting information.- -> Html-page css modName contents info =- header (thetitle << render (pretty modName)- +++- meta ! [ httpequiv "Content-Type"- , content "text/html; charset=UTF-8"- ]- +++- meta ! [ httpequiv "Content-Style-Type"- , content "text/css"- ]- +++- thelink noHtml ! [ href css- , rel "stylesheet"- , thetype "text/css"- ])- +++- body << pre << code contents info---- | Constructs the HTML displaying the code.--code :: String -- ^ The contents of the module.- -> CompressedFile -- ^ Highlighting information.- -> Html-code contents info =- mconcat $- map (\(pos, s, mi) -> annotate pos mi (stringToHtml s)) $- map (\cs -> case cs of- (mi, (pos, _)) : _ ->- (pos, map (snd . snd) cs, maybe mempty id mi)- [] -> __IMPOSSIBLE__) $- List.groupBy ((==) `on` fst) $- map (\(pos, c) -> (Map.lookup pos infoMap, (pos, c))) $- zip [1..] contents- where- infoMap = toMap (decompress info)-- annotate :: Integer -> MetaInfo -> Html -> Html- annotate pos mi = anchor ! attributes- where- attributes =- [name (show pos)] ++- maybe [] link (definitionSite mi) ++- (case classes of- [] -> []- cs -> [theclass $ unwords cs])-- classes =- maybe [] noteClasses (note mi)- ++ otherAspectClasses (otherAspects mi)- ++ maybe [] aspectClasses (aspect mi)-- aspectClasses (Name mKind op) = kindClass ++ opClass- where- kindClass = maybe [] ((: []) . showKind) mKind-- showKind (Constructor Inductive) = "InductiveConstructor"- showKind (Constructor CoInductive) = "CoinductiveConstructor"- showKind k = show k-- opClass = if op then ["Operator"] else []- aspectClasses a = [show a]-- otherAspectClasses = map show-- -- Notes are not included.- noteClasses s = []-- link (m, pos) = [href $ modToFile m ++ "#" ++ show pos]+import Agda.Interaction.Highlighting.HTML.Backend as Exports+ ( htmlBackend+ )
@@ -0,0 +1,204 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Backend for generating highlighted, hyperlinked HTML from Agda sources.++module Agda.Interaction.Highlighting.HTML.Backend+ ( htmlBackend+ ) where++import Agda.Interaction.Highlighting.HTML.Base++import Prelude hiding ((!!), concatMap)++import Control.DeepSeq+import Control.Monad.Trans ( MonadIO )+import Control.Monad.Except ( MonadError(throwError) )++import Data.Map (Map)++import GHC.Generics (Generic)++import Agda.Interaction.Options+ ( ArgDescr(ReqArg, NoArg)+ , OptDescr(..)+ , Flag+ )+import Agda.Compiler.Backend (Backend,Backend_boot(..), Backend',Backend'_boot(..), Recompile(..))+import Agda.Compiler.Common (IsMain(..), curIF)++import Agda.Syntax.TopLevelModuleName (TopLevelModuleName)++import Agda.TypeChecking.Monad+ ( MonadDebug+ , ReadTCState+ , Definition+ , reportS+ )++-- | Options for HTML generation++data HtmlFlags = HtmlFlags+ { htmlFlagEnabled :: Bool+ , htmlFlagDir :: FilePath+ , htmlFlagHighlight :: HtmlHighlight+ , htmlFlagHighlightOccurrences :: Bool+ , htmlFlagCssFile :: Maybe FilePath+ } deriving (Eq, Generic)++instance NFData HtmlFlags++data HtmlCompileEnv = HtmlCompileEnv+ { htmlCompileEnvOpts :: HtmlOptions+ }++data HtmlModuleEnv = HtmlModuleEnv+ { htmlModEnvCompileEnv :: HtmlCompileEnv+ , htmlModEnvName :: TopLevelModuleName+ }++data HtmlModule = HtmlModule+data HtmlDef = HtmlDef++htmlBackend :: Backend+htmlBackend = Backend htmlBackend'++htmlBackend' :: Backend' HtmlFlags HtmlCompileEnv HtmlModuleEnv HtmlModule HtmlDef+htmlBackend' = Backend'+ { backendName = "HTML"+ , backendVersion = Nothing+ , options = initialHtmlFlags+ , commandLineFlags = htmlFlags+ , isEnabled = htmlFlagEnabled+ , preCompile = preCompileHtml+ , preModule = preModuleHtml+ , compileDef = compileDefHtml+ , postModule = postModuleHtml+ , postCompile = postCompileHtml+ -- --only-scope-checking works, but with the caveat that cross-module links+ -- will not have their definition site populated.+ , scopeCheckingSuffices = True+ , mayEraseType = const $ return False+ , backendInteractTop = Nothing+ , backendInteractHole = Nothing+ }++initialHtmlFlags :: HtmlFlags+initialHtmlFlags = HtmlFlags+ { htmlFlagEnabled = False+ , htmlFlagDir = defaultHTMLDir+ , htmlFlagHighlight = HighlightAll+ -- Don't enable by default because it causes potential+ -- performance problems+ , htmlFlagHighlightOccurrences = False+ , htmlFlagCssFile = Nothing+ }++htmlOptsOfFlags :: HtmlFlags -> HtmlOptions+htmlOptsOfFlags flags = HtmlOptions+ { htmlOptDir = htmlFlagDir flags+ , htmlOptHighlight = htmlFlagHighlight flags+ , htmlOptHighlightOccurrences = htmlFlagHighlightOccurrences flags+ , htmlOptCssFile = htmlFlagCssFile flags+ }++-- | The default output directory for HTML.++defaultHTMLDir :: FilePath+defaultHTMLDir = "html"++htmlFlags :: [OptDescr (Flag HtmlFlags)]+htmlFlags =+ [ Option [] ["html"] (NoArg htmlFlag)+ "generate HTML files with highlighted source code"+ , Option [] ["html-dir"] (ReqArg htmlDirFlag "DIR")+ ("directory in which HTML files are placed (default: " +++ defaultHTMLDir ++ ")")+ , Option [] ["highlight-occurrences"] (NoArg highlightOccurrencesFlag)+ ("highlight all occurrences of hovered symbol in generated " +++ "HTML files")+ , Option [] ["css"] (ReqArg cssFlag "URL")+ "the CSS file used by the HTML files (can be relative)"+ , Option [] ["html-highlight"] (ReqArg htmlHighlightFlag "[code,all,auto]")+ ("whether to highlight only the code parts (code) or " +++ "the file as a whole (all) or " +++ "decide by source file type (auto)")+ ]++htmlFlag :: Flag HtmlFlags+htmlFlag o = return $ o { htmlFlagEnabled = True }++htmlDirFlag :: FilePath -> Flag HtmlFlags+htmlDirFlag d o = return $ o { htmlFlagDir = d }++cssFlag :: FilePath -> Flag HtmlFlags+cssFlag f o = return $ o { htmlFlagCssFile = Just f }++highlightOccurrencesFlag :: Flag HtmlFlags+highlightOccurrencesFlag o = return $ o { htmlFlagHighlightOccurrences = True }++parseHtmlHighlightFlag :: MonadError String m => String -> m HtmlHighlight+parseHtmlHighlightFlag "code" = return HighlightCode+parseHtmlHighlightFlag "all" = return HighlightAll+parseHtmlHighlightFlag "auto" = return HighlightAuto+parseHtmlHighlightFlag opt = throwError $ concat ["Invalid option <", opt, ">, expected <all>, <auto> or <code>"]++htmlHighlightFlag :: String -> Flag HtmlFlags+htmlHighlightFlag opt o = do+ flag <- parseHtmlHighlightFlag opt+ return $ o { htmlFlagHighlight = flag }++runLogHtmlWithMonadDebug :: MonadDebug m => LogHtmlT m a -> m a+runLogHtmlWithMonadDebug = runLogHtmlWith $ reportS "html" 1++preCompileHtml+ :: (MonadIO m, MonadDebug m)+ => HtmlFlags+ -> m HtmlCompileEnv+preCompileHtml flags = runLogHtmlWithMonadDebug $ do+ logHtml $ unlines+ [ "Warning: HTML is currently generated for ALL files which can be"+ , "reached from the given module, including library files."+ ]+ let opts = htmlOptsOfFlags flags+ prepareCommonDestinationAssets opts+ return $ HtmlCompileEnv opts++preModuleHtml+ :: Applicative m+ => HtmlCompileEnv+ -> IsMain+ -> TopLevelModuleName+ -> Maybe FilePath+ -> m (Recompile HtmlModuleEnv HtmlModule)+preModuleHtml cenv _isMain modName _ifacePath = pure $ Recompile (HtmlModuleEnv cenv modName)++compileDefHtml+ :: Applicative m+ => HtmlCompileEnv+ -> HtmlModuleEnv+ -> IsMain+ -> Definition+ -> m HtmlDef+compileDefHtml _env _menv _isMain _def = pure HtmlDef++postModuleHtml+ :: (MonadIO m, MonadDebug m, ReadTCState m)+ => HtmlCompileEnv+ -> HtmlModuleEnv+ -> IsMain+ -> TopLevelModuleName+ -> [HtmlDef]+ -> m HtmlModule+postModuleHtml _env menv _isMain _modName _defs = do+ let generatePage = defaultPageGen . htmlCompileEnvOpts . htmlModEnvCompileEnv $ menv+ htmlSrc <- srcFileOfInterface (htmlModEnvName menv) <$> curIF+ runLogHtmlWithMonadDebug $ generatePage htmlSrc+ return HtmlModule++postCompileHtml+ :: Applicative m+ => HtmlCompileEnv+ -> IsMain+ -> Map TopLevelModuleName HtmlModule+ -> m ()+postCompileHtml _cenv _isMain _modulesByName = pure ()
@@ -0,0 +1,436 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Function for generating highlighted, hyperlinked HTML from Agda+-- sources.++module Agda.Interaction.Highlighting.HTML.Base+ ( HtmlOptions(..)+ , HtmlHighlight(..)+ , prepareCommonDestinationAssets+ , srcFileOfInterface+ , defaultPageGen+ , MonadLogHtml(logHtml)+ , LogHtmlT+ , runLogHtmlWith+ ) where++import Prelude hiding ((!!), concatMap)++import Control.DeepSeq+import Control.Monad+import Control.Monad.Trans ( MonadIO(..), lift )+import Control.Monad.Trans.Reader ( ReaderT(runReaderT), ask )++import Data.Foldable (toList, concatMap)+import Data.Maybe+import qualified Data.IntMap as IntMap+import Data.List.Split (splitWhen)+import Data.Text.Lazy (Text)+import qualified Data.Text.Lazy as T++import GHC.Generics (Generic)++import qualified Network.URI.Encode++import System.FilePath+import System.Directory++import Text.Blaze.Html5+ ( preEscapedToHtml+ , toHtml+ , stringValue+ , Html+ , (!)+ , Attribute+ )+import qualified Text.Blaze.Html5 as Html5+import qualified Text.Blaze.Html5.Attributes as Attr+import Text.Blaze.Html.Renderer.Text ( renderHtml )+ -- The imported operator (!) attaches an Attribute to an Html value+ -- The defined operator (!!) attaches a list of such Attributes++import Agda.Interaction.Highlighting.Precise hiding (toList)+import Agda.Interaction.Highlighting.HTML.Forester++import Agda.Syntax.Common+import Agda.Syntax.TopLevelModuleName++import qualified Agda.TypeChecking.Monad as TCM+ ( Interface(..)+ )++import Agda.Setup ( getDataFileName )++import Agda.Utils.Function+import Agda.Utils.List1 (String1, pattern (:|))+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.IO.UTF8 as UTF8+import Agda.Syntax.Common.Pretty++import Agda.Utils.Impossible++-- | The Agda data directory containing the files for the HTML backend.++htmlDataDir :: FilePath+htmlDataDir = "html"++-- | The name of the default CSS file.++defaultCSSFile :: FilePath+defaultCSSFile = "Agda.css"++-- | The name of the occurrence-highlighting JS file.++occurrenceHighlightJsFile :: FilePath+occurrenceHighlightJsFile = "highlight-hover.js"++-- | The directive inserted before the rendered code blocks++rstDelimiter :: String+rstDelimiter = ".. raw:: html\n"++-- | The directive inserted before rendered code blocks in org++orgDelimiterStart :: String+orgDelimiterStart = "#+BEGIN_EXPORT html\n<pre class=\"Agda\">\n"++-- | The directive inserted after rendered code blocks in org++orgDelimiterEnd :: String+orgDelimiterEnd = "</pre>\n#+END_EXPORT\n"++-- | Determine how to highlight the file++data HtmlHighlight = HighlightAll | HighlightCode | HighlightAuto+ deriving (Show, Eq, Generic)++instance NFData HtmlHighlight++highlightOnlyCode :: HtmlHighlight -> FileType -> Bool+highlightOnlyCode HighlightAll _ = False+highlightOnlyCode HighlightCode _ = True+highlightOnlyCode HighlightAuto AgdaFileType = False+highlightOnlyCode HighlightAuto MdFileType = True+highlightOnlyCode HighlightAuto RstFileType = True+highlightOnlyCode HighlightAuto OrgFileType = True+highlightOnlyCode HighlightAuto TypstFileType = True+highlightOnlyCode HighlightAuto TreeFileType = True+highlightOnlyCode HighlightAuto TexFileType = False++-- | Determine the generated file extension++highlightedFileExt :: HtmlHighlight -> FileType -> String+highlightedFileExt hh ft+ | not $ highlightOnlyCode hh ft = "html"+ | otherwise = case ft of+ AgdaFileType -> "html"+ MdFileType -> "md"+ RstFileType -> "rst"+ TexFileType -> "tex"+ OrgFileType -> "org"+ TypstFileType -> "typ"+ TreeFileType -> "tree"++-- | Options for HTML generation++data HtmlOptions = HtmlOptions+ { htmlOptDir :: FilePath+ , htmlOptHighlight :: HtmlHighlight+ , htmlOptHighlightOccurrences :: Bool+ , htmlOptCssFile :: Maybe FilePath+ } deriving Eq++-- | Internal type bundling the information related to a module source file++data HtmlInputSourceFile = HtmlInputSourceFile+ { _srcFileModuleName :: TopLevelModuleName+ , _srcFileType :: FileType+ -- ^ Source file type+ , _srcFileText :: Text+ -- ^ Source text+ , _srcFileHighlightInfo :: HighlightingInfo+ -- ^ Highlighting info+ }++-- | Bundle up the highlighting info for a source file++srcFileOfInterface ::+ TopLevelModuleName -> TCM.Interface -> HtmlInputSourceFile+srcFileOfInterface m i = HtmlInputSourceFile m (TCM.iFileType i) (TCM.iSource i) (TCM.iHighlighting i)++-- | Logging during HTML generation++type HtmlLogMessage = String+type HtmlLogAction m = HtmlLogMessage -> m ()++class MonadLogHtml m where+ logHtml :: HtmlLogAction m++type LogHtmlT m = ReaderT (HtmlLogAction m) m++instance Monad m => MonadLogHtml (LogHtmlT m) where+ logHtml message = do+ doLog <- ask+ lift $ doLog message++runLogHtmlWith :: HtmlLogAction m -> LogHtmlT m a -> m a+runLogHtmlWith = flip runReaderT++renderSourceFile :: HtmlOptions -> HtmlInputSourceFile -> Text+renderSourceFile opts = renderSourcePage+ where+ cssFile = fromMaybe defaultCSSFile (htmlOptCssFile opts)+ highlightOccur = htmlOptHighlightOccurrences opts+ htmlHighlight = htmlOptHighlight opts+ renderSourcePage (HtmlInputSourceFile moduleName fileType sourceCode hinfo) =+ page cssFile highlightOccur onlyCode fileType moduleName pageContents+ where+ tokens = tokenStream sourceCode hinfo+ onlyCode = highlightOnlyCode htmlHighlight fileType+ pageContents = code onlyCode fileType tokens++defaultPageGen :: (MonadIO m, MonadLogHtml m) => HtmlOptions -> HtmlInputSourceFile -> m ()+defaultPageGen opts srcFile@(HtmlInputSourceFile moduleName ft _ _) = do+ logHtml $ render $ "Generating HTML for" <+> pretty moduleName <+> ((parens (pretty target)) <> ".")+ writeRenderedHtml html target+ where+ ext = highlightedFileExt (htmlOptHighlight opts) ft+ target = (htmlOptDir opts) </> modToFile moduleName ext+ html = renderSourceFile opts srcFile++prepareCommonDestinationAssets :: MonadIO m => HtmlOptions -> m ()+prepareCommonDestinationAssets options = liftIO $ do+ -- There is a default directory given by 'defaultHTMLDir'+ let htmlDir = htmlOptDir options+ createDirectoryIfMissing True htmlDir++ -- If the default CSS file should be used, then it is copied to+ -- the output directory.+ let cssFile = htmlOptCssFile options+ when (isNothing $ cssFile) $ do+ defCssFile <- getDataFileName $+ htmlDataDir </> defaultCSSFile+ copyFile defCssFile (htmlDir </> defaultCSSFile)++ let highlightOccurrences = htmlOptHighlightOccurrences options+ when highlightOccurrences $ do+ highlightJsFile <- getDataFileName $+ htmlDataDir </> occurrenceHighlightJsFile+ copyFile highlightJsFile (htmlDir </> occurrenceHighlightJsFile)++-- | Converts module names to the corresponding HTML file names.++modToFile :: TopLevelModuleName -> String -> FilePath+modToFile m ext = Network.URI.Encode.encode $ render (pretty m) <.> ext++-- | Generates a highlighted, hyperlinked version of the given module.++writeRenderedHtml+ :: MonadIO m+ => Text -- ^ Rendered page+ -> FilePath -- ^ Output path.+ -> m ()+writeRenderedHtml html target = liftIO $ UTF8.writeTextToFile target html+++-- | Attach multiple Attributes++(!!) :: Html -> [Attribute] -> Html+h !! as = h ! mconcat as++-- | Constructs the web page, including headers.++page :: FilePath -- ^ URL to the CSS file.+ -> Bool -- ^ Highlight occurrences+ -> Bool -- ^ Whether to reserve literate+ -> FileType -- ^ Type of file+ -> TopLevelModuleName -- ^ Module to be highlighted.+ -> Html+ -> Text+page css+ highlightOccurrences+ htmlHighlight+ fileType+ modName+ pageContent =+ renderF $ if htmlHighlight+ then pageContent+ else Html5.docTypeHtml $ hdr <> rest+ where++ renderF = case fileType of+ TreeFileType -> renderForesterHtml+ _ -> renderHtml++ hdr = Html5.head $ mconcat+ [ Html5.meta !! [ Attr.charset "utf-8" ]+ , Html5.title (toHtml . render $ pretty modName)+ , Html5.link !! [ Attr.rel "stylesheet"+ , Attr.href $ stringValue css+ ]+ , if highlightOccurrences+ then Html5.script mempty !!+ [ Attr.type_ "text/javascript"+ , Attr.src $ stringValue occurrenceHighlightJsFile+ ]+ else mempty+ ]++ rest = Html5.body $ (Html5.pre ! Attr.class_ "Agda") pageContent++-- | Position, Contents, Infomation++type TokenInfo =+ ( Int+ , String1+ , Aspects+ )++-- | Constructs token stream ready to print.++tokenStream+ :: Text -- ^ The contents of the module.+ -> HighlightingInfo -- ^ Highlighting information.+ -> [TokenInfo]+tokenStream contents info =+ map (\ ((mi, (pos, c)) :| xs) ->+ (pos, c :| map (snd . snd) xs, fromMaybe mempty mi)) $+ List1.groupBy ((==) `on` fst) $+ zipWith (\pos c -> (IntMap.lookup pos infoMap, (pos, c))) [1..] (T.unpack contents)+ where+ infoMap = toMap info++-- | Constructs the HTML displaying the code.++code :: Bool -- ^ Whether to generate non-code contents as-is+ -> FileType -- ^ Source file type+ -> [TokenInfo]+ -> Html+code onlyCode fileType = mconcat . if onlyCode+ then case fileType of+ -- Explicitly written all cases, so people+ -- get compile error when adding new file types+ -- when they forget to modify the code here+ RstFileType -> map mkRst . splitByMarkup+ MdFileType -> map mkMd . splitByMarkup+ AgdaFileType -> map mkHtml+ OrgFileType -> map mkOrg . splitByMarkup+ TreeFileType -> map mkMd . splitByMarkup+ -- Two useless cases, probably will never used by anyone+ TexFileType -> map mkMd . splitByMarkup+ TypstFileType -> map mkMd . splitByMarkup+ else map mkHtml+ where+ trd (_, _, a) = a++ splitByMarkup :: [TokenInfo] -> [[TokenInfo]]+ splitByMarkup = splitWhen $ (== Just Markup) . aspect . trd++ mkHtml :: TokenInfo -> Html+ mkHtml (pos, s, mi) =+ -- Andreas, 2017-06-16, issue #2605:+ -- Do not create anchors for whitespace.+ applyUnless (mi == mempty) (annotate pos mi) $ toHtml $ List1.toList s++ backgroundOrAgdaToHtml :: TokenInfo -> Html+ backgroundOrAgdaToHtml token@(_, s, mi) = case aspect mi of+ Just Background -> preEscapedToHtml $ List1.toList s+ Just Markup -> __IMPOSSIBLE__+ _ -> mkHtml token++ -- Proposed in #3373, implemented in #3384+ mkRst :: [TokenInfo] -> Html+ mkRst = mconcat . (toHtml rstDelimiter :) . map backgroundOrAgdaToHtml++ -- The assumption here and in mkOrg is that Background tokens and Agda tokens are always+ -- separated by Markup tokens, so these runs only contain one kind.+ mkMd :: [TokenInfo] -> Html+ mkMd tokens = if containsCode then formatCode else formatNonCode+ where+ containsCode = any ((/= Just Background) . aspect . trd) tokens++ formatCode = Html5.pre ! Attr.class_ "Agda" $ mconcat $ backgroundOrAgdaToHtml <$> tokens+ formatNonCode = mconcat $ backgroundOrAgdaToHtml <$> tokens++ mkOrg :: [TokenInfo] -> Html+ mkOrg tokens = mconcat $ if containsCode then formatCode else formatNonCode+ where+ containsCode = any ((/= Just Background) . aspect . trd) tokens++ startDelimiter = preEscapedToHtml orgDelimiterStart+ endDelimiter = preEscapedToHtml orgDelimiterEnd++ formatCode = startDelimiter : foldr (\x -> (backgroundOrAgdaToHtml x :)) [endDelimiter] tokens+ formatNonCode = map backgroundOrAgdaToHtml tokens++ -- Put anchors that enable referencing that token.+ -- We put a fail safe numeric anchor (file position) for internal references+ -- (issue #2756), as well as a heuristic name anchor for external references+ -- (issue #2604).+ annotate :: Int -> Aspects -> Html -> Html+ annotate pos mi =+ applyWhen hereAnchor (anchorage nameAttributes mempty <>) . anchorage posAttributes+ where+ -- Warp an anchor (<A> tag) with the given attributes around some HTML.+ anchorage :: [Attribute] -> Html -> Html+ anchorage attrs html = Html5.a html !! attrs++ -- File position anchor (unique, reliable).+ posAttributes :: [Attribute]+ posAttributes = concat+ [ [Attr.id $ stringValue $ show pos ]+ , toList $ link <$> definitionSite mi+ , Attr.class_ (stringValue $ unwords classes) <$ guard (not $ null classes)+ ]++ -- Named anchor (not reliable, but useful in the general case for outside refs).+ nameAttributes :: [Attribute]+ nameAttributes = [ Attr.id $ stringValue $ fromMaybe __IMPOSSIBLE__ $ mDefSiteAnchor ]++ classes = concat+ [ concatMap noteClasses (note mi)+ , otherAspectClasses (toList $ otherAspects mi)+ , concatMap aspectClasses (aspect mi)+ ]++ aspectClasses (Name mKind op) = kindClass ++ opClass+ where+ kindClass = toList $ fmap showKind mKind++ showKind (Constructor Inductive) = "InductiveConstructor"+ showKind (Constructor CoInductive) = "CoinductiveConstructor"+ showKind k = show k++ opClass = ["Operator" | op]+ aspectClasses a = [show a]+++ otherAspectClasses = map show++ -- Notes are not included.+ noteClasses _s = []++ -- Should we output a named anchor?+ -- Only if we are at the definition site now (@here@)+ -- and such a pretty named anchor exists (see 'defSiteAnchor').+ hereAnchor :: Bool+ hereAnchor = here && isJust mDefSiteAnchor++ mDefinitionSite :: Maybe DefinitionSite+ mDefinitionSite = definitionSite mi++ -- Are we at the definition site now?+ here :: Bool+ here = maybe False defSiteHere mDefinitionSite++ mDefSiteAnchor :: Maybe String+ mDefSiteAnchor = maybe __IMPOSSIBLE__ defSiteAnchor mDefinitionSite++ link (DefinitionSite m defPos _here _aName) = Attr.href $ stringValue $+ -- If the definition site points to the top of a file,+ -- we drop the anchor part and just link to the file.+ applyUnless (defPos <= 1)+ (++ "#" +++ Network.URI.Encode.encode (show defPos))+ -- Network.URI.Encode.encode (fromMaybe (show defPos) aName)) -- Named links disabled+ (Network.URI.Encode.encode $ modToFile m "html")
@@ -0,0 +1,147 @@+module Agda.Interaction.Highlighting.HTML.Forester+ ( renderForesterHtml,+ )+where++import Data.ByteString (ByteString)+import Data.ByteString qualified as S (isInfixOf)+import Data.List (isInfixOf)+import Data.Monoid (mappend, mempty)+import Data.Text (Text)+import Data.Text qualified as T+import Data.Text.Encoding (decodeUtf8)+import Data.Text.Lazy qualified as L+import Data.Text.Lazy.Builder (Builder)+import Data.Text.Lazy.Builder qualified as B+import Text.Blaze.Html5 (Html)+import Text.Blaze.Internal+ ( ChoiceString (..),+ MarkupM (..),+ StaticString (getText),+ )++fromChoiceString ::+ -- | Decoder for bytestrings+ (ByteString -> Text) ->+ -- | String to render+ ChoiceString ->+ -- | Resulting builder+ Builder+fromChoiceString _ (Static s) = B.fromText $ getText s+fromChoiceString _ (String s) = B.fromText $ T.pack s+fromChoiceString _ (Text s) = B.fromText s+fromChoiceString d (ByteString s) = B.fromText $ d s+fromChoiceString d (PreEscaped x) = case x of+ String s -> B.fromText $ T.pack s+ Text s -> B.fromText s+ s -> fromChoiceString d s+fromChoiceString d (External x) = case x of+ -- Check that the sequence "</" is *not* in the external data.+ String s -> if "</" `isInfixOf` s then mempty else B.fromText (T.pack s)+ Text s -> if "</" `T.isInfixOf` s then mempty else B.fromText s+ ByteString s -> if "</" `S.isInfixOf` s then mempty else B.fromText (d s)+ s -> fromChoiceString d s+fromChoiceString d (AppendChoiceString x y) =+ fromChoiceString d x `mappend` fromChoiceString d y+fromChoiceString _ EmptyChoiceString = mempty+{-# INLINE fromChoiceString #-}++modify_open :: StaticString -> Text+modify_open open =+ let a = getText open+ in T.cons '<' (T.append "html:" (T.tail a))++modify_key :: StaticString -> Text+modify_key key =+ let a = getText key+ in T.dropEnd 2 (T.strip a)++-- Escape for forester lexer+wrap_verb :: Builder -> Builder+wrap_verb w = B.fromLazyText $ L.foldr go "" (B.toLazyText w)+ where+ go :: Char -> L.Text -> L.Text+ go '[' acc = L.append "\\startverb[\\stopverb" acc+ go ']' acc = L.append "\\startverb]\\stopverb" acc+ go x acc = L.cons x acc++renderMarkupBuilderWith ::+ (ByteString -> Text) ->+ Html ->+ Builder+renderMarkupBuilderWith d = go mempty+ where+ go :: Builder -> MarkupM b -> Builder+ go attrs (Parent _ open close content) =+ mconcat+ [ B.fromText "\\",+ B.fromText (modify_open open),+ B.fromText ">",+ attrs,+ B.fromText "{",+ go mempty content,+ B.fromText "}"+ ]+ go attrs (CustomParent tag content) =+ mconcat+ [ B.fromText "\\<html:",+ fromChoiceString d tag,+ B.fromText ">",+ attrs,+ B.fromText "{",+ go mempty content,+ fromChoiceString d tag,+ B.fromText "}"+ ]+ go attrs (Leaf _ begin end _) =+ mconcat+ [ B.fromText (modify_open begin),+ B.fromText ">",+ attrs,+ B.fromText "{}"+ ]+ go attrs (CustomLeaf tag close _) =+ mconcat+ [ B.fromText "\\<html:",+ fromChoiceString d tag,+ attrs,+ B.fromText ">{}"+ ]+ go attrs (AddAttribute _ key value h) =+ go+ ( mconcat+ [ B.singleton '[',+ B.fromText (modify_key key),+ B.fromText "]{",+ wrap_verb (fromChoiceString d value),+ B.fromText "}",+ attrs+ ]+ )+ h+ go attrs (AddCustomAttribute key value h) =+ go+ ( mconcat+ [ B.singleton '[',+ fromChoiceString d key,+ B.fromText "]{",+ wrap_verb (fromChoiceString d value),+ B.fromText "}",+ attrs+ ]+ )+ h+ go _ (Content content _) = wrap_verb (fromChoiceString d content)+ go _ (Comment comment _) = B.fromText "% " <> fromChoiceString d comment+ go attrs (Append h1 h2) = go attrs h1 <> go attrs h2+ go _ (Empty _) = mempty+ {-# NOINLINE go #-}+{-# INLINE renderMarkupBuilderWith #-}++renderMarkupWith :: (ByteString -> Text) -> Html -> L.Text+renderMarkupWith d = B.toLazyText . renderMarkupBuilderWith d+{-# INLINE renderMarkupWith #-}++renderForesterHtml :: Html -> L.Text+renderForesterHtml = renderMarkupWith decodeUtf8+{-# INLINE renderForesterHtml #-}
@@ -0,0 +1,85 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Functions which give precise syntax highlighting info in JSON format.++module Agda.Interaction.Highlighting.JSON (jsonifyHighlightingInfo) where++import qualified Data.ByteString.Lazy.Char8 as BS++import Agda.Interaction.Highlighting.Common+import Agda.Interaction.Highlighting.Precise hiding (String)+import Agda.Utils.Range (Range(..))+import Agda.Interaction.JSON+import Agda.Interaction.Response++import Agda.TypeChecking.Monad (HighlightingMethod(..), ModuleToSource, topLevelModuleFilePath)++import Agda.Utils.FileName (AbsolutePath, filePath)+import Agda.Utils.IO.TempFile (writeToTempFile)+import Agda.Utils.CallStack (HasCallStack)++-- | Encode meta information into a JSON Value+showAspects+ :: ModuleToSource+ -- ^ Must contain a mapping for the definition site's module, if any.+ -> (Range, Aspects) -> Value+showAspects modFile (range, aspect) = object+ [ "range" .= [from range, to range]+ , "atoms" .= toAtoms aspect+ , "tokenBased" .= tokenBased aspect+ , "note" .= note aspect+ , "definitionSite" .= fmap defSite (definitionSite aspect)+ ]+ where+ defSite (DefinitionSite mdl position _ _) = object+ [ "filepath" .= filePath f+ , "position" .= position+ ]+ where+ f :: HasCallStack => AbsolutePath+ f = topLevelModuleFilePath modFile mdl -- partial function, so use CallStack!++instance EncodeTCM TokenBased where+instance ToJSON TokenBased where+ toJSON TokenBased = String "TokenBased"+ toJSON NotOnlyTokenBased = String "NotOnlyTokenBased"++-- | Turns syntax highlighting information into a JSON value+jsonifyHighlightingInfo+ :: HighlightingInfo+ -> RemoveTokenBasedHighlighting+ -> HighlightingMethod+ -> ModuleToSource+ -- ^ Must contain a mapping for every definition site's module.+ -> Maybe FilePath+ -> IO Value+jsonifyHighlightingInfo info remove method modFile file =+ case chooseHighlightingMethod info method of+ Direct -> direct+ Indirect -> indirect+ where+ result :: Value+ result = object+ [ "remove" .= case remove of+ RemoveHighlighting -> True+ KeepHighlighting -> False+ , "payload" .= map (showAspects modFile) (toList info)+ ]++ direct :: IO Value+ direct = return $ object $+ [ "kind" .= String "HighlightingInfo"+ , "direct" .= True+ , "info" .= result+ ] ++ fileField++ indirect :: IO Value+ indirect = do+ filepath <- writeToTempFile (BS.unpack (encode result))+ return $ object $+ [ "kind" .= String "HighlightingInfo"+ , "direct" .= False+ , "filepath" .= filepath+ ] ++ fileField++ fileField = maybe [] (\path -> ["file" .= path]) file
@@ -0,0 +1,12 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Generating highlighted and aligned LaTeX from literate Agda source.++module Agda.Interaction.Highlighting.LaTeX+ ( module Exports+ ) where++import Agda.Interaction.Highlighting.LaTeX.Backend as Exports+ ( latexBackend+ , latexBackendName+ )
@@ -0,0 +1,214 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.Highlighting.LaTeX.Backend+ ( latexBackend+ , latexBackendName+ ) where++import Agda.Interaction.Highlighting.LaTeX.Base+ ( LaTeXOptions(..)+ , MonadLogLaTeX(logLaTeX)+ , logMsgToText+ , generateLaTeXIO+ , prepareCommonAssets+ )++import Control.DeepSeq+import Control.Monad.Trans (MonadIO)++import Data.Functor ( (<&>) )+import qualified Data.Map as Map+import Data.Map ( Map )+import qualified Data.Text as T++import GHC.Generics (Generic)++import System.FilePath ( (</>) )++import Agda.Compiler.Backend (Backend,Backend_boot(..), Backend',Backend'_boot(..), Definition, Recompile(..))+import Agda.Compiler.Common (curIF, IsMain(IsMain, NotMain))++import Agda.Interaction.Options+ ( ArgDescr(NoArg, ReqArg)+ , CommandLineOptions ( optGHCiInteraction, optPragmaOptions )+ , optCountClusters+ , Flag+ , OptDescr(..)+ )++import Agda.Syntax.Common (BackendName)+import Agda.Syntax.Position (mkRangeFile, rangeFilePath)+import Agda.Syntax.TopLevelModuleName (TopLevelModuleName, projectRoot)++import Agda.TypeChecking.Monad+ ( HasOptions(commandLineOptions)+ , MonadDebug+ , useSession, lensModuleToSourceId+ , ReadTCState+ , reportS+ , MonadFileId+ , srcFilePath, ReadTCState+ )++import Agda.Utils.FileName (filePath, mkAbsolute)++------------------------------------------------------------------------+-- * Main.++-- Command-line flag options, prior to e.g. path resolution and validation.+data LaTeXFlags = LaTeXFlags+ { latexFlagOutDir :: FilePath+ , latexFlagSourceFile :: Maybe FilePath+ , latexFlagGenerateLaTeX :: Bool+ -- ^ Are we going to try to generate LaTeX at all?+ } deriving (Eq, Generic)++instance NFData LaTeXFlags++-- | The default output directory for LaTeX.++defaultLaTeXDir :: FilePath+defaultLaTeXDir = "latex"++defaultLaTeXFlags :: LaTeXFlags+defaultLaTeXFlags = LaTeXFlags+ { latexFlagOutDir = defaultLaTeXDir+ , latexFlagSourceFile = Nothing+ , latexFlagGenerateLaTeX = False+ }++-- | Command-line flag options for LaTeX.+-- The 'latexPragmaOptions' are not included here since they have a different 'Flag' type.+latexFlagsDescriptions :: [OptDescr (Flag LaTeXFlags)]+latexFlagsDescriptions =+ [ Option [] ["latex"] (NoArg latexFlag)+ "generate LaTeX with highlighted source code"+ , Option [] ["latex-dir"] (ReqArg latexDirFlag "DIR")+ ("directory in which LaTeX files are placed (default: " +++ defaultLaTeXDir ++ ")")+ ]++latexFlag :: Flag LaTeXFlags+latexFlag o = return $ o { latexFlagGenerateLaTeX = True }++latexDirFlag :: FilePath -> Flag LaTeXFlags+latexDirFlag d o = return $ o { latexFlagOutDir = d }++data LaTeXCompileEnv = LaTeXCompileEnv LaTeXFlags+data LaTeXModuleEnv = LaTeXModuleEnv LaTeXOptions+data LaTeXModule = LaTeXModule+data LaTeXDef = LaTeXDef++latexBackendName :: BackendName+latexBackendName = "LaTeX"++latexBackend :: Backend+latexBackend = Backend latexBackend'++latexBackend' :: Backend' LaTeXFlags LaTeXCompileEnv LaTeXModuleEnv LaTeXModule LaTeXDef+latexBackend' = Backend'+ { backendName = latexBackendName+ , backendVersion = Nothing+ , options = defaultLaTeXFlags+ , commandLineFlags = latexFlagsDescriptions+ , isEnabled = latexFlagGenerateLaTeX+ , preCompile = preCompileLaTeX+ , preModule = preModuleLaTeX+ , compileDef = compileDefLaTeX+ , postModule = postModuleLaTeX+ , postCompile = postCompileLaTeX+ , scopeCheckingSuffices = True+ , mayEraseType = const $ return False+ , backendInteractTop = Nothing+ , backendInteractHole = Nothing+ }++-- | A wrapper to implement 'MonadLogLaTeX'.+newtype LogLaTeXDebugT m a = LogLaTeXDebugT { runLogLaTeXDebugT :: m a }+ deriving (Functor, Applicative, Monad, MonadIO)++instance MonadDebug m => MonadLogLaTeX (LogLaTeXDebugT m) where+ logLaTeX = LogLaTeXDebugT . (reportS "compile.latex" 1) . T.unpack . logMsgToText++-- Resolve the raw flags into usable LaTeX options.+resolveLaTeXOptions :: (ReadTCState m, HasOptions m, MonadFileId m)+ => LaTeXFlags+ -> TopLevelModuleName+ -> m LaTeXOptions+resolveLaTeXOptions flags moduleName = do+ options <- commandLineOptions+ modFiles <- useSession lensModuleToSourceId+ let msrc = Map.lookup moduleName modFiles+ mf <- traverse srcFilePath msrc+ let+ mSrcFileName = mf <&> \ f ->+ mkRangeFile (mkAbsolute (filePath f)) (Just moduleName)+ -- TODO: ^^^^^^^^^^^^^^^^^^^^^^^^^ can this just be `f`?+ countClusters = optCountClusters . optPragmaOptions $ options+ latexDir = latexFlagOutDir flags+ -- FIXME: This reliance on emacs-mode to decide whether to interpret the output location as project-relative or+ -- cwd-relative is gross. Also it currently behaves differently for JSON mode :-/+ -- And it prevents us from doing a real "one-time" setup.+ outDir = case (mSrcFileName, optGHCiInteraction options) of+ (Just sourceFile, True) ->+ filePath (projectRoot (rangeFilePath sourceFile) moduleName) </>+ latexDir+ _ -> latexDir+ return LaTeXOptions+ { latexOptOutDir = outDir+ , latexOptSourceFileName = mSrcFileName+ , latexOptCountClusters = countClusters+ }++preCompileLaTeX+ :: Applicative m+ => LaTeXFlags+ -> m LaTeXCompileEnv+preCompileLaTeX flags = pure $ LaTeXCompileEnv flags++preModuleLaTeX+ :: (HasOptions m, ReadTCState m, MonadFileId m)+ => LaTeXCompileEnv+ -> IsMain+ -> TopLevelModuleName+ -> Maybe FilePath+ -> m (Recompile LaTeXModuleEnv LaTeXModule)+preModuleLaTeX (LaTeXCompileEnv flags) isMain moduleName _ifacePath = case isMain of+ IsMain -> Recompile . LaTeXModuleEnv <$> resolveLaTeXOptions flags moduleName+ NotMain -> return $ Skip LaTeXModule++compileDefLaTeX+ :: Applicative m+ => LaTeXCompileEnv+ -> LaTeXModuleEnv+ -> IsMain+ -> Definition+ -> m LaTeXDef+compileDefLaTeX _cenv _menv _main _def = pure LaTeXDef++postModuleLaTeX+ :: (MonadDebug m, ReadTCState m, MonadIO m)+ => LaTeXCompileEnv+ -> LaTeXModuleEnv+ -> IsMain+ -> TopLevelModuleName+ -> [LaTeXDef]+ -> m LaTeXModule+postModuleLaTeX _cenv (LaTeXModuleEnv latexOpts) _main _moduleName _defs = do+ i <- curIF+ runLogLaTeXDebugT do+ -- FIXME: It would be better to do "prepareCommonAssets" in @preCompileLaTeX@, but because+ -- the output directory depends on the module-relative project root (when in emacs-mode),+ -- we can't do that until we see the module.+ -- However, for now that is OK because we only generate LaTeX for the main module.+ prepareCommonAssets (latexOptOutDir latexOpts)+ generateLaTeXIO latexOpts i+ return LaTeXModule++postCompileLaTeX+ :: Applicative m+ => LaTeXCompileEnv+ -> IsMain+ -> Map TopLevelModuleName LaTeXModule+ -> m ()+postCompileLaTeX _cenv _main _modulesByName = pure ()
@@ -0,0 +1,852 @@+{-# LANGUAGE CPP #-}++-- | Function for generating highlighted and aligned LaTeX from literate+-- Agda source.++module Agda.Interaction.Highlighting.LaTeX.Base+ ( LaTeXOptions(..)+ , generateLaTeXIO+ , prepareCommonAssets+ , MonadLogLaTeX(logLaTeX)+ , LogMessage(..)+ , logMsgToText+ ) where++import Prelude hiding (log)++import Data.Bifunctor (second)+import Data.Char+import Data.Maybe+import Data.Function (on)+import Data.Foldable (toList)++import Control.Exception.Base (IOException, try)+import Control.Monad.Trans.Reader as R ( ReaderT(runReaderT))+import Control.Monad.RWS.Strict+ ( RWST(runRWST)+ , MonadReader(..), asks+ , MonadState(..), gets, modify+ , lift, tell+ )+import Control.Monad.IO.Class+ ( MonadIO(..)+ )++import System.Directory+import System.FilePath+import System.Process ( readProcess )++import Data.Text (Text)+import qualified Data.Text as T+#ifdef COUNT_CLUSTERS+import qualified Data.Text.ICU as ICU+#endif+import qualified Data.Text.Lazy as L+import qualified Data.Text.Lazy.Encoding as E+import qualified Data.ByteString.Lazy as BS++import Data.HashSet (HashSet)+import qualified Data.HashSet as Set+import qualified Data.IntMap as IntMap+import qualified Data.List as List++import Agda.Syntax.Common+import Agda.Syntax.Parser.Literate (literateTeX, LayerRole, atomizeLayers)+import qualified Agda.Syntax.Parser.Literate as L+import Agda.Syntax.Position (RangeFile, startPos')+import Agda.Syntax.TopLevelModuleName+ (TopLevelModuleName, moduleNameParts)++import Agda.Interaction.Highlighting.Precise hiding (toList)++import Agda.TypeChecking.Monad (Interface(..)) --, reportSLn)++import Agda.Setup ( getDataFileName )++import Agda.Utils.Function (applyWhen)+import Agda.Utils.Functor ((<&>))+import Agda.Utils.List (last1, updateHead, updateLast)+import Agda.Utils.Maybe (whenJust)+import Agda.Utils.Monad+import qualified Agda.Utils.List1 as List1++import Agda.Utils.Impossible++------------------------------------------------------------------------+-- * Logging++-- | Log LaTeX messages using a provided action.+--+-- This could be accomplished by putting logs into the RWST output and splitting it+-- into a WriterT, but that becomes slightly more complicated to reason about in+-- the presence of IO exceptions.+--+-- We want the logging to be reasonably polymorphic, avoid space leaks that can occur+-- with WriterT, and also be usable during outer phases such as directory preparation.++class Monad m => MonadLogLaTeX m where+ logLaTeX :: LogMessage -> m ()++data LogMessage = LogMessage Debug Text [Text] deriving Show++------------------------------------------------------------------------+-- * The monad and its associated data types.++-- | The @LaTeX@ monad is a combination of @RWST@ and a logger @m@.+--+-- The reader part contains static options used,+-- the writer is where the output goes,+-- the state is for keeping track of the tokens and some other useful info, and+-- the MonadLogLaTeX part is used for printing debugging info.++type LaTeXT = RWST Env [Output] State+type LaTeX a = forall m. MonadLogLaTeX m => LaTeXT m a+-- Andreas, 2025-03-23 we sometimes expand @a -> LaTeX b@+-- to @forall m. MonadLogLaTeX m => a -> LaTeXT m b@+-- to combat changes in the type checker of GHC 9 over GHC 8.+-- Originally (by asr, 2021-02-07) we used eta-expansions in these places+-- to circumvent the GHC type checker regressions (see Issue #4955).++-- | Output items.++data Output+ = Text !Text+ -- ^ A piece of text.+ | MaybeColumn !AlignmentColumn+ -- ^ A column. If it turns out to be an indentation column that is+ -- not used to indent or align something, then no column will be+ -- generated, only whitespace ('agdaSpace').+ deriving Show++-- | Column kinds.++data Kind+ = Indentation+ -- ^ Used only for indentation (the placement of the first token+ -- on a line, relative to tokens on previous lines).+ | Alignment+ -- ^ Used both for indentation and for alignment.+ deriving (Eq, Show)++-- | Unique identifiers for indentation columns.++type IndentationColumnId = Int++-- | Alignment and indentation columns.++data AlignmentColumn = AlignmentColumn+ { columnCodeBlock :: !Int+ -- ^ The column's code block.+ , columnColumn :: !Int+ -- ^ The column number.+ , columnKind :: Maybe IndentationColumnId+ -- ^ The column kind. 'Nothing' for alignment columns and @'Just'+ -- i@ for indentation columns, where @i@ is the column's unique+ -- identifier.+ } deriving Show++-- | Type of function for estimating column width of text.++type TextWidthEstimator = Text -> Int++data Env = Env+ { estimateTextWidth :: !TextWidthEstimator+ -- ^ How to estimate the column width of text (i.e. Count extended grapheme clusters vs. code points).+ , debugs :: [Debug]+ -- ^ Says what debug information should printed.+ }++data State = State+ { codeBlock :: !Int -- ^ The number of the current code block.+ , column :: !Int -- ^ The current column number.+ , columns :: [AlignmentColumn]+ -- ^ All alignment columns found on the+ -- current line (so far), in reverse+ -- order.+ , columnsPrev :: [AlignmentColumn]+ -- ^ All alignment columns found in+ -- previous lines (in any code block),+ -- with larger columns coming first.+ , nextId :: !IndentationColumnId+ -- ^ The next indentation column+ -- identifier.+ , usedColumns :: HashSet IndentationColumnId+ -- ^ Indentation columns that have+ -- actually+ -- been used.+ }++type Tokens = [Token]++data Token = Token+ { text :: !Text+ , info :: Aspects+ }+ deriving Show++withTokenText :: (Text -> Text) -> Token -> Token+withTokenText f tok@Token{text = t} = tok{text = f t}++data Debug = MoveColumn | NonCode | Code | Spaces | Output | FileSystem+ deriving (Eq, Show)++-- | Run function for the @LaTeX@ monad.+runLaTeX ::+ LaTeXT m a -> Env -> State -> m (a, State, [Output])+runLaTeX = runRWST++emptyState :: State+emptyState = State+ { codeBlock = 0+ , column = 0+ , columns = []+ , columnsPrev = []+ , nextId = 0+ , usedColumns = Set.empty+ }++emptyEnv+ :: TextWidthEstimator -- ^ Count extended grapheme clusters?+ -> Env+emptyEnv twe = Env twe []+++------------------------------------------------------------------------+-- * Some helpers.++-- | Gives the size of the string. If cluster counting is enabled,+-- then the number of extended grapheme clusters is computed (the root+-- locale is used), and otherwise the number of code points.++size :: Text -> LaTeX Int+size t = asks estimateTextWidth <&> ($ t)++-- | Does the string consist solely of whitespace?++isSpaces :: Text -> Bool+isSpaces = T.all isSpace++-- | Is the character a whitespace character distinct from '\n'?++isSpaceNotNewline :: Char -> Bool+isSpaceNotNewline c = isSpace c && c /= '\n'++-- | Replaces all forms of whitespace, except for new-line characters,+-- with spaces.++replaceSpaces :: Text -> Text+replaceSpaces = T.map (\c -> if isSpaceNotNewline c then ' ' else c)+++-- | If the `Token` consists of spaces, the internal column counter is advanced+-- by the length of the token. Otherwise, `moveColumnForToken` is a no-op.+moveColumnForToken :: Token -> LaTeX ()+moveColumnForToken Token{ text = t } = do+ unless (isSpaces t) do+ log MoveColumn t+ moveColumn =<< size t++-- | Merges 'columns' into 'columnsPrev', resets 'column' and+-- 'columns'++resetColumn :: LaTeX ()+resetColumn = modify $ \s ->+ s { column = 0+ , columnsPrev = mergeCols (columns s) (columnsPrev s)+ , columns = []+ }+ where+ -- Remove shadowed columns from old.+ mergeCols [] old = old+ mergeCols new@(n:ns) old = new ++ filter ((< leastNew) . columnColumn) old+ where+ leastNew = columnColumn (last1 n ns)++moveColumn :: MonadLogLaTeX m => Int -> LaTeXT m ()+moveColumn i = modify \ s -> s { column = i + column s }++-- | Registers a column of the given kind. The column is returned.++registerColumn :: Kind -> LaTeX AlignmentColumn+registerColumn kind = do+ column <- gets column+ codeBlock <- gets codeBlock+ colKind <- case kind of+ Alignment -> return Nothing+ Indentation -> do+ nextId <- gets nextId+ modify $ \s -> s { nextId = succ nextId }+ return (Just nextId)+ let c = AlignmentColumn { columnColumn = column+ , columnCodeBlock = codeBlock+ , columnKind = colKind+ }+ modify $ \s -> s { columns = c : columns s }+ return c++-- | Registers the given column as used (if it is an indentation+-- column).++useColumn :: AlignmentColumn -> LaTeX ()+useColumn c = whenJust (columnKind c) $ \ i ->+ modify $ \ s -> s { usedColumns = Set.insert i (usedColumns s) }++-- | Alignment column zero in the current code block.++columnZero :: LaTeX AlignmentColumn+columnZero = do+ codeBlock <- gets codeBlock+ return $ AlignmentColumn { columnColumn = 0+ , columnCodeBlock = codeBlock+ , columnKind = Nothing+ }++-- | Registers column zero as an alignment column.++registerColumnZero :: LaTeX ()+registerColumnZero = do+ c <- columnZero+ modify $ \s -> s { columns = [c] }++-- | Changes to the state that are performed at the start of a code+-- block.++enterCode :: LaTeX ()+enterCode = do+ resetColumn+ modify $ \s -> s { codeBlock = codeBlock s + 1 }++-- | Changes to the state that are performed at the end of a code+-- block.++leaveCode :: LaTeX ()+leaveCode = return ()++tshow :: Show a => a -> Text+tshow = T.pack . show++logMsgToText :: LogMessage -> Text+logMsgToText (LogMessage messageLabel text extra) = T.concat $+ [ tshow messageLabel, ": '", text, "' "+ ] ++ if null extra then [] else ["(", T.unwords extra, ")"]++logHelper :: Debug -> Text -> [Text] -> LaTeX ()+logHelper debug text extra = do+ logLevels <- debugs <$> ask+ when (debug `elem` logLevels) $ do+ lift $ logLaTeX (LogMessage debug text extra)++log :: Debug -> Text -> LaTeX ()+log MoveColumn text = do+ cols <- gets columns+ logHelper MoveColumn text ["columns=", tshow cols]+log Code text = do+ cols <- gets columns+ col <- gets column+ logHelper Code text ["columns=", tshow cols, "col=", tshow col]+log debug text = logHelper debug text []++output :: MonadLogLaTeX m => Output -> LaTeXT m ()+output item = do+ log Output $ tshow item+ tell [item]++------------------------------------------------------------------------+-- * LaTeX and polytable strings.++-- Polytable, http://www.ctan.org/pkg/polytable, is used for code+-- alignment, similar to lhs2TeX's approach.++nl :: Text+nl = "%\n"++-- | A command that is used when two tokens are put next to each other+-- in the same column.++agdaSpace :: Text+agdaSpace = cmdPrefix <> "Space" <> cmdArg T.empty <> nl++-- | The column's name.+--+-- Indentation columns have unique names, distinct from all alignment+-- column names.++columnName :: AlignmentColumn -> Text+columnName c = T.pack $ case columnKind c of+ Nothing -> show (columnColumn c)+ Just i -> show i ++ "I"++-- | Opens a column with the given name.++ptOpen' :: Text -> Text+ptOpen' name = "\\>[" <> name <> "]"++-- | Opens the given column.++ptOpen :: AlignmentColumn -> Text+ptOpen c = ptOpen' (columnName c)++-- | Opens a special column that is only used at the beginning of+-- lines.++ptOpenBeginningOfLine :: Text+ptOpenBeginningOfLine = ptOpen' "." <> "[@{}l@{}]"++-- | Opens the given column, and inserts an indentation instruction+-- with the given argument at the end of it.++ptOpenIndent+ :: AlignmentColumn+ -> Int -- ^ Indentation instruction argument.+ -> Text+ptOpenIndent c delta =+ ptOpen c <> "[@{}l@{"+ <> cmdPrefix+ <> "Indent"+ <> cmdArg (T.pack $ show delta)+ <> "}]"++ptClose :: Text+ptClose = "\\<"++ptClose' :: AlignmentColumn -> Text+ptClose' c =+ ptClose <> "[" <> columnName c <> "]"++ptNL :: Text+ptNL = nl <> "\\\\\n"++ptEmptyLine :: Text+ptEmptyLine =+ nl <> "\\\\["+ <> cmdPrefix+ <> "EmptyExtraSkip"+ <> "]%\n"++cmdPrefix :: Text+cmdPrefix = "\\Agda"++cmdArg :: Text -> Text+cmdArg x = "{" <> x <> "}"++------------------------------------------------------------------------+-- * Output generation from a stream of labelled tokens.++processLayers :: MonadLogLaTeX m => [(LayerRole, Tokens)] -> LaTeXT m ()+processLayers = mapM_ \ (layerRole, toks) -> do+ case layerRole of+ L.Markup -> processMarkup toks+ L.Comment -> processComment toks+ L.Code -> processCode toks++-- | Deals with markup, which is output verbatim.+processMarkup :: MonadLogLaTeX m => Tokens -> LaTeXT m ()+processMarkup = mapM_ \ t -> do+ moveColumnForToken t+ output $ Text $ text t++-- | Deals with literate text, which is output verbatim+processComment :: MonadLogLaTeX m => Tokens -> LaTeXT m ()+processComment = mapM_ \ t -> do+ let t' = text t+ unless ("%" == T.take 1 (T.stripStart t')) $ do+ moveColumnForToken t+ output $ Text t'++-- | Deals with code blocks. Every token, except spaces, is pretty+-- printed as a LaTeX command.+processCode :: Tokens -> LaTeX ()+processCode toks' = do+ output $ Text nl+ enterCode+ mapM_ go toks'+ ptOpenWhenColumnZero =<< gets column+ output $ Text $ ptClose <> nl+ leaveCode++ where+ go tok'@Token{ text = tok } = do+ -- Get the column information before grabbing the token, since+ -- grabbing (possibly) moves the column.+ col <- gets column++ moveColumnForToken tok'+ log Code tok++ unless (T.null tok) $+ if (isSpaces tok) then do+ spaces $ T.group $ replaceSpaces tok+ else do+ ptOpenWhenColumnZero col+ output $ Text $+ -- we return the escaped token wrapped in commands corresponding+ -- to its aspect (if any) and other aspects (e.g. error, unsolved meta)+ foldr (\c t -> cmdPrefix <> c <> cmdArg t)+ (escape tok)+ $ map fromOtherAspect (toList $ otherAspects $ info tok') +++ concatMap fromAspect (toList $ aspect $ info tok')++ -- Non-whitespace tokens at the start of a line trigger an+ -- alignment column.+ ptOpenWhenColumnZero col =+ when (col == 0) $ do+ registerColumnZero+ output . Text . ptOpen =<< columnZero++ -- Translation from OtherAspect to command strings. So far it happens+ -- to correspond to @show@ but it does not have to (cf. fromAspect)+ fromOtherAspect :: OtherAspect -> Text+ fromOtherAspect a = let s = T.pack (show a) in+ -- Andreas, 2026-02-17, issue #8402+ -- Expand OtherAspect into all of its cases+ -- such that a developer adding to OtherAspect gets alerted here.+ -- All ASPECTs need a corresponding @\AgdaASPECT@ command in agda.sty.+ case a of+ Error -> s+ ErrorWarning -> s+ DottedPattern -> s+ UnsolvedMeta -> s+ UnsolvedConstraint -> s+ TerminationProblem -> s+ PositivityProblem -> s+ Deadcode -> s+ ShadowingInTelescope -> s+ CoverageProblem -> s+ TypeChecks -> s+ MissingDefinition -> s+ InstanceProblem -> s+ CosmeticProblem -> s+ CatchallClause -> s+ ConfluenceProblem -> s++ fromAspect :: Aspect -> [Text]+ fromAspect a = let s = [T.pack $ show a] in case a of+ URL url -> [ "HRef", cmdArg url ]+ Comment -> s+ Keyword -> s+ Hole -> s+ String -> s+ Number -> s+ Symbol -> s+ PrimitiveType -> s+ Pragma -> s+ Background -> s+ Markup -> s+ Name Nothing isOp -> fromAspect (Name (Just Postulate) isOp)+ -- At the time of writing the case above can be encountered in+ -- --only-scope-checking mode, for instance for the token "Size"+ -- in the following code:+ --+ -- {-# BUILTIN SIZE Size #-}+ --+ -- The choice of "Postulate" works for this example, but might+ -- be less appropriate for others.+ Name (Just kind) isOp -> if isOp then ["Operator", c] else [c]+ where+ sk = T.pack $ show kind+ c = case kind of+ Bound -> sk+ Generalizable -> sk+ Constructor Inductive -> "InductiveConstructor"+ Constructor CoInductive -> "CoinductiveConstructor"+ Datatype -> sk+ Field -> sk+ Function -> sk+ Module -> sk+ Postulate -> sk+ Primitive -> sk+ Record -> sk+ Argument -> sk+ Macro -> sk++-- | Escapes special characters.+escape :: Text -> Text+escape (T.uncons -> Nothing) = T.empty+escape (T.uncons -> Just (c, s)) = T.pack (replace c) <> escape s+ where+ replace :: Char -> String+ replace char = case char of+ '_' -> "\\AgdaUnderscore{}"+ '{' -> "\\{"+ '}' -> "\\}"+ '#' -> "\\#"+ '$' -> "\\$"+ '&' -> "\\&"+ '%' -> "\\%"+ '~' -> "\\textasciitilde{}"+ '^' -> "\\textasciicircum{}"+ '\\' -> "\\textbackslash{}"+ ' ' -> "\\ "+ _ -> [ char ]++-- | Every element in the list should consist of either one or more+-- newline characters, or one or more space characters. Two adjacent+-- list elements must not contain the same character.+--+-- If the final element of the list consists of spaces, then these+-- spaces are assumed to not be trailing whitespace.+spaces :: [Text] -> LaTeX ()+spaces [] = return ()++-- Newlines.+spaces (s@(T.uncons -> Just ('\n', _)) : ss) = do+ col <- gets column+ when (col == 0) do+ output . Text . ptOpen =<< columnZero+ output $ Text $ ptClose <> ptNL <>+ T.replicate (T.length s - 1) ptEmptyLine+ resetColumn+ spaces ss++-- Spaces followed by a newline character.+spaces (_ : ss@(_ : _)) = spaces ss++-- Spaces that are not followed by a newline character.+spaces [ s ] = do+ col <- gets column++ let len = T.length s+ kind = if col /= 0 && len == 1+ then Indentation+ else Alignment++ moveColumn len+ column <- registerColumn kind++ if col /= 0+ then log Spaces "col /= 0"+ else do+ columns <- gets columnsPrev+ codeBlock <- gets codeBlock++ log Spaces $+ "col == 0: " <> T.pack (show (len, columns))++ case filter ((<= len) . columnColumn) columns of+ c : _ | columnColumn c == len, isJust (columnKind c) -> do+ -- Align. (This happens automatically if the column is an+ -- alignment column, but c is an indentation column.)+ useColumn c+ output $ Text $ ptOpenBeginningOfLine+ output $ Text $ ptClose' c+ c : _ | columnColumn c < len -> do+ -- Indent.+ useColumn c+ output $ Text $ ptOpenIndent c (codeBlock - columnCodeBlock c)+ _ -> return ()++ output $ MaybeColumn column++-- | Split multi-lines string literals into multiple string literals+-- Isolating leading spaces for the alignment machinery to work+-- properly+stringLiteral :: Token -> Tokens+stringLiteral t | aspect (info t) == Just String =+ map (\ x -> t { text = x })+ $ concatMap leadingSpaces+ $ List.intersperse "\n"+ $ T.lines (text t)+ where+ leadingSpaces :: Text -> [Text]+ leadingSpaces tok = [pre, suf]+ where (pre , suf) = T.span isSpaceNotNewline tok++stringLiteral t = [t]++-- | Split multi-line comments into several tokens.+-- See issue #5398.+multiLineComment :: Token -> Tokens+multiLineComment Token{ text = s, info = i } | aspect i == Just Comment =+ map (`Token` i)+ $ List.intersperse "\n"+ $ T.lines s+-- multiLineComment Token{ text = s, info = i } | aspect i == Just Comment =+-- map emptyToPar+-- $ List1.groupBy ((==) `on` T.null)+-- $ T.lines s+-- where+-- emptyToPar :: List1 Text -> Token+-- emptyToPar ts@(t :| _)+-- | T.null t = Token{ text = "\n", info = mempty }+-- | otherwise = Token{ text = sconcat $ List1.intersperse "\n" ts, info = i }+multiLineComment t = [t]++------------------------------------------------------------------------+-- * Main.++-- | The Agda data directory containing the files for the LaTeX backend.++latexDataDir :: FilePath+latexDataDir = "latex"++defaultStyFile :: String+defaultStyFile = "agda.sty"++data LaTeXOptions = LaTeXOptions+ { latexOptOutDir :: FilePath+ , latexOptSourceFileName :: Maybe RangeFile+ -- ^ The parser uses a @Position@ which includes a source filename for+ -- error reporting and such. We don't actually get the source filename+ -- with an @Interface@, and it isn't necessary to look it up.+ -- This is a "nice-to-have" parameter.+ , latexOptCountClusters :: Bool+ -- ^ Count extended grapheme clusters rather than code points when+ -- generating LaTeX.+ }++getTextWidthEstimator :: Bool -> TextWidthEstimator+getTextWidthEstimator _countClusters =+#ifdef COUNT_CLUSTERS+ if _countClusters+ then length . (ICU.breaks (ICU.breakCharacter ICU.Root))+ else T.length+#else+ T.length+#endif++-- | Create the common base output directory and check for/install the style file.+prepareCommonAssets :: (MonadLogLaTeX m, MonadIO m) => FilePath -> m ()+prepareCommonAssets dir = do+ -- Make sure @dir@ will exist.+ dirExisted <- liftIO $ doesDirectoryExist dir+ unless dirExisted $+ -- Create directory @dir@ and parent directories.+ liftIO $ createDirectoryIfMissing True dir++ -- Check whether TeX will find @agda.sty@.+ texFindsSty <- liftIO $ try $+ readProcess+ "kpsewhich"+ (applyWhen dirExisted (("--path=" ++ dir) :) [defaultStyFile])+ ""+ case texFindsSty of+ Right _ -> return ()+ Left (e :: IOException) -> do+ -- -- we are lacking MonadDebug here, so no debug printing via reportSLn+ -- reportSLn "compile.latex.sty" 70 $ unlines+ -- [ unwords [ "Searching for", defaultStyFile, "in", dir, "returns:" ]+ -- , show e+ -- ]+ let agdaSty = dir </> defaultStyFile+ unlessM (pure dirExisted `and2M` liftIO (doesFileExist agdaSty)) $ do+ -- It is safe now to create the default style file in @dir@ without overwriting+ -- a possibly user-edited copy there.+ logFileSystem $ unwords $+ [defaultStyFile, "was not found. Copying a default version of", defaultStyFile, "into", dir]+ liftIO $ do+ styFile <- getDataFileName $+ latexDataDir </> defaultStyFile+ copyFile styFile agdaSty++logFileSystem :: (MonadLogLaTeX m) => String -> m ()+logFileSystem s = logLaTeX $ LogMessage FileSystem (T.pack s) []++-- | Generates a LaTeX file for the given interface.+generateLaTeXIO :: (MonadLogLaTeX m, MonadIO m) => LaTeXOptions -> Interface -> m ()+generateLaTeXIO opts i = do+ let textWidthEstimator = getTextWidthEstimator (latexOptCountClusters opts)+ let baseDir = latexOptOutDir opts+ let outPath = baseDir </>+ latexOutRelativeFilePath (iTopLevelModuleName i)+ latex <- E.encodeUtf8 <$> toLaTeX+ (emptyEnv textWidthEstimator)+ (latexOptSourceFileName opts)+ (iSource i)+ (iHighlighting i)+ logFileSystem $ unwords [ "writing", outPath ]+ liftIO $ do+ createDirectoryIfMissing True (takeDirectory outPath)+ BS.writeFile outPath latex++latexOutRelativeFilePath :: TopLevelModuleName -> FilePath+latexOutRelativeFilePath m =+ List.intercalate [pathSeparator]+ (map T.unpack $ List1.toList $ moduleNameParts m) <.>+ "tex"++-- | Transforms the source code into LaTeX.+toLaTeX+ :: MonadLogLaTeX m+ => Env+ -> Maybe RangeFile+ -> L.Text+ -> HighlightingInfo+ -> m L.Text+toLaTeX env path source hi =++ processTokens env++ . map+ ( ( \(role, tokens) ->+ (role,) $+ -- This bit fixes issue 954+ ( applyWhen (L.isCode role) $+ -- Remove trailing whitespace from the+ -- final line; the function spaces+ -- expects trailing whitespace to be+ -- followed by a newline character.+ whenMoreThanOne+ ( updateLast+ $ withTokenText+ $ \suf ->+ maybe+ suf+ (T.dropWhileEnd isSpaceNotNewline)+ (T.stripSuffix "\n" suf)+ )+ . updateLast (withTokenText $ T.dropWhileEnd isSpaceNotNewline)+ . updateHead+ ( withTokenText $+ \pre ->+ fromMaybe pre $ T.stripPrefix "\n" $+ T.dropWhile+ isSpaceNotNewline+ pre+ )+ )+ tokens+ ) . ( second+ ( -- Split tokens at newlines+ concatMap stringLiteral+ . concatMap multiLineComment+ . List1.toList+ . fmap (\ (mi, cs) -> Token+ { text = T.pack $ List1.toList cs+ , info = fromMaybe mempty mi+ }+ )+ . List1.groupByFst1+ )+ )+ )+ . List1.groupByFst++ -- Look up the meta info at each position in the highlighting info.+ . zipWith (\pos (role, char) -> (role, (IntMap.lookup pos infoMap, char)))+ [1..]+ -- Map each character to its role+ . atomizeLayers+ . literateTeX (startPos' ())+ $ L.unpack source+ where+ infoMap = toMap hi++ whenMoreThanOne :: ([a] -> [a]) -> [a] -> [a]+ whenMoreThanOne f xs@(_:_:_) = f xs+ whenMoreThanOne _ xs = xs+++processTokens+ :: MonadLogLaTeX m+ => Env+ -> [(LayerRole, Tokens)]+ -> m L.Text+processTokens env ts = do+ ((), s, os) <- runLaTeX (processLayers ts) env emptyState+ return $ L.fromChunks $ map (render s) os+ where+ render _ (Text s) = s+ render s (MaybeColumn c)+ | Just i <- columnKind c,+ not (i `Set.member` usedColumns s) = agdaSpace+ | otherwise = nl <> ptOpen c
@@ -1,301 +1,313 @@-{-# LANGUAGE DeriveDataTypeable #-}- -- | Types used for precise syntax highlighting. module Agda.Interaction.Highlighting.Precise- ( Aspect(..)+ ( -- * Highlighting information+ Aspect(..) , NameKind(..) , OtherAspect(..)- , MetaInfo(..)- , File+ , Aspects(..)+ , DefinitionSite(..)+ , TokenBased(..)+ , RangePair(..)+ , rangePairInvariant+ , PositionMap(..)+ , DelayedMerge(..)+ , delayedMergeInvariant , HighlightingInfo- , singleton- , several- , smallestPos- , toMap- , CompressedFile- , compress- , decompress- , Agda.Interaction.Highlighting.Precise.tests+ , highlightingInfoInvariant+ , HighlightingInfoBuilder+ , highlightingInfoBuilderInvariant+ -- ** Operations+ , parserBased+ , kindOfNameToNameKind+ , IsBasicRangeMap(..)+ , RangeMap.several+ , Convert(..)+ , RangeMap.insideAndOutside+ , RangeMap.restrictTo ) where -import Agda.Utils.TestHelpers-import Agda.Utils.String-import Agda.Utils.List hiding (tests)-import Data.List-import Data.Function-import Data.Monoid-import Control.Monad-import Agda.Utils.QuickCheck-import Data.Map (Map)-import qualified Data.Map as Map-import Data.Generics (Typeable, Data)+import Prelude hiding (null) -import qualified Agda.Syntax.Abstract.Name as A-import qualified Agda.Syntax.Common as C-import qualified Agda.Syntax.Concrete as SC+import Control.DeepSeq -import Agda.Interaction.Highlighting.Range+import Data.Function (on)+import Data.Semigroup ( Endo(..) ) ---------------------------------------------------------------------------- Files+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import Data.Set (Set)+import qualified Data.Set as Set --- | Various more or less syntactic aspects of the code. (These cannot--- overlap.)+import GHC.Generics (Generic) -data Aspect- = Comment- | Keyword- | String- | Number- | Symbol -- ^ Symbols like forall, =, ->, etc.- | PrimitiveType -- ^ Things like Set and Prop.- | Name (Maybe NameKind) Bool -- ^ Is the name an operator part?- deriving (Eq, Show, Typeable, Data)+import Agda.Syntax.Common qualified as Common+import Agda.Syntax.TopLevelModuleName+import Agda.Syntax.Abstract.Name ( KindOfName(..) ) -data NameKind- = Bound -- ^ Bound variable.- | Constructor C.Induction -- ^ Inductive or coinductive constructor.- | Datatype- | Field -- ^ Record field.- | Function- | Module -- ^ Module name.- | Postulate- | Primitive -- ^ Primitive.- | Record -- ^ Record type.- deriving (Eq, Show, Typeable, Data)+import Agda.Utils.Range --- | Other aspects. (These can overlap with each other and with--- 'Aspect's.)+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Null+import Agda.Utils.RangeMap (RangeMap, IsBasicRangeMap(..))+import qualified Agda.Utils.RangeMap as RangeMap -data OtherAspect- = Error- | DottedPattern- | UnsolvedMeta- | TerminationProblem- | IncompletePattern- -- ^ When this constructor is used it is probably a good idea to- -- include a 'note' explaining why the pattern is incomplete.- deriving (Eq, Show, Enum, Bounded, Typeable, Data)+import Agda.Syntax.Common.Aspect+import Agda.Utils.String --- | Meta information which can be associated with a--- character\/character range.+import Agda.Utils.Impossible -data MetaInfo = MetaInfo- { aspect :: Maybe Aspect- , otherAspects :: [OtherAspect]- , note :: Maybe String- -- ^ This note, if present, can be displayed as a tool-tip or- -- something like that. It should contain useful information about- -- the range (like the module containing a certain identifier, or- -- the fixity of an operator).- , definitionSite :: Maybe (SC.TopLevelModuleName, Integer)- -- ^ The definition site of the annotated thing, if applicable and- -- known. File positions are counted from 1.+-- | A limited kind of syntax highlighting information: a pair+-- consisting of 'Ranges' and 'Aspects'.+--+-- Note the invariant which 'RangePair's should satisfy+-- ('rangePairInvariant').++newtype RangePair = RangePair+ { rangePair :: (Ranges, Aspects) }- deriving (Eq, Show, Typeable, Data)+ deriving (Show, NFData) --- | A 'File' is a mapping from file positions to meta information.+-- | Invariant for 'RangePair'.++rangePairInvariant :: RangePair -> Bool+rangePairInvariant (RangePair (rs, _)) =+ rangesInvariant rs++-- | Syntax highlighting information, represented by maps from+-- positions to 'Aspects'. -- -- The first position in the file has number 1. -newtype File = File { mapping :: Map Integer MetaInfo }- deriving (Eq, Show, Typeable, Data)+newtype PositionMap = PositionMap+ { positionMap :: IntMap Aspects+ }+ deriving (Show, NFData) --- | Returns the smallest position, if any, in the 'File'.+-- | Highlighting info with delayed merging.+--+-- Merging large sets of highlighting info repeatedly might be costly.+-- The idea of this type is to accumulate small pieces of highlighting+-- information, and then to merge them all at the end.+--+-- Note the invariant which values of this type should satisfy+-- ('delayedMergeInvariant'). -smallestPos :: File -> Maybe Integer-smallestPos = fmap (fst . fst) . Map.minViewWithKey . mapping+newtype DelayedMerge hl = DelayedMerge (Endo [hl])+ deriving (Semigroup, Monoid) --- | Syntax highlighting information for a given source file.+instance Show hl => Show (DelayedMerge hl) where+ showsPrec _ (DelayedMerge f) =+ showString "DelayedMerge (Endo (" .+ shows (appEndo f []) .+ showString " ++))" -type HighlightingInfo = CompressedFile+-- | Invariant for @'DelayedMerge' hl@, parametrised by the invariant+-- for @hl@.+--+-- Additionally the endofunction should be extensionally equal to @(fs+-- '++')@ for some list @fs@. ---------------------------------------------------------------------------- Creation+delayedMergeInvariant :: (hl -> Bool) -> DelayedMerge hl -> Bool+delayedMergeInvariant inv (DelayedMerge f) =+ all inv (appEndo f []) --- | @'singleton' r m@ is a file whose positions are those in @r@, and--- in which every position is associated with @m@.+-- | Highlighting information.+--+-- Note the invariant which values of this type should satisfy+-- ('highlightingInfoInvariant').+--+-- This is a type synonym in order to make it easy to change to+-- another representation. -singleton :: Range -> MetaInfo -> File-singleton r m = File {- mapping = Map.fromAscList [ (p, m) | p <- toList r ] }+type HighlightingInfo = RangeMap Aspects -prop_singleton r m =- compress (singleton r m) ==- if null (toList r) then [] else [(r, m)]+-- | The invariant for 'HighlightingInfo'. --- | Like 'singleton', but with several ranges instead of only one.+highlightingInfoInvariant :: HighlightingInfo -> Bool+highlightingInfoInvariant = RangeMap.rangeMapInvariant -several :: [Range] -> MetaInfo -> File-several rs m = mconcat $ map (\r -> singleton r m) rs+-- | A type that is intended to be used when constructing highlighting+-- information.+--+-- Note the invariant which values of this type should satisfy+-- ('highlightingInfoBuilderInvariant').+--+-- This is a type synonym in order to make it easy to change to+-- another representation.+--+-- The type should be an instance of @'IsBasicRangeMap' 'Aspects'@,+-- 'Semigroup' and 'Monoid', and there should be an instance of+-- @'Convert' 'HighlightingInfoBuilder' 'HighlightingInfo'@. +type HighlightingInfoBuilder = DelayedMerge RangePair++-- | The invariant for 'HighlightingInfoBuilder'.+--+-- Additionally the endofunction should be extensionally equal to @(fs+-- '++')@ for some list @fs@.++highlightingInfoBuilderInvariant :: HighlightingInfoBuilder -> Bool+highlightingInfoBuilderInvariant =+ delayedMergeInvariant rangePairInvariant+ --------------------------------------------------------------------------- Merging+-- Creation and conversion --- | Merges meta information.+-- | A variant of 'mempty' with 'tokenBased' set to+-- 'NotOnlyTokenBased'. -mergeMetaInfo :: MetaInfo -> MetaInfo -> MetaInfo-mergeMetaInfo m1 m2 = MetaInfo- { aspect = (mplus `on` aspect) m1 m2- , otherAspects = nub $ ((++) `on` otherAspects) m1 m2- , note = case (note m1, note m2) of- (Just n1, Just n2) -> Just $- if n1 == n2 then n1- else addFinalNewLine n1 ++ "----\n" ++ n2- (Just n1, Nothing) -> Just n1- (Nothing, Just n2) -> Just n2- (Nothing, Nothing) -> Nothing- , definitionSite = (mplus `on` definitionSite) m1 m2- }+parserBased :: Aspects+parserBased = mempty { tokenBased = NotOnlyTokenBased } -instance Monoid MetaInfo where- mempty = MetaInfo { aspect = Nothing- , otherAspects = []- , note = Nothing- , definitionSite = Nothing- }- mappend = mergeMetaInfo+-- | Conversion from classification of the scope checker. --- | Merges files.+kindOfNameToNameKind :: KindOfName -> NameKind+kindOfNameToNameKind = \case+ -- Inductive is Constructor default, overwritten by CoInductive+ ConName -> Constructor Common.Inductive+ CoConName -> Constructor Common.CoInductive+ FldName -> Field+ PatternSynName -> Constructor Common.Inductive+ GeneralizeName -> Generalizable+ DisallowedGeneralizeName -> Generalizable+ MacroName -> Macro+ QuotableName -> Function+ DataName -> Datatype+ RecName -> Record+ FunName -> Function+ AxiomName -> Postulate+ PrimName -> Primitive+ OtherDefName -> Function -merge :: File -> File -> File-merge f1 f2 =- File { mapping = (Map.unionWith mappend `on` mapping) f1 f2 }+instance IsBasicRangeMap Aspects RangePair where+ singleton rs m = RangePair (rs, m) -instance Monoid File where- mempty = File { mapping = Map.empty }- mappend = merge+ toList (RangePair (Ranges rs, m)) =+ [ (r, m) | r <- rs, not (null r) ] ---------------------------------------------------------------------------- Inspection+ toMap f = toMap (convert (DelayedMerge (Endo (f :))) :: PositionMap) --- | Convert the 'File' to a map from file positions (counting from 1)--- to meta information.+instance IsBasicRangeMap Aspects PositionMap where+ singleton rs m = PositionMap+ { positionMap =+ IntMap.fromDistinctAscList [ (p, m) | p <- rangesToPositions rs ]+ } -toMap :: File -> Map Integer MetaInfo-toMap = mapping+ toList = map join . List1.groupBy' p . IntMap.toAscList . positionMap+ where+ p (pos1, m1) (pos2, m2) = pos2 == pos1 + 1 && m1 == m2+ join pms = ( Range { from = List1.head ps, to = List1.last ps + 1 }+ , List1.head ms+ )+ where (ps, ms) = List1.unzip pms ---------------------------------------------------------------------------- Compression+ toMap = positionMap --- | A compressed 'File', in which consecutive positions with the same--- 'MetaInfo' are stored together.+instance Semigroup a =>+ IsBasicRangeMap a (DelayedMerge (RangeMap a)) where+ singleton r m = DelayedMerge (Endo (singleton r m :)) -type CompressedFile = [(Range, MetaInfo)]+ toMap f = toMap (convert f :: RangeMap a)+ toList f = toList (convert f :: RangeMap a) --- | Compresses a file by merging consecutive positions with equal--- meta information into longer ranges.+instance IsBasicRangeMap Aspects (DelayedMerge RangePair) where+ singleton r m = DelayedMerge (Endo (singleton r m :)) -compress :: File -> CompressedFile-compress f = map join $ groupBy' p (Map.toAscList $ mapping f)- where- p (pos1, m1) (pos2, m2) = pos2 == pos1 + 1 && m1 == m2- join pms = ( Range { from = head ps, to = last ps + 1 }- , head ms- )- where (ps, ms) = unzip pms+ toMap f = toMap (convert f :: PositionMap)+ toList f = toList (convert f :: RangeMap Aspects) --- | Decompresses a compressed file.+instance IsBasicRangeMap Aspects (DelayedMerge PositionMap) where+ singleton r m = DelayedMerge (Endo (singleton r m :)) -decompress :: CompressedFile -> File-decompress =- File .- Map.fromList .- concat .- map (\(r, m) -> [ (p, m) | p <- toList r ])+ toMap f = toMap (convert f :: PositionMap)+ toList f = toList (convert f :: PositionMap) -prop_compress f =- decompress c == f- &&- and (map (rangeInvariant . fst) c)- &&- and [ not (overlapping r1 r2) | (r1, r2) <- allPairs (map fst c) ]- where- c = compress f+-- | Conversion between different types. - allPairs [] = []- allPairs (x : xs) = map ((,) x) xs ++ allPairs xs+class Convert a b where+ convert :: a -> b ---------------------------------------------------------------------------- Generators+instance Monoid hl => Convert (DelayedMerge hl) hl where+ convert (DelayedMerge f) = mconcat (appEndo f []) -instance Arbitrary Aspect where- arbitrary =- frequency [ (3, elements [ Comment, Keyword, String, Number- , Symbol, PrimitiveType ])- , (1, liftM2 Name (maybeGen arbitrary) arbitrary)- ]+instance Convert (RangeMap Aspects) (RangeMap Aspects) where+ convert = id -instance CoArbitrary Aspect where- coarbitrary Comment = variant 0- coarbitrary Keyword = variant 1- coarbitrary String = variant 2- coarbitrary Number = variant 3- coarbitrary Symbol = variant 4- coarbitrary PrimitiveType = variant 5- coarbitrary (Name nk b) =- variant 6 . maybeCoGen coarbitrary nk . coarbitrary b+instance Convert PositionMap (RangeMap Aspects) where+ convert =+ RangeMap.fromNonOverlappingNonEmptyAscendingList .+ toList -instance Arbitrary NameKind where- arbitrary = oneof $ [liftM Constructor arbitrary] ++- map return [ Bound- , Datatype- , Field- , Function- , Module- , Postulate- , Primitive- , Record- ]+instance Convert (DelayedMerge PositionMap) (RangeMap Aspects) where+ convert f = convert (convert f :: PositionMap) -instance CoArbitrary NameKind where- coarbitrary Bound = variant 0- coarbitrary (Constructor ind) = variant 1 . coarbitrary ind- coarbitrary Datatype = variant 2- coarbitrary Field = variant 3- coarbitrary Function = variant 4- coarbitrary Module = variant 5- coarbitrary Postulate = variant 6- coarbitrary Primitive = variant 7- coarbitrary Record = variant 8+instance Convert (DelayedMerge RangePair) PositionMap where+ convert (DelayedMerge f) =+ PositionMap $+ IntMap.fromListWith (flip (<>))+ [ (p, m)+ | RangePair (r, m) <- appEndo f []+ , p <- rangesToPositions r+ ] -instance Arbitrary OtherAspect where- arbitrary = elements [minBound .. maxBound]+instance Convert (DelayedMerge RangePair) (RangeMap Aspects) where+ convert (DelayedMerge f) =+ mconcat+ [ singleton r m+ | RangePair (r, m) <- appEndo f []+ ] -instance CoArbitrary OtherAspect where- coarbitrary = coarbitrary . fromEnum+------------------------------------------------------------------------+-- Merging -instance Arbitrary MetaInfo where- arbitrary = do- aspect <- arbitrary- other <- arbitrary- note <- maybeGen string- defSite <- arbitrary- return (MetaInfo { aspect = aspect, otherAspects = other- , note = note, definitionSite = defSite })- where string = listOfElements "abcdefABCDEF/\\.\"'@()åäö\n"+instance Semigroup TokenBased where+ b1@NotOnlyTokenBased <> b2 = b1+ TokenBased <> b2 = b2 -instance CoArbitrary MetaInfo where- coarbitrary (MetaInfo aspect otherAspects note defSite) =- coarbitrary aspect .- coarbitrary otherAspects .- coarbitrary note .- coarbitrary defSite+instance Monoid TokenBased where+ mempty = TokenBased+ mappend = (<>) -instance Arbitrary File where- arbitrary = fmap (File . Map.fromList) $ listOf arbitrary -instance CoArbitrary File where- coarbitrary (File rs) = coarbitrary (Map.toAscList rs)+instance Semigroup DefinitionSite where+ d1 <> d2 | d1 == d2 = d1+ | otherwise = d1 -- TODO: __IMPOSSIBLE__ ---------------------------------------------------------------------------- All tests+-- | Merges meta information. --- | All the properties.+mergeAspects :: Aspects -> Aspects -> Aspects+mergeAspects m1 m2 = Aspects+ { aspect = (unionMaybeWith (<>) `on` aspect) m1 m2+ , otherAspects = (Set.union `on` otherAspects) m1 m2+ , note = case (note m1, note m2) of+ (n1, "") -> n1+ ("", n2) -> n2+ (n1, n2)+ | n1 == n2 -> n1+ | otherwise -> addFinalNewLine n1 ++ "----\n" ++ n2+ , definitionSite = (unionMaybeWith (<>) `on` definitionSite) m1 m2+ , tokenBased = tokenBased m1 <> tokenBased m2+ } -tests :: IO Bool-tests = runTests "Agda.Interaction.Highlighting.Precise"- [ quickCheck' prop_singleton- , quickCheck' prop_compress- ]+instance Semigroup Aspects where+ (<>) = mergeAspects++instance Monoid Aspects where+ mempty = Aspects+ { aspect = Nothing+ , otherAspects = Set.empty+ , note = []+ , definitionSite = Nothing+ , tokenBased = mempty+ }+ mappend = (<>)++instance Semigroup PositionMap where+ f1 <> f2 = PositionMap+ { positionMap = (IntMap.unionWith mappend `on` positionMap) f1 f2 }++instance Monoid PositionMap where+ mempty = PositionMap { positionMap = IntMap.empty }+ mappend = (<>)
@@ -1,99 +1,33 @@-{-# LANGUAGE DeriveDataTypeable #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-} --- | Ranges.+-- | Converting generic ranges to Agda's ranges. module Agda.Interaction.Highlighting.Range- ( Range(..)- , rangeInvariant- , overlapping- , toList- , getRanges- , getRangesA+ ( module Agda.Utils.Range , rToR- , Agda.Interaction.Highlighting.Range.tests+ , rangeToRange ) where -import Agda.Utils.QuickCheck-import Data.List-import Data.Generics (Typeable, Data)-import Agda.Utils.TestHelpers-import qualified Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Concrete as C-import qualified Agda.Syntax.Position as P---- | Character ranges. The first character in the file has position 1.--- Note that the 'to' position is considered to be outside of the--- range.------ Invariant: @'from' '<=' 'to'@.--data Range = Range { from, to :: Integer }- deriving (Eq, Ord, Show, Typeable, Data)---- | The 'Range' invariant.--rangeInvariant :: Range -> Bool-rangeInvariant r = from r <= to r---- | 'True' iff the ranges overlap.------ The ranges are assumed to be well-formed.--overlapping :: Range -> Range -> Bool-overlapping r1 r2 = not $- to r1 <= from r2 || to r2 <= from r1---- | Converts a range to a list of positions.--toList :: Range -> [Integer]-toList r = [from r .. to r - 1]----------------------------------------------------------------------------- Conversion---- | Calculates a set of ranges associated with a name.------ For an operator the ranges associated with the NameParts are--- returned. Otherwise the range associated with the Name is returned.------ A boolean, indicating operatorness, is also returned.--getRanges :: C.Name -> ([Range], Bool)-getRanges n = (rToR $ P.getRange n, C.isOperator n)---- | Like 'getRanges', but for 'A.QName's. Note that the module part--- of the name is thrown away; only the base part is used.--getRangesA :: A.QName -> ([Range], Bool)-getRangesA = getRanges . A.nameConcrete . A.qnameName+import Agda.Syntax.Position qualified as P+import Agda.Utils.Range --- | Converts a 'P.Range' to a list of 'Range's.+-- | Converts a 'P.Range' to a 'Ranges'. -rToR :: P.Range -> [Range]-rToR (P.Range is) = map iToR is+rToR :: P.Range -> Ranges+rToR r = Ranges (map iToR (P.rangeIntervals r)) where- iToR (P.Interval { P.iStart = P.Pn { P.posPos = pos1 }- , P.iEnd = P.Pn { P.posPos = pos2 }- }) =- Range { from = toInteger pos1, to = toInteger pos2 }----------------------------------------------------------------------------- Generators--instance Arbitrary Range where- arbitrary = do- [from, to] <- fmap sort $ vectorOf 2 positive- return $ Range { from = from, to = to }--instance CoArbitrary Range where- coarbitrary (Range f t) = coarbitrary f . coarbitrary t----------------------------------------------------------------------------- All tests+ iToR (P.Interval () P.Pn'{ P.posPos = pos1 } P.Pn'{ P.posPos = pos2 }) =+ Range { from = fromIntegral pos1, to = fromIntegral pos2 } --- | All the properties.+-- | Converts a 'P.Range', seen as a continuous range, to a 'Range'. -tests :: IO Bool-tests = runTests "Agda.Interaction.Highlighting.Range"- [ quickCheck' rangeInvariant- ]+rangeToRange :: P.Range -> Range+rangeToRange r =+ case P.rangeToInterval r of+ Nothing -> Range { from = 0, to = 0 }+ Just (P.Interval _ s e) -> Range+ { from = fromIntegral $ P.posPos s+ , to = fromIntegral $ P.posPos e+ }
@@ -1,87 +1,95 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Interaction.Highlighting.Vim where import Control.Monad.Trans-import Data.Char-import Data.Set ( Set )-import Data.Map ( Map )-import System.FilePath +import Data.Function ( on ) import qualified Data.List as List import qualified Data.Map as Map-import qualified Data.Set as Set+import Data.Maybe -import Agda.Syntax.Scope.Base+import System.FilePath++import Agda.Syntax.Abstract.Name (AbstractName(..), KindOfName (FldName))+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty import Agda.Syntax.Concrete.Name as CName+import Agda.Syntax.Scope.Base import Agda.TypeChecking.Monad -import qualified Agda.Utils.IO.UTF8 as UTF8-import Agda.Utils.Tuple--#include "../../undefined.h"-import Agda.Utils.Impossible--on f g x y = f (g x) (g y)+import Agda.Utils.IO.UTF8 qualified as UTF8+import Agda.Utils.List1 ( List1, pattern (:|) )+import Agda.Utils.List1 qualified as List1 vimFile :: FilePath -> FilePath vimFile file = case splitFileName file of- (path, name) -> path </> "" <.> name <.> "vim"+ (path, name) -> path </> "" <.> name <.> "vim" escape :: String -> String escape = concatMap esc where- escchars = "$\\^.*~[]"- esc c | c `elem` escchars = ['\\',c]- | otherwise = [c]+ escchars :: String+ escchars = "$\\^.*~[]"+ esc c | c `elem` escchars = ['\\',c]+ | otherwise = [c] +wordBounded :: String -> String+wordBounded s0 = concat ["\\<", s0, "\\>"]+ keyword :: String -> [String] -> String keyword _ [] = ""-keyword cat ws = "syn keyword " ++ unwords (cat : ws)+keyword cat ws = "syn keyword " ++ unwords (cat : ws) -match :: String -> [String] -> String-match _ [] = ""-match cat ws = "syn match " ++ cat ++ " \"" ++- concat (List.intersperse "\\|" $ map escape ws) ++ "\""+match :: String -> List1 String -> String+match cat (w :| ws) =+ "syn match "+ ++ cat+ ++ " \""+ ++ List.intercalate "\\|" (map (wordBounded . escape) $ w:ws)+ ++ "\"" -matches :: [String] -> [String] -> [String] -> [String] -> [String]-matches cons icons defs idefs =+matches :: [String] -> [String] -> [String] -> [String] -> [String] -> [String] -> [String]+matches cons icons defs idefs flds iflds = map snd $ List.sortBy (compare `on` fst) $ cons' ++ defs' ++ icons' ++ idefs' where- cons' = foo "agdaConstructor" $ classify length cons- icons' = foo "agdaInfixConstructor" $ classify length icons- defs' = foo "agdaFunction" $ classify length defs- idefs' = foo "agdaInfixFunction" $ classify length idefs+ cons' = foo "agdaConstructor" $ classify length cons+ icons' = foo "agdaInfixConstructor" $ classify length icons+ defs' = foo "agdaFunction" $ classify length defs+ idefs' = foo "agdaInfixFunction" $ classify length idefs - classify f = List.groupBy ((==) `on` f)- . List.sortBy (compare `on` f)+ classify f = List1.groupBy ((==) `on` f)+ . List.sortBy (compare `on` f) - foo :: String -> [[String]] -> [(Int, String)]- foo cat = map (length . head /\ match cat)+ foo :: String -> [List1 String] -> [(Int, String)]+ foo cat = map (length . List1.head &&& match cat) toVim :: NamesInScope -> String-toVim ns = unlines $ matches mcons micons mdefs midefs+toVim ns = unlines $ matches mcons micons mdefs midefs mflds miflds where- cons = [ x | (x, def:_) <- Map.toList ns, anameKind def == ConName ]- defs = [ x | (x, def:_) <- Map.toList ns, anameKind def == DefName ]+ cons = [ x | (x, con :| _) <- Map.toList ns, isJust $ isConName $ anameKind con ]+ defs = [ x | (x, def :| _) <- Map.toList ns, isDefName (anameKind def) ]+ flds = [ x | (x, fld :| _) <- Map.toList ns, anameKind fld == FldName ] - mcons = map show cons- mdefs = map show defs+ mcons = map prettyShow cons+ mdefs = map prettyShow defs+ mflds = map prettyShow flds - micons = concatMap parts cons- midefs = concatMap parts defs+ micons = concatMap parts cons+ midefs = concatMap parts defs+ miflds = concatMap parts flds - parts (NoName _ _) = []- parts (Name _ [_]) = []- parts (Name _ ps) = [ x | Id x <- ps ]+ parts n+ | isOperator n = map rawNameToString $ nameStringParts n+ | otherwise = [] generateVimFile :: FilePath -> TCM () generateVimFile file = do scope <- getScope liftIO $ UTF8.writeFile (vimFile file) $ toVim $ names scope where- names = nsNames . everythingInScope+ names = nsNames . everythingInScope
@@ -1,575 +1,1743 @@ {-# LANGUAGE CPP #-}-{-| This module deals with finding imported modules and loading their- interface files.--}-module Agda.Interaction.Imports where--import Prelude hiding (catch)--import Control.Arrow-import Control.Monad.Error-import Control.Monad.State-import qualified Control.Exception as E-import qualified Data.Map as Map-import qualified Data.List as List-import qualified Data.Set as Set-import qualified Data.ByteString.Lazy as BS-import Data.List-import Data.Maybe-import Data.Map (Map)-import Data.Set (Set)-import System.Directory-import System.Time-import qualified Agda.Utils.IO.Locale as LocIO-import System.FilePath hiding (splitPath)--import Agda.Syntax.Position-import qualified Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Concrete as C-import Agda.Syntax.Abstract.Name-import Agda.Syntax.Parser-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad-import Agda.Syntax.Translation.ConcreteToAbstract-import Agda.Syntax.Internal--import Agda.Termination.TermCheck--import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Serialise-import Agda.TypeChecking.Primitive-import Agda.TypeChecker--import Agda.Interaction.FindFile-import Agda.Interaction.Options-import Agda.Interaction.Highlighting.Precise (HighlightingInfo)-import Agda.Interaction.Highlighting.Generate-import Agda.Interaction.Highlighting.Vim-import qualified Agda.Interaction.Highlighting.Range as R--import Agda.Utils.FileName-import Agda.Utils.Monad-import Agda.Utils.IO.Binary-import Agda.Utils.Pretty-import Agda.Utils.Fresh--import Agda.Utils.Impossible-#include "../undefined.h"---- | Merge an interface into the current proof state.-mergeInterface :: Interface -> TCM ()-mergeInterface i = do- let sig = iSignature i- builtin = Map.toList $ iBuiltin i- prim = [ x | (_,Prim x) <- builtin ]- bi = Map.fromList [ (x,Builtin t) | (x,Builtin t) <- builtin ]- bs <- gets stBuiltinThings- reportSLn "import.iface.merge" 10 $ "Merging interface"- reportSLn "import.iface.merge" 20 $- " Current builtins " ++ show (Map.keys bs) ++ "\n" ++- " New builtins " ++ show (Map.keys bi)- let check b = case (b1, b2) of- (Builtin x, Builtin y)- | x == y -> return ()- | otherwise -> typeError $ DuplicateBuiltinBinding b x y- _ -> __IMPOSSIBLE__- where- Just b1 = Map.lookup b bs- Just b2 = Map.lookup b bi- mapM_ check (map fst $ Map.toList $ Map.intersection bs bi)- addImportedThings sig bi (iHaskellImports i)- reportSLn "import.iface.merge" 20 $- " Rebinding primitives " ++ show prim- prim <- Map.fromList <$> mapM rebind prim- modify $ \st -> st { stImportedBuiltins = stImportedBuiltins st `Map.union` prim- }- where- rebind x = do- PrimImpl _ pf <- lookupPrimitiveFunction x- return (x, Prim pf)--addImportedThings ::- Signature -> BuiltinThings PrimFun -> Set String -> TCM ()-addImportedThings isig ibuiltin hsImports =- modify $ \st -> st- { stImports = unionSignatures [stImports st, isig]- , stImportedBuiltins = Map.union (stImportedBuiltins st) ibuiltin- , stHaskellImports = Set.union (stHaskellImports st) hsImports- }---- | Scope checks the given module. A proper version of the module--- name (with correct definition sites) is returned.--scopeCheckImport :: ModuleName -> TCM (ModuleName, Map ModuleName Scope)-scopeCheckImport x = do- reportSLn "import.scope" 5 $ "Scope checking " ++ show x- verboseS "import.scope" 10 $ do- visited <- Map.keys <$> getVisitedModules- liftIO $ LocIO.putStrLn $- " visited: " ++ intercalate ", " (map (render . pretty) visited)- i <- fst <$> getInterface x- addImport x- return (iModuleName i `withRangesOfQ` mnameToConcrete x, iScope i)---- | If the module has already been visited (without warnings), then--- its interface is returned directly. Otherwise the computation is--- used to find the interface and the computed interface is stored for--- potential later use.--alreadyVisited :: C.TopLevelModuleName ->- TCM (Interface, Either Warnings ClockTime) ->- TCM (Interface, Either Warnings ClockTime)-alreadyVisited x getIface = do- mm <- getVisitedModule x- case mm of- -- A module with warnings should never be allowed to be- -- imported from another module.- Just mi | not (miWarnings mi) -> do- reportSLn "import.visit" 10 $ " Already visited " ++ render (pretty x)- return (miInterface mi, Right $ miTimeStamp mi)- _ -> do- reportSLn "import.visit" 5 $ " Getting interface for " ++ render (pretty x)- r@(i, wt) <- getIface- reportSLn "import.visit" 5 $ " Now we've looked at " ++ render (pretty x)- case wt of- Left _ -> do- t <- liftIO getClockTime- visitModule $ ModuleInfo- { miInterface = i- , miWarnings = True- , miTimeStamp = t- }- Right t ->- visitModule $ ModuleInfo- { miInterface = i- , miWarnings = False- , miTimeStamp = t- }- return r---- | Warnings.------ Invariant: The fields are never empty at the same time.--data Warnings = Warnings- { terminationProblems :: [TerminationError]- -- ^ Termination checking problems are not reported if- -- 'optTerminationCheck' is 'False'.- , unsolvedMetaVariables :: [Range]- -- ^ Meta-variable problems are reported as type errors unless- -- 'optAllowUnsolved' is 'True'.- , unsolvedConstraints :: Constraints- -- ^ Same as 'unsolvedMetaVariables'.- }---- | Turns warnings into an error. Even if several errors are possible--- only one is raised.--warningsToError :: Warnings -> TypeError-warningsToError (Warnings [] [] []) = __IMPOSSIBLE__-warningsToError (Warnings _ w@(_:_) _) = UnsolvedMetas w-warningsToError (Warnings _ _ w@(_:_)) = UnsolvedConstraints w-warningsToError (Warnings w@(_:_) _ _) = TerminationCheckFailed w---- | Type checks the given module (if necessary).--typeCheck :: AbsolutePath -> TCM (Interface, Maybe Warnings)-typeCheck f = do- m <- moduleName f-- (i, wt) <- getInterface' m True- return (i, case wt of- Left w -> Just w- Right _ -> Nothing)---- | Tries to return the interface associated to the given module. The--- time stamp of the relevant interface file is also returned. May--- type check the module. An error is raised if a warning is--- encountered.--getInterface :: ModuleName -> TCM (Interface, ClockTime)-getInterface x = do- (i, wt) <- getInterface' (toTopLevelModuleName x) False- case wt of- Left w -> typeError $ warningsToError w- Right t -> return (i, t)---- | A more precise variant of 'getInterface'. If warnings are--- encountered then they are returned instead of being turned into--- errors.--getInterface' :: C.TopLevelModuleName- -> Bool -- ^ If type checking is necessary, should all- -- state changes inflicted by 'createInterface'- -- be preserved?- -> TCM (Interface, Either Warnings ClockTime)-getInterface' x includeStateChanges =- -- Preserve the pragma options unless includeStateChanges is True.- bracket (stPragmaOptions <$> get)- (unless includeStateChanges . setPragmaOptions) $ \_ -> do- -- Forget the pragma options (locally).- setCommandLineOptions . stPersistentOptions . stPersistent =<< get-- alreadyVisited x $ addImportCycleCheck x $ do- file <- findFile x -- requires source to exist-- reportSLn "import.iface" 10 $ " Check for cycle"- checkForImportCycle-- uptodate <- do- ignore <- ignoreInterfaces- cached <- isCached file -- if it's cached ignoreInterfaces has no effect- -- to avoid typechecking a file more than once- newer <- liftIO $ filePath (toIFile file) `isNewerThan` filePath file- return $ newer && (not ignore || cached)-- reportSLn "import.iface" 5 $- " " ++ render (pretty x) ++ " is " ++- (if uptodate then "" else "not ") ++ "up-to-date."-- (stateChangesIncluded, (i, wt)) <-- if uptodate then skip file else typeCheck file-- -- Ensure that the given module name matches the one in the file.- let topLevelName = toTopLevelModuleName $ iModuleName i- unless (topLevelName == x) $ do- checkModuleName topLevelName file- typeError $ OverlappingProjects file topLevelName x-- visited <- isVisited x- reportSLn "import.iface" 5 $ if visited then " We've been here. Don't merge."- else " New module. Let's check it out."- unless (visited || stateChangesIncluded) $ mergeInterface i-- modify (\s -> s { stCurrentModule = Just $ iModuleName i })-- -- Interfaces are only stored if no warnings were encountered.- case wt of- Left w -> return ()- Right t -> storeDecodedModule i t-- return (i, wt)-- where- isCached file = do- let ifile = filePath $ toIFile file- exist <- liftIO $ doesFileExist ifile- if not exist- then return False- else do- t <- liftIO $ getModificationTime ifile- mm <- getDecodedModule x- return $ case mm of- Just (mi, mt) | mt >= t -> True- _ -> False-- skip file = do- -- Examine the mtime of the interface file. If it is newer than the- -- stored version (in stDecodedModules), or if there is no stored version,- -- read and decode it. Otherwise use the stored version.- let ifile = filePath $ toIFile file- t <- liftIO $ getModificationTime ifile- mm <- getDecodedModule x- (cached, mi) <- case mm of- Just (mi, mt) ->- if mt < t- then do dropDecodedModule x- reportSLn "import.iface" 5 $ " file is newer, re-reading " ++ ifile- (,) False <$> readInterface ifile- else do reportSLn "import.iface" 5 $ " using stored version of " ++ ifile- return (True, Just mi)- Nothing -> do- reportSLn "import.iface" 5 $ " no stored version, reading " ++ ifile- (,) False <$> readInterface ifile-- -- Check that it's the right version- case mi of- Nothing -> do- reportSLn "import.iface" 5 $ " bad interface, re-type checking"- typeCheck file- Just i -> do-- reportSLn "import.iface" 5 $ " imports: " ++ show (iImportedModules i)-- ts <- map snd <$> mapM getInterface (iImportedModules i)-- -- If any of the imports are newer we need to retype check- if any (> t) ts- then do- -- liftIO close -- Close the interface file. See above.- typeCheck file- else do- unless cached $ reportSLn "" 1 $- "Skipping " ++ render (pretty x) ++- " (" ++ ifile ++ ")."- -- We set the pragma options of the skipped file here,- -- because if the top-level file is skipped we want the- -- pragmas to apply to interactive commands in the UI.- mapM_ setOptionsFromPragma (iPragmaOptions i)- return (False, (i, Right t))-- typeCheck file =- let ret a = do- reportSLn "" 1 $ "Finished " ++ render (pretty x) ++ "."- return a- in do- -- Do the type checking.- reportSLn "" 1 $ "Checking " ++ render (pretty x) ++ " (" ++ filePath file ++ ")."- if includeStateChanges then do- r <- createInterface file x-- -- Merge the signature with the signature for imported- -- things.- sig <- getSignature- addImportedThings sig Map.empty Set.empty- setSignature emptySignature-- ret (True, r)- else do- ms <- getImportPath- mf <- stModuleToSource <$> get- vs <- getVisitedModules- ds <- getDecodedModules- opts <- stPersistentOptions . stPersistent <$> get- isig <- getImportedSignature- ibuiltin <- gets stImportedBuiltins- -- Every interface is treated in isolation. Note: Changes- -- to stDecodedModules are not preserved if an error is- -- encountered in an imported module.- r <- liftIO $ runTCM $- withImportPath ms $ do- setDecodedModules ds- setCommandLineOptions opts- modify $ \s -> s { stModuleToSource = mf }- setVisitedModules vs- addImportedThings isig ibuiltin Set.empty-- r <- createInterface file x-- mf <- stModuleToSource <$> get- ds <- getDecodedModules- return (r, do- modify $ \s -> s { stModuleToSource = mf }- setDecodedModules ds- case r of- (i, Right t) -> storeDecodedModule i t- _ -> return ()- )-- case r of- Left err -> throwError err- Right (r, update) -> do- update- case r of- (_, Right _) -> do- r <- skip file- ret r- _ ->- ret (False, r)---readInterface :: FilePath -> TCM (Maybe Interface)-readInterface file = do- -- Decode the interface file- (s, close) <- liftIO $ readBinaryFile' file- do i <- liftIO . E.evaluate =<< decode s-- -- Close the file. Note- -- ⑴ that evaluate ensures that i is evaluated to WHNF (before- -- the next IO operation is executed), and- -- ⑵ that decode returns Nothing if an error is encountered,- -- so it is safe to close the file here.- liftIO close-- return i- -- Catch exceptions and close- `catchError` \e -> liftIO close >> handler e- -- Catch exceptions- `catchError` handler- where- handler e = case errError e of- IOException _ e -> do- liftIO $ LocIO.putStrLn $ "IO exception: " ++ show e- return Nothing -- Work-around for file locking bug.- -- TODO: What does this refer to? Please- -- document.- _ -> throwError e---- | Writes the given interface to the given file. Returns the file's--- new modification time stamp, or 'Nothing' if the write failed.--writeInterface :: FilePath -> Interface -> TCM ClockTime-writeInterface file i = do- reportSLn "import.iface.write" 5 $ "Writing interface file " ++ file ++ "."- encodeFile file i- reportSLn "import.iface.write" 5 "Wrote interface file."- liftIO $ getModificationTime file- `catchError` \e -> do- reportSLn "" 1 $- "Failed to write interface " ++ file ++ "."- liftIO $- whenM (doesFileExist file) $ removeFile file- throwError e---- | Tries to type check a module and write out its interface. The--- function only writes out an interface file if it does not encounter--- any warnings.------ If appropriate this function writes out syntax highlighting--- information.--createInterface- :: AbsolutePath -- ^ The file to type check.- -> C.TopLevelModuleName -- ^ The expected module name.- -> TCM (Interface, Either Warnings ClockTime)-createInterface file mname = do- reportSLn "import.iface.create" 5 $- "Creating interface for " ++ render (pretty mname) ++ "."- verboseS "import.iface.create" 10 $ do- visited <- Map.keys <$> getVisitedModules- liftIO $ LocIO.putStrLn $- " visited: " ++ intercalate ", " (map (render . pretty) visited)-- previousHsImports <- getHaskellImports-- (pragmas, top) <- liftIO $ parseFile' moduleParser file-- pragmas <- concat <$> concreteToAbstract_ pragmas- -- identity for top-level pragmas at the moment- let getOptions (A.OptionsPragma opts) = Just opts- getOptions _ = Nothing- options = catMaybes $ map getOptions pragmas- mapM_ setOptionsFromPragma options- topLevel <- concreteToAbstract_ (TopLevel top)-- termErrs <- catchError (do- -- Type checking.- checkDecls (topLevelDecls topLevel)- unfreezeMetas-- -- Count number of metas- verboseS "profile.metas" 10 $ do- MetaId n <- fresh- tickN "metas" n-- -- Termination checking.- termErrs <- ifM (optTerminationCheck <$> pragmaOptions)- (termDecls $ topLevelDecls topLevel)- (return [])- mapM_ (\e -> reportSLn "term.warn.no" 2- (show (termErrFunctions e) ++- " do(es) NOT pass the termination checker."))- termErrs- return termErrs- ) (\e -> do- -- If there is an error syntax highlighting info can still be- -- generated.- case rStart $ getRange e of- Just (Pn { srcFile = Just f }) | f == file -> do- syntaxInfo <- generateSyntaxInfo file (Just e) topLevel []- modFile <- stModuleToSource <$> get- -- The highlighting info is included with the error.- case errHighlighting e of- Just _ -> __IMPOSSIBLE__- Nothing ->- throwError $ e { errHighlighting =- Just (syntaxInfo, modFile) }- _ -> throwError e- )-- -- Generate syntax highlighting info.- syntaxInfo <- generateSyntaxInfo file Nothing topLevel termErrs-- -- Generate Vim file.- whenM (optGenerateVimFile <$> commandLineOptions) $- withScope_ (insideScope topLevel) $ generateVimFile $ filePath file-- -- Print stats- stats <- Map.toList <$> getStatistics- case stats of- [] -> return ()- _ -> reportS "profile" 1 $ unlines $- [ "Ticks for " ++ show (pretty mname) ] ++- [ " " ++ s ++ " = " ++ show n- | (s, n) <- sortBy (compare `on` snd) stats ]-- -- Check if there are unsolved meta-variables...- unsolvedOK <- optAllowUnsolved <$> pragmaOptions- unsolvedMetas <- List.nub <$> (mapM getMetaRange =<< getOpenMetas)- unless (null unsolvedMetas || unsolvedOK) $- typeError $ UnsolvedMetas unsolvedMetas-- -- ...or unsolved constraints- unsolvedConstraints <- getAllConstraints- unless (null unsolvedConstraints || unsolvedOK) $- typeError $ UnsolvedConstraints unsolvedConstraints-- setScope $ outsideScope topLevel-- reportSLn "scope.top" 50 $ "SCOPE " ++ show (insideScope topLevel)-- i <- buildInterface topLevel syntaxInfo previousHsImports options-- if and [ null termErrs, null unsolvedMetas, null unsolvedConstraints ]- then do- -- The file was successfully type-checked (and no warnings were- -- encountered), so the interface should be written out.- let ifile = filePath $ toIFile file- t <- writeInterface ifile i- return (i, Right t)- else- return (i, Left $ Warnings termErrs unsolvedMetas unsolvedConstraints)---- | Builds an interface for the current module, which should already--- have been successfully type checked.--buildInterface :: TopLevelInfo- -- ^ 'TopLevelInfo' for the current module.- -> HighlightingInfo- -- ^ Syntax highlighting info for the module.- -> Set String- -- ^ Haskell modules imported in imported modules- -- (transitively).- -> [OptionsPragma]- -- ^ Options set in @OPTIONS@ pragmas.- -> TCM Interface-buildInterface topLevel syntaxInfo previousHsImports pragmas = do- reportSLn "import.iface" 5 "Building interface..."- scope' <- getScope- let scope = scope' { scopeCurrent = m }- sig <- getSignature- builtin <- gets stLocalBuiltins- ms <- getImports- hsImps <- getHaskellImports- let builtin' = Map.mapWithKey (\x b -> fmap (const x) b) builtin- reportSLn "import.iface" 7 " instantiating all meta variables"- i <- instantiateFull $ Interface- { iImportedModules = Set.toList ms- , iModuleName = m- , iScope = publicModules scope- , iInsideScope = insideScope topLevel- , iSignature = sig- , iBuiltin = builtin'- , iHaskellImports = Set.difference hsImps- previousHsImports- , iHighlighting = syntaxInfo- , iPragmaOptions = pragmas- }- reportSLn "import.iface" 7 " interface complete"- return i- where m = topLevelModuleName topLevel---- | True if the first file is newer than the second file. If a file doesn't--- exist it is considered to be infinitely old.-isNewerThan :: FilePath -> FilePath -> IO Bool-isNewerThan new old = do- newExist <- doesFileExist new- oldExist <- doesFileExist old- if not (newExist && oldExist)- then return newExist- else do- newT <- getModificationTime new- oldT <- getModificationTime old- return $ newT >= oldT+{-# LANGUAGE NondecreasingIndentation #-}++{-| This module deals with finding imported modules and loading their+ interface files.+-}+module Agda.Interaction.Imports+ ( Mode, pattern ScopeCheck, pattern TypeCheck++ , CheckResult (CheckResult)+ , crModuleInfo+ , crInterface+ , crWarnings+ , crMode+ , crSource++ , Source(..)+ , scopeCheckFileImport+ , parseSource+ , typeCheckMain+ , getNonMainInterface+ , getNonMainModuleInfo+ , getInterface+ , importPrimitiveModules+ , raiseNonFatalErrors++ , MainInterface(..)+ , TCWorkers+ , wantsParallelChecking+ , chaseModule+ , setOptionsFromSourcePragmas++ -- Currently only used by test/api/Issue1168.hs:+ , readInterface+ ) where++import Prelude hiding (null)++import Control.Exception qualified as E+import Control.Monad.Except ( MonadError(..), ExceptT, runExceptT, withExceptT )+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.State ( MonadState(..), execStateT )+import Control.Monad.Trans.Maybe+import Control.Concurrent+import Control.DeepSeq++import Data.Either+import Data.Monoid+import Data.List (intercalate)+import Data.List qualified as List+import Data.Maybe+import Data.Map (Map)+import Data.Map qualified as Map+import Data.HashMap.Strict qualified as HMap+import Data.ByteString qualified as B+import Data.Set (Set)+import Data.Set qualified as Set+import Data.Text (Text)+import Data.Text qualified as T+import Data.Text.Lazy qualified as TL++import GHC.Conc++import System.Directory (doesFileExist, removeFile)+import System.FilePath ( (</>) )+import System.IO+import System.IO.Error (isUserError, isFullError)++import Agda.Benchmarking++import Agda.Syntax.Concrete.Definitions qualified as C+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Concrete qualified as C+import Agda.Syntax.Concrete.Attribute+import Agda.Syntax.Concrete.Generic+import Agda.Syntax.Abstract.Name+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty hiding (Mode)+import Agda.Syntax.Common.Pretty qualified as Pretty+import Agda.Syntax.Parser+import Agda.Syntax.Position+import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.UnusedImports (warnUnusedImports)+import Agda.Syntax.TopLevelModuleName+import Agda.Syntax.Translation.ConcreteToAbstract+ ( TopLevel( TopLevel )+ , TopLevelInfo( TopLevelInfo, topLevelDecls, topLevelScope)+ , checkAttributes, concreteToAbstract_+ )+import Agda.Syntax.Translation.ConcreteToAbstract qualified as CToA++import Agda.TypeChecking.InstanceArguments+import Agda.TypeChecking.Errors+import Agda.TypeChecking.Warnings hiding (warnings)+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Rewriting.Confluence ( checkConfluenceOfRules, sortRulesOfSymbol )+import Agda.TypeChecking.Rewriting.NonLinPattern (getMatchables)+import Agda.TypeChecking.MetaVars ( openMetasToPostulates )+import Agda.TypeChecking.Monad.State as S+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Serialise (decode, encodeFile, decodeInterface, deserializeHashes)+import Agda.TypeChecking.Primitive+import Agda.TypeChecking.Pretty as P+import Agda.TypeChecking.DeadCode+import Agda.TypeChecking.Monad.Benchmark qualified as Bench++import Agda.TheTypeChecker++import Agda.Interaction.BasicOps ( getGoals, prettyGoals )+import Agda.Interaction.FindFile+import Agda.Interaction.Highlighting.Generate+import Agda.Interaction.Highlighting.Precise qualified as Highlighting ( convert )+import Agda.Interaction.Highlighting.Vim+import Agda.Interaction.Library+import Agda.Interaction.Options+import Agda.Interaction.Options.Lenses qualified as Lens+import Agda.Interaction.Options.Warnings (unsolvedWarnings)+import Agda.Interaction.Response+ (RemoveTokenBasedHighlighting(KeepHighlighting))++import Agda.Utils.CallStack (HasCallStack)+import Agda.Utils.FileName+import Agda.Utils.Hash+import Agda.Utils.IO.Binary+import Agda.Utils.Lens+import Agda.Utils.List ( nubOn )+import Agda.Utils.Maybe+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Interaction.Options.ProfileOptions qualified as Profile+import Agda.Utils.Singleton+import Agda.Utils.Set1 qualified as Set1+import Agda.Utils.Trie qualified as Trie+import Agda.Utils.Impossible+import Agda.Utils.IORef.Strict+import Agda.Utils.Tuple.Strict (Pair(..))+import Agda.Utils.Tuple.Strict qualified as Strict+++-- | Whether to ignore interfaces (@.agdai@) other than built-in modules++ignoreInterfaces :: HasOptions m => m Bool+ignoreInterfaces = optIgnoreInterfaces <$> commandLineOptions++-- | Whether to ignore all interface files (@.agdai@)++ignoreAllInterfaces :: HasOptions m => m Bool+ignoreAllInterfaces = optIgnoreAllInterfaces <$> commandLineOptions++-- | Whether to write interface files (@.agdai@)++writeInterfaces :: HasOptions m => m Bool+writeInterfaces = optWriteInterfaces <$> commandLineOptions++-- | The decorated source code.++data Source = Source+ { srcText :: TL.Text -- ^ Source code.+ , srcFileType :: FileType -- ^ Source file type+ , srcOrigin :: SourceFile -- ^ Source location at the time of its parsing+ , srcModule :: C.Module -- ^ The parsed module.+ , srcModuleName :: TopLevelModuleName -- ^ The top-level module name.+ , srcProjectLibs :: [AgdaLibFile] -- ^ The .agda-lib file(s) of the project this file belongs to.+ , srcAttributes :: !Attributes+ -- ^ Every encountered attribute.+ }++-- | Parses a source file and prepares the 'Source' record.++parseSource :: SourceFile -> TCM Source+parseSource sourceFile = Bench.billTo [Bench.Parsing] $ do+ -- Issue #7303:+ -- The parser previously used mdo to avoid the duplicate parsing for the+ -- bootstrapping of the TopLevelModuleName in Range.+ -- But that made ranges blackholes during parsing,+ -- introducing regression #7301, fragility of the API as observed in #7492,+ -- and debugging headaches as ranges could not be showed during parsing.+ -- Now we bite the bullet to parse the source twice,+ -- until a better management of ranges comes about.+ --+ -- (E.g. it is unclear why ranges need the file name/id in place+ -- so early, as all the ranges from one file have the same file id.+ -- It would be sufficient to fill in the file name/id when the mixing+ -- with other files starts, e.g. during scope checking.)++ f <- srcFilePath sourceFile++ -- Read the source text.+ let rf0 = mkRangeFile f Nothing+ setCurrentRange (beginningOfFile rf0) do++ source <- runPM $ readFilePM rf0+ let txt = TL.unpack source++ -- Get the literate markdown option.+ mdOnlyAgdaBlocks <- optMdOnlyAgdaBlocks <$> commandLineOptions++ -- Bootstrapping: parse the module name.+ parsedModName0 <- moduleName f . fst . fst =<< do+ runPMDropWarnings $ parseFile mdOnlyAgdaBlocks moduleParser rf0 txt++ -- Now parse again, with module name present to be filled into the ranges.+ let rf = mkRangeFile f $ Just parsedModName0+ setCurrentRange (beginningOfFile rf) do++ ((parsedMod, attrs), fileType) <- runPM $ parseFile mdOnlyAgdaBlocks moduleParser rf txt+ parsedModName <- moduleName f parsedMod++ libs <- getAgdaLibFiles f parsedModName+ return Source+ { srcText = source+ , srcFileType = fileType+ , srcOrigin = sourceFile+ , srcModule = parsedMod+ , srcModuleName = parsedModName+ , srcProjectLibs = libs+ , srcAttributes = attrs+ }+++-- | Computes the module name of the top-level module in the given file.+--+-- If no top-level module name is given, then an attempt is made to+-- use the file name as a module name.++moduleName ::+ AbsolutePath+ -- ^ The path to the file.+ -> C.Module+ -- ^ The parsed module.+ -> TCM TopLevelModuleName+moduleName file parsedModule = Bench.billTo [Bench.ModuleName] $ do+ let defaultName = rootNameModule file+ raw = rawTopLevelModuleNameForModule parsedModule+ topLevelModuleName =<< if isNoName raw+ then setCurrentRange (rangeFromAbsolutePath file) do+ m <- runPM (fst <$> parse moduleNameParser defaultName)+ `catchError` \_ ->+ typeError $ InvalidFileName file DoesNotCorrespondToValidModuleName+ case m of+ C.Qual{} ->+ typeError $ InvalidFileName file $+ RootNameModuleNotAQualifiedModuleName $ T.pack defaultName+ C.QName{} ->+ return $ RawTopLevelModuleName+ { rawModuleNameRange = getRange m+ , rawModuleNameParts = singleton (T.pack defaultName)+ , rawModuleNameInferred = True+ -- Andreas, 2025-06-21, issue #7953:+ -- Remember we made up this module name to improve errors.+ }+ else return raw+++srcDefaultPragmas :: Source -> [OptionsPragma]+srcDefaultPragmas src = map _libPragmas (srcProjectLibs src)++srcFilePragmas :: Source -> [OptionsPragma]+srcFilePragmas src = pragmas+ where+ cpragmas = C.modPragmas (srcModule src)+ pragmas = [ OptionsPragma+ { pragmaStrings = opts+ , pragmaRange = r+ }+ | C.OptionsPragma r opts <- cpragmas+ ]++-- | Set options from a 'Source' pragma, using the source+-- ranges of the pragmas for error reporting. Flag to check consistency.+setOptionsFromSourcePragmas :: Bool -> Source -> TCM ()+setOptionsFromSourcePragmas checkOpts src = do+ mapM_ setOpts (srcDefaultPragmas src)+ mapM_ setOpts (srcFilePragmas src)+ where+ setOpts | checkOpts = checkAndSetOptionsFromPragma+ | otherwise = setOptionsFromPragma++-- | Is the aim to type-check the top-level module, or only to+-- scope-check it?++data Mode+ = ScopeCheck+ | TypeCheck+ deriving (Eq, Show)++-- | Are we loading the interface for the user-loaded file+-- or for an import?+data MainInterface+ = MainInterface Mode -- ^ For the main file.+ --+ -- In this case state changes inflicted by+ -- 'createInterface' are preserved.+ | NotMainInterface -- ^ For an imported file.+ --+ -- In this case state changes inflicted by+ -- 'createInterface' are not preserved.+ deriving (Eq, Show)++-- | Should state changes inflicted by 'createInterface' be preserved?++includeStateChanges :: MainInterface -> Bool+includeStateChanges (MainInterface _) = True+includeStateChanges NotMainInterface = False++-- | The kind of interface produced by 'createInterface'+moduleCheckMode :: MainInterface -> ModuleCheckMode+moduleCheckMode = \case+ MainInterface TypeCheck -> ModuleTypeChecked+ NotMainInterface -> ModuleTypeChecked+ MainInterface ScopeCheck -> ModuleScopeChecked++-- | Merge an interface into the current proof state.+mergeInterface :: Interface -> TCM ()+mergeInterface i = do+ let sig = iSignature i+ builtin = Map.toAscList $ iBuiltin i+ primOrBi = \case+ (_, Prim x) -> Left x+ (x, Builtin t) -> Right (x, Builtin t)+ (x, BuiltinRewriteRelations xs) -> Right (x, BuiltinRewriteRelations xs)+ (prim, bi') = partitionEithers $ map primOrBi builtin+ bi = Map.fromDistinctAscList bi'+ warns = iWarnings i+ bs <- getsTC stBuiltinThings+ reportSLn "import.iface.merge" 10 $ "Merging interface " ++ prettyShow (iTopLevelModuleName i)+ reportSLn "import.iface.merge" 20 $+ " Current builtins " ++ show (Map.keys bs) ++ "\n" +++ " New builtins " ++ show (Map.keys bi)+ let check (BuiltinName b) (Builtin x) (Builtin y)+ | x == y = return ()+ | otherwise = typeError $ DuplicateBuiltinBinding b x y+ check _ (BuiltinRewriteRelations xs) (BuiltinRewriteRelations ys) = return ()+ check _ _ _ = __IMPOSSIBLE__+ sequence_ $ Map.intersectionWithKey check bs bi++ addImportedThings+ sig+ (iMetaBindings i)+ bi+ (iPatternSyns i)+ (iDisplayForms i)+ (iUserWarnings i)+ (iPartialDefs i)+ warns+ (iOpaqueBlocks i)+ (iOpaqueNames i)++ reportSLn "import.iface.merge" 50 $+ " Rebinding primitives " ++ show prim+ mapM_ rebind prim++ whenJustM (optConfluenceCheck <$> pragmaOptions) \ confChk -> do+ let rews = concat $ HMap.elems $ sig ^. sigRewriteRules+ verboseS "import.iface.confluence" 20 do+ if null rews then reportSLn "" 1 $ " No rewrite rules imported"+ else do+ reportSDoc "" 1 $ P.vcat $ map (P.nest 2) $+ "Checking confluence of imported rewrite rules" :+ map (("-" P.<+>) . prettyTCM . grName) rews++ -- Andreas, 2025-06-28, PR #7934 and issue #7969:+ -- Global confluence checker requires rules to be sorted+ -- according to the generality of their lhs+ when (confChk == GlobalConfluenceCheck) $+ forM_ (nubOn id $ map grHead rews) sortRulesOfSymbol++ -- #8273: We need to ensure the module we are importing is considered+ -- imported when checking confluence.+ --+ -- Ideally we would probably add the imports earlier, but this seems very+ -- fiddly to do correctly. Instead, we just locally add the imports+ -- for the duration of checking confluence and revert the state+ -- afterwards.+ locallyAddImport (iTopLevelModuleName i) $+ checkConfluenceOfRules confChk rews+ where+ rebind (x, q) = do+ (_, pf) <- lookupPossiblyTrustedPrimitiveFunction x+ stImportedBuiltins `modifyTCLens` Map.insert (someBuiltin x) (Prim pf{ primFunName = q })++addImportedThings+ :: Signature+ -> RemoteMetaStore+ -> BuiltinThings+ -> A.PatternSynDefns+ -> DisplayForms+ -> UserWarnings -- ^ Imported user warnings+ -> Set QName -- ^ Name of imported definitions which are partial+ -> Set TCWarning+ -> Map OpaqueId OpaqueBlock+ -> Map QName OpaqueId+ -> TCM ()+addImportedThings isig metas ibuiltin patsyns display userwarn+ partialdefs warnings oblock oid = do+ stImports `modifyTCLens` \ imp -> importSignature imp isig+ stImportedMetaStore `modifyTCLens` HMap.union metas+ stImportedBuiltins `modifyTCLens` \ imp -> Map.unionWith unionBuiltin imp ibuiltin+ stImportedUserWarnings `modifyTCLens` \ imp -> Map.union imp userwarn+ stImportedPartialDefs `modifyTCLens` \ imp -> Set.union imp partialdefs+ stPatternSynImports `modifyTCLens` \ imp -> Map.union imp patsyns+ stImportedDisplayForms `modifyTCLens` \ imp -> HMap.unionWith (<>) imp display+ stTCWarnings `modifyTCLens` \ imp -> Set.union imp warnings+ stOpaqueBlocks `modifyTCLens` \ imp -> imp `Map.union` oblock+ stOpaqueIds `modifyTCLens` \ imp -> imp `Map.union` oid++-- | Merges two signatures, assuming the second is being imported into the first+--+-- This is not commutative: `Map.union` is left-biased and we also assume that+-- updates from rewrite rules in the first signature do not need to be+-- re-applied (rewrite rules in the current signature cannot refer to+-- definitions that are not in the current signature)+importSignature ::+ Signature+ -- ^ Current signature+ -> Signature+ -- ^ Signature being imported+ -> Signature+ -- ^ Merged signature+importSignature (Sig a b c d) (Sig a' b' c' d') =+ Sig (Map.union a a')+ (fixupDefs $ HMap.union b b') -- definitions are unique (in at most one module) but need to be fixed to account for the new rewrite rules+ (HMap.unionWith mappend c c') -- rewrite rules are accumulated+ (d <> d') -- instances are accumulated+ where+ -- #8218: Rewrite rules can modify the signature (e.g. definitional+ -- injectivity of the head symbol). We need to replay these adjustments when+ -- importing because rewrite rules might be defined in a different module+ -- from the definitions they modify.+ fixupDefs ds = foldr (\(f, rews) -> updateDefsForRewrites f rews+ $ rews >>= getMatchables)+ ds (HMap.toList c')++-- | Scope checks the given module, generating an interface or retrieving an existing one.+-- Returns the module name and exported scope from the interface.+--+scopeCheckFileImport ::+ TopLevelModuleName+ -> TCM (ModuleName, Map ModuleName Scope)+scopeCheckFileImport top = do+ reportSLn "import.scope" 15 $ "Scope checking " ++ prettyShow top+ verboseS "import.scope" 30 $ do+ visited <- prettyShow <$> getPrettyVisitedModules+ reportSLn "import.scope" 30 $ " visited: " ++ visited+ -- Since scopeCheckFileImport is called from the scope checker,+ -- we need to reimburse her account.+ i <- Bench.billTo [] $ getNonMainInterface top Nothing+ addImport top++ -- Print list of imported modules in current state.+ verboseS "import.iface.imports" 10 do+ imports <- Set.toList <$> useTC stImportedModules+ reportSLn "import.iface.imports" 10 $ intercalate "\n" $+ unwords [prettyShow top, "added, all imports:"] :+ map (\ x -> unwords [ " ", "-", prettyShow x ]) imports++ -- Print list of transitively imported modules in current state.+ verboseS "import.iface.imports" 20 do+ imports <- Set.toList <$> useTC stImportedModulesTransitive+ reportSLn "import.iface.imports" 10 $ intercalate "\n" $+ unwords [prettyShow top, "added, all transitive imports:"] :+ map (\ x -> unwords [ " ", "-", prettyShow x ]) imports++ -- If that interface was supposed to raise a warning on import, do so.+ whenJust (iImportWarning i) $ warning . UserWarning++ -- let s = publicModules $ iInsideScope i+ let s = iScope i+ return (iModuleName i, s)++-- | The result and associated parameters of a type-checked file,+-- when invoked directly via interaction or a backend.+-- Note that the constructor is not exported.++data CheckResult = CheckResult'+ { crModuleInfo :: ModuleInfo+ , crSource' :: Source+ }++-- | Flattened unidirectional pattern for 'CheckResult' for destructuring inside+-- the 'ModuleInfo' field.+pattern CheckResult :: Interface -> Set TCWarning -> ModuleCheckMode -> Source -> CheckResult+pattern CheckResult { crInterface, crWarnings, crMode, crSource } <- CheckResult'+ { crModuleInfo = ModuleInfo+ { miInterface = crInterface+ , miWarnings = crWarnings+ , miMode = crMode+ }+ , crSource' = crSource+ }++-- | Structure necessary for synchronising parallel type-checking workers.+data TCWorkers = Workers+ { workerThreads :: !(MVar (HMap.HashMap TopLevelModuleName (MVar (Maybe TCErr))))+ -- ^ Synchronized map containing synchronisation points for each+ -- worker to signal completion (or failure).+ , workerModules :: !(IORef DecodedModules)+ -- ^ The shared 'DecodedModules' where workers can put their results.+ , workerStarted :: !(IORef Int)+ -- ^ How many threads have actually started their work. Used for progress reporting.+ }++-- | If the user has asked for it, prepare the type checker for loading+-- in parallel, and return a 'TCWorkers' instance that can be used to+-- coordinate a number of type-checking tasks.+--+-- The given module name, when encountered, will be treated as the+-- 'MainInterface'.+wantsParallelChecking :: TCM (Maybe TCWorkers)+wantsParallelChecking = fmap optParallelChecking commandLineOptions >>= \case+ Sequential -> pure Nothing+ Parallel{} -> Just <$> do+ -- If we're doing parallel type-checking, we have to synchronise the+ -- interaction callback to make sure we don't end up with mangled logs+ -- (or, worse, mangled Lisp!).+ out <- liftIO $ newMVar ()+ cb <- getInteractionOutputCallback+ setInteractionOutputCallback \r -> bracket_ (liftIO (takeMVar out)) (liftIO . putMVar out) $+ cb r++ threads <- liftIO $ newMVar mempty+ results <- liftIO . newIORef =<< getDecodedModules+ started <- liftIO $ newIORef 0+ pure Workers+ { workerThreads = threads+ , workerModules = results+ , workerStarted = started+ }++-- | Gets the prefix string to use for reporting the progress message+-- (Checking, Loading, etc.) for the module this worker is responsible+-- for.+-- As a side-effect, updates the 'workerStarted' count.+thisWorkerPrefix :: TCWorkers -> TCM String+thisWorkerPrefix workers = do+ -- In general, we don't know ahead-of-time how many modules we will+ -- end up checking (e.g. with --build-library, this fluctuates), but+ -- the number of modules for which we have a result slot is a pretty+ -- good estimate.+ sz <- show . HMap.size <$> liftIO (readMVar (workerThreads workers))+ me <- liftIO $ atomicModifyIORef (workerStarted workers) \n -> (n + 1, show (n + 1))+ let+ pad = replicate (length sz - length me) ' '+ out = "(" <> pad <> me <> "/" <> sz <> ") "+ out `deepseq` pure out++-- | Type-check the given module, using a 'TCWorkers' instance to check+-- its imports in parallel.+--+-- Returns an action which *waits* for completion of type-checking of+-- the given module. Note that the given action updates the+-- 'DecodedModules' in the TC state where it is called to the current+-- results of parallel type-checking. The state after running this+-- action is guaranteed to contain a 'DecodedModule' for the given+-- 'TopLevelModuleName'.+--+-- If the given 'MainInterface' indicates that we are checking the main+-- module, its checking will happen in the calling thread, and in the+-- calling TC state. Otherwise, a thread (with isolated TC state) is+-- created to check it.+--+-- Regardless of whether we spawned a new thread or not, checking of the+-- given module will block until all of its imports have been checked.+chaseModule+ :: TCWorkers -- ^ For synchronization+ -> TopLevelModuleName -- ^ The name of the module to check+ -> MainInterface -- ^ Are we checking the main module?+ -> Maybe Source -- ^ Pre-parsed source+ -> TCM (TCM ModuleInfo)+chaseModule workers mod main msrc = do+ let+ -- This is the generic action for waiting on the result of checking+ -- a module. The MVar is used just for signaling.+ use var = liftIO (readMVar var) >>= \case+ Just exc -> throwError exc+ Nothing -> do+ setDecodedModules =<< liftIO (readIORef (workerModules workers))+ getDecodedModule mod >>= \case+ Just mi -> pure mi+ Nothing -> __IMPOSSIBLE_VERBOSE__ $+ "internal error: parallel loading had thread responsible for "+ <> show (Agda.Syntax.Common.Pretty.pretty mod)+ <> " marked as ready, but it has not been decoded"++ has = modifyMVar (workerThreads workers) \wmap -> case HMap.lookup mod wmap of+ Just var -> pure (wmap, Left var)+ Nothing -> do+ var <- newEmptyMVar+ let nmap = HMap.insert mod var wmap+ nmap `seq` pure (nmap, Right var)++ -- In the critical section that holds workerThreads, we just decide+ -- whether to spawn a new thread or not.+ -- If the module already had an entry (Left), we can immediately+ -- return the waiting thunk.+ liftIO has >>= \case+ Left var -> use var <$ reportSDoc "import.parallel" 15 ("reusing " <> P.pretty mod)++ -- Otherwise, we have to handle spawning the new thread to do+ -- type-checking.+ Right var -> use var <$ do+ stack <- viewTC eImportStack++ let+ -- If this is the call corresponding to checking the main+ -- module, we don't start a new thread.+ -- This is because we want to be in the state from checking the+ -- main module, e.g. for interactive checking.+ --+ -- If we *are* starting a new thread, we must install an+ -- exception handler to catch any TCErrs that make it to the top+ -- level, so that they can propagate back to the main thread+ -- eventually.+ detach cont+ | MainInterface _ <- main = cont+ | otherwise = do+ forkTCM $ flip catchError (liftIO . putMVar var . Just) $ do+ -- If we're starting a new thread, we also need to parse the source file.+ -- For debugging/profiling/etc., label the thread with the+ -- name of the module that we're checking.+ liftIO do+ let name = show (Agda.Syntax.Common.Pretty.pretty mod)+ me <- myThreadId+ labelThread me ("TC " <> name)+ cont++ detach do+ reportSDoc "import.parallel" 15 $ "checking " <> P.pretty mod+ src <- maybe (parseSource =<< findFile mod) pure msrc++ -- Now we traverse through all the imports and collect the+ -- "promises" for waiting on them. This will spawn the threads+ -- to check them.+ imports <- flip foldDecl (srcModule src) \case+ C.Import opn r x as is -> do+ let dec = C.NiceImport opn r x as is+ traceCall (ScopeCheckDeclaration dec) do++ tl <- S.topLevelModuleName (rawTopLevelModuleNameForQName x)++ -- This is a bit fiddly. 'getInterface' below will push mod+ -- onto the import stack, so if we push it around the entire+ -- thread, we get a spurious cyclic import error.+ --+ -- However, we can't also push tl, because *its* worker+ -- thread would end up pushing it, so *it* would be on the+ -- stack twice, too!+ --+ -- We have to check for import cycles here because GHC does+ -- not seem to always generate the proper "thread blocked+ -- indefinitely on MVar operation".+ act <- locallyTC eImportStack (mod:) do+ locallyTC eImportStack (tl:) checkForImportCycle+ chaseModule workers tl NotMainInterface Nothing++ pure $ Endo (act:)++ _ -> pure mempty++ -- Now we wait for all the dependencies and, when that's done,+ -- we can just type-check the module as usual.+ -- Waiting for the dependencies will have moved us to a TC state+ -- where they have been placed in the DecodedModules map, so the+ -- normal type-checking code will just reuse them when we get+ -- around to actually scope checking the import.+ sequence_ (appEndo imports [])++ prefix <- thisWorkerPrefix workers+ mi <- locallyTC eChasePrefix (const (Just prefix)) $+ getInterface mod main (Just src)++ -- After we're done, update the shared DecodedModules map and+ -- signal our completion.+ liftIO do+ atomicModifyIORef (workerModules workers) \v -> (Map.insert mod mi v, ())+ putMVar var Nothing++-- | Type checks the main file of the interaction.+-- This could be the file loaded in the interacting editor (emacs),+-- or the file passed on the command line.+--+-- First, the primitive modules are imported.+-- Then, @getInterface@ is called to do the main work.+--+-- If the 'Mode' is 'ScopeCheck', then type-checking is not+-- performed, only scope-checking. (This may include type-checking+-- of imported modules.) In this case the generated, partial+-- interface is not stored in the state ('stDecodedModules'). Note,+-- however, that if the file has already been type-checked, then a+-- complete interface is returned.++typeCheckMain+ :: Mode+ -- ^ Should the file be type-checked, or only scope-checked?+ -> Source+ -- ^ The decorated source code.+ -> TCM CheckResult+typeCheckMain mode src = do+ -- liftIO $ putStrLn $ "This is typeCheckMain " ++ prettyShow f+ -- liftIO . putStrLn . show =<< getVerbosity++ -- For the main interface, we also remember the pragmas from the file+ setOptionsFromSourcePragmas True src++ -- Import the Agda.Primitive modules+ importPrimitiveModules++ -- Now do the type checking via getInterface.+ checkModuleName' (srcModuleName src) (srcOrigin src)++ mi <- wantsParallelChecking >>= \case+ Just workers -> join $ chaseModule workers (srcModuleName src) (MainInterface mode) (Just src)+ Nothing -> getInterface (srcModuleName src) (MainInterface mode) (Just src)++ stCurrentModule `setTCLens'`+ Strict.Just (iModuleName (miInterface mi) :!: iTopLevelModuleName (miInterface mi))++ return $ CheckResult' mi src++-- Andreas, 2016-07-11, issue 2092+-- The error range should be set to the file with the wrong module name+-- not the importing one (which would be the default).+checkModuleName' :: TopLevelModuleName' Range -> SourceFile -> TCM ()+checkModuleName' m f =+ setCurrentRange m $ checkModuleName m f Nothing++-- | Import the primitive modules (unless --no-load-primitives).+importPrimitiveModules :: TCM ()+importPrimitiveModules = whenM (optLoadPrimitives <$> pragmaOptions) $ do+ reportSLn "import.main" 10 "Importing the primitive modules."+ libdirPrim <- useSession lensPrimitiveLibDir+ reportSLn "import.main" 20 $ "Library primitive dir = " ++ show libdirPrim+ -- Turn off import-chasing messages.+ -- We have to modify the persistent verbosity setting, since+ -- getInterface resets the current verbosity settings to the persistent ones.++ bracket_ (getsTC Lens.getPersistentVerbosity) Lens.putPersistentVerbosity $ do+ -- set root verbosity to 0+ Lens.modifyPersistentVerbosity+ (Strict.Just . Trie.insert [] 0 . Strict.fromMaybe Trie.empty)++ -- We don't want to generate highlighting information for Agda.Primitive.+ withHighlightingLevel None $ do+ locallyTC eImplPrimitiveImporting (\_ -> True) $ do+ forM_ (map (filePath libdirPrim </>) $ Set.toList primitiveModules) \ f -> do+ sf <- srcFromPath (mkAbsolute f)+ primSource <- parseSource sf+ checkModuleName' (srcModuleName primSource) (srcOrigin primSource)+ void $ getNonMainInterface (srcModuleName primSource) (Just primSource)++ reportSLn "import.main" 10 $ "Done importing the primitive modules."++-- | Tries to return the interface associated to the given (imported) module.+-- The time stamp of the relevant interface file is also returned.+-- Calls itself recursively for the imports of the given module.+-- May type check the module.+-- An error is raised if a warning is encountered.+--+-- Do not use this for the main file, use 'typeCheckMain' instead.++getNonMainInterface+ :: TopLevelModuleName+ -> Maybe Source+ -- ^ Optional: the source code and some information about the source code.+ -> TCM Interface+getNonMainInterface x msrc = do+ mi <- getNonMainModuleInfo x msrc+ tcWarningsToError (TopLevelModuleNameWithSourceFile x $ miSourceFile mi) $ Set.toAscList $ miWarnings mi+ return (miInterface mi)++getNonMainModuleInfo+ :: TopLevelModuleName+ -> Maybe Source+ -- ^ Optional: the source code and some information about the source code.+ -> TCM ModuleInfo+getNonMainModuleInfo x msrc =+ -- Preserve/restore the current pragma options, which will be mutated when loading+ -- and checking the interface.+ bracket_ (useTC stPragmaOptions) (stPragmaOptions `setTCLens`) $+ getInterface x NotMainInterface msrc++-- | If the module has already been visited (without warnings), then+-- its interface is returned directly.+--+-- Otherwise the interface is loaded via 'getStoredInterface'.+--+-- If that fails it is created via 'createInterface' or, for non-main modules,+-- 'createInterfaceIsolated'.+-- A such created interface is stored for potential later use.++getInterface+ :: TopLevelModuleName+ -> MainInterface+ -> Maybe Source+ -- ^ Optional: the source code and some information about the source code.+ -> TCM ModuleInfo+getInterface x isMain msrc = locallyTC eImportStack (x :) do++ -- We remember but reset the pragma options locally.+ currentOptions <- useTC stPragmaOptions+ -- Issue #3644 (Abel 2020-05-08): Set approximate range for errors in options.+ setCurrentRange (C.modPragmas . srcModule <$> msrc) $ do+ -- Now reset the options+ setCommandLineOptions =<< getsTC (stPersistentOptions . stPersistentState)++ -- Lookup x in the collection of visited modules.+ getVisitedModule x >>= \case++ -- Case: already visited and usable.+ Just mi+ -- We can only reuse a sufficiently checked module,+ -- e.g. we cannot import a just scope-checked module when type-checking a module.+ | miMode mi >= moduleCheckMode isMain+ -- A module with warnings should never be allowed to be imported from another module.+ , null $ miWarnings mi -> do+ reportSLn "import.visit" 10 $ " Already visited " ++ prettyShow x+ addOptionsCompatibilityWarnings currentOptions mi++ -- Case: not already visited or unusable.+ _ -> do++ -- Load the module.+ reportSLn "import.visit" 5 $ " Getting interface for " ++ prettyShow x++ file <- case msrc of+ Nothing -> findFile x+ Just src -> do+ -- Andreas, 2021-08-17, issue #5508.+ -- So it happened with @msrc == Just{}@ that the file was not added to @ModuleToSource@,+ -- only with @msrc == Nothing@ (then @findFile@ does it).+ -- As a consequence, the file was added later, but with a file name constructed+ -- from a module name. As #5508 shows, this can be fatal in case-insensitive file systems.+ -- The file name (with case variant) then no longer maps to the module name.+ -- To prevent this, we register the connection in @ModuleToSource@ here,+ -- where we have the correct spelling of the file name.+ let file = srcOrigin src+ modifySession lensModuleToSourceId $ Map.insert x file+ pure file++ reportSDoc "import.iface" 15 do+ path <- srcFilePath file+ P.text $ List.intercalate "\n" $ map (" " ++)+ [ "module: " ++ prettyShow x+ , "file: " ++ prettyShow path+ ]++ reportSLn "import.iface" 15 $ " Check for cycle"+ checkForImportCycle++ mi <- Bench.billTo [Bench.Import] (getStoredInterface x file msrc)+ `catchExceptT` \ reason -> do++ reportSLn "import.iface" 5 $ concat [" ", prettyShow x, " is not up-to-date because ", reason, "."]+ setCommandLineOptions . stPersistentOptions . stPersistentState =<< getTC+ mi <- case isMain of+ MainInterface{} -> createInterface x file isMain msrc+ NotMainInterface -> createInterfaceIsolated x file msrc++ -- Ensure that the given module name matches the one in the file.+ let topLevelName = iTopLevelModuleName (miInterface mi)+ unless (topLevelName == x) do+ path <- srcFilePath file+ typeError $ OverlappingProjects path topLevelName x++ pure mi++ mi <- addOptionsCompatibilityWarnings currentOptions mi+ reportSLn "import.visit" 5 $ " Now we've looked at " ++ prettyShow x++ -- Interfaces are not stored if we are only scope-checking, or+ -- if any warnings were encountered.+ when (moduleCheckMode isMain == ModuleTypeChecked && null (miWarnings mi)) do+ storeDecodedModule mi++ reportS "warning.import" 10+ [ "module: " ++ show (moduleNameParts x)+ , "WarningOnImport: " ++ show (iImportWarning (miInterface mi))+ ]++ -- Record the module as visited.+ visitModule mi+ return mi+ where+ addOptionsCompatibilityWarnings :: PragmaOptions -> ModuleInfo -> TCM ModuleInfo+ addOptionsCompatibilityWarnings currentOptions+ mi@ModuleInfo{ miInterface = i, miIsBuiltin = isBuiltin, miWarnings = ws } = do++ -- Andreas, 2026-02-03, issue #8361, debug printing by @nad.+ -- For testing whether 'isBuiltinModule' is thread-safe.+ reportSDoc "import.iface.builtin" 25 do+ P.hsep [ "The module", prettyTCM (iTopLevelModuleName i), "is"+ , if maybe False isPrimitiveModule isBuiltin then "primitive." else "not primitive."+ ]++ -- Check that imported options are compatible with current ones (issue #2487),+ -- but give primitive modules a pass.+ -- Compute updated warnings if needed.+ ws' <- fromMaybe ws <$> getOptionsCompatibilityWarnings isMain currentOptions mi+ return mi{ miWarnings = ws' }++-- | If checking produced non-benign warnings, error out.+--+raiseNonFatalErrors :: (HasOptions m, MonadTCError m)+ => CheckResult -- ^ E.g. obtained from 'typeCheckMain'.+ -> m ()+raiseNonFatalErrors result = do+ Set1.unlessNullM (applyFlagsToTCWarnings (crWarnings result)) $ \ ws ->+ typeError $ NonFatalErrors ws++-- | Check if the options used for checking an imported module are+-- compatible with the current options. Raises Non-fatal errors if+-- not.+checkOptionsCompatible ::+ PragmaOptions -> PragmaOptions -> TopLevelModuleName -> TCM Bool+checkOptionsCompatible current imported importedModule = flip execStateT True $ do+ reportSDoc "import.iface.options" 25 $ P.nest 2 $ "current options =" P.<+> showOptions current+ reportSDoc "import.iface.options" 25 $ P.nest 2 $ "imported options =" P.<+> showOptions imported+ forM_ infectiveCoinfectiveOptions $ \opt -> do+ unless (icOptionOK opt current imported) $ do+ reportSDoc "import.iface.options" 25 $ P.nest 2 $+ "incompatible: " <> P.text (icOptionDescription opt)+ <> ", current: " <> P.pretty (icOptionActive opt current)+ <> ", imported: " <> P.pretty (icOptionActive opt imported)+ put False+ warning $+ (case icOptionKind opt of+ Infective -> InfectiveImport+ Coinfective -> CoInfectiveImport)+ (icOptionWarning opt current imported importedModule)+ where+ showOptions opts =+ P.prettyList $+ map (\opt -> (P.text (icOptionDescription opt) <> ": ") P.<+>+ P.pretty (icOptionActive opt opts))+ infectiveCoinfectiveOptions++-- | Compare options and return collected warnings.+-- | Returns `Nothing` if warning collection was skipped.++getOptionsCompatibilityWarnings ::+ MainInterface+ -> PragmaOptions+ -> ModuleInfo+ -> TCM (Maybe (Set TCWarning))+getOptionsCompatibilityWarnings isMain currentOptions info =++ -- are we importing a primitive module implicitly?+ viewTC eImplPrimitiveImporting >>= \case+ True -> pure Nothing+ False -> case info of+ ModuleInfo{ miIsBuiltin = isBuiltin+ , miInterface = Interface{ iOptionsUsed, iTopLevelModuleName = m }+ , miSourceFile } -> do++ -- Add range to name of imported module.+ m' <- if not $ null $ getRange m then pure m else do+ path <- srcFilePath miSourceFile+ pure $ setRange (rangeFromAbsolutePath path) m++ case isBuiltin of+ Just IsAgdaPrimitive ->+ pure Nothing+ Just IsAgdaPrimitiveCubical ->+ case _optCubical currentOptions of+ Nothing -> do+ warning $ CoInfectiveImport $+ Pretty.fsep $+ Pretty.pwords "Module imports the cubical primitive module" +++ Pretty.pwords "but does not enable a --cubical[={full,erased,no-glue}] option."+ Just <$> getAllWarnings' isMain ErrorWarnings+ Just _ -> pure Nothing+ _ ->+ ifM (checkOptionsCompatible currentOptions iOptionsUsed m')+ {-then-} (pure Nothing) -- No warnings to collect because options were compatible.+ {-else-} (Just <$> getAllWarnings' isMain ErrorWarnings)++-- | Try to get the interface from interface file or cache.++getStoredInterface :: HasCallStack+ => TopLevelModuleName+ -- ^ Module name of file we process.+ -> SourceFile+ -- ^ File we process.+ -> Maybe Source+ -> ExceptT String TCM ModuleInfo+getStoredInterface x file@(SourceFile fi) msrc = do++ -- Check whether interface file exists and is in cache+ -- in the correct version (as testified by the interface file hash).+ --+ -- This is a lazy action which may be skipped if there is no cached interface+ -- and we're ignoring interface files for some reason.+ let getIFileHashesET = do+ -- Check that the interface file exists and return its hash.+ ifile <- maybeToExceptT "the interface file could not be found" $ MaybeT $+ findInterfaceFile' file++ -- Check that the interface file exists and return its hash.+ hashes <- maybeToExceptT "the interface file hash could not be read" $ MaybeT $ liftIO $+ getInterfaceFileHashes ifile++ return (ifile, hashes)++ -- Examine the hash of the interface file. If it is different from the+ -- stored version (in stDecodedModules), or if there is no stored version,+ -- read and decode it. Otherwise use the stored version.+ --+ -- This is a lazy action which may be skipped if the cached or on-disk interface+ -- is invalid, missing, or skipped for some other reason.+ let checkSourceHashET ifaceH = do+ sourceH <- case msrc of+ Nothing -> do+ path <- srcFilePath file+ liftIO $ hashTextFile path+ Just src -> return $ hashText (srcText src)++ unless (sourceH == ifaceH) $+ throwError $ concat+ [ "the source hash (", show sourceH, ")"+ , " does not match the source hash for the interface (", show ifaceH, ")"+ ]++ reportSLn "import.iface" 5 $ concat [" ", prettyShow x, " is up-to-date."]++ let+ -- Load or reload the interface file, if possible.+ loadInterfaceFile whyNotCached =+ withExceptT (\e -> concat [whyNotCached, " and ", e]) $ do+ whenM ignoreAllInterfaces $+ throwError "we're ignoring all interface files"++ whenM ignoreInterfaces $+ whenNothingM (isBuiltinModule fi) $+ throwError "we're ignoring non-builtin interface files"++ (ifile, hashes) <- getIFileHashesET++ let ifp = filePath $ intFilePath $ ifile++ Bench.billTo [Bench.Deserialization] $ do+ checkSourceHashET (fst hashes)++ reportSLn "import.iface" 5 $ " no stored version, reading " ++ ifp++ i <- maybeToExceptT "bad interface, re-type checking" $ MaybeT $+ readInterface ifile++ -- Ensure that the given module name matches the one in the file.+ let topLevelName = iTopLevelModuleName i+ unless (topLevelName == x) do+ path <- srcFilePath file+ lift $ typeError $ OverlappingProjects path topLevelName x++ isBuiltinMod <- isBuiltinModule fi++ lift $ chaseMsg "Loading " x $ Just ifp+ -- print imported warnings+ reportWarningsForModule x $ iWarnings i++ loadDecodedModule file $ ModuleInfo+ { miInterface = i+ , miWarnings = empty+ , miIsBuiltin = isBuiltinMod+ , miMode = ModuleTypeChecked+ , miSourceFile = file+ }++ -- Check if we have cached the module.+ cachedE <- runExceptT $ maybeToExceptT "the interface has not been decoded" $ MaybeT $+ lift $ getDecodedModule x++ case cachedE of+ Left whyNotCached -> loadInterfaceFile whyNotCached++ -- If it's cached ignoreInterfaces has no effect;+ -- to avoid typechecking a file more than once.+ Right mi -> do+ (ifile, hashes) <- getIFileHashesET++ let ifp = filePath $ intFilePath ifile+ let i = miInterface mi++ -- Make sure the hashes match.+ let cachedIfaceHash = iFullHash i+ let fileIfaceHash = snd hashes+ if cachedIfaceHash /= fileIfaceHash then do+ lift $ dropDecodedModule x+ reportSLn "import.iface" 50 $ " cached hash = " ++ show cachedIfaceHash+ reportSLn "import.iface" 50 $ " stored hash = " ++ show fileIfaceHash+ reportSLn "import.iface" 5 $ " file is newer, re-reading " ++ ifp+ loadInterfaceFile $ concat+ [ "the cached interface hash (", show cachedIfaceHash, ")"+ , " does not match interface file (", show fileIfaceHash, ")"+ ]+ else Bench.billTo [Bench.Deserialization] $ do+ checkSourceHashET (iSourceHash i)++ reportSLn "import.iface" 5 $ " using stored version of " ++ filePath (intFilePath ifile)+ loadDecodedModule file mi++-- | Report those given warnings that come from the given module.++reportWarningsForModule :: MonadDebug m => TopLevelModuleName -> Set TCWarning -> m ()+reportWarningsForModule x warns = do+ unlessNull (filter ((Strict.Just (Just x) ==) . fmap rangeFileName . tcWarningOrigin) $ Set.toAscList warns) \ ws ->+ alwaysReportSDoc "warning" 1 $+ -- Andreas, 2025-08-01, PR #8040+ -- Make sure that imported warnings coming from different modules are separated by an empty line.+ -- E.g. test/Succeed/ImportWarnings+ -- Technique from PR #7473:+ P.vcat $ concatMap (\ w -> [ "", P.prettyTCM w ]) ws+ -- Technique from PR #7362:+ -- P.vsep $ map P.prettyTCM ws++-- | Check whether the loaded module is up-to-date+-- and merge into state if this is the case.+--+loadDecodedModule+ :: SourceFile+ -- ^ File we process.+ -> ModuleInfo+ -- ^ The interface we loaded or created.+ -> ExceptT String TCM ModuleInfo+loadDecodedModule sf@(SourceFile fi) mi = do+ file <- srcFilePath sf+ let fp = filePath file+ let i = miInterface mi+ let imports = iImportedModules i+ let name = iTopLevelModuleName i++ -- Print imported modules.+ verboseS "import.iface.imports" 5 $ unless (null imports) $+ reportSLn "import.iface.imports" 5 $ intercalate "\n" $+ unwords [ prettyShow name, "imports:" ] :+ map (\ (x, hash) -> unwords [ " ", "-", prettyShow x, concat ["(hash: ", prettyShow hash, ")"] ])+ imports++ -- We set the pragma options of the skipped file here, so that+ -- we can check that they are compatible with those of the+ -- imported modules. Also, if the top-level file is skipped we+ -- want the pragmas to apply to interactive commands in the UI.+ -- Jesper, 2021-04-18: Check for changed options in library files!+ -- (see #5250)+ libOptions <- lift $ getLibraryOptions file name+ lift $ mapM_ setOptionsFromPragma (libOptions ++ iFilePragmaOptions i)++ -- Check that options that matter haven't changed compared to+ -- current options (issue #2487).+ whenNothingM (isBuiltinModule fi) do+ current <- useTC stPragmaOptions+ when (recheckBecausePragmaOptionsChanged (iOptionsUsed i) current) $+ throwError "options changed"++ -- If any of the imports are newer we need to re-typecheck.+ badHashMessages <- fmap lefts $ forM imports \ (impName, impHash) -> runExceptT do+ reportSLn "import.iface" 30 $ concat ["Checking that module hash of import ", prettyShow impName, " matches ", prettyShow impHash ]+ latestImpHash <- lift $ lift $ setCurrentRange impName $ moduleHash impName+ reportSLn "import.iface" 30 $ concat ["Done checking module hash of import ", prettyShow impName]+ when (impHash /= latestImpHash) $+ throwError $ concat+ [ "module hash for imported module ", prettyShow impName, " is out of date"+ , " (import cached=", prettyShow impHash, ", latest=", prettyShow latestImpHash, ")"+ ]++ unlessNull badHashMessages (throwError . unlines)++ reportSLn "import.iface" 5 $ prettyShow name ++ ": interface is valid and can be merged into the state."++ lift $ mergeInterface i+ Bench.billTo [Bench.Highlighting] $+ lift $ ifTopLevelAndHighlightingLevelIs NonInteractive $+ highlightFromInterface i sf++ return mi++-- | Run the type checker on a file and create an interface.+--+-- Mostly, this function calls 'createInterface'.+-- But if it is not the main module we check,+-- we do it in a fresh state, suitably initialize,+-- in order to forget some state changes after successful type checking.++createInterfaceIsolated ::+ TopLevelModuleName+ -- ^ Module name of file we process.+ -> SourceFile+ -- ^ File we process.+ -> Maybe Source+ -- ^ Optional: the source code and some information about the source code.+ -> TCM ModuleInfo+createInterfaceIsolated x file msrc = do+ cleanCachedLog+ ms <- viewTC eImportStack+ pref <- viewTC eChasePrefix+ range <- viewTC eRange+ call <- viewTC eCall+ vs <- getVisitedModules+ ds <- getDecodedModules+ opts <- stPersistentOptions . stPersistentState <$> getTC+ isig <- useTC stImports+ metas <- useTC stImportedMetaStore+ ibuiltin <- useTC stImportedBuiltins+ display <- useTC stImportsDisplayForms+ userwarn <- useTC stImportedUserWarnings+ partialdefs <- useTC stImportedPartialDefs+ opaqueblk <- useTC stOpaqueBlocks+ opaqueid <- useTC stOpaqueIds+ ipatsyns <- getPatternSynImports+ -- Andreas, 2026-10-24, issue #8875:+ -- Library warnings (e.g. LibraryVersionConflict) may explain an error+ -- in the imported module, so we add them to the state of the error.+ let isLibraryWarning = \case+ LibraryWarning{} -> True+ _ -> False+ libWarns <- Set.filter (isLibraryWarning . tcWarning) <$> useTC stTCWarnings+ let addLibWarns = \case+ err@TypeError{} | not (null libWarns) ->+ err{ tcErrState = over stTCWarnings (Set.union libWarns) $ tcErrState err }+ err -> err+ -- Every interface is treated in isolation. Note: Some changes to+ -- the persistent state may not be preserved if an error other+ -- than a type error or an IO exception is encountered in an+ -- imported module.+ (mi, newDecodedModules) <- (either (throwError . addLibWarns) pure =<<) $+ withoutCache $+ -- The cache should not be used for an imported module, and it+ -- should be restored after the module has been type-checked+ freshTCM $+ localTC (+ -- Andreas, 2014-08-18:+ -- Preserve the range of import statement+ -- for reporting termination errors in+ -- imported modules:+ set eRange range+ . set eCall call+ . set eImportStack ms+ . set eChasePrefix pref+ ) do+ setDecodedModules ds+ setCommandLineOptions opts+ setVisitedModules vs+ addImportedThings isig metas ibuiltin ipatsyns display+ userwarn partialdefs empty opaqueblk opaqueid++ r <- createInterface x file NotMainInterface msrc+ ds' <- getDecodedModules+ return (r, ds')++ setDecodedModules newDecodedModules++ -- We skip the file which has just been type-checked to+ -- be able to forget some of the local state from+ -- checking the module.+ -- Note that this doesn't actually read the interface+ -- file, only the cached interface. (This comment is not+ -- correct, see+ -- test/Fail/customised/NestedProjectRoots.err.)+ validated <- runExceptT $ loadDecodedModule file mi++ -- NOTE: This attempts to type-check FOREVER if for some+ -- reason it continually fails to validate interface.+ let recheckOnError = \msg -> do+ alwaysReportSLn "import.iface" 1 $ "Failed to validate just-loaded interface: " ++ msg+ createInterfaceIsolated x file msrc++ either recheckOnError pure validated+++-- | Formats and outputs the "Checking", "Finished" and "Loading " messages.++chaseMsg+ :: String -- ^ The prefix, like @Checking@, @Finished@, @Loading @.+ -> TopLevelModuleName -- ^ The module name.+ -> Maybe String -- ^ Optionally: the file name.+ -> TCM ()+chaseMsg kind x file = do+ indentation <- viewTC eChasePrefix >>= \case+ Just pref -> pure pref+ Nothing -> (`replicate` ' ') . pred . length <$> viewTC eImportStack+ traceImports <- optTraceImports <$> commandLineOptions+ let maybeFile = caseMaybe file "." $ \ f -> " (" ++ f ++ ")."+ vLvl | kind == "Checking"+ && traceImports > 0 = 1+ | kind == "Finished"+ && traceImports > 1 = 1+ | List.isPrefixOf "Loading" kind+ && traceImports > 2 = 1+ | otherwise = 2+ alwaysReportSLn "import.chase" vLvl $ concat+ [ indentation, kind, " ", prettyShow x, maybeFile ]++-- | Print the highlighting information contained in the given interface.++highlightFromInterface+ :: Interface+ -> SourceFile+ -- ^ The corresponding file.+ -> TCM ()+highlightFromInterface i sf = do+ reportSDoc "import.iface" 5 do+ file <- srcFilePath sf+ P.text $ "Generating syntax info for " ++ filePath file +++ " (read from interface)."+ printHighlightingInfo KeepHighlighting (iHighlighting i)++-- | Read interface file corresponding to a module.++readInterface :: InterfaceFile -> TCM (Maybe Interface)+readInterface file = do+ let ifp = filePath $ intFilePath file+ bstr <- (liftIO $ Just <$!> B.readFile ifp) `catchError` \case+ IOException _ _ e -> do+ alwaysReportSLn "" 0 $ "IO exception: " ++ show e+ return Nothing -- Work-around for file locking bug.+ -- TODO: What does this refer to? Please+ -- document.+ e -> throwError e+ case bstr of+ Just bstr -> runMaybeT (constructIScope <$!> decodeInterface bstr)+ Nothing -> pure Nothing+++-- | Writes the given interface to the given file.+--+-- The written interface is decoded and returned.++writeInterface :: AbsolutePath -> Interface -> TCM Interface+writeInterface file i = let fp = filePath file in do+ reportSLn "import.iface.write" 5 $+ "Writing interface file " ++ fp ++ "."+ -- Andreas, 2015-07-13+ -- After QName memoization (AIM XXI), scope serialization might be cheap enough.+ -- -- Andreas, Makoto, 2014-10-18 AIM XX:+ -- -- iInsideScope is bloating the interface files, so we do not serialize it?+ -- i <- return $+ -- i { iInsideScope = emptyScopeInfo+ -- }+ -- [Old: Andreas, 2016-02-02 this causes issue #1804, so don't do it:]+ -- Andreas, 2020-05-13, #1804, #4647: removed private declarations+ -- only when we actually write the interface.+ let+ filteredIface = i { iInsideScope = withoutPrivates $ iInsideScope i }+ filteredIface <- pruneTemporaryInstances filteredIface+ reportSLn "import.iface.write" 50 $+ "Writing interface file with hash " ++ show (iFullHash filteredIface) ++ "."+ iface <- encodeFile fp filteredIface+ reportSLn "import.iface.write" 5 "Wrote interface file."+ pure iface+ `catchError` \e -> do+ alwaysReportSLn "" 1 $+ "Failed to write interface " ++ fp ++ "."+ -- Andreas, 2025-09-12, issue #8098, don't delete when writing failed on a readonly file.+ -- Only delete file when disk is full or Agda had an internal error during serialization.+ case e of+ IOException _ _ ioe | not (isUserError ioe), not (isFullError ioe)+ -> return ()+ _ -> liftIO $ whenM (doesFileExist fp) $ removeFile fp+ throwError e++-- | Tries to type check a module and write out its interface. The+-- function only writes out an interface file if it does not encounter+-- any warnings.+--+-- If appropriate this function writes out syntax highlighting+-- information.++createInterface ::+ TopLevelModuleName -- ^ The expected module name.+ -> SourceFile -- ^ The file to type check.+ -> MainInterface -- ^ Are we dealing with the main module?+ -> Maybe Source -- ^ Optional information about the source code.+ -> TCM ModuleInfo+createInterface mname sf@(SourceFile sfi) isMain msrc = do+ stFileId `setTCLens'` Strict.Just sfi+ file <- srcFilePath sf+ let+ fp = filePath file+ onlyScope = ModuleScopeChecked == moduleCheckMode isMain+ checkMsg = if onlyScope then "Reading "+ else "Checking"+ withMsgs = bracket_ (chaseMsg checkMsg mname $ Just fp) $ const $ do+ ws <- getAllWarnings AllWarnings+ let classified = classifyWarnings $ Set.toAscList ws+ reportWarningsForModule mname $ tcWarnings classified+ when (null (nonFatalErrors classified)) $ chaseMsg "Finished" mname Nothing++ withMsgs $ Bench.billTo [Bench.TopModule mname] $ localTC (set eCurrentPath (Just sfi)) do++ reportSLn "import.iface.create" 5 $+ "Creating interface for " ++ prettyShow mname ++ "..."+ verboseS "import.iface.create" 10 $ do+ visited <- prettyShow <$> getPrettyVisitedModules+ reportSLn "import.iface.create" 10 $ " visited: " ++ visited++ src <- maybe (parseSource sf) pure msrc++ srcPath <- srcFilePath $ srcOrigin src++ fileTokenInfo <- Bench.billTo [Bench.Highlighting] $+ generateTokenInfoFromSource+ (let !top = srcModuleName src in+ mkRangeFile srcPath (Just top))+ (TL.unpack $ srcText src)+ stTokens `modifyTCLens` (fileTokenInfo <>)++ -- Only check consistency if not main (we check consistency for the main module in+ -- `typeCheckMain`.+ let checkConsistency | MainInterface{} <- isMain = False+ | otherwise = True+ setOptionsFromSourcePragmas checkConsistency src+ checkAttributes (srcAttributes src)+ syntactic <- optSyntacticEquality <$> pragmaOptions+ localTC (set eSyntacticEqualityFuel syntactic) $ do++ verboseS "import.iface.create" 15 $ do+ nestingLevel <- asksTC (pred . length . view eImportStack)+ highlightingLevel <- viewTC eHighlightingLevel+ reportSLn "import.iface.create" 15 $ unlines+ [ " nesting level: " ++ show nestingLevel+ , " highlighting level: " ++ show highlightingLevel+ ]++ -- Scope checking.+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Starting scope checking."+ topLevel <- Bench.billTo [Bench.Scoping] $ do+ let topDecls = C.modDecls $ srcModule src+ concreteToAbstract_ (TopLevel (srcOrigin src) mname topDecls)+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Finished scope checking."++ let ds = topLevelDecls topLevel+ scope = topLevelScope topLevel++ -- Highlighting from scope checker.+ reportSLn "import.iface.highlight" 15 $ prettyShow mname ++ ": Starting highlighting from scope."+ Bench.billTo [Bench.Highlighting] $ do+ -- Generate and print approximate syntax highlighting info.+ ifTopLevelAndHighlightingLevelIs NonInteractive $+ printHighlightingInfo KeepHighlighting fileTokenInfo+ ifTopLevelAndHighlightingLevelIsOr NonInteractive onlyScope $+ mapM_ (\ d -> generateAndPrintSyntaxInfo d Partial onlyScope) ds+ reportSLn "import.iface.highlight" 15 $ prettyShow mname ++ ": Finished highlighting from scope."+++ -- Type checking.++ -- Now that all the options are in we can check if caching should+ -- be on.+ activateLoadedFileCache++ -- invalidate cache if pragmas change, TODO move+ cachingStarts+ opts <- useTC stPragmaOptions+ me <- readFromCachedLog+ case me of+ Just (Pragmas opts', _) | opts == opts'+ -> return ()+ _ -> do+ reportSLn "cache" 10 $ "pragma changed: " ++ show (isJust me)+ cleanCachedLog+ writeToCurrentLog $ Pragmas opts++ if onlyScope+ then do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Skipping type checking."+ cacheCurrentLog+ else do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Starting type checking."+ Bench.billTo [Bench.Typing] $ mapM_ checkDeclCached ds `finally_` cacheCurrentLog+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Finished type checking."++ -- Ulf, 2013-11-09: Since we're rethrowing the error, leave it up to the+ -- code that handles that error to reset the state.+ -- Ulf, 2013-11-13: Errors are now caught and highlighted in InteractionTop.+ -- catchError_ (checkDecls ds) $ \e -> do+ -- ifTopLevelAndHighlightingLevelIs NonInteractive $+ -- printErrorInfo e+ -- throwError e++ unfreezeMetas++ -- Profiling: Count number of metas.+ whenProfile Profile.Metas $ do+ m <- fresh+ tickN "metas" (metaId m)++ -- Generate unused imports warning.+ warnUnusedImports++ -- Highlighting from type checker.+ reportSLn "import.iface.highlight" 15 $ prettyShow mname ++ ": Starting highlighting from type info."+ Bench.billTo [Bench.Highlighting] $ do++ -- Move any remaining token highlighting to stSyntaxInfo.+ toks <- useTC stTokens+ ifTopLevelAndHighlightingLevelIs NonInteractive $+ printHighlightingInfo KeepHighlighting toks+ stTokens `setTCLens` mempty++ -- Grabbing warnings and unsolved metas to highlight them+ warnings <- getAllWarnings AllWarnings+ unless (null warnings) $ reportSDoc "import.iface.highlight" 20 $+ "collected warnings: " <> prettyTCM warnings+ unsolved <- getAllUnsolvedWarnings+ unless (null unsolved) $ reportSDoc "import.iface.highlight" 20 $+ "collected unsolved: " <> prettyTCM unsolved+ let warningInfo =+ Highlighting.convert $ foldMap warningHighlighting $ Set.fromList unsolved `Set.union` warnings++ stSyntaxInfo `modifyTCLens` \inf -> (inf `mappend` toks) `mappend` warningInfo++ whenM (optGenerateVimFile <$> commandLineOptions) $+ -- Generate Vim file.+ evalWithScope scope $ generateVimFile $ filePath $ srcPath+ reportSLn "import.iface.create" 15 $ prettyShow mname ++ ": Finished highlighting from type info."++ setScope scope+ reportSLn "scope.top" 90 $ "SCOPE " ++ show scope++ -- TODO: It would be nice if unsolved things were highlighted+ -- after every mutual block.++ openMetas <- getOpenMetas+ unless (null openMetas) $ do+ reportSLn "import.metas" 10 $ prettyShow mname ++ ": We have unsolved metas."+ reportSDoc "import.metas" 10 $ prettyGoals =<< getGoals++ ifTopLevelAndHighlightingLevelIs NonInteractive printUnsolvedInfo++ -- Andreas, 2016-08-03, issue #964+ -- When open metas are allowed,+ -- permanently freeze them now by turning them into postulates.+ -- This will enable serialization.+ -- savedMetaStore <- useTC stMetaStore+ unless (includeStateChanges isMain) $+ -- Andreas, 2018-11-15, re issue #3393:+ -- We do not get here when checking the main module+ -- (then includeStateChanges is True).+ whenM (optAllowUnsolved <$> pragmaOptions) $ do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Turning unsolved metas (if any) into postulates."+ withCurrentModule (scope ^. scopeCurrent) openMetasToPostulates+ -- Clear constraints as they might refer to what+ -- they think are open metas.+ stAwakeConstraints `setTCLens` []+ stSleepingConstraints `setTCLens` []++ -- Serialization.+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Starting serialization."+ i <- Bench.billTo [Bench.Serialization, Bench.BuildInterface] $+ buildInterface src topLevel++ reportS "tc.top" 101 $+ "Signature:" :+ [ unlines+ [ prettyShow q+ , " type: " ++ show (defType def)+ , " def: " ++ show cc+ ]+ | (q, def) <- HMap.toList $ iSignature i ^. sigDefinitions,+ Function{ funCompiled = cc } <- [theDef def]+ ]+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Finished serialization."++ mallWarnings <- getAllWarnings' isMain ErrorWarnings++ isWritingInterfaces <- writeInterfaces++ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Considering writing to interface file."+ finalIface <- constructIScope <$> case (null mallWarnings, isMain, isWritingInterfaces) of+ (False, _, _) -> do+ -- Andreas, 2018-11-15, re issue #3393+ -- The following is not sufficient to fix #3393+ -- since the replacement of metas by postulates did not happen.+ -- -- | not (allowUnsolved && all (isUnsolvedWarning . tcWarning) allWarnings) -> do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": We have warnings, skipping writing interface file."+ return i+ (True, MainInterface ScopeCheck , _) -> do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": We are just scope-checking, skipping writing interface file."+ return i+ (_, _, False) -> do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": We are not writing any interfaces, skipping writing interface file."+ return i+ (True, _, _) -> Bench.billTo [Bench.Serialization] $ do+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Actually calling writeInterface."+ -- The file was successfully type-checked (and no warnings were+ -- encountered), so the interface should be written out.+ ifile <- toIFile sf+ serializedIface <- writeInterface ifile i+ reportSLn "import.iface.create" 7 $ prettyShow mname ++ ": Finished writing to interface file."+ pure serializedIface++ -- -- Restore the open metas, as we might continue in interaction mode.+ -- Actually, we do not serialize the metas if checking the MainInterface+ -- stMetaStore `setTCLens` savedMetaStore++ -- Profiling: Print statistics.+ printStatistics (Just mname) =<< getStatistics++ -- Get the statistics of the current module+ -- and add it to the accumulated statistics.+ localStatistics <- getStatistics+ lensAccumStatistics `modifyTCLens'` (<>) localStatistics+ reportSLn "import.iface" 25 $ prettyShow mname ++ ": Added statistics to the accumulated statistics."++ isBuiltinMod <- isBuiltinModule sfi++ return ModuleInfo+ { miInterface = finalIface+ , miWarnings = mallWarnings+ , miIsBuiltin = isBuiltinMod+ , miMode = moduleCheckMode isMain+ , miSourceFile = sf+ }++-- | Expert version of 'getAllWarnings'; if 'isMain' is a+-- 'MainInterface', the warnings definitely include also unsolved+-- warnings.++getAllWarnings' :: (MonadWarning m, MonadTCM m) => MainInterface -> WhichWarnings -> m (Set TCWarning)+getAllWarnings' MainInterface{} = getAllWarningsPreserving unsolvedWarnings+getAllWarnings' NotMainInterface = getAllWarningsPreserving Set.empty++-- Andreas, issue 964: not checking null interactionPoints+-- anymore; we want to serialize with open interaction points now!++-- | Reconstruct the 'iScope' (not serialized)+-- from the 'iInsideScope' (serialized).++constructIScope :: Interface -> Interface+constructIScope i = billToPure [ Deserialization ] $+ i{ iScope = publicModules $ iInsideScope i }++-- | Builds an interface for the current module, which should already+-- have been successfully type checked.+buildInterface+ :: Source+ -- ^ 'Source' for the current module.+ -> TopLevelInfo+ -- ^ 'TopLevelInfo' scope information for the current module.+ -> TCM Interface+buildInterface src topLevel = do+ reportSLn "import.iface" 5 "Building interface..."+ let mname = CToA.topLevelModuleName topLevel+ source = srcText src+ fileType = srcFileType src+ defPragmas = srcDefaultPragmas src+ filePragmas = srcFilePragmas src++ -- Andreas, 2014-05-03: killRange did not result in significant reduction+ -- of .agdai file size, and lost a few seconds performance on library-test.+ -- Andreas, Makoto, 2014-10-18 AIM XX: repeating the experiment+ -- with discarding also the nameBindingSite in QName:+ -- Saves 10% on serialization time (and file size)!+ --+ -- NOTE: We no longer discard all nameBindingSites (but the commit+ -- that introduced this change seems to have made Agda a bit+ -- faster and interface file sizes a bit smaller, at least for the+ -- standard library).+ !mhs <- mapM (\top -> (top,) <$> moduleHash top) . Set.toAscList =<< useR stImportedModules+ !foreignCode <- useTC stForeignCode++ let !scope = topLevelScope topLevel++ (!solvedMetas, !definitions, !displayForms) <- eliminateDeadCode scope+ !sig <- set sigDefinitions definitions <$> getSignature++ -- Andreas, 2015-02-09 kill ranges in pattern synonyms before+ -- serialization to avoid error locations pointing to external files+ -- when expanding a pattern synonym.+ !patsyns <- killRange <$> getPatternSyns++ !userwarns <- useTC stLocalUserWarnings+ !importwarn <- useTC stWarningOnImport+ !syntaxInfo <- useTC stSyntaxInfo+ !optionsUsed <- useTC stPragmaOptions+ !partialDefs <- useTC stLocalPartialDefs++ -- Only serialise the opaque blocks actually defined in this+ -- top-level module.+ !opaqueBlocks' <- useTC stOpaqueBlocks+ !opaqueIds' <- useTC stOpaqueIds+ let+ !mh = moduleNameId (srcModuleName src)+ !opaqueBlocks = Map.filterWithKey (\(OpaqueId _ mod) _ -> mod == mh) opaqueBlocks'+ isLocal qnm = case nameId qnm of+ NameId _ mh' -> mh' == mh+ !opaqueIds = Map.filterWithKey (\qnm (OpaqueId _ mod) -> isLocal qnm || mod == mh) opaqueIds'++ !builtin <- Map.mapWithKey (\ x b -> primName x <$> b) <$> useTC stLocalBuiltins+ !warnings <- Set.filter (isSourceCodeWarning . warningName . tcWarning) <$> getAllWarnings AllWarnings++ let !i = Interface+ { iSourceHash = hashText source+ , iSource = source+ , iFileType = fileType+ , iImportedModules = mhs+ , iModuleName = mname+ , iTopLevelModuleName = srcModuleName src+ , iScope = empty -- publicModules scope+ , iInsideScope = scope+ , iSignature = sig+ , iMetaBindings = solvedMetas+ , iDisplayForms = displayForms+ , iUserWarnings = userwarns+ , iImportWarning = importwarn+ , iBuiltin = builtin+ , iForeignCode = foreignCode+ , iHighlighting = syntaxInfo+ , iDefaultPragmaOptions = defPragmas+ , iFilePragmaOptions = filePragmas+ , iOptionsUsed = optionsUsed+ , iPatternSyns = patsyns+ , iWarnings = warnings+ , iPartialDefs = partialDefs+ , iOpaqueBlocks = opaqueBlocks+ , iOpaqueNames = opaqueIds+ }+ !i <-+ ifM (optSaveMetas <$> pragmaOptions)+ (return i)+ (do reportSLn "import.iface" 7+ " instantiating all metavariables in interface"+ Bench.billTo [Bench.InterfaceInstantiateFull] $ liftReduce $ instantiateFull' i)+ reportSLn "import.iface" 7 " interface complete"+ return i++ where+ primName (PrimitiveName x) b = (x, primFunName b)+ primName (BuiltinName x) b = __IMPOSSIBLE__++-- | Returns (iSourceHash, iFullHash)+-- We do not need to check that the file exist because we only+-- accept @InterfaceFile@ as an input and not arbitrary @AbsolutePath@!+getInterfaceFileHashes :: InterfaceFile -> IO (Maybe (Hash, Hash))+getInterfaceFileHashes fp = do+ let ifile = filePath $ intFilePath fp+ h <- openBinaryFile ifile ReadMode+ bstr <- B.hGetSome h (2 * hashSize)+ hClose h+ deserializeHashes bstr++moduleHash :: TopLevelModuleName -> TCM Hash+moduleHash m = iFullHash <$> getNonMainInterface m Nothing
@@ -1,9 +1,12 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Interaction.Imports where -import Agda.Syntax.Abstract.Name ( ModuleName )-import Agda.Syntax.Scope.Base ( Scope )-import Agda.TypeChecking.Monad.Base ( TCM )-import Data.Map ( Map )+import Data.Map ( Map ) -scopeCheckImport :: ModuleName -> TCM (ModuleName, Map ModuleName Scope)+import Agda.Syntax.Abstract.Name ( ModuleName )+import Agda.Syntax.Scope.Base ( Scope )+import Agda.Syntax.TopLevelModuleName ( TopLevelModuleName )+import Agda.TypeChecking.Monad.Base ( TCM )++scopeCheckFileImport :: TopLevelModuleName -> TCM (ModuleName, Map ModuleName Scope)
@@ -0,0 +1,1266 @@+{-# LANGUAGE NondecreasingIndentation #-}+{-# OPTIONS_GHC -fno-cse #-}+{-# OPTIONS_GHC -Wno-orphans #-}++module Agda.Interaction.InteractionTop+ ( module Agda.Interaction.InteractionTop+ )+ where++import Prelude hiding (null)++import Control.Concurrent+import Control.Concurrent.Async+import Control.Concurrent.STM.TChan+import Control.Concurrent.STM.TVar+import qualified Control.Exception as E++import Control.Monad.Except ( MonadError(..), ExceptT(..), runExceptT )+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.State ( MonadState(..), gets, modify, runStateT )+import Control.Monad.STM+import Control.Monad.State ( StateT )++import Data.Char qualified as Char+import Data.Either ( partitionEithers )+import Data.Function ( on )+import Data.List qualified as List+import Data.Map qualified as Map+import Data.Maybe+import Data.Set qualified as Set++import System.Directory+import System.FilePath++import Agda.TypeChecking.Monad as TCM+import qualified Agda.TypeChecking.Pretty as TCP+import Agda.TypeChecking.Errors+import Agda.TypeChecking.Opacity (saturateOpaqueBlocks)+import Agda.TypeChecking.Rules.Term (checkExpr, isType_)+import Agda.TypeChecking.Warnings (warning)++import Agda.Syntax.Fixity+import Agda.Syntax.Position+import Agda.Syntax.Parser+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty hiding (Mode)+import Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Glyph+import Agda.Syntax.Abstract as A+import Agda.Syntax.Abstract.Pretty+import Agda.Syntax.Info (mkDefInfo)+import Agda.Syntax.Translation.ConcreteToAbstract+import Agda.Syntax.Translation.AbstractToConcrete+import Agda.Syntax.Translation.InternalToAbstract (reify)+import Agda.Syntax.Scope.Base+import Agda.Syntax.TopLevelModuleName++import Agda.Interaction.Base+import Agda.Interaction.ExitCode (pattern TCMError, exitAgdaWith)+import Agda.Interaction.FindFile+import Agda.Interaction.Options+import Agda.Interaction.Options.Lenses as Lenses+import Agda.Interaction.Options.ProfileOptions qualified as Profile+import Agda.Interaction.MakeCase+import Agda.Interaction.SearchAbout+import Agda.Interaction.Response hiding (Function, ExtendedLambda)+import qualified Agda.Interaction.Response as R+import qualified Agda.Interaction.BasicOps as B+import Agda.Interaction.Highlighting.Precise hiding (Error, Postulate, singleton)+import Agda.Interaction.Imports ( Mode, pattern ScopeCheck, pattern TypeCheck )+import qualified Agda.Interaction.Imports as Imp+import Agda.Interaction.Command+ (CommandM, liftLocalState, revLift, revLiftTC, localStateCommandM)+import Agda.Interaction.Highlighting.Generate++import Agda.Compiler.Backend++import Agda.Mimer.Mimer as Mimer++import Agda.Utils.Either+import Agda.Utils.FileName+import Agda.Utils.Function+import Agda.Utils.Hash+import Agda.Utils.IO (showIOException)+import Agda.Utils.Lens+import Agda.Utils.List (sortOnM)+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Maybe (whenJust)+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.String+import Agda.Utils.Time+import Agda.Utils.Tuple+import Agda.Utils.WithDefault (lensCollapseDefault, lensKeepDefault)++import Agda.Utils.Impossible++-- | Opposite of 'liftIO' for 'CommandM'.+--+-- This function should only be applied to computations that are+-- guaranteed not to raise any errors (except for 'IOException's).++commandMToIO :: (forall x . (CommandM a -> IO x) -> IO x) -> CommandM a+commandMToIO ci_i = revLift runStateT lift $ \ct -> revLiftTC runSafeTCM liftIO $ ci_i . (. ct)++-- | Lift a TCM action transformer to a CommandM action transformer.++liftCommandMT :: (forall x . TCM x -> TCM x) -> CommandM a -> CommandM a+liftCommandMT f m = revLift runStateT lift $ f . ($ m)++-- | Ditto, but restore state.++liftCommandMTLocalState :: (forall x . TCM x -> TCM x) -> CommandM a -> CommandM a+liftCommandMTLocalState f = liftCommandMT f . localStateCommandM++-- | Put a response by the callback function given by 'stInteractionOutputCallback'.++putResponse :: Response -> CommandM ()+putResponse = lift . appInteractionOutputCallback+++-- | A Lens for 'theInteractionPoints'.++modifyTheInteractionPoints :: ([InteractionId] -> [InteractionId]) -> CommandM ()+modifyTheInteractionPoints f = modify $ \ s ->+ s { theInteractionPoints = f (theInteractionPoints s) }+++-- * Operations for manipulating 'oldInteractionScopes'.++-- | A Lens for 'oldInteractionScopes'.+modifyOldInteractionScopes :: (OldInteractionScopes -> OldInteractionScopes) -> CommandM ()+modifyOldInteractionScopes f = modify $ \ s ->+ s { oldInteractionScopes = f $ oldInteractionScopes s }++insertOldInteractionScope :: InteractionId -> ScopeInfo -> CommandM ()+insertOldInteractionScope ii scope = do+ lift $ reportSLn "interaction.scope" 20 $ "inserting old interaction scope " ++ show ii+ modifyOldInteractionScopes $ Map.insert ii scope++removeOldInteractionScope :: InteractionId -> CommandM ()+removeOldInteractionScope ii = do+ lift $ reportSLn "interaction.scope" 20 $ "removing old interaction scope " ++ show ii+ modifyOldInteractionScopes $ Map.delete ii++getOldInteractionScope :: InteractionId -> CommandM ScopeInfo+getOldInteractionScope ii = do+ ms <- gets $ Map.lookup ii . oldInteractionScopes+ case ms of+ Nothing -> __IMPOSSIBLE_VERBOSE__ $ "not an old interaction point: " ++ show ii+ Just scope -> return scope++-- | Do setup and error handling for a command.++handleCommand_ :: CommandM () -> CommandM ()+handleCommand_ = handleCommand id (return ())++handleCommand :: (forall a. CommandM a -> CommandM a) -> CommandM () -> CommandM () -> CommandM ()+handleCommand wrap onFail cmd = handleNastyErrors $ wrap $ do+ oldState <- getTC++ -- -- Andreas, 2016-11-18 OLD CODE:+ -- -- onFail and handleErr are executed in "new" command state (not TCState).+ -- -- But it seems that if an exception is raised, it is identical to the old state,+ -- -- see code for catchErr.+ -- res <- (`catchErr` (return . Just)) $ Nothing <$ cmd+ -- maybe (return ()) (\ e -> onFail >> handleErr e) res++ -- Andreas, 2016-11-18 NEW CODE: execute onFail and handleErr in handler+ -- which means (looking at catchErr) they run in state s rathern than s'.+ -- Yet, it looks like s == s' in case the command failed.+ cmd `catchErr` \ e -> do+ onFail+ handleErr Nothing e+ -- Andreas, 2016-11-18, issue #2174+ -- Reset TCState after error is handled, to get rid of metas created during failed command+ lift $ do+ newPersistentState <- useTC lensPersistentState+ putTC oldState+ lensPersistentState `setTCLens` newPersistentState++ where+ -- Preserves state so we can do unsolved meta highlighting+ catchErr :: CommandM a -> (TCErr -> CommandM a) -> CommandM a+ catchErr m h = do+ s <- get+ (x, s') <- lift $ do runStateT m s+ `catchError_` \ e ->+ runStateT (h e) s+ put s'+ return x++ -- Handle every possible kind of error (#637), except for+ -- AsyncCancelled, which is used to abort Agda.+ handleNastyErrors :: CommandM () -> CommandM ()+ handleNastyErrors m = commandMToIO $ \ toIO -> do++ let asyncHandler e@AsyncCancelled = return (Left e)++ ioHandler (e :: E.IOException) = Right <$> do+ toIO $ handleErr (Just Direct) $ IOException Nothing noRange e++ generalHandler (e :: E.SomeException) = Right <$> do+ toIO $ handleErr (Just Direct) $ GenericException $ showIOException e++ r <- (Right <$> toIO m)+ `E.catch` asyncHandler+ `E.catch` ioHandler+ `E.catch` generalHandler+ case r of+ Right x -> return x+ Left e -> E.throwIO e++ -- Displays an error and instructs Emacs to jump to the site of the+ -- error. Because this function may switch the focus to another file+ -- the status information is also updated.+ handleErr method e = do++ -- TODO: make a better predicate for this+ noError <- lift $ null <$> renderError e+ unless noError do++ unsolved <- lift $ computeUnsolvedInfo+ err <- lift $ errorHighlighting e+ modFile <- lift $ useSession lensModuleToSource+ -- `theCurrentFile` may have been reset by `onFail`; use the IOTCM+ -- path to distinguish another file from the current buffer.+ currentPath <- gets theCurrentFilePath+ let errorFile = case rangeFile (getRange e) of+ Strict.Just rf+ | Just (rangeFilePath rf) /= currentPath ->+ Just $ filePath $ rangeFilePath rf+ | otherwise -> Nothing+ Strict.Nothing -> Nothing+ method <- case method of+ Nothing -> lift $ viewTC eHighlightingMethod+ Just m -> return m+ let errorInfo = convert err+ unsolvedInfo = convert unsolved+ info = errorInfo <> unsolvedInfo+ -- Errors take precedence over unsolved things.++ showImpl <- lift $ optShowImplicit <$> useTC stPragmaOptions+ showIrr <- lift $ optShowIrrelevant <$> useTC stPragmaOptions+ do+ mapM_ putResponse $+ [ Resp_DisplayInfo $ Info_Error $ Info_GenericError e ] +++ tellEmacsToJumpToError (getRange e) +++ (case errorFile of+ Just file ->+ [ Resp_HighlightingInfo errorInfo KeepHighlighting+ method modFile (Just file)+ , Resp_HighlightingInfo unsolvedInfo KeepHighlighting+ method modFile Nothing+ ]+ Nothing ->+ [ Resp_HighlightingInfo info KeepHighlighting method modFile Nothing ]) +++ [ Resp_Status $ Status { sChecked = False+ , sShowImplicitArguments = showImpl+ , sShowIrrelevantArguments = showIrr+ } ]+ whenM (optExitOnError <$> commandLineOptions) $+ liftIO $ exitAgdaWith TCMError++-- | Run an 'IOTCM' value, catch the exceptions, emit output+--+-- If an error happens the state of 'CommandM' does not change,+-- but stPersistent may change (which contains successfully+-- loaded interfaces for example).++runInteraction :: IOTCM -> CommandM ()+runInteraction iotcm = do+ currentAbs <- liftIO $ absolute current+ modify $ \s -> s { theCurrentFilePath = Just currentAbs }+ handleCommand inEmacs onFail $ do+ cf <- gets theCurrentFile+ cmd <- if independent cmd then return cmd else do+ when (Just currentAbs /= (currentFilePath <$> cf)) $ do+ let mode = TypeCheck+ cmd_load' current [] True mode $ \_ -> return ()+ cf <- fromMaybe __IMPOSSIBLE__ <$> gets theCurrentFile+ return $ case iotcm (Just (currentFileModule cf)) of+ IOTCM _ _ _ cmd -> cmd++ withCurrentFile $ interpret cmd++ cf' <- gets theCurrentFile+ when (updateInteractionPointsAfter cmd+ &&+ Just currentAbs == (currentFilePath <$> cf')) $ do+ putResponse . Resp_InteractionPoints =<< gets theInteractionPoints++ where+ -- The ranges in cmd might be incorrect because of the use of+ -- Nothing here. That is taken care of above.+ IOTCM current highlighting highlightingMethod cmd = iotcm Nothing++ inEmacs :: forall a. CommandM a -> CommandM a+ inEmacs = liftCommandMT $ withEnv $ initEnv & eHighlightingLevel .~ highlighting+ & eHighlightingMethod .~ highlightingMethod++ -- If an independent command fails we should reset theCurrentFile (Issue853).+ onFail | independent cmd = modify $ \ s -> s { theCurrentFile = Nothing }+ | otherwise = return ()++------------------------------------------------------------------------+-- Command queues++-- | If the next command from the command queue is anything but an+-- actual command, then the command is returned.+--+-- If the command is an 'IOTCM' command, then the following happens:+-- The given computation is applied to the command and executed. If an+-- abort command is encountered (and acted upon), then the computation+-- is interrupted, the persistent state and all options are restored,+-- and some commands are sent to the frontend. If the computation was+-- not interrupted, then its result is returned.++-- TODO: It might be nice if some of the changes to the persistent+-- state inflicted by the interrupted computation were preserved.++maybeAbort :: (IOTCM -> CommandM a) -> CommandM (Command' (Maybe a))+maybeAbort m = do+ commandState <- get+ let q = commandQueue commandState+ (n, cmd) <- liftIO $ atomically $ readTChan (commands q)+ case cmd of+ Done -> return Done+ Error e -> return (Error e)+ Command c -> do+ tcState <- getTC+ tcEnv <- askTC+ result <- liftIO $ race+ (runTCM tcEnv tcState $+ runStateT (m c) commandState)+ (waitForAbort n q)+ case result of+ Left ((x, commandState'), tcState') -> do+ putTC tcState'+ put commandState'+ case c Nothing of+ IOTCM _ _ _ Cmd_exit -> do+ putResponse Resp_DoneExiting+ return Done+ _ -> return (Command (Just x))+ Right a -> do+ liftIO $ popAbortedCommands q a+ putTC $ set lensPragmaOptions (tcState ^. lensPragmaOptions) $+ initStateFromPersistentState $ stPersistentState tcState+ put $ (initCommandState (commandQueue commandState))+ { optionsOnReload = optionsOnReload commandState+ }+ putResponse Resp_DoneAborting+ displayStatus+ return (Command Nothing)+ where++ -- Returns if the currently executing command should be aborted.+ -- The "abort number" is returned.++ waitForAbort+ :: Integer -- The number of the currently executing command.+ -> CommandQueue -- The command queue.+ -> IO Integer+ waitForAbort n q = do+ atomically $ do+ a <- readTVar (abort q)+ case a of+ Just a' | n <= a' -> return a'+ _ -> retry++ -- Removes every command for which the command number is at most+ -- the given number (the "abort number") from the command queue.+ --+ -- New commands could be added to the end of the queue while this+ -- computation is running. This does not lead to a race condition,+ -- because those commands have higher command numbers, so they will+ -- not be removed.++ popAbortedCommands :: CommandQueue -> Integer -> IO ()+ popAbortedCommands q n = do+ done <- atomically $ do+ cmd <- tryReadTChan (commands q)+ case cmd of+ Nothing -> return True+ Just c ->+ if fst c <= n then+ return False+ else do+ unGetTChan (commands q) c+ return True+ unless done $+ popAbortedCommands q n++-- | Creates a command queue, and forks a thread that writes commands+-- to the queue. The queue is returned.++initialiseCommandQueue+ :: IO Command+ -- ^ Returns the next command.+ -> IO CommandQueue+initialiseCommandQueue next = do+ commands <- newTChanIO+ abort <- newTVarIO Nothing++ let -- Read commands. The argument is the number of the previous+ -- command (other than abort commands) that was read, if any.+ readCommands n = do+ c <- next+ case c of+ Command c | IOTCM _ _ _ Cmd_abort <- c Nothing -> do+ atomically $ writeTVar abort (Just n)+ readCommands n+ _ -> do+ let n' = (succ n)+ atomically $ writeTChan commands (n', c)+ case c of+ Done -> return ()+ _ -> readCommands n'++ _ <- forkIO (readCommands 0)++ return (CommandQueue { commands, abort })++---------------------------------------------------------++-- | Can the command run even if the relevant file has not been loaded+-- into the state?++independent :: Interaction -> Bool+independent (Cmd_load {}) = True+independent Cmd_load_no_metas{} = True+independent (Cmd_compile {}) = True+independent (Cmd_load_highlighting_info {}) = True+independent Cmd_tokenHighlighting {} = True+independent Cmd_show_version = True+independent _ = False++-- | Should 'Resp_InteractionPoints' be issued after the command has+-- run?++updateInteractionPointsAfter :: Interaction -> Bool+updateInteractionPointsAfter Cmd_load{} = True+updateInteractionPointsAfter Cmd_compile{} = True+updateInteractionPointsAfter Cmd_backend_top{} = True+updateInteractionPointsAfter Cmd_backend_hole{} = True+updateInteractionPointsAfter Cmd_constraints{} = False+updateInteractionPointsAfter Cmd_metas{} = False+updateInteractionPointsAfter Cmd_load_no_metas{} = False+updateInteractionPointsAfter Cmd_show_module_contents_toplevel{} = False+updateInteractionPointsAfter Cmd_search_about_toplevel{} = False+updateInteractionPointsAfter Cmd_solveAll{} = True+updateInteractionPointsAfter Cmd_solveOne{} = True+updateInteractionPointsAfter Cmd_infer_toplevel{} = False+updateInteractionPointsAfter Cmd_compute_toplevel{} = False+updateInteractionPointsAfter Cmd_load_highlighting_info{} = False+updateInteractionPointsAfter Cmd_tokenHighlighting{} = False+updateInteractionPointsAfter Cmd_highlight{} = True+updateInteractionPointsAfter ShowImplicitArgs{} = False+updateInteractionPointsAfter ToggleImplicitArgs{} = False+updateInteractionPointsAfter ShowIrrelevantArgs{} = False+updateInteractionPointsAfter ToggleIrrelevantArgs{} = False+updateInteractionPointsAfter Cmd_give{} = True+updateInteractionPointsAfter Cmd_refine{} = True+updateInteractionPointsAfter Cmd_intro{} = True+updateInteractionPointsAfter Cmd_refine_or_intro{} = True+updateInteractionPointsAfter Cmd_autoOne{} = True+updateInteractionPointsAfter Cmd_autoAll{} = True+updateInteractionPointsAfter Cmd_context{} = False+updateInteractionPointsAfter Cmd_helper_function{} = False+updateInteractionPointsAfter Cmd_infer{} = False+updateInteractionPointsAfter Cmd_goal_type{} = False+updateInteractionPointsAfter Cmd_elaborate_give{} = True+updateInteractionPointsAfter Cmd_goal_type_context{} = False+updateInteractionPointsAfter Cmd_goal_type_context_infer{} = False+updateInteractionPointsAfter Cmd_goal_type_context_check{} = False+updateInteractionPointsAfter Cmd_show_module_contents{} = False+updateInteractionPointsAfter Cmd_make_case{} = True+updateInteractionPointsAfter Cmd_compute{} = False+updateInteractionPointsAfter Cmd_why_in_scope{} = False+updateInteractionPointsAfter Cmd_why_in_scope_toplevel{} = False+updateInteractionPointsAfter Cmd_show_version{} = False+updateInteractionPointsAfter Cmd_abort{} = False+updateInteractionPointsAfter Cmd_exit{} = False++getBackendName :: CompilerBackend -> BackendName+getBackendName = \case+ LaTeX -> "LaTeX"+ QuickLaTeX -> "LaTeX"+ OtherBackend "GHCNoMain" -> "GHC"+ OtherBackend b -> b++-- | Interpret an interaction.+--+-- For each goal command specific to an 'InteractionPoint'+-- that comes with a 'Range' for this interaction point+-- we first synchronize this 'Range' with the 'Range'+-- Agda has stored for the interaction meta.+-- In general, we consider the 'Range' sent with the command+-- as more up-to-date than the the 'Range' Agda has stored.+-- This is because the editor keeps track of changes+-- (that usually modify the position of interaction points),+-- but Agda does not.+--+-- Some goal commands carry a 'Range' for reasons of uniformity but do not use it.+-- For those, we do not synchronize the range.++interpret :: Interaction -> CommandM ()++interpret (Cmd_load m argv) = do+ cmd_load' m argv True mode $ \_ -> interpret $ Cmd_metas AsIs+ where+ mode = TypeCheck++interpret (Cmd_compile backend file argv) = do+ cmd_load' file argv allowUnsolved mode $ \ checkResult -> do+ ws <- lift $ applyFlagsToTCWarnings $ crWarnings checkResult+ case null ws of+ True -> do+ lift $ callBackend (getBackendName backend) isMain checkResult+ display_info . Info_CompilationOk backend =<< lift B.getWarningsAndNonFatalErrors+ False -> display_info $ Info_Error $ Info_CompilationError ws+ where+ allowUnsolved = backend `elem` [LaTeX, QuickLaTeX]+ mode | QuickLaTeX <- backend = ScopeCheck+ | otherwise = TypeCheck+ isMain | OtherBackend "GHCNoMain" <- backend = NotMain+ | otherwise = IsMain++interpret (Cmd_backend_top backend cmd) = do+ callBackendInteractTop (getBackendName backend) cmd++interpret (Cmd_backend_hole ii rng s backend cmd) = do+ rng <- syncInteractionRange ii rng+ callBackendInteractHole (getBackendName backend) cmd ii rng s++interpret (Cmd_constraints norm) = do+ display_info . Info_Constraints =<< lift (B.getConstraints norm)++interpret (Cmd_metas norm) = do+ ms <- lift $ B.getGoals' norm (max Simplified norm)+ display_info . Info_AllGoalsWarnings ms =<< lift B.getWarningsAndNonFatalErrors++interpret (Cmd_load_no_metas file) = do+ -- Fail if there are open metas.+ let allowMetas = False+ cmd_load' file [] allowMetas TypeCheck $ \ result -> do+ Imp.raiseNonFatalErrors result+ unlessM (null <$> getOpenMetas) __IMPOSSIBLE__++interpret (Cmd_show_module_contents_toplevel norm s) = do+ atTopLevel $ showModuleContents norm noRange s++interpret (Cmd_search_about_toplevel norm s) = do+ atTopLevel $ searchAbout norm noRange s++interpret (Cmd_solveAll norm) = solveInstantiatedGoals norm Nothing+interpret (Cmd_solveOne norm ii _ _) = solveInstantiatedGoals norm' (Just ii)+ -- `solveOne` is called via `agda2-maybe-normalised` which does not use+ -- AsIs < Simplified < Normalised but rather Simplified < Instantiated < Normalised+ -- So we remap the Rewrite modifiers to match solveAll's behaviour.+ -- NB: instantiate is called in getSolvedInteractionPoints no matter what.+ where norm' = case norm of+ Simplified -> AsIs+ Instantiated -> Simplified+ _ -> norm++interpret (Cmd_infer_toplevel norm s) = do+ (time, expr) <- parseAndDoAtToplevel (B.typeInCurrent norm) s+ state <- get+ display_info $ Info_InferredType state time expr++interpret (ShowImplicitArgs showImpl) = do+ opts <- lift commandLineOptions+ setCommandLineOpts $+ set (lensPragmaOptions . lensOptShowImplicit . lensKeepDefault) showImpl opts++interpret ToggleImplicitArgs = do+ opts <- lift commandLineOptions+ setCommandLineOpts $+ over (lensPragmaOptions . lensOptShowImplicit . lensCollapseDefault) not opts++interpret (ShowIrrelevantArgs showIrr) = do+ opts <- lift commandLineOptions+ setCommandLineOpts $+ set (lensPragmaOptions . lensOptShowIrrelevant . lensKeepDefault) showIrr opts++interpret ToggleIrrelevantArgs = do+ opts <- lift commandLineOptions+ setCommandLineOpts $+ over (lensPragmaOptions . lensOptShowIrrelevant . lensCollapseDefault) not opts++interpret (Cmd_load_highlighting_info source) = do+ l <- viewTC eHighlightingLevel+ when (l /= None) $ do+ -- Make sure that the include directories have+ -- been set.+ setCommandLineOpts =<< lift commandLineOptions+ resp <- lift $ liftIO . tellToUpdateHighlighting =<< do+ ex <- liftIO $ doesFileExist source+ absSource <- srcFromPath =<< liftIO (absolute source)+ if ex+ then+ do+ src <- Imp.parseSource absSource+ let m = Imp.srcModuleName src+ checkModuleName m absSource Nothing+ mmi <- getVisitedModule m+ case mmi of+ Nothing -> return Nothing+ Just mi ->+ if hashText (Imp.srcText src) == iSourceHash (miInterface mi)+ then do+ modFile <- useSession lensModuleToSource+ method <- viewTC eHighlightingMethod+ return $ Just (iHighlighting $ miInterface mi, method, modFile)+ else+ return Nothing+ `catchError` \_ -> return Nothing+ else+ return Nothing+ mapM_ putResponse resp++interpret (Cmd_tokenHighlighting source remove) = do+ info <- do l <- viewTC eHighlightingLevel+ if l == None+ then return Nothing+ else do+ source' <- liftIO (absolute source)+ lift $ (Just <$> generateTokenInfo source')+ `catchError` \_ ->+ return Nothing+ `finally`+ case remove of+ Remove -> liftIO $ removeFile source+ Keep -> return ()+ case info of+ Just info' -> lift $ printHighlightingInfo RemoveHighlighting info'+ Nothing -> return ()++interpret (Cmd_highlight ii rng s) = do+ rng <- syncInteractionRange ii rng+ l <- viewTC eHighlightingLevel+ when (l /= None) $ do+ scope <- getOldInteractionScope ii+ removeOldInteractionScope ii+ handle $ do+ parsed <- try (Info_HighlightingParseError ii) $+ B.parseExpr rng s+ expr <- try (Info_HighlightingScopeCheckError ii) $+ concreteToAbstract scope parsed+ lift $ printHighlightingInfo KeepHighlighting =<<+ generateTokenInfoFromString rng s+ lift $ highlightExpr expr+ where+ handle :: ExceptT Info_Error TCM () -> CommandM ()+ handle m = do+ res <- lift $ runExceptT m+ case res of+ Left err -> display_info $ Info_Error err+ Right _ -> return ()+ try :: Info_Error -> TCM a -> ExceptT Info_Error TCM a+ try err m = ExceptT $ do+ (mapLeft (const err) <$> freshTCM m) `catchError` \ _ -> return (Left err)+ -- freshTCM to avoid scope checking creating new interaction points++interpret (Cmd_give force ii rng s) = do+ rng <- syncInteractionRange ii rng+ give_gen force ii rng s Give++interpret (Cmd_refine ii rng s) = do+ rng <- syncInteractionRange ii rng+ give_gen WithoutForce ii rng s Refine++interpret (Cmd_intro pmLambda ii rng _) = do+ rng <- syncInteractionRange ii rng+ ss <- lift $ B.introTactic pmLambda ii+ liftCommandMT (withInteractionId ii) $ case ss of+ [] -> do+ display_info $ Info_Intro_NotFound+ [s] -> give_gen WithoutForce ii rng s Intro+ _:_:_ -> do+ display_info $ Info_Intro_ConstructorUnknown ss++interpret (Cmd_refine_or_intro pmLambda ii r s) = interpret $+ let s' = trim s+ in (if null s' then Cmd_intro pmLambda else Cmd_refine) ii r s'++interpret (Cmd_autoOne norm ii rng str) = do+ rng <- syncInteractionRange ii rng+ iscope <- getInteractionScope ii+ (time, result) <- maybeTimed $ Mimer.mimer norm ii rng str+ case result of+ MimerNoResult -> display_info $ Info_Auto "No solution found"+ MimerExpr str -> do+ res <- parseExprFromAuto ii rng str \ e -> do+ insertOldInteractionScope ii iscope+ _ <- liftTCM $ B.give WithForce ii e+ putResponse $ Resp_GiveAction ii $ Give_String str+ modifyTheInteractionPoints (List.delete ii)+ whenJust time (display_info . Info_Time)+ case res of+ Left msg -> display_info $ Info_Auto msg+ Right () -> return ()+ MimerList sols -> do+ display_info $ Info_Auto $ unlines $+ [ "Solutions:" ] +++ [ " " ++ show i ++ ". " ++ s | (i, s) <- sols ]++interpret (Cmd_autoAll norm) = do+ iis <- getInteractionPoints+ getOldScope <- do+ st <- getTC+ pure $ \ ii -> liftLocalState $ putTC st >> getInteractionScope ii+ unless (null iis) $ do+ let time = 1000 `div` length iis+ st <- getTC+ (msgs, solveds) <- partitionEithers <$> forM iis \ ii -> do+ rng <- getInteractionRange ii+ res <- Mimer.mimer norm ii rng ("-t " ++ show time ++ "ms")+ case res of+ MimerNoResult -> pure $ Right []+ MimerExpr str -> parseExprFromAuto ii rng str \ e -> do+ iscope <- getOldScope ii+ insertOldInteractionScope ii iscope+ _ <- liftTCM $ B.give WithoutForce ii e+ putResponse $ Resp_GiveAction ii $ Give_String str+ pure [ii]+ MimerList{} -> pure $ Right [] -- Don't list solutions in autoAll+ unlessNull (concat solveds) \ solved -> modifyTheInteractionPoints (List.\\ solved)+ unlessNull (concat msgs) (display_info . Info_Auto)++interpret (Cmd_context norm ii _ _) = do+ display_info . Info_Context ii =<< liftLocalState (B.getResponseContext norm ii)++interpret (Cmd_helper_function norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ -- Create type of application of new helper function that would solve the goal.+ helperType <- liftLocalState $ B.metaHelperType norm ii rng s+ display_info $ Info_GoalSpecific ii (Goal_HelperFunction helperType)++interpret (Cmd_infer norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ expr <- liftLocalState $ withInteractionId ii $ B.typeInMeta ii norm =<< B.parseExprIn ii rng s+ display_info $ Info_GoalSpecific ii (Goal_InferredType expr)++interpret (Cmd_goal_type norm ii _ _) = do+ display_info $ Info_GoalSpecific ii (Goal_CurrentGoal norm)++interpret (Cmd_elaborate_give norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ give_gen WithoutForce ii rng s $ ElaborateGive norm++interpret (Cmd_goal_type_context norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ cmd_goal_type_context_and GoalOnly norm ii rng s++interpret (Cmd_goal_type_context_infer norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ -- In case of the empty expression to type, don't fail with+ -- a stupid parse error, but just fall back to+ -- Cmd_goal_type_context.+ aux <- if all Char.isSpace s+ then return GoalOnly+ else do+ liftLocalState $ withInteractionId ii $ do+ parsed <- B.parseExprIn ii rng s+ (typ, faces) <- B.typeAndFacesInMeta ii norm parsed+ return (GoalAndHave typ faces)+ cmd_goal_type_context_and aux norm ii rng s++interpret (Cmd_goal_type_context_check norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ expr <- liftLocalState $ withInteractionId ii $ do+ expr <- B.parseExprIn ii rng s+ goal <- B.typeOfMeta AsIs ii+ term <- case goal of+ OfType _ ty -> checkExpr expr =<< isType_ ty+ _ -> __IMPOSSIBLE__+ reify =<< B.normalForm norm term+ cmd_goal_type_context_and (GoalAndElaboration expr) norm ii rng s++interpret (Cmd_show_module_contents norm ii rng s) = do+ rng <- syncInteractionRange ii rng+ liftCommandMT (withInteractionId ii) $ showModuleContents norm rng s++interpret (Cmd_why_in_scope_toplevel s) = do+ atTopLevel $ whyInScope s++interpret (Cmd_why_in_scope ii _range s) = do+ liftCommandMT (withInteractionId ii) $ whyInScope s++interpret (Cmd_make_case ii rng s) = do+ rng <- syncInteractionRange ii rng+ (f, casectxt, cs) <- lift $ makeCase ii rng s+ liftCommandMT (withInteractionId ii) $ do+ tel <- lift $ lookupSection (qnameModule f) -- don't shadow the names in this telescope+ unicode <- getsTC $ optUseUnicode . getPragmaOptions+ pcs :: [Doc] <- lift $ inTopContext $ addContext tel $ mapM prettyAUnqualify cs+ let pcs' :: [String] = List.map (extlam_dropName unicode casectxt . decorate) pcs+ lift $ reportSDoc "interaction.case" 60 $ TCP.vcat+ [ "InteractionTop.Cmd_make_case"+ , TCP.nest 2 $ TCP.vcat+ [ "cs = " TCP.<+> TCP.vcat (map prettyA cs)+ , "pcs = " TCP.<+> TCP.vcat (map return pcs)+ , "pcs' = " TCP.<+> TCP.vcat (map TCP.text pcs')+ ]+ ]+ lift $ reportSDoc "interaction.case" 90 $ TCP.vcat+ [ "InteractionTop.Cmd_make_case"+ , TCP.nest 2 $ TCP.vcat+ [ "cs = " TCP.<+> TCP.text (show cs)+ ]+ ]+ putResponse $ Resp_MakeCase ii (makeCaseVariant casectxt) pcs'++interpret (Cmd_compute_toplevel cmode s) = do+ (time, expr) <- parseAndDoAtToplevel (B.computeInCurrent cmode) (B.computeWrapInput cmode s)+ state <- get+ display_info $ Info_NormalForm state cmode time expr++interpret (Cmd_compute cmode ii rng s) = do+ rng <- syncInteractionRange ii rng+ expr <- liftLocalState $ do+ e <- B.parseExprIn ii rng $ B.computeWrapInput cmode s+ withInteractionId ii $ B.computeInCurrent cmode e+ display_info $ Info_GoalSpecific ii (Goal_NormalForm cmode expr)++interpret Cmd_show_version = display_info Info_Version++interpret Cmd_abort = return ()+interpret Cmd_exit = return ()++-- | Try to parse an expression generated by Auto and feed it to the continuation if successful.+-- If unsuccessful, just report the solution via 'Info_Auto'.+parseExprFromAuto :: InteractionId -> Range -> String -> (A.Expr -> CommandM a) -> CommandM (Either String a)+parseExprFromAuto ii rng str ret = do+ liftTCM (runPMIO $ parseRangeString exprWhereParser rng str) >>= \case+ -- Since the String comes from the Agda printer, we can ignore parse warnings.+ -- Also, no @where@ clause will be attached to the expression.+ (Right (C.ExprWhere ce _wh, _attrs), _warns) -> do+ e <- withInteractionId ii $ liftTCM $ concreteToAbstract_ ce+ Right <$> ret e+ (Left err, _warns) -> return $ Left $ unlines+ [ unwords [ prettyShow ii, ":=", str, " (fails to parse)" ]+ , prettyShow $ killRange err+ -- The range makes no sense since the string came from within Agda.+ ]++-- | If given range is empty, get the range of the interaction point.+-- Otherwise, set the range of the interaction point to the given range.+--+-- The idea is that the interaction frontend may have a more recent range for an interaction point+-- (for example, if the user has edited the file since the last command was sent).+--+-- There may be frontends that do not send ranges (like the interaction test suite),+-- so in that case get the range from the interaction point.+syncInteractionRange :: (MonadInteractionPoints m, MonadDebug m, MonadError TCErr m)+ => InteractionId -> Range -> m Range+syncInteractionRange ii r+ | null r = getInteractionRange ii+ | otherwise = r <$ setInteractionRange r ii+++decorate :: Doc -> String+decorate = renderStyle (style { mode = OneLineMode })++makeCaseVariant :: CaseContext -> MakeCaseVariant+makeCaseVariant Nothing = R.Function+makeCaseVariant Just{} = R.ExtendedLambda++-- very dirty hack, string manipulation by dropping the function name+-- and replacing the last " = " with " -> ". It's important not to replace+-- the equal sign in named implicit with an arrow!+extlam_dropName :: UnicodeOrAscii -> CaseContext -> String -> String+extlam_dropName _ Nothing x = x+extlam_dropName glyphMode Just{} x+ = unwords $ reverse $ replEquals $ reverse $ drop 1 $ words x+ where+ arrow = render $ _arrow $ specialCharactersForGlyphs glyphMode+ replEquals ("=" : ws) = arrow : ws+ replEquals (w : ws) = w : replEquals ws+ replEquals [] = []++-- | Solved goals already instantiated internally+-- The second argument potentially limits it to one specific goal.+solveInstantiatedGoals :: Rewrite -> Maybe InteractionId -> CommandM ()+solveInstantiatedGoals norm mii = do+ -- Andreas, 2016-10-23 issue #2280: throw away meta elims.+ out <- lift $ localTC (set ePrintMetasBare True) $ do+ sip <- B.getSolvedInteractionPoints False norm+ -- only solve metas which have a proper instantiation, i.e., not another meta+ let sip' = maybe id (\ ii -> filter ((ii ==) . fst3)) mii sip+ mapM prt sip'+ putResponse $ Resp_SolveAll out+ where+ prt (i, m, e) = do+ mi <- getMetaInfo <$> lookupLocalMeta m+ e' <- withMetaInfo mi $ abstractToConcreteCtx TopCtx e+ return (i, e')++-- | @cmd_load' file argv unsolvedOk cmd@+-- loads the module in file @file@,+-- using @argv@ as the command-line options.+--+-- If type checking completes without any exceptions having been+-- encountered then the command @cmd r@ is executed, where @r@ is the+-- result of 'Imp.typeCheckMain'.++cmd_load'+ :: FilePath -- ^ File to load into interaction.+ -> [String] -- ^ Arguments to Agda for loading this file+ -> Bool -- ^ Allow unsolved meta-variables?+ -> Mode -- ^ Full type-checking, or only scope-checking?+ -> (CheckResult -> CommandM a)+ -- ^ Continuation after successful loading.+ -> CommandM a+cmd_load' file argv unsolvedOK mode cmd = do++ -- Forget the previous "current file" and interaction points.+ modify $ \ st -> st { theInteractionPoints = []+ , theCurrentFile = Nothing+ }++ -- Update the status. Because the "current file" is not set the+ -- status is not "Checked".+ displayStatus++ -- Reset the state, preserving options and decoded modules. Note+ -- that if the include directories have changed, then the decoded+ -- modules are reset by TCM.setCommandLineOptions' below.+ lift resetState++ -- Clear the info buffer to make room for information about which+ -- module is currently being type-checked.+ putResponse Resp_ClearRunningInfo++ -- Remove any prior syntax highlighting.+ putResponse (Resp_ClearHighlighting NotOnlyTokenBased)++ -- Parse the file.+ --+ -- Note that options are set below.+ fp <- liftIO $ absolute file+ sf <- liftTCM $ srcFromPath fp+ src <- lift $ Imp.parseSource sf+ -- Andreas, 2024-08-03, see test/Interaction/FileNotFound:+ -- Run 'getModificationTime' after 'parseSource',+ -- otherwise the user gets a weird error for non-existing files.+ -- (We assume that parsing is fast in comparison to type-checking,+ -- so it should not matter much whether we get the time stamp+ -- before or after parsing.)+ t <- liftIO $ getModificationTime file++ -- Store the warnings.+ warnings <- useTC stTCWarnings++ -- All options are reset when a file is reloaded, including the+ -- choice of whether or not to display implicit arguments.+ opts0 <- gets optionsOnReload+ backends <- useSession lensBackends+ let (z, warns) = runOptM $ parseBackendOptions backends argv opts0+ mapM_ (lift . warning . OptionWarning) warns+ case z of+ Left err -> lift $ typeError $ OptionError err+ Right (_, opts) -> do+ opts <- lift $ addTrustedExecutables opts+ let update = over (lensOptAllowUnsolved . lensKeepDefault) (unsolvedOK &&)+ root = projectRoot fp $ Imp.srcModuleName src+ lift $ TCM.setCommandLineOptions' root $ mapPragmaOptions update opts++ -- Restore the warnings that were saved above.+ modifyTCLens stTCWarnings $ Set.union warnings++ ok <- lift $ Imp.typeCheckMain mode src++ -- The module type checked. If the file was not changed while the+ -- type checker was running then the interaction points and the+ -- "current file" are stored.+ t' <- liftIO $ getModificationTime file+ when (t == t') $ do+ is <- lift $ sortInteractionPoints =<< getInteractionPoints+ modify $ \st -> st { theInteractionPoints = is+ , theCurrentFile = Just $ CurrentFile+ { currentFilePath = fp+ , currentFileModule = Imp.srcModuleName src+ , currentFileArgs = argv+ , currentFileStamp = t+ }+ }++ cmd ok++-- | Set 'envCurrentPath' to 'theCurrentFile', if any.+withCurrentFile :: CommandM a -> CommandM a+withCurrentFile m = do+ mfile <- gets $ fmap currentFilePath . theCurrentFile+ i <- traverse idFromFile mfile+ localTC (set eCurrentPath i) m++atTopLevel :: CommandM a -> CommandM a+atTopLevel cmd = liftCommandMT B.atTopLevel cmd++---------------------------------------------------------------------------+-- Giving, refining.++data GiveRefine = Give | Refine | Intro | ElaborateGive Rewrite+ deriving (Eq, Show)++-- | A "give"-like action (give, refine, etc).+--+-- @give_gen force ii rng s give_ref mk_newtxt@+-- acts on interaction point @ii@+-- occupying range @rng@,+-- placing the new content given by string @s@,+-- and replacing @ii@ by the newly created interaction points+-- in the state if safety checks pass (unless @force@ is applied).+give_gen+ :: UseForce -- ^ Should safety checks be skipped?+ -> InteractionId+ -> Range+ -> String+ -> GiveRefine+ -> CommandM ()+give_gen force ii rng s0 giveRefine = do+ let s = trim s0+ reportSDoc "interaction.give" 20 $ TCP.text ("give_gen " ++ s) TCP.<+> TCP.pretty rng+ -- Issue #8858: the disambiguated names recorded while checking the+ -- given expression have ranges inside the old goal.+ -- They are only valid for the immediate highlighting below,+ -- afterwards they are stale and would pollute later highlighting+ -- (e.g. by @Cmd_highlight@). Thus, we restore the old map at the end.+ disambiguatedNames <- useTC stDisambiguatedNames+ -- Andreas, 2015-02-26 if string is empty do nothing rather+ -- than giving a parse error.+ flip finally (setTCLens stDisambiguatedNames disambiguatedNames) $ unless (null s) $ do+ let give_ref =+ case giveRefine of+ Give -> B.give+ Refine -> B.refine+ Intro -> B.refine+ ElaborateGive norm -> B.elaborate_give norm+ -- save scope of the interaction point (for printing the given expr. later)+ scope <- getInteractionScope ii+ -- parse string and "give", obtaining an abstract expression+ -- and newly created interaction points+ (time, (ae, ae0, iis)) <- maybeTimed $ do+ -- Issue 3000: mark the current hole as solved before giving, to avoid confusing it with potential+ -- new interaction points introduced by the give.+ removeInteractionPoint ii+ mis <- getInteractionPoints+ reportSLn "interaction.give" 30 $ "interaction points before = " ++ show mis+ given <- lift $ B.parseExprIn ii rng s+ ae <- lift $ give_ref force ii given+ mis' <- getInteractionPoints+ reportSLn "interaction.give" 30 $ "interaction points after = " ++ show mis'+ return (ae, given, mis' List.\\ mis)+ -- favonia: backup the old scope for highlighting+ insertOldInteractionScope ii scope+ -- sort the new interaction points and put them into the state+ -- in replacement of the old interaction point+ reportSDoc "interaction.give" 30 $ TCP.hsep $ ("new interaction points:" :) $+ map (\ i -> TCP.prettyTCM =<< do (i,) <$> getInteractionRange i) iis+ iis' <- sortInteractionPoints iis+ modifyTheInteractionPoints $ replace ii iis'+ -- print abstract expr+ ce <- abstractToConcreteScope scope ae+ reportS "interaction.give" 30+ [ "ce = " ++ prettyShow ce+ , "scopePrecedence = " ++ show (scope ^. scopePrecedence)+ ]++ -- Issue 7218: if the give/refine command creates an extended+ -- lambda, it also needs to be added to the relevant unfolding sets.+ -- The easiest way to make sure this is consistent is to just re-run+ -- the saturation procedures.+ saturateOpaqueBlocks++ -- if the command was @Give@, use the literal user input;+ -- Andreas, 2014-01-15, see issue 1020:+ -- Refine could solve a goal by introducing the sole constructor+ -- without arguments. Then there are no interaction metas, but+ -- we still cannot just `give' the user string (which may be empty).+ -- WRONG: also, if no interaction metas were created by @Refine@+ -- WRONG: let literally = (giveRefine == Give || null iis) && rng /= noRange+ -- Ulf, 2015-03-30, if we're doing intro we can't do literal give since+ -- there is nothing in the hole (issue 1892).+ let literally = (giveRefine == Give || giveRefine == Refine) && ae == ae0 && rng /= noRange+ -- Ulf, 2014-01-24: This works for give since we're highlighting the string+ -- that's already in the buffer. Doing it before the give action means that+ -- the highlighting is moved together with the text when the hole goes away.+ -- To make it work for refine we'd have to adjust the ranges.+ when literally $ do+ l <- viewTC eHighlightingLevel+ when (l /= None) $ lift $ do+ printHighlightingInfo KeepHighlighting =<<+ generateTokenInfoFromString rng s+ highlightExpr ae+ putResponse $ Resp_GiveAction ii $ mkNewTxt literally ce+ reportSLn "interaction.give" 30 $ "putResponse GiveAction passed"+ -- display new goal set (if not measuring time)+ maybe (interpret $ Cmd_metas AsIs) (display_info . Info_Time) time+ reportSLn "interaction.give" 30 $ "interpret Cmd_metas passed"+ where+ -- Substitutes xs for x in ys.+ replace x xs ys = concatMap (\ y -> if y == x then xs else [y]) ys+ -- For @Give@ we can replace the ii by the user given input.+ mkNewTxt True C.Paren{} = Give_Paren+ mkNewTxt True _ = Give_NoParen+ -- Otherwise, we replace it by the reified value Agda computed.+ mkNewTxt False ce = Give_String $ prettyShow ce++highlightExpr :: A.Expr -> TCM ()+highlightExpr e =+ localTC ( set eImportStack []+ . set eHighlightingLevel NonInteractive+ . set eHighlightingMethod Direct) $+ generateAndPrintSyntaxInfo decl Full True+ where+ dummy = mkName_ (NameId 0 noModuleNameHash) ("dummy" :: String)+ info = mkDefInfo (nameConcrete dummy) noFixity' PublicAccess ConcreteDef (getRange e)+ decl = A.Axiom OtherDefName info defaultArgInfo Nothing (qnameFromList $ singleton dummy) e++-- | Sorts interaction points based on their ranges.++sortInteractionPoints+ :: (MonadInteractionPoints m, MonadError TCErr m, MonadDebug m)+ => [InteractionId] -> m [InteractionId]+sortInteractionPoints = sortOnM getInteractionRange++-- | Displays the current goal, the given document, and the current+-- context.+--+-- Should not modify the state.++cmd_goal_type_context_and :: GoalTypeAux -> Rewrite -> InteractionId -> Range ->+ String -> CommandM ()+cmd_goal_type_context_and aux norm ii _ _ = do+ ctx <- lift $ B.getResponseContext norm ii+ constr <- lift $ lookupInteractionId ii >>= B.getConstraintsMentioning norm+ boundary <- lift $ B.getIPBoundary norm ii+ display_info $ Info_GoalSpecific ii (Goal_GoalType norm aux ctx boundary constr)++-- | Shows all the top-level names in the given module, along with+-- their types.++showModuleContents :: Rewrite -> Range -> String -> CommandM ()+showModuleContents norm rng s = do+ (modules, tel, types) <- lift $ B.moduleContents norm rng s+ display_info $ Info_ModuleContents modules tel types++-- | Shows all the top-level names in scope which mention all the given+-- identifiers in their type.++searchAbout :: Rewrite -> Range -> String -> CommandM ()+searchAbout norm rg names = do+ unlessNull (trim names) $ \ trimmedNames -> do+ hits <- lift $ findMentions norm rg trimmedNames+ display_info $ Info_SearchAbout hits trimmedNames++-- | Explain why something is in scope.++whyInScope :: String -> CommandM ()+whyInScope s = do+ Just file <- gets theCurrentFile+ let cwd = takeDirectory (filePath $ currentFilePath file)+ why <- liftLocalState $ B.whyInScope cwd s+ display_info $ Info_WhyInScope why++-- | Sets the command line options and updates the status information.++setCommandLineOpts :: CommandLineOptions -> CommandM ()+setCommandLineOpts opts = do+ lift $ TCM.setCommandLineOptions opts+ displayStatus+++-- | Computes some status information.+--+-- Does not change the state.++status :: CommandM Status+status = do+ cf <- gets theCurrentFile+ showImpl <- lift showImplicitArguments+ showIrr <- lift showIrrelevantArguments++ -- Check if the file was successfully type checked, and has not+ -- changed since. Note: This code does not check if any dependencies+ -- have changed, and uses a time stamp to check for changes.+ checked <- lift $ case cf of+ Nothing -> return False+ Just f -> do+ t <- liftIO $ getModificationTime $ filePath (currentFilePath f)+ if currentFileStamp f == t+ then+ maybe False (null . miWarnings) <$>+ getVisitedModule (currentFileModule f)+ else+ return False++ return $ Status { sShowImplicitArguments = showImpl,+ sShowIrrelevantArguments = showIrr,+ sChecked = checked }++-- | Displays or updates status information.+--+-- Does not change the state.++displayStatus :: CommandM ()+displayStatus =+ putResponse . Resp_Status =<< status++-- | @display_info@ does what @'displayInfo' False@ does, but+-- additionally displays some status information (see 'status' and+-- 'displayStatus').++display_info :: DisplayInfo -> CommandM ()+display_info info = do+ displayStatus+ putResponse $ Resp_DisplayInfo info++-- | Parses and scope checks an expression (using the \"inside scope\"+-- as the scope), performs the given command with the expression as+-- input, and returns the result and the time it takes.++parseAndDoAtToplevel+ :: (A.Expr -> TCM a)+ -- ^ The command to perform.+ -> String+ -- ^ The expression to parse.+ -> CommandM (Maybe CPUTime, a)+parseAndDoAtToplevel cmd s = do+ localStateCommandM $ do+ (e, attrs) <- lift $ runPM $ parse exprParser s+ lift $ checkAttributes attrs+ maybeTimed $ atTopLevel $ lift $+ cmd =<< concreteToAbstract_ e++maybeTimed :: CommandM a -> CommandM (Maybe CPUTime, a)+maybeTimed work = do+ doTime <- lift $ hasProfileOption Profile.Interactive+ if not doTime+ then (Nothing,) <$> work+ else do+ (r, time) <- measureTime work+ return (Just time, r)++-- | Tell to highlight the code using the given highlighting+-- info (unless it is @Nothing@).++tellToUpdateHighlighting+ :: Maybe (HighlightingInfo, HighlightingMethod, ModuleToSource) -> IO [Response]+tellToUpdateHighlighting Nothing = return []+tellToUpdateHighlighting (Just (info, method, modFile)) =+ return [Resp_HighlightingInfo info KeepHighlighting method modFile Nothing]++-- | Tells the Emacs mode to go to the first error position (if any).++tellEmacsToJumpToError :: Range -> [Response]+tellEmacsToJumpToError r =+ case rStart r of+ Nothing -> []+ Just (Pn' Strict.Nothing _ _) -> []+ Just (Pn' (Strict.Just f) p _) -> [Resp_JumpToError (filePath (rangeFilePath f)) p]
@@ -0,0 +1,151 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE OverloadedStrings #-}++-- | Encoding stuff into JSON values in TCM++module Agda.Interaction.JSON+ ( module Export+ , EncodeTCM(..)+ , obj, kind, kind'+ , (.=)+ , (@=), (#=)+ ) where++import Control.Monad as Export ((>=>), (<=<))+import Data.Aeson as Export hiding (Result(..), (.=))++import qualified Data.Aeson+import Data.Aeson.Types ( Pair )+import qualified Data.Aeson.Key as Key++import Data.Text (Text)+import Data.Word (Word32)++-- import qualified Agda.Syntax.Translation.InternalToAbstract as I2A+-- import qualified Agda.Syntax.Translation.AbstractToConcrete as A2C++-- import qualified Agda.Syntax.Concrete as C+-- import qualified Agda.Syntax.Internal as I+import Agda.TypeChecking.Monad hiding ((.=))+import Agda.Syntax.Common.Pretty++import Agda.Utils.DocTree qualified as DocTree+import qualified Agda.Utils.FileName as File+import qualified Agda.Utils.Maybe.Strict as Strict+import Agda.Interaction.Highlighting.Common (toAtoms)+import qualified Data.Aeson.KeyMap as KeyMap++toKey :: Text -> Key+toKey = Key.fromText++---------------------------------------------------------------------------+-- * The EncodeTCM class++-- | The JSON version of`PrettyTCM`, for encoding JSON value in TCM+class EncodeTCM a where+ encodeTCM :: a -> TCM Value+ default encodeTCM :: ToJSON a => a -> TCM Value+ encodeTCM = pure . toJSON++-- | TCM monadic version of object+obj :: [TCM Pair] -> TCM Value+obj = (object <$>) . sequence++-- | A key-value pair for encoding a JSON object.+(.=) :: ToJSON a => Text -> a -> Pair+(.=) = (Data.Aeson..=) . toKey++-- | Pairs a key with a value wrapped in TCM+(#=) :: (ToJSON a) => Text -> TCM a -> TCM Pair+(#=) key boxed = do+ value <- boxed+ pure $ key .= toJSON value++-- | Abbreviation of `_ #= encodeTCM _`+(@=) :: (EncodeTCM a) => Text -> a -> TCM Pair+(@=) key value = do+ encoded <- encodeTCM value+ pure $ key .= encoded++-- | A handy alternative of `obj` with kind specified+kind :: Text -> [TCM Pair] -> TCM Value+kind k = obj . (("kind" @= String k) :)++-- | A handy alternative of `object` with kind specified+kind' :: Text -> [Pair] -> Value+kind' k = object . (("kind" .= String k) :)++-- ---------------------------------------------------------------------------+-- -- * The Rep & ToRep class+--+-- -- | Translates internal types to concrete types+-- class ToRep i c | i -> c where+-- toRep :: i -> TCM c+--+-- instance ToRep I.Term C.Expr where+-- toRep internal = I2A.reify internal >>= A2C.abstractToConcrete_+--+-- instance ToRep I.Type C.Expr where+-- toRep internal = I2A.reify internal >>= A2C.abstractToConcrete_+--+-- data Rep internal concrete = Rep+-- { internalRep :: internal+-- , concreteRep :: concrete+-- }+--+-- instance (ToJSON i, ToJSON c) => ToJSON (Rep i c) where+-- toJSON (Rep i c) = object+-- [ "internal" .= i+-- , "concrete" .= c+-- ]+--+-- rep :: (ToRep i c) => i -> TCM (Rep i c)+-- rep internal = do+-- concrete <- toRep internal+-- return $ Rep+-- { internalRep = internal+-- , concreteRep = concrete+-- }++--------------------------------------------------------------------------------+-- Instances of ToJSON or EncodeTCM++encodeListTCM :: EncodeTCM a => [a] -> TCM Value+encodeListTCM = mapM encodeTCM >=> return . toJSONList++instance EncodeTCM a => EncodeTCM [a] where+ encodeTCM = mapM encodeTCM >=> return . toJSONList++-- overlaps with the instance declared above+instance {-# OVERLAPPING #-} EncodeTCM String++instance EncodeTCM Bool+instance EncodeTCM Int+instance EncodeTCM Word32+instance EncodeTCM Value+instance EncodeTCM Doc+instance EncodeTCM DocTree++instance ToJSON DocTree where+ toJSON = toJSON . DocTree.treeToTextNoAnn+ -- toJSON = toJsonDocTree -- TODO: communicate annotations to JSON client++-- UNUSED code taken from+-- https://github.com/plt-amy/agda/blob/9fd50b883f14a05792ed79a0b693fbecb2165bf5/src/full/Agda/LSP/Output.hs#L29-L35+toJsonDocTree :: DocTree -> Value+toJsonDocTree = \case+ DocTree.Node tt ds -> Object $ KeyMap.fromList+ [ ("style", toJSON (toAtoms tt))+ , ("children", toJSONList ds)+ ]+ DocTree.Text t -> toJSON t++instance ToJSON Doc where+ toJSON = toJSON . render++instance EncodeTCM a => EncodeTCM (Maybe a) where+ encodeTCM Nothing = return Null+ encodeTCM (Just a) = encodeTCM a++instance ToJSON File.AbsolutePath where+ toJSON (File.AbsolutePath path) = toJSON path
@@ -0,0 +1,490 @@+module Agda.Interaction.JSONTop+ ( jsonREPL+ ) where++import Control.Monad+ ( (<=<), forM )+import Control.Monad.IO.Class+ ( MonadIO(..) )++import Data.ByteString.Lazy (ByteString)+import qualified Data.ByteString.Lazy.Char8 as BS+import qualified Data.Text as T+import qualified Data.Set as Set++import Agda.Interaction.AgdaTop+import Agda.Interaction.Base+ ( CommandState(..), CurrentFile(..), ComputeMode(..), Rewrite(..)+ , OutputConstraint_boot(..), OutputForm_boot(..))+import Agda.Interaction.Output (OutputConstraint, OutputForm)+import qualified Agda.Interaction.BasicOps as B+import Agda.Interaction.EmacsTop+import Agda.Interaction.JSON+import Agda.Interaction.Response as R+import Agda.Interaction.Highlighting.JSON++import Agda.Syntax.Abstract.Pretty+ ( prettyATop )+import Agda.Syntax.Common+import qualified Agda.Syntax.Abstract as A+import qualified Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Name+ ( NameInScope(..), Name )+import Agda.Syntax.Internal+ ( telToList, Dom'(..), Dom, MetaId(..), ProblemId(..), Blocker(..), alwaysUnblock,+ domIsFinite, domInfo )+import Agda.Syntax.Position+ ( Range, rangeIntervals, Interval'(..), Position'(..), noRange, posLine, posCol )+import Agda.Syntax.Scope.Base+ ( WhyInScopeData(..) )++import Agda.TypeChecking.Errors+ ( getAllWarningsOfTCErr )+import Agda.TypeChecking.Monad+ ( Comparison(..), inTopContext, TCM, TCErr, TCWarning, NamedMeta(..), withInteractionId )+import Agda.TypeChecking.Monad.MetaVars+ ( getInteractionRange, getMetaRange, withMetaId )+import Agda.TypeChecking.Pretty+ ( PrettyTCM(..), prettyTCM )+-- borrowed from EmacsTop, for temporarily serialising stuff+import Agda.TypeChecking.Pretty.Warning+ ( filterTCWarnings )+import Agda.TypeChecking.Warnings+ ( WarningsAndNonFatalErrors(..) )++import qualified Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Common.Pretty+ ( Pretty(..), prettyShow )+import Agda.Utils.Time+ ( CPUTime(..) )++import Agda.VersionCommit++--------------------------------------------------------------------------------++-- | 'jsonREPL' is a interpreter like 'mimicGHCi', but outputs JSON-encoded strings.+--+-- 'jsonREPL' reads Haskell values (that starts from 'IOTCM' ...) from stdin,+-- interprets them, and outputs JSON-encoded strings. into stdout.++jsonREPL :: TCM () -> TCM ()+jsonREPL = repl (liftIO . BS.putStrLn <=< jsonifyResponse) "JSON> "++instance EncodeTCM NameInScope where+instance ToJSON NameInScope where+ toJSON InScope = toJSON True+ toJSON NotInScope = toJSON False++instance EncodeTCM Status where+instance ToJSON Status where+ toJSON status = object+ [ "showImplicitArguments" .= sShowImplicitArguments status+ , "showIrrelevantArguments" .= sShowIrrelevantArguments status+ , "checked" .= sChecked status+ ]++instance EncodeTCM CommandState where+instance ToJSON CommandState where+ toJSON commandState = object+ [ "interactionPoints" .= theInteractionPoints commandState+ , "currentFile" .= theCurrentFile commandState+ -- more?+ ]++instance EncodeTCM CurrentFile where+instance ToJSON CurrentFile where+ toJSON (CurrentFile path _ _ time) = toJSON (path, time) -- backwards compat.++instance EncodeTCM ResponseContextEntry where+ encodeTCM entry = obj+ [ "originalName" @= encodePretty (respOrigName entry)+ , "reifiedName" @= encodePretty (respReifName entry)+ , "binding" #= prettyATop (unArg (respType entry))+ , "inScope" @= respInScope entry+ ]++instance EncodeTCM (Position' ()) where+instance ToJSON (Position' ()) where+ toJSON p = object+ [ "pos" .= toJSON (posPos p)+ , "line" .= toJSON (posLine p)+ , "col" .= toJSON (posCol p)+ ]++instance EncodeTCM Range where+instance ToJSON Range where+ toJSON = toJSON . map prettyInterval . rangeIntervals+ where prettyInterval (Interval f s e) = object [ "start" .= (f <$ s), "end" .= (f <$ e) ]++instance EncodeTCM ProblemId where+instance EncodeTCM MetaId where++instance ToJSON ProblemId where toJSON (ProblemId i) = toJSON i++instance ToJSON ModuleNameHash where+ toJSON (ModuleNameHash h) = toJSON h++instance ToJSON MetaId where+ toJSON m = object+ [ "id" .= toJSON (metaId m)+ , "module" .= toJSON (metaModule m)+ ]++instance EncodeTCM InteractionId where+ encodeTCM ii@(InteractionId i) = obj+ [ "id" @= toJSON i+ , "range" #= intervalsTCM+ ]+ where+ intervalsTCM = toJSON <$> getInteractionRange ii+instance ToJSON InteractionId where+ toJSON (InteractionId i) = toJSON i++instance EncodeTCM NamedMeta where+ encodeTCM m = obj+ [ "name" #= nameTCM+ , "range" #= intervalsTCM+ ]+ where+ nameTCM = encodeShow <$> withMetaId (nmid m) (prettyATop m)+ intervalsTCM = toJSON <$> getMetaRange (nmid m)++instance EncodeTCM GiveResult where+instance ToJSON GiveResult where+ toJSON (Give_String s) = object [ "str" .= s ]+ toJSON Give_Paren = object [ "paren" .= True ]+ toJSON Give_NoParen = object [ "paren" .= False ]++instance EncodeTCM MakeCaseVariant where+instance ToJSON MakeCaseVariant where+ toJSON R.Function = String "Function"+ toJSON R.ExtendedLambda = String "ExtendedLambda"++encodePretty :: Pretty a => a -> Value+encodePretty = encodeShow . pretty++encodeShow :: Show a => a -> Value+encodeShow = String . T.pack . show++encodePrettyTCM :: PrettyTCM a => a -> TCM Value+encodePrettyTCM = (encodeShow <$>) . prettyTCM++instance EncodeTCM Rewrite where+instance ToJSON Rewrite where toJSON = encodeShow++instance EncodeTCM CPUTime where+instance ToJSON CPUTime where toJSON = encodePretty++instance EncodeTCM ComputeMode where+instance ToJSON ComputeMode where toJSON = encodeShow++instance EncodeTCM C.Expr where+instance ToJSON C.Expr where toJSON = encodePretty++instance EncodeTCM A.Expr where+ encodeTCM e = encodeShow <$> prettyATop e++encodeOCCmp :: EncodeTCM a => Comparison+ -> a -> a -> T.Text+ -> TCM Value+encodeOCCmp c i j k = kind k+ [ "comparison" @= encodeShow c+ , "constraintObjs" #= traverse encodeTCM [i, j]+ ]++-- Goals+instance (EncodeTCM a, EncodeTCM b) => EncodeTCM (OutputConstraint b a) where+ encodeTCM = \case+ OfType i a -> kind "OfType"+ [ "constraintObj" #= encodeTCM i+ , "type" #= encodeTCM a+ ]+ CmpInType c a i j -> kind "CmpInType"+ [ "comparison" @= encodeShow c+ , "type" #= encodeTCM a+ , "constraintObjs" #= traverse encodeTCM [i, j]+ ]+ CmpElim ps a is js -> kind "CmpElim"+ [ "polarities" @= map encodeShow ps+ , "type" #= encodeTCM a+ , "constraintObjs" #= traverse (traverse encodeTCM) [is, js]+ ]+ JustType a -> kind "JustType"+ [ "constraintObj" #= encodeTCM a+ ]+ JustSort a -> kind "JustSort"+ [ "constraintObj" #= encodeTCM a+ ]+ CmpTypes c i j -> encodeOCCmp c i j "CmpTypes"+ CmpLevels c i j -> encodeOCCmp c i j "CmpLevels"+ CmpTeles c i j -> encodeOCCmp c i j "CmpTeles"+ CmpSorts c i j -> encodeOCCmp c i j "CmpSorts"+ Assign i a -> kind "Assign"+ [ "constraintObj" #= encodeTCM i+ , "value" #= encodeTCM a+ ]+ TypedAssign i v t -> kind "TypedAssign"+ [ "constraintObj" #= encodeTCM i+ , "value" #= encodeTCM v+ , "type" #= encodeTCM t+ ]+ PostponedCheckArgs i es t0 t1 -> kind "PostponedCheckArgs"+ [ "constraintObj" #= encodeTCM i+ , "ofType" #= encodeTCM t0+ , "arguments" #= forM es encodeTCM+ , "type" #= encodeTCM t1+ ]+ IsEmptyType a -> kind "IsEmptyType"+ [ "type" #= encodeTCM a+ ]+ SizeLtSat a -> kind "SizeLtSat"+ [ "type" #= encodeTCM a+ ]+ FindInstanceOF i t cs -> kind "FindInstanceOF"+ [ "constraintObj" #= encodeTCM i+ , "candidates" #= forM cs encodeKVPairs+ , "type" #= encodeTCM t+ ]+ where encodeKVPairs (_, v, t) = obj -- TODO: encode kind+ [ "value" #= encodeTCM v+ , "type" #= encodeTCM t+ ]+ ResolveInstanceOF q -> kind "ResolveInstanceOF"+ [ "name" @= encodePretty q+ ]+ PTSInstance a b -> kind "PTSInstance"+ [ "constraintObjs" #= traverse encodeTCM [a, b]+ ]+ PostponedCheckFunDef name a err -> kind "PostponedCheckFunDef"+ [ "name" @= encodePretty name+ , "type" #= encodeTCM a+ , "error" #= encodeTCM err+ ]+ DataSort q s -> kind "DataSort"+ [ "name" @= encodePretty q+ , "sort" #= encodeTCM s+ ]+ CheckLock t lk -> kind "CheckLock"+ [ "head" #= encodeTCM t+ , "lock" #= encodeTCM lk+ ]+ UsableAtMod mod t -> kind "UsableAtMod"+ [ "mod" @= encodePretty mod+ , "term" #= encodeTCM t+ ]++encodeNamedPretty :: PrettyTCM a => (Name, a) -> TCM Value+encodeNamedPretty (name, a) = obj+ [ "name" @= encodePretty name+ , "term" #= encodePrettyTCM a+ ]++instance EncodeTCM (OutputForm C.Expr C.Expr) where+ encodeTCM (OutputForm range problems unblock oc) = obj+ [ "range" @= range+ , "problems" @= problems+ , "unblocker" @= unblock+ , "constraint" #= encodeTCM oc+ ]++instance EncodeTCM Blocker where+ encodeTCM (UnblockOnMeta x) = kind "UnblockOnMeta" [ "meta" @= x ]+ encodeTCM (UnblockOnProblem p) = kind "UnblockOnProblem" [ "id" @= p ]+ encodeTCM (UnblockOnDef q) = kind "UnblockOnDef" [ "name" @= encodePretty q ]+ encodeTCM (UnblockOnAll us) = kind "UnblockOnAll" [ "blockers" @= Set.toList us ]+ encodeTCM (UnblockOnAny us) = kind "UnblockOnAny" [ "blockers" @= Set.toList us ]++instance EncodeTCM DisplayInfo where+ encodeTCM :: DisplayInfo -> TCM Value+ encodeTCM (Info_CompilationOk backend wes) = do+ ws <- filterTCWarnings (tcWarnings wes)+ es <- filterTCWarnings (nonFatalErrors wes)+ kind "CompilationOk"+ [ "backend" @= encodePretty backend+ , "warnings" #= encodeTCM ws+ , "errors" #= encodeTCM es+ ]+ encodeTCM (Info_Constraints constraints) = kind "Constraints"+ [ "constraints" #= forM constraints encodeTCM+ ]+ encodeTCM (Info_AllGoalsWarnings (vis, invis) wes) = do+ ws <- filterTCWarnings (tcWarnings wes)+ es <- filterTCWarnings (nonFatalErrors wes)+ kind "AllGoalsWarnings"+ [ "visibleGoals" #= forM vis (\i -> withInteractionId (B.outputFormId $ OutputForm noRange [] alwaysUnblock i) $ encodeTCM i)+ , "invisibleGoals" #= forM invis encodeTCM+ , "warnings" #= encodeTCM ws+ , "errors" #= encodeTCM es+ ]+ encodeTCM (Info_Time time) = kind "Time"+ [ "time" @= time+ ]+ encodeTCM (Info_Error err) = encodeTCM err+ encodeTCM Info_Intro_NotFound = kind "IntroNotFound" []+ encodeTCM (Info_Intro_ConstructorUnknown introductions) = kind "IntroConstructorUnknown"+ [ "constructors" @= map toJSON introductions+ ]+ encodeTCM (Info_Auto info) = kind "Auto"+ [ "info" @= toJSON info+ ]+ encodeTCM (Info_ModuleContents names tele contents) = kind "ModuleContents"+ [ "contents" #= forM contents encodeNamedPretty+ , "telescope" #= forM (telToList tele) encodeDomType+ , "names" @= map encodePretty names+ ]+ where+ encodeDomType :: PrettyTCM a => Dom (ArgName, a) -> TCM Value+ encodeDomType dom = obj+ [ "dom" #= encodePrettyTCM (unDom dom)+ , "name" @= fmap encodePretty (bareNameOf dom)+ , "finite" @= toJSON (domIsFinite dom)+ , "cohesion" @= encodeShow (modCohesion . argInfoModality $ domInfo dom)+ , "relevance" @= encodeShow (modRelevance . argInfoModality $ domInfo dom)+ , "hiding" @= case argInfoHiding $ domInfo dom of+ Instance o -> show o+ o -> show o+ ]+ encodeTCM (Info_SearchAbout results search) = kind "SearchAbout"+ [ "results" #= forM results encodeNamedPretty+ , "search" @= toJSON search+ ]+ encodeTCM (Info_WhyInScope why@(WhyInScopeData y path _ _ _)) = kind "WhyInScope"+ [ "thing" @= prettyShow y+ , "filepath" @= toJSON path+ -- use Emacs message first+ , "message" #= explainWhyInScope why+ ]+ encodeTCM (Info_NormalForm commandState computeMode time expr) = kind "NormalForm"+ [ "commandState" @= commandState+ , "computeMode" @= computeMode+ , "time" @= time+ , "expr" #= (encodeShow <$> prettyNormalForm commandState computeMode expr)+ ]+ encodeTCM (Info_InferredType commandState time expr) = kind "InferredType"+ [ "commandState" @= commandState+ , "time" @= time+ , "expr" #= (encodeShow <$> prettyInferredType commandState expr)+ ]+ encodeTCM (Info_Context ii ctx) = kind "Context"+ [ "interactionPoint" @= ii+ , "context" @= ctx+ ]+ encodeTCM Info_Version = kind "Version"+ [ "version" @= (versionWithCommitInfo :: String)+ ]+ encodeTCM (Info_GoalSpecific ii info) = kind "GoalSpecific"+ [ "interactionPoint" @= ii+ , "goalInfo" #= withInteractionId ii (encodeGoalSpecific ii info)+ ]++instance EncodeTCM GoalTypeAux where+ encodeTCM GoalOnly = kind "GoalOnly" []+ encodeTCM (GoalAndHave expr boundary) = kind "GoalAndHave"+ [ "expr" #= encodePrettyTCM expr+ , "boundary" @= map encodePretty boundary+ ]+ encodeTCM (GoalAndElaboration expr) = kind "GoalAndElaboration"+ [ "term" #= encodePrettyTCM expr ]++encodeGoalSpecific :: InteractionId -> GoalDisplayInfo -> TCM Value+encodeGoalSpecific ii = go+ where+ go (Goal_HelperFunction helperType) = kind "HelperFunction"+ [ "signature" #= inTopContext (prettyATop helperType)+ ]+ go (Goal_NormalForm computeMode expr) = kind "NormalForm"+ [ "computeMode" @= computeMode+ , "expr" #= B.showComputed computeMode expr+ ]+ go (Goal_GoalType rewrite goalType entries boundary outputForms) = kind "GoalType"+ [ "rewrite" @= rewrite+ , "typeAux" @= goalType+ , "type" #= prettyTypeOfMeta rewrite ii+ , "entries" @= entries+ , "boundary" @= map encodePretty boundary+ , "outputForms" @= map encodePretty outputForms+ ]+ go (Goal_CurrentGoal rewrite) = kind "CurrentGoal"+ [ "rewrite" @= rewrite+ , "type" #= prettyTypeOfMeta rewrite ii+ ]+ go (Goal_InferredType expr) = kind "InferredType"+ [ "expr" #= prettyATop expr+ ]++instance EncodeTCM Info_Error where+ encodeTCM :: Info_Error -> TCM Value+ encodeTCM (Info_GenericError err) = do+ ws <- filterTCWarnings =<< getAllWarningsOfTCErr err+ kind "Error"+ [ "warnings" #= encodeTCM ws+ , "error" #= encodeTCM err+ ]+ encodeTCM err = kind "Error"+ [ "warnings" @= ([] :: [String])+ , "error" #= obj+ [ "message" #= showInfoError err+ ]+ ]++instance EncodeTCM TCErr where+ encodeTCM err = obj+ [ "message" #= encodePrettyTCM err+ ]++instance EncodeTCM TCWarning where+ encodeTCM w = obj+ [ "message" #= (P.render <$> prettyTCM w)+ ]++instance EncodeTCM Response where+ encodeTCM (Resp_HighlightingInfo info remove method modFile file) =+ liftIO $ jsonifyHighlightingInfo info remove method modFile file+ encodeTCM (Resp_DisplayInfo info) = kind "DisplayInfo"+ [ "info" @= info+ ]+ encodeTCM (Resp_ClearHighlighting tokenBased) = kind "ClearHighlighting"+ [ "tokenBased" @= tokenBased+ ]+ encodeTCM Resp_DoneAborting = kind "DoneAborting" []+ encodeTCM Resp_DoneExiting = kind "DoneExiting" []+ encodeTCM Resp_ClearRunningInfo = kind "ClearRunningInfo" []+ encodeTCM (Resp_RunningInfo debugLevel msg) = kind "RunningInfo"+ [ "debugLevel" @= debugLevel+ , "message" @= msg+ ]+ encodeTCM (Resp_Status status) = kind "Status"+ [ "status" @= status+ ]+ encodeTCM (Resp_JumpToError filepath position) = kind "JumpToError"+ [ "filepath" @= filepath+ , "position" @= position+ ]+ encodeTCM (Resp_InteractionPoints interactionPoints) = kind "InteractionPoints"+ [ "interactionPoints" @= interactionPoints+ ]+ encodeTCM (Resp_GiveAction i giveResult) = kind "GiveAction"+ [ "interactionPoint" @= i+ , "giveResult" @= giveResult+ ]+ encodeTCM (Resp_MakeCase id variant clauses) = kind "MakeCase"+ [ "interactionPoint" @= id+ , "variant" @= variant+ , "clauses" @= clauses+ ]+ encodeTCM (Resp_SolveAll solutions) = kind "SolveAll"+ [ "solutions" @= map encodeSolution solutions+ ]+ where+ encodeSolution (i, expr) = object+ [ "interactionPoint" .= i+ , "expression" .= P.prettyShow expr+ ]+ encodeTCM (Resp_Mimer ii str) = kind "Mimer"+ [ "interactionPoint" @= ii+ , "solution" @= str+ ]++-- | Convert Response to an JSON value for interactive editor frontends.+jsonifyResponse :: Response -> TCM ByteString+jsonifyResponse = pure . encode <=< encodeTCM
@@ -0,0 +1,733 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE OverloadedLists #-}+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Library management.+--+-- Sample use:+--+-- @+-- -- Get libraries as listed in @.agda/libraries@ file.+-- libs <- getInstalledLibraries Nothing+--+-- -- Get the libraries (and immediate paths) relevant for @projectRoot@.+-- -- This involves locating and processing the @.agda-lib@ file for the project.+-- (project, libNames, includePaths) <- getDefaultLibraries projectRoot True+--+-- -- Get include paths of depended-on libraries.+-- resolvedPaths <- libraryIncludePaths Nothing project libs libNames+--+-- let allPaths = includePaths ++ resolvedPaths+-- @+--+module Agda.Interaction.Library+ ( findProjectRoot+ , getDefaultLibraries+ , getInstalledLibraries+ , getTrustedExecutables+ , libraryIncludePaths+ , getAgdaLibFile+ , getPrimitiveLibDir+ , classifyBuiltinModule_+ , builtinModules+ , builtinModulesWithSafePostulates+ , builtinModulesWithUnsafePostulates+ , primitiveModules+ , LibName, parseLibName+ , OptionsPragma(..)+ , AgdaLibFile(..)+ , ExeName+ , LibM+ , mkLibM+ , LibWarning(..)+ , LibPositionInfo(..)+ , libraryWarningName+ , ProjectConfig(..)+ -- * Exported for testing+ , findLib'+ ) where++import qualified Control.Exception as E+import Control.Monad.Except ( runExceptT, MonadError, throwError )+import Control.Monad.Writer ( Writer, runWriterT, tell )+import Control.Monad.IO.Class ( MonadIO(..) )++import Data.Bifunctor ( first, second )+import Data.Either+import Data.Function (on)+import qualified Data.List as List+import Data.Map ( Map )+import qualified Data.Map as Map+import Data.Set ( Set )+import qualified Data.Set as Set+import qualified Data.Text as T+import Data.Tree ( Tree(Node) )++import System.Directory+import System.FilePath+import System.IO.Error ( isPermissionError )++import Agda.Interaction.Library.Base+import Agda.Interaction.Library.Parse++import Agda.Syntax.Common.Pretty ( prettyShow )++import Agda.TypeChecking.Monad.Base.Types ( IsBuiltinModule(..) )++import Agda.Utils.Environment+import Agda.Utils.FileName+import Agda.Utils.IO ( catchIO )+import qualified Agda.Utils.IO.UTF8 as UTF8+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|) )+import Agda.Utils.List2 ( pattern List2 )+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Singleton+import Agda.Utils.Tuple ( secondM )++import Agda.Setup ( getDataFileName, getAgdaAppDir )+import Agda.Version++------------------------------------------------------------------------+-- * Types and Monads+------------------------------------------------------------------------++-- | Raise collected 'LibErrors' as exception.+--+mkLibM :: [AgdaLibFile] -> LibErrorIO a -> LibM a+mkLibM libs m = do+ (x, ews) <- lift $ lift $ runWriterT m+ let (errs, warns) = partitionEithers ews+ tell warns+ () <- List1.unlessNull errs \ errs -> throwError $ LibErrors libs errs+ return x++------------------------------------------------------------------------+-- * Resources+------------------------------------------------------------------------++-- | Returns the absolute default lib dir. This directory is used to+-- store the Primitive.agda file.+getPrimitiveLibDir :: IO AbsolutePath+getPrimitiveLibDir = do+ libdir <- filePath <$> (absolute =<< getDataFileName "lib")+ ifM (doesDirectoryExist libdir)+ (return $ AbsolutePath $ T.pack $ libdir </> "prim")+ (error $ "The lib directory " ++ libdir ++ " does not exist")++-- | The @$AGDA_DIR/libraries@ file lists the libraries Agda should know about.+-- The content of @libraries@ is a list of paths to @.agda-lib@ files.+--+-- Agda honors also version-specific @libraries@ files, e.g. @libraries-2.6.0@.+--+-- @defaultLibraryFiles@ gives a list of all @libraries@ files Agda should process+-- by default. The first file in this list that exists is actually used.+--+defaultLibraryFiles :: List1 FilePath+defaultLibraryFiles = ("libraries-" ++ version) :| "libraries" : []++-- | The @$AGDA_DIR/defaults@ file lists the library names relevant for all+-- Agda projects.+--+-- Agda also honors version-specific @defaults@ files, e.g. @defaults-2.6.0@.+--+-- @defaultsFiles@ gives a list of all @defaults@ Agda should process+-- by default. The first file in this list that exists is actually used.+--+defaultsFiles :: List1 FilePath+defaultsFiles = ("defaults-" ++ version) :| "defaults" : []++-- | The @$AGDA_DIR/executables@ file lists the executables Agda should know about.+-- The content of @executables@ is a list of paths to executables.+--+-- Agda honors also version-specific @executables@ files, e.g. @executables-2.6.0@.+--+-- @defaultExecutablesFiles@ gives a list of all @executables@ Agda should process+-- by default. The first file in this list that exists is actually used.+--+defaultExecutableFiles :: List1 FilePath+defaultExecutableFiles = ("executables-" ++ version) :| "executables" : []++------------------------------------------------------------------------+-- * Agda builtin modules+------------------------------------------------------------------------++-- | Prefix path with @Agda.Builtin@.++agdaBuiltin :: FilePath -> FilePath+agdaBuiltin = ("Agda" </>) . ("Builtin" </>)++-- | The very magical, auto-imported modules.++agdaPrimitive :: FilePath+agdaPrimitive = "Agda" </> "Primitive.agda"++agdaPrimitiveCubical :: FilePath+agdaPrimitiveCubical = "Agda" </> "Primitive" </> "Cubical.agda"++primitiveModules :: Set FilePath+primitiveModules = Set.fromList [agdaPrimitive, agdaPrimitiveCubical]++-- | These builtins may use postulates, and are still considered @--safe@.++builtinModulesWithSafePostulates :: Set FilePath+builtinModulesWithSafePostulates =+ (primitiveModules `Set.union`) $ Set.fromList $+ map agdaBuiltin $+ [ "Bool.agda"+ , "Char.agda"+ , "Char" </> "Properties.agda"+ , "Coinduction.agda"+ , "Cubical" </> "Equiv.agda"+ , "Cubical" </> "Glue.agda"+ , "Cubical" </> "HCompU.agda"+ , "Cubical" </> "Id.agda"+ , "Cubical" </> "Path.agda"+ , "Cubical" </> "Sub.agda"+ , "Equality" </> "Erase.agda"+ , "Equality.agda"+ , "Erased" </> "Box-cong.agda"+ , "Erased" </> "Erased.agda"+ , "Erased" </> "Funext.agda"+ , "Erased" </> "Propext.agda"+ , "Erased" </> "Quotient.agda"+ , "Float.agda"+ , "Float" </> "Properties.agda"+ , "FromNat.agda"+ , "FromNeg.agda"+ , "FromString.agda"+ , "Int.agda"+ , "IO.agda"+ , "List.agda"+ , "Maybe.agda"+ , "Nat.agda"+ , "Reflection.agda"+ , "Reflection" </> "Properties.agda"+ , "Reflection" </> "External.agda"+ , "Sigma.agda"+ , "Size.agda"+ , "Strict.agda"+ , "String.agda"+ , "String" </> "Properties.agda"+ , "Unit.agda"+ , "Word.agda"+ , "Word" </> "Properties.agda"+ ]++-- | These builtins may not use postulates under @--safe@. They are not+-- automatically unsafe, but will be if they use an unsafe feature.++builtinModulesWithUnsafePostulates :: Set FilePath+builtinModulesWithUnsafePostulates = Set.fromList $+ map agdaBuiltin $+ [ "TrustMe.agda"+ , "Equality" </> "Rewrite.agda"+ ]++-- | All builtin modules.++builtinModules :: Set FilePath+builtinModules = builtinModulesWithSafePostulates `Set.union`+ builtinModulesWithUnsafePostulates++-- | Determine whether the second absolute path refers to one of Agda's primitive modules.+-- The first argument should be the result of 'getPrimitiveLibDir'.+--+classifyBuiltinModule_ :: AbsolutePath -> AbsolutePath -> Maybe IsBuiltinModule+classifyBuiltinModule_ primLibDir fp = do+ f <- relativizeAbsolutePath fp primLibDir+ guard $ f `Set.member` builtinModules+ if f `Set.member` builtinModulesWithUnsafePostulates then return IsBuiltinModule+ else if f == agdaPrimitive then pure IsAgdaPrimitive+ else if f == agdaPrimitiveCubical then pure IsAgdaPrimitiveCubical+ else pure IsBuiltinModuleWithSafePostulates++------------------------------------------------------------------------+-- * Get the libraries for the current project+------------------------------------------------------------------------++-- | Find project root by looking for @.agda-lib@ files.+--+-- If there are none, look in the parent directories until one is found.++findProjectConfig ::+ FilePath+ -- ^ Candidate (initially: the directory Agda was called in).+ -> LibM ProjectConfig+ -- ^ Actual root and @.agda-lib@ file for this project.+findProjectConfig root = do+ getCachedProjectConfig root >>= \case+ Just conf -> return conf+ Nothing -> handlePermissionException do+ libFiles <- liftIO $ getDirectoryContents root >>=+ filterM (\file -> and2M+ (pure $ takeExtension file == ".agda-lib")+ (doesFileExist (root </> file)))+#if defined(wasm32_HOST_ARCH)+ -- During tests, wasmtime sometimes reports duplicate entries in a directory.+ -- This extra step workarounds the quirky behavior; see comments in PR #8205.+ let libFiles' = case libFiles of+ [] -> []+ [file] -> [file]+ (f:files)+ | all (== f) files -> [f] -- All entries are duplicates of the same file+ | otherwise -> libFiles+#else+ let libFiles' = libFiles+#endif+ case libFiles' of+ [] -> liftIO (upPath root) >>= \case+ Just up -> do+ conf <- over lensConfigAbove (+ 1) <$> findProjectConfig up+ storeCachedProjectConfig root conf+ return conf+ Nothing -> return DefaultProjectConfig+ [file] -> do+ let conf = ProjectConfig root file 0+ storeCachedProjectConfig root conf+ return conf+ f1:f2:files -> throwError $ LibErrors [] $ singleton $ LibError Nothing $+ SeveralAgdaLibFiles root $ List2 f1 f2 files++ where+ -- Andreas, 2024-06-26, issue #7331:+ -- In case of missing permission we terminate our search for the project file+ -- with the default value.+ handlePermissionException :: LibM ProjectConfig -> LibM ProjectConfig+ handlePermissionException = flip catchIO \ e ->+ if isPermissionError e then return DefaultProjectConfig else liftIO $ E.throwIO e++ -- Note that "going up" one directory is OS dependent+ -- if the directory is a symlink.+ --+ -- Quoting from https://hackage.haskell.org/package/directory-1.3.6.1/docs/System-Directory.html#v:canonicalizePath :+ --+ -- Note that on Windows parent directories .. are always fully+ -- expanded before the symbolic links, as consistent with the+ -- rest of the Windows API (such as GetFullPathName). In+ -- contrast, on POSIX systems parent directories .. are+ -- expanded alongside symbolic links from left to right. To+ -- put this more concretely: if L is a symbolic link for R/P,+ -- then on Windows L\.. refers to ., whereas on other+ -- operating systems L/.. refers to R.+ upPath :: FilePath -> IO (Maybe FilePath)+ upPath root = do+ up <- canonicalizePath $ root </> ".."+ if up == root then return Nothing else return $ Just up+++-- | Get project root++findProjectRoot :: FilePath -> LibM (Maybe FilePath)+findProjectRoot root = findProjectConfig root <&> \case+ ProjectConfig p _ _ -> Just p+ DefaultProjectConfig -> Nothing+++-- | Get the content of the @.agda-lib@ file in the given project root.+getAgdaLibFile :: FilePath -> LibM [AgdaLibFile]+getAgdaLibFile path = findProjectConfig path >>= \case+ DefaultProjectConfig -> return []+ ProjectConfig root file above -> mkLibM [] $+ map (set libAbove above) <$>+ parseLibFiles Nothing [(0, root </> file)]++-- | Get dependencies and include paths for given project root:+--+-- Look for @.agda-lib@ files according to 'findAgdaLibFiles'.+-- If none are found, use default dependencies (according to @defaults@ file)+-- and current directory (project root).+--+-- Also returns the @.agda-lib@ file of the project, if any.+--+getDefaultLibraries+ :: FilePath -- ^ Project root.+ -> Bool -- ^ Use @defaults@ if no @.agda-lib@ file exists for this project?+ -> LibM (Maybe AgdaLibFile, [LibName], [FilePath])+ -- ^ The returned @LibName@s are all non-empty strings.+getDefaultLibraries root optDefaultLibs = do+ libs <- getAgdaLibFile root+ if null libs+ then (Nothing,,[]) <$> if optDefaultLibs then mkLibM [] $ (libNameForCurrentDir :) <$> readDefaultsFile else return []+ else return $ libsAndPaths libs+ where+ libsAndPaths ls = ( listToMaybe ls+ , concatMap _libDepends ls+ , nubOn id (concatMap _libIncludes ls)+ )++-- | Return list of libraries to be used by default.+--+-- None if the @defaults@ file does not exist.+--+readDefaultsFile :: LibErrorIO [LibName]+readDefaultsFile = do+ agdaDir <- liftIO getAgdaAppDir+ let defaults = List1.map (agdaDir </>) defaultsFiles -- NB: very short list+ files <- liftIO $ filterM doesFileExist (List1.toList defaults)+ case files of+ [] -> return []+ file : _ -> do+ ls <- liftIO $ map snd . stripCommentLines <$> UTF8.readFile file+ return $ map parseLibName $ concatMap splitCommas ls+ `catchIO` \ e -> do+ raiseErrors' [ ReadError e "Failed to read defaults file." ]+ return []++------------------------------------------------------------------------+-- * Reading the installed libraries+------------------------------------------------------------------------++-- | Returns the path of the @libraries@ file which lists the libraries Agda knows about.+--+-- Note: file may not exist.+--+-- If the user specified an alternative @libraries@ file which does not exist,+-- an exception is thrown containing the name of this file.+getLibrariesFile+ :: (MonadIO m, MonadError FilePath m)+ => Maybe FilePath -- ^ Override the default @libraries@ file?+ -> m LibrariesFile+getLibrariesFile (Just overrideLibFile) = do+ -- A user-specified override file must exist.+ ifM (liftIO $ doesFileExist overrideLibFile)+ {-then-} (return $ LibrariesFile overrideLibFile True)+ {-else-} (throwError overrideLibFile)+getLibrariesFile Nothing = do+ agdaDir <- liftIO $ getAgdaAppDir+ let defaults = List1.map (agdaDir </>) defaultLibraryFiles -- NB: very short list+ files <- liftIO $ filterM doesFileExist (List1.toList defaults)+ case files of+ file : _ -> return $ LibrariesFile file True+ [] -> return $ LibrariesFile (List1.last defaults) False -- doesn't exist, but that's ok++-- | Parse the descriptions of the libraries Agda knows about.+--+-- Returns none if there is no @libraries@ file.+--+getInstalledLibraries+ :: Maybe FilePath -- ^ Override the default @libraries@ file?+ -> LibM [AgdaLibFile] -- ^ Content of library files. (Might have empty @LibName@s.)+getInstalledLibraries overrideLibFile = mkLibM [] $ do+ filem <- liftIO $ runExceptT $ getLibrariesFile overrideLibFile+ case filem of+ Left theOverrideLibFile -> do+ raiseErrors' [ LibrariesFileNotFound theOverrideLibFile ]+ return []+ Right file -> do+ if not (lfExists file) then return [] else do+ ls <- liftIO $ stripCommentLines <$> UTF8.readFile (lfPath file)+ files <- liftIO $ sequence [ (i, ) <$> expandEnvironmentVariables s | (i, s) <- ls ]+ parseLibFiles (Just file) $ nubOn snd files+ `catchIO` \ e -> do+ raiseErrors' [ ReadError e "Failed to read installed libraries." ]+ return []++-- | Parse the given library files.+--+parseLibFiles+ :: Maybe LibrariesFile -- ^ Name of @libraries@ file for error reporting.+ -> [(LineNumber, FilePath)] -- ^ Library files paired with their line number in @libraries@.+ -> LibErrorIO [AgdaLibFile] -- ^ Content of library files. (Might have empty @LibName@s.)+parseLibFiles mlibFile files = do++ anns <- forM files $ \(ln, file) -> do+ getCachedAgdaLibFile file >>= \case+ Just lib -> return (Right lib, [])+ Nothing -> do+ (e, ws) <- liftIO $ runP <$> parseLibFile file+ let pos = LibPositionInfo (lfPath <$> mlibFile) ln file+ ws' = map (LibWarning (Just pos)) ws+ case e of+ Left err -> do+ return (Left (Just pos, err), ws')+ Right lib -> do+ storeCachedAgdaLibFile file lib+ return (Right lib, ws')++ let (xs, warns) = unzip anns+ (errs, als) = partitionEithers xs++ List1.unlessNull (concat warns) warnings+ List1.unlessNull errs $ \ errs1 ->+ raiseErrors $ fmap (\ (mc, err) -> LibError mc $ LibParseError err) errs1++ return $ nubOn _libFile als++-- | Remove trailing white space and line comments.+--+stripCommentLines :: String -> [(LineNumber, String)]+stripCommentLines = concatMap strip . zip [1..] . lines+ where+ strip (i, s) = [ (i, s') | not $ null s' ]+ where s' = trimLineComment s++-- | Returns the path of the @executables@ file which lists the trusted executables Agda knows about.+--+-- Note: file may not exist.+--+getExecutablesFile+ :: IO ExecutablesFile+getExecutablesFile = do+ agdaDir <- getAgdaAppDir+ let defaults = List1.map (agdaDir </>) defaultExecutableFiles -- NB: very short list+ findM doesFileExist defaults >>= \case+ Just file -> return $ ExecutablesFile file True+ Nothing -> return $ ExecutablesFile (List1.last defaults) False -- doesn't exist, but that's ok++-- | Return the trusted executables Agda knows about.+--+-- Returns none if there is no @executables@ file.+--+getTrustedExecutables+ :: LibM (Map ExeName FilePath) -- ^ Content of @executables@ files.+getTrustedExecutables = mkLibM [] $ do+ file <- liftIO getExecutablesFile+ if not (efExists file) then return Map.empty else do+ es <- liftIO $ stripCommentLines <$> UTF8.readFile (efPath file)+ lines <- liftIO $ mapM (secondM expandEnvironmentVariables) es+ parseExecutablesFile file lines+ `catchIO` \ e -> do+ raiseErrors' [ ReadError e "Failed to read trusted executables." ]+ return Map.empty++-- | Parse the @executables@ file.+--+parseExecutablesFile+ :: ExecutablesFile+ -> [(LineNumber, FilePath)]+ -> LibErrorIO (Map ExeName FilePath)+parseExecutablesFile ef files = do+ executables <- forM files $ \(ln, fp) -> do+ -- Compute canonical executable name and absolute filepath.+ let strExeName = takeFileName fp+ let strExeName' = fromMaybe strExeName $ stripExtension exeExtension strExeName+ let txtExeName = T.pack strExeName'+ exePath <- liftIO $ makeAbsolute fp+ return (txtExeName, (ln, exePath))++ -- Create a map from executable names to their location(s).+ let exeMap1 :: Map ExeName (List1 (LineNumber, FilePath))+ exeMap1 = Map.fromListWith (<>) $ map (second singleton) $ reverse executables++ -- Separate non-ambiguous from ambiguous mappings.+ let (exeMap, duplicates) = Map.mapEither List2.fromList1Either exeMap1++ -- Report ambiguous mappings with line numbers.+ List1.unlessNull (Map.toList duplicates) $ \ duplicates1 ->+ raiseErrors' $ fmap (uncurry $ DuplicateExecutable $ efPath ef) duplicates1++ -- Return non-ambiguous mappings without line numbers.+ return $ fmap snd exeMap++------------------------------------------------------------------------+-- * Resolving library names to include pathes+------------------------------------------------------------------------++-- | Get all include pathes for a list of libraries to use.+--+-- Warns if a library is depended on in different versions+-- (see 'libraryVersionConflicts').+libraryIncludePaths+ :: Maybe FilePath -- ^ @libraries@ file (error reporting only).+ -> Maybe AgdaLibFile -- ^ The project the libraries are used by, if any (warnings only).+ -> [AgdaLibFile] -- ^ Libraries Agda knows about.+ -> [LibName] -- ^ (Non-empty) library names to be resolved to (lists of) pathes.+ -> LibM [FilePath] -- ^ Resolved pathes (no duplicates). Contains "." if @[LibName]@ does.+libraryIncludePaths overrideLibFile root libs xs0 = mkLibM libs $ do+ efile <- liftIO $ runExceptT $ getLibrariesFile overrideLibFile+ case efile of+ Left theOverrideLibFile -> do+ raiseErrors' [ LibrariesFileNotFound theOverrideLibFile ]+ return []+ Right file -> do+ (ls, resolved) <- embedWriter $ find file Map.empty xs+ ws <- liftIO $ libraryVersionConflicts root xs $ Map.mapMaybe id resolved+ List1.unlessNull ws warnings'+ return $ dot ++ incs ls+ where+ (dots, xs) = List.partition (== libNameForCurrentDir) xs0+ incs = nubOn id . concatMap _libIncludes+ dot = [ "." | not $ null dots ]++ -- Due to library dependencies, the work list may grow temporarily.+ find+ :: LibrariesFile -- Only for error reporting.+ -> Map LibName (Maybe AgdaLibFile)+ -- Already processed libraries and what they resolved to.+ -> [LibName] -- Work list: libraries left to be resolved.+ -> Writer LibErrWarns ([AgdaLibFile], Map LibName (Maybe AgdaLibFile))+ find _ visited [] = pure ([], visited)+ find file visited (x : xs)+ | x `Map.member` visited = find file visited xs+ | otherwise = do+ -- May or may not find the library+ ml <- case findLib x libs of+ [l] -> pure (Just l)+ [] -> Nothing <$ raiseErrors' [LibNotFound file x]+ l1 : l2 : ls -> Nothing <$ raiseErrors' [AmbiguousLib x $ List2 l1 l2 ls]+ -- If it is found, add its dependencies to work list+ let xs' = foldMap _libDepends ml ++ xs+ first (mcons ml) <$> find file (Map.insert x ml visited) xs'++-- | Detect libraries that are depended on in different versions (issue #8875).+--+-- For each such library, we return a 'LibraryVersionConflict' warning+-- containing the dependency tree pruned to the paths leading to the conflicting versions.+--+libraryVersionConflicts+ :: Maybe AgdaLibFile -- ^ The project, if any.+ -> [LibName] -- ^ The libraries the project depends on.+ -> Map LibName AgdaLibFile -- ^ What the (transitively) depended-on libraries resolved to.+ -> IO [LibWarning']+libraryVersionConflicts root roots resolved = do+ -- We identify libraries by the canonical path of their @.agda-lib@ file.+ -- Also, the canonical paths are absolute, so the Emacs mode can make them clickable.+ let canon l = do+ f <- canonicalizePath (_libFile l) `catchIO` \ (_ :: E.IOException) -> pure (_libFile l)+ pure l{ _libFile = f }+ root <- traverse canon root+ resolved <- traverse canon resolved+ pure $ libraryVersionConflicts' root roots resolved++-- | Pure part of 'libraryVersionConflicts'.+libraryVersionConflicts'+ :: Maybe AgdaLibFile -- ^ The project, if any.+ -> [LibName] -- ^ The libraries the project depends on.+ -> Map LibName AgdaLibFile -- ^ What the (transitively) depended-on libraries resolved to.+ -> [LibWarning']+libraryVersionConflicts' root roots resolved =+ [ conflict b fs | (b, fs) <- Map.toList groups, Set.size fs >= 2 ]+ where+ -- The distinct library files, grouped by the base name of their library.+ groups :: Map T.Text (Set FilePath)+ groups = Map.fromListWith Set.union+ [ (b, Set.singleton $ _libFile l)+ | l <- maybeToList root ++ Map.elems resolved+ , let b = libNameBase $ _libName l+ , not $ T.null b+ ]++ -- The dependencies of a library.+ deps :: LibName -> [LibName]+ deps x = nubOn id $ foldMap _libDepends $ Map.lookup x resolved++ label :: LibName -> T.Text+ label = T.pack . prettyShow++ rootLabel :: T.Text+ rootLabel = case root of+ Just l | not $ T.null $ libNameBase $ _libName l -> label $ _libName l+ _ -> libDepRootLabel++ -- The name a library resolved to, if different from the requested name.+ resolvedAs :: LibName -> Maybe T.Text+ resolvedAs x = case _libName <$> Map.lookup x resolved of+ Just y | y /= x -> Just $ label y+ _ -> Nothing++ conflict :: T.Text -> Set FilePath -> LibWarning'+ conflict b fs = LibraryVersionConflict b tree files+ where+ -- The libraries resolving to a conflicting version or depending on such.+ relevant :: Set LibName+ relevant = saturate $ Map.keysSet $ Map.filter ((`Set.member` fs) . _libFile) resolved++ saturate :: Set LibName -> Set LibName+ saturate s+ | Set.size s' == Set.size s = s+ | otherwise = saturate s'+ where+ s' = Set.union s $ Map.keysSet $+ Map.filterWithKey (\ x _ -> any (`Set.member` s) $ deps x) resolved++ relevantOnly :: [LibName] -> [LibName]+ relevantOnly = filter (`Set.member` relevant)++ -- A library resolving to one of the conflicting versions.+ conflicting :: LibName -> Bool+ conflicting x = maybe False ((`Set.member` fs) . _libFile) $ Map.lookup x resolved++ tree :: LibDepTree+ tree = Node (LibDepNode rootLabel Nothing) $ snd $+ expand Set.empty $ relevantOnly $ nubOn id roots++ -- Expand the given siblings from left to right.+ expand :: Set LibName -> [LibName] -> (Set LibName, [LibDepTree])+ expand seen = second catMaybes . List.mapAccumL visit seen++ -- A library that has been visited before is omitted.+ -- So is a library which does not lead to a conflicting version not shown before.+ visit :: Set LibName -> LibName -> (Set LibName, Maybe LibDepTree)+ visit seen x+ | x `Set.member` seen = (seen, Nothing)+ | otherwise = second prune $ expand (Set.insert x seen) $ relevantOnly $ deps x+ where+ prune ts+ | null ts && not (conflicting x) = Nothing+ | otherwise = Just $ Node (LibDepNode (label x) (resolvedAs x)) ts++ -- The files of the libraries mentioned in the tree, in order of first occurrence,+ -- with the position of the first dependency shown in the tree.+ files :: [(T.Text, FilePath, Maybe LibFilePos)]+ files = nubOn (\ (l, f, _) -> (l, f)) $+ [ (rootLabel, _libFile l, firstDepPos l ts) | l <- maybeToList root ] +++ concatMap entries ts+ where Node _ ts = tree++ entries :: LibDepTree -> [(T.Text, FilePath, Maybe LibFilePos)]+ entries (Node n ts) =+ [ (depLabel n, _libFile l, firstDepPos l ts) | l <- maybeToList $ Map.lookup (depLabel n) libOf ] +++ concatMap entries ts++ -- Where the first of the given dependencies is mentioned in the given library file.+ firstDepPos :: AgdaLibFile -> [LibDepTree] -> Maybe LibFilePos+ firstDepPos l = \case+ Node n _ : _ -> Map.lookup (depLabel n) $ Map.mapKeys label $ _libDependsPos l+ [] -> Nothing++ libOf :: Map T.Text AgdaLibFile+ libOf = Map.fromList [ (label x, l) | (x, l) <- Map.toList resolved ]++-- | @findLib x libs@ retrieves the matches for @x@ from list @libs@.+--+-- 1. Case @x@ is unversioned:+-- If @x@ is contained in @libs@, then that match is returned.+-- Otherwise, the matches with the highest version number are returned.+--+-- 2. Case @x@ is versioned: the matches with the highest version number are returned.+--+-- Examples, see 'findLib''.+--+findLib :: LibName -> [AgdaLibFile] -> [AgdaLibFile]+findLib = findLib' _libName++-- | Generalized version of 'findLib' for testing.+--+-- > findLib' id "a" [ "a-1", "a-02", "a-2", "b" ] == [ "a-02", "a-2" ]+--+-- > findLib' id "a" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a" ]+-- > findLib' id "a-1" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a-1", "a-01" ]+-- > findLib' id "a-2" [ "a", "a-1", "a-01", "a-2", "b" ] == [ "a-2" ]+-- > findLib' id "c" [ "a", "a-1", "a-01", "a-2", "b" ] == []+--+findLib' :: (a -> LibName) -> LibName -> [a] -> [a]+findLib' libName x libs =+ case ls of+ -- Take the first and all exact matches (modulo leading zeros in version numbers).+ l : ls' -> l : takeWhile (((==) `on` libName) l) ls'+ [] -> []+ where+ -- @LibName@s that match @x@, sorted descendingly.+ -- The unversioned LibName, if any, will come first.+ ls = List.sortBy (flip compare `on` libName) [ l | l <- libs, x `hasMatch` libName l ]+ -- foo > foo-2.2 > foo-2.0.1 > foo-2 > foo-1.0++-- | @x `hasMatch` y@ if @x@ and @y@ have the same base and+-- either @x@ has no version qualifier or the versions also match.+hasMatch :: LibName -> LibName -> Bool+hasMatch (LibName rx vx) (LibName ry vy) = rx == ry && (vx == vy || null vx)
@@ -0,0 +1,644 @@+-- | Basic data types for library management.++module Agda.Interaction.Library.Base where++import Prelude hiding (null)++import Control.DeepSeq+import qualified Control.Exception as E++import Control.Monad.Except+import Control.Monad.State+import Control.Monad.Writer ( WriterT, runWriterT, MonadWriter, tell )+import Control.Monad.IO.Class ( MonadIO(..) )++import Data.Bifunctor ( first , second )+import Data.Char ( isDigit )+import Data.Function ( (&), on )+import Data.Hashable ( Hashable )+import qualified Data.List as List+import Data.Map ( Map )+import qualified Data.Map as Map+import Data.Text ( Text, unpack )+import qualified Data.Text as T+import Data.Tree ( Tree )++import GHC.Generics ( Generic )++import System.Directory++import Agda.Interaction.Options.Warnings++import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete.Glyph ( treeGlyphs )+import Agda.Syntax.Position++import Agda.Utils.IO ( showIOException )+import Agda.Utils.Lens+import Agda.Utils.List ( chopWhen )+import Agda.Utils.List1 ( List1, toList )+import Agda.Utils.List2 ( List2, toList )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Null++-- | A symbolic library name.+--+-- Library names are structured into the base name and a suffix of version+-- numbers, e.g. @mylib-1.2.3@. The version suffix is optional.+data LibName = LibName+ { libNameBase :: Text+ -- ^ Actual library name.+ , libNameVersion :: [Integer]+ -- ^ Major version, minor version, subminor version, etc., all non-negative.+ } deriving (Eq, Show, Generic)++-- | In comparisons, a missing version number is assumed to be infinity.+-- E.g. @foo > foo-2.2 > foo-2.0.1 > foo-2 > foo-1.0@.+instance Ord LibName where+ compare = compare `on` versionMeasure+ where+ versionMeasure :: LibName -> (Text, Bool, [Integer])+ versionMeasure (LibName rx vs) = (rx, null vs, vs)++instance Pretty LibName where+ pretty = \case+ LibName base [] -> pretty base+ LibName base vs -> hcat [ pretty base, "-", text $ List.intercalate "." $ map show vs ]++-- | Split a library name into basename and a list of version numbers.+--+-- > parseLibName "foo-1.2.3" == LibName "foo" [1, 2, 3]+-- > parseLibName "foo-01.002.3" == LibName "foo" [1, 2, 3]+--+-- Note that because of leading zeros, @parseLibName@ is not injective.+-- (@prettyShow . parseLibName@ would produce a normal form.)+parseLibName :: String -> LibName+parseLibName s =+ case span (\ c -> isDigit c || c == '.') (reverse s) of+ (v, '-' : x) | valid vs ->+ LibName (T.pack $ reverse x) $ reverse $ map (read . reverse) vs+ where+ vs = chopWhen (== '.') v+ valid [] = False+ valid vs = not $ any null vs+ _ -> LibName (T.pack s) []++data LibrariesFile = LibrariesFile+ { lfPath :: FilePath+ -- ^ E.g. @~/.agda/libraries@.+ , lfExists :: Bool+ -- ^ The libraries file might not exist,+ -- but we may print its assumed location in error messages.+ } deriving (Show, Generic)++-- | A symbolic executable name.+--+type ExeName = Text+type ExeMap = Map ExeName FilePath++data ExecutablesFile = ExecutablesFile+ { efPath :: FilePath+ -- ^ E.g. @~/.agda/executables@.+ , efExists :: Bool+ -- ^ The executables file might not exist,+ -- but we may print its assumed location in error messages.+ } deriving (Show, Generic)++-- | The special name @\".\"@ is used to indicated that the current directory+-- should count as a project root.+--+libNameForCurrentDir :: LibName+libNameForCurrentDir = LibName "." []++-- | A file can either belong to a project located at a given root+-- containing an .agda-lib file, or be part of the default project.+data ProjectConfig+ = ProjectConfig+ { configRoot :: FilePath+ -- ^ Directory which contains the @.agda-lib@ file for the current project.+ , configAgdaLibFile :: FilePath+ -- ^ @.agda-lib@ file relative to 'configRoot' (filename only, no directory).+ , configAbove :: !Int+ -- ^ How many directories above the Agda file is the @.agda-lib@ file located?+ }+ | DefaultProjectConfig+ deriving Generic++-- | The options from an @OPTIONS@ pragma (or a @.agda-lib@ file).+--+-- In the future it might be nice to switch to a more structured+-- representation. Note that, currently, there is not a one-to-one+-- correspondence between list elements and options.+data OptionsPragma = OptionsPragma+ { pragmaStrings :: [String]+ -- ^ The options.+ , pragmaRange :: Range+ -- ^ The range of the options in the pragma (not including things+ -- like an @OPTIONS@ keyword).+ }+ deriving Show++instance Semigroup OptionsPragma where+ OptionsPragma { pragmaStrings = ss1, pragmaRange = r1 } <>+ OptionsPragma { pragmaStrings = ss2, pragmaRange = r2 } =+ OptionsPragma+ { pragmaStrings = ss1 ++ ss2+ , pragmaRange = fuseRanges r1 r2+ }++instance Monoid OptionsPragma where+ mempty = OptionsPragma { pragmaStrings = [], pragmaRange = noRange }+ mappend = (<>)++-- | Ranges are not forced.++instance NFData OptionsPragma where+ rnf (OptionsPragma a _) = rnf a++-- | Content of a @.agda-lib@ file.+--+data AgdaLibFile = AgdaLibFile+ { _libName :: LibName -- ^ The symbolic name of the library.+ , _libFile :: FilePath -- ^ Path to this @.agda-lib@ file (not content of the file).+ , _libAbove :: !Int -- ^ How many directories above the+ -- Agda file is the @.agda-lib@ file+ -- located?+ , _libIncludes :: [FilePath] -- ^ Roots where to look for the modules of the library.+ , _libDepends :: [LibName] -- ^ Dependencies.+ , _libDependsPos :: Map LibName LibFilePos+ -- ^ Where the dependencies are mentioned+ -- in the @.agda-lib@ file (first mention).+ , _libPragmas :: OptionsPragma+ -- ^ Default pragma options for all files in the library.+ }+ deriving (Show, Generic)++emptyLibFile :: AgdaLibFile+emptyLibFile = AgdaLibFile+ { _libName = empty+ , _libFile = ""+ , _libAbove = 0+ , _libIncludes = []+ , _libDepends = []+ , _libDependsPos = Map.empty+ , _libPragmas = mempty+ }++---------------------------------------------------------------------------+-- * Lenses+---------------------------------------------------------------------------++-- ** Lenses for 'ProjectConfig'++lensConfigAbove :: Lens' ProjectConfig Int+lensConfigAbove f = \case+ DefaultProjectConfig -> DefaultProjectConfig <$ f 0+ c@ProjectConfig{} -> f (configAbove c) <&> \ !i -> c{ configAbove = i }++-- ** Lenses for 'AgdaLibFile'++libName :: Lens' AgdaLibFile LibName+libName f a = f (_libName a) <&> \ x -> a { _libName = x }++libFile :: Lens' AgdaLibFile FilePath+libFile f a = f (_libFile a) <&> \ x -> a { _libFile = x }++libAbove :: Lens' AgdaLibFile Int+libAbove f a = f (_libAbove a) <&> \ x -> a { _libAbove = x }++libIncludes :: Lens' AgdaLibFile [FilePath]+libIncludes f a = f (_libIncludes a) <&> \ x -> a { _libIncludes = x }++libDepends :: Lens' AgdaLibFile [LibName]+libDepends f a = f (_libDepends a) <&> \ x -> a { _libDepends = x }++libPragmas :: Lens' AgdaLibFile OptionsPragma+libPragmas f a = f (_libPragmas a) <&> \ x -> a { _libPragmas = x }+++------------------------------------------------------------------------+-- * Library warnings and errors+------------------------------------------------------------------------++-- ** Position information++type LineNumber = Int+type ColumnNumber = Int++-- | A stretch of a line in a file.+data LibFilePos = LibFilePos+ { lfpLine :: !LineNumber+ , lfpStartCol :: !ColumnNumber -- ^ Starting column (1-based).+ , lfpEndCol :: !ColumnNumber -- ^ Ending column (exclusive).+ }+ deriving (Show, Generic)++-- | Print as @line.col-endcol@, the format used for ranges in Agda files.+instance Pretty LibFilePos where+ pretty (LibFilePos l c e) = hcat [ pretty l, ".", pretty c, "-", pretty e ]++-- | Information about which @.agda-lib@ file we are reading+-- and from where in the @libraries@ file it came from.++data LibPositionInfo = LibPositionInfo+ { libFilePos :: Maybe FilePath -- ^ Name of @libraries@ file.+ , lineNumPos :: LineNumber -- ^ Line number in @libraries@ file.+ , filePos :: FilePath -- ^ Library file.+ }+ deriving (Show, Generic)++-- ** Warnings++data LibWarning = LibWarning (Maybe LibPositionInfo) LibWarning'+ deriving (Show, Generic)++-- | Library Warnings.+data LibWarning'+ = UnknownField String+ | LibraryVersionConflict+ -- ^ A library is depended on in different versions.+ Text+ -- ^ The library name without version.+ LibDepTree+ -- ^ The dependency tree, pruned to the paths leading to the conflicting versions.+ [(Text, FilePath, Maybe LibFilePos)]+ -- ^ The @.agda-lib@ files of the libraries mentioned in the tree,+ -- keyed by their 'depLabel',+ -- with the position of the first dependency shown in the tree (if any).+ deriving (Show, Generic)++-- | A dependency tree of libraries, used to report the provenance+-- of a 'LibraryVersionConflict'.+type LibDepTree = Tree LibDepNode++-- | A node in a 'LibDepTree'.+data LibDepNode = LibDepNode+ { depLabel :: Text+ -- ^ The library name as written in the @depend@ field+ -- (or the name of the project at the root).+ , depResolvedAs :: Maybe Text+ -- ^ The name of the library the label resolved to, if different from the label.+ }+ deriving (Show, Generic)++-- | Label of the root of a 'LibDepTree' if the project has no name.+libDepRootLabel :: Text+libDepRootLabel = "<root>"++libraryWarningName :: LibWarning -> WarningName+libraryWarningName (LibWarning c w) = case w of+ UnknownField{} -> LibUnknownField_+ LibraryVersionConflict{} -> LibraryVersionConflict_++-- * Errors++data LibError = LibError (Maybe LibPositionInfo) LibError'+ deriving (Show, Generic)++-- | Collected errors while processing library files.+--+data LibError'+ = LibrariesFileNotFound FilePath+ -- ^ The user specified replacement for the default @libraries@ file does not exist.+ | LibNotFound LibrariesFile LibName+ -- ^ Raised when a library name could not successfully be resolved+ -- to an @.agda-lib@ file.+ --+ | AmbiguousLib LibName (List2 AgdaLibFile)+ -- ^ Raised when a library name is defined in several @.agda-lib files@.+ | SeveralAgdaLibFiles FilePath (List2 FilePath)+ -- ^ The given project root contains more than one @.agda-lib@ file.+ | LibParseError LibParseError+ -- ^ The @.agda-lib@ file could not be parsed.+ | ReadError+ -- ^ An I/O Error occurred when reading a file.+ E.IOException+ -- ^ The caught exception+ String+ -- ^ Explanation when this error occurred.+ | DuplicateExecutable+ -- ^ The @executables@ file contains duplicate entries.+ FilePath+ -- ^ Name of the @executables@ file.+ Text+ -- ^ Name of the executable that is defined twice.+ (List2 (LineNumber, FilePath))+ -- ^ The resolutions of the executable.+ deriving (Show, Generic)++-- | Exceptions thrown by the @.agda-lib@ parser.+--+data LibParseError+ = BadLibraryName String+ -- ^ An invalid library name, e.g., containing spaces.+ | ReadFailure FilePath E.IOException+ -- ^ I/O error while reading file.+ | MissingFields (List1 String)+ -- ^ Missing these mandatory fields.+ | DuplicateFields (List1 String)+ -- ^ These fields occur each more than once.+ | MissingFieldName LineNumber+ -- ^ At the given line number, a field name is missing before the @:@.+ | BadFieldName LineNumber String+ -- ^ At the given line number, an invalid field name is encountered before the @:@.+ -- (E.g., containing spaces.)+ | MissingColonForField LineNumber String+ -- ^ At the given line number, the given field is not followed by @:@.+ | ContentWithoutField LineNumber+ -- ^ At the given line number, indented text (content) is not preceded by a field.+ deriving (Show, Generic)++-- ** Raising warnings and errors++-- | Collection of 'LibError's and 'LibWarning's.+--+type LibErrWarns = [Either LibError LibWarning]++warnings :: MonadWriter LibErrWarns m => List1 LibWarning -> m ()+warnings = tell . map Right . toList++warnings' :: MonadWriter LibErrWarns m => List1 LibWarning' -> m ()+warnings' = tell . map (Right . LibWarning Nothing) . toList++raiseErrors' :: MonadWriter LibErrWarns m => List1 LibError' -> m ()+raiseErrors' = tell . map (Left . (LibError Nothing)) . toList++raiseErrors :: MonadWriter LibErrWarns m => List1 LibError -> m ()+raiseErrors = tell . map Left . toList+++------------------------------------------------------------------------+-- * Library Monad+------------------------------------------------------------------------++-- | Collects 'LibError's and 'LibWarning's.+--+type LibErrorIO = WriterT LibErrWarns (StateT LibState IO)++-- | Throws 'LibErrors' exceptions, still collects 'LibWarning's.+type LibM = ExceptT LibErrors (WriterT [LibWarning] (StateT LibState IO))++type LibState = LibCache++-- | Cache locations of project configurations and parsed @.agda-lib@ files.+data LibCache = LibCache+ { projectConfigs :: !(Map FilePath ProjectConfig)+ -- ^ Map from directories to paths of closest enclosing @.agda-lib@+ -- files (or 'DefaultProjectConfig' if there are none).+ , agdaLibFiles :: !(Map FilePath AgdaLibFile)+ -- ^ Contents of @.agda-lib@ files that have already been parsed.+ }+ deriving (Generic)++-- | Collected errors when processing an @.agda-lib@ file.+--+data LibErrors = LibErrors+ { libErrorsInstalledLibraries :: [AgdaLibFile]+ , libErrors :: List1 LibError+ } deriving (Show, Generic)++runLibM :: LibM a -> LibState -> IO ((Either LibErrors a, [LibWarning]), LibState)+runLibM m s = m & runExceptT & runWriterT & (`runStateT` s)++getCachedProjectConfig+ :: (MonadState LibState m, MonadIO m)+ => FilePath -> m (Maybe ProjectConfig)+getCachedProjectConfig path = do+ path <- liftIO $ canonicalizePath path+ Map.lookup path <$> gets projectConfigs++storeCachedProjectConfig+ :: (MonadState LibState m, MonadIO m)+ => FilePath -> ProjectConfig -> m ()+storeCachedProjectConfig path conf = do+ path <- liftIO $ canonicalizePath path+ modify \ s -> s { projectConfigs = Map.insert path conf $ projectConfigs s }++getCachedAgdaLibFile+ :: (MonadState LibState m, MonadIO m)+ => FilePath -> m (Maybe AgdaLibFile)+getCachedAgdaLibFile path = do+ path <- liftIO $ canonicalizePath path+ Map.lookup path <$> gets agdaLibFiles++storeCachedAgdaLibFile+ :: (MonadState LibState m, MonadIO m)+ => FilePath -> AgdaLibFile -> m ()+storeCachedAgdaLibFile path lib = do+ path <- liftIO $ canonicalizePath path+ modify \ s -> s { agdaLibFiles = Map.insert path lib $ agdaLibFiles s }++------------------------------------------------------------------------+-- * Prettyprinting errors and warnings+------------------------------------------------------------------------++-- | Pretty-print 'LibError'.+formatLibError :: [AgdaLibFile] -> LibError -> Doc+formatLibError installed (LibError mc e) =+ case (mc, e) of+ (Just c, LibParseError err) -> sep [ formatLibPositionInfo c err, pretty e ]+ (_ , LibNotFound{} ) -> vcat [ pretty e, prettyInstalledLibraries installed ]+ _ -> pretty e+++-- | Pretty-print 'LibErrors'.+formatLibErrors :: LibErrors -> Doc+formatLibErrors (LibErrors libs errs) =+ vcat $ map (formatLibError libs) $ List1.toList errs++-- | Does a parse error contain a line number?+hasLineNumber :: LibParseError -> Maybe LineNumber+hasLineNumber = \case+ BadLibraryName _ -> Nothing+ ReadFailure _ _ -> Nothing+ MissingFields _ -> Nothing+ DuplicateFields _ -> Nothing+ MissingFieldName l -> Just l+ BadFieldName l _ -> Just l+ MissingColonForField l _ -> Just l+ ContentWithoutField l -> Just l++-- UNUSED:+-- -- | Does a parse error contain the name of the parsed file?+-- hasFilePath :: LibParseError -> Maybe FilePath+-- hasFilePath = \case+-- BadLibraryName _ -> Nothing+-- ReadFailure f _ -> Just f+-- MissingFields _ -> Nothing+-- DuplicateFields _ -> Nothing+-- MissingFieldName _ -> Nothing+-- BadFieldName _ _ -> Nothing+-- MissingColonForField _ _ -> Nothing+-- ContentWithoutField _ -> Nothing++-- | Compute a position position prefix.+--+-- Depending on the error to be printed, it will+--+-- - either give the name of the @libraries@ file and a line inside it,+--+-- - or give the name of the @.agda-lib@ file.+--+formatLibPositionInfo :: LibPositionInfo -> LibParseError -> Doc+formatLibPositionInfo (LibPositionInfo libFile lineNum file) = \case++ -- If we couldn't even read the @.agda-lib@ file, report error in the @libraries@ file.+ ReadFailure _ _+ | Just lf <- libFile+ -> hcat [ text lf, ":", pretty lineNum, ":" ]+ | otherwise+ -> empty++ -- If the parse error comes with a line number, print it here.+ e | Just l <- hasLineNumber e+ -> hcat [ text file, ":", pretty l, ":" ]+ | otherwise+ -> hcat [ text file, ":" ]++prettyInstalledLibraries :: [AgdaLibFile] -> Doc+prettyInstalledLibraries installed =+ vcat $ ("Installed libraries:" :) $+ map (nest 2) $+ if null installed then ["(none)"]+ else [ sep [ pretty $ _libName l, nest 2 $ parens $ text $ _libFile l ]+ | l <- installed+ ]++-- | Pretty-print library management error without position info.++instance Pretty LibError' where+ pretty = \case++ LibrariesFileNotFound path -> sep+ [ text "Libraries file not found:"+ , text path+ ]++ LibNotFound file lib -> vcat $+ [ hcat [ "Library '", pretty lib, "' not found." ]+ , sep [ "Add the path to its .agda-lib file to"+ , nest 2 $ text $ "'" ++ lfPath file ++ "'"+ , "to install."+ ]+ ]++ AmbiguousLib lib tgts -> vcat $+ sep [ hcat [ "Ambiguous library '", pretty lib, "'." ]+ , "Could refer to any one of"+ ]+ : [ nest 2 $ pretty (_libName l) <+> parens (text $ _libFile l) | l <- toList tgts ]++ SeveralAgdaLibFiles root files -> vcat $+ sep [ "The project root", pretty root ]+ : "may contain only one .agda-lib file, but I found several:"+ : map (("-" <+>) . pretty) (List.sort $ toList files)++ LibParseError err -> pretty err++ ReadError e msg -> vcat+ [ text $ msg+ , text $ showIOException e+ ]++ DuplicateExecutable exeFile exe paths -> vcat $+ hcat [ "Duplicate entries for executable '", (text . unpack) exe, "' in ", text exeFile, ":" ] :+ map (\ (ln, fp) -> nest 2 $ (pretty ln <> colon) <+> text fp) (toList paths)++-- | Print library file parse error without position info.+--+instance Pretty LibParseError where+ pretty = \case++ BadLibraryName s -> sep+ [ "Bad library name:", quotes (text s) ]+ ReadFailure file e -> vcat+ [ hsep [ "Failed to read library file", text file <> "." ]+ , "Reason:" <+> text (showIOException e)+ ]++ MissingFields xs -> "Missing" <+> listFields xs+ DuplicateFields xs -> "Duplicate" <+> listFields xs++ MissingFieldName l -> atLine l $ "Missing field name"+ BadFieldName l s -> atLine l $ "Bad field name" <+> text (show s)+ MissingColonForField l s -> atLine l $ "Missing ':' for field " <+> text (show s)+ ContentWithoutField l -> atLine l $ "Missing field"++ where+ listFields xs = hsep $ fieldS xs : list xs+ fieldS xs = singPlural xs "field:" "fields:"+ list = punctuate comma . map (quotes . text) . toList+ atLine l = id+ -- The line number will be printed by 'formatLibPositionInfo'!+ -- atLine l doc = hsep [ text (show l) <> ":", doc ]+++instance Pretty LibWarning where+ pretty (LibWarning mc w) =+ case mc of+ Nothing -> pretty w+ Just (LibPositionInfo _ _ file) -> hcat [ text file, ":"] <+> pretty w++instance Pretty LibWarning' where+ pretty = \case+ UnknownField s -> text $ "Unknown field '" ++ s ++ "'"+ LibraryVersionConflict lib tree files -> vcat $ concat+ [ [ hcat [ "Different versions of the library '", pretty lib, "' depended on:" ] ]+ , [ prettyLibDepTree tree ]+ , [ "Library files:" ]+ -- Andreas, 2026-10-24, issue #8875+ -- We print positions as "file:line.col-endcol"+ -- so that the Emacs mode makes them clickable.+ -- Without a dependency position, we point to the beginning of the file.+ , [ hcat [ brackets (pretty l), ":" ] <+> hcat [ text f, ":", maybe "1.1" pretty mpos ]+ | (l, f, mpos) <- files+ ]+ ]++-- | Render a 'LibDepTree', one line per node.+prettyLibDepTree :: LibDepTree -> Doc+prettyLibDepTree = prettyTree treeGlyphs++instance Pretty LibDepNode where+ pretty (LibDepNode l mr) = case mr of+ Nothing -> brackets (pretty l)+ Just r -> pretty r <+> "as" <+> brackets (pretty l)++------------------------------------------------------------------------+-- Hashable instances+------------------------------------------------------------------------++instance Hashable LibName++------------------------------------------------------------------------+-- Null instances+------------------------------------------------------------------------++instance Null LibName where+ empty = LibName empty empty+ null (LibName a b) = null a && null b++instance Null LibCache where+ empty = LibCache empty empty+ null (LibCache a b) = null a && null b++------------------------------------------------------------------------+-- NFData instances+------------------------------------------------------------------------++instance NFData ExecutablesFile+instance NFData LibrariesFile+instance NFData ProjectConfig+instance NFData AgdaLibFile+instance NFData LibName+instance NFData LibCache+instance NFData LibPositionInfo+instance NFData LibFilePos+instance NFData LibWarning+instance NFData LibWarning'+instance NFData LibDepNode+instance NFData LibError+instance NFData LibError'+instance NFData LibErrors+instance NFData LibParseError+instance NFData E.IOException where rnf _ = ()
@@ -0,0 +1,324 @@+-- | Parser for @.agda-lib@ files.+--+-- Example file:+--+-- @+-- name: Main+-- depend:+-- standard-library+-- include: .+-- src more-src+--+-- @+--+-- Should parse as:+--+-- @+-- AgdaLib+-- { libName = "Main"+-- , libFile = path_to_this_file+-- , libIncludes = [ "." , "src" , "more-src" ]+-- , libDepends = [ "standard-library" ]+-- }+-- @+--+module Agda.Interaction.Library.Parse+ ( parseLibFile+ , splitCommas+ , trimLineComment+ , runP+ ) where++import Control.Monad+import Control.Monad.Except+import Control.Monad.Writer+import Data.Char+import qualified Data.List as List+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Text (Text)+import qualified Data.Text as T+import System.FilePath++import Agda.Interaction.Library.Base++import Agda.Syntax.Position++import Agda.Utils.Applicative+import Agda.Utils.FileName+import Agda.Utils.IO ( catchIO )+import qualified Agda.Utils.IO.UTF8 as UTF8+import Agda.Utils.Lens+import Agda.Utils.List ( duplicates )+import Agda.Utils.List1 ( List1, toList )+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.Maybe.Strict as Strict+import Agda.Utils.Singleton+import Agda.Utils.String ( ltrim )++-- | Parser monad: Can throw @LibParseError@s, and collects+-- @LibWarning'@s library warnings.+type P = ExceptT LibParseError (Writer [LibWarning'])++runP :: P a -> (Either LibParseError a, [LibWarning'])+runP = runWriter . runExceptT++warningP :: LibWarning' -> P ()+warningP = tell . pure++-- | The config files we parse have the generic structure of a sequence+-- of @field : content@ entries.+type GenericFile = [GenericEntry]++data GenericEntry = GenericEntry+ { geHeader :: String -- ^ E.g. field name. @trim@med.+ , _geContent :: [ContentLine] -- ^ E.g. field content. @trim@med.+ }++-- | A (part of a) line of field content.+data ContentLine = ContentLine+ { clLine :: LineNumber+ , clColumn :: ColumnNumber -- ^ Column (1-based) where 'clText' starts.+ , clText :: String -- ^ @trim@med.+ }+ deriving (Show)++-- | Library file field format format [sic!].+data Field = forall a. Field+ { fName :: String+ -- ^ Name of the field.+ , fOptional :: Bool+ -- ^ Is it optional?+ , fParse :: Range -> [ContentLine] -> P a+ -- ^ Content parser for this field.+ --+ -- The range points to the start of the file.+ , fSet :: LensSet AgdaLibFile a+ -- ^ Sets parsed content in 'AgdaLibFile' structure.+ }++optionalField ::+ String -> (Range -> [ContentLine] -> P a) -> Lens' AgdaLibFile a -> Field+optionalField str p l = Field str True p (set l)++-- | @.agda-lib@ file format with parsers and setters.+agdaLibFields :: [Field]+agdaLibFields =+ -- Andreas, 2017-08-23, issue #2708, field "name" is optional.+ [ optionalField "name" (\_ -> parseName . map clText) libName+ , optionalField "include" (\_ -> pure . concatMap (parsePaths . clText)) libIncludes+ , Field "depend" True (\_ -> pure . parseDepends)+ (\ (ds, pos) l -> l{ _libDepends = ds, _libDependsPos = pos })+ , optionalField "flags" (\r -> pure . foldMap (parseFlags r . clText)) libPragmas+ ]+ where+ -- Remember where the dependencies are mentioned (issue #8875).+ parseDepends :: [ContentLine] -> ([LibName], Map LibName LibFilePos)+ parseDepends cls = (map fst ds, Map.fromListWith (\ _new old -> old) ds)+ where+ ds = [ (parseLibName w, LibFilePos l c (c + length w))+ | ContentLine l c0 s <- cls+ , (c, w) <- splitCommasPos c0 s+ ]++ parseName :: [String] -> P LibName+ parseName [s] | [name] <- words s = pure $ parseLibName name+ parseName ls = throwError $ BadLibraryName $ unwords ls++ parsePaths :: String -> [FilePath]+ parsePaths = go id where+ fixup acc = let fp = acc [] in not (null fp) ?$> fp+ go acc [] = fixup acc+ go acc ('\\' : ' ' :cs) = go (acc . (' ':)) cs+ go acc ('\\' : '\\' :cs) = go (acc . ('\\':)) cs+ go acc ( ' ' :cs) = fixup acc ++ go id cs+ go acc (c :cs) = go (acc . (c:)) cs++ parseFlags :: Range -> String -> OptionsPragma+ parseFlags r s = OptionsPragma+ { pragmaStrings = words s+ , pragmaRange = r+ }++-- | Parse @.agda-lib@ file.+--+-- Sets 'libFile' name and turn mentioned include directories into absolute+-- pathes (provided the given 'FilePath' is absolute).+--+parseLibFile :: FilePath -> IO (P AgdaLibFile)+parseLibFile file = do+ abs <- absolute file+ (fmap setPath . parseLib abs <$> UTF8.readFile file) `catchIO` \e ->+ return $ throwError $ ReadFailure file e+ where+ setPath lib = unrelativise (takeDirectory file) (set libFile file lib)+ unrelativise dir = over libIncludes (map (dir </>))++-- | Parse file contents.+parseLib+ :: AbsolutePath+ -- ^ The parsed file.+ -> String+ -> P AgdaLibFile+parseLib file s = fromGeneric file =<< parseGeneric s++-- | Parse 'GenericFile' with 'agdaLibFields' descriptors.+fromGeneric+ :: AbsolutePath+ -- ^ The parsed file.+ -> GenericFile+ -> P AgdaLibFile+fromGeneric file = fromGeneric' file agdaLibFields++-- | Given a list of 'Field' descriptors (with their custom parsers),+-- parse a 'GenericFile' into the 'AgdaLibFile' structure.+--+-- Checks mandatory fields are present;+-- no duplicate fields, no unknown fields.++fromGeneric'+ :: AbsolutePath+ -- ^ The parsed file.+ -> [Field]+ -> GenericFile+ -> P AgdaLibFile+fromGeneric' file fields fs = do+ checkFields fields (map geHeader fs)+ foldM upd emptyLibFile fs+ where+ -- The range points to the start of the file.+ r :: Range+ r = beginningOfFile file+ upd :: AgdaLibFile -> GenericEntry -> P AgdaLibFile+ upd l (GenericEntry h cs) = do+ mf <- findField h fields+ case mf of+ Just Field{ fParse, fSet } -> do+ x <- fParse r cs+ return $ fSet x l+ Nothing -> return l++-- | Ensure that there are no duplicate fields and no mandatory fields are missing.+checkFields :: [Field] -> [String] -> P ()+checkFields fields fs = do+ -- Report missing mandatory fields.+ () <- List1.unlessNull missing $ throwError . MissingFields+ -- Report duplicate fields.+ List1.unlessNull (duplicates fs) $ throwError . DuplicateFields+ where+ mandatory :: [String]+ mandatory = [ fName f | f <- fields, not $ fOptional f ]+ missing :: [String]+ missing = mandatory List.\\ fs++-- | Find 'Field' with given 'fName', throw error if unknown.+findField :: String -> [Field] -> P (Maybe Field)+findField s fs = maybe err (return . Just) $ List.find ((s ==) . fName) fs+ where err = warningP (UnknownField s) >> return Nothing++-- Generic file parser ----------------------------------------------------++-- | Example:+--+-- @+-- parseGeneric "name:Main--BLA\ndepend:--BLA\n standard-library--BLA\ninclude : . --BLA\n src more-src \n"+-- == Right [("name",["Main"]),("depend",["standard-library"]),("include",[".","src more-src"])]+-- @+parseGeneric :: String -> P GenericFile+parseGeneric s =+ groupLines =<< concat <$> zipWithM parseLine [1..] (map stripComments $ lines s)++-- | Lines with line numbers.+data GenericLine+ = Header LineNumber String+ -- ^ Header line, like a field name, e.g. "include :". Cannot be indented.+ -- @String@ is 'trim'med.+ | Content ContentLine+ -- ^ Other line. Must be indented.+ deriving (Show)++-- | Parse line into 'Header' and 'Content' components.+--+-- Precondition: line comments and trailing whitespace have been stripped away.+--+-- Example file:+--+-- @+-- name: Main+-- depend:+-- standard-library+-- include: .+-- src more-src+-- @+--+-- This should give+--+-- @+-- [ Header 1 "name"+-- , Content (ContentLine 1 7 "Main")+-- , Header 2 "depend"+-- , Content (ContentLine 3 3 "standard-library")+-- , Header 4 "include"+-- , Content (ContentLine 4 10 ".")+-- , Content (ContentLine 5 3 "src more-src")+-- ]+-- @+parseLine :: LineNumber -> String -> P [GenericLine]+parseLine _ "" = pure []+parseLine l s@(c:_)+ -- Indented lines are 'Content'.+ | isSpace c = pure [content $ ltrim s]+ -- Non-indented lines are 'Header'.+ | otherwise =+ case break (== ':') s of+ -- Headers are single words followed by a colon.+ -- Anything after the colon that is not whitespace is 'Content'.+ (h, ':' : r) ->+ case words h of+ [h] -> pure $ Header l h : [content r' | let r' = ltrim r, not (null r')]+ [] -> throwError $ MissingFieldName l+ hs -> throwError $ BadFieldName l h+ _ -> throwError $ MissingColonForField l (ltrim s)+ where+ -- @r@ is a suffix of @s@.+ content r = Content $ ContentLine l (length s - length r + 1) r++-- | Collect 'Header' and subsequent 'Content's into 'GenericEntry'.+--+-- Leading 'Content's? That's an error.+--+groupLines :: [GenericLine] -> P GenericFile+groupLines [] = pure []+groupLines (Content c : _) = throwError $ ContentWithoutField $ clLine c+groupLines (Header _ h : ls) = (GenericEntry h [ c | Content c <- cs ] :) <$> groupLines ls1+ where+ (cs, ls1) = span isContent ls+ isContent Content{} = True+ isContent Header{} = False++-- | Remove leading whitespace and line comment.+trimLineComment :: String -> String+trimLineComment = stripComments . ltrim++-- | Break a comma-separated string. Result strings are @trim@med.+splitCommas :: String -> [String]+splitCommas = map snd . splitCommasPos 1++-- | Break a comma-separated string starting at the given column.+-- Result strings are @trim@med and come with their starting column.+splitCommasPos :: ColumnNumber -> String -> [(ColumnNumber, String)]+splitCommasPos c0 = go . zip [c0..]+ where+ go ps = case dropWhile (isSep . snd) ps of+ [] -> []+ ps'@((c, _) : _) -> let (w, rest) = break (isSep . snd) ps' in (c, map snd w) : go rest+ isSep c = c == ',' || isSpace c++-- | ...and trailing, but not leading, whitespace.+stripComments :: String -> String+stripComments "" = ""+stripComments ('-':'-':c:_) | isSpace c = ""+stripComments (c : s) = cons c (stripComments s)+ where+ cons c "" | isSpace c = ""+ cons c s = c : s
@@ -1,138 +1,635 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} +{-# LANGUAGE NondecreasingIndentation #-}+ module Agda.Interaction.MakeCase where -import Prelude hiding (mapM, mapM_)-import Control.Applicative-import Control.Monad hiding (mapM, mapM_)-import Control.Monad.State hiding (mapM, mapM_)-import qualified Data.Map as Map-import Data.Traversable-import Data.List+import Prelude hiding ((!!), null) +import qualified Data.List as List+import Data.Maybe+import Data.Monoid+ import Agda.Syntax.Common+import Agda.Syntax.Info import Agda.Syntax.Position+import qualified Agda.Syntax.Concrete as C+import qualified Agda.Syntax.Concrete.Pattern as C import qualified Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Info as A-import Agda.Syntax.Abstract.Views+import qualified Agda.Syntax.Abstract.Pattern as A+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Common.Pretty ( prettyShow ) import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern+import Agda.Syntax.Parser.Helpers ( mkValidName )+import Agda.Syntax.Scope.Base ( ResolvedName(..), BindingSource(..), exceptKindsOfNames )+import Agda.Syntax.Scope.Monad ( resolveName' ) import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Scope.Base (emptyScopeInfo) import Agda.TypeChecking.Monad-import qualified Agda.TypeChecking.Monad.Context as Context import Agda.TypeChecking.Coverage+import Agda.TypeChecking.Coverage.SplitPattern ( SplitPatVar(..) , SplitPattern , applySplitPSubst , fromSplitPatterns )+import Agda.TypeChecking.Empty ( isEmptyTel ) import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Irrelevance-import Agda.TypeChecker+import Agda.TypeChecking.Rules.Def (checkClauseLHS)+import Agda.TypeChecking.Rules.LHS (LHSResult(..))+import Agda.TypeChecking.Rules.LHS.Problem (AsBinding(..)) -import Agda.Interaction.BasicOps+import Agda.Interaction.Options -import Agda.Utils.Size-import Agda.Utils.Permutation+import qualified Agda.Utils.BiMap as BiMap+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Three+import Agda.Utils.WithDefault (lensKeepDefault) -#include "../undefined.h" import Agda.Utils.Impossible -data CaseContext = FunctionDef | ExtendedLambda Int Int- deriving (Eq)--- | Find the clause whose right hand side is the given meta--- BY SEARCHING THE WHOLE SIGNATURE. Returns--- the original clause, before record patterns have been translated--- away. Raises an error if there is no matching clause.------ Andreas, 2010-09-21: This looks like a SUPER UGLY HACK to me. You are--- walking through the WHOLE signature to find an information you have--- thrown away earlier. (shutter with disgust).--- This code fails for record rhs because they have been eta-expanded,--- so the MVar is gone.-findClause :: MetaId -> TCM (CaseContext, QName, Clause)-findClause m = do- sig <- getImportedSignature- let res = do- def <- Map.elems $ sigDefinitions sig- Function{funClauses = cs} <- [theDef def]- c <- cs- unless (rhsIsm $ clauseBody c) []- return (defName def, c)- case res of- [] -> do- reportSDoc "interaction.case" 10 $ vcat $- [ text "Interaction.MakeCase.findClause fails"- , text "expected rhs to be meta var" <+> (text $ show m)- , text "but could not find it in the signature"- ]- reportSDoc "interaction.case" 20 $ vcat $ map (text . show) (Map.elems $ sigDefinitions sig) -- you asked for it!- typeError $ GenericError "Right hand side must be a single hole when making a case distinction."- [(n,c)] | isPrefixOf extendlambdaname $ show $ A.qnameName n -> do- Just (h , nh) <- Map.lookup n <$> getExtLambdaTele- return (ExtendedLambda h nh , n , c)- | otherwise -> return (FunctionDef , n , c)- _ -> __IMPOSSIBLE__+type CaseContext = Maybe ExtLamInfo++-- | For the names the user enters for case-splitting, there can be different actions+-- depending on what the name resolved to.+data SplitAction+ = RevealDotPattern Name+ -- ^ De Bruijn index of a pattern variable bound to a value, turn into dot pattern.+ | RevealHiddenVariable Int+ -- ^ De Bruijn index of a hidden argument, make this argument visible.+ | SplitOnVariable Int+ -- ^ De Bruijn index of an unconstrained pattern variable, split on it.+ deriving (Show)++splitActionToEither3 :: SplitAction -> Either3 Name Int Int+splitActionToEither3 = \case+ RevealDotPattern i -> In1 i+ RevealHiddenVariable i -> In2 i+ SplitOnVariable i -> In3 i++-- | Parse variables (visible or hidden), returning their de Bruijn indices.+-- Used in 'makeCase'.++parseVariables+ :: QName -- ^ The function name.+ -> Context -- ^ The context of the RHS of the clause we are splitting.+ -> [AsBinding] -- ^ The as-bindings of the clause we are splitting+ -> InteractionId -- ^ The hole of this function we are working on.+ -> Range -- ^ The range of this hole.+ -> [String] -- ^ The words the user entered in this hole (variable names).+ -> TCM [SplitAction]+ -- ^ The computed de Bruijn indices of the variables and the inferred action.+parseVariables f cxt asb ii rng ss = do++ -- We parse the variables in two steps:+ -- (1) Convert the strings given by the user to abstract names,+ -- using the scope information from the interaction meta.+ -- (2) Convert the abstract names to de Bruijn indices,+ -- using the context of the clause.++ -- Get into the context of the meta.+ mId <- lookupInteractionId ii+ updateMetaVarRange mId rng+ mi <- getMetaInfo <$> lookupLocalMeta mId+ enterClosure mi $ \ r -> do++ reportSDoc "interaction.case" 20 $ do+ m <- currentModule+ tel <- lookupSection m+ vcat+ [ "parseVariables:"+ , "current module =" <+> prettyTCM m+ , "current section =" <+> inTopContext (prettyTCM tel)+ , "clause context =" <+> prettyTCM (PrettyContext cxt)+ ]++ -- Get printed representation of variables in context. These are+ -- used for recognizing when the user wants to make a hidden+ -- variable (which is not in scope) visible.+ n <- getContextSize+ xs <- forM (downFrom n) $ \ i ->+ (,) <$> (P.render <$> prettyTCM (var i)) <*> nameOfBV i++ -- Step 1: From strings to abstract names+ abstractNames :: [(A.Name, Maybe BindingSource)] <- forM ss $ \s -> do++ cname <- either failParseError (return . C.QName) $ mkValidName False r s+ -- Note: the range in the concrete name is only approximate.+ -- Jesper, 2018-12-19: Don't consider generalizable names since+ -- they can be shadowed by hidden variables.+ resolveName' (exceptKindsOfNames [GeneralizeName]) Nothing cname >>= \case++ -- Fail if s is a name, but not of a variable.+ DefinedName{} -> failNotVar s+ FieldName{} -> failNotVar s+ ConstructorName{} -> failNotVar s+ PatternSynResName{} -> failNotVar s++ -- If s is a variable name, return it together with binding information.+ VarName x b -> return (x, Just b)++ -- If s is not a name, compare it to the printed variable representation.+ UnknownName -> case (lookup s xs) of+ Nothing -> failUnbound s+ Just x -> return (x, Nothing)++ -- Step 2: Resolve each abstract name to a de Bruijn index.++ -- First, get context names of the clause.+ let clauseCxtNames = contextNames' cxt++ -- Valid names to split on are pattern variables of the clause,+ -- plus as-bindings that refer to a variable.+ let clauseVars = zip clauseCxtNames (map var [0..]) +++ map (\(AsB name v _) -> (name,v)) asb++ -- We cannot split on module parameters or make them visible+ params <- moduleParamsToApply $ qnameModule f+ let isParam i = any ((== var i) . unArg) params++ forM (zip ss abstractNames) $ \(s, (name, bound)) -> case bound of+ -- Case 1: variable has a binding site. Check if it also exists in+ -- the clause context so we can split on it.+ Just bindingSource -> case (lookup name clauseVars, bindingSource) of+ -- Case 1a: it is also known in the clause telescope and is+ -- actually a variable. If a pattern variable (`PatternBound`)+ -- has been refined to a module parameter we do allow splitting+ -- on it, since the instantiation could as well have been the+ -- other way around (see #2183).+ (Just (Var i []), PatternBound _) -> return (SplitOnVariable i)+ -- Case 1b: the variable has been refined.+ -- Andreas, 2025-10-12, issue #7941: We can turn it into an explicit dot pattern.+ (Just v , PatternBound _) -> return (RevealDotPattern name) -- failInstantiatedVar s v+ -- Case 1c: the variable is bound locally (e.g. a record let)+ (Nothing , PatternBound _) -> failCaseLet s+ -- Case 1d: module parameter+ (Just (Var i []), LambdaBound ) -> failModuleBound s+ -- Case 1e: locally lambda-bound variable+ (_ , LambdaBound ) -> failLocal s+ -- Case 1f: let-bound variable+ (_ , LetBound ) -> failLetBound s+ -- Case 1g: with-bound variable+ (_ , WithBound ) -> failWithBound s+ -- Case 1h: macro-bound variable (interactive command impossible in macro context)+ (_ , MacroBound ) -> __IMPOSSIBLE__+ -- Case 2: variable has no binding site, so we check if it can be+ -- made visible.+ Nothing -> case List.find (((==) `on` nameConcrete) name . fst) clauseVars of+ -- Case 2a: there is a variable with that concrete name in the+ -- clause context. If it is not a parameter, we can make it+ -- visible.+ Just (x, Var i []) | isParam i -> failHiddenModuleBound s+ | otherwise -> return (RevealHiddenVariable i)+ -- Case 2b: there is a variable with that concrete name, but it+ -- has been refined.+ -- Andreas, 2025-10-12, issue #7941: We can turn it into an explicit dot pattern.+ Just (x, v) -> return (RevealDotPattern x) -- failInstantiatedVar s v+ -- Case 2c: there is no variable with that name. Since it was in+ -- scope for the interaction meta, the only possibility is that+ -- it is a hidden lambda-bound variable.+ Nothing -> failHiddenLocal s+ where- rhsIsm (Bind b) = rhsIsm $ unAbs b- rhsIsm NoBody = False- rhsIsm (Body e) = case e of- MetaV m' _ -> m == m'- _ -> False -makeCase :: InteractionId -> Range -> String -> TCM (CaseContext , [A.Clause])-makeCase hole rng s = withInteractionId hole $ do- meta <- lookupInteractionId hole- (casectxt, f, clause@(Clause{ clauseTel = tel, clausePerm = perm, clausePats = ps })) <- findClause meta+ failParseError s = interactionError $ CaseSplitError $ P.text s+ failNotVar s = interactionError $ CaseSplitError $ P.text $ "Not a variable: " ++ s+ failUnbound s = interactionError $ CaseSplitError $ P.text $ "Unbound variable " ++ s+ failAmbiguous s = interactionError $ CaseSplitError $ P.text $ "Ambiguous variable " ++ s+ failLocal s = interactionError $ CaseSplitError $ P.text $+ "Cannot split on local variable " ++ s+ failHiddenLocal s = interactionError $ CaseSplitError $ P.text $+ "Cannot make hidden lambda-bound variable " ++ s ++ " visible"+ failModuleBound s = interactionError $ CaseSplitError $ P.text $+ "Cannot split on module parameter " ++ s+ failHiddenModuleBound s = interactionError $ CaseSplitError $ P.text $+ "Cannot make hidden module parameter " ++ s ++ " visible"+ failLetBound s = interactionError $ CaseSplitError $ P.text $+ "Cannot split on let-bound variable " ++ s+ failWithBound s = interactionError $ CaseSplitError $ P.text $+ "Cannot split on variable " ++ s +++ ", because it is an equality proof bound by a with-abstraction"+ -- failInstantiatedVar s v = interactionError . CaseSplitError =<< sep+ -- [ text $ "Cannot split on variable " ++ s ++ ", because it is bound to"+ -- , prettyTCM v+ -- ]+ failCaseLet s = interactionError $ CaseSplitError $ P.text $+ "Cannot split on variable " ++ s +++ ", because let-declarations may not be defined by pattern-matching"++++-- | Lookup the clause for an interaction point in the signature.+-- Returns the CaseContext, the previous clauses, the clause itself,+-- and a list of the remaining ones.++type ClauseZipper =+ ( [Clause] -- previous clauses+ , Clause -- clause of interest+ , [Clause] -- other clauses+ )++getClauseZipperForIP :: QName -> Int -> TCM (CaseContext, ClauseZipper)+getClauseZipperForIP f clauseNo = do+ (theDef <$> getConstInfo f) >>= \case+ Function{funClauses = cs, funExtLam = extlam} -> do+ let (cs1,ccs2) = fromMaybe __IMPOSSIBLE__ $ splitExactlyAt clauseNo cs+ (c,cs2) = fromMaybe __IMPOSSIBLE__ $ uncons ccs2+ return (extlam, (cs1, c, cs2))+ d -> do+ reportSDoc "impossible" 10 $ vcat+ [ "getClauseZipperForIP" <+> prettyTCM f <+> text (show clauseNo)+ <+> "received"+ , text (show d)+ ]+ __IMPOSSIBLE__++recheckAbstractClause :: Type -> IsWithFunction Substitution -> A.SpineClause -> TCM (Clause, Context, [AsBinding])+recheckAbstractClause t sub acl = checkClauseLHS t sub acl $ \ lhs -> do+ let cl = Clause { clauseLHSRange = getRange acl+ , clauseFullRange = getRange acl+ , clauseTel = lhsVarTele lhs+ , namedClausePats = lhsPatterns lhs+ , clauseBody = Nothing -- We don't need the body for make case+ , clauseType = Just (lhsBodyType lhs)+ , clauseCatchall = empty+ , clauseRecursive = MaybeRecursive+ , clauseUnreachable = Nothing+ , clauseEllipsis = lhsEllipsis $ A.spLhsInfo $ A.clauseLHS acl+ , clauseWhereModule = A.whereModule $ A.clauseWhereDecls acl+ }+ cxt <- getContext+ let asb = lhsAsBindings lhs+ return (cl, cxt, asb)+++-- | Entry point for case splitting tactic.++makeCase :: InteractionId -> Range -> String -> TCM (QName, CaseContext, [A.Clause])+makeCase hole rng s = withInteractionId hole $ locallyTC eMakeCase (const True) $ do++ -- Jesper, 2018-12-10: print unsolved metas in dot patterns as _+ localTC (set ePrintMetasBare True) do++ -- Get function clause which contains the interaction point.+ InteractionPoint { ipMeta = mm, ipClause = ipCl} <- lookupInteractionPoint hole+ (f, clauseNo, clTy, clWithSub, absCl@A.Clause{ clauseRHS = rhs }, clClos) <- case ipCl of+ IPClause f i t sub cl clo -> return (f, i, t, sub, cl, clo)+ IPNoClause -> interactionError $ CaseSplitError $+ "Cannot split here, as we are not in a function definition"+ (casectxt, (prevClauses0, _clause, follClauses0)) <- getClauseZipperForIP f clauseNo++ -- Instead of using the actual internal clause, we retype check the abstract clause (with+ -- eMakeCase = True). This disables the forcing translation in the unifier, which allows us to+ -- split on forced variables.+ (clause, clauseCxt, clauseAsBindings) <-+ enterClosure clClos $ \ _ -> locallyTC eMakeCase (const True) $+ recheckAbstractClause clTy clWithSub absCl++ let (prevClauses, follClauses) = killRange (prevClauses0, follClauses0)+ -- Andreas, 2019-08-08, issue #3966+ -- Kill the ranges of the existing clauses to prevent wrong error+ -- location to be set by the coverage checker (via isCovered)+ -- for test/Interaction/Issue191++ -- See below, CLEAN UP OF THE GENERATED CLAUSES+ let+ filterOutExistingClauses :: [(SplitClause,a)] -> TCM [(SplitClause,a)]+ filterOutExistingClauses scs = do+ -- 1. filter out the generated clauses that are already covered+ -- we consider a generated clause already covered if it is covered by:+ -- a. a pre-existing clause defined before the one we splitted (prevClauses)+ -- b. a pre-existing clause defined after the one we splitted (follClauses)+ -- under the condition that it did not cover the one we splitted but was+ -- covered by it (i.e. it was considered unreachable).+ -- The key idea here is:+ -- f m zero = ? ---- split on m ---> f (suc m) zero = ?+ -- f zero zero = ? f zero zero = ?+ -- f _ _ = ? f _ _ = ?+ -- because [f zero zero] is already defined.+ -- However we ignore [f _ _]: [f m zero] was already a refinement of it,+ -- hinting that we considered it more important than the catchall.+ reportSDoc "interaction.case.filter" 20 $ vcat+ [ "prevClauses:"+ , nest 2 $ vcat $ map prettyTCM prevClauses+ ]+ let sclause = clauseToSplitClause clause+ fcs <- filterM (\ cl -> (isCovered f [clause] (clauseToSplitClause cl)) `and2M`+ (not <$> isCovered f [cl] sclause))+ follClauses+ filterM (not <.> isCovered f (prevClauses ++ fcs) . fst) scs++ let perm = fromMaybe __IMPOSSIBLE__ $ clausePerm clause+ tel = clauseTel clause+ ps = namedClausePats clause+ ell = clauseEllipsis clause+ reportSDoc "interaction.case" 100 $ vcat+ [ "splitting clause:"+ , nest 2 $ vcat+ [ "f =" <+> (text . show) f+ , "context =" <+> ((inTopContext . (text . show)) =<< getContextTelescope)+ , "tel =" <+> (text . show) tel+ , "perm =" <+> text (show perm)+ , "ps =" <+> (text . show) ps+ ]+ ]+ reportSDoc "interaction.case" 60 $ vcat+ [ "splitting clause:"+ , nest 2 $ vcat+ [ "f =" <+> pretty f+ , "context =" <+> ((inTopContext . pretty) =<< getContextTelescope)+ , "tel =" <+> pretty tel+ , "perm =" <+> (text . show) perm+ , "ps =" <+> pretty ps+ ]+ ] reportSDoc "interaction.case" 10 $ vcat- [ text "splitting clause:"+ [ "splitting clause:" , nest 2 $ vcat- [ text "f =" <+> prettyTCM f- , text "context =" <+> (prettyTCM =<< getContextTelescope)- , text "tel =" <+> prettyTCM tel- , text "perm =" <+> text (show perm)- , text "ps =" <+> text (show ps)+ [ "f =" <+> prettyTCM f+ , "context =" <+> ((inTopContext . prettyTCM) =<< getContextTelescope)+ , "tel =" <+> (inTopContext . prettyTCM) tel+ , "perm =" <+> text (show perm)+ , "ps =" <+> addContext tel (prettyTCMPatternList ps)+ , "ell =" <+> text (show ell)+ , "type =" <+> addContext tel (prettyTCM $ clauseType clause) ] ]- var <- deBruijnIndex =<< parseExprIn hole rng s- z <- splitClauseWithAbs clause var- (case z of- Left err -> typeError . GenericError . show =<< prettyTCM err- Right (Left cl) -> ((:[]) <$> makeAbsurdClause f cl)- Right (Right c) -> (mapM (makeAbstractClause f) c)) >>= (\ x -> return (casectxt , x)) -makeAbsurdClause :: QName -> SplitClause -> TCM A.Clause-makeAbsurdClause f (SClause tel perm ps _) = do+ -- Check split variables.++ let vars = words s++ -- If the user just entered ".", do nothing.+ -- This will expand an ellipsis, if present.++ if concat vars == "." then do+ cl <- makeAbstractClause f rhs NoEllipsis $ clauseToSplitClause clause+ return (f, casectxt, [cl])++ -- If we have no split variables, split on result.++ else if null vars then do+ -- Andreas, 2017-07-24, issue #2654:+ -- When we introduce projection patterns in an extended lambda,+ -- we need to print them postfix.+ let postProjInExtLam = applyWhen (isJust casectxt) $+ withPragmaOptions $ set (lensOptPostfixProjections . lensKeepDefault) True+ (piTel, sc) <- insertTrailingArgs False $ clauseToSplitClause clause+ -- Andreas, 2015-05-05 If we introduced new function arguments+ -- do not split on result. This might be more what the user wants.+ -- To split on result, he can then C-c C-c again.+ -- Andreas, 2015-05-21 Issue 1516: However, if only hidden+ -- arguments are introduced, C-c C-c virtually does nothing+ -- (as they are not shown and get lost on the way to emacs and back).+ newPats <- if null piTel then return False else do+ -- If there were any pattern introduce, they will only have effect+ -- if any of them is shown by the printer+ imp <- optShowImplicit <$> pragmaOptions+ return $ imp || any visible (telToList piTel)+ scs <- if newPats then pure [sc] else postProjInExtLam $ do+ res <- splitResult f sc+ case res of++ Left err -> do+ -- Andreas, 2017-12-16, issue #2871+ -- If there is nothing to split, introduce trailing hidden arguments.++ -- Get trailing hidden pattern variables+ let trailingPatVars :: [NamedArg DBPatVar]+ trailingPatVars = takeWhileJust isVarP $ reverse ps+ isVarP (Arg ai (Named n (VarP _ x))) = Just $ Arg ai $ Named n x+ isVarP _ = Nothing+ -- If all are already coming from the user, there is really nothing todo!+ when (all ((UserWritten ==) . getOrigin) trailingPatVars) $ do+ typeError $ SplitError err+ -- Otherwise, we make these user-written+ let xs = map (dbPatVarIndex . namedArg) trailingPatVars+ return [makePatternVarsVisible [] xs sc]++ Right cov -> ifNotM (optCopatterns <$> pragmaOptions) failNoCop $ {-else-} do+ -- Andreas, 2016-05-03: do not introduce function arguments after projection.+ -- This is sometimes annoying and can anyway be done by another C-c C-c.+ -- mapM (snd <.> fixTarget) $ splitClauses cov+ return cov+ checkClauseIsClean ipCl+ (f, casectxt,) <$> do+ -- Andreas, 2020-05-18, issue #4536+ -- When result splitting yields no clauses, replace rhs by @record{}@.+ if null scs then+ return [ A.spineToLhs $ absCl{ A.clauseRHS = makeRHSEmptyRecord rhs } ]+ else do+ scs <- map fst <$> filterOutExistingClauses (map (, ()) scs)+ mapM (makeAbstractClause f rhs ell) scs+ else do+ -- split on variables+ xs <- parseVariables f clauseCxt clauseAsBindings hole rng vars+ reportSLn "interaction.case" 30 $ "parsedVariables: " ++ show (zip xs vars)+ -- Variables that are not in scope yet are brought into scope (@toShow@)+ -- The other variables are split on (@toSplit@).+ let (toDotP, toShow, toSplit) = mapEither3 splitActionToEither3 xs+ let sc0 = clauseToSplitClause clause+ let sc = makePatternVarsVisible toDotP toShow sc0+ reportSLn "interaction.case" 30 $ "toDot = " ++ prettyShow toDotP+ reportSLn "interaction.case" 30 $ "splitclause before makePatternVarsVisible: " ++ prettyShow sc0+ reportSLn "interaction.case" 30 $ "splitclause after: " ++ prettyShow sc+ reportSLn "interaction.case" 60 $ "splitclause before makePatternVarsVisible: " ++ show (killRange $ scPats sc0)+ reportSLn "interaction.case" 60 $ "splitclause after: " ++ show (killRange $ scPats sc)+ scs <- split f toSplit sc+ reportSLn "interaction.case" 70 $ "makeCase: survived the splitting"++ -- If any of the split variables is hidden by the ellipsis, we+ -- should force the expansion of the ellipsis.+ let splitNames =+ map (ctxEntryName . fromMaybe __IMPOSSIBLE__ . (`cxLookup` clauseCxt))+ toSplit+ shouldExpandEllipsis <- return (not $ null toShow) `or2M` anyEllipsisVar f absCl splitNames+ let ell' | shouldExpandEllipsis = NoEllipsis+ | otherwise = ell++ -- CLEAN UP OF THE GENERATED CLAUSES+ -- 1. filter out the generated clauses that are already covered+ -- we consider a generated clause already covered if it is covered by:+ -- a. a pre-existing clause defined before the one we splitted (prevClauses)+ -- b. a pre-existing clause defined after the one we splitted (follClauses)+ -- under the condition that it did not cover the one we splitted but was+ -- covered by it (i.e. it was considered unreachable).+ -- The key idea here is:+ -- f m zero = ? ---- split on m ---> f (suc m) zero = ?+ -- f zero zero = ? f zero zero = ?+ -- f _ _ = ? f _ _ = ?+ -- because [f zero zero] is already defined.+ -- However we ignore [f _ _]: [f m zero] was already a refinement of it,+ -- hinting that we considered it more important than the catchall.+ scs <- filterOutExistingClauses scs+ reportSLn "interaction.case" 70 $ "makeCase: survived filtering out already covered clauses"+ -- 2. filter out trivially impossible clauses not asked for by the user+ cs <- catMaybes <$> do+ forM scs $ \ (sc, isAbsurd) -> if isAbsurd+ -- absurd clause coming from a split asked for by the user+ then Just <$> makeAbsurdClause f ell' sc+ -- trivially empty clause due to the refined patterns+ else+ ifM (liftTCM $ (optInferAbsurdClauses <$> pragmaOptions) `and2M` isEmptyTel (scTel sc))+ {- then -} (pure Nothing)+ {- else -} (Just <$> makeAbstractClause f rhs ell' sc)+ reportSLn "interaction.case" 70 $ "makeCase: survived filtering out impossible clauses"+ -- 3. If the cleanup removed everything then we know that none of the clauses where+ -- absurd but that all of them were trivially empty. In this case we rewind and+ -- insert all the clauses (garbage in, garbage out!)+ cs <- if not (null cs) then pure cs+ else mapM (makeAbstractClause f rhs ell' . fst) scs++ reportSDoc "interaction.case" 65 $ vcat+ [ "split result:"+ , nest 2 $ vcat $ map prettyA cs+ ]+ checkClauseIsClean ipCl+ return (f, casectxt, cs)++ where+ failNoCop = interactionError $ CaseSplitError $+ "OPTION --copatterns needed to split on result here"++ -- Split clause on given variables, return the resulting clauses together+ -- with a bool indicating whether each clause is absurd+ split :: QName -> [Nat] -> SplitClause -> TCM [(SplitClause, Bool)]+ split f [] clause = return [(clause,False)]+ split f (var : vars) clause = do+ z <- dontAssignMetas $ splitClauseWithAbsurd clause var+ case z of+ Left err -> typeError $ SplitError err+ Right (Left cl) -> return [(cl,True)]+ Right (Right cov) -> concat <$> do+ forM (splitClauses cov) $ \ cl ->+ split f (mapMaybe (newVar cl) vars) cl++ -- Finds the new variable corresponding to an old one, if any.+ newVar :: SplitClause -> Nat -> Maybe Nat+ newVar c x = case applySplitPSubst (scSubst c) (var x) of+ Var y [] -> Just y+ _ -> Nothing++ -- Check whether clause has been refined after last load.+ -- In this case, we refuse to split, as this might lose the refinements.+ checkClauseIsClean :: IPClause -> TCM ()+ checkClauseIsClean ipCl = do+ sips <- filter ipSolved . BiMap.elems <$> useTC stInteractionPoints+ when (List.any ((== ipCl) . ipClause) sips) $+ interactionError $ CaseSplitError $ "Cannot split as clause rhs has been refined. Please reload"++-- | Make the given pattern variables visible by marking their origin as+-- 'CaseSplit' and pattern origin as 'PatOSplit' in the 'SplitClause'.+makePatternVarsVisible :: [Name] -> [Nat] -> SplitClause -> SplitClause+makePatternVarsVisible xs is sc@SClause{ scPats = ps } =+ sc{ scPats = mapNamedArgPattern mkVis ps }+ where+ mkVis :: NamedArg SplitPattern -> NamedArg SplitPattern+ mkVis (Arg ai (Named n (VarP o (SplitPatVar x i ls))))+ | i `elem` is =+ -- We could introduce extra consistency checks, like+ -- if visible ai then __IMPOSSIBLE__ else+ -- or passing the parsed name along and comparing it with @x@+ Arg (setOrigin CaseSplit ai) $ Named n $ VarP (PatternInfo PatOSplit []) $ SplitPatVar x i ls+ mkVis (Arg ai (Named n (DotP (PatternInfo (PatOVar x) _) v)))+ | x `elem` xs = Arg ai (Named n (DotP (PatternInfo PatOSplit []) v))+ mkVis np = np++-- | If a copattern split yields no clauses, we must be at an empty record type.+-- In this case, replace the rhs by @record{}@+makeRHSEmptyRecord :: A.RHS -> A.RHS+makeRHSEmptyRecord = \case+ A.RHS{} -> A.RHS{ rhsExpr = A.Rec empty empty empty, rhsConcrete = Nothing }+ rhs@A.RewriteRHS{} -> rhs{ A.rewriteRHS = makeRHSEmptyRecord $ A.rewriteRHS rhs }+ A.AbsurdRHS -> __IMPOSSIBLE__+ A.WithRHS{} -> __IMPOSSIBLE__++-- | Make clause with no rhs (because of absurd match).++makeAbsurdClause :: QName -> ExpandedEllipsis -> SplitClause -> TCM A.Clause+makeAbsurdClause f ell (SClause tel sps _ _ t) = do+ showImp <- showImplicitArguments+ let+ ps = fromSplitPatterns sps+ ps' = applyWhen showImp filterOutGeneralizedVarPatterns ps+ -- Internal clause+ cl = Clause+ { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = tel+ , namedClausePats = ps'+ , clauseBody = Nothing+ , clauseType = argFromDom <$> t+ , clauseCatchall = empty+ , clauseRecursive = MaybeRecursive+ , clauseUnreachable = Nothing+ , clauseEllipsis = ell+ , clauseWhereModule = Nothing+ } reportSDoc "interaction.case" 10 $ vcat- [ text "Interaction.MakeCase.makeCase: split clause:"+ [ "Interaction.MakeCase.makeAbsurdClause: split clause:" , nest 2 $ vcat- [ text "context =" <+> (prettyTCM =<< getContextTelescope)- , text "tel =" <+> prettyTCM tel- , text "perm =" <+> text (show perm)- , text "ps =" <+> text (show ps)+ [ "context =" <+> do (inTopContext . prettyTCM) =<< getContextTelescope+ , "tel =" <+> do inTopContext $ prettyTCM tel+ , "ps =" <+> do inTopContext $ addContext tel $ prettyTCMPatternList ps -- P.sep <$> prettyTCMPatterns ps+ , "ps' =" <+> do inTopContext $ addContext tel $ prettyTCMPatternList ps'+ , "ell =" <+> text (show ell) ] ]- withCurrentModule (qnameModule f) $ do- -- Normalise the dot patterns- ps <- addCtxTel tel $ normalise ps- inContext [] $ reify $ NamedClause f $ Clause noRange tel perm ps NoBody+ reportSDoc "interaction.case" 10 $+ nest 2 $ vcat+ [ "ps (raw)=" <+> text (show ps)+ ]+ withCurrentModule (qnameModule f) $+ inTopContext $ reify $ QNamed f cl -makeAbstractClause :: QName -> SplitClause -> TCM A.Clause-makeAbstractClause f cl = do- A.Clause lhs _ _ <- makeAbsurdClause f cl- return $ mkClause lhs+-- | Drop hidden patterns introduced by generalization with an unparsable name.+-- If we drop one, we need to make the next non-dropped hidden pattern named.+filterOutGeneralizedVarPatterns :: [NamedArg DeBruijnPattern] -> [NamedArg DeBruijnPattern]+filterOutGeneralizedVarPatterns = go False where- mkClause :: A.LHS -> A.Clause- mkClause lhs = A.Clause lhs (A.RHS $ A.QuestionMark info) []- where- info = A.MetaInfo noRange emptyScopeInfo Nothing+ go b [] = []+ go b (p : ps)+ | maybe False (isGeneralizedVarName . prettyShow) (getNameOf p) = go True ps+ | otherwise = applyWhen (b && getHiding p == Hidden) makeNamedArgUserWritten p : go False ps -deBruijnIndex :: A.Expr -> TCM Nat-deBruijnIndex e = do- (v, _) <- -- Andreas, 2010-09-21 allow splitting on irrelevant (record) vars--- Context.wakeIrrelevantVars $- applyRelevanceToContext Irrelevant $- inferExpr e- case v of- Var n _ -> return n- _ -> typeError . GenericError . show =<< (fsep $- pwords "The scrutinee of a case distinction must be a variable,"- ++ [ prettyTCM v ] ++ pwords "isn't.")+makeNamedArgUserWritten :: NamedArg a -> NamedArg a+makeNamedArgUserWritten (Arg info (Named n a)) = Arg info (Named (setOrigin UserWritten <$> n) a)++-- | Unparseable variable names are those that contain a '.'.+isGeneralizedVarName :: PatVarName -> Bool+isGeneralizedVarName = elem '.'++-- | Make a clause with a question mark as rhs.++makeAbstractClause :: QName -> A.RHS -> ExpandedEllipsis -> SplitClause -> TCM A.Clause+makeAbstractClause f rhs ell cl = do++ lhs <- A.clauseLHS <$> makeAbsurdClause f ell cl+ reportSDoc "interaction.case" 60 $ "reified lhs: " <+> prettyA lhs+ return $ A.Clause lhs [] rhs A.noWhereDecls empty+ -- let ii = InteractionId (-1) -- Dummy interaction point since we never type check this.+ -- -- Can end up in verbose output though (#1842), hence not __IMPOSSIBLE__.+ -- let info = A.emptyMetaInfo -- metaNumber = Nothing in order to print as ?, not ?n+ -- return $ A.Clause lhs [] (A.RHS $ A.QuestionMark info ii) [] False++anyEllipsisVar :: QName -> A.SpineClause -> [Name] -> TCM Bool+anyEllipsisVar f cl xs = do+ let lhs = A.clauseLHS cl+ ps = A.spLhsPats lhs+ ell = lhsEllipsis $ A.spLhsInfo lhs+ anyVar :: A.Pattern -> Any -> Any+ anyVar p acc = Any $ getAny acc || case p of+ A.VarP x -> A.unBind x `elem` xs+ _ -> False+ case ell of+ NoEllipsis -> return False+ ExpandedEllipsis _ k -> do+ ps' <- snd <$> reifyDisplayFormP f ps []+ let ellipsisPats :: A.Patterns+ ellipsisPats = fst $ C.splitEllipsis k ps'+ reportSDoc "interaction.case.ellipsis" 40 $ vcat+ [ "should we expand the ellipsis?"+ , nest 2 $ "xs =" <+> prettyList_ (map prettyA xs)+ , nest 2 $ "ellipsisPats =" <+> prettyList_ (map prettyA ellipsisPats)+ ]+ return $ getAny $ A.foldrAPattern anyVar ellipsisPats
@@ -1,26 +1,49 @@-{-# LANGUAGE TypeSynonymInstances, FlexibleInstances,- MultiParamTypeClasses #-}-module Agda.Interaction.Monad where+{-# OPTIONS_GHC -Wunused-imports #-} -import Agda.TypeChecking.Monad+{-# OPTIONS_GHC -fwarn-orphans #-}+{-# LANGUAGE CPP #-} -import Control.Monad.Trans-import Control.Monad.Error-import System.Console.Haskeline+module Agda.Interaction.Monad+ ( IM+ , runIM+ , readline+ ) where +import Control.Exception (throwIO)+import Control.Monad.Except (MonadError (..))+import Control.Monad.Trans (MonadIO, lift, liftIO)+import qualified System.Console.Haskeline as Haskeline+import qualified Control.Monad.Catch as Haskeline (catch)++import Agda.TypeChecking.Monad+ ( HasOptions+ , MonadFileId+ , MonadTCEnv+ , MonadTCM+ , MonadTCState+ , ReadTCState+ , TCErr+ , type TCM, pattern TCM, TCMT, unTCM+ , mapTCMT+ )+ -- | Interaction monad.+newtype IM a = IM {unIM :: TCMT (Haskeline.InputT IO) a}+ deriving+ ( Functor, Applicative, Monad, MonadIO+ , HasOptions, MonadTCEnv, ReadTCState, MonadTCState, MonadTCM+ , MonadFileId+ ) -type IM = TCMT (InputT IO)+runIM :: IM a -> TCM a+runIM = mapTCMT (Haskeline.runInputT Haskeline.defaultSettings) . unIM instance MonadError TCErr IM where- throwError = liftIO . throwIO- catchError m h = mapTCMT liftIO $ runIM m `catchError` (runIM . h)+ throwError = liftIO . throwIO+ catchError (IM (TCM m)) h = IM . TCM $ \s e ->+ m s e `Haskeline.catch` \err -> unTCM (unIM (h err)) s e -- | Line reader. The line reader history is not stored between -- sessions.- readline :: String -> IM (Maybe String)-readline s = lift (getInputLine s)--runIM :: IM a -> TCM a-runIM = mapTCMT (runInputT defaultSettings)+readline s = IM $ lift (Haskeline.getInputLine s)
@@ -1,452 +1,11 @@-{-# LANGUAGE StandaloneDeriving, DeriveFunctor #-}+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Interaction.Options- ( CommandLineOptions(..)- , PragmaOptions(..)- , OptionsPragma- , Flag- , Verbosity- , checkOpts- , parseStandardOptions- , parsePragmaOptions- , parsePluginOptions- , defaultOptions- , defaultVerbosity- , standardOptions_- , unsafePragmaOptions- , isLiterate- , mapFlag- , usage- , tests+ ( module Agda.Interaction.Options.Base+ , module Agda.Interaction.Options.HasOptions+ , module Agda.Interaction.Options.Types ) where -import Control.Monad ( when )-import Control.Monad.Error ( MonadError(..) )-import Data.Maybe (isJust)-import Data.List ( isSuffixOf , intercalate )-import System.Console.GetOpt (getOpt, usageInfo, ArgOrder(ReturnInOrder)- , OptDescr(..), ArgDescr(..)- )-import Agda.Utils.TestHelpers ( runTests )-import Agda.Utils.QuickCheck ( quickCheck' )-import Agda.Utils.FileName ( AbsolutePath )-import Agda.Utils.Monad ( readM )-import Agda.Utils.List ( wordsBy )-import Agda.Utils.String ( indent )-import Agda.Utils.Trie ( Trie )-import qualified Agda.Utils.Trie as Trie---- | This should probably go somewhere else.-isLiterate :: FilePath -> Bool-isLiterate file = ".lagda" `isSuffixOf` file---- OptDescr is a Functor ----------------------------------------------------deriving instance Functor OptDescr-deriving instance Functor ArgDescr--type Verbosity = Trie String Int--data CommandLineOptions =- Options { optProgramName :: String- , optInputFile :: Maybe FilePath- , optIncludeDirs :: Either [FilePath] [AbsolutePath]- -- ^ 'Left' is used temporarily, before the paths have- -- been made absolute. An empty 'Left' list is- -- interpreted as @["."]@ (see- -- 'Agda.TypeChecking.Monad.Options.makeIncludeDirsAbsolute').- , optShowVersion :: Bool- , optShowHelp :: Bool- , optInteractive :: Bool- , optRunTests :: Bool- , optCompile :: Bool- , optEpicCompile :: Bool- , optJSCompile :: Bool- , optCompileDir :: Maybe FilePath- -- ^ In the absence of a path the project root is used.- , optGenerateVimFile :: Bool- , optGenerateHTML :: Bool- , optDependencyGraph :: Maybe FilePath- , optHTMLDir :: FilePath- , optCSSFile :: Maybe FilePath- , optIgnoreInterfaces :: Bool- , optForcing :: Bool- , optGhcFlags :: [String]- , optPragmaOptions :: PragmaOptions- , optEpicFlags :: [String]- , optSafe :: Bool- }- deriving Show---- | Options which can be set in a pragma.--data PragmaOptions = PragmaOptions- { optShowImplicit :: Bool- , optVerbose :: Verbosity- , optProofIrrelevance :: Bool- , optAllowUnsolved :: Bool- , optDisablePositivity :: Bool- , optTerminationCheck :: Bool- , optTerminationDepth :: Int- , optCompletenessCheck :: Bool- , optUniverseCheck :: Bool- , optSizedTypes :: Bool- , optInjectiveTypeConstructors :: Bool- , optGuardingTypeConstructors :: Bool- , optUniversePolymorphism :: Bool- , optIrrelevantProjections :: Bool- , optExperimentalIrrelevance :: Bool -- ^ irrelevant levels, irrelevant data matching- , optWithoutK :: Bool- }- deriving Show---- | The options from an @OPTIONS@ pragma.------ In the future it might be nice to switch to a more structured--- representation. Note that, currently, there is not a one-to-one--- correspondence between list elements and options.-type OptionsPragma = [String]---- | Map a function over the long options. Also removes the short options.--- Will be used to add the plugin name to the plugin options.-mapFlag :: (String -> String) -> OptDescr a -> OptDescr a-mapFlag f (Option _ long arg descr) = Option [] (map f long) arg descr--defaultVerbosity :: Verbosity-defaultVerbosity = Trie.singleton [] 1--defaultOptions :: CommandLineOptions-defaultOptions =- Options { optProgramName = "agda"- , optInputFile = Nothing- , optIncludeDirs = Left []- , optShowVersion = False- , optShowHelp = False- , optInteractive = False- , optRunTests = False- , optCompile = False- , optEpicCompile = False- , optJSCompile = False- , optCompileDir = Nothing- , optGenerateVimFile = False- , optGenerateHTML = False- , optDependencyGraph = Nothing- , optHTMLDir = defaultHTMLDir- , optCSSFile = Nothing- , optIgnoreInterfaces = False- , optForcing = True- , optGhcFlags = []- , optPragmaOptions = defaultPragmaOptions- , optEpicFlags = []- , optSafe = False- }--defaultPragmaOptions :: PragmaOptions-defaultPragmaOptions = PragmaOptions- { optShowImplicit = False- , optVerbose = defaultVerbosity- , optProofIrrelevance = False- , optExperimentalIrrelevance = False- , optIrrelevantProjections = True- , optAllowUnsolved = False- , optDisablePositivity = False- , optTerminationCheck = True- , optTerminationDepth = 0 -- this is the cutoff value- , optCompletenessCheck = True- , optUniverseCheck = True- , optSizedTypes = False- , optInjectiveTypeConstructors = False- , optGuardingTypeConstructors = False- , optUniversePolymorphism = True- , optWithoutK = False- }---- | The default output directory for HTML.--defaultHTMLDir = "html"--prop_defaultOptions = case checkOpts defaultOptions of- Left _ -> False- Right _ -> True--{- | @f :: Flag opts@ is an action on the option record that results from- parsing an option. @f opts@ produces either an error message or an- updated options record--}-type Flag opts = opts -> Either String opts---- | Checks that the given options are consistent.--checkOpts :: Flag CommandLineOptions-checkOpts opts- | not (atMostOne [optAllowUnsolved . p, optCompile]) = Left- "Unsolved meta variables are not allowed when compiling.\n"- | not (atMostOne [optInteractive, optCompile, optEpicCompile, optJSCompile]) =- Left "Choose at most one: compiler/interactive mode.\n"- | not (atMostOne [optGenerateHTML, optInteractive]) =- Left "Choose at most one: HTML generator or interactive mode.\n"- | not (atMostOne [isJust . optDependencyGraph, optInteractive]) =- Left "Choose at most one: Dependency graph generator or interactive mode.\n"- | not (atMostOne [ optUniversePolymorphism . p- , not . optUniverseCheck . p- ]) =- Left "Cannot have both universe polymorphism and type in type.\n"- | (not . null . optEpicFlags $ opts)- && not (optEpicCompile opts) =- Left "Cannot set Epic flags without using the Epic backend.\n"- | otherwise = Right opts- where- atMostOne bs = length (filter ($ opts) bs) <= 1-- p = optPragmaOptions---- Check for unsafe pramas. Gives a list of used unsafe flags.--unsafePragmaOptions :: PragmaOptions -> [String]-unsafePragmaOptions opts =- [ "--allow-unsolved-metas" | optAllowUnsolved opts ] ++- [ "--no-positivity-check" | optDisablePositivity opts ] ++- [ "--no-termination-check" | not (optTerminationCheck opts) ] ++- [ "--no-coverage-check" | not (optCompletenessCheck opts) ] ++- [ "--type-in-type" | not (optUniverseCheck opts) ] ++- [ "--sized-types" | optSizedTypes opts ] ++- [ "--injective-type-constructors" | optInjectiveTypeConstructors opts ] ++- [ "--guardedness-preserving-type-constructors" | optGuardingTypeConstructors opts ] ++- [ "--experimental-irrelevance" | optExperimentalIrrelevance opts ]---- The default pragma options should be considered safe--defaultPragmaOptionsSafe :: IO Bool-defaultPragmaOptionsSafe- | null unsafe = return True- | otherwise = do putStrLn $ "Following pragmas are default but not safe: "- ++ intercalate ", " unsafe- return False- where unsafe = unsafePragmaOptions defaultPragmaOptions--inputFlag :: FilePath -> Flag CommandLineOptions-inputFlag f o =- case optInputFile o of- Nothing -> return $ o { optInputFile = Just f }- Just _ -> throwError "only one input file allowed"--versionFlag o = return $ o { optShowVersion = True }-helpFlag o = return $ o { optShowHelp = True }-safeFlag o = return $ o { optSafe = True }-proofIrrelevanceFlag o = return $ o { optProofIrrelevance = True }-experimentalIrrelevanceFlag o = return $ o { optExperimentalIrrelevance = True }-noIrrelevantProjectionsFlag o = return $ o { optIrrelevantProjections = False }-ignoreInterfacesFlag o = return $ o { optIgnoreInterfaces = True }-allowUnsolvedFlag o = return $ o { optAllowUnsolved = True }-showImplicitFlag o = return $ o { optShowImplicit = True }-runTestsFlag o = return $ o { optRunTests = True }-vimFlag o = return $ o { optGenerateVimFile = True }-noPositivityFlag o = return $ o { optDisablePositivity = True }-dontTerminationCheckFlag o = return $ o { optTerminationCheck = False }-dontCompletenessCheckFlag o = return $ o { optCompletenessCheck = False }-dontUniverseCheckFlag o = return $ o { optUniverseCheck = False- , optUniversePolymorphism = False }-sizedTypes o = return $ o { optSizedTypes = True }-injectiveTypeConstructorFlag o = return $ o { optInjectiveTypeConstructors = True }-guardingTypeConstructorFlag o = return $ o { optGuardingTypeConstructors = True }-universePolymorphismFlag o = return $ o { optUniversePolymorphism = True }-noUniversePolymorphismFlag o = return $ o { optUniversePolymorphism = False }-noForcingFlag o = return $ o { optForcing = False }-withoutKFlag o = return $ o { optWithoutK = True }--interactiveFlag o = return $ o { optInteractive = True- , optPragmaOptions = (optPragmaOptions o)- { optAllowUnsolved = True }- }-compileFlag o = return $ o { optCompile = True }-compileEpicFlag o = return $ o { optEpicCompile = True}-compileJSFlag o = return $ o { optJSCompile = True}-compileDirFlag f o = return $ o { optCompileDir = Just f }-ghcFlag f o = return $ o { optGhcFlags = f : optGhcFlags o }-epicFlagsFlag s o = return $ o { optEpicFlags = optEpicFlags o ++ [s]}--htmlFlag o = return $ o { optGenerateHTML = True }-dependencyGraphFlag f o = return $ o { optDependencyGraph = Just f }-htmlDirFlag d o = return $ o { optHTMLDir = d }-cssFlag f o = return $ o { optCSSFile = Just f }--includeFlag d o = return $ o { optIncludeDirs = Left (d : ds) }- where ds = either id (const []) $ optIncludeDirs o--verboseFlag s o =- do (k,n) <- parseVerbose s- return $ o { optVerbose = Trie.insert k n $ optVerbose o }- where- parseVerbose s = case wordsBy (`elem` ":.") s of- [] -> usage- ss -> do- n <- readM (last ss) `catchError` \_ -> usage- return (init ss, n)- usage = throwError "argument to verbose should be on the form x.y.z:N or N"--terminationDepthFlag s o =- do k <- readM s `catchError` \_ -> usage- when (k < 1) $ usage -- or: turn termination checking off for 0- return $ o { optTerminationDepth = k-1 }- where usage = throwError "argument to termination-depth should be >= 1"--integerArgument :: String -> String -> Either String Int-integerArgument flag s =- readM s `catchError` \_ ->- throwError $ "option '" ++ flag ++ "' requires an integer argument"--standardOptions :: [OptDescr (Flag CommandLineOptions)]-standardOptions =- [ Option ['V'] ["version"] (NoArg versionFlag) "show version number"- , Option ['?'] ["help"] (NoArg helpFlag) "show this help"- , Option ['I'] ["interactive"] (NoArg interactiveFlag)- "start in interactive mode"- , Option ['c'] ["compile"] (NoArg compileFlag)- "compile program using the MAlonzo backend (experimental)"- , Option [] ["epic"] (NoArg compileEpicFlag) "compile program using the Epic backend"- , Option [] ["js"] (NoArg compileJSFlag) "compile program using the JS backend"- , Option [] ["compile-dir"] (ReqArg compileDirFlag "DIR")- ("directory for compiler output (default: the project root)")- , Option [] ["ghc-flag"] (ReqArg ghcFlag "GHC-FLAG")- "give the flag GHC-FLAG to GHC when compiling using MAlonzo"- , Option [] ["epic-flag"] (ReqArg epicFlagsFlag "EPIC-FLAG")- "give the flag EPIC-FLAG to Epic when compiling using Epic"- , Option [] ["test"] (NoArg runTestsFlag)- "run internal test suite"- , Option [] ["vim"] (NoArg vimFlag)- "generate Vim highlighting files"- , Option [] ["html"] (NoArg htmlFlag)- "generate HTML files with highlighted source code"- , Option [] ["dependency-graph"] (ReqArg dependencyGraphFlag "FILE")- "generate a Dot file with a module dependency graph"- , Option [] ["html-dir"] (ReqArg htmlDirFlag "DIR")- ("directory in which HTML files are placed (default: " ++- defaultHTMLDir ++ ")")- , Option [] ["css"] (ReqArg cssFlag "URL")- "the CSS file used by the HTML files (can be relative)"- , Option [] ["ignore-interfaces"] (NoArg ignoreInterfacesFlag)- "ignore interface files (re-type check everything)"- , Option ['i'] ["include-path"] (ReqArg includeFlag "DIR")- "look for imports in DIR"- , Option [] ["no-forcing"] (NoArg noForcingFlag)- "disable the forcing optimisation"- , Option [] ["safe"] (NoArg safeFlag)- "disable postulates, unsafe OPTION pragmas and primTrustMe"- ] ++ map (fmap lift) pragmaOptions- where- lift :: Flag PragmaOptions -> Flag CommandLineOptions- lift f = \opts -> do- ps <- f (optPragmaOptions opts)- return (opts { optPragmaOptions = ps })--pragmaOptions :: [OptDescr (Flag PragmaOptions)]-pragmaOptions =- [ Option [] ["show-implicit"] (NoArg showImplicitFlag)- "show implicit arguments when printing"- , Option ['v'] ["verbose"] (ReqArg verboseFlag "N")- "set verbosity level to N"- -- , Option [] ["proof-irrelevance"] (NoArg proofIrrelevanceFlag)- -- "enable proof irrelevance (experimental feature)"- , Option [] ["allow-unsolved-metas"] (NoArg allowUnsolvedFlag)- "allow unsolved meta variables (only needed in batch mode)"- , Option [] ["no-positivity-check"] (NoArg noPositivityFlag)- "do not warn about not strictly positive data types"- , Option [] ["no-termination-check"] (NoArg dontTerminationCheckFlag)- "do not warn about possibly nonterminating code"- , Option [] ["termination-depth"] (ReqArg terminationDepthFlag "N")- "allow termination checker to count decrease/increase upto N (default N=1)"- , Option [] ["no-coverage-check"] (NoArg dontCompletenessCheckFlag)- "do not warn about possibly incomplete pattern matches"- , Option [] ["type-in-type"] (NoArg dontUniverseCheckFlag)- "ignore universe levels (this makes Agda inconsistent)"- , Option [] ["sized-types"] (NoArg sizedTypes)- "use sized types (inconsistent with coinduction)"- , Option [] ["injective-type-constructors"] (NoArg injectiveTypeConstructorFlag)- "enable injective type constructors (makes Agda anti-classical and possibly inconsistent)"- , Option [] ["guardedness-preserving-type-constructors"] (NoArg guardingTypeConstructorFlag)- "treat type constructors as inductive constructors when checking productivity"- , Option [] ["no-universe-polymorphism"] (NoArg noUniversePolymorphismFlag)- "disable universe polymorphism"- , Option [] ["universe-polymorphism"] (NoArg universePolymorphismFlag)- "enable universe polymorphism (default)"- , Option [] ["no-irrelevant-projections"] (NoArg noIrrelevantProjectionsFlag)- "disable projection of irrelevant record fields"- , Option [] ["experimental-irrelevance"] (NoArg experimentalIrrelevanceFlag)- "enable potentially unsound irrelevance features (irrelevant levels, irrelevant data matching)"- , Option [] ["without-K"] (NoArg withoutKFlag)- "disable the K rule (maybe)"- ]---- | Used for printing usage info.-standardOptions_ :: [OptDescr ()]-standardOptions_ = map (fmap $ const ()) standardOptions---- | Don't export-parseOptions' ::- [String] -> [OptDescr (Flag opts)] -> (String -> Flag opts) -> Flag opts-parseOptions' argv opts fileArg = \defaults ->- case getOpt (ReturnInOrder fileArg) opts argv of- (o,_,[]) -> foldl (>>=) (return defaults) o- (_,_,errs) -> throwError $ concat errs---- | Parse the standard options.-parseStandardOptions :: [String] -> Either String CommandLineOptions-parseStandardOptions argv =- checkOpts =<<- parseOptions' argv standardOptions inputFlag defaultOptions---- | Parse options from an options pragma.-parsePragmaOptions- :: [String]- -- ^ Pragma options.- -> CommandLineOptions- -- ^ Command-line options which should be updated.- -> Either String PragmaOptions-parsePragmaOptions argv opts = do- ps <- parseOptions' argv pragmaOptions- (\s _ -> throwError $ "Bad option in pragma: " ++ s)- (optPragmaOptions opts)- checkOpts (opts { optPragmaOptions = ps })- return ps---- | Parse options for a plugin.-parsePluginOptions :: [String] -> [OptDescr (Flag opts)] -> Flag opts-parsePluginOptions argv opts =- parseOptions' argv opts- (\s _ -> throwError $- "Internal error: Flag " ++ s ++ " passed to a plugin")---- | The usage info message. The argument is the program name (probably--- agda).-usage :: [OptDescr ()] -> [(String, String, [String], [OptDescr ()])] -> String -> String-usage options pluginInfos progName =- usageInfo (header progName) options ++- "\nPlugins:\n" ++- indent 2 (concatMap pluginMsg pluginInfos)-- where- header progName = unlines [ "Agda"- , ""- , "Usage: " ++ progName ++ " [OPTIONS...] FILE"- ]-- pluginMsg (name, help, inherited, opts)- | null opts && null inherited = optHeader- | otherwise = usageInfo (optHeader ++- " Plugin-specific options:" ++- inheritedOptions inherited- ) opts- where- optHeader = "\n" ++ name ++ "-plugin:\n" ++ indent 2 help- inheritedOptions [] = ""- inheritedOptions pls =- "\n Inherits options from: " ++ unwords pls----------------------------------------------------------------------------- All tests--tests :: IO Bool-tests = runTests "Agda.Interaction.Options"- [ quickCheck' prop_defaultOptions- , defaultPragmaOptionsSafe- ]+import Agda.Interaction.Options.Base+import Agda.Interaction.Options.HasOptions+import Agda.Interaction.Options.Types
@@ -0,0 +1,102 @@+-- | Definitions and tools for arguments of command-line options.++module Agda.Interaction.Options.Arguments where++import Data.Map (Map)+import Data.Map qualified as Map++import Agda.Interaction.Options.Help (allHelpTopics)+import Agda.Interaction.Options.ProfileOptions (validProfileOptionStrings)+import Agda.Interaction.Options.Warnings (warningNameToString, warningSets)+import Agda.Setup.EmacsMode qualified as EmacsMode (setupFlag, compileFlag, locateFlag)++-- * Names of the arguments of options that have a finite enumeration.++-- | Print the possible values of an argument of the given type.+optionValues :: Map String [String]+optionValues = Map.fromList $+ ( colorArg , colorValues ) :+ ( emacsModeArg , emacsModeValues ) :+ ( helpArg , helpValues ) :+ ( profileArg , profileValues ) :+ ( traceImportsArg , traceImportsValues ) :+ ( warningArg , warningValues ) :+ ( erasedMatchesArg, erasedMatchesValues) :+ []++-- ** @--color@++-- | Argument to @--color@.+colorArg :: String+colorArg = "COLOR_MODE"++-- | Possible values for @--color@.+colorValues :: [String]+colorValues = [ "always", "auto", "never" ]++-- ** @--emacs-mode@++-- | Argument to @--emacs-mode@.+emacsModeArg :: String+emacsModeArg = "EMACS_MODE_COMMAND"++-- | Possible values for @--emacs-mode@.+emacsModeValues :: [String]+emacsModeValues = [EmacsMode.setupFlag, EmacsMode.compileFlag, EmacsMode.locateFlag]++-- ** @--erased-matches@++-- | The argument to @--erased-matches@.++erasedMatchesArg :: String+erasedMatchesArg = "MATCH_KINDS"++-- | Possible values for @--erased-matches@.++erasedMatchesValues :: [String]+erasedMatchesValues =+ ["none", "empty", "non-dependent", "restricted", "unrestricted"]++-- ** @--help@++-- | Argument to @--help@.+helpArg :: String+helpArg = "HELP_TOPIC"++-- | Possible values for @--help@.+helpValues :: [String]+helpValues = map fst allHelpTopics++-- ** @--profile@++-- | Argument to @--profile@.+profileArg :: String+profileArg = "TO_PROFILE"++-- | Possible values for @--profile@.+profileValues :: [String]+profileValues = validProfileOptionStrings++-- ** @--trace-imports@++-- | Argument to @--trace-imports@.+traceImportsArg :: String+traceImportsArg = "IMPORT_TRACING_LEVEL"++-- | Possible values for @--trace-imports@.+traceImportsValues :: [String]+traceImportsValues = [ show n | n <- [0..3] ]++-- ** @--warning@++-- | Argument to @--warning@.+warningArg :: String+warningArg = "WARNING"++-- | Possible values for @--warning@.+warningValues :: [String]+warningValues = concat $+ map fst warningSets :+ map (\ w -> [w, "no" ++ w]) ws+ where+ ws = "error" : map warningNameToString [minBound..maxBound]
@@ -0,0 +1,2225 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE PartialTypeSignatures #-}++{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wno-partial-type-signatures #-}+{-# OPTIONS_GHC -Wno-missing-signatures #-}++module Agda.Interaction.Options.Base+ ( CommandLineOptions(..)+ , PragmaOptions(..)+ , OptionError+ , OptionWarning(..), optionWarningName+ , Flag, OptM, runOptM, OptDescr(..), ArgDescr(..)+ , Verbosity, VerboseKey, VerboseLevel+ , ConfluenceCheck(..)+ , DiagnosticsColours(..)+ , EmacsModeCommand(..)+ , PrintAgdaVersion(..)+ , UnicodeOrAscii(..)+ , WarningMode(..)+ , checkOpts+ , parsePragmaOptions+ , parsePluginOptions+ , parseVerboseKey+ , stripRTS+ , defaultOptions+ , defaultInteractionOptions+ , defaultCutOff+ , defaultPragmaOptions+ , optionGroups+ , latexPragmaOptions+ , unsafePragmaOptions+ , recheckBecausePragmaOptionsChanged+ , InfectiveCoinfective(..)+ , InfectiveCoinfectiveOption(..)+ , infectiveCoinfectiveOptions+ , ImpliedPragmaOption(..)+ , impliedPragmaOptions+ , safeFlag+ , mapFlag+ -- Reused by PandocAgda+ , inputFlag+ , standardOptions, deadStandardOptions+ , getOptSimple+ -- * Lenses for 'PragmaOptions'+ , lensOptShowImplicit+ , lensOptShowIrrelevant+ , lensOptUseUnicode+ , lensOptVerbose+ , lensOptProfiling+ , lensOptIrrelevance+ , lensOptProp+ , lensOptLevelUniverse+ , lensOptTwoLevel+ , lensOptAllowUnsolved+ , lensOptAllowIncompleteMatch+ , lensOptPositivityCheck+ , lensOptTerminationCheck+ , lensOptTerminationDepth+ , lensOptUniverseCheck, lensOptNoUniverseCheck+ , lensOptOmegaInOmega+ , lensOptCumulativity+ , lensOptSizedTypes+ , lensOptGuardedness+ , lensOptInjectiveTypeConstructors+ , lensOptUniversePolymorphism+ , lensOptIrrelevantProjections+ , lensOptExperimentalIrrelevance+ , lensOptExperimentalLazyInstances+ , lensOptWithoutK+ , lensOptCubicalCompatible+ , lensOptCopatterns+ , lensOptPatternMatching+ , lensOptExactSplit+ , lensOptHiddenArgumentPuns+ , lensOptEta+ , lensOptForcing+ , lensOptProjectionLike+ , lensOptErasure+ , lensOptErasedMatches+ , lensOptEraseRecordParameters+ , lensOptRewriting+ , lensOptLocalRewriting+ , lensOptCubical+ , lensOptGuarded+ , lensOptFirstOrder+ , lensOptRequireUniqueMetaSolutions+ , lensOptPostfixProjections+ , lensOptKeepPatternVariables+ , lensOptInferAbsurdClauses+ , lensOptInstanceSearchDepth+ , lensOptBacktrackingInstances+ , lensOptQualifiedInstances+ , lensOptInversionMaxDepth+ , lensOptSafe+ , lensOptDoubleCheck+ , lensOptSyntacticEquality+ , lensOptWarningMode+ , lensOptCompileMain+ , lensOptCaching+ , lensOptCountClusters+ , lensOptAutoInline+ , lensOptPrintPatternSynonyms+ , lensOptFastReduce+ , lensOptCallByName+ , lensOptConfluenceCheck+ , lensOptCohesion+ , lensOptFlatSplit+ , lensOptPolarity+ , lensOptOccurrence+ , lensOptImportSorts+ , lensOptLoadPrimitives+ , lensOptAllowExec+ , lensOptSaveMetas+ , lensOptShowIdentitySubstitutions+ , lensOptKeepCoveringClauses+ -- * Boolean accessors to 'PragmaOptions' collapsing default+ , optShowImplicit+ , optShowGeneralized+ , optShowIrrelevant+ , optIrrelevance+ , optProp+ , optLevelUniverse+ , optTwoLevel+ , optAllowUnsolved+ , optAllowIncompleteMatch+ , optPositivityCheck+ , optTerminationCheck+ , optUniverseCheck+ , optOmegaInOmega+ , optCumulativity+ , optSizedTypes+ , optGuardedness+ , optInjectiveTypeConstructors+ , optUniversePolymorphism+ , optIrrelevantProjections+ , optExperimentalIrrelevance+ , optWithoutK+ , optCubicalCompatible+ , optCopatterns+ , optPatternMatching+ , optHiddenArgumentPuns+ , optEta+ , optForcing+ , optProjectionLike+ , optErasure+ , optEraseRecordParameters+ , optRewriting+ , optLocalRewriting+ , optGuarded+ , optFirstOrder+ , optRequireUniqueMetaSolutions+ , optPostfixProjections+ , optKeepPatternVariables+ , optInferAbsurdClauses+ , optBacktrackingInstances+ , optQualifiedInstances+ , optSafe+ , optDoubleCheck+ , optCompileNoMain+ , optCaching+ , optCountClusters+ , optAutoInline+ , optPrintPatternSynonyms+ , optFastReduce+ , optCallByName+ , optCohesion+ , optFlatSplit+ , optPolarity+ , optOccurrence+ , optFunext+ , optPropext+ , optQuotients+ , optImportSorts+ , optLoadPrimitives+ , optAllowExec+ , optSaveMetas+ , optShowIdentitySubstitutions+ , optKeepCoveringClauses+ , optLargeIndices+ , optForcedArgumentRecursion+ , optQuoteMetas+ -- * Non-boolean accessors to 'PragmaOptions'+ , optConfluenceCheck+ , optCubical+ , optErasedMatches+ , optInstanceSearchDepth+ , optInversionMaxDepth+ , optProfiling+ , optSyntacticEquality+ , optTerminationDepth+ , optUseUnicode+ , optVerbose+ , optWarningMode+ ) where++import Prelude hiding ( null, not, (&&), (||) )++import Control.DeepSeq+import Control.Monad ( when, void )+import Control.Monad.Except ( ExceptT, MonadError(throwError), runExceptT )+import Control.Monad.Writer ( Writer, runWriter, MonadWriter(..) )++import Data.Bifunctor ( second )+import Data.Function ( (&) )+import Data.List ( intercalate )+import Data.Maybe+import Data.Set ( Set )+import qualified Data.Set as Set++import GHC.Generics (Generic)++import Agda.Utils.GetOpt ( getOpt', ArgOrder(ReturnInOrder)+ , OptDescr(..), ArgDescr(..)+ )+import qualified System.IO.Unsafe as UNSAFE (unsafePerformIO)++import Text.EditDistance+import Text.Read ( readMaybe )++import Agda.Termination.CutOff ( CutOff(..), defaultCutOff )++import Agda.Interaction.Library ( OptionsPragma(..), parseLibName )+import Agda.Interaction.Options.Arguments+import Agda.Interaction.Options.Default+import Agda.Interaction.Options.Help+ ( Help(HelpFor, GeneralHelp)+ , string2HelpTopic+ , allHelpTopics+ )+import Agda.Interaction.Options.Types+import Agda.Interaction.Options.Warnings++import Agda.Syntax.Concrete.Glyph ( unsafeSetUnicodeOrAscii, UnicodeOrAscii(..) )+import qualified Agda.Syntax.Common as C+import Agda.Syntax.Common (AllowedErasedMatches, Cubical(..))+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Position (PrintRange(PrintRange))+import Agda.Syntax.TopLevelModuleName (TopLevelModuleName)++import qualified Agda.Setup.EmacsMode as EmacsMode++import Agda.Utils.Boolean+import Agda.Utils.Function ( applyWhen, applyUnless )+import Agda.Utils.Functor ( (<&>) )+import Agda.Utils.Lens ( Lens', (^.), over, over', set )+import Agda.Utils.List ( chopWhen, headWithDefault, initLast1 )+import Agda.Utils.List1 ( List1, pattern (:|), toList )+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.Maybe.Strict as Strict+import Agda.Utils.Monad ( tell1 )+import Agda.Utils.Null+import Agda.Interaction.Options.ProfileOptions+import Agda.Utils.String ( unwords1 )+import qualified Agda.Utils.String as String+import qualified Agda.Utils.Trie as Trie+import Agda.Utils.TypeLits+import Agda.Utils.WithDefault++import Agda.Utils.Impossible++parseVerboseKey :: VerboseKey -> [VerboseKeyItem]+parseVerboseKey = List1.wordsBy (`elem` ['.', ':'])++data ImpliedPragmaOption where+ ImpliesPragmaOption+ :: String -> Bool -> (PragmaOptions -> WithDefault a)+ -> String -> Bool -> (PragmaOptions -> WithDefault b)+ -> ImpliedPragmaOption+ -- ^ The first option having the given value implies the second option having its given value.+ -- For instance, `ImpliesPragmaOption "lossy-unification" True _optFirstOrder+ -- "require-unique-meta-solutions" False _optRequireUniqueMetaSolutions`+ -- encodes the fact that --lossy-unification implies --no-require-unique-meta-solutions.++impliedPragmaOptions :: [ImpliedPragmaOption]+impliedPragmaOptions =+ [ ("erase-record-parameters", _optEraseRecordParameters) ==> ("erasure", _optErasure)+ , ("experimental-irrelevance", _optExperimentalIrrelevance) ==> ("irrelevance", _optIrrelevance)+ , ("flat-split", _optFlatSplit) ==> ("cohesion", _optCohesion)+ , ("irrelevant-projections", _optIrrelevantProjections) ==> ("irrelevance", _optIrrelevance)+ , ("no-load-primitives", _optLoadPrimitives) ==> ("no-import-sorts", _optImportSorts)+ , ("lossy-unification", _optFirstOrder) ==> ("no-require-unique-meta-solutions", _optRequireUniqueMetaSolutions)+ , ImpliesPragmaOption+ "erased-matches (with a different argument than \"=none\")" True+ (\opts -> case _optErasedMatches opts of+ C.ErasedMatchesDefault -> Default+ C.ErasedMatchesDefaultOn -> Value True+ C.ErasedMatches allowed -> Value (allowed /= mempty))+ "erasure" True _optErasure+ ]+ where+ yesOrNo ('n':'o':'-':s) = (False, s)+ yesOrNo s = (True, s)+ (nameA, optA) ==> (nameB, optB) = ImpliesPragmaOption stemA valA optA stemB valB optB+ where+ (valA, stemA) = yesOrNo nameA+ (valB, stemB) = yesOrNo nameB++-- collapse defaults+optShowImplicit :: PragmaOptions -> Bool+optShowGeneralized :: PragmaOptions -> Bool+optShowIrrelevant :: PragmaOptions -> Bool+optIrrelevance :: PragmaOptions -> Bool+optProp :: PragmaOptions -> Bool+optLevelUniverse :: PragmaOptions -> Bool+optTwoLevel :: PragmaOptions -> Bool+optAllowUnsolved :: PragmaOptions -> Bool+optAllowIncompleteMatch :: PragmaOptions -> Bool+optPositivityCheck :: PragmaOptions -> Bool+optTerminationCheck :: PragmaOptions -> Bool+optUniverseCheck :: PragmaOptions -> Bool+optOmegaInOmega :: PragmaOptions -> Bool+optCumulativity :: PragmaOptions -> Bool+optSizedTypes :: PragmaOptions -> Bool+optGuardedness :: PragmaOptions -> Bool+optInjectiveTypeConstructors :: PragmaOptions -> Bool+optUniversePolymorphism :: PragmaOptions -> Bool+optIrrelevantProjections :: PragmaOptions -> Bool+optExperimentalIrrelevance :: PragmaOptions -> Bool+optWithoutK :: PragmaOptions -> Bool+optCubicalCompatible :: PragmaOptions -> Bool+optCopatterns :: PragmaOptions -> Bool+optPatternMatching :: PragmaOptions -> Bool+optHiddenArgumentPuns :: PragmaOptions -> Bool+optEta :: PragmaOptions -> Bool+optForcing :: PragmaOptions -> Bool+optProjectionLike :: PragmaOptions -> Bool+-- | 'optErasure' is implied by 'optEraseRecordParameters',+-- 'optFunext' and 'optPropext'. 'optErasure' is also implied by an+-- explicitly given @--erased-matches@ with an argument distinct+-- from @=none@.+optErasure :: PragmaOptions -> Bool+optEraseRecordParameters :: PragmaOptions -> Bool+optRewriting :: PragmaOptions -> Bool+optLocalRewriting :: PragmaOptions -> Bool+optGuarded :: PragmaOptions -> Bool+optFirstOrder :: PragmaOptions -> Bool+optRequireUniqueMetaSolutions :: PragmaOptions -> Bool+optPostfixProjections :: PragmaOptions -> Bool+optKeepPatternVariables :: PragmaOptions -> Bool+optInferAbsurdClauses :: PragmaOptions -> Bool+optBacktrackingInstances :: PragmaOptions -> Bool+optQualifiedInstances :: PragmaOptions -> Bool+optSafe :: PragmaOptions -> Bool+optDoubleCheck :: PragmaOptions -> Bool+optCompileNoMain :: PragmaOptions -> Bool+optCaching :: PragmaOptions -> Bool+optCountClusters :: PragmaOptions -> Bool+optAutoInline :: PragmaOptions -> Bool+optPrintPatternSynonyms :: PragmaOptions -> Bool+optFastReduce :: PragmaOptions -> Bool+optCallByName :: PragmaOptions -> Bool+-- | 'optCohesion' is implied by 'optFlatSplit'.+optCohesion :: PragmaOptions -> Bool+optFlatSplit :: PragmaOptions -> Bool+optPolarity :: PragmaOptions -> Bool+optOccurrence :: PragmaOptions -> Bool+-- | 'optFunext' is implied by 'optQuotients'.+optFunext :: PragmaOptions -> Bool+optPropext :: PragmaOptions -> Bool+optQuotients :: PragmaOptions -> Bool+-- | 'optImportSorts' requires 'optLoadPrimitives'.+optImportSorts :: PragmaOptions -> Bool+optLoadPrimitives :: PragmaOptions -> Bool+optAllowExec :: PragmaOptions -> Bool+optSaveMetas :: PragmaOptions -> Bool+optShowIdentitySubstitutions :: PragmaOptions -> Bool+optKeepCoveringClauses :: PragmaOptions -> Bool+optLargeIndices :: PragmaOptions -> Bool+optForcedArgumentRecursion :: PragmaOptions -> Bool++optShowImplicit = collapseDefault . _optShowImplicit+optShowGeneralized = collapseDefault . _optShowGeneralized+optShowIrrelevant = collapseDefault . _optShowIrrelevant+optIrrelevance = collapseDefault . _optIrrelevance+optProp = collapseDefault . _optProp+optLevelUniverse = collapseDefault . _optLevelUniverse+optTwoLevel = collapseDefault . _optTwoLevel+optAllowUnsolved = collapseDefault . _optAllowUnsolved+optAllowIncompleteMatch = collapseDefault . _optAllowIncompleteMatch+optPositivityCheck = collapseDefault . _optPositivityCheck+optTerminationCheck = collapseDefault . _optTerminationCheck+optUniverseCheck = collapseDefault . _optUniverseCheck+optOmegaInOmega = collapseDefault . _optOmegaInOmega+optCumulativity = collapseDefault . _optCumulativity+optSizedTypes = collapseDefault . _optSizedTypes+optGuardedness = collapseDefault . _optGuardedness+optInjectiveTypeConstructors = collapseDefault . _optInjectiveTypeConstructors+optUniversePolymorphism = collapseDefault . _optUniversePolymorphism+optIrrelevantProjections = collapseDefault . _optIrrelevantProjections+optExperimentalIrrelevance = collapseDefault . _optExperimentalIrrelevance+optWithoutK = collapseDefault . _optWithoutK+optCubicalCompatible = collapseDefault . _optCubicalCompatible+optCopatterns = collapseDefault . _optCopatterns+optPatternMatching = collapseDefault . _optPatternMatching+optHiddenArgumentPuns = collapseDefault . _optHiddenArgumentPuns+optEta = collapseDefault . _optEta+optForcing = collapseDefault . _optForcing+optProjectionLike = collapseDefault . _optProjectionLike+-- --erase-record-parameters implies --erasure+optErasure = collapseDefault . _optErasure ||+ optEraseRecordParameters ||+ optFunext ||+ optPropext ||+ ((/= C.ErasedMatchesDefault) &&+ (/= C.ErasedMatches mempty)) .+ _optErasedMatches+optEraseRecordParameters = collapseDefault . _optEraseRecordParameters+optRewriting = collapseDefault . _optRewriting+optLocalRewriting = collapseDefault . _optLocalRewriting+optGuarded = collapseDefault . _optGuarded+optFirstOrder = collapseDefault . _optFirstOrder+optRequireUniqueMetaSolutions = collapseDefault . _optRequireUniqueMetaSolutions && not . optFirstOrder+-- --lossy-unification implies --no-require-unique-meta-solutions+optPostfixProjections = collapseDefault . _optPostfixProjections+optKeepPatternVariables = collapseDefault . _optKeepPatternVariables+optInferAbsurdClauses = collapseDefault . _optInferAbsurdClauses+optBacktrackingInstances = collapseDefault . _optBacktrackingInstances+optQualifiedInstances = collapseDefault . _optQualifiedInstances+optSafe = collapseDefault . _optSafe+optDoubleCheck = collapseDefault . _optDoubleCheck+optCompileNoMain = not . collapseDefault . _optCompileMain+optCaching = collapseDefault . _optCaching+optCountClusters = collapseDefault . _optCountClusters+optAutoInline = collapseDefault . _optAutoInline+optPrintPatternSynonyms = collapseDefault . _optPrintPatternSynonyms+optFastReduce = collapseDefault . _optFastReduce+optCallByName = collapseDefault . _optCallByName+-- --flat-split implies --cohesion+optCohesion = collapseDefault . _optCohesion || optFlatSplit+optFlatSplit = collapseDefault . _optFlatSplit+optPolarity = collapseDefault . _optPolarity+optOccurrence = collapseDefault . _optOccurrence+optFunext = collapseDefault . _optFunext ||+ optQuotients+optPropext = collapseDefault . _optPropext+optQuotients = collapseDefault . _optQuotients+-- --no-load-primitives implies --no-import-sorts+optImportSorts = collapseDefault . _optImportSorts && optLoadPrimitives+optLoadPrimitives = collapseDefault . _optLoadPrimitives+optAllowExec = collapseDefault . _optAllowExec+optSaveMetas = collapseDefault . _optSaveMetas+optShowIdentitySubstitutions = collapseDefault . _optShowIdentitySubstitutions+optKeepCoveringClauses = collapseDefault . _optKeepCoveringClauses+optLargeIndices = collapseDefault . _optLargeIndices+optForcedArgumentRecursion = collapseDefault . _optForcedArgumentRecursion+optQuoteMetas = collapseDefault . _optQuoteMetas++-- Collapse defaults (non-Bool)++optUseUnicode :: PragmaOptions -> UnicodeOrAscii+optUseUnicode = collapseDefault . _optUseUnicode++optErasedMatches :: PragmaOptions -> AllowedErasedMatches+optErasedMatches opts = case _optErasedMatches opts of+ C.ErasedMatches m ->+ m+ C.ErasedMatchesDefault+ | not (optErasure opts) ->+ allowedErasedMatches None+ | optWithoutK opts ->+ allowedErasedMatches Empty+ | otherwise ->+ allowedErasedMatches Empty <> allowedErasedMatches Unrestricted+ C.ErasedMatchesDefaultOn+ | optWithoutK opts ->+ allowedErasedMatches Empty <> allowedErasedMatches NonDependent+ | otherwise ->+ allowedErasedMatches Empty <> allowedErasedMatches Unrestricted++-- Extra trivial accessors (keep in alphabetical order)++optConfluenceCheck :: PragmaOptions -> _+optCubical :: PragmaOptions -> _+optInstanceSearchDepth :: PragmaOptions -> _+optInversionMaxDepth :: PragmaOptions -> _+optProfiling :: PragmaOptions -> _+optSyntacticEquality :: PragmaOptions -> _+optTerminationDepth :: PragmaOptions -> _+optVerbose :: PragmaOptions -> _+optWarningMode :: PragmaOptions -> _++optConfluenceCheck = _optConfluenceCheck+optCubical = _optCubical+optInstanceSearchDepth = _optInstanceSearchDepth+optInversionMaxDepth = _optInversionMaxDepth+optProfiling = _optProfiling+optSyntacticEquality = _optSyntacticEquality+optTerminationDepth = _optTerminationDepth+optVerbose = _optVerbose+optWarningMode = _optWarningMode++-- Lenses for PragmaOptions+-- N.B.: We use PartialTypeSignatures here to not repeat default values (DRY!).++lensOptShowImplicit :: Lens' PragmaOptions _+lensOptShowImplicit f o = f (_optShowImplicit o) <&> \ i -> o{ _optShowImplicit = i }++lensOptShowIrrelevant :: Lens' PragmaOptions _+lensOptShowIrrelevant f o = f (_optShowIrrelevant o) <&> \ i -> o{ _optShowIrrelevant = i }++lensOptUseUnicode :: Lens' PragmaOptions _+lensOptUseUnicode f o = f (_optUseUnicode o) <&> \ i -> o{ _optUseUnicode = i }++lensOptVerbose :: Lens' PragmaOptions _+lensOptVerbose f o = f (_optVerbose o) <&> \ i -> o{ _optVerbose = i }++lensOptProfiling :: Lens' PragmaOptions _+lensOptProfiling f o = f (_optProfiling o) <&> \ i -> o{ _optProfiling = i }++lensOptIrrelevance :: Lens' PragmaOptions _+lensOptIrrelevance f o = f (_optIrrelevance o) <&> \ i -> o{ _optIrrelevance = i }++lensOptProp :: Lens' PragmaOptions _+lensOptProp f o = f (_optProp o) <&> \ i -> o{ _optProp = i }++lensOptLevelUniverse :: Lens' PragmaOptions _+lensOptLevelUniverse f o = f (_optLevelUniverse o) <&> \ i -> o{ _optLevelUniverse = i }++lensOptTwoLevel :: Lens' PragmaOptions _+lensOptTwoLevel f o = f (_optTwoLevel o) <&> \ i -> o{ _optTwoLevel = i }++lensOptAllowUnsolved :: Lens' PragmaOptions _+lensOptAllowUnsolved f o = f (_optAllowUnsolved o) <&> \ i -> o{ _optAllowUnsolved = i }++lensOptAllowIncompleteMatch :: Lens' PragmaOptions _+lensOptAllowIncompleteMatch f o = f (_optAllowIncompleteMatch o) <&> \ i -> o{ _optAllowIncompleteMatch = i }++lensOptPositivityCheck :: Lens' PragmaOptions _+lensOptPositivityCheck f o = f (_optPositivityCheck o) <&> \ i -> o{ _optPositivityCheck = i }++lensOptTerminationCheck :: Lens' PragmaOptions _+lensOptTerminationCheck f o = f (_optTerminationCheck o) <&> \ i -> o{ _optTerminationCheck = i }++lensOptTerminationDepth :: Lens' PragmaOptions _+lensOptTerminationDepth f o = f (_optTerminationDepth o) <&> \ i -> o{ _optTerminationDepth = i }++lensOptUniverseCheck :: Lens' PragmaOptions _+lensOptUniverseCheck f o = f (_optUniverseCheck o) <&> \ i -> o{ _optUniverseCheck = i }++lensOptNoUniverseCheck :: Lens' PragmaOptions _+lensOptNoUniverseCheck f o = f (not' $ _optUniverseCheck o) <&> \ i -> o{ _optUniverseCheck = not' i }++lensOptOmegaInOmega :: Lens' PragmaOptions _+lensOptOmegaInOmega f o = f (_optOmegaInOmega o) <&> \ i -> o{ _optOmegaInOmega = i }++lensOptCumulativity :: Lens' PragmaOptions _+lensOptCumulativity f o = f (_optCumulativity o) <&> \ i -> o{ _optCumulativity = i }++lensOptSizedTypes :: Lens' PragmaOptions _+lensOptSizedTypes f o = f (_optSizedTypes o) <&> \ i -> o{ _optSizedTypes = i }++lensOptGuardedness :: Lens' PragmaOptions _+lensOptGuardedness f o = f (_optGuardedness o) <&> \ i -> o{ _optGuardedness = i }++lensOptInjectiveTypeConstructors :: Lens' PragmaOptions _+lensOptInjectiveTypeConstructors f o = f (_optInjectiveTypeConstructors o) <&> \ i -> o{ _optInjectiveTypeConstructors = i }++lensOptUniversePolymorphism :: Lens' PragmaOptions _+lensOptUniversePolymorphism f o = f (_optUniversePolymorphism o) <&> \ i -> o{ _optUniversePolymorphism = i }++lensOptIrrelevantProjections :: Lens' PragmaOptions _+lensOptIrrelevantProjections f o = f (_optIrrelevantProjections o) <&> \ i -> o{ _optIrrelevantProjections = i }++lensOptExperimentalIrrelevance :: Lens' PragmaOptions _+lensOptExperimentalIrrelevance f o = f (_optExperimentalIrrelevance o) <&> \ i -> o{ _optExperimentalIrrelevance = i }++lensOptWithoutK :: Lens' PragmaOptions _+lensOptWithoutK f o = f (_optWithoutK o) <&> \ i -> o{ _optWithoutK = i }++lensOptCubicalCompatible :: Lens' PragmaOptions _+lensOptCubicalCompatible f o = f (_optCubicalCompatible o) <&> \ i -> o{ _optCubicalCompatible = i }++lensOptCopatterns :: Lens' PragmaOptions _+lensOptCopatterns f o = f (_optCopatterns o) <&> \ i -> o{ _optCopatterns = i }++lensOptPatternMatching :: Lens' PragmaOptions _+lensOptPatternMatching f o = f (_optPatternMatching o) <&> \ i -> o{ _optPatternMatching = i }++lensOptExactSplit :: Lens' PragmaOptions _+lensOptExactSplit f o = f (_optExactSplit o) <&> \ i -> o{ _optExactSplit = i }++lensOptHiddenArgumentPuns :: Lens' PragmaOptions _+lensOptHiddenArgumentPuns f o = f (_optHiddenArgumentPuns o) <&> \ i -> o{ _optHiddenArgumentPuns = i }++lensOptEta :: Lens' PragmaOptions _+lensOptEta f o = f (_optEta o) <&> \ i -> o{ _optEta = i }++lensOptForcing :: Lens' PragmaOptions _+lensOptForcing f o = f (_optForcing o) <&> \ i -> o{ _optForcing = i }++lensOptProjectionLike :: Lens' PragmaOptions _+lensOptProjectionLike f o = f (_optProjectionLike o) <&> \ i -> o{ _optProjectionLike = i }++lensOptErasure :: Lens' PragmaOptions _+lensOptErasure f o = f (_optErasure o) <&> \ i -> o{ _optErasure = i }++lensOptErasedMatches :: Lens' PragmaOptions _+lensOptErasedMatches f o = f (_optErasedMatches o) <&> \ i -> o{ _optErasedMatches = i }++lensOptEraseRecordParameters :: Lens' PragmaOptions _+lensOptEraseRecordParameters f o = f (_optEraseRecordParameters o) <&> \ i -> o{ _optEraseRecordParameters = i }++lensOptRewriting :: Lens' PragmaOptions _+lensOptRewriting f o = f (_optRewriting o) <&> \ i -> o{ _optRewriting = i }++lensOptLocalRewriting :: Lens' PragmaOptions _+lensOptLocalRewriting f o = f (_optLocalRewriting o) <&> \ i -> o{ _optLocalRewriting = i }++lensOptCubical :: Lens' PragmaOptions _+lensOptCubical f o = f (_optCubical o) <&> \ i -> o{ _optCubical = i }++lensOptGuarded :: Lens' PragmaOptions _+lensOptGuarded f o = f (_optGuarded o) <&> \ i -> o{ _optGuarded = i }++lensOptFirstOrder :: Lens' PragmaOptions _+lensOptFirstOrder f o = f (_optFirstOrder o) <&> \ i -> o{ _optFirstOrder = i }++lensOptRequireUniqueMetaSolutions :: Lens' PragmaOptions _+lensOptRequireUniqueMetaSolutions f o = f (_optRequireUniqueMetaSolutions o) <&> \ i -> o{ _optRequireUniqueMetaSolutions = i }++lensOptPostfixProjections :: Lens' PragmaOptions _+lensOptPostfixProjections f o = f (_optPostfixProjections o) <&> \ i -> o{ _optPostfixProjections = i }++lensOptKeepPatternVariables :: Lens' PragmaOptions _+lensOptKeepPatternVariables f o = f (_optKeepPatternVariables o) <&> \ i -> o{ _optKeepPatternVariables = i }++lensOptInferAbsurdClauses :: Lens' PragmaOptions _+lensOptInferAbsurdClauses f o = f (_optInferAbsurdClauses o) <&> \ i -> o{ _optInferAbsurdClauses = i }++lensOptInstanceSearchDepth :: Lens' PragmaOptions _+lensOptInstanceSearchDepth f o = f (_optInstanceSearchDepth o) <&> \ i -> o{ _optInstanceSearchDepth = i }++lensOptBacktrackingInstances :: Lens' PragmaOptions _+lensOptBacktrackingInstances f o = f (_optBacktrackingInstances o) <&> \ i -> o{ _optBacktrackingInstances = i }++lensOptQualifiedInstances :: Lens' PragmaOptions _+lensOptQualifiedInstances f o = f (_optQualifiedInstances o) <&> \ i -> o{ _optQualifiedInstances = i }++lensOptInversionMaxDepth :: Lens' PragmaOptions _+lensOptInversionMaxDepth f o = f (_optInversionMaxDepth o) <&> \ i -> o{ _optInversionMaxDepth = i }++lensOptSafe :: Lens' PragmaOptions _+lensOptSafe f o = f (_optSafe o) <&> \ i -> o{ _optSafe = i }++lensOptDoubleCheck :: Lens' PragmaOptions _+lensOptDoubleCheck f o = f (_optDoubleCheck o) <&> \ i -> o{ _optDoubleCheck = i }++lensOptSyntacticEquality :: Lens' PragmaOptions _+lensOptSyntacticEquality f o = f (_optSyntacticEquality o) <&> \ i -> o{ _optSyntacticEquality = i }++lensOptWarningMode :: Lens' PragmaOptions _+lensOptWarningMode f o = f (_optWarningMode o) <&> \ i -> o{ _optWarningMode = i }++lensOptCompileMain :: Lens' PragmaOptions _+lensOptCompileMain f o = f (_optCompileMain o) <&> \ i -> o{ _optCompileMain = i }++lensOptCaching :: Lens' PragmaOptions _+lensOptCaching f o = f (_optCaching o) <&> \ i -> o{ _optCaching = i }++lensOptCountClusters :: Lens' PragmaOptions _+lensOptCountClusters f o = f (_optCountClusters o) <&> \ i -> o{ _optCountClusters = i }++lensOptAutoInline :: Lens' PragmaOptions _+lensOptAutoInline f o = f (_optAutoInline o) <&> \ i -> o{ _optAutoInline = i }++lensOptPrintPatternSynonyms :: Lens' PragmaOptions _+lensOptPrintPatternSynonyms f o = f (_optPrintPatternSynonyms o) <&> \ i -> o{ _optPrintPatternSynonyms = i }++lensOptFastReduce :: Lens' PragmaOptions _+lensOptFastReduce f o = f (_optFastReduce o) <&> \ i -> o{ _optFastReduce = i }++lensOptCallByName :: Lens' PragmaOptions _+lensOptCallByName f o = f (_optCallByName o) <&> \ i -> o{ _optCallByName = i }++lensOptConfluenceCheck :: Lens' PragmaOptions _+lensOptConfluenceCheck f o = f (_optConfluenceCheck o) <&> \ i -> o{ _optConfluenceCheck = i }++lensOptCohesion :: Lens' PragmaOptions _+lensOptCohesion f o = f (_optCohesion o) <&> \ i -> o{ _optCohesion = i }++lensOptFlatSplit :: Lens' PragmaOptions _+lensOptFlatSplit f o = f (_optFlatSplit o) <&> \ i -> o{ _optFlatSplit = i }++lensOptPolarity :: Lens' PragmaOptions _+lensOptPolarity f o = f (_optPolarity o) <&> \ i -> o{ _optPolarity = i}++lensOptOccurrence :: Lens' PragmaOptions _+lensOptOccurrence f o =+ f (_optOccurrence o) <&> \ i -> o{ _optOccurrence = i}++lensOptFunext :: Lens' PragmaOptions _+lensOptFunext f o = f (_optFunext o) <&> \ i -> o{ _optFunext = i }++lensOptPropext :: Lens' PragmaOptions _+lensOptPropext f o = f (_optPropext o) <&> \ i -> o{ _optPropext = i }++lensOptQuotients :: Lens' PragmaOptions _+lensOptQuotients f o =+ f (_optQuotients o) <&> \ i -> o{ _optQuotients = i }++lensOptImportSorts :: Lens' PragmaOptions _+lensOptImportSorts f o = f (_optImportSorts o) <&> \ i -> o{ _optImportSorts = i }++lensOptLoadPrimitives :: Lens' PragmaOptions _+lensOptLoadPrimitives f o = f (_optLoadPrimitives o) <&> \ i -> o{ _optLoadPrimitives = i }++lensOptAllowExec :: Lens' PragmaOptions _+lensOptAllowExec f o = f (_optAllowExec o) <&> \ i -> o{ _optAllowExec = i }++lensOptSaveMetas :: Lens' PragmaOptions _+lensOptSaveMetas f o = f (_optSaveMetas o) <&> \ i -> o{ _optSaveMetas = i }++lensOptShowIdentitySubstitutions :: Lens' PragmaOptions _+lensOptShowIdentitySubstitutions f o = f (_optShowIdentitySubstitutions o) <&> \ i -> o{ _optShowIdentitySubstitutions = i }++lensOptKeepCoveringClauses :: Lens' PragmaOptions _+lensOptKeepCoveringClauses f o = f (_optKeepCoveringClauses o) <&> \ i -> o{ _optKeepCoveringClauses = i }++lensOptLargeIndices :: Lens' PragmaOptions _+lensOptLargeIndices f o = f (_optLargeIndices o) <&> \ i -> o{ _optLargeIndices = i }++lensOptForcedArgumentRecursion :: Lens' PragmaOptions _+lensOptForcedArgumentRecursion f o = f (_optForcedArgumentRecursion o) <&> \ i -> o{ _optForcedArgumentRecursion = i }++lensOptExperimentalLazyInstances :: Lens' PragmaOptions _+lensOptExperimentalLazyInstances f o = f (_optExperimentalLazyInstances o) <&> \ i -> o{ _optExperimentalLazyInstances = i }++lensOptQuoteMetas :: Lens' PragmaOptions _+lensOptQuoteMetas f o = f (_optQuoteMetas o) <&> \ i -> o{ _optQuoteMetas = i }++-- | Map a function over the long options. Also removes the short options.+-- Will be used to add the plugin name to the plugin options.+mapFlag :: (String -> String) -> OptDescr a -> OptDescr a+mapFlag f (Option _ long arg descr) = Option [] (map f long) arg descr++defaultInteractionOptions :: PragmaOptions+defaultInteractionOptions = defaultPragmaOptions++-- | The options parse monad 'OptM' collects warnings that are not discarded+-- when a fatal error occurrs+newtype OptM a = OptM { unOptM :: ExceptT OptionError (Writer OptionWarnings) a }+ deriving (Functor, Applicative, Monad, MonadError OptionError, MonadWriter OptionWarnings)++type OptionError = String+type OptionWarnings = [OptionWarning]++runOptM :: OptM opts -> (Either OptionError opts, OptionWarnings)+runOptM = runWriter . runExceptT . unOptM++{- | @f :: Flag opts@ is an action on the option record that results from+ parsing an option. @f opts@ produces either an error message or an+ updated options record+-}+type Flag opts = opts -> OptM opts++-- | Warnings when parsing options.++data OptionWarning+ = OptionRenamed { oldOptionName :: String, newOptionName :: String }+ -- ^ Name of option changed in a newer version of Agda.+ | WarningProblem WarningModeError+ -- ^ A problem with setting or unsetting a warning.+ | LocalRewritingConfluenceCheck+ -- ^ Confluence checking for local rewrite rules is unimplemented.+ deriving (Show, Generic)++instance NFData OptionWarning++instance Pretty OptionWarning where+ pretty = \case+ OptionRenamed old new -> hsep+ [ "Option", option old, "is deprecated, please use", option new, "instead" ]+ WarningProblem err -> pretty (prettyWarningModeError err) <+> "See --help=warning."+ LocalRewritingConfluenceCheck -> fsep $ pwords "Confluence checking (--confluence-check or --local-confluence-check) is not yet implemented for local rewrite rules (--local-rewriting)"+ where+ option = text . ("--" ++)++optionWarningName :: OptionWarning -> WarningName+optionWarningName = \case+ OptionRenamed{} -> OptionRenamed_+ WarningProblem{} -> WarningProblem_+ LocalRewritingConfluenceCheck -> LocalRewritingConfluenceCheck_++-- | Checks that the given options are consistent.+-- Also makes adjustments (e.g. when one option implies another).++checkOpts :: (MonadError OptionError m, MonadWriter OptionWarnings m)+ => CommandLineOptions -> m CommandLineOptions+checkOpts opts = do+ -- NOTE: This is a temporary hold-out until --vim can be converted into a backend or plugin,+ -- whose options compatibility currently is checked in `Agda.Compiler.Backend`.+ --+ -- Additionally, note that some options checking is performed in `Agda.Main`+ -- in which the top-level frontend and backend interactors are selected.+ --+ -- Those checks are not represented here, because:+ -- - They are used solely for selecting the initial executon mode; they+ -- don't need to be checked on a per-module etc basis.+ -- - I hope/expect that the presence of those specific flags will be eventually+ -- abstracted out (like the Backends' internal flags), so that they are invisible+ -- to the rest of the type-checking system.+ when (optGenerateVimFile opts && optOnlyScopeChecking opts) $+ throwError $ "The --only-scope-checking flag cannot be combined with --vim."++ lensPragmaOptions checkPragmaOptions opts++-- | Check for pragma option consistency and make adjustments.++checkPragmaOptions :: (MonadError OptionError m, MonadWriter OptionWarnings m)+ => PragmaOptions -> m PragmaOptions+checkPragmaOptions opts = do++ -- Check for errors in pragma options.++ when ((optEraseRecordParameters `butNot` optErasure) opts) $+ throwError+ "The option --erase-record-parameters requires the use of --erasure"++ when (isJust (optConfluenceCheck opts) && optLocalRewriting opts) $+ tell1 LocalRewritingConfluenceCheck++#ifndef COUNT_CLUSTERS+ when (optCountClusters opts) $+ throwError+ "Cluster counting has not been enabled in this build of Agda."+#endif++ -- Perform corrections in pragma options.++ return $ opts++ -- -WTerminationIssue iff --termination-check+ & conformWarningToOption TerminationIssue_ optTerminationCheck++ -- -WNotStrictlyPositive iff --positivity-check+ . conformWarningToOption NotStrictlyPositive_ optPositivityCheck++ -- unsolvedWarnings iff --no-allow-unsolved-metas+ . conformWarningsToOption unsolvedWarnings (not . optAllowUnsolved)++ -- incompleteMatchWarnings iff --no-allow-incomplete-matches+ . conformWarningsToOption incompleteMatchWarnings (not . optAllowIncompleteMatch)++-- | Activate warning when and only when option is on.+conformWarningToOption ::+ WarningName+ -- ^ Warning to toggle.+ -> (PragmaOptions -> Bool)+ -- ^ Which flag to conform to?+ -> PragmaOptions+ -- ^ Options to modify.+ -> PragmaOptions+ -- ^ Modified options.+conformWarningToOption = conformWarningsToOption . Set.singleton++-- | Activate warnings when option is on and deactivate them when option is off.+conformWarningsToOption ::+ Set WarningName+ -- ^ Warnings to toggle.+ -> (PragmaOptions -> Bool)+ -- ^ Which flag to conform to?+ -> PragmaOptions+ -- ^ Options to modify.+ -> PragmaOptions+ -- ^ Modified options.+conformWarningsToOption ws f opts =+ over (lensOptWarningMode . warningSet) (if f opts then (`Set.union` ws) else (Set.\\ ws)) opts++-- | Check for unsafe pragmas. Gives a list of used unsafe flags.++unsafePragmaOptions :: PragmaOptions -> [String]+unsafePragmaOptions opts =+ [ "--allow-unsolved-metas" | optAllowUnsolved opts ] +++ [ "--allow-incomplete-matches" | optAllowIncompleteMatch opts ] +++ [ "--no-positivity-check" | not (optPositivityCheck opts) ] +++ [ "--no-termination-check" | not (optTerminationCheck opts) ] +++ [ "--type-in-type" | not (optUniverseCheck opts) ] +++ [ "--omega-in-omega" | optOmegaInOmega opts ] +++ [ "--sized-types" | optSizedTypes opts ] +++ [ "--injective-type-constructors" | optInjectiveTypeConstructors opts ] +++ [ "--irrelevant-projections" | optIrrelevantProjections opts ] +++ [ "--experimental-irrelevance" | optExperimentalIrrelevance opts ] +++ [ "--rewriting" | optRewriting opts ] +++ [ "--local-rewriting" | optLocalRewriting opts ]+ +++ [ "--cubical=compatible and --with-K" | optCubicalCompatible opts, not (optWithoutK opts) ] +++ [ "--without-K and --flat-split" | optWithoutK opts, optFlatSplit opts ] +++ [ "--without-K and --erased-matches=unrestricted"+ | optWithoutK opts, C.emUnrestricted (optErasedMatches opts)+ ] +++ [ "--cumulativity" | optCumulativity opts ] +++ [ "--allow-exec" | optAllowExec opts ] +++ [ "--no-load-primitives" | not $ optLoadPrimitives opts ] +++ [ "--without-K and --large-indices" | optWithoutK opts, optLargeIndices opts ] +++ [ "--large-indices and --forced-argument-recursion"+ | optLargeIndices opts, optForcedArgumentRecursion opts ] +++ []++-- | This function returns 'True' if the file should be rechecked.++recheckBecausePragmaOptionsChanged+ :: PragmaOptions+ -- ^ The options that were used to check the file.+ -> PragmaOptions+ -- ^ The options that are currently in effect.+ -> Bool+recheckBecausePragmaOptionsChanged used current =+ blankOut used /= blankOut current+ where+ -- "Blank out" irrelevant options.+ -- It does not matter what we replace them with, so we take the null value.+ blankOut opts = opts+ { _optShowImplicit = empty+ , _optShowIrrelevant = empty+ , _optVerbose = empty+ , _optProfiling = empty+ , _optPostfixProjections = empty+ , _optCompileMain = empty+ , _optCaching = empty+ , _optCountClusters = empty+ , _optPrintPatternSynonyms = empty+ , _optShowIdentitySubstitutions = empty+ , _optKeepPatternVariables = empty+ }++-- | Descriptions of infective and coinfective options.++data InfectiveCoinfectiveOption = ICOption+ { icOptionActive :: PragmaOptions -> Bool+ -- ^ Is the option active?+ , icOptionDescription :: String+ -- ^ A description of the option (typically a flag that activates+ -- the option).+ , icOptionKind :: InfectiveCoinfective+ -- ^ Is the option (roughly speaking) infective or coinfective?+ , icOptionOK :: PragmaOptions -> PragmaOptions -> Bool+ -- ^ This function returns 'True' exactly when, from the+ -- perspective of the option in question, the options in the+ -- current module (the first argument) are compatible with the+ -- options in a given imported module (the second argument).+ , icOptionWarning ::+ PragmaOptions -> PragmaOptions -> TopLevelModuleName -> Doc+ -- ^ A warning message that should be used if this option is not+ -- used correctly. The given module name is the name of an+ -- imported module for which 'icOptionOK' failed for the first two+ -- arguments.+ }++-- | A standard infective option: If the option is active in an+-- imported module, then it must be active in the current module.++infectiveOption+ :: (PragmaOptions -> Bool)+ -- ^ Is the option active?+ -> String+ -- ^ A description of the option.+ -> InfectiveCoinfectiveOption+infectiveOption opt s = ICOption+ { icOptionActive = opt+ , icOptionDescription = s+ , icOptionKind = Infective+ , icOptionOK = \current imported ->+ opt imported <= opt current+ , icOptionWarning = \_ _ m -> fsep $+ pwords "Importing module" ++ [pretty $ PrintRange m] ++ pwords "using the" +++ [text s] ++ pwords "flag from a module which does not."+ }++-- | A standard coinfective option: If the option is active in the+-- current module, then it must be active in all imported modules.++coinfectiveOption+ :: (PragmaOptions -> Bool)+ -- ^ Is the option active?+ -> String+ -- ^ A description of the option.+ -> InfectiveCoinfectiveOption+coinfectiveOption opt s = ICOption+ { icOptionActive = opt+ , icOptionDescription = s+ , icOptionKind = Coinfective+ , icOptionOK = \current imported ->+ opt current <= opt imported+ , icOptionWarning = \_ _ m -> fsep $+ pwords "Importing module" ++ [pretty $ PrintRange m] +++ pwords "not using the" ++ [text s] +++ pwords "flag from a module which does."+ }++-- | Infective and coinfective options.+--+-- Note that @--cubical[=full]@ and @--cubical=erased@ are \"jointly+-- infective\": if one of them is used in one module, then one or the+-- other must be used in all modules that depend on this module.++infectiveCoinfectiveOptions :: [InfectiveCoinfectiveOption]+infectiveCoinfectiveOptions =+ [ coinfectiveOption optSafe "--safe"+ , coinfectiveOption optWithoutK "--without-K"+ , cubicalCompatible+ , coinfectiveOption (not . optUniversePolymorphism)+ "--no-universe-polymorphism"+ , coinfectiveOption (not . optCumulativity) "--no-cumulativity"+ , coinfectiveOption optLevelUniverse "--level-universe"+ , infectiveOption (isJust . optCubical) "--cubical[={full,erased,no-glue}]"+ , cubicalWithoutGlue+ , infectiveOption optGuarded "--guarded"+ , infectiveOption optIrrelevance "--irrelevance"+ , infectiveOption optProp "--prop"+ , infectiveOption optTwoLevel "--two-level"+ , infectiveOption optRewriting "--rewriting"+ , infectiveOption optLocalRewriting "--local-rewriting"+ , infectiveOption optSizedTypes "--sized-types"+ , infectiveOption optGuardedness "--guardedness"+ , infectiveOption optFlatSplit "--flat-split"+ , infectiveOption optPolarity "--polarity"+ , infectiveOption optCohesion "--cohesion"+ , infectiveOption optErasure "--erasure"+ , infectiveOption optFunext "--erased-funext"+ , infectiveOption optPropext "--erased-propext"+ , infectiveOption optQuotients "--erased-quotients"+ , ICOption+ { icOptionActive =+ (C.ErasedMatches mempty /=) . _optErasedMatches+ , icOptionDescription =+ "--erased-matches"+ , icOptionKind =+ Infective+ , icOptionOK = \current imported ->+ optErasedMatches imported <= optErasedMatches current+ , icOptionWarning = \current imported m -> fsep $+ pwords "Importing module" ++ [pretty $ PrintRange m] +++ pwords "using (effectively) the flags" +++ [text $ showEffectiveErasedMatchFlags $+ optErasedMatches imported] +++ pwords "from a module which uses the flags" +++ [text $ showEffectiveErasedMatchFlags $+ optErasedMatches current]+ }+ ]+ where+ cubicalCompatible =+ (coinfectiveOption optCubicalCompatible "--cubical=compatible")+ { icOptionOK = \current imported ->+ -- One must use --cubical=compatible in the imported module if+ -- it is used in the current module, except if the current+ -- module also uses --with-K and not --safe, and the imported+ -- module uses --with-K.+ if optCubicalCompatible current+ then optCubicalCompatible imported+ ||+ not (optWithoutK imported)+ &&+ not (optWithoutK current)+ &&+ not (optSafe current)+ else True+ }++ cubicalWithoutGlue =+ let flagName = "--cubical=no-glue" in+ (infectiveOption (\o -> optCubical o == Just CWithoutGlue) flagName)+ { icOptionOK = \current imported ->+ -- If the current module uses Cubical without glue,+ -- then the imported modules cannot use glue.+ case (optCubical current, optCubical imported) of+ (Just CWithoutGlue, Just CFull) -> False+ (Just CWithoutGlue, Just CErased) -> False+ _ -> True+ , icOptionWarning = \_ _ m -> fsep $+ pwords "Importing module" ++ [pretty $ PrintRange m] +++ pwords "which might contain glue to a module with the option" +++ pwords (flagName ++ ".")+ }++inputFlag :: FilePath -> Flag CommandLineOptions+inputFlag f o =+ case optInputFile o of+ Nothing -> return $ o { optInputFile = Just f }+ Just _ -> throwError "only one input file allowed"++printAgdaDataDirFlag :: Flag CommandLineOptions+printAgdaDataDirFlag o = return $ o { optPrintAgdaDataDir = True }++printAgdaAppDirFlag :: Flag CommandLineOptions+printAgdaAppDirFlag o = return $ o { optPrintAgdaAppDir = True }++printOptionsFlag :: Flag CommandLineOptions+printOptionsFlag o = return $ o { optPrintOptions = True }++setupFlag :: Flag CommandLineOptions+setupFlag o = return $ o { optSetup = True }++versionFlag :: Flag CommandLineOptions+versionFlag o = return $ o { optPrintVersion = Just PrintAgdaVersion }++numericVersionFlag :: Flag CommandLineOptions+numericVersionFlag o = return $ o { optPrintVersion = Just PrintAgdaNumericVersion }++helpFlag :: Maybe String -> Flag CommandLineOptions+helpFlag Nothing o = return $ o { optPrintHelp = Just GeneralHelp }+helpFlag (Just str) o = case string2HelpTopic str of+ Just hpt -> return $ o { optPrintHelp = Just (HelpFor hpt) }+ Nothing -> throwError $ concat+ [ "unknown help topic ", str, " (", printHelpTopics "topic", ")" ]++-- | Helper to explain @--help@.+printHelpTopics :: String -> String+printHelpTopics mvar = concat+ [ "available"+ , ifNull mvar "" {-else-} \ topic -> " " ++ String.pluralS allHelpTopics topic+ , ": "+ , intercalate ", " $ map fst allHelpTopics+ ]++emacsModeFlag :: String -> Flag CommandLineOptions+emacsModeFlag s o+ | s == EmacsMode.setupFlag = add EmacsModeSetup+ | s == EmacsMode.compileFlag = add EmacsModeCompile+ | s == EmacsMode.locateFlag = add EmacsModeLocate+ | otherwise = throwError $ concat+ [ "unknown emacs-mode command "+ , s+ , " ("+ , printEmacsModeCommands "commands"+ , ")"+ ]+ where+ add m = return o{ optEmacsMode = Set.insert m $ optEmacsMode o }++printEmacsModeCommands :: String -> String+printEmacsModeCommands mvar = concat+ [ "available"+ , ifNull mvar "" {-else-} \ cmd -> " " ++ cmd+ , ": "+ , intercalate ", " emacsModeValues+ ]++safeFlag :: Flag PragmaOptions+safeFlag o = do+ return $ o { _optSafe = Value True+ , _optSizedTypes = setDefault False (_optSizedTypes o)+ }++syntacticEqualityFlag :: Maybe String -> Flag PragmaOptions+syntacticEqualityFlag s o =+ case fuel of+ Left err -> throwError err+ Right fuel -> return $ o { _optSyntacticEquality = fuel }+ where+ fuel = case s of+ Nothing -> Right Strict.Nothing+ Just s -> case readMaybe s of+ Just n | n >= 0 -> Right (Strict.Just n)+ _ -> Left $ "Not a natural number: " ++ s++ignoreInterfacesFlag :: Flag CommandLineOptions+ignoreInterfacesFlag o = return $ o { optIgnoreInterfaces = True }++ignoreAllInterfacesFlag :: Flag CommandLineOptions+ignoreAllInterfacesFlag o = return $ o { optIgnoreAllInterfaces = True }++noWriteInterfacesFlag :: Flag CommandLineOptions+noWriteInterfacesFlag o = return $ o { optWriteInterfaces = False }++traceImportsFlag :: Maybe String -> Flag CommandLineOptions+traceImportsFlag arg o = do+ mode <- case arg of+ Nothing -> return 2+ Just str -> case reads str :: [(Integer, String)] of+ [(n, "")] -> return n+ _ -> throwError $ "unknown printing option " ++ str ++ ". Please specify a number."+ return $ o { optTraceImports = mode }++diagnosticsColour :: Maybe String -> Flag CommandLineOptions+diagnosticsColour arg o = case arg of+ Just "auto" -> pure o { optDiagnosticsColour = AutoColour }+ Just "always" -> pure o { optDiagnosticsColour = AlwaysColour }+ Just "never" -> pure o { optDiagnosticsColour = NeverColour }+ Just str -> throwError $ "unknown colour option " ++ str ++ ". Please specify one of auto, always, or never."+ Nothing -> pure o { optDiagnosticsColour = AutoColour }++parallelismFlag :: Maybe String -> Flag CommandLineOptions+parallelismFlag (Just n) o = case readMaybe n of+ Just 0 -> pure o { optParallelChecking = Parallel Nothing }+ Just 1 -> pure o { optParallelChecking = Sequential }+ Just i -> pure o { optParallelChecking = Parallel (Just i) }+ Nothing -> throwError $ "the parallelism should be a number, and " <> show n <> " isn't."+parallelismFlag Nothing o = pure o { optParallelChecking = Parallel Nothing }+++-- | Side effect for setting '_optUseUnicode'.+--+unicodeOrAsciiEffect :: UnicodeOrAscii -> Flag PragmaOptions+unicodeOrAsciiEffect a o = return $ UNSAFE.unsafePerformIO $ do+ unsafeSetUnicodeOrAscii a+ return o++ghciInteractionFlag :: Flag CommandLineOptions+ghciInteractionFlag o = return $ o { optGHCiInteraction = True }++jsonInteractionFlag :: Flag CommandLineOptions+jsonInteractionFlag o = return $ o { optJSONInteraction = True }++interactionExitFlag :: Flag CommandLineOptions+interactionExitFlag o = return $ o { optExitOnError = True }++vimFlag :: Flag CommandLineOptions+vimFlag o = return $ o { optGenerateVimFile = True }++onlyScopeCheckingFlag :: Flag CommandLineOptions+onlyScopeCheckingFlag o = return $ o { optOnlyScopeChecking = True }++transliterateFlag :: Flag CommandLineOptions+transliterateFlag o = return $ o { optTransliterate = True }++mdOnlyAgdaBlocksFlag :: Bool -> Flag CommandLineOptions+mdOnlyAgdaBlocksFlag b o = return $ o { optMdOnlyAgdaBlocks = b }++withKFlag :: Flag PragmaOptions+withKFlag =+ -- with-K is the opposite of --without-K, so collapse default when disabling --without-K+ lensOptWithoutK (lensCollapseDefault $ const $ pure False)+++withoutKFlag :: Flag PragmaOptions+withoutKFlag o = return $ o+ { _optWithoutK = Value True+ , _optFlatSplit = setDefault False $ _optFlatSplit o+ }++-- A unified flag for all cubical variants:+-- [--cubical] defaults to Cubical+-- [--cubical={compatible,no-glue,erased,full}] corresponds to the 4 options.+cubicalFlagOptArg :: Maybe String -> Flag PragmaOptions+cubicalFlagOptArg s = case s of+ Nothing -> cubicalFlag CFull+ Just "full" -> cubicalFlag CFull+ Just "erased" -> cubicalFlag CErased+ Just "no-glue" -> cubicalFlag CWithoutGlue+ Just "compatible" -> cubicalCompatibleFlag+ _ -> return $ throwError+ "Cubical variant can be omitted or one of {compatible, no-glue, erased, full}."++cubicalCompatibleFlag :: Flag PragmaOptions+cubicalCompatibleFlag o =+ return $ o+ { _optCubicalCompatible = Value True+ , _optWithoutK = setDefault True $ _optWithoutK o+ , _optFlatSplit = setDefault False $ _optFlatSplit o+ }++cubicalFlag+ :: Cubical -- ^ Which variant of Cubical Agda?+ -> Flag PragmaOptions+cubicalFlag variant o =+ return $ o+ { _optCubical = Just variant+ , _optCubicalCompatible = setDefault True $ _optCubicalCompatible o+ , _optWithoutK = setDefault True $ _optWithoutK o+ -- Andreas, 2026-01-20, issue #8326+ -- Do not set optTwoLevel here, but have been implied by optCubical+ -- , _optTwoLevel = setDefault True $ _optTwoLevel o+ , _optFlatSplit = setDefault False $ _optFlatSplit o+ }++instanceDepthFlag :: String -> Flag PragmaOptions+instanceDepthFlag s o = do+ d <- integerArgument "--instance-search-depth" s+ return $ o { _optInstanceSearchDepth = d }++inversionMaxDepthFlag :: String -> Flag PragmaOptions+inversionMaxDepthFlag s o = do+ d <- integerArgument "--inversion-max-depth" s+ return $ o { _optInversionMaxDepth = d }++interactiveFlag :: Flag CommandLineOptions+interactiveFlag o = return $ o { optInteractive = True }++compileDirFlag :: FilePath -> Flag CommandLineOptions+compileDirFlag f o = return $ o { optCompileDir = Just f }++includeFlag :: FilePath -> Flag CommandLineOptions+includeFlag d o = return $ o { optIncludePaths = d : optIncludePaths o }++libraryFlag :: String -> Flag CommandLineOptions+libraryFlag s o = return $ o { optLibraries = optLibraries o ++ [parseLibName s] }++overrideLibrariesFileFlag :: String -> Flag CommandLineOptions+overrideLibrariesFileFlag s o =+ return $ o+ { optOverrideLibrariesFile = Just s+ , optUseLibs = True+ }++noDefaultLibsFlag :: Flag CommandLineOptions+noDefaultLibsFlag o = return $ o { optDefaultLibs = False }++noLibsFlag :: Flag CommandLineOptions+noLibsFlag o = return $ o { optUseLibs = False }++verboseFlag :: String -> Flag PragmaOptions+verboseFlag s o =+ do (k,n) <- parseVerbose s+ return $+ o { _optVerbose =+ Strict.Just $ Trie.insert k n $+ case _optVerbose o of+ Strict.Nothing -> Trie.singleton [] 1+ Strict.Just v -> v+ }+ where+ parseVerbose :: String -> OptM ([VerboseKeyItem], VerboseLevel)+ parseVerbose s = case parseVerboseKey s of+ [] -> usage+ s0:ss0 -> do+ let (ss, s) = initLast1 s0 ss0+ -- The last entry must be a number.+ n <- maybe usage return $ readMaybe $ toList s+ return (ss, n)+ usage = throwError "argument to verbose should be on the form x.y.z:N or N"++profileFlag :: String -> Flag PragmaOptions+profileFlag s o =+ case addProfileOption s (_optProfiling o) of+ Left err -> throwError err+ Right prof -> pure o{ _optProfiling = prof }++warningModeFlag :: String -> Flag PragmaOptions+warningModeFlag s o = case warningModeUpdate s of+ Right upd -> return $ o { _optWarningMode = upd (_optWarningMode o) }+ Left err -> o <$ tell1 (WarningProblem err)++terminationDepthFlag :: String -> Flag PragmaOptions+terminationDepthFlag s o =+ do k <- maybe usage return $ readMaybe s+ when (k < 1) $ usage -- or: turn termination checking off for 0+ return $ o { _optTerminationDepth = CutOff $ k-1 }+ where usage = throwError "argument to termination-depth should be >= 1"++confluenceCheckFlag :: ConfluenceCheck -> Flag PragmaOptions+confluenceCheckFlag f o = return $ o { _optConfluenceCheck = Just f }++noConfluenceCheckFlag :: Flag PragmaOptions+noConfluenceCheckFlag o = return $ o { _optConfluenceCheck = Nothing }++exactSplitFlag :: Bool -> Flag PragmaOptions+exactSplitFlag b o = do+ return $ conformWarningsToOption exactSplitWarnings (const b)+ $ o { _optExactSplit = Value b }+++integerArgument :: String -> String -> OptM Int+integerArgument flag s = maybe usage return $ readMaybe s+ where+ usage = throwError $ "option '" ++ flag ++ "' requires an integer argument"++-- | This list should contain all options defined in this module.+standardOptions :: [OptDescr (Flag CommandLineOptions)]+standardOptions = concat $+ map (fmap lensPragmaOptions) (snd latexPragmaOptions) :+ map snd optionGroups++optionGroups :: [(String, [OptDescr (Flag CommandLineOptions)])]+optionGroups =+ [ informationOptions+ , mainModeOptions+ , projectOptions+ , essentialConfigurationOptions+ , literateOptions+ , diagnosticsOptions+ , emb warningPragmaOptions+ , emb checkerPragmaOptions+ , emb languagePragmaOptions+ , emb universePragmaOptions+ , emb modalityPragmaOptions+ , emb terminationPragmaOptions+ , emb patternMatchingPragmaOptions+ , emb instancePragmaOptions+ , emb rewritingPragmaOptions+ , emb equalityCheckingPragmaOptions+ , emb optimizationPragmaOptions+ , emb printerPragmaOptions+ , emb backendPragmaOptions+ , compilationOptions+ , emb debuggingPragmaOptions+ , emb reflectionPragmaOptions+ ]+ where+ emb = second $ map $ fmap lensPragmaOptions++-- | Options that make Agda print information, setup itself etc.+-- Agda can execute these tasks in addition to a main mode \/ frontend \/ interactor.+informationOptions :: (String, [OptDescr (Flag CommandLineOptions)])+informationOptions = ("Setup and basic information",)+ [ Option ['V'] ["version"] (NoArg versionFlag)+ ("print version information")++ , Option [] ["numeric-version"] (NoArg numericVersionFlag)+ ("print version number")++ , Option ['?'] ["help"] (OptArg helpFlag helpArg)+ ("print help; " ++ printHelpTopics helpArg)++ , Option [] ["emacs-mode"] (ReqArg emacsModeFlag emacsModeArg) $ concat+ [ "administer the Emacs Agda mode; "+ , printEmacsModeCommands (emacsModeArg ++ "s")+ , "; confer --help=emacs-mode"+ ]++ , Option [] ["print-agda-dir"] (NoArg printAgdaDataDirFlag)+ ("print the Agda data directory")++ , Option [] ["print-agda-app-dir"] (NoArg printAgdaAppDirFlag)+ ("print $AGDA_DIR")++ , Option [] ["print-agda-data-dir"] (NoArg printAgdaDataDirFlag)+ ("print the Agda data directory")++ , Option [] ["print-options"] (NoArg printOptionsFlag)+ ("print the full list of Agda's options")++ , Option [] ["setup"] (NoArg setupFlag)+ ("setup the Agda data directory")+ ]++mainModeOptions :: (String, [OptDescr (Flag CommandLineOptions)])+mainModeOptions = ("Main modes of operation",)+ [ Option [] ["build-library"] (NoArg \ o -> return o{ optBuildLibrary = True })+ "build all modules included by the @.agda-lib@ file in the current directory"++ , Option ['I'] ["interactive"] (NoArg interactiveFlag)+ "start in interactive mode"++ , Option [] ["interaction"] (NoArg ghciInteractionFlag)+ "for use with the Emacs mode"+ , Option [] ["interaction-json"] (NoArg jsonInteractionFlag)+ "for use with other editors such as Atom"+ ]++projectOptions :: (String, [OptDescr (Flag CommandLineOptions)])+projectOptions = ("Project configuration",)+ [ Option ['i'] ["include-path"] (ReqArg includeFlag "DIR")+ "look for imports in DIR"+ , Option ['l'] ["library"] (ReqArg libraryFlag "LIB")+ "use library LIB"+ , Option [] ["library-file"] (ReqArg overrideLibrariesFileFlag "FILE")+ "use FILE instead of the standard libraries file"+ , Option [] ["no-libraries"] (NoArg noLibsFlag)+ "don't use any library files"+ , Option [] ["no-default-libraries"] (NoArg noDefaultLibsFlag)+ "don't use default libraries"+ ]++essentialConfigurationOptions :: (String, [OptDescr (Flag CommandLineOptions)])+essentialConfigurationOptions = ("Essential type checker configuration",)+ [ Option [] ["ignore-interfaces"] (NoArg ignoreInterfacesFlag)+ "ignore interface files (re-type check everything)"+ , Option [] ["no-write-interfaces"] (NoArg noWriteInterfacesFlag)+ "don't write interface files to the filesystem"++ , Option [] ["only-scope-checking"] (NoArg onlyScopeCheckingFlag)+ "only scope-check the top-level module, do not type-check it"+ , Option [] ["interaction-exit-on-error"]+ (NoArg interactionExitFlag)+ "exit if a type error is encountered"+ , Option [] ["vim"] (NoArg vimFlag)+ "generate Vim highlighting files"+ , Option ['j'] ["parallel"] (OptArg parallelismFlag "N")+ "use N cores for parallel type-checking. The default is 1, 0 (or no argument) means auto."+ ]++literateOptions :: (String, [OptDescr (Flag CommandLineOptions)])+literateOptions = ("Literate Agda",)+ [ Option [] ["literate-markdown-only-agda-blocks"] (NoArg $ mdOnlyAgdaBlocksFlag True)+ "in literate Markdown/Typst, only treat code blocks marked ```agda as Agda code"+ , Option [] ["no-literate-markdown-only-agda-blocks"] (NoArg $ mdOnlyAgdaBlocksFlag False)+ "treat all code blocks as Agda code (default)"+ ]++diagnosticsOptions :: (String, [OptDescr (Flag CommandLineOptions)])+diagnosticsOptions = ("Diagnostics and output",) $+ [ Option [] ["colour", "color"] (OptArg diagnosticsColour (intercalate "|" colorValues))+ ("whether or not to colour diagnostics output. The default is auto.")++ , Option [] ["trace-imports"] (OptArg traceImportsFlag traceImportsArg)+ (concat+ [ "print information about accessed modules during type-checking (where "+ , traceImportsArg+ , "="+ , intercalate "|" traceImportsValues+ , ", default: 2)"+ ])++ , Option [] ["transliterate"] (NoArg transliterateFlag)+ "transliterate unsupported code points when printing to stdout/stderr"+ ] ++ map (fmap lensPragmaOptions) (snd unicodePragmaOptions)++compilationOptions :: (String, [OptDescr (Flag CommandLineOptions)])+compilationOptions = ("Compilation options",) $+ [ Option [] ["compile-dir"] (ReqArg compileDirFlag "DIR")+ ("directory for compiler output (default: the project root)")+ ] ++ map (fmap lensPragmaOptions) (snd compilationPragmaOptions)++-- | Command line options of previous versions of Agda.+-- Should not be listed in the usage info, put parsed by GetOpt for good error messaging.+deadStandardOptions :: [OptDescr (Flag CommandLineOptions)]+deadStandardOptions =+ [ removedOption "sharing" msgSharing+ , removedOption "no-sharing" msgSharing+ , removedOption "local-interfaces" "(in 2.8.0)"+ , Option [] ["ignore-all-interfaces"] (NoArg ignoreAllInterfacesFlag) -- not deprecated! Just hidden+ "ignore all interface files (re-type check everything, including builtin files)"+ -- https://github.com/agda/agda/issues/3522#issuecomment-461010898+ -- The option is "developer only", so it is hidden.+ -- However, it is documented in the user manual.+ ] ++ map (fmap lensPragmaOptions) deadPragmaOptions+ where+ msgSharing = "(in favor of the Agda abstract machine)"++-- | This list should contain all pragma options except for the 'deadPragmaOptions'.+pragmaOptions :: [OptDescr (Flag PragmaOptions)]+pragmaOptions = concat $ map snd+ [ unicodePragmaOptions+ , warningPragmaOptions+ , checkerPragmaOptions+ , languagePragmaOptions+ , universePragmaOptions+ , modalityPragmaOptions+ , terminationPragmaOptions+ , patternMatchingPragmaOptions+ , instancePragmaOptions+ , rewritingPragmaOptions+ , equalityCheckingPragmaOptions+ , optimizationPragmaOptions+ , printerPragmaOptions+ , latexPragmaOptions+ , backendPragmaOptions+ , compilationPragmaOptions+ , debuggingPragmaOptions+ , reflectionPragmaOptions+ ]++warningPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+warningPragmaOptions = ("Warnings",) $ concat+ [ [ Option ['W'] ["warning"] (ReqArg warningModeFlag warningArg)+ ("set warning flags. See --help=warning.")+ ]+ ]++-- | Controlling extra checks (termination etc.).+checkerPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+checkerPragmaOptions = ("Consistency checking",) $ concat+ [ pragmaFlag "allow-unsolved-metas" lensOptAllowUnsolved+ "succeed and create interface file regardless of unsolved meta variables" ""+ Nothing+ , pragmaFlag "allow-incomplete-matches" lensOptAllowIncompleteMatch+ "succeed and create interface file regardless of incomplete pattern matches" ""+ Nothing+ , pragmaFlag "positivity-check" lensOptPositivityCheck+ "warn about not strictly positive data types" ""+ Nothing+ , pragmaFlag "termination-check" lensOptTerminationCheck+ "warn about possibly nonterminating code" ""+ Nothing+ , [ Option [] ["termination-depth"] (ReqArg terminationDepthFlag "N")+ ("allow termination checker to count decrease/increase upto N (default N=" +++ show (1 + defaultCutOff) ++ ")")+ ]+ , [ Option [] ["safe"] (NoArg safeFlag)+ "disable postulates, unsafe OPTION pragmas and primEraseEquality, implies --no-sized-types"+ ]+ , pragmaFlag "allow-exec" lensOptAllowExec+ "allow system calls to trusted executables with primExec" ""+ Nothing+ ]++-- | Main flavor of language.+languagePragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+languagePragmaOptions = ("Language variant",)+ [ Option [] ["without-K"] (NoArg withoutKFlag)+ "turn on checks to make code compatible with HoTT (e.g. disabling the K rule). Implies --no-flat-split."+ , Option [] ["cubical"] (OptArg cubicalFlagOptArg "VARIANT")+ $ "enable cubical features (e.g. overloads lambdas for paths)." +++ "Accepted variants: full, erased, no-glue, compatible (default: full)."+ -- For backwards compatibility only. Use "--cubical=compatible" instead.+ , Option [] ["cubical-compatible"] (NoArg cubicalCompatibleFlag)+ "turn on generation of auxiliary code required for --cubical, implies --without-K"+ -- For backwards compatibility only. Use "--cubical=erased" instead.+ , Option [] ["erased-cubical"] (NoArg $ cubicalFlag CErased)+ "enable cubical features (some only in erased settings), implies --cubical=compatible"+ , Option [] ["with-K"] (NoArg withKFlag)+ "enable the K rule in pattern matching (default)"+ ]++universePragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+universePragmaOptions = ("Universes",) $ concat+ [ pragmaFlag "type-in-type" lensOptNoUniverseCheck+ "ignore universe levels" "(this makes Agda inconsistent)"+ Nothing+ , pragmaFlag "omega-in-omega" lensOptOmegaInOmega+ "enable typing rule Setω : Setω" "(this makes Agda inconsistent)"+ Nothing+ , pragmaFlag "cumulativity" lensOptCumulativity+ "enable subtyping of universes" "(e.g. Set =< Set₁)"+ $ Just "disable subtyping of universes"+ , pragmaFlag "irrelevance" lensOptIrrelevance+ "enable the use of the irrelevance modality" ""+ $ Just "disable the use of the irrelevance modality"+ , pragmaFlag "prop" lensOptProp+ "enable the use of the Prop universe" ""+ $ Just "disable the use of the Prop universe"+ , pragmaFlag "level-universe" lensOptLevelUniverse+ "place type Level in a dedicated LevelUniv universe" ""+ Nothing+ , pragmaFlag "two-level" lensOptTwoLevel+ "enable the use of SSet* universes" ""+ Nothing+ , pragmaFlag "universe-polymorphism" lensOptUniversePolymorphism+ "enable universe polymorphism" ""+ $ Just "disable universe polymorphism"+ , pragmaFlag "large-indices" lensOptLargeIndices+ "allow constructors with large indices" ""+ $ Just "always check that constructor arguments live in universes compatible with that of the datatype"++ , pragmaFlag "import-sorts" lensOptImportSorts+ "implicitly import Agda.Primitive using (Set; Prop) at the start of each top-level module" ""+ $ Just "disable the implicit import of Agda.Primitive using (Set; Prop) at the start of each top-level module"+ , pragmaFlag "load-primitives" lensOptLoadPrimitives+ "load primitives modules" ""+ $ Just "disable loading of primitive modules completely (implies --no-import-sorts)"+ ]++modalityPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+modalityPragmaOptions = ("Modalities",) $ concat+ [ pragmaFlag "erasure" lensOptErasure+ "enable erasure" ""+ Nothing+ , [ Option [] ["erased-matches"]+ (OptArg parseErasedMatchesArg erasedMatchesArg)+ ("allow erased matches of the given (comma-separated) " +++ erasedMatchesArg ++ " (" +++ intercalate ", " erasedMatchesValues ++ ")")+ , Option [] ["no-erased-matches"]+ (NoArg (parseErasedMatchesArg (Just "none")))+ "a synonym for --erased-matches=none"+ ]+ , pragmaFlag "erase-record-parameters" lensOptEraseRecordParameters+ "mark all parameters of record modules as erased" "(implies --erasure)"+ Nothing+ , pragmaFlag "cohesion" lensOptCohesion+ "enable the cohesion modalities" "(in particular @flat)"+ Nothing+ , pragmaFlag "flat-split" lensOptFlatSplit+ "allow splitting on `(@flat x : A)' arguments" "(implies --cohesion)"+ Nothing+ , pragmaFlag "guarded" lensOptGuarded+ "enable @lock/@tick attributes" ""+ $ Just "disable @lock/@tick attributes"+ , pragmaFlag "polarity" lensOptPolarity+ "enable the polarity modalities (@++, @mixed, etc.) and their integration in the positivity checker" ""+ Nothing+ , pragmaFlag "occurrence-analysis" lensOptOccurrence+ "enable automated occurrence analysis for functions"+ "(can be slow)"+ Nothing+ , pragmaFlag "erased-funext" lensOptFunext+ "allow the use of Agda.Builtin.Erased.Funext" ""+ Nothing+ , pragmaFlag "erased-propext" lensOptPropext+ "allow the use of Agda.Builtin.Erased.Propext" ""+ Nothing+ , pragmaFlag "erased-quotients" lensOptQuotients+ "allow the use of Agda.Builtin.Erased.Quotient" ""+ Nothing+ , pragmaFlag "irrelevant-projections" lensOptIrrelevantProjections+ "enable projection of irrelevant record fields and similar irrelevant definitions" "(inconsistent)"+ $ Just "disable projection of irrelevant record fields and similar irrelevant definitions"+ , pragmaFlag "experimental-irrelevance" lensOptExperimentalIrrelevance+ "enable potentially unsound irrelevance features" "(irrelevant levels, irrelevant data matching)"+ Nothing+ ]++terminationPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+terminationPragmaOptions = ("Termination and productivity checking",) $ concat+ [ pragmaFlag "sized-types" lensOptSizedTypes+ "enable sized types" "(inconsistent with --guardedness)"+ $ Just "disable sized types"+ , pragmaFlag "guardedness" lensOptGuardedness+ "enable constructor-based guarded corecursion" "(inconsistent with --sized-types)"+ $ Just "disable constructor-based guarded corecursion"+ , pragmaFlag "forced-argument-recursion" lensOptForcedArgumentRecursion+ "allow recursion on forced constructor arguments" ""+ Nothing+ ]++patternMatchingPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+patternMatchingPragmaOptions = ("Pattern matching",) $ concat+ [ pragmaFlag "pattern-matching" lensOptPatternMatching+ "enable pattern matching" ""+ $ Just "disable pattern matching completely"+ , pragmaFlag "copatterns" lensOptCopatterns+ "enable definitions by copattern matching" ""+ $ Just "disable definitions by copattern matching"+ , [ Option [] ["exact-split"] (NoArg $ exactSplitFlag True)+ "require all clauses in a definition to hold as definitional equalities (unless marked CATCHALL)"+ , Option [] ["no-exact-split"] (NoArg $ exactSplitFlag False)+ "do not require all clauses in a definition to hold as definitional equalities (default)"+ ]+ , pragmaFlag "hidden-argument-puns" lensOptHiddenArgumentPuns+ "interpret the patterns {x} and {{x}} as puns" ""+ Nothing+ , pragmaFlag "injective-type-constructors" lensOptInjectiveTypeConstructors+ "enable injective type constructors" "(makes Agda anti-classical and possibly inconsistent)"+ $ Just "disable injective type constructors"+ , [ Option [] ["inversion-max-depth"] (ReqArg inversionMaxDepthFlag "N")+ "set maximum depth for pattern match inversion to N (default: 50)"+ ]+ ]++instancePragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+instancePragmaOptions = ("Instance search",) $ concat+ [ [ Option [] ["instance-search-depth"] (ReqArg instanceDepthFlag "N")+ "set instance search depth to N (default: 500)"+ ]+ , backtrackingInstancesOption+ , pragmaFlag "qualified-instances" lensOptQualifiedInstances+ "use instances with qualified names" ""+ Nothing+ , pragmaFlag "experimental-lazy-instances" lensOptExperimentalLazyInstances+ "enable experimental, faster implementation of instance search" ""+ Nothing+ ]++rewritingPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+rewritingPragmaOptions = ("Rewriting and confluence",) $ concat+ [ pragmaFlag "rewriting" lensOptRewriting+ "enable declaration and use of REWRITE rules" ""+ $ Just "disable declaration and use of REWRITE rules"+ , [ Option [] ["local-confluence-check"] (NoArg $ confluenceCheckFlag LocalConfluenceCheck)+ "enable checking of local confluence of REWRITE rules"+ , Option [] ["confluence-check"] (NoArg $ confluenceCheckFlag GlobalConfluenceCheck)+ "enable global confluence checking of REWRITE rules (more restrictive than --local-confluence-check)"+ , Option [] ["no-confluence-check"] (NoArg noConfluenceCheckFlag)+ "disable confluence checking of REWRITE rules (default)"+ ]+ , pragmaFlag "local-rewriting" lensOptLocalRewriting+ "enable declaring local rewrite rules with the @rewrite annotation" ""+ $ Just "disable local rewrite rules"+ ]++equalityCheckingPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+equalityCheckingPragmaOptions = ("Definitional equality",) $ concat+ [ pragmaFlag "eta-equality" lensOptEta+ "default records to eta-equality" ""+ $ Just "default records to no-eta-equality"+ , lossyUnificationOption+ , requireUniqueMetaSolutionsOptions+ , [ Option [] ["no-syntactic-equality"] (NoArg $ syntacticEqualityFlag (Just "0"))+ "disable the syntactic equality shortcut in the conversion checker"+ , Option [] ["syntactic-equality"] (OptArg syntacticEqualityFlag "FUEL")+ "give the syntactic equality shortcut FUEL units of fuel (default: unlimited)"+ ]+ , pragmaFlag "auto-inline" lensOptAutoInline+ "enable automatic compile-time inlining" ""+ $ Just "disable automatic compile-time inlining, only definitions marked INLINE will be inlined"++ , pragmaFlag "fast-reduce" lensOptFastReduce+ "enable reduction using the Agda Abstract Machine" ""+ $ Just "disable reduction using the Agda Abstract Machine"+ , pragmaFlag "call-by-name" lensOptCallByName+ "use call-by-name evaluation instead of call-by-need" ""+ $ Just "use call-by-need evaluation"+ ]++optimizationPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+optimizationPragmaOptions = ("Type checker optimizations",) $ concat+ [ pragmaFlag "caching" lensOptCaching+ "enable caching of typechecking" ""+ $ Just "disable caching of typechecking"+ , pragmaFlag "double-check" lensOptDoubleCheck+ "enable double-checking of all terms using the internal typechecker" ""+ $ Just "disable double-checking of terms"+ , pragmaFlag "forcing" lensOptForcing+ "enable the forcing analysis for data constructors" "(optimisation)"+ $ Just "disable the forcing analysis"+ , pragmaFlag "projection-like" lensOptProjectionLike+ "enable the analysis whether function signatures liken those of projections" "(optimisation)"+ $ Just "disable the projection-like analysis"+ , pragmaFlag "infer-absurd-clauses" lensOptInferAbsurdClauses+ "eliminate absurd clauses in case splitting and coverage checking" ""+ $ Just "do not automatically eliminate absurd clauses in case splitting and coverage checking (can speed up type-checking)"+ , pragmaFlag "save-metas" lensOptSaveMetas+ "save meta-variables" ""+ Nothing+ ]++unicodePragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+unicodePragmaOptions = ("Unicode",) $ concat+ [ pragmaFlag' "unicode" lensOptUseUnicode unicodeOrAsciiEffect+ "use unicode characters when printing terms" ""+ Nothing+ ]++-- | Controlling the rendering of Agda expressions.+printerPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+printerPragmaOptions = ("Checker output",) $ concat+ [ pragmaFlag "show-implicit" lensOptShowImplicit+ "show implicit arguments when printing" ""+ Nothing+ , pragmaFlag "show-irrelevant" lensOptShowIrrelevant+ "show irrelevant arguments when printing" ""+ Nothing+ , pragmaFlag "show-identity-substitutions" lensOptShowIdentitySubstitutions+ "show all arguments of metavariables when printing terms" ""+ Nothing+ , pragmaFlag "print-pattern-synonyms" lensOptPrintPatternSynonyms+ "keep pattern synonyms when printing terms" ""+ $ Just "expand pattern synonyms when printing terms"+ , pragmaFlag "postfix-projections" lensOptPostfixProjections+ "prefer postfix projection notation" ""+ $ Just "prefer prefix projection notation"+ , pragmaFlag "keep-pattern-variables" lensOptKeepPatternVariables+ "don't replace variables with dot patterns during case splitting" ""+ $ Just "replace variables with dot patterns during case splitting"+ ]++-- | Latex pragma options.+latexPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+latexPragmaOptions = ("Latex options",) $ concat+ [ pragmaFlag "count-clusters" lensOptCountClusters+ "count extended grapheme clusters when generating LaTeX"+ ("(note that this flag " +++#ifdef COUNT_CLUSTERS+ "is not enabled in all builds"+#else+ "has not been enabled in this build"+#endif+ ++ " of Agda)")+ Nothing+ ]++-- | Backend-relevant options.+backendPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+backendPragmaOptions = ("Backend options",) $ concat+ [ pragmaFlag "keep-covering-clauses" lensOptKeepCoveringClauses+ "do not discard covering clauses" "(required for some external backends)"+ $ Just "discard covering clauses"+ ]++-- | Common options for compilers.+compilationPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+compilationPragmaOptions = ("Compilation options",) $ concat+ [ pragmaFlag "main" lensOptCompileMain+ "treat the requested module as the main module of a program when compiling" ""+ Nothing+ ]++-- | Debugging and profiling Agda.+debuggingPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+debuggingPragmaOptions = ("Debugging and profiling Agda",) $ concat+ [ [ Option ['v'] ["verbose"] (ReqArg verboseFlag "N")+ "set verbosity level to N. Only has an effect if Agda was built with the \"debug\" flag."+ , Option [] ["profile"] (ReqArg profileFlag profileArg)+ (concat+ [ "turn on profiling for "+ , profileArg+ , " (where "+ , profileArg+ , "="+ , intercalate "|" profileValues+ , ")"+ ])+ ]+ ]++reflectionPragmaOptions :: (String, [OptDescr (Flag PragmaOptions)])+reflectionPragmaOptions = ("Reflection",) $ concat+ [ pragmaFlag "quote-metas" lensOptQuoteMetas+ "allow unquoting to not get blocked by metas" ""+ Nothing+ ]++-- | Construct a flag of type @WithDefault _@+--+pragmaFlag :: (IsBool a, KnownBool b)+ => String+ -- ^ Long option name. Prepended with @no-@ for negative version.+ -> Lens' PragmaOptions (WithDefault' a b)+ -- ^ Field to switch.+ -> String+ -- ^ Explanation for positive option.+ -> String+ -- ^ Additional info for positive option (not repeated for negative option).+ -> Maybe String+ -- ^ Explanation for negative option.+ -> [OptDescr (Flag PragmaOptions)]+pragmaFlag long field = pragmaFlag' long field (const return)++-- | Construct a flag of type @WithDefault _@+--+pragmaFlag' :: (IsBool a, KnownBool b)+ => String+ -- ^ Long option name. Prepended with @no-@ for negative version.+ -> Lens' PragmaOptions (WithDefault' a b)+ -- ^ Field to switch.+ -> (a -> Flag PragmaOptions)+ -- ^ Given the new value, perform additional effect (can override field setting).+ -> String+ -- ^ Explanation for positive option.+ -> String+ -- ^ Additional info for positive option (not repeated for negative option).+ -> Maybe String+ -- ^ Explanation for negative option.+ -> [OptDescr (Flag PragmaOptions)]+ -- ^ Pair of option descriptors (positive, negative)+pragmaFlag' long field = pragmaFlagBool' long (field . lensCollapseDefault)++-- | Construct a flag of type 'IsBool'.+--+pragmaFlagBool :: (IsBool a)+ => String+ -- ^ Long option name. Prepended with @no-@ for negative version.+ -> Lens' PragmaOptions a+ -- ^ Field to switch.+ -> String+ -- ^ Explanation for positive option.+ -> String+ -- ^ Additional info for positive option (not repeated for negative option).+ -> Maybe String+ -- ^ Explanation for negative option.+ -> [OptDescr (Flag PragmaOptions)]+pragmaFlagBool long field = pragmaFlagBool' long field (const return)++-- | Construct a flag of type 'IsBool' with extra effect.+--+pragmaFlagBool' :: IsBool a+ => String+ -- ^ Long option name. Prepended with @no-@ for negative version.+ -> Lens' PragmaOptions a+ -- ^ Field to switch.+ -> (a -> Flag PragmaOptions)+ -- ^ Given the new value, perform additional effect (can override field setting).+ -> String+ -- ^ Explanation for positive option.+ -> String+ -- ^ Additional info for positive option (not repeated for negative option).+ -> Maybe String+ -- ^ Explanation for negative option.+ -> [OptDescr (Flag PragmaOptions)]+ -- ^ Pair of option descriptors (positive, negative)+pragmaFlagBool' long field effect pos info neg =+ [ Option [] [no b long] (flag b) (def b $ expl b) | b <- [True,False] ]+ where+ b0 = defaultPragmaOptions ^. field+ no b = applyUnless b ("no-" ++)+ flag b = NoArg $ effect a . set field a+ where a = fromBool b+ def b = applyWhen (fromBool b == b0) (++ " (default)")+ expl b = if b then unwords1 [pos, info] else fromMaybe ("do not " ++ pos) neg++pragmaOptionDefault :: KnownBool b => (PragmaOptions -> WithDefault b) -> Bool -> String+pragmaOptionDefault f b =+ if b == collapseDefault (f defaultPragmaOptions) then " (default)" else ""++lossyUnificationOption :: [OptDescr (Flag PragmaOptions)]+lossyUnificationOption =+ pragmaFlag "lossy-unification" lensOptFirstOrder+ "enable heuristically unifying `f es = f es'` by unifying `es = es'`"+ "even when it could lose solutions"+ Nothing++requireUniqueMetaSolutionsOptions :: [OptDescr (Flag PragmaOptions)]+requireUniqueMetaSolutionsOptions =+ pragmaFlag "require-unique-meta-solutions" lensOptRequireUniqueMetaSolutions+ "require unique solutions to meta variables"+ "even when it could lose solutions"+ Nothing++backtrackingInstancesOption :: [OptDescr (Flag PragmaOptions)]+backtrackingInstancesOption =+ pragmaFlag "backtracking-instance-search" lensOptBacktrackingInstances+ "allow backtracking during instance search"+ ""+ Nothing++-- | Pragma options of previous versions of Agda.+-- Should not be listed in the usage info, put parsed by GetOpt for good error messaging.+deadPragmaOptions :: [OptDescr (Flag PragmaOptions)]+deadPragmaOptions = concat+ [ map (uncurry removedOption)+ [ ("guardedness-preserving-type-constructors"+ , "")+ , ("no-coverage-check"+ , inVersion "2.5.1") -- see issue #1918+ , ("no-sort-comparison"+ , "")+ , ("subtyping"+ , inVersion "2.6.3") -- see issue #5427+ , ("no-subtyping"+ , inVersion "2.6.3") -- see issue #5427+ , ("no-flat-split", inVersion "2.6.3") -- See issue #6263.+ ]+ , map (uncurry renamedNoArgOption)+ [ ( "experimental-lossy-unification"+ , headWithDefault __IMPOSSIBLE__ lossyUnificationOption+ )+ , ( "overlapping-instances"+ , headWithDefault __IMPOSSIBLE__ backtrackingInstancesOption+ )+ ]+ ]+ where+ inVersion = ("in version " ++)++-- | Generate a dead options that just error out saying this option has been removed.+removedOption ::+ String+ -- ^ The name of the removed option.+ -> String+ -- ^ Optional: additional remark, like in which version the option was removed.+ -> OptDescr (Flag a)+removedOption name remark = Option [] [name] (NoArg $ const $ throwError msg) msg+ where+ msg = unwords ["Option", "--" ++ name, "has been removed", remark]++-- | Generate a deprecated option that resolves to another option.+renamedNoArgOption ::+ String+ -- ^ The deprecated long option name.+ -> OptDescr (Flag a)+ -- ^ The new option.+ -> OptDescr (Flag a)+ -- ^ The old option which additionally emits a 'RenamedOption' warning.+renamedNoArgOption old = \case+ Option _ [new] (NoArg flag) description ->+ Option [] [old] (NoArg flag') $ concat [description, " (DEPRECATED, use --", new, ")"]+ where+ flag' o = tell1 (OptionRenamed old new) >> flag o+ _ -> __IMPOSSIBLE__++-- | Used for printing usage info.+-- Does not include the dead options.+standardOptions_ :: [OptDescr ()]+standardOptions_ = map void standardOptions++-- | Simple interface for Agda.Utils.GetOpt+-- Could be moved to Agda.Utils.Options (does not exist yet)+getOptSimple+ :: [String] -- ^ command line argument words+ -> [OptDescr (Flag opts)] -- ^ options handlers+ -> (String -> Flag opts) -- ^ handler of non-options (only one is allowed)+ -> Flag opts -- ^ combined opts data structure transformer+getOptSimple argv opts fileArg = \ defaults ->+ case getOpt' (ReturnInOrder fileArg) opts argv of+ (o, _, [] , [] ) -> foldl (>>=) (return defaults) o+ (_, _, unrecognized, errs) -> throwError $ umsg ++ emsg++ where+ ucap = "Unrecognized " ++ String.pluralS unrecognized "option" ++ ":"+ ecap = String.pluralS errs "Option error" ++ ":"+ umsg = if null unrecognized then "" else unlines $+ ucap : map suggest unrecognized+ emsg = if null errs then "" else unlines $+ ecap : errs++ -- Suggest alternatives that are at most 3 typos away++ longopts :: [String]+ longopts = map ("--" ++) $ concatMap (\ (Option _ long _ _) -> long) opts++ dist :: String -> String -> Int+ dist s t = restrictedDamerauLevenshteinDistance defaultEditCosts s t++ close :: String -> String -> Maybe (Int, String)+ close s t = let d = dist s t in if d <= 3 then Just (d, t) else Nothing++ closeopts :: String -> [(Int, String)]+ closeopts s = mapMaybe (close s) longopts++ alts :: String -> [List1 String]+ alts s = map (fmap snd) $ List1.groupOn fst $ closeopts s++ suggest :: String -> String+ suggest s = case alts s of+ [] -> s+ as : _ -> s ++ " (did you mean " ++ sugs as ++ " ?)"++ sugs :: List1 String -> String+ sugs (a :| []) = a+ sugs as = "any of " ++ List1.unwords as++-- | Parse options from an options pragma.+parsePragmaOptions+ :: OptionsPragma+ -- ^ Pragma options.+ -> CommandLineOptions+ -- ^ Command-line options which should be updated.+ -> OptM PragmaOptions+parsePragmaOptions argv opts = do+ ps <- getOptSimple+ (pragmaStrings argv)+ (deadPragmaOptions ++ pragmaOptions)+ (\s _ -> throwError $ "Bad option in pragma: " ++ s)+ (optPragmaOptions opts)+ checkPragmaOptions ps++-- | Parse options for a plugin.+parsePluginOptions :: [String] -> [OptDescr (Flag opts)] -> Flag opts+parsePluginOptions argv opts =+ getOptSimple argv opts+ (\s _ -> throwError $+ "Internal error: Flag " ++ s ++ " passed to a plugin")++-- | Removes RTS options from a list of options.++stripRTS :: [String] -> [String]+stripRTS [] = []+stripRTS ("--RTS" : argv) = argv+stripRTS (arg : argv)+ | is "+RTS" arg = stripRTS $ drop 1 $ dropWhile (not . is "-RTS") argv+ | otherwise = arg : stripRTS argv+ where+ is x arg = [x] == take 1 (words arg)++------------------------------------------------------------------------+-- Erased matches++-- | Different options for @--erased-matches@.++data ErasedMatchOption+ = None+ -- ^ No erased matches are allowed.+ | Empty+ -- ^ Erased matches are allowed for the empty type.+ | NonDependent+ -- ^ Erased matches are allowed for single-constructor,+ -- non-indexed data types.+ | Restricted+ -- ^ @[]-cong@ is allowed.+ | Unrestricted+ -- ^ All kinds of erased matches are allowed for+ -- single-constructor data types (indexed or not).+ deriving (Show, Generic, Enum, Bounded)++-- | Parses the argument of @--erased-matches@.++parseErasedMatchesArg :: Maybe String -> Flag PragmaOptions+parseErasedMatchesArg ms opts =+ (\allowed -> over' lensOptErasedMatches (<> allowed) opts) <$>+ case ms of+ Nothing -> return C.ErasedMatchesDefaultOn+ Just s ->+ mconcat . map (C.ErasedMatches . allowedErasedMatches) <$>+ mapM parse (chopWhen (== ',') s)+ where+ parse "none" = return None+ parse "empty" = return Empty+ parse "non-dependent" = return NonDependent+ parse "restricted" = return Restricted+ parse "unrestricted" = return Unrestricted+ parse s = throwError $+ "Unknown argument to --erased-matches: " ++ s++-- | Translates from 'ErasedMatchOption' to 'AllowedErasedMatches'.++allowedErasedMatches :: ErasedMatchOption -> AllowedErasedMatches+allowedErasedMatches None =+ mempty+allowedErasedMatches Empty = C.AllowedErasedMatches+ { emEmpty = True+ , emNonDependent = False+ , emDependent = Strict.Nothing+ }+allowedErasedMatches NonDependent = C.AllowedErasedMatches+ { emEmpty = False+ , emNonDependent = True+ , emDependent = Strict.Nothing+ }+allowedErasedMatches Restricted = C.AllowedErasedMatches+ { emEmpty = False+ , emNonDependent = False+ , emDependent = Strict.Just C.Restricted+ }+allowedErasedMatches Unrestricted = C.AllowedErasedMatches+ { emEmpty = False+ , emNonDependent = True+ , emDependent = Strict.Just C.Unrestricted+ }++-- | Translates from 'AllowedErasedMatches' to lists of+-- 'ErasedMatchOption's.++erasedMatchOptions :: AllowedErasedMatches -> List1 ErasedMatchOption+erasedMatchOptions allowed = List1.fromListSafe (None :| []) flags+ where+ flags =+ (if C.emEmpty allowed then [Empty] else []) +++ (if C.emUnrestricted allowed then [Unrestricted] else+ (if C.emRestricted allowed then [Restricted] else []) +++ (if C.emNonDependent allowed then [NonDependent] else []))++-- | Turns a non-empty list of 'ErasedMatchOption's into a+-- corresponding instance of @--erased-matches@.++showErasedMatchFlags :: List1 ErasedMatchOption -> String+showErasedMatchFlags opts =+ "--erased-matches=" +++ intercalate "," (fmap showOpt (List1.toList opts))+ where+ showOpt = \case+ None -> "none"+ Empty -> "empty"+ NonDependent -> "non-dependent"+ Unrestricted -> "unrestricted"+ Restricted -> "restricted"++-- | An instance of @--erased-matches@ that would lead to the given+-- 'AllowedErasedMatches' record.++showEffectiveErasedMatchFlags :: AllowedErasedMatches -> String+showEffectiveErasedMatchFlags =+ showErasedMatchFlags . erasedMatchOptions
@@ -0,0 +1,158 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++-- | Tools for shell completion scripts.+--+-- Bash completion takes a list of completion words (the current commandline)+-- and a completion index (the current word to be completed) and returns+-- a list of possible completions of this word.+--+-- To do bash completion /inside/ Agda, we need to pass this data to Agda.+-- So we equip Agda with a special option @--bash-completion@ which takes+-- first the completion index (number) and then the completion words.+-- E.g.+--+-- @+-- agda --bash-completion 1 --warn+-- @+--+-- This should complete @--warn@ to @--warning=@.+--+-- @+-- agda --bash-completion 1 --warning=+-- @+--+-- This would list the possible values for WARNING.+-- However, these are too many and one may get the annoying question+-- whether one really wants to see all.+-- So we should only produce a small enough list.+-- We show the common prefixes of all values up to a maximal number (threshold).+-- To this end, we may store the possible completion as a compressed trie+-- where instead of letters we use maximal non-overlapping prefixes.+-- Then we compute a fair truncation of the tree so that the+-- total number of leaves stay below the threshold.++module Agda.Interaction.Options.BashCompletion where++import Prelude hiding (null)++import Data.Bifunctor ( first )+import Data.Map qualified as Map+import Data.Maybe+import Text.Read ( readMaybe )++import Agda.Interaction.Options.Arguments ( optionValues )+import Agda.Interaction.Options.Base ( standardOptions )++import Agda.Utils.Function ( applyWhenJust )+import Agda.Utils.GetOpt ( OptDescr(..), ArgDescr(..) )+import Agda.Utils.List ( (!!!) )+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Null+import Agda.Utils.Trie (Trie)+import Agda.Utils.Trie qualified as Trie+import Agda.Utils.CompressedTrie qualified as CompressedTrie++type Help = String++printedOptions :: [String]+printedOptions = map fst printedOptionsWithHelp++printedOptionsWithHelp :: [(String, Help)]+printedOptionsWithHelp = printOptions standardOptions++-- | Print just the names of the given options (e.g. for bash completion scripts).+-- For long options with finitely enumerable arguments, print all variants.+printOptions :: [OptDescr a] -> [(String, Help)]+printOptions = concat . map \case+ Option short long arg help -> concat $+ map (,help) ss :+ map (,help) ls :+ map (map (,noHelp))+ [ [ s ++ a | s <- ss ] +++ [ l ++ "=" ++ a | l <- ls ]+ | a <- as+ ]+ where+ ss :: [String]+ ss = [ '-' : s : "" | s <- short ]+ ls :: [String]+ ls = [ "--" ++ l | l <- long ]+ as :: [String]+ as = fromMaybe [] do+ t <- argType+ Map.lookup t optionValues+ argType :: Maybe String+ argType = case arg of+ NoArg{} -> Nothing+ ReqArg _ t -> Just t+ OptArg _ t -> Just t+ noHelp :: Help+ noHelp = ""++-- | Should the 'completions' be truncated to a given maximum number of prefixes?+type Truncate = Maybe Int++-- | Handle the option @--bash-complete@.+-- It expects the index @COMP_CWORD@ as first argument+-- that tells which of the following arguments @COMP_WORDS@+-- is supposed to be completed.+--+-- It either returns an error message or the result for @COMPREPLY@.+--+bashComplete ::+ Truncate+ -- ^ Truncate completions suggestions? To how many?+ -> [String]+ -- ^ Arguments following @--bash-complete@.+ -> Either String String+ -- ^ Error or @COMPREPLY@.+bashComplete tr = \case+ cword : words+ | Just i <- readMaybe cword+ , length words > i+ , Just w <- words !!! i+ -> case complete tr w of+ Completion (Just s) _ -> return s+ Completion ms cs ->+ return $ unlines $ concat+ [ maybeToList ms+ , map fst cs+ ]+ _args -> Left "Error: Wrong invokation of --bash-complete"++-- | The result of an invokation of (bash) completion.+data Completion = Completion+ { extended :: Maybe String+ -- ^ If 'Nothing', then the completion word cannot become a valid option ever.+ , completions :: [(String, Help)]+ -- ^ If 'null', the 'extended' word cannot be further completed.+ }++-- | Cached trie of options.+optionsTrie :: Trie Char Help+optionsTrie = Trie.fromList printedOptionsWithHelp++-- | Complete the given word as an option.+complete :: Truncate -> String -> Completion+complete trunc s+ -- No completion possible?+ | null t =+ Completion Nothing []+ -- Unambiguously (partially) complete by at least one letter.+ | Just (k, _t') <- CompressedTrie.isSingleBranch t =+ Completion (Just $ s ++ List1.toList k) compls+ -- No unambiguous completion possible: just return suggestions.+ | otherwise =+ Completion Nothing compls+ where+ -- The possible suffixes.+ t = CompressedTrie.compress $ Trie.delete [] $ Trie.lookupTrie s optionsTrie+ -- The possibly truncated list of completions.+ compls = map (first (s ++)) $ CompressedTrie.toList $ CompressedTrie.substLeaves f tt+ where+ -- t truncated.+ tt = applyWhenJust trunc CompressedTrie.truncateSizeWithLeaves t+ -- Replace empty leaves by "..." branches.+ f = maybe (CompressedTrie.singleton "..." empty) CompressedTrie.root
@@ -0,0 +1,140 @@+-- | Default values for the options.++module Agda.Interaction.Options.Default where++import Agda.Interaction.Options.ProfileOptions () -- Null instance+import Agda.Interaction.Options.Types+import Agda.Interaction.Options.Warnings ( defaultWarningMode )+import Agda.Termination.CutOff ( defaultCutOff )+import Agda.Utils.Null+import Agda.Utils.WithDefault++import Agda.Utils.Impossible++defaultOptions :: CommandLineOptions+defaultOptions = Options+ { optProgramName = "agda"+ , optInputFile = Nothing+ , optIncludePaths = []+ , optAbsoluteIncludePaths = []+ , optLibraries = []+ , optOverrideLibrariesFile = Nothing+ , optDefaultLibs = True+ , optUseLibs = True+ , optTraceImports = 1+ , optTrustedExecutables = empty+ , optPrintAgdaDataDir = False+ , optPrintAgdaAppDir = False+ , optPrintOptions = False+ , optPrintVersion = Nothing+ , optPrintHelp = Nothing+ , optBuildLibrary = False+ , optSetup = False+ , optEmacsMode = empty+ , optInteractive = False+ , optGHCiInteraction = False+ , optJSONInteraction = False+ , optExitOnError = False+ , optCompileDir = Nothing+ , optGenerateVimFile = False+ , optIgnoreInterfaces = False+ , optIgnoreAllInterfaces = False+ , optWriteInterfaces = True+ , optPragmaOptions = defaultPragmaOptions+ , optOnlyScopeChecking = False+ , optTransliterate = False+ , optDiagnosticsColour = AutoColour+ , optMdOnlyAgdaBlocks = False+ , optParallelChecking = Sequential+ }++defaultPragmaOptions :: PragmaOptions+defaultPragmaOptions = PragmaOptions+ { _optShowImplicit = Default+ , _optShowGeneralized = Default+ , _optShowIrrelevant = Default+ , _optUseUnicode = Default -- UnicodeOk+ , _optVerbose = empty+ , _optProfiling = empty+ , _optIrrelevance = Default+ , _optProp = Default+ , _optLevelUniverse = Default+ , _optTwoLevel = Default+ , _optAllowUnsolved = Default+ , _optAllowIncompleteMatch = Default+ , _optPositivityCheck = Default+ , _optTerminationCheck = Default+ , _optTerminationDepth = defaultCutOff+ , _optUniverseCheck = Default+ , _optOmegaInOmega = Default+ , _optCumulativity = Default+ , _optSizedTypes = Default+ , _optGuardedness = Default+ , _optInjectiveTypeConstructors = Default+ , _optUniversePolymorphism = Default+ , _optIrrelevantProjections = Default+ , _optExperimentalIrrelevance = Default+ , _optWithoutK = Default+ , _optCubicalCompatible = Default+ , _optCopatterns = Default+ , _optPatternMatching = Default+ , _optExactSplit = Default+ , _optHiddenArgumentPuns = Default+ , _optEta = Default+ , _optForcing = Default+ , _optProjectionLike = Default+ , _optErasure = Default+ , _optErasedMatches = mempty+ , _optEraseRecordParameters = Default+ , _optRewriting = Default+ , _optLocalRewriting = Default+ , _optCubical = Nothing+ , _optGuarded = Default+ , _optFirstOrder = Default+ , _optRequireUniqueMetaSolutions = Default+ , _optPostfixProjections = Default+ , _optKeepPatternVariables = Default+ , _optInferAbsurdClauses = Default+ , _optInstanceSearchDepth = 500+ , _optBacktrackingInstances = Default+ , _optQualifiedInstances = Default+ , _optInversionMaxDepth = 50+ , _optSafe = Default+ , _optDoubleCheck = Default+ , _optSyntacticEquality = empty+ , _optWarningMode = defaultWarningMode+ , _optCompileMain = Default+ , _optCaching = Default+ , _optCountClusters = Default+ , _optAutoInline = Default+ , _optPrintPatternSynonyms = Default+ , _optFastReduce = Default+ , _optCallByName = Default+ , _optConfluenceCheck = Nothing+ , _optCohesion = Default+ , _optFlatSplit = Default+ , _optPolarity = Default+ , _optOccurrence = Default+ , _optFunext = Default+ , _optPropext = Default+ , _optQuotients = Default+ , _optImportSorts = Default+ , _optLoadPrimitives = Default+ , _optAllowExec = Default+ , _optSaveMetas = Default+ , _optShowIdentitySubstitutions = Default+ , _optKeepCoveringClauses = Default+ , _optForcedArgumentRecursion = Default+ , _optLargeIndices = Default+ , _optExperimentalLazyInstances = Default+ , _optQuoteMetas = Default+ }++-- Null instances++instance Null CommandLineOptions where+ empty = defaultOptions+ null = __IMPOSSIBLE__++instance Null PragmaOptions where+ empty = defaultPragmaOptions
@@ -0,0 +1,562 @@+-- | Provide names for the errors Agda throws.Options/Er++module Agda.Interaction.Options.Errors where++import Control.DeepSeq ( NFData )+import Data.List ( sort )+import Generic.Data ( FiniteEnumeration(..) )+import GHC.Generics ( Generic )++import Agda.Syntax.Common ( ConstructorOrPatternSynonym(..) )++import Agda.Utils.Function ( applyWhenJust )+import Agda.Utils.List ( initWithDefault )+import Agda.Utils.Impossible ( __IMPOSSIBLE__ )++-- | Extra information for error 'CannotQuoteTerm'.++data CannotQuoteTerm+ = CannotQuoteTermHidden+ | CannotQuoteTermNothing+ deriving (Show, Generic, Enum, Bounded)++-- | What kind of declaration?+--+-- See also 'Agda.Syntax.Concrete.Definitions.Types.DataRecOrFun'.++data DataRecOrFun_+ = DataName_ -- ^ Name of a data type.+ | RecName_ -- ^ Name of a record type.+ | FunName_ -- ^ Name of a function.+ deriving (Show, Generic, Enum, Bounded)++-- | The reason for an 'ErasedDatatype' error.++data ErasedDatatypeReason+ = SeveralConstructors+ -- ^ There are several constructors.+ | ErasedMatchesDisabledEmpty+ -- ^ Erased matches are disabled for empty types.+ | ErasedMatchesDisabledNonDependent+ -- ^ Erased matches are disabled for non-indexed,+ -- single-constructor types.+ | ErasedMatchesDisabledDependent+ -- ^ Erased matches are disabled for indexed, single-constructor+ -- types.+ deriving (Show, Generic, Enum, Bounded)++-- | Things not allowed in dot patterns.++data NotAllowedInDotPatterns+ = LetExpressions+ | PatternLambdas+ deriving (Show, Generic, Enum, Bounded)++-- | Reasons for error 'NotAValidLetBinding'.++data NotAValidLetBinding+ = MissingRHS+ | NotAValidLetPattern+ | WhereClausesNotAllowed+ | CopatternsNotAllowed+ -- These cannot be triggered:+ -- -- | EllipsisNotAllowed+ -- -- | WithPatternsNotAllowed+ deriving (Show, Generic, Enum, Bounded)++-- | Reasons for error 'NotAValidLetExpression'.++data NotAValidLetExpression+ = MissingBody+ deriving (Show, Generic, Enum, Bounded)++-- | Symbolic name of an Agda error.++data ErrorName+ -- Error groups (alphabetically) with named sub errors+ = ExecError_ ExecError_+ | GHCBackendError_ GHCBackendError_+ | ImpossibleConstructor_ NegativeUnification_+ | InteractionError_ InteractionError_+ | JSBackendError_ JSBackendError_+ | NicifierError_ DeclarationException_+ | SplitError_ SplitError_+ | UnquoteError_ UnquoteError_+ -- Generic errors (alphabetically)+ | CompilationError_+ | CustomBackendError_+ | InternalError_+ | LibraryError_+ | NonFatalErrors_+ | NotImplemented_+ | NotSupported_+ | OptionError_+ | SyntaxError_+ | UserError_+ -- Other errors (alphabetically)+ | AbsentRHSRequiresAbsurdPattern_+ | AbstractConstructorNotInScope_+ | AmbiguousConstructor_+ | AmbiguousField_+ | AmbiguousModule_+ | AmbiguousName_+ | AmbiguousOverloadedProjection_+ | AmbiguousParseForApplication_+ | AmbiguousParseForLHS_+ | AmbiguousProjection_+ | AmbiguousTopLevelModuleName_+ | AsPatternInPatternSynonym_+ | AttributeKindNotEnabled_+ | BackendDoesNotSupportOnlyScopeChecking_+ | BadArgumentsToPatternSynonym_+ | BothWithAndRHS_+ | BuiltinInParameterisedModule_+ | BuiltinMustBeConstructor_+ | BuiltinMustBeData_+ | BuiltinMustBeDef_+ | BuiltinMustBeFunction_+ | BuiltinMustBePostulate_+ | CannotApply_+ | CannotEliminateWithPattern_+ | CannotEliminateWithProjection_+ | CannotGeneralizeEtaExpandable_+ | CannotGenerateHCompClause_+ | CannotGenerateTransportClause_+ | CannotGenerateTransportLocalRewrite_+ | CannotQuote_ CannotQuote_+ | CannotQuoteTerm_ CannotQuoteTerm+ | CannotResolveAmbiguousPatternSynonym_+ | CannotRewriteByNonEquation_+ | CannotSolveSizeConstraints_+ | CantResolveOverloadedConstructorsTargetingSameDatatype_+ | ClashingDefinition_+ | ClashingModule_+ | ComatchingDisabledForRecord_+ | ConstructorDoesNotTargetGivenType_+ | ConstructorPatternInWrongDatatype_+ | ContradictorySizeConstraint_+ | CopatternHeadNotProjection_+ | CubicalCompilationNotSupported_+ | CubicalNotErasure_+ | CubicalPrimitiveNotFullyApplied_+ | CyclicModuleDependency_+ | DatatypeIndexPolarity_+ | DeBruijnIndexOutOfScope_+ | DeclarationsAfterTopLevelModule_+ | DefinitionInDifferentModule_+ | DefinitionIsErased_+ | DefinitionIsIrrelevant_+ | DoNotationError_+ | DoesNotMentionTicks_+ | DotPatternInPatternSynonym_+ | DuplicateBuiltinBinding_+ | DuplicateConstructors_+ | DuplicateFields_+ | DuplicateImports_+ | DuplicateOverlapPragma_+ | DuplicatePrimitiveBinding_+ | EmptyTypeOfSizes_+ | EtaPragmaVsNoEtaEquality_+ | ExpectedBindingForParameter_+ | ExpectedIntervalLiteral_+ | FieldOutsideRecord_+ | FaceConstraintDisjunction_+ | FaceConstraintUnsatisfiable_+ | FileNotFound_+ | ForcedConstructorNotInstantiated_+ | FunctionTypeInSizeUniv_+ | GeneralizationFailed_+ | GeneralizationPrepruneErrorRefinedContext_+ | GeneralizationPrepruneErrorCyclicDependencies_+ | GeneralizationPrepruneErrorFailedToInstantiate_+ | GeneralizeCyclicDependency_+ | GeneralizeNotSupportedHere_+ | GeneralizedVarInLetOpenedModule_+ | ModuleNameHashCollision_+ | HidingMismatch_+ | IdiomBracketError_+ | InvalidBuiltin_+ | InvalidDottedExpression_+ | IllTypedPatternAfterWithAbstraction_+ | IlltypedRewriteRule_+ | IllegalDeclarationBeforeTopLevelModule_+ | IllegalHidingInPostfixProjection_+ | IllegalInstanceVariableInPatternSynonym_+ | IllegalLetInTelescope_+ | IllegalPatternInTelescope_+ | IllformedProjectionPatternAbstract_+ | IllformedProjectionPatternConcrete_+ | IncorrectTypeForRewriteRelation_+ | InstanceNoCandidate_+ | InstanceSearchDepthExhausted_+ | InvalidFileName_+ | InvalidModalTelescopeUse_+ | InvalidPattern_+ | InvalidProjectionParameter_+ | InvalidPun_ ConstructorOrPatternSynonym+ | InvalidTypeSort_+ | LambdaIsErased_+ | LibTooFarDown_+ | LiteralTooBig_+ | MacroResultTypeMismatch_+ | MetaCannotDependOn_+ | MetaErasedSolution_+ | MetaIrrelevantSolution_+ | MismatchedProjectionsError_+ | MissingBindingsForTelescopeVariables_+ | MissingTypeSignature_ DataRecOrFun_+ | ModuleArityMismatch_+ | ModuleDefinedInOtherFile_+ | ModuleNameDoesntMatchFileName_+ | ModuleNameUnexpected_+ | MultipleFixityDecls_+ | MultiplePolarityPragmas_+ | ExplicitPolarityVsPragma_+ | ConstructorNameOfNonRecord_+ | NamedWhereModuleInRefinedContext_+ | NamedWhereModuleUnderWith_+ | NeedOptionAllowExec_+ | NeedOptionCopatterns_+ | NeedOptionCubical_+ | NeedOptionPatternMatching_+ | NeedOptionIrrelevance_+ | NeedOptionProp_+ | NeedOptionRewriting_+ | NeedOptionSizedTypes_+ | NeedOptionTwoLevel_+ | NeedOptionUniversePolymorphism_+ | NegativeLiteralInPattern_+ | NoBindingForBuiltin_+ | NoBindingForPrimitive_+ | NoKnownRecordWithSuchFields_+ | NoParameterOfName_+ | NoParseForApplication_+ | NoParseForLHS_+ | NoSuchBuiltinName_+ | NoSuchModule_+ | NoSuchPrimitiveFunction_+ | NotAValidLetBinding_ (Maybe NotAValidLetBinding)+ | NotAValidLetExpression_ NotAValidLetExpression+ | NotAllowedInDotPatterns_ NotAllowedInDotPatterns+ | NotAnExpression_+ | NotInScope_+ | NotLeqSort_+ | NotValidBeforeField_+ | OverlappingProjects_+ | PathAbstractionFailed_+ | PatternInPathLambda_+ | PatternInSystem_+ | PatternSynonymArgumentShadows_ ConstructorOrPatternSynonym+ | PostulatedSizeInModule_+ | PrivateRecordField_+ | ProjectionIsIrrelevant_+ | QualifiedLocalModule_+ | QuantityMismatch_+ | RecordIsErased_+ | ReferencesFutureVariables_+ | RelevanceMismatch_+ | RepeatedNamesInImportDirective_+ | RepeatedVariablesInPattern_+ | ShadowedModule_+ | ShouldBeASort_+ | ShouldBeEmpty_+ | ShouldBePath_+ | ShouldBePi_+ | ShouldBeRecordPattern_+ | ShouldBeRecordType_+ | ShouldEndInApplicationOfTheDatatype_+ | SolvedButOpenHoles_+ | SortCannotDependOnItsIndex_+ | SortDoesNotAdmitDataDefinitions_+ | SortOfSplitVarError_+ | SplitInProp_+ | SplitOnAbstract_+ | SplitOnCoinductive_+ | SplitOnIrrelevant_+ | SplitOnNonEtaRecord_+ | SplitOnNonVariable_+ | SplitOnPartial_+ | SplitOnUnchecked_+ | SplitOnUnusableCohesion_+ | SplitOnUnusablePolarity_+ | TacticAttributeNotAllowed_+ | TooFewArgumentsToPatternSynonym_+ | TooFewPatternsInWithClause_+ | TooManyFields_+ | TooManyPatternsInWithClause_+ | TriedToCopyConstrainedPrim_+ | TrustedBuiltin_+ | TrustedPrimitive_+ | InvalidInstanceHeadType_+ | UnboundVariablesInPatternSynonym_+ | UnequalTerms_+ | UnequalTypes_+ | UnexpectedModalityAnnotationInParameter_+ | UnexpectedParameter_+ | UnexpectedTypeSignatureForParameter_+ | UnexpectedWithPatterns_+ | UnguardedEtaRecord_+ | UnknownBackend_+ | UnusableAtModality_+ | UnusedVariableInPatternSynonym_+ | VariableIsErased_+ | VariableIsIrrelevant_+ | VariableIsOfUnusableCohesion_+ | VariableIsOfUnusablePolarity_+ | WithClausePatternMismatch_+ | WithOnFreeVariable_+ | WrongAnnotationInLambda_+ | WrongArgInfoForPrimitive_+ | WrongCohesionInLambda_+ | WrongPolarityInLambda_+ | WrongHidingInApplication_+ | WrongHidingInLHS_+ | WrongHidingInLambda_+ | WrongHidingInProjection_+ | WrongIrrelevanceInLambda_+ | WrongNamedArgument_+ | WrongNamedArgumentInLHS_+ | WrongNumberOfConstructorArguments_+ | WrongQuantityInLambda_+ | WrongSharpArity_+ deriving (Show, Generic)+ deriving (Enum, Bounded) via (FiniteEnumeration ErrorName)++-- | Nicifier errors.+--+data DeclarationException_+ = AmbiguousConstructorN_+ | AmbiguousFunClauses_+ | BadMacroDef_+ | DisallowedInterleavedMutual_+ | DuplicateAnonDeclaration_+ | DuplicateDefinition_+ | InvalidMeasureMutual_+ | MissingWithClauses_+ | MultipleEllipses_+ | OpaqueInMutual_+ | UnfoldingOutsideOpaque_+ | UnquoteDefRequiresSignature_+ | WrongContentBlock_+ | WrongDefinition_+ deriving (Show, Generic)+ deriving (Enum, Bounded) via (FiniteEnumeration DeclarationException_)++data GHCBackendError_+ = ConstructorCountMismatch_+ | NotAHaskellType_ NotAHaskellType_+ | WrongTypeOfMain_+ deriving (Show, Generic)+ deriving (Enum, Bounded) via (FiniteEnumeration GHCBackendError_)++data JSBackendError_+ = BadCompilePragma_+ deriving (Show, Generic)+ deriving (Enum, Bounded) via (FiniteEnumeration JSBackendError_)++data InteractionError_+ = CannotGive_+ | CannotRefine_+ | CaseSplitError_+ | ExpectedIdentifier_+ | ExpectedApplication_+ | NoActionForInteractionPoint_+ | NoSuchInteractionPoint_+ | UnexpectedWhere_+ deriving (Show, Generic, Enum, Bounded)++data NegativeUnification_+ = UnifyConflict_+ | UnifyCycle_+ deriving (Show, Generic, Enum, Bounded)++data NotAHaskellType_+ = BadDontCare_+ | BadLambda_+ | BadMeta_+ | NoPragmaFor_+ | NotCompiled_+ | WrongPragmaFor_+ deriving (Show, Generic, Enum, Bounded)++data SplitError_+ = ErasedDatatype_ ErasedDatatypeReason+ | GenericSplitError_+ -- Specific errors+ | BlockedType_+ | CannotCreateMissingClause_+ | CoinductiveDatatype_+ | CosplitNoRecordType_+ | CosplitNoTarget_+ | NotADatatype_+ | UnificationStuck_+ deriving (Show, Generic)+ deriving (Enum, Bounded) via (FiniteEnumeration SplitError_)++data CannotQuote_+ = CannotQuoteAmbiguous_+ | CannotQuoteExpression_+ | CannotQuoteHidden_+ | CannotQuoteNothing_+ | CannotQuotePattern_+ deriving (Show, Generic, Enum, Bounded)++data ExecError_+ = ExeNotTrusted_+ | ExeNotFound_+ | ExeNotExecutable_+ deriving (Show, Generic, Enum, Bounded)++data UnquoteError_+ = BlockedOnMeta_+ | CannotDeclareHiddenFunction_+ | CommitAfterDef_+ | ConInsteadOfDef_+ | DefineDataNotData_+ | DefInsteadOfCon_+ | EscapingVariable_+ | MissingDeclaration_+ | MissingDefinition_+ | NakedUnquote_+ | NonCanonical_+ | PatLamWithoutClauses_+ | StaleMeta_+ | TooManyParameters_+ | UnboundName_+ deriving (Show, Generic, Enum, Bounded)++-- * Printing error names+------------------------------------------------------------------------++defaultErrorNameString :: Show a => a -> String+defaultErrorNameString = initWithDefault __IMPOSSIBLE__ . show++erasedDatatypeReasonString :: ErasedDatatypeReason -> String+erasedDatatypeReasonString = show++errorNameString :: ErrorName -> String+errorNameString = \case+ ExecError_ err -> "Exec." ++ execErrorNameString err+ GHCBackendError_ err -> "GHCBackend." ++ ghcBackendErrorNameString err+ ImpossibleConstructor_ err -> "ImpossibleConstructor." ++ negativeUnificationErrorNameString err+ InteractionError_ err -> "Interaction." ++ interactionErrorNameString err+ JSBackendError_ err -> "JSBackend." ++ jsBackendErrorNameString err+ NicifierError_ err -> "Syntax." ++ declarationExceptionNameString err+ SplitError_ err -> "SplitError." ++ splitErrorNameString err+ UnquoteError_ err -> "Unquote." ++ unquoteErrorNameString err+ CannotQuote_ err -> "CannotQuote." ++ cannotQuoteNameString err+ CannotQuoteTerm_ err -> "CannotQuoteTerm." ++ cannotQuoteTermNameString err+ InvalidPun_ err -> "InvalidPun." ++ constructorOrPatternSynonymNameString err+ MissingTypeSignature_ err -> "MissingTypeSignature." ++ dataRecOrFunString err+ NotAllowedInDotPatterns_ err -> "NotAllowedInDotPatterns." ++ notAllowedInDotPatternsString err+ NotAValidLetBinding_ merr -> applyWhenJust merr (\ err hd -> hd ++ "." ++ notAValidLetBindingString err) "NotAValidLetBinding"+ NotAValidLetExpression_ err -> "NotAValidLetExpression." ++ notAValidLetExpressionString err+ PatternSynonymArgumentShadows_ err -> "PatternSynonymArgumentShadows." ++ constructorOrPatternSynonymNameString err+ err -> defaultErrorNameString err++constructorOrPatternSynonymNameString :: ConstructorOrPatternSynonym -> String+constructorOrPatternSynonymNameString = \case+ IsConstructor -> "Constructor"+ IsPatternSynonym -> "PatternSynonym"++dataRecOrFunString :: DataRecOrFun_ -> String+dataRecOrFunString = \case+ DataName_ -> "Data"+ RecName_ -> "Record"+ FunName_ -> "Function"++declarationExceptionNameString :: DeclarationException_ -> String+declarationExceptionNameString = \case+ AmbiguousConstructorN_ -> "AmbiguousConstructor"+ err -> defaultErrorNameString err++ghcBackendErrorNameString :: GHCBackendError_ -> String+ghcBackendErrorNameString = \case+ NotAHaskellType_ err -> "NotAHaskellType." ++ notAHaskellTypeErrorNameString err+ err -> defaultErrorNameString err++jsBackendErrorNameString :: JSBackendError_ -> String+jsBackendErrorNameString = defaultErrorNameString++interactionErrorNameString :: InteractionError_ -> String+interactionErrorNameString = defaultErrorNameString++negativeUnificationErrorNameString :: NegativeUnification_ -> String+negativeUnificationErrorNameString = defaultErrorNameString++notAHaskellTypeErrorNameString :: NotAHaskellType_ -> String+notAHaskellTypeErrorNameString = defaultErrorNameString++notAValidLetBindingString :: NotAValidLetBinding -> String+notAValidLetBindingString = show++notAValidLetExpressionString :: NotAValidLetExpression -> String+notAValidLetExpressionString = show++notAllowedInDotPatternsString :: NotAllowedInDotPatterns -> String+notAllowedInDotPatternsString = show++splitErrorNameString :: SplitError_ -> String+splitErrorNameString = \case+ ErasedDatatype_ err -> "ErasedDatatype." ++ erasedDatatypeReasonString err+ err -> defaultErrorNameString err++cannotQuoteNameString :: CannotQuote_ -> String+cannotQuoteNameString = \case+ CannotQuoteAmbiguous_ -> "Ambiguous"+ CannotQuoteExpression_ -> "Expression"+ CannotQuoteHidden_ -> "Hidden"+ CannotQuoteNothing_ -> "Nothing"+ CannotQuotePattern_ -> "Pattern"++cannotQuoteTermNameString :: CannotQuoteTerm -> String+cannotQuoteTermNameString = \case+ CannotQuoteTermHidden -> "Hidden"+ CannotQuoteTermNothing -> "Nothing"++execErrorNameString :: ExecError_ -> String+execErrorNameString = defaultErrorNameString++unquoteErrorNameString :: UnquoteError_ -> String+unquoteErrorNameString = defaultErrorNameString++-- | Print list of errors.++helpErrors :: String+helpErrors = unlines $ concat+ [ [ "Agda's errors:"+ , ""+ ]+ , sort $ map errorNameString [minBound..maxBound]+ ]++-- * Print error messages+------------------------------------------------------------------------++verbalizeNotAValidLetBinding :: NotAValidLetBinding -> String+verbalizeNotAValidLetBinding = \case+ MissingRHS -> "Missing right hand side in let binding"+ NotAValidLetPattern -> "Not a valid let pattern"+ WhereClausesNotAllowed -> "`where` clauses not allowed in let bindings"+ CopatternsNotAllowed -> "Copatterns not allowed in let bindings"+ -- These cannot be triggered:+ -- EllipsisNotAllowed -> "`...` not allowed in let bindings"+ -- WithPatternsNotAllowed -> "`with` patterns not allowed in let bindings"++verbalizeNotAValidLetExpression :: NotAValidLetExpression -> String+verbalizeNotAValidLetExpression = \case+ MissingBody -> "Missing body in let-expression"++-- Instances+------------------------------------------------------------------------++deriving via (FiniteEnumeration (Maybe a))+ instance (Bounded a, Enum a) => Enum (Maybe a)+deriving via (FiniteEnumeration (Maybe a))+ instance (Bounded a) => Bounded (Maybe a)++instance NFData CannotQuoteTerm+instance NFData ErasedDatatypeReason+instance NFData NotAllowedInDotPatterns+instance NFData NotAValidLetBinding+instance NFData NotAValidLetExpression
@@ -0,0 +1,47 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.Options.HasOptions+ ( HasOptions (pragmaOptions, commandLineOptions)+ ) where++import Control.Monad.Except (ExceptT)+import Control.Monad.Reader (ReaderT)+import Control.Monad.State (StateT)+import Control.Monad.Trans ( MonadTrans, lift )+import Control.Monad.Trans.Identity (IdentityT)+import Control.Monad.Trans.Maybe (MaybeT)+import Control.Monad.Writer (WriterT)++import Agda.Interaction.Options.Types (PragmaOptions, CommandLineOptions)+import Agda.Utils.Update (ChangeT)+import Agda.Utils.ListT (ListT)+import Agda.Utils.StrictReader qualified as Strict+import Agda.Utils.StrictWriter qualified as Strict+import Agda.Utils.StrictState qualified as Strict++class (Functor m, Applicative m, Monad m) => HasOptions m where+ -- | Returns the pragma options which are currently in effect.+ pragmaOptions :: m PragmaOptions+ -- | Returns the command line options which are currently in effect.+ commandLineOptions :: m CommandLineOptions++ default pragmaOptions :: (HasOptions n, MonadTrans t, m ~ t n) => m PragmaOptions+ pragmaOptions = lift pragmaOptions++ default commandLineOptions :: (HasOptions n, MonadTrans t, m ~ t n) => m CommandLineOptions+ commandLineOptions = lift commandLineOptions++-- HasOptions lifts through monad transformers+-- (see default signatures in the HasOptions class).++instance HasOptions m => HasOptions (ChangeT m)+instance HasOptions m => HasOptions (ExceptT e m)+instance HasOptions m => HasOptions (IdentityT m)+instance HasOptions m => HasOptions (ListT m)+instance HasOptions m => HasOptions (MaybeT m)+instance HasOptions m => HasOptions (ReaderT r m)+instance HasOptions m => HasOptions (StateT s m)+instance (HasOptions m, Monoid w) => HasOptions (WriterT w m)+instance HasOptions m => HasOptions (Strict.ReaderT r m)+instance HasOptions m => HasOptions (Strict.StateT s m)+instance (HasOptions m, Monoid w) => HasOptions (Strict.WriterT w m)
@@ -0,0 +1,65 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.Options.Help+ (+ Help (..)+ , helpTopicUsage+ , string2HelpTopic+ , allHelpTopics+ ) where++import Control.DeepSeq++import GHC.Generics (Generic)++import Agda.Interaction.Options.Errors+import Agda.Interaction.Options.Warnings++import qualified Agda.Setup.EmacsMode as EmacsMode++-- | Interface to the @help@ function+data Help+ = GeneralHelp+ -- ^ General usage information+ | HelpFor HelpTopic+ -- ^ Specialised usage information about TOPIC+ deriving (Eq, Show, Generic)++instance NFData Help++-- | List of Help Topics+-- NOTA BENE:+-- You need to add each new topic together with its name to @allHelpTopics@++data HelpTopic+ = Warning+ | Error+ | EmacsMode+ deriving (Eq, Show, Generic)++instance NFData HelpTopic++allHelpTopics :: [(String, HelpTopic)]+allHelpTopics =+ [ ("warning" , Warning )+ , ("error" , Error )+ , ("emacs-mode", EmacsMode)+ ]++-- | Usage information generation++helpTopicUsage :: HelpTopic -> String+helpTopicUsage = \case+ Warning -> usageWarning+ Error -> helpErrors+ EmacsMode -> EmacsMode.help++-- | Conversion functions to strings++string2HelpTopic :: String -> Maybe HelpTopic+string2HelpTopic = flip lookup allHelpTopics++-- UNUSED Liang-Ting Chen 2019-07-15+--helpTopic2String :: HelpTopic -> String+--helpTopic2String w = fromMaybe __IMPOSSIBLE__ $ lookup w (map swap allHelpTopics)+--
@@ -0,0 +1,177 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Lenses for 'CommandLineOptions' and 'PragmaOptions'.+--+-- Add as needed.+--+-- Nothing smart happening here.++module Agda.Interaction.Options.Lenses where++import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Monad.State+import Agda.Interaction.Options++import Agda.Utils.WithDefault (pattern Value)++---------------------------------------------------------------------------+-- * Pragma options+---------------------------------------------------------------------------++modifyPragmaOptions :: MonadTCState m => (PragmaOptions -> PragmaOptions) -> m ()+modifyPragmaOptions = modifyTC . mapPragmaOptions++---------------------------------------------------------------------------+-- ** Verbosity in the local pragma options+---------------------------------------------------------------------------++class LensVerbosity a where+ getVerbosity :: a -> Verbosity+ setVerbosity :: Verbosity -> a -> a+ mapVerbosity :: (Verbosity -> Verbosity) -> a -> a++ -- default implementations+ setVerbosity = mapVerbosity . const+ mapVerbosity f a = setVerbosity (f $ getVerbosity a) a++instance LensVerbosity PragmaOptions where+ getVerbosity = _optVerbose+ setVerbosity is opts = opts { _optVerbose = is }++instance LensVerbosity TCState where+ getVerbosity = getVerbosity . getPragmaOptions+ mapVerbosity = mapPragmaOptions . mapVerbosity++modifyVerbosity :: MonadTCState m => (Verbosity -> Verbosity) -> m ()+modifyVerbosity = modifyTC . mapVerbosity++putVerbosity :: MonadTCState m => Verbosity -> m ()+putVerbosity = modifyTC . setVerbosity++---------------------------------------------------------------------------+-- * Command line options+---------------------------------------------------------------------------++class LensCommandLineOptions a where+ getCommandLineOptions :: a -> CommandLineOptions+ setCommandLineOptions :: CommandLineOptions -> a -> a+ mapCommandLineOptions :: (CommandLineOptions -> CommandLineOptions) -> a -> a++ -- default implementations+ setCommandLineOptions = mapCommandLineOptions . const+ mapCommandLineOptions f a = setCommandLineOptions (f $ getCommandLineOptions a) a++instance LensCommandLineOptions PersistentTCState where+ getCommandLineOptions = stPersistentOptions+ setCommandLineOptions opts st = st { stPersistentOptions = opts }++instance LensCommandLineOptions TCState where+ getCommandLineOptions = getCommandLineOptions . stPersistentState+ mapCommandLineOptions = updatePersistentState . mapCommandLineOptions++modifyCommandLineOptions :: MonadTCState m => (CommandLineOptions -> CommandLineOptions) -> m ()+modifyCommandLineOptions = modifyTC . mapCommandLineOptions++---------------------------------------------------------------------------+-- ** Safe mode+---------------------------------------------------------------------------++type SafeMode = Bool++class LensSafeMode a where+ getSafeMode :: a -> SafeMode+ setSafeMode :: SafeMode -> a -> a+ mapSafeMode :: (SafeMode -> SafeMode) -> a -> a++ -- default implementations+ setSafeMode = mapSafeMode . const+ mapSafeMode f a = setSafeMode (f $ getSafeMode a) a++instance LensSafeMode PragmaOptions where+ getSafeMode = optSafe+ setSafeMode is opts = opts { _optSafe = Value is } -- setSafeOption++instance LensSafeMode CommandLineOptions where+ getSafeMode = getSafeMode . getPragmaOptions+ mapSafeMode = mapPragmaOptions . mapSafeMode++instance LensSafeMode PersistentTCState where+ getSafeMode = getSafeMode . getCommandLineOptions+ mapSafeMode = mapCommandLineOptions . mapSafeMode++instance LensSafeMode TCState where+ getSafeMode = getSafeMode . getCommandLineOptions+ mapSafeMode = mapCommandLineOptions . mapSafeMode++modifySafeMode :: MonadTCState m => (SafeMode -> SafeMode) -> m ()+modifySafeMode = modifyTC . mapSafeMode++putSafeMode :: MonadTCState m => SafeMode -> m ()+putSafeMode = modifyTC . setSafeMode++---------------------------------------------------------------------------+-- ** Include directories+---------------------------------------------------------------------------++class LensIncludePaths a where+ getAbsoluteIncludePaths :: a -> [AbsolutePath]+ setAbsoluteIncludePaths :: [AbsolutePath] -> a -> a+ mapAbsoluteIncludePaths :: ([AbsolutePath] -> [AbsolutePath]) -> a -> a++ -- default implementations+ setAbsoluteIncludePaths = mapAbsoluteIncludePaths . const+ mapAbsoluteIncludePaths f a = setAbsoluteIncludePaths (f $ getAbsoluteIncludePaths a) a++instance LensIncludePaths CommandLineOptions where+ getAbsoluteIncludePaths = optAbsoluteIncludePaths+ setAbsoluteIncludePaths is opts = opts { optAbsoluteIncludePaths = is }++instance LensIncludePaths PersistentTCState where+ getAbsoluteIncludePaths = getAbsoluteIncludePaths . getCommandLineOptions+ mapAbsoluteIncludePaths = mapCommandLineOptions . mapAbsoluteIncludePaths++instance LensIncludePaths TCState where+ getAbsoluteIncludePaths = getAbsoluteIncludePaths . getCommandLineOptions+ mapAbsoluteIncludePaths = mapCommandLineOptions . mapAbsoluteIncludePaths++modifyAbsoluteIncludePaths :: MonadTCState m => ([AbsolutePath] -> [AbsolutePath]) -> m ()+modifyAbsoluteIncludePaths = modifyTC . mapAbsoluteIncludePaths++putAbsoluteIncludePaths :: MonadTCState m => [AbsolutePath] -> m ()+putAbsoluteIncludePaths = modifyTC . setAbsoluteIncludePaths++---------------------------------------------------------------------------+-- ** Verbosity+---------------------------------------------------------------------------++type PersistentVerbosity = Verbosity+class LensPersistentVerbosity a where+ getPersistentVerbosity :: a -> PersistentVerbosity+ setPersistentVerbosity :: PersistentVerbosity -> a -> a+ mapPersistentVerbosity :: (PersistentVerbosity -> PersistentVerbosity) -> a -> a++ -- default implementations+ setPersistentVerbosity = mapPersistentVerbosity . const+ mapPersistentVerbosity f a = setPersistentVerbosity (f $ getPersistentVerbosity a) a++instance LensPersistentVerbosity PragmaOptions where+ getPersistentVerbosity = getVerbosity+ setPersistentVerbosity = setVerbosity++instance LensPersistentVerbosity CommandLineOptions where+ getPersistentVerbosity = getPersistentVerbosity . getPragmaOptions+ mapPersistentVerbosity = mapPragmaOptions . mapPersistentVerbosity++instance LensPersistentVerbosity PersistentTCState where+ getPersistentVerbosity = getPersistentVerbosity . getCommandLineOptions+ mapPersistentVerbosity = mapCommandLineOptions . mapPersistentVerbosity++instance LensPersistentVerbosity TCState where+ getPersistentVerbosity = getPersistentVerbosity . getCommandLineOptions+ mapPersistentVerbosity = mapCommandLineOptions . mapPersistentVerbosity++modifyPersistentVerbosity :: MonadTCState m => (PersistentVerbosity -> PersistentVerbosity) -> m ()+modifyPersistentVerbosity = modifyTC . mapPersistentVerbosity++putPersistentVerbosity :: MonadTCState m => PersistentVerbosity -> m ()+putPersistentVerbosity = modifyTC . setPersistentVerbosity
@@ -0,0 +1,115 @@++module Agda.Interaction.Options.ProfileOptions+ ( ProfileOption(..)+ , ProfileOptions+ , noProfileOptions+ , addProfileOption+ , containsProfileOption+ , profileOptionsToList+ , profileOptionsFromList+ , validProfileOptionStrings+ ) where++import Control.DeepSeq+import Control.Monad+import Data.List (intercalate)+import Data.Char (toLower)+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Map (Map)+import qualified Data.Map as Map+import GHC.Generics (Generic)+import Text.EditDistance (restrictedDamerauLevenshteinDistance, defaultEditCosts)++import qualified Agda.Utils.List1 as List1+import Agda.Utils.Null (Null, empty)++-- | Various things that can be measured when checking an Agda development. Turned on with+-- the `--profile` flag, for instance `--profile=sharing` to turn on the 'Sharing' option.+-- 'Internal', 'Modules', and 'Definitions' are mutually exclusive.+--+-- NOTE: Changing this data type requires bumping the interface version number in+-- 'Agda.TypeChecking.Serialise.currentInterfaceVersion'.+data ProfileOption+ = Internal -- ^ Measure time taken by various parts of the system (type checking, serialization, etc)+ | Modules -- ^ Measure time spent on individual (Agda) modules+ | Definitions -- ^ Measure time spent on individual (Agda) definitions+ | Sharing -- ^ Measure things related to sharing+ | Serialize -- ^ Collect detailed statistics about serialization+ | Constraints -- ^ Collect statistics about constraint solving+ | Metas -- ^ Count number of created metavariables+ | Interactive -- ^ Measure time of interactive commands+ | Conversion -- ^ Collect statistics about conversion checking+ | Instances -- ^ Collect statistics about instance search+ | Sections -- ^ Collect statistics about section applications+ deriving (Show, Eq, Ord, Enum, Bounded, Generic)++instance NFData ProfileOption++-- | A set of 'ProfileOption's+newtype ProfileOptions = ProfileOpts { unProfileOpts :: Set ProfileOption }+ deriving (Show, Eq, NFData, Null)++-- | The empty set of profiling options.+noProfileOptions :: ProfileOptions+noProfileOptions = empty++addAllProfileOptions :: ProfileOptions -> ProfileOptions+addAllProfileOptions (ProfileOpts opts) = ProfileOpts $ foldl ins opts [minBound..maxBound]+ where+ ins os o | any (incompatible o) os = os+ | otherwise = Set.insert o os++-- | Strings accepted by 'addProfileOption'+validProfileOptionStrings :: [String]+validProfileOptionStrings = "all" : map optName [minBound .. maxBound :: ProfileOption]++parseOpt :: String -> Either String ProfileOption+parseOpt = \ s -> case Map.lookup s names of+ Nothing -> Left $ err s+ Just o -> Right o+ where+ names = Map.fromList [ (optName o, o) | o <- [minBound .. maxBound] ]++ close s t = restrictedDamerauLevenshteinDistance defaultEditCosts s t <= 3+ err s = concat ["Not a valid profiling option: '", s, "'. ", hint s]+ hint s = case filter (close s) (Map.keys names) of+ [] -> concat [ "Valid options are ", intercalate ", " $ Map.keys names, ", or all." ]+ ss -> concat [ "Did you mean ", intercalate " or " ss, "?" ]++optName :: ProfileOption -> String+optName = map toLower . show++incompatible :: ProfileOption -> ProfileOption -> Bool+incompatible o1 o2+ | o1 == o2 = False+ | otherwise = any (\ set -> elem o1 set && elem o2 set) sets+ where+ sets = [[Internal, Modules, Definitions]]++-- | Parse and add a profiling option to a set of profiling options. Returns `Left` with a helpful+-- error message if the option doesn't parse or if it's incompatible with existing options.+-- The special string "all" adds all options compatible with the given set and prefering the first+-- of incompatible options. So `--profile=all` sets 'Internal' over 'Modules' and 'Definitions',+-- but `--profile=modules --profile=all` sets 'Modules' and not 'Internal'.+addProfileOption :: String -> ProfileOptions -> Either String ProfileOptions+addProfileOption "all" opts = pure $ addAllProfileOptions opts+addProfileOption s (ProfileOpts opts) = do+ o <- parseOpt s+ List1.ifNull (filter (incompatible o) $ Set.toList opts)+ {-then-}+ (return $ ProfileOpts $ Set.insert o opts)+ {-else-} $ \ conflicts ->+ Left $ concat ["Cannot use profiling option '", s, "' with '", optName $ List1.head $ conflicts, "'"]++-- | Check if a given profiling option is present in a set of profiling options.+containsProfileOption :: ProfileOption -> ProfileOptions -> Bool+containsProfileOption o (ProfileOpts opts) = Set.member o opts++-- | Use only for serialization.+profileOptionsToList :: ProfileOptions -> [ProfileOption]+profileOptionsToList (ProfileOpts opts) = Set.toList opts++-- | Use only for serialization.+profileOptionsFromList :: [ProfileOption] -> ProfileOptions+profileOptionsFromList opts = ProfileOpts $ Set.fromList opts
@@ -0,0 +1,330 @@+{-# LANGUAGE DataKinds #-}++{-# OPTIONS_GHC -Wunused-imports #-}++-- | A module defining the types exported by "Agda.Interaction.Options" for use in the rest of the codebase.+--+-- This is a boot module to avoid cyclic module dependencies.+-- Only put types and trivial instances here.++module Agda.Interaction.Options.Types where++import Control.DeepSeq ( NFData )+import Data.Functor ( (<&>) )+import Data.Map ( Map )+import Data.Set ( Set )+import GHC.Generics ( Generic )++import Agda.Syntax.Common+ (Cubical, AllowedErasedMatchesWithDefaults)+import Agda.Syntax.Concrete.Glyph ( UnicodeOrAscii )+import Agda.Interaction.Library ( ExeName, LibName )+import Agda.Interaction.Options.Help ( Help )+import Agda.Interaction.Options.Warnings ( WarningMode )+import Agda.Termination.CutOff ( CutOff )++import Agda.Utils.FileName ( AbsolutePath )+import Agda.Utils.Lens ( Lens', (^.), over )+import Agda.Utils.List1 ( String1 )+import qualified Agda.Utils.Maybe.Strict as Strict+import Agda.Interaction.Options.ProfileOptions ( ProfileOptions )+import Agda.Utils.Trie ( Trie )+import Agda.Utils.WithDefault ( WithDefault, WithDefault' )++---------------------------------------------------------------------------+-- * Option records++-- Don't forget to update+-- doc/user-manual/tools/command-line-options.rst+-- if you make changes to the command-line options!++data CommandLineOptions = Options+ { optProgramName :: String+ , optInputFile :: Maybe FilePath+ , optIncludePaths :: [FilePath]+ , optAbsoluteIncludePaths :: [AbsolutePath]+ -- ^ The list should not contain duplicates.+ , optLibraries :: [LibName]+ , optOverrideLibrariesFile :: Maybe FilePath+ -- ^ Use this (if 'Just') instead of @~\/.agda\/libraries@.+ , optDefaultLibs :: Bool+ -- ^ Use @~\/.agda\/defaults@.+ , optUseLibs :: Bool+ -- ^ look for @.agda-lib@ files.+ , optTraceImports :: Integer+ -- ^ Configure notifications about imported modules.+ , optTrustedExecutables :: Map ExeName FilePath+ -- ^ Map names of trusted executables to absolute paths.++ -- Setup and printing+ , optPrintAgdaDataDir :: Bool+ , optPrintAgdaAppDir :: Bool+ , optPrintOptions :: Bool+ -- ^ Print all options as a simple list (for implementing bash completion).+ , optPrintVersion :: Maybe PrintAgdaVersion+ , optPrintHelp :: Maybe Help+ , optBuildLibrary :: Bool+ -- ^ @--build-library@: Build all modules in the current library.+ , optSetup :: Bool+ -- ^ Force Agda to self-setup at startup.+ , optEmacsMode :: Set EmacsModeCommand+ -- ^ Emacs mode administration+ -- (formerly done by the @agda-mode@ executable).+ -- Accepted subcommands: @locate@, @setup@, @compile@.+ -- Can be given several times,+ -- subcommands are accumulated in the set.++ , optInteractive :: Bool+ -- ^ Agda REPL (@-I@).+ , optGHCiInteraction :: Bool+ -- ^ @--interaction@ mode.+ , optJSONInteraction :: Bool+ -- ^ @--interaction-json@ mode.+ , optExitOnError :: !Bool+ -- ^ Exit if an interactive command fails.+ , optCompileDir :: Maybe FilePath+ -- ^ In the absence of a path the project root is used.+ , optGenerateVimFile :: Bool+ , optIgnoreInterfaces :: Bool+ , optIgnoreAllInterfaces :: Bool+ , optWriteInterfaces :: Bool+ , optPragmaOptions :: PragmaOptions+ , optOnlyScopeChecking :: Bool+ -- ^ Should the top-level module only be scope-checked, and not type-checked?+ , optTransliterate :: Bool+ -- ^ Should code points that are not supported by the locale be transliterated?+ , optDiagnosticsColour :: DiagnosticsColours+ -- ^ Configure colour output.+ , optMdOnlyAgdaBlocks :: Bool+ -- ^ In literate Markdown/Typst, only treat @```agda@ blocks as code.+ , optParallelChecking :: Parallelism+ -- ^ Should imports be type-checked in parallel?+ }+ deriving (Show, Generic)++-- | Options which can be set in a pragma.++data PragmaOptions = PragmaOptions+ { _optShowImplicit :: WithDefault 'False+ , _optShowGeneralized :: WithDefault 'True+ -- ^ Show generalized parameters in Pi types+ , _optShowIrrelevant :: WithDefault 'False+ , _optUseUnicode :: WithDefault' UnicodeOrAscii 'True -- Would like to write UnicodeOk instead of True here+ , _optVerbose :: !Verbosity+ , _optProfiling :: ProfileOptions+ , _optIrrelevance :: WithDefault 'True+ , _optProp :: WithDefault 'False+ , _optLevelUniverse :: WithDefault 'False+ , _optTwoLevel :: WithDefault 'False+ , _optAllowUnsolved :: WithDefault 'False+ , _optAllowIncompleteMatch :: WithDefault 'False+ , _optPositivityCheck :: WithDefault 'True+ , _optTerminationCheck :: WithDefault 'True+ , _optTerminationDepth :: CutOff+ -- ^ Cut off structural order comparison at some depth in termination checker?+ , _optUniverseCheck :: WithDefault 'True+ , _optOmegaInOmega :: WithDefault 'False+ , _optCumulativity :: WithDefault 'False+ , _optSizedTypes :: WithDefault 'False+ , _optGuardedness :: WithDefault 'False+ , _optInjectiveTypeConstructors :: WithDefault 'False+ , _optUniversePolymorphism :: WithDefault 'True+ , _optIrrelevantProjections :: WithDefault 'False+ -- off by default in > 2.5.4, see issue #2170+ , _optExperimentalIrrelevance :: WithDefault 'False+ -- ^ irrelevant levels, irrelevant data matching+ , _optWithoutK :: WithDefault 'False+ , _optCubicalCompatible :: WithDefault 'False+ , _optCopatterns :: WithDefault 'True+ -- ^ Allow definitions by copattern matching?+ , _optPatternMatching :: WithDefault 'True+ -- ^ Is pattern matching allowed in the current file?+ , _optExactSplit :: WithDefault 'False+ , _optHiddenArgumentPuns :: WithDefault 'False+ -- ^ Should patterns of the form @{x}@ or @⦃ x ⦄@ be interpreted as puns?+ , _optEta :: WithDefault 'True+ , _optForcing :: WithDefault 'True+ -- ^ Perform the forcing analysis on data constructors?+ , _optProjectionLike :: WithDefault 'True+ -- ^ Perform the projection-likeness analysis on functions?+ , _optErasure :: WithDefault 'False+ , _optErasedMatches :: AllowedErasedMatchesWithDefaults+ -- ^ What kinds of erased matches are allowed?+ , _optEraseRecordParameters :: WithDefault 'False+ -- ^ Mark parameters of record modules as erased?+ , _optRewriting :: WithDefault 'False+ -- ^ Can rewrite rules be added and used?+ , _optLocalRewriting :: WithDefault 'False+ -- ^ Can local rewrite rules be added and used?+ , _optCubical :: Maybe Cubical+ , _optGuarded :: WithDefault 'False+ , _optFirstOrder :: WithDefault 'False+ -- ^ Should we speculatively unify function applications as if they were injective? Implies+ -- optRequireUniqueMetaSolutions.+ , _optRequireUniqueMetaSolutions :: WithDefault 'True+ -- ^ Forbid non-unique meta solutions allowed. For instance from INJECTIVE_FOR_INFERENCE pragmas.+ , _optPostfixProjections :: WithDefault 'True+ -- ^ Should system generated projections 'ProjSystem' be printed+ -- postfix (True) or prefix (False).+ , _optKeepPatternVariables :: WithDefault 'True+ -- ^ Should case splitting replace variables with dot patterns+ -- (False) or keep them as variables (True).+ , _optInferAbsurdClauses :: WithDefault 'True+ -- ^ Should case splitting and coverage checking try to discharge absurd clauses?+ -- Default: 'True', but 'False' might make coverage checking considerably faster in some cases.+ , _optInstanceSearchDepth :: Int+ , _optBacktrackingInstances :: WithDefault 'False+ , _optQualifiedInstances :: WithDefault 'True+ -- ^ Should instance search consider instances with qualified names?+ , _optInversionMaxDepth :: Int+ , _optSafe :: WithDefault 'False+ , _optDoubleCheck :: WithDefault 'False+ , _optSyntacticEquality :: !(Strict.Maybe Int)+ -- ^ Should the conversion checker use the syntactic equality shortcut?+ -- 'Nothing' means that it should.+ -- @'Just' n@, for a non-negative number @n@, means that syntactic equality+ -- checking gets @n@ units of fuel.+ -- If the fuel becomes zero, then syntactic equality checking is turned off.+ -- The fuel counter is decreased in the failure continuation of+ -- 'Agda.TypeChecking.SyntacticEquality.checkSyntacticEquality'.+ , _optWarningMode :: WarningMode+ , _optCompileMain :: WithDefault 'True+ -- ^ Treat the module given at the command line or via interaction as main module in compilation?+ , _optCaching :: WithDefault 'True+ , _optCountClusters :: WithDefault 'False+ -- ^ Count extended grapheme clusters rather than code points+ -- when generating LaTeX.+ , _optAutoInline :: WithDefault 'False+ -- ^ Automatic compile-time inlining for simple definitions+ -- (unless marked @NOINLINE@).+ , _optPrintPatternSynonyms :: WithDefault 'True+ , _optFastReduce :: WithDefault 'True+ -- ^ Use the Agda abstract machine ('fastReduce')?+ , _optCallByName :: WithDefault 'False+ -- ^ Use call-by-name instead of call-by-need.+ , _optConfluenceCheck :: Maybe ConfluenceCheck+ -- ^ Check confluence of rewrite rules?+ , _optCohesion :: WithDefault 'False+ -- ^ Are the cohesion modalities available?+ , _optFlatSplit :: WithDefault 'False+ -- ^ Can we split on a @(\@flat x : A)@ argument?+ , _optPolarity :: WithDefault 'False+ -- ^ Can we use modal polarities (@++, @+, etc.)?+ , _optOccurrence :: WithDefault 'True+ -- ^ Perform automated occurrence analysis for functions?+ , _optFunext :: WithDefault 'False+ -- ^ Can @Agda.Builtin.Erased.Funext@ be used?+ , _optPropext :: WithDefault 'False+ -- ^ Can @Agda.Builtin.Erased.Propext@ be used?+ , _optQuotients :: WithDefault 'False+ -- ^ Can @Agda.Builtin.Erased.Quotient@ be used?+ , _optImportSorts :: WithDefault 'True+ -- ^ Should every top-level module start with an implicit statement+ -- @open import Agda.Primitive using (Set; Prop)@?+ , _optLoadPrimitives :: WithDefault 'True+ -- ^ Should we load the primitive modules at all?+ -- This is a stronger form of 'optImportSorts'.+ , _optAllowExec :: WithDefault 'False+ -- ^ Allow running external @executables@ from meta programs.+ , _optSaveMetas :: WithDefault 'False+ -- ^ Save meta-variables to interface files.+ , _optShowIdentitySubstitutions :: WithDefault 'False+ -- ^ Show identity substitutions when pretty-printing terms+ -- (i.e. always show all arguments of a metavariable).+ , _optKeepCoveringClauses :: WithDefault 'False+ -- ^ Do not discard clauses constructed by the coverage checker+ -- (needed for some external backends).+ , _optLargeIndices :: WithDefault 'False+ -- ^ Allow large indices, and large forced arguments in+ -- constructors.+ , _optForcedArgumentRecursion :: WithDefault 'True+ -- ^ Allow recursion on forced constructor arguments.+ , _optExperimentalLazyInstances :: WithDefault 'False+ -- ^ Defer instance search based on discrimination tree results+ , _optQuoteMetas :: WithDefault 'False+ }+ deriving (Show, Eq, Generic)++---------------------------------------------------------------------------+-- * Auxiliary structures (by default in alphabetic order)++data ConfluenceCheck+ = LocalConfluenceCheck+ | GlobalConfluenceCheck+ deriving (Show, Eq, Generic)++data DiagnosticsColours+ = AlwaysColour+ | NeverColour+ | AutoColour+ deriving (Show, Generic)++data Parallelism+ = Sequential+ | Parallel (Maybe Int)+ deriving (Show, Generic)++-- | If several @--emacs-mode@ commands are given,+-- they are executed in the order as given in this datatype.+data EmacsModeCommand+ = EmacsModeCompile+ -- ^ Compile the @.el@ files to @.elc@.+ | EmacsModeSetup+ -- ^ Add the initialization lines to @.emacs@.+ | EmacsModeLocate+ -- ^ Print the installation location of @agda2.el@.+ deriving (Eq, Ord, Show, Generic)++-- | Infective or coinfective?+data InfectiveCoinfective+ = Infective+ | Coinfective+ deriving (Eq, Show, Generic)++-- | Options @--version@ and @--numeric-version@ (last wins).+data PrintAgdaVersion+ = PrintAgdaVersion+ -- ^ Print Agda version information.+ | PrintAgdaNumericVersion+ -- ^ Print Agda version number.+ deriving (Show, Generic)++type VerboseKey = String+type VerboseKeyItem = String1+type VerboseLevel = Int++-- | 'Strict.Nothing' is used if no verbosity options have been given,+-- thus making it possible to handle the default case relatively+-- quickly. Note that 'Strict.Nothing' corresponds to a trie with+-- verbosity level 1 for the empty path.+type Verbosity = Strict.Maybe (Trie VerboseKeyItem VerboseLevel)++---------------------------------------------------------------------------+-- * Lenses++class LensPragmaOptions a where+ getPragmaOptions :: a -> PragmaOptions+ setPragmaOptions :: PragmaOptions -> a -> a+ mapPragmaOptions :: (PragmaOptions -> PragmaOptions) -> a -> a+ lensPragmaOptions :: Lens' a PragmaOptions++ {-# MINIMAL lensPragmaOptions #-}+ getPragmaOptions = (^. lensPragmaOptions)+ setPragmaOptions = mapPragmaOptions . const+ mapPragmaOptions = over lensPragmaOptions++instance LensPragmaOptions CommandLineOptions where+ lensPragmaOptions f st = f (optPragmaOptions st) <&> \ opts -> st { optPragmaOptions = opts }++---------------------------------------------------------------------------+-- NFData instances++instance NFData CommandLineOptions+instance NFData PragmaOptions++instance NFData ConfluenceCheck+instance NFData Parallelism+instance NFData DiagnosticsColours+instance NFData EmacsModeCommand+instance NFData InfectiveCoinfective+instance NFData PrintAgdaVersion
@@ -0,0 +1,700 @@++module Agda.Interaction.Options.Warnings+ (+ WarningMode (..)+ , warningSet+ , warn2Error+ , lensSingleWarning+ , defaultWarningSet+ , allWarnings+ , usualWarnings+ , noWarnings+ , unsolvedWarnings+ , unusedImportsWarnings+ , incompleteMatchWarnings+ , errorWarnings+ , exactSplitWarnings+ , defaultWarningMode+ , WarningModeError(..)+ , prettyWarningModeError+ , warningModeUpdate+ , warningSets+ , WarningName (..)+ , warningNameToString+ , string2WarningName+ , usageWarning+ )+where++import Control.DeepSeq+import Control.Monad ( guard, when )+import Control.Monad.Except ( throwError )++import qualified Data.HashMap.Strict as HMap+import Data.List ( stripPrefix, intercalate, partition, sort )+import Data.Set ( Set )+import qualified Data.Set as Set+import Data.Text ( Text )+import qualified Data.Text as Text++import GHC.Generics (Generic)++import Agda.Utils.Either ( maybeToEither )+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.Maybe+import Agda.Utils.Singleton ( singleton )+import Agda.Utils.Tuple ( (&&&) )++import Agda.Utils.Impossible+++-- | A @WarningMode@ has two components: a set of warnings to be displayed+-- and a flag stating whether warnings should be turned into fatal errors.+data WarningMode = WarningMode+ { _warningSet :: Set WarningName+ -- ^ Invariant: When 'UnusedImportsAll_' is in the warning set, so must be 'UnusedImports_'.+ , _warn2Error :: Bool+ } deriving (Eq, Show, Generic)++instance NFData WarningMode++-- Lenses++warningSet :: Lens' WarningMode (Set WarningName)+warningSet f o = (\ ws -> o { _warningSet = ws }) <$> f (_warningSet o)++warn2Error :: Lens' WarningMode Bool+warn2Error f o = (\ ws -> o { _warn2Error = ws }) <$> f (_warn2Error o)++lensSingleWarning :: WarningName -> Lens' WarningMode Bool+lensSingleWarning w = warningSet . contains w++-- | The @defaultWarningMode@ is a curated set of warnings covering non-fatal+-- errors and disabling style-related ones++defaultWarningSet :: String+defaultWarningSet = "warn"++defaultWarningMode :: WarningMode+defaultWarningMode = WarningMode ws False where+ ws = fst $ fromMaybe __IMPOSSIBLE__ $ lookup defaultWarningSet warningSets++-- | Some warnings are errors and cannot be turned off.+data WarningModeError+ = Unknown Text+ -- ^ Unknown warning.+ | NoNoError Text+ -- ^ Warning that cannot be disabled.+ | NoUnusedImportsAll+ -- ^ @-WnoUnusedImports=all@ is not supported, use @-WnoUnusedImports@ instead.+ deriving (Show, Generic)++instance NFData WarningModeError++prettyWarningModeError :: WarningModeError -> Text+prettyWarningModeError = \case+ Unknown w -> Text.concat [ "Unknown warning flag: ", w, "." ]+ NoNoError w -> Text.concat+ [ "You may only turn off benign warnings. The warning "+ , w+ , " is a non-fatal error and thus cannot be ignored."+ ]+ NoUnusedImportsAll ->+ "-WnoUnusedImports=all is not supported, use -WnoUnusedImports instead."++-- | From user-given directives we compute WarningMode updates+type WarningModeUpdate = WarningMode -> WarningMode++-- | @warningModeUpdate str@ computes the action of @str@ over the current+-- @WarningMode@: it may reset the set of warnings, add or remove a specific+-- flag or demand that any warning be turned into an error++warningModeUpdate :: String -> Either WarningModeError WarningModeUpdate+warningModeUpdate str = case str of+ "error" -> pure $ set warn2Error True+ "noerror" -> pure $ set warn2Error False+ _ | Just ws <- fst <$> lookup str warningSets+ -> pure $ set warningSet ws+ _ -> case stripPrefix "no" str of+ Nothing -> do+ wname <- stringToWarningName str+ let+ wnames = case wname of+ -- Invariant: when UnusedImportsAll_ is in the warning set,+ -- so must be UnusedImports_+ UnusedImportsAll_ -> unusedImportsWarnings+ w -> singleton w+ pure $ over warningSet $ (`Set.union` wnames)+ Just str' -> do+ wname <- stringToWarningName str'+ when (wname `elem` errorWarnings) $+ throwError $ NoNoError $ Text.pack str'+ wnames <- case wname of+ UnusedImports_ -> pure unusedImportsWarnings+ UnusedImportsAll_ -> throwError NoUnusedImportsAll+ w -> pure $ singleton w+ pure $ over warningSet $ (Set.\\ wnames)+ where+ stringToWarningName :: String -> Either WarningModeError WarningName+ stringToWarningName str = maybeToEither (Unknown $ Text.pack str) $ string2WarningName str+++-- | Common sets of warnings++warningSets :: [(String, (Set WarningName, String))]+warningSets = [ ("all" , (allWarnings, "All of the existing warnings"))+ , ("warn" , (usualWarnings, "Default warning level"))+ , ("ignore", (errorWarnings, "Ignore all the benign warnings"))+ ]++noWarnings :: Set WarningName+noWarnings = Set.empty++unsolvedWarnings :: Set WarningName+unsolvedWarnings = Set.fromList+ [ UnsolvedMetaVariables_+ , UnsolvedInteractionMetas_+ , UnsolvedConstraints_+ ]++incompleteMatchWarnings :: Set WarningName+incompleteMatchWarnings = Set.fromList [ CoverageIssue_ ]++errorWarnings :: Set WarningName+errorWarnings = Set.fromList+ [ CoverageIssue_+ , InvalidCharacterLiteral_+ , MissingDefinitions_+ , MissingDataDeclaration_+ , NotAllowedInMutual_+ , NotStrictlyPositive_+ , ConstructorDoesNotFitInData_+ , OverlappingTokensWarning_+ , PragmaCompiled_+ , RecursiveRecordNeedsInductivity_+ , SafeFlagPostulate_+ , SafeFlagPragma_+ , SafeFlagNonTerminating_+ , SafeFlagTerminating_+ , SafeFlagWithoutKFlagPrimEraseEquality_+ , SafeFlagNoPositivityCheck_+ , SafeFlagPolarity_+ , SafeFlagNoUniverseCheck_+ , SafeFlagInjective_+ , SafeFlagNoCoverageCheck_+ , TerminationIssue_+ , TooManyArgumentsToSort_+ , UnsolvedMetaVariables_+ , UnsolvedInteractionMetas_+ , UnsolvedConstraints_+ , InfectiveImport_+ , CoInfectiveImport_+ -- Andreas, 2024-02-15: the following warning used to be a GenericWarning (not an error warning).+ -- Maybe revisit.+ -- , ConfluenceCheckingIncompleteBecauseOfMeta_+ , RewriteNonConfluent_+ , RewriteMaybeNonConfluent_+ , RewriteAmbiguousRules_+ , RewriteMissingRule_+ , LocalRewriteOutsideTelescope_+ , InferredLocalRewrite_+ , TopLevelPolarity_++ -- Recoverable parse errors+ , MismatchedBrackets_++ -- Recoverable scope-checking errors+ , HiddenNotInArgumentPosition_+ , InstanceNotInArgumentPosition_+ , MacroInLetBindings_+ , AbstractInLetBindings_+ , IllegalDeclarationInDataDefinition_+ , UnknownNamesInFixityDecl_ -- This may lead to subsequent scope or operator parse errors.+ , UnknownNamesInPolarityPragmas_ -- This may lead to subsequent type-checking errors.+ ]++allWarnings :: Set WarningName+allWarnings = Set.fromList [minBound..maxBound]++usualWarnings :: Set WarningName+usualWarnings =+ allWarnings Set.\\ exactSplitWarnings Set.\\ Set.fromList+ [ UnknownFixityInMixfixDecl_+ , ShadowingInTelescope_+ , UnusedImports_+ , UnusedImportsAll_+ ]++-- | Warnings enabled by @--exact-split@.+--+exactSplitWarnings :: Set WarningName+exactSplitWarnings = Set.fromList+ [ CoverageNoExactSplit_+ , InlineNoExactSplit_+ , ShouldBeEtaRecordPattern_+ ]++-- | Both of these warnings are disabled by @-WnoUnusedImports@.+unusedImportsWarnings :: Set WarningName+unusedImportsWarnings = Set.fromList [ UnusedImports_, UnusedImportsAll_ ]++-- | The @WarningName@ data enumeration is meant to have a one-to-one correspondance+-- to existing warnings in the codebase.++data WarningName+ -- Option Warnings+ = OptionRenamed_+ | WarningProblem_+ -- ^ Some warning could not be set or unset.+ | LocalRewritingConfluenceCheck_+ -- Parser Warnings+ | OverlappingTokensWarning_+ | MisplacedAttributes_+ | UnknownPolarity_+ | UnknownAttribute_+ | UnsupportedAttribute_+ | MultipleAttributes_+ | MismatchedBrackets_+ -- Library Warnings+ | LibUnknownField_+ | LibraryVersionConflict_+ -- Nicifer Warnings+ | DefinitionBeforeDeclaration_+ | DivergentModalityInClause_+ | EmptyAbstract_+ | EmptyConstructor_+ | EmptyField_+ | EmptyGeneralize_+ | EmptyInstance_+ | EmptyMacro_+ | EmptyMutual_+ | EmptyPostulate_+ | EmptyPrimitive_+ | EmptyPrivate_+ | EmptyRewritePragma_+ | EmptyWhere_+ | EmptyPolarityPragma_+ | FixityDeclarationForNonOperator_+ | HiddenGeneralize_+ | InvalidCatchallPragma_+ | InvalidConstructorBlock_+ | InvalidCoverageCheckPragma_+ | InvalidDataOrRecDefParameter_+ | InvalidEtaEqualityPragma_+ | InvalidNoPositivityCheckPragma_+ | InvalidNoUniverseCheckPragma_+ | DuplicateRecordDirective_+ | InvalidTerminationCheckPragma_+ | InvalidTacticAttribute_+ | MissingDataDeclaration_+ | MissingDefinitions_+ | NotAllowedInMutual_+ | OpenImportAbstract_+ | OpenImportPrivate_+ | PolarityPragmasButNotPostulates_+ | PragmaCompiled_+ | PragmaNoTerminationCheck_+ | ShadowingInTelescope_+ | UnknownFixityInMixfixDecl_+ | UnknownNamesInFixityDecl_+ | UnknownNamesInPolarityPragmas_+ | UselessAbstract_+ | UselessImport_+ | UselessInstance_+ | UselessMacro_+ | UselessPrivate_+ -- Scope and Type Checking Warnings+ | AbsurdPatternRequiresAbsentRHS_+ | AsPatternShadowsConstructorOrPatternSynonym_+ | PatternShadowsConstructor_+ | CantGeneralizeOverSorts_+ | ClashesViaRenaming_ -- issue #4154+ | CoverageIssue_+ | CoverageNoExactSplit_+ | InlineNoExactSplit_+ | DeprecationWarning_+ | DuplicateUsing_+ | FixingCohesion_+ | FixingPolarity_+ | FixingRelevance_+ | MisplacedRewrite_+ -- TODO: linearity+ -- -- | FixingQuantity_+ | FixityInRenamingModule_+ | InvalidCharacterLiteral_+ | UnusedImports_+ | UnusedImportsAll_+ | UselessPragma_+ | IllegalDeclarationInDataDefinition_+ | IllformedAsClause_+ | InstanceArgWithExplicitArg_+ | InstanceWithExplicitArg_+ | InstanceNoOutputTypeName_+ | InteractionMetaBoundaries_+ | InversionDepthReached_+ | ModuleDoesntExport_+ | NotInScope_+ | NotStrictlyPositive_+ | ConstructorDoesNotFitInData_+ | CoinductiveEtaRecord_+ | UnguardedEtaRecordW_+ | UnsupportedIndexedMatch_+ | OldBuiltin_+ | BuiltinDeclaresIdentifier_+ | PlentyInHardCompileTimeMode_+ | PragmaCompileErased_+ | PragmaCompileList_+ | PragmaCompileMaybe_+ | PragmaCompileUnparsable_+ | PragmaCompileWrong_+ | PragmaCompileWrongName_+ | PragmaExpectsDefinedSymbol_+ | PragmaExpectsUnambiguousConstructorOrFunction_+ | PragmaExpectsUnambiguousProjectionOrFunction_+ | UnknownJSPrimitive_+ | NoMain_+ | NotARewriteRule_+ | RewriteLHSNotDefinitionOrConstructor_+ | RewriteVariablesNotBoundByLHS_+ | RewriteVariablesBoundMoreThanOnce_+ | RewriteVariablesBoundInSingleton_+ | RewriteLHSReduces_+ | RewriteHeadSymbolIsProjectionLikeFunction_+ | RewriteHeadSymbolIsTypeConstructor_+ | RewriteHeadSymbolContainsMetas_+ | RewriteConstructorParametersNotGeneral_+ | RewriteContainsUnsolvedMetaVariables_+ | RewriteBlockedOnProblems_+ | RewriteRequiresDefinitions_+ | RewriteDoesNotTargetRewriteRelation_+ | RewriteBeforeFunctionDefinition_+ | RewriteBeforeMutualFunctionDefinition_+ | ConfluenceCheckingIncompleteBecauseOfMeta_+ | ConfluenceForCubicalNotSupported_+ | RewriteMaybeNonConfluent_+ | RewriteNonConfluent_+ | RewriteAmbiguousRules_+ | RewriteMissingRule_+ | DuplicateRewriteRule_+ | LocalRewriteOutsideTelescope_+ | InferredLocalRewrite_+ | SafeFlagInjective_+ | SafeFlagNoCoverageCheck_+ | SafeFlagNonTerminating_+ | SafeFlagNoPositivityCheck_+ | SafeFlagNoUniverseCheck_+ | SafeFlagPolarity_+ | SafeFlagPostulate_+ | SafeFlagPragma_+ | SafeFlagTerminating_+ | SafeFlagWithoutKFlagPrimEraseEquality_+ | ShouldBeEtaRecordPattern_+ | TerminationIssue_+ | TooManyArgumentsToSort_+ | UnreachableClauses_+ | UnsolvedConstraints_+ | UnsolvedInteractionMetas_+ | UnsolvedMetaVariables_+ | UselessHiding_+ | UselessInline_+ | UselessPatternDeclarationForRecord_+ | UselessPublic_+ | UselessTactic_+ | UserWarning_+ | InvalidDisplayForm_+ | UnusedVariablesInDisplayForm_+ | RewritesNothing_+ | RecursiveRecordNeedsInductivity_+ | WithClauseProjectionFixityMismatch_+ | WithoutKFlagPrimEraseEquality_+ | ConflictingPragmaOptions_+ | WrongInstanceDeclaration_+ | TooManyPolarities_+ | TopLevelPolarity_+ -- Checking consistency of options+ | CoInfectiveImport_+ | InfectiveImport_+ -- Record field warnings+ | DuplicateFields_+ | TooManyFields_+ -- Opaque/unfolding+ | MissingTypeSignatureForOpaque_+ | NotAffectedByOpaque_+ | UnfoldingWrongName_+ | UnfoldTransparentName_+ | UselessOpaque_+ -- Recoverable scope checking errors+ | HiddenNotInArgumentPosition_+ | InstanceNotInArgumentPosition_+ | MacroInLetBindings_+ | AbstractInLetBindings_+ -- Cubical+ | FaceConstraintCannotBeHidden_+ | FaceConstraintCannotBeNamed_+ -- Backends+ | CustomBackendWarning_+ deriving (Eq, Ord, Show, Read, Enum, Bounded, Generic)++instance NFData WarningName++-- | The flag corresponding to a warning is precisely the name of the constructor+-- minus the trailing underscore.++string2WarningName :: String -> Maybe WarningName+string2WarningName = (`HMap.lookup` warnings) where+ warnings = HMap.fromList $ map (\x -> (warningNameToString x, x)) [minBound..maxBound]++warningNameToString :: WarningName -> String+warningNameToString = \case+ UnguardedEtaRecordW_ -> "UnguardedEtaRecord"+ UnusedImportsAll_ -> "UnusedImports=all"+ w -> initWithDefault __IMPOSSIBLE__ $ show w++-- | @warningUsage@ generated using @warningNameDescription@++usageWarning :: String+usageWarning = intercalate "\n"+ [ "The -W or --warning option can be used to disable or enable\+ \ different warnings. The flag -W error (or --warning=error)\+ \ can be used to turn all warnings into errors, while -W noerror\+ \ turns this off again."+ , ""+ , "A group of warnings can be enabled by -W group, where group is\+ \ one of the following:"+ , ""+ , untable (fmap (fst &&& snd . snd) warningSets)++ , "Individual benign warnings can be turned on and off by -W Name and\+ \ -W noName, respectively, where Name comes from the following\+ \ list (warnings marked with 'd' are turned on by default):"+ , ""+ , warningTable True benign++ , "Error warnings are always on and cannot be turned off:"+ , ""+ , warningTable False severe+ ]++ where++ (severe, benign) = partition (`Set.member` errorWarnings) [minBound..maxBound]++ warningTable printD ws =+ untable $ forMaybe ws $ \ w ->+ let wnd = warningNameDescription w in+ ( warningNameToString w+ , applyWhen printD ((if w `Set.member` usualWarnings then "d" else " ") ++)+ " " +++ wnd+ ) <$ guard (not $ null wnd)++ untable :: [(String, String)] -> String+ untable rows =+ let len = maximum (map (length . fst) rows) in+ unlines $ for (sort rows) $ \ (hdr, cnt) ->+ concat [ hdr, replicate (1 + len - length hdr) ' ', cnt ]+++-- | @WarningName@ descriptions used for generating usage information+-- Leave String empty to skip that name.+--+-- The description should be a completion of the sentence "This warning is about ...".+-- So, typically the subject is in plural.+--+warningNameDescription :: WarningName -> String+warningNameDescription = \case+ -- Option Warnings+ OptionRenamed_ -> "Renamed options."+ WarningProblem_ -> "Problems with switching warnings."+ LocalRewritingConfluenceCheck_ -> "Confluence checking local rewrite rules in not yet implemented."+ -- Parser Warnings+ OverlappingTokensWarning_ -> "Multi-line comments spanning one or more literate text blocks."+ MisplacedAttributes_ -> "Attributes where they are not supported."+ UnknownPolarity_ -> "Unknown polarities."+ UnknownAttribute_ -> "Unknown attributes."+ UnsupportedAttribute_ -> "Unsupported attributes."+ MultipleAttributes_ -> "Multiple attributes."+ MismatchedBrackets_ -> "Mismatched brackets."+ -- Library Warnings+ LibUnknownField_ -> "Unknown fields in library files."+ LibraryVersionConflict_ -> "Depending on different versions of the same library."+ -- Nicifer Warnings+ DivergentModalityInClause_ -> "Divergent modalities in function clauses."+ EmptyAbstract_ -> "Empty `abstract' blocks."+ EmptyConstructor_ -> "Empty `constructor' blocks."+ EmptyField_ -> "Empty `field` blocks."+ EmptyGeneralize_ -> "Empty `variable' blocks."+ EmptyInstance_ -> "Empty `instance' blocks."+ EmptyMacro_ -> "Empty `macro' blocks."+ EmptyMutual_ -> "Empty `mutual' blocks."+ EmptyPostulate_ -> "Empty `postulate' blocks."+ EmptyPrimitive_ -> "Empty `primitive' blocks."+ EmptyPrivate_ -> "Empty `private' blocks."+ EmptyRewritePragma_ -> "Empty `REWRITE' pragmas."+ EmptyWhere_ -> "Empty `where' blocks."+ EmptyPolarityPragma_ -> "`POLARITY' pragmas giving no polarities."+ FixityDeclarationForNonOperator_ -> "Fixity declarations for non-operators."+ HiddenGeneralize_ -> "Hidden identifiers in variable blocks."+ InvalidCatchallPragma_ -> "`CATCHALL' pragmas before a non-function clause."+ InvalidConstructorBlock_ -> "`constructor' blocks outside of `interleaved mutual' blocks."+ InvalidCoverageCheckPragma_ -> "Coverage checking pragmas before non-function or `mutual' blocks."+ InvalidDataOrRecDefParameter_ -> "Invalid decorations of parameters of a `data' or `record' definition (that is separate of the `data' or `record' declaration)."+ InvalidEtaEqualityPragma_ -> "Eta equality pragmas before something other than a `record' type declaration."+ InvalidNoPositivityCheckPragma_ -> "Positivity checking pragmas before non-`data', `record' or `mutual' blocks."+ InvalidNoUniverseCheckPragma_ -> "Universe checking pragmas before non-`data' or `record' declaration."+ DuplicateRecordDirective_ -> "Conflicting directives in a record declaration."+ InvalidTacticAttribute_ -> "Misplaced @(tactic ...) attributes."+ InvalidTerminationCheckPragma_ -> "Termination checking pragmas before non-function or `mutual' blocks."+ MissingDataDeclaration_ -> "Constructor definitions not associated to a data declaration."+ MissingDefinitions_ -> "Declarations not associated to a definition."+ NotAllowedInMutual_ -> "Declarations not allowed in a mutual block."+ OpenImportAbstract_ -> "`open' or `import' statements in 'abstract' blocks."+ OpenImportPrivate_ -> "`open' or `import' statements in 'private' blocks."+ PolarityPragmasButNotPostulates_ -> "Polarity pragmas for non-postulates."+ PragmaCompiled_ -> "'COMPILE' pragmas in safe mode."+ PragmaNoTerminationCheck_ -> "`NO_TERMINATION_CHECK' pragmas; such are deprecated."+ ShadowingInTelescope_ -> "Repeated variable names in telescopes."+ UnknownFixityInMixfixDecl_ -> "Mixfix names without an associated fixity declaration."+ UnknownNamesInFixityDecl_ -> "Names not declared in the same scope as their syntax or fixity declaration."+ UnknownNamesInPolarityPragmas_ -> "Names not declared in the same scope as their polarity pragmas."+ UselessAbstract_ -> "`abstract' blocks where they have no effect."+ UselessHiding_ -> "Names in `hiding' directive that are anyway not imported."+ UselessImport_ -> "`import' statements that do not bring anything into scope."+ UselessInline_ -> "`INLINE' pragmas where they have no effect."+ UselessInstance_ -> "`instance' blocks where they have no effect."+ UselessMacro_ -> "`macro' blocks where they have no effect."+ UselessPrivate_ -> "`private' blocks where they have no effect."+ UselessPublic_ -> "`public' directives that have no effect."+ UselessPatternDeclarationForRecord_ -> "`pattern' attributes where they have no effect."+ UselessTactic_ -> "`@tactic` attributes where they have no effect."+ -- Scope and Type Checking Warnings+ AbsurdPatternRequiresAbsentRHS_ -> "Clauses with an absurd pattern that have a right hand side."+ AsPatternShadowsConstructorOrPatternSynonym_ -> "@-patterns that shadow constructors or pattern synonyms."+ PatternShadowsConstructor_ -> "Pattern variables that shadow constructors."+ CantGeneralizeOverSorts_ -> "Attempts to generalize over sort metas in 'variable' declaration."+ ClashesViaRenaming_ -> "Clashes introduced by `renaming'." -- issue #4154+ CoverageIssue_ -> "Failed coverage checks."+ CoverageNoExactSplit_ -> "Failed exact split checks."+ InlineNoExactSplit_ -> "Failed exact split checks after inlining record constructors."+ DeprecationWarning_ -> "Deprecated features."+ DefinitionBeforeDeclaration_ -> "Definitions that occur before their declarations."+ -- TODO: linearity+ -- FixingQuantity_ -> "Correcting invalid user-written quantity."+ FixingRelevance_ -> "Correcting invalid user-written relevance attribute."+ FixingCohesion_ -> "Correcting invalid user-written cohesion attribute."+ FixingPolarity_ -> "Correcting invalid user-written polarity attribute."+ MisplacedRewrite_ -> "Ignoring invalid user-written local rewrite attribute."+ InvalidCharacterLiteral_ -> "Illegal character literals."+ UselessPragma_ -> "Pragmas that get ignored."+ IllegalDeclarationInDataDefinition_ -> "Declarations not allowed in `data' definitions."+ IllformedAsClause_ -> "Illformed `as'-clauses in `import' statements."+ InstanceNoOutputTypeName_ -> "Instance arguments whose type does not end in a named or variable type; those are never considered by instance search."+ InstanceArgWithExplicitArg_ -> "Instance arguments with explicit arguments; those are never considered by instance search."+ InstanceWithExplicitArg_ -> "`instance` declarations with explicit arguments; those are never considered by instance search."+ InversionDepthReached_ -> "Inversions of pattern-matching failures due to exhausted inversion depth."+ ModuleDoesntExport_ -> "Imported names that are not actually exported."+ DuplicateUsing_ -> "Repeated names in using directive."+ FixityInRenamingModule_ -> "Fixity annotations in `renaming' directive for `module'."+ NotInScope_ -> "Out of scope names."+ NotStrictlyPositive_ -> "Failed strict positivity checks."+ ConstructorDoesNotFitInData_ -> "Failed constructor size checks."+ CoinductiveEtaRecord_ -> "Record type declared as both coinductive and having eta-equality."+ UnguardedEtaRecordW_ -> "Record type declared with eta-equality that has an unguarded recursive occurrence."+ UnsupportedIndexedMatch_ -> "Failures to compute full equivalence when splitting on indexed family."+ OldBuiltin_ -> "Deprecated `BUILTIN' pragmas."+ BuiltinDeclaresIdentifier_ -> "`BUILTIN' pragmas that declare a new identifier but have been given an existing one."+ PlentyInHardCompileTimeMode_ -> "Uses of @ω or @plenty in hard compile-time mode."+ PragmaCompileErased_ -> "`COMPILE' pragmas targeting an erased symbol."+ PragmaCompileList_ -> "`COMPILE GHC' pragmas for lists."+ PragmaCompileMaybe_ -> "`COMPILE GHC' pragmas for `MAYBE'."+ PragmaCompileUnparsable_ -> "Unparsable `COMPILE GHC' pragmas."+ PragmaCompileWrong_ -> "Ill-formed `COMPILE GHC' pragmas."+ PragmaCompileWrongName_ -> "`COMPILE' pragmas referring to identifiers that are neither definitions nor constructors.'"+ PragmaExpectsDefinedSymbol_ -> "Pragmas referring to identifiers that are not defined symbols."+ PragmaExpectsUnambiguousConstructorOrFunction_ -> "Pragmas referring to identifiers that are not unambiguous constructors or functions.'"+ PragmaExpectsUnambiguousProjectionOrFunction_ -> "Pragmas referring to identifiers that are not unambiguous projections or functions.'"+ UnknownJSPrimitive_ -> "Primitive compiled to `Undefined' by the JS backend because it is not in the list of known primitives."+ NoMain_ -> "Compilation of modules that do not define `main'."+ NotARewriteRule_ -> "`REWRITE pragmas referring to identifiers that are neither definitions nor constructors.'"+ RewriteLHSNotDefinitionOrConstructor_ -> "Rewrite rule head symbol is not a defined symbol or constructor."+ RewriteVariablesNotBoundByLHS_ -> "Rewrite rule does not bind all of its variables."+ RewriteVariablesBoundMoreThanOnce_ -> "Constructor-headed rewrite rule has non-linear parameters."+ RewriteVariablesBoundInSingleton_ -> "Rewrite rule binds some variables in possibly definitionally singular contexts."+ RewriteLHSReduces_ -> "Rewrite rule LHS is not in weak-head normal form."+ RewriteHeadSymbolIsProjectionLikeFunction_ -> "Rewrite rule head symbol is a projection-like function."+ RewriteHeadSymbolIsTypeConstructor_ -> "Rewrite rule head symbol is a type constructor."+ RewriteHeadSymbolContainsMetas_ -> "Definition of rewrite rule head symbol contains unsolved metas."+ RewriteConstructorParametersNotGeneral_ -> "Constructor-headed rewrite rule parameters are not fully general."+ RewriteContainsUnsolvedMetaVariables_ -> "Rewrite rule contains unsolved metas."+ RewriteBlockedOnProblems_ -> "Checking rewrite rule blocked by unsolved constraint."+ RewriteRequiresDefinitions_ -> "Checking rewrite rule blocked by missing definition."+ RewriteDoesNotTargetRewriteRelation_ -> "Rewrite rule does not target the rewrite relation."+ RewriteBeforeFunctionDefinition_ -> "Rewrite rule is not yet defined."+ RewriteBeforeMutualFunctionDefinition_ -> "Mutually declaration with the rewrite rule is not yet defined."+ ConfluenceCheckingIncompleteBecauseOfMeta_ -> "Incomplete confluence checks because of unsolved metas."+ ConfluenceForCubicalNotSupported_ -> "Incomplete confluence checks because of `--cubical'."+ RewriteMaybeNonConfluent_ -> "Failed local confluence checks while computing overlap."+ RewriteNonConfluent_ -> "Failed local confluence checks while joining critical pairs."+ RewriteAmbiguousRules_ -> "Failed global confluence checks because of overlapping rules."+ RewriteMissingRule_ -> "Failed global confluence checks because of missing rule."+ DuplicateRewriteRule_ -> "Duplicate rewrite rules."+ LocalRewriteOutsideTelescope_ -> "'@rewrite' arguments are (currently) only allowed in module telescopes."+ InferredLocalRewrite_ -> "Tried to solve a meta with an '@rewrite' function."+ SafeFlagInjective_ -> "`INJECTIVE' pragmas with the safe flag."+ SafeFlagNoCoverageCheck_ -> "`NON_COVERING` pragmas with the safe flag."+ SafeFlagNonTerminating_ -> "`NON_TERMINATING' pragmas with the safe flag."+ SafeFlagNoPositivityCheck_ -> "`NO_POSITIVITY_CHECK' pragmas with the safe flag."+ SafeFlagNoUniverseCheck_ -> "`NO_UNIVERSE_CHECK' pragmas with the safe flag."+ SafeFlagPolarity_ -> "`POLARITY' pragmas with the safe flag."+ SafeFlagPostulate_ -> "`postulate' blocks with the safe flag."+ SafeFlagPragma_ -> "Unsafe `OPTIONS' pragmas with the safe flag."+ SafeFlagTerminating_ -> "`TERMINATING' pragmas with the safe flag."+ SafeFlagWithoutKFlagPrimEraseEquality_ -> "`primEraseEquality' used with the safe and without-K flags."+ ConflictingPragmaOptions_ -> "Conflicting pragma options."+ TerminationIssue_ -> "Failed termination checks."+ UnreachableClauses_ -> "Unreachable function clauses."+ UnsolvedConstraints_ -> "Unsolved constraints."+ UnsolvedInteractionMetas_ -> "Unsolved interaction meta variables."+ InteractionMetaBoundaries_ -> "Interaction meta variables that have unsolved boundary constraints."+ UnsolvedMetaVariables_ -> "Unsolved meta variables."+ UserWarning_ -> "User-defined warnings via one of the 'WARNING_ON_*' pragmas."+ InvalidDisplayForm_ -> "Invalid display forms."+ UnusedVariablesInDisplayForm_ -> "Bound but unused variables in display forms."+ ShouldBeEtaRecordPattern_ -> "Irrefutable record pattern without eta."+ TooManyArgumentsToSort_ -> "Extra arguments given to a sort."+ RecursiveRecordNeedsInductivity_ -> "Recursive records declared neither `inductive' nor `coinductive'."+ RewritesNothing_ -> "`rewrite' clauses that do not fire."+ WithClauseProjectionFixityMismatch_ -> "With clauses using projections in different fixities than their parent clauses."+ WithoutKFlagPrimEraseEquality_ -> "Uses of `primEraseEquality' with the without-K flags."+ WrongInstanceDeclaration_ -> "Instances that do not adhere to the required format."+ TooManyPolarities_ -> "Too many polarities given in POLARITY pragma."+ TopLevelPolarity_ -> "Declaring definitions with an explicit polarity annotation."+ UnusedImports_ -> "Identifiers brought into scope but never referenced."+ UnusedImportsAll_ -> "Identifiers brought into scope but never referenced (strict version)."+ -- Checking consistency of options+ CoInfectiveImport_ -> "Importing a file not using e.g. `--safe' from one which does."+ InfectiveImport_ -> "Importing a file using e.g. `--cubical' into one which does not."+ -- Record field warnings+ DuplicateFields_ -> "Record expressions with duplicate field names."+ TooManyFields_ -> "Record expressions with invalid field names."+ -- Opaque/unfolding warnings+ MissingTypeSignatureForOpaque_ -> "Definitions that are `abstract` or `opaque` yet lack type signatures."+ NotAffectedByOpaque_ -> "Declarations unaffected by enclosing `opaque` blocks."+ UnfoldingWrongName_ -> "Names in `unfolding` clause that are not unambiguous functions."+ UnfoldTransparentName_ -> "Non-`opaque` names mentioned in an `unfolding` clause."+ UselessOpaque_ -> "`opaque` blocks that have no effect."++ -- Recoverable scope-checking errors+ HiddenNotInArgumentPosition_ -> "Hidden argument with no matching function."+ InstanceNotInArgumentPosition_ -> "Instance argument with no matching function."+ MacroInLetBindings_ -> "Macros can not be let-bound."+ AbstractInLetBindings_ -> "Let bindings can not contain abstract declarations."++ -- Cubical+ FaceConstraintCannotBeHidden_ -> "Face constraint patterns that are given as implicit arguments."+ FaceConstraintCannotBeNamed_ -> "Face constraint patterns that are given as named arguments."+ -- Backends+ CustomBackendWarning_ -> "Custom warnings from backends."
@@ -0,0 +1,14 @@++module Agda.Interaction.Output where++import Agda.Interaction.Base++import Agda.TypeChecking.Monad.Base (TCErr)++--------------------------+-- * TCM-aware aliases+--------------------------++type OutputForm a b = OutputForm_boot TCErr a b++type OutputConstraint a b = OutputConstraint_boot TCErr a b
@@ -0,0 +1,25 @@++module Agda.Interaction.Response+ ( module Agda.Interaction.Response+ , module Agda.Interaction.Response.Base+ , WarningsAndNonFatalErrors+ , InteractionOutputCallback+ , defaultInteractionOutputCallback+ )+ where++import Agda.Interaction.Response.Base++import Agda.TypeChecking.Monad.Base+ (TCM, TCErr, TCWarning, InteractionOutputCallback, defaultInteractionOutputCallback)+import Agda.TypeChecking.Warnings (WarningsAndNonFatalErrors)++--------------------------+-- * TCM-aware aliases+--------------------------++type Response = Response_boot TCErr TCWarning WarningsAndNonFatalErrors+type DisplayInfo = DisplayInfo_boot TCErr TCWarning WarningsAndNonFatalErrors+type Info_Error = Info_Error_boot TCErr TCWarning+type GoalDisplayInfo = GoalDisplayInfo_boot TCErr+type Goals = Goals_boot TCErr
@@ -0,0 +1,183 @@+------------------------------------------------------------------------+-- | Data type for all interactive responses+------------------------------------------------------------------------++module Agda.Interaction.Response.Base+ ( Response_boot (..)+ , RemoveTokenBasedHighlighting (..)+ , MakeCaseVariant (..)+ , DisplayInfo_boot (..)+ , GoalDisplayInfo_boot(..)+ , Goals_boot+ , Info_Error_boot(..)+ , GoalTypeAux(..)+ , ResponseContextEntry(..)+ , Status (..)+ , GiveResult (..)+ ) where++import Control.Monad.Trans ( MonadIO(liftIO) )+import Data.Set (Set)+import Data.Word (Word32)++import Agda.Interaction.Base+ ( CommandState+ , CompilerBackend+ , ComputeMode+ , OutputConstraint_boot+ , OutputConstraint'+ , OutputForm_boot+ , Rewrite+ )+import Agda.Interaction.Highlighting.Precise+import qualified Agda.Syntax.Abstract as A+import Agda.Syntax.Common (InteractionId(..), Arg)+import Agda.Syntax.Common.Pretty (DocTree)+import Agda.Syntax.Concrete (Expr)+import Agda.Syntax.Concrete.Name (Name, QName, NameInScope)+import Agda.Syntax.Scope.Base (WhyInScopeData)+import qualified Agda.Syntax.Internal as I+import Agda.TypeChecking.Monad.Base.Types+ (HighlightingMethod, ModuleToSource, NamedMeta, IPFace')+import Agda.Utils.Impossible+import Agda.Utils.Time+import qualified Agda.Syntax.Concrete.Name as C++-- | Responses for any interactive interface+--+-- Note that the response is given in pieces and incrementally,+-- so the user can have timely response even during long computations.++data Response_boot tcErr tcWarning warningsAndNonFatalErrors+ = Resp_HighlightingInfo+ HighlightingInfo+ RemoveTokenBasedHighlighting+ HighlightingMethod+ ModuleToSource+ (Maybe FilePath)+ -- ^ Target file, or 'Nothing' for the current buffer.+ | Resp_Status Status+ | Resp_JumpToError FilePath Word32+ | Resp_InteractionPoints [InteractionId]+ | Resp_GiveAction InteractionId GiveResult+ | Resp_MakeCase InteractionId MakeCaseVariant [String]+ -- ^ Response is list of printed clauses.+ | Resp_SolveAll [(InteractionId, Expr)]+ -- ^ Solution for one or more meta-variables.+ | Resp_Mimer InteractionId (Maybe String)+ | Resp_DisplayInfo (DisplayInfo_boot tcErr tcWarning warningsAndNonFatalErrors)+ | Resp_RunningInfo Int DocTree+ -- ^ The integer is the message's debug level.+ -- The 'DocTree' usually does not contain a final newline.+ | Resp_ClearRunningInfo+ | Resp_ClearHighlighting TokenBased+ -- ^ Clear highlighting of the given kind.+ | Resp_DoneAborting+ -- ^ A command sent when an abort command has completed+ -- successfully.+ | Resp_DoneExiting+ -- ^ A command sent when an exit command is about to be+ -- completed.++-- | Should token-based highlighting be removed in conjunction with+-- the application of new highlighting (in order to reduce the risk of+-- flicker)?++data RemoveTokenBasedHighlighting+ = RemoveHighlighting+ -- ^ Yes, remove all token-based highlighting from the file.+ | KeepHighlighting+ -- ^ No.++-- | There are two kinds of \"make case\" commands.++data MakeCaseVariant = Function | ExtendedLambda++-- | Info to display at the end of an interactive command++data DisplayInfo_boot tcErr tcWarning warningsAndNonFatalErrors+ = Info_CompilationOk CompilerBackend warningsAndNonFatalErrors+ | Info_Constraints [OutputForm_boot tcErr Expr Expr]+ | Info_AllGoalsWarnings (Goals_boot tcErr) warningsAndNonFatalErrors+ | Info_Time CPUTime+ | Info_Error (Info_Error_boot tcErr tcWarning)+ -- ^ When an error message is displayed this constructor should be+ -- used, if appropriate.+ | Info_Intro_NotFound+ | Info_Intro_ConstructorUnknown [String]+ | Info_Auto String+ -- ^ 'Info_Auto' denotes either an error or a success (when 'Resp_GiveAction' is present)+ -- TODO: split these into separate constructors+ | Info_ModuleContents [Name] I.Telescope [(Name, I.Type)]+ | Info_SearchAbout [(Name, I.Type)] String+ | Info_WhyInScope WhyInScopeData+ | Info_NormalForm CommandState ComputeMode (Maybe CPUTime) A.Expr+ | Info_InferredType CommandState (Maybe CPUTime) A.Expr+ | Info_Context InteractionId [ResponseContextEntry]+ | Info_Version+ | Info_GoalSpecific InteractionId (GoalDisplayInfo_boot tcErr)++data GoalDisplayInfo_boot tcErr+ = Goal_HelperFunction (OutputConstraint' A.Expr C.Name)+ | Goal_NormalForm ComputeMode A.Expr+ | Goal_GoalType Rewrite GoalTypeAux [ResponseContextEntry] [IPFace' Expr] [OutputForm_boot tcErr Expr Expr]+ | Goal_CurrentGoal Rewrite+ | Goal_InferredType A.Expr++-- | Goals & Warnings+type Goals_boot tcErr =+ ( [OutputConstraint_boot tcErr A.Expr InteractionId] -- visible metas (goals)+ , [OutputConstraint_boot tcErr A.Expr NamedMeta] -- hidden (unsolved) metas+ )++-- | Errors that goes into Info_Error+--+-- When an error message is displayed this constructor should be+-- used, if appropriate.+data Info_Error_boot tcErr tcWarning+ = Info_GenericError tcErr+ | Info_CompilationError (Set tcWarning)+ | Info_HighlightingParseError InteractionId+ | Info_HighlightingScopeCheckError InteractionId++-- | Auxiliary information that comes with Goal Type++data GoalTypeAux+ = GoalOnly+ | GoalAndHave A.Expr [IPFace' Expr]+ | GoalAndElaboration A.Expr++-- | Entry in context.++data ResponseContextEntry = ResponseContextEntry+ { respOrigName :: Name -- ^ The original concrete name.+ , respReifName :: Name -- ^ The name reified from abstract syntax.+ , respType :: Arg A.Expr -- ^ The type.+ , respLetValue :: Maybe A.Expr -- ^ The value (if it is a let-bound variable)+ , respInScope :: NameInScope -- ^ Whether the 'respReifName' is in scope.+ }+++-- | Status information.++data Status = Status+ { sShowImplicitArguments :: Bool+ -- ^ Are implicit arguments displayed?+ , sShowIrrelevantArguments :: Bool+ -- ^ Are irrelevant arguments displayed?+ , sChecked :: Bool+ -- ^ Has the module been successfully type checked?+ }++-- | Give action result+--+-- Comment derived from agda2-mode.el+--+-- If 'GiveResult' is 'Give_String s', then the goal is replaced by 's',+-- and otherwise the text inside the goal is retained (parenthesised+-- if 'GiveResult' is 'Give_Paren').++data GiveResult+ = Give_String String+ | Give_Paren+ | Give_NoParen
@@ -0,0 +1,77 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Interaction.SearchAbout (findMentions) where++import Control.Monad++import Data.Either (partitionEithers)+import Data.Foldable (toList)+import Data.List (isInfixOf)+import Data.Map qualified as Map+import Data.Set qualified as Set++import Agda.Interaction.Base (Rewrite)+import Agda.Interaction.BasicOps (normalForm, parseName)+import Agda.Syntax.Abstract.Name (AbstractName(..), KindOfName (PatternSynName))+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Syntax.Concrete qualified as C+import Agda.Syntax.Internal qualified as I+import Agda.Syntax.Internal.Names (namesIn)+import Agda.Syntax.Position (Range)+import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Monad+import Agda.TypeChecking.Monad.Env+import Agda.TypeChecking.Monad.Signature++import Agda.Utils.List (initLast1)+import Agda.Utils.List1 qualified as List1++findMentions :: Rewrite -> Range -> String -> ScopeM [(C.Name, I.Type)]+findMentions norm rg nm = do+ -- We start by dealing with the user's input++ -- The users passes in `nm`, a list of identifiers and strings+ -- to match against definitions in scope. `findMentions` will+ -- select all of the definitions such that:+ -- - all of the specified identifiers appear in their type+ -- (which has been normalised according to `norm`)+ -- - all of the specified strings are substrings of their name++ -- We separate the strings from the names by a rough analysis+ -- and then parse and resolve the names in the current scope+ let (userSubStrings, nms) = partitionEithers $ isString <$> words nm+ rnms <- mapM (resolveName <=< parseName rg) nms+ let userIdentifiers = fmap (fmap anameName . anames) rnms++ -- We then collect all the things in scope, by name.+ -- Issue #2381: We explicitly filter out pattern synonyms because they+ -- don't have a type. Looking it up makes Agda panic!+ snms <- fmap (nsNames . allThingsInScope) $ getNamedScope =<< currentModule+ let namesInScope = filter ((PatternSynName /=) . anameKind . snd)+ $ List1.concat $ map (\ (c, as) -> fmap (c,) as) $ Map.toList snms++ -- Once we have the user-provided names and the names of all the+ -- thing in scope we can start the search: for each name in scope,+ -- we grab its type, normalise it according to `norm` and collect+ -- the identifiers in it. We then check whether it meets the user's+ -- criteria.+ ress <- forM namesInScope $ \ (x, n) -> do+ t <- normalForm norm =<< typeOfConst (anameName n)+ return $ do+ guard $ all (`isInfixOf` prettyShow x) userSubStrings+ guard $ all (any (`Set.member` namesIn t)) userIdentifiers+ return (x, t)+ return $ concat ress++ where+ isString :: String -> Either String String+ isString ('"' : c : cs)+ | (str, '"') <- initLast1 c cs+ = Left $ filter (/= '"') str+ isString str+ = Right str++ anames (DefinedName _ an _) = [an]+ anames (FieldName ans) = toList ans+ anames (ConstructorName _ ans)= toList ans+ anames _ = []
@@ -4,167 +4,533 @@ -} module Agda.Main where -import Control.Monad.State-import Control.Monad.Error-import Control.Applicative+import Prelude hiding (null) -import Data.List-import Data.Map (Map)-import qualified Data.Map as Map+import qualified Control.Exception as E+import Control.Monad ( void )+import Control.Monad.Except ( MonadError(..), ExceptT(..), runExceptT )+import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Concurrent (setNumCapabilities)++import qualified Data.List as List+import Data.Function ( (&) )+import Data.Functor import Data.Maybe+import qualified Data.Set as Set+import qualified Data.Text as T -import System.Environment-import System.Exit-import System.FilePath-import qualified Agda.Utils.IO.Locale as LocIO-import System.Time+import GHC.Conc (getNumProcessors) -import Agda.Syntax.Position-import Agda.Syntax.Parser-import Agda.Syntax.Concrete.Pretty ()-import qualified Agda.Syntax.Abstract as A-import Agda.Syntax.Abstract.Pretty-import Agda.Syntax.Translation.ConcreteToAbstract-import Agda.Syntax.Translation.AbstractToConcrete-import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Abstract.Name-import Agda.Syntax.Strict-import Agda.Syntax.Scope.Base+import System.Environment ( getArgs, getProgName )+import System.Exit ( exitSuccess, ExitCode )+import System.FilePath ( takeFileName )+import Agda.Utils.GetOpt+import qualified System.IO as IO -import Agda.Interaction.Exceptions-import Agda.Interaction.CommandLine.CommandLine+import Agda.Interaction.BuildLibrary (buildLibrary, printAccumulatedWarnings)+import Agda.Interaction.CommandLine+import Agda.Interaction.ExitCode as ExitCode (AgdaError(..), exitSuccess, exitAgdaWith)+import Agda.Interaction.Highlighting.LaTeX.Backend (latexBackendName) import Agda.Interaction.Options-import Agda.Interaction.Monad-import Agda.Interaction.GhciTop () -- to make sure it compiles-import qualified Agda.Interaction.Imports as Imp-import qualified Agda.Interaction.Highlighting.Dot as Dot-import Agda.Interaction.Highlighting.HTML+import Agda.Interaction.Options.BashCompletion (bashComplete, printedOptions)+import Agda.Interaction.Options.Help (Help (..), helpTopicUsage)+import Agda.Interaction.EmacsTop (mimicGHCi)+import Agda.Interaction.JSONTop (jsonREPL)+import Agda.Interaction.FindFile ( SourceFile(SourceFile) )+import Agda.Interaction.Imports qualified as Imp -import Agda.TypeChecker import Agda.TypeChecking.Monad-import Agda.TypeChecking.Reduce import Agda.TypeChecking.Errors-import qualified Agda.TypeChecking.Serialise-import Agda.TypeChecking.Serialise-import Agda.TypeChecking.SizedTypes--import Agda.Compiler.MAlonzo.Compiler as MAlonzo-import Agda.Compiler.Epic.Compiler as Epic-import Agda.Compiler.JS.Compiler as JS+import qualified Agda.TypeChecking.Monad.Benchmark as Bench+import Agda.TypeChecking.Errors+import Agda.TypeChecking.Warnings+import Agda.TypeChecking.Pretty -import Agda.Termination.TermCheck+import Agda.Compiler.Backend+import Agda.Compiler.Builtin -import Agda.Utils.Monad-import Agda.Utils.FileName-import Agda.Utils.Pretty+import Agda.Setup ( getAgdaAppDir, getDataDir, setup )+import Agda.Setup.EmacsMode -import Agda.Tests-import Agda.Version+import Agda.Version (version)+import Agda.VersionCommit ( versionWithCommitInfo ) -import qualified System.IO as IO+import qualified Agda.Utils.Benchmark as UtilsBench+import qualified Agda.Syntax.Common.Pretty.ANSI as ANSI+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Utils.FileName (absolute, filePath, AbsolutePath)+import Agda.Utils.String+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null -#include "undefined.h" import Agda.Utils.Impossible+import Agda.Utils.Function (applyWhen) -- | The main function-runAgda :: TCM ()-runAgda = do- progName <- liftIO getProgName- argv <- liftIO getArgs- let opts = parseStandardOptions argv- case opts of- Left err -> liftIO $ optionError err- Right opts- | optShowHelp opts -> liftIO printUsage- | optShowVersion opts -> liftIO printVersion- | optRunTests opts -> liftIO $ do- ok <- testSuite- unless ok exitFailure- | isNothing (optInputFile opts)- && not (optInteractive opts)- -> liftIO printUsage- | otherwise -> do- setCommandLineOptions opts- checkFile+runAgda :: [Backend] -> IO ()+runAgda backends = runAgda' $ builtinBackends ++ backends++-- | The main function without importing built-in backends+runAgda' :: [Backend] -> IO ()+runAgda' backends = do+ getArgs >>= \case++ -- Special mode of operation for @--bash-complete@.+ "--bash-complete" : args ->+ case bashComplete trunc args of+ Right s -> putStr s+ Left err -> do+ putStrLn err+ exitAgdaWith ExitCode.OptionError+ where+ -- Truncate to max 50 completion suggestions.+ trunc = Just 50++ -- Ordinary entrypoint.+ args -> runAgdaArgs backends args++runAgdaArgs :: [Backend] -> [String] -> IO ()+runAgdaArgs backends args = do+ progName <- getProgName+ let (conf, warns) = runOptM $ parseBackendOptions backends args defaultOptions++ case conf of+ Left err -> optionError err+ Right (bs, opts) -> do++ -- Setup Agda if requested+ when (optSetup opts) $ Agda.Setup.setup True++ -- Print information as requested+ whenJust (optPrintVersion opts) $ printVersion bs+ whenJust (optPrintHelp opts) $ printUsage bs+ when (optPrintAgdaAppDir opts) $ printAgdaAppDir+ when (optPrintAgdaDataDir opts) $ printAgdaDataDir+ when (optPrintOptions opts) $ printOptions++ -- Setup emacs mode+ when (EmacsModeSetup `Set.member` optEmacsMode opts) do+ unless (optSetup opts) $ Agda.Setup.setup False+ setupDotEmacs $ takeFileName progName++ -- Compile emacs mode+ when (EmacsModeCompile `Set.member` optEmacsMode opts) do+ unless (optSetup opts) $ Agda.Setup.setup False+ compileElispFiles++ -- Locate emacs mode+ when (EmacsModeLocate `Set.member` optEmacsMode opts) do+ unless (optSetup opts) $ Agda.Setup.setup False+ printEmacsModeFile++ -- The absolute path of the input file, if provided+ inputFile <- liftIO $ mapM absolute $ optInputFile opts++ (runExceptT $ getInteractor bs inputFile opts) >>= \case+ Left err -> optionError err+ Right Nothing -> do+ let+ something = or+ [ opts & optSetup+ , opts & optPrintVersion & isJust+ , opts & optPrintHelp & isJust+ , opts & optPrintAgdaAppDir+ , opts & optPrintAgdaDataDir+ , opts & optPrintOptions+ , opts & optEmacsMode & not . null+ ]+ -- if no task was given to Agda+ unless something $ optionError "No task given."++ Right (Just interactor) -> do+ unless (optSetup opts) $ Agda.Setup.setup False++ runTCMPrettyErrors do++ mapM_ (warning . OptionWarning) warns++ when (optTransliterate opts) $ liftIO $ do+ -- When --interaction or --interaction-json is used, then we+ -- use UTF-8 when writing to stdout (and when reading from+ -- stdin).+ if optGHCiInteraction opts || optJSONInteraction opts+ then optionError $+ "The option --transliterate must not be combined with " +++ "--interaction or --interaction-json"+ else do+ -- Transliterate unsupported code points.+ enc <- IO.mkTextEncoding (show IO.localeEncoding ++ "//TRANSLIT")+ IO.hSetEncoding IO.stdout enc+ IO.hSetEncoding IO.stderr enc++ setSession lensBackends bs+ runAgdaWithOptions interactor progName opts+++type Interactor a+ -- Setup/initialization action.+ -- This is separated so that errors can be reported in the appropriate format.+ = TCM ()+ -- Type-checking action+ -> (AbsolutePath -> TCM CheckResult)+ -- Main transformed action.+ -> TCM a++-- | Major mode of operation, not including the standard mode (checking the given main module).+data FrontendType+ = FrontEndInteraction InteractionFormat+ -- ^ @--interaction@ or @--interaction-json@.+ | FrontEndRepl+ -- ^ @--interactive@.+ | FrontEndBuildLibrary+ -- ^ @--build-library@.++data InteractionFormat+ = InteractionEmacs+ -- ^ @--interaction@.+ | InteractionJson+ -- ^ @--interaction-json@.++pattern FrontEndEmacs :: FrontendType+pattern FrontEndEmacs = FrontEndInteraction InteractionEmacs++pattern FrontEndJson :: FrontendType+pattern FrontEndJson = FrontEndInteraction InteractionJson++{-# COMPLETE FrontEndBuildLibrary, FrontEndEmacs, FrontEndJson, FrontEndRepl #-}++buildLibraryInteractor :: Interactor ()+buildLibraryInteractor setup _check = do setup; buildLibrary++-- | Emacs/JSON mode. Note that it ignores the "check" action because it calls typeCheck directly.+interactionInteractor :: InteractionFormat -> Interactor ()+interactionInteractor InteractionEmacs setup _check = mimicGHCi setup+interactionInteractor InteractionJson setup _check = jsonREPL setup++-- | The (deprecated) repl mode.+replInteractor :: Maybe AbsolutePath -> Interactor ()+replInteractor = runInteractionLoop++-- | The interactor to use when there are no frontends or backends specified.+defaultInteractor :: AbsolutePath -> Interactor ()+defaultInteractor file setup check = do setup; void $ check file++getInteractor :: MonadError String m => [Backend] -> Maybe AbsolutePath -> CommandLineOptions -> m (Maybe (Interactor ()))+getInteractor configuredBackends maybeInputFile opts = do++ case enabledFrontends of+ _:_:_ -> throwError $ concat ["Must not specify multiple ", enabledFrontendNames]++ -- standard mode of operation+ [] -> do+ case (maybeInputFile, enabledBackends) of+ (Just inputFile, _:_) -> return $ Just $ backendInteraction inputFile enabledBackends+ (Just inputFile, []) -> return $ Just $ defaultInteractor inputFile+ (Nothing, []) -> return Nothing -- No backends, frontends, or input files specified.+ (Nothing, _:_) -> throwError $ concat ["No input file specified for ", enabledBackendNames]++ -- special mode of operation+ [fe] -> do+ case fe of+ -- --interactive+ FrontEndRepl -> do+ noBackends fe+ notJustScopeChecking fe+ return $ Just $ replInteractor maybeInputFile+ -- --interaction(-json)+ FrontEndInteraction i -> do+ noBackends fe+ notJustScopeChecking fe+ noInputFile fe+ return $ Just $ interactionInteractor i+ -- --build-library+ FrontEndBuildLibrary -> do+ noBackends fe -- Issue #8024: Backends are not supported yet.+ unless (optUseLibs opts) $+ throwError "--build-library cannot be combined with --no-libraries"+ noInputFile fe+ return $ Just buildLibraryInteractor where- checkFile :: TCM ()- checkFile = do- i <- optInteractive <$> liftTCM commandLineOptions- compile <- optCompile <$> liftTCM commandLineOptions- epic <- optEpicCompile <$> liftTCM commandLineOptions- js <- optJSCompile <$> liftTCM commandLineOptions- when i $ liftIO $ LocIO.putStr splashScreen- let failIfNoInt (Just i) = return i- -- The allowed combinations of command-line- -- options should rule out Nothing here.- failIfNoInt Nothing = __IMPOSSIBLE__+ -- NOTE: The notion of a backend being "enabled" *just* refers to this top-level interaction mode selection. The+ -- interaction/interactive front-ends may still invoke available backends even if they are not "enabled".+ isBackendEnabled (Backend b) = isEnabled b (options b)+ enabledBackends = filter isBackendEnabled configuredBackends+ enabledFrontends = concat+ [ [ FrontEndRepl | optInteractive opts ]+ , [ FrontEndEmacs | optGHCiInteraction opts ]+ , [ FrontEndJson | optJSONInteraction opts ]+ , [ FrontEndBuildLibrary | optBuildLibrary opts ]+ ]+ -- Constructs messages like "(no backend)", "backend ghc", "backends (ghc, ocaml)"+ pluralize w [] = concat ["(no ", w, ")"]+ pluralize w [x] = concat [w, " ", x]+ pluralize w xs = concat [w, "s (", List.intercalate ", " xs, ")"]+ enabledBackendNames = pluralize "backend" [ T.unpack $ backendName b | Backend b <- enabledBackends ]+ enabledFrontendNames = pluralize "frontend" (frontendFlagName <$> enabledFrontends)+ frontendFlagName = ("--" ++) . \case+ FrontEndEmacs -> "interaction"+ FrontEndJson -> "interaction-json"+ FrontEndRepl -> "interactive"+ FrontEndBuildLibrary -> "build-library"+ noBackends fe = unless (null enabledBackends) $+ throwError $ concat ["Cannot mix ", frontendFlagName fe, " with ", enabledBackendNames]+ noInputFile fe = whenJust maybeInputFile \ inputFile -> errorFrontendFileDisallowed inputFile fe+ notJustScopeChecking = when (optOnlyScopeChecking opts) . errorFrontendScopeChecking+ errorFrontendScopeChecking fe = throwError $+ concat ["The --only-scope-checking flag cannot be combined with ", frontendFlagName fe]+ errorFrontendFileDisallowed inputFile fe = throwError $+ concat ["Must not specify an input file (", filePath inputFile, ") with ", frontendFlagName fe] - interaction :: TCM (Maybe Interface) -> TCM ()- interaction | i = runIM . interactionLoop- | compile = (MAlonzo.compilerMain =<<) . (failIfNoInt =<<)- | epic = (Epic.compilerMain =<<) . (failIfNoInt =<<)- | js = (JS.compilerMain =<<) . (failIfNoInt =<<)- | otherwise = (() <$)- interaction $ do- hasFile <- hasInputFile- resetState- if not hasFile then return Nothing else do- file <- getInputFile- (i, mw) <- Imp.typeCheck file+-- | Run Agda with parsed command line options+runAgdaWithOptions+ :: Interactor a -- ^ Backend interaction+ -> String -- ^ program name+ -> CommandLineOptions -- ^ parsed command line options+ -> TCM a+runAgdaWithOptions interactor progName opts = do+ -- Main function.+ -- Bill everything to root of Benchmark trie.+ UtilsBench.setBenchmarking UtilsBench.BenchmarkOn+ -- Andreas, Nisse, 2016-10-11 AIM XXIV+ -- Turn benchmarking on provisionally, otherwise we lose track of time spent+ -- on e.g. LaTeX-code generation.+ -- Benchmarking might be turned off later by setCommandlineOptions - unsolvedOK <- optAllowUnsolved <$> pragmaOptions+ Bench.billTo [] $+ interactor initialSetup checkFile+ `finally_` do+ -- Print benchmarks.+ Bench.print - result <- case mw of- Just (Imp.Warnings [] [] []) -> __IMPOSSIBLE__- Just (Imp.Warnings _ unsolved@(_:_) _)- | not unsolvedOK -> typeError $ UnsolvedMetas unsolved- Just (Imp.Warnings _ _ unsolved@(_:_))- | not unsolvedOK -> typeError $ UnsolvedConstraints unsolved- Just (Imp.Warnings termErrs@(_:_) _ _) ->- typeError $ TerminationCheckFailed termErrs- Just _ -> return Nothing- Nothing -> return $ Just i+ -- Print accumulated statistics.+ printStatistics Nothing =<< useTC lensAccumStatistics+ where+ -- Options are fleshed out here so that (most) errors like+ -- "bad library path" are validated within the interactor,+ -- so that they are reported with the appropriate protocol/formatting.+ initialSetup :: TCM ()+ initialSetup = do+ opts <- addTrustedExecutables opts+ setCommandLineOptions opts - whenM (optGenerateHTML <$> commandLineOptions) $- generateHTML $ iModuleName i+ -- The GHC runtime has some funky behaviour if we ask it to set+ -- the number of capabilities on startup.+ --+ -- a) The minimum heap size seems to shoot up to approx. the GC+ -- allocation area times the number of processors, which means the+ -- performance regression tests with very low memory usage limit+ -- simply fail to start;+ --+ -- b) Even if we set the number of capabilities back down to 1,+ -- the parallel GC seems to be used unconditionally if we have+ -- more capabilities on startup, which adds a noticeable amount of+ -- overhead.+ liftIO case optParallelChecking opts of+ Parallel Nothing -> setNumCapabilities =<< getNumProcessors+ Parallel (Just i) -> setNumCapabilities i+ Sequential -> setNumCapabilities 1 - whenM (isJust . optDependencyGraph <$> commandLineOptions) $- Dot.generateDot $ i+ checkFile :: AbsolutePath -> TCM CheckResult+ checkFile inputFile = do+ -- Andreas, 2013-10-30 The following 'resetState' kills the+ -- verbosity options. That does not make sense (see fail/Issue641).+ -- 'resetState' here does not seem to serve any purpose,+ -- thus, I am removing it.+ -- resetState+ let mode = if optOnlyScopeChecking opts+ then Imp.ScopeCheck+ else Imp.TypeCheck + src <- srcFromPath inputFile+ result <- Imp.typeCheckMain mode =<< Imp.parseSource src++ unless (crMode result == ModuleScopeChecked) $+ Imp.raiseNonFatalErrors result++ let i = crInterface result+ reportSDoc "main" 50 $ pretty i++ printAccumulatedWarnings return result + -- | Print usage information.-printUsage :: IO ()-printUsage = do+printUsage :: [Backend] -> Help -> IO ()+printUsage backends hp = do progName <- getProgName- LocIO.putStr $ usage standardOptions_ [] progName+ putStr $ unlines+ [ "Agda version " ++ version+ , ""+ , "Usage: " ++ progName ++ " [OPTIONS...] [FILE]"+ ]+ case hp of+ GeneralHelp -> do+ forM_ optionGroups \ (header, opts) -> do+ usage header opts+ forM_ backends \ (Backend b) -> do+ let+ opts = applyWhen (backendName b == latexBackendName)+ (++ map void (snd latexPragmaOptions))+ (map void (commandLineFlags b))+ -- NB: @map void@ to make the 'OptDescr' types match.+ usage (T.unpack (backendName b) ++ " backend options") opts+ HelpFor topic -> putStr $ helpTopicUsage topic+ where+ fmt h = "\n" ++ h ++ ":\n"+ width = 40+ usage :: String -> [OptDescr a] -> IO ()+ usage header opts = putStr $ usageInfo width (fmt header) opts -- | Print version information.-printVersion :: IO ()-printVersion =- LocIO.putStrLn $ "Agda version " ++ version+printVersion :: [Backend] -> PrintAgdaVersion -> IO ()+printVersion _ PrintAgdaNumericVersion = putStrLn versionWithCommitInfo+printVersion backends PrintAgdaVersion = do+ putStrLn $ "Agda version " ++ versionWithCommitInfo+ unless (null flags) $+ mapM_ putStrLn $ ("Built with flags (cabal -f)" :) $ map bullet flags+ mapM_ putStrLn+ [ bullet $ T.unpack $ T.unwords [ name, "backend version", ver ]+ | Backend Backend'{ backendName = name, backendVersion = Just ver } <- backends ]+ where+ bullet = (" - " ++)+ -- Print cabal flags that were involved in compilation.+ flags =+ -- Keep in alphabetical order!+#ifdef DEBUG+ "debug: enable debug printing ('-v' verbosity flags)" :+#endif+#ifdef DEBUG_PARSING+ "debug-parsing: enable printing grammars for operator parsing via '-v scope.grammar:10'" :+#endif+#ifdef DEBUG_SERIALISATION+ "debug-serialisation: extra debug info during serialisation into '.agdai' files" :+#endif+#ifdef COUNT_CLUSTERS+ "enable-cluster-counting: unicode cluster counting in LaTeX backend using the ICU library" :+#endif+#ifdef OPTIMISE_HEAVILY+ "optimise-heavily: extra optimisations" :+#endif+#ifdef USE_XDG_DATA_HOME+ concat+ [ "use-xdg-data-home: install and locate data files under $XDG_DATA_HOME/agda/"+ , "$AGDA_VERSION" -- , versionWithCommitInfo+ -- Andreas, 2025-06-28, we could put in the actual version here+ -- but I think the text is clearer in the generic form+ , " by default instead of the location defined by Cabal"+ ]+ :+#endif+#ifdef VERSION_WITH_GIT_HASH+ "version-with-git-hash: suffix version information with the Git commit hash" :+#endif+ [] +printAgdaDataDir :: IO ()+printAgdaDataDir = putStrLn =<< getDataDir++printAgdaAppDir :: IO ()+printAgdaAppDir = putStrLn =<< getAgdaAppDir++printOptions :: IO ()+printOptions = mapM_ putStrLn printedOptions+ -- | What to do for bad options. optionError :: String -> IO () optionError err = do- LocIO.putStrLn $ "Error: " ++ err- printUsage- exitFailure+ prog <- getProgName+ putStrLn $ "Error: " ++ err ++ "\nRun '" ++ prog ++ " --help' for help on command line options."+ exitAgdaWith ExitCode.OptionError --- | Main-main :: IO ()-main = do-#if MIN_VERSION_base(4,2,0)- -- Ensure that UTF-8 is used for functions in Agda.Utils.IO.Locale- IO.hSetEncoding IO.stdout IO.utf8+-- | Run a TCM action in IO; catch and pretty print errors.++-- If some error message cannot be printed due to locale issues, then+-- one may get the "Error when handling error" error message. There is+-- currently no test case for this error, but on some systems one can+-- (at the time of writing) trigger it by running @LC_CTYPE=C agda+-- --no-libraries Bug.agda@, where @Bug.agda@ contains the following+-- code (if there is some other file in the same directory, for+-- instance @Bug.lagda@, then the error message may be different):+--+-- @+-- _ : Set+-- _ = Set+-- @++runTCMPrettyErrors :: TCM () -> IO ()+runTCMPrettyErrors tcm = do+ r <- runTCMTop+ ( ( (Nothing <$ tcm)+ `catchError` \err -> do+ s2s <- prettyTCWarnings' =<< getAllWarningsOfTCErr err+ s1 <- prettyError err+ ANSI.putDocLn $ P.vsep $ s2s ++ [ s1 ]+ liftIO $ do+ helpForLocaleError err+ return (Just TCMError)+ ) `catchImpossible` \e -> do+ printException e+ return (Just ImpossibleError)+ ) `E.catches`+ -- Catch all exceptions except for those of type ExitCode+ -- (which are thrown by exitWith) and asynchronous exceptions+ -- (which are for instance raised when Ctrl-C is used, or if+ -- the program runs out of heap or stack space).+ [ E.Handler $ \(e :: ExitCode) -> E.throw e+ , E.Handler $ \(e :: E.AsyncException) -> E.throw e+ , E.Handler $ \(e :: E.SomeException) -> do+ printException e+ return $ Right (Just UnknownError)+ ]+ case r of+ Right Nothing -> exitSuccess+ Right (Just reason) -> exitAgdaWith reason+ Left err -> do+ liftIO $ do+ putStrLn "\n\nError when handling error:"+ putStrLn $ tcErrString err+ helpForLocaleError err+ exitAgdaWith UnknownError+ where+ printException e = liftIO $ putStr $+ -- Andreas, 2024-07-03, issue #7299+ -- Regression in base-4.20: printing of exception produces trailing whitespace.+ -- https://gitlab.haskell.org/ghc/ghc/-/issues/25052+#if MIN_VERSION_base(4,20,0)+ rtrim $ #endif- r <- runTCM $ runAgda `catchError` \err -> do- s <- prettyError err- liftIO $ LocIO.putStrLn s- throwError err- case r of- Right _ -> exitSuccess- Left _ -> exitFailure- `catchImpossible` \e -> do- LocIO.putStr $ show e- exitFailure+ E.displayException e++-- | If the error is an IO error, and the error message suggests that+-- the problem is related to locales or code pages, print out some+-- extra information.++helpForLocaleError :: TCErr -> IO ()+helpForLocaleError e = case e of+ (IOException _ _ e)+ | "invalid argument" `List.isInfixOf` show e -> msg+ _ -> return ()+ where+ msg = putStr $ unlines+ [ ""+ , "This error may be due to the use of a locale or code page that does not"+ , "support some character used in the program being type-checked."+ , ""+ , "If it is, then one option is to use the option --transliterate, in which"+ , "case unsupported characters are (hopefully) replaced with something else,"+ , "perhaps question marks. However, that could make the output harder to"+ , "read."+ , ""+ , "If you want to fix the problem \"properly\", then you could try one of the"+ , "following suggestions:"+ , ""+ , "* If you are using Windows, try switching to a different code page (for"+ , " instance by running the command 'CHCP 65001')."+ , ""+ , "* If you are using a Unix-like system, try using a different locale. The"+ , " installed locales are perhaps printed by the command 'locale -a'. If"+ , " you have a UTF-8 locale installed (for instance sv_SE.UTF-8), then you"+ , " can perhaps make Agda use this locale by running something like"+ , " 'LC_ALL=sv_SE.UTF-8 agda <...>'."+ ]
@@ -0,0 +1,690 @@+-- | This module contains the implementation of Mimer, the current+-- implementation of the auto interactive command (C-c C-a) and the successor of+-- Agsy.+--+-- The overall idea is that Mimer gathers a collection of "components" that it+-- could use for building a solution and tries to refine the goal iteratively+-- using these components. Components include global definitions, local variables,+-- let-bound variables, and recursive calls to the function being defined.+--+-- Mimer manages multiple branches of the search at the same time and assigns a+-- cost to each branch, which is the sum of the costs of all its components. The+-- cost of a component in turn is determined by its type and the number of new+-- metas it introduces.+--+-- A branch can be refined by picking one of its unsolved metavariables and+-- refining it with all available components, resulting in a number of new+-- branches (each one with a higher cost than the original).+--+-- Mimer iteratively refines the branch with the lowest cost until it finds a+-- solution or runs out of time.++module Agda.Mimer.Mimer+ ( MimerResult(..)+ , mimer+ )+ where++import Prelude hiding (null)++import Control.Monad+import Control.Monad.Except (catchError)+import Control.Monad.IO.Class (liftIO)+import Control.Monad.Reader (ReaderT(..), runReaderT, asks, ask, lift)+import Data.Functor ((<&>))+import qualified Data.Map as Map+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Maybe (maybeToList)+import Data.PQueue.Min (MinQueue)+import qualified Data.PQueue.Min as Q++import qualified Agda.Benchmarking as Bench+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty qualified as P+import Agda.Syntax.Info (pattern UnificationMeta)+import Agda.Syntax.Internal+import Agda.Syntax.Position (Range, noRange)+import Agda.Syntax.Translation.InternalToAbstract (reify, blankNotInScope)++import Agda.TypeChecking.CheckInternal ( checkInternal )+import Agda.TypeChecking.Empty (isEmptyType)+import Agda.TypeChecking.Level (levelType)+import Agda.TypeChecking.MetaVars (newValueMeta)+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce (reduce, instantiateFull, instantiate)+import Agda.TypeChecking.Rules.Term (makeAbsurdLambda)+import Agda.TypeChecking.Substitute (apply)++import Agda.Interaction.Options ( optDoubleCheck )++import Agda.Utils.Impossible (__IMPOSSIBLE__)+import Agda.Utils.Maybe (catMaybes)+import Agda.Utils.Monad (concatMapM, ifM, whenM)+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.Tuple (first, second)+import Agda.Utils.Time (measureTime, getCPUTime, fromMilliseconds)++import Data.IORef (readIORef)++import Agda.Interaction.Base (Rewrite(..))+import Agda.Interaction.BasicOps (normalForm)++import Agda.Mimer.Types (MimerResult(..), BaseComponents(..), Component(..), RecCall(..),+ SearchBranch(..), SearchStepResult(..), SearchOptions(..),+ Goal(..), Costs(..), goalMeta, deleteCompMeta,+ incRefineFail, incRefineSuccess, incCompRegen, incCompNoRegen,+ nextGoal, addCost, isNoResult)+import Agda.Mimer.Monad+import Agda.Mimer.Options++-- IDEA for implementing case-splitting:+-- 1. Modify the collectRecVarCandidates to get all variables.+-- 2. Go through all variables to see if they are data types (not records)+-- 3. Run makeCase for those variables.+-- 4. Find out how to get the new interaction points/metas from the cases+-- 5. After search is done, compute out-of-scope variables.+-- 6. Run make-case again to introduce those variables.+-- 7. Redo the reification in the new clauses.+-- 8. Return the new clauses and follow Auto for insertion.++-- | Entry point.+-- Run Mimer on the given interaction point, returning the desired solution(s).+-- Also debug prints timing statistics.+mimer :: MonadTCM tcm+ => Rewrite -- ^ Degree of normalization of solution terms.+ -> InteractionId -- ^ Hole to run on.+ -> Range -- ^ Range of hole (for parse errors).+ -> String -- ^ Content of hole (to parametrize Mimer).+ -> tcm MimerResult+mimer norm ii rng argStr = liftTCM $ do+ reportSDoc "mimer.top" 10 do+ "Running Mimer on interaction point" <+> pretty ii <+> "with argument string" <+> text (show argStr)++ (sol, time) <- measureTime $ do++ opts <- parseOptions ii rng argStr+ reportS "mimer.top" 60 ("Mimer options: " ++ show opts)++ sols <- localTCState $ runSearch norm opts ii rng++ -- Turn the solutions into the desired results (first solution or list of solutions).+ case drop (optSkip opts) $ zip [0..] sols of+ [] -> do+ reportSLn "mimer.top" 10 "No solution found"+ return MimerNoResult+ sols' | optList opts -> pure $ MimerList [ (i, s) | (i, MimerExpr s) <- sols' ]+ (_, sol) : _ -> do+ reportSDoc "mimer.top" 10 $ "Solution:" <+> prettyTCM sol+ return sol++ -- Print timing statistic.+ reportSDoc "mimer.top" 10 ("Total elapsed time:" <+> pretty time)+ when (not $ isNoResult sol) $+ verboseS "mimer.stats" 50 $ writeTime ii time++ return sol+++-- Order to try things in:+-- 1. Local variables (including let-bound)+-- 2. Data constructors+-- 3. Where clauses+-- 4. Lambda abstract+-- Other: Equality, empty type, record projections+-- - If we only use constructors if the target type is a data type, we might+-- generate η-reducible expressions, e.g. λ xs → _∷_ 0 xs+++------------------------------------------------------------------------------+-- * Core algorithm+------------------------------------------------------------------------------++runSearch :: Rewrite -> Options -> InteractionId -> Range -> TCM [MimerResult]+runSearch norm options ii rng = withInteractionId ii $ do+ metaId <- lookupInteractionId ii+ metaVar <- lookupLocalMeta metaId++ -- We want to be able to solve with recursive calls+ setMetaOccursCheck metaId DontRunMetaOccursCheck++ metaIds <- case mvInstantiation metaVar of+ InstV inst -> do++ metaIds <- allOpenMetas (instBody inst)++ -- TODO: Make pretty instantiation for 'Instantiation'?+ reportSDoc "mimer.init" 20 $ sep [ "Interaction point already instantiated:" <+> pretty (instBody inst)+ , "with args" <+> pretty (instTel inst) ]++ -- ctx <- getContextTelescope+ -- #7402: still solve the top-level meta, because we don't have the correct contexts for the+ -- submetas+ return [metaId | not $ null metaIds]+ OpenMeta UnificationMeta -> do+ reportSLn "mimer.init" 20 "Interaction point not instantiated."+ return [metaId]+ _ -> __IMPOSSIBLE__+ -- TODO: Print each meta-variable's full context telescope+ reportSDoc "mimer.init" 20 $ "Remaining meta-variables to solve:" <+> prettyTCM metaIds+ reportSDoc "mimer.init" 20 $ "Meta var args" <+> (prettyTCM =<< getMetaContextArgs metaVar)+++ fnArgs1 <- withShowAllArguments' False $ getContextArgs >>= mapM prettyTCM+ fnArgs2 <- withShowAllArguments' True $ getContextArgs >>= mapM prettyTCM+ let bringScope = map snd $ filter (uncurry (/=)) $ zip fnArgs1 fnArgs2+ bringScopeNoBraces = map (filter (`notElem` ['{', '}']) . P.render) bringScope+ reportSDoc "mimer.temp" 20 $ vcat+ [ "Things to bring into scope:"+ , nest 2 $ vcat+ [ "Context args (don't show):" <+> pretty fnArgs1+ , "Context args (show all): " <+> pretty fnArgs2+ , "To bring into scope: " <+> pretty bringScope+ , "To bring into scope (str):" <+> pretty bringScopeNoBraces+ ]+ ]++ -- Check if there are any meta-variables to be solved+ case metaIds of+ -- No variables to solve, return the instantiation given+ [] -> do+ case mvInstantiation metaVar of+ InstV inst -> do+ expr <- withInteractionId ii $ do+ metaArgs <- getMetaContextArgs metaVar+ instantiateFull (apply (MetaV metaId []) metaArgs) >>= normalForm norm >>= reify+ str <- P.render <$> prettyTCM expr+ let sol = MimerExpr str+ reportSDoc "mimer.init" 10 $ "Goal already solved. Solution:" <+> text str+ return [sol]+ _ -> __IMPOSSIBLE__+ _ -> do+ searchOptions <- makeSearchOptions norm options ii+ -- Caution: startSearchBranch puts the current TCState in the branch, which includes+ -- the freshId counter for components, that gets bumped in makeSearchOptions+ -- above (computing the initial components), so it's important to not switch+ -- these two calls around.+ startBranch <- startSearchBranch metaIds++ reportSDoc "mimer.init" 20 $ "Using search options:" $$ nest 2 (prettyTCM searchOptions)+ reportSDoc "mimer.init" 20 $ "Initial search branch:" $$ nest 2 (pretty startBranch)++ flip runReaderT searchOptions $ bench [] $ do++ -- TODO: Check what timing stuff is used in Agda.Utils.Time+ timeout <- fromMilliseconds <$> asks searchTimeout+ startTime <- liftIO getCPUTime+ let go :: Int -> Int -> MinQueue SearchBranch -> SM ([MimerResult], Int)+ go 0 n _ = pure ([], n)+ go need n branchQueue = case Q.minView branchQueue of+ Nothing -> do+ reportSLn "mimer.search" 30 $ "No remaining search branches."+ return ([], n)+ Just (branch, branchQueue') -> do+ time <- liftIO getCPUTime+ mimerTrace 0 10 $ vcat+ [ "Choosing branch"+ , nest 2 $ sep+ [ branchInstantiationDocCost branch <> ","+ , nest 2 $ "metas:" <+> prettyTCM (map goalMeta $ sbGoals branch)+ ]+ ]+ reportSDoc "mimer.search" 50 $ "Full branch:" <+> pretty branch+ reportSMDoc "mimer.search" 50 $+ "Instantiation of other branches:" <+> prettyList (map branchInstantiationDocCost $ Q.toAscList branchQueue')++ let elapsed = time - startTime+ if elapsed < timeout+ then do+ stepResults <- refine branch+ reportSLn "mimer.search" 45 "partitionStepResult"+ (newBranches, sols) <- partitionStepResult stepResults+ let branchQueue'' = foldr Q.insert branchQueue' newBranches+ reportSLn "mimer.search" 40 $ show (length sols) ++ " solutions found during cycle " ++ show (n + 1)+ reportSMDoc "mimer.search" 45 $ "Solutions:" <+> prettyTCM sols+ mimerTrace 0 40 $ vcat+ [ "Cycle" <+> pretty (n + 1) <+> "branches"+ , nest 2 $ vcat $ map branchInstantiationDocCost $ Q.toAscList branchQueue''+ ]+ unless (null sols) $ mimerTrace 0 20 $ vcat+ [ "Cycle" <+> pretty (n + 1) <+> "solutions"+ , nest 2 $ vcat $ map prettyTCM sols+ ]++ let sols' = take need sols+ first (sols' ++) <$> go (need - length sols') (n + 1) branchQueue''+ else do+ reportSLn "mimer.search" 30 $ "Search time limit reached. Elapsed search time: " ++ show elapsed+ return ([], n)+ let numSolutions | optList options = 10 + optSkip options+ | otherwise = 1 + optSkip options+ (sols, nrSteps) <- go numSolutions 0 $ Q.singleton startBranch+ reportSLn "mimer.search" 20 $ "Search ended after " ++ show (nrSteps + 1) ++ " cycles"+ -- results <- liftTCM $ mapM exprToStringAndVars sols+ reportSDoc "mimer.search" 15 $ "Solutions found: " <+> prettyList (map prettyTCM sols)+ reportSMDoc "mimer.stats" 10 $ do+ ref <- asks searchStats+ stats <- liftIO $ readIORef ref+ "Statistics:" <+> text (show stats)+ return sols++-- | If there is no cache entry for the checkpoint, create one. If there already+-- is one, even if the components are not yet generated for some entries, it is+-- returned as is.+prepareComponents :: Goal -> SearchBranch -> SM (SearchBranch, [(Component, [Component])])+prepareComponents goal branch = withBranchAndGoal branch goal $ do+ reportSDoc "mimer.components" 50 $ "Preparing components for goal" <+> prettyTCM (goalMeta goal)+ checkpoint <- viewTC eCurrentCheckpoint+ -- Check if we there is something in the cache for this checkpoint+ comps <- case Map.lookup checkpoint (sbCache branch) of+ -- No, generate components from scratch+ Nothing -> do+ updateStat incCompRegen+ reportSDoc "mimer.components" 20 $ vcat+ [ "No cache found checkpoint:" <+> pretty checkpoint+ , nest 2 $ "with context:" <+> (inTopContext . prettyTCM =<< getContextTelescope) ]+ -- Generate components for this context+ comps <- genComponents+ reportSDoc "mimer.components" 20 $ "Generated" <+> pretty (sum $ map (length . snd) comps) <+> "components"+ whenM (optDoubleCheck <$> pragmaOptions) $+ mapM_ checkInternalComponent $ concatMap (\(x,xs) -> x:xs) comps+ return comps+ -- Yes, just update the missing generated components+ Just cache -> mapM prepare (Map.toAscList cache)+ let newCache = Map.fromList $ map (second Just) comps+ branch' <- updateBranch [] branch{sbCache = Map.insert checkpoint newCache (sbCache branch)}+ return (branch', comps)+ where+ prepare :: (Component, Maybe [Component]) -> SM (Component, [Component])+ prepare (sourceComp, Just comps) = do+ updateStat incCompNoRegen+ return (sourceComp, comps)+ prepare (sourceComp, Nothing) = do+ updateStat incCompRegen+ (sourceComp,) <$> genComponentsFrom True sourceComp++checkInternalComponent :: Component -> SM ()+checkInternalComponent comp = do+ reportSDoc "mimer.components" 40 $ "double-checking component" <+> prettyTCM comp+ lift $ checkInternal (compTerm comp) CmpLeq (compType comp)++genComponents :: SM [(Component, [Component])]+genComponents = do+ opts <- ask+ let comps = searchBaseComponents opts+ n <- localVarCount+ reportSDoc "mimer.components" 20 $ "Generating components"+ localVars <- lift (getLocalVars n (costLocal $ searchCosts opts))+ >>= genAddSource (searchGenProjectionsLocal opts)+ reportSDoc "mimer.components" 25 $ " localVars = " <+> pretty localVars+ recCalls <- genAddSource (searchGenProjectionsRec opts) (maybeToList (hintThisFn comps) ++ hintMutualFns comps)+ reportSDoc "mimer.components" 25 $ " recCalls = " <+> pretty recCalls+ letVars <- mapM getOpenComponent (hintLetVars comps)+ >>= genAddSource (searchGenProjectionsLet opts)+ reportSDoc "mimer.components" 25 $ " letVars = " <+> pretty letVars+ fns <- genAddSource (searchGenProjectionsExternal opts) (hintFns comps)+ reportSDoc "mimer.components" 25 $ " fns = " <+> pretty fns+ axioms <- genAddSource (searchGenProjectionsExternal opts) (hintAxioms comps)+ reportSDoc "mimer.components" 25 $ " axioms = " <+> pretty axioms+ return $ localVars ++ letVars ++ recCalls ++ fns ++ axioms+ where+ genAddSource :: Bool -> [Component] -> SM [(Component, [Component])]+ genAddSource genProj = mapM (\comp -> (comp,) <$> genComponentsFrom genProj comp)+++genComponentsFrom :: Bool -- ^ Apply record elimination+ -> Component+ -> SM [Component]+genComponentsFrom appRecElims origComp = do+ reportSDoc "mimer.components" 50 $ "Generating components from original component" <+> prettyTCM (compId origComp) <+> prettyTCM (compName origComp)+ comps <- if | compRec origComp /= NotRecCall+ -> mapM (applyToMetasG Nothing) =<< genRecCalls origComp+ | otherwise+ -> singleton <$> applyToMetasG Nothing origComp+ if appRecElims+ then concat <$> mapM (applyProjections Set.empty) comps+ else return comps+ where+ applyProjections :: Set QName -> Component -> SM [Component]+ applyProjections seenRecords comp = do+ projComps <- getRecordInfo (compType comp) >>= \case+ Nothing -> return []+ Just (recordName, args, fields, isRecursive)+ | Set.member recordName seenRecords -> do+ reportSDoc "mimer.components" 60 $+ "Skipping projection because recursive record already seen:" <+> pretty recordName+ return []+ | otherwise -> do+ let seenRecords' = if isRecursive then Set.insert recordName seenRecords else seenRecords+ comps <- mapM (applyProj args comp >=> applyToMetasG Nothing) fields+ concatMapM (applyProjections seenRecords') comps+ return $ comp : projComps++genRecCalls :: Component -> SM [Component]+genRecCalls thisFn = do+ reportSDoc "mimer.components.open" 40 $ "Generating recursive calls for component" <+> prettyTCM (compId thisFn) <+> prettyTCM (compName thisFn)+ reportSDoc "mimer.components.open" 60 $ " checkpoint =" <+> (prettyTCM =<< viewTC eCurrentCheckpoint)+ -- TODO: Make sure there are no pruning problems+ rv <- asks (hintRecVars . searchBaseComponents)+ reportSDoc "mimer.components" 40 $ " rv = " <+> pretty (fmap (map fst) rv)+ getOpen rv >>= \case+ [] -> do+ reportSDoc "mimer.components" 40 $ "No candidate arguments for a recursive call"+ return []+ recCandTerms -> do+ reportSDoc "mimer.components" 45 $ " recCandTerms = " <+> pretty (map fst recCandTerms)+ Costs{ costLocal, costNewMeta, costNewHiddenMeta } <- asks searchCosts+ n <- localVarCount+ localVars <- lift $ getLocalVars n costLocal+ let recCands = [ (t, i) | t@(compTerm -> v@Var{}) <- localVars, NoSubst i <- maybeToList $ lookup v recCandTerms ]++ -- For a mutual call, argument positions need not correspond (#8783).+ let isMutualCall = compRec thisFn == MutualCall+ samePos i j = isMutualCall || i == j++ newRecCall = do+ -- Apply the recursive call to new metas+ (thisFnTerm, thisFnType, newMetas) <- lift $ applyToMetas 0 (compTerm thisFn) (compType thisFn)+ let argGoals = map Goal newMetas+ comp <- newComponent newMetas (compCost thisFn) (compName thisFn) 0 thisFnTerm thisFnType+ return (comp, zip argGoals [0..])++ -- go :: Component -- ^ Recursive call function applied to meta-variables+ -- -> [(Goal, Int)] -- ^ Remaining parameters to try to fill+ -- -> [(Component, Int)] -- ^ Remaining argument candidates for the current parameter+ -- -> SM [Component]+ go _thisFn [] _args = return []+ go thisFn (_ : goals) [] = go thisFn goals recCands+ go thisFn ((goal, i) : goals) ((arg, j) : args) | samePos i j = do+ reportSMDoc "mimer.components.rec" 80 $ hsep+ [ "Trying to generate recursive call"+ , prettyTCM (compTerm thisFn)+ , "with" <+> prettyTCM (compTerm arg)+ , "for" <+> prettyTCM (goalMeta goal) ]+ goalType <- getMetaTypeInContext (goalMeta goal)+ state <- getTC+ ifM (tryRefineWith' goal goalType arg)+ (do+ let newComp = deleteCompMeta (goalMeta goal) thisFn+ (thisFn', goals') <- newRecCall+ (newComp:) <$> go thisFn' (drop (length goals' - length goals - 1) goals') args)+ (do+ putTC state+ go thisFn ((goal, i) : goals) args)+ go thisFn goals (_ : args) = go thisFn goals args+ (thisFn', argGoals) <- newRecCall+ comps <- go thisFn' argGoals recCands+ reportSDoc "mimer.components" 45 $ " comps = " <+> pretty comps+ -- Compute costs for the calls:+ -- - costNewMeta/costNewHiddenMeta for each unsolved argument+ -- - zero for solved arguments+ -- - costLocal for the parameter we recurse on+ let callCost comp = (costLocal +) . sum <$> argCosts (compTerm comp)+ argCosts (Def _ elims) = mapM argCost elims+ argCosts _ = __IMPOSSIBLE__+ argCost (Apply arg) = instantiate arg <&> \ case+ Arg h MetaV{} | visible h -> costNewMeta+ | otherwise -> costNewHiddenMeta+ _ -> 0+ argCost Proj{} = pure 0+ argCost IApply{} = pure 0+ mapM (\ c -> (`addCost` c) <$> callCost c) comps+++refine :: SearchBranch -> SM [SearchStepResult]+refine branch = withBranchState branch $ do+ let (goal1, branch1) = nextGoal branch++ withBranchAndGoal branch1 goal1 $ do+ goalType1 <- bench [Bench.Reduce] $ reduce =<< getMetaTypeInContext (goalMeta goal1)++ mimerTrace 1 10 $ sep+ [ "Refining goal"+ , nest 2 $ prettyTCM (goalMeta goal1) <+> ":" <+> prettyTCM goalType1+ , nest 2 $ "in context" <+> (inTopContext . prettyTCM =<< getContextTelescope)+ ]++ reportSDoc "mimer.refine" 30 $ "Goal type:" <+> pretty goalType1+ reportSDoc "mimer.refine" 30 $ "Goal context:" <+> (pretty =<< getContextTelescope)++ -- Lambda-abstract as far as possible.+ -- Assigning the goal can wake up postponed constraints, which may fail;+ -- then the branch is dead (rather than the whole search).+ tryLamAbs' goal1 goalType1 branch1 >>= \case+ Nothing -> return []+ -- Absurd lambda+ Just (Left branch2) -> do+ mimerTrace 1 10 $ sep+ [ "Absurd lambda refinement", nest 2 $ prettyGoalInst goal1 ]+ args <- map Apply <$> getContextArgs+ e <- blankNotInScope =<< reify (MetaV (goalMeta goal1) args)+ return [ResultExpr e]+ -- Normal abstraction+ Just (Right (goal2, goalType2, branch2)) -> withBranchAndGoal branch2 goal2 $ do+ (branch3, components) <- prepareComponents goal2 branch2+ withBranchAndGoal branch3 goal2 $ do++ when (goalMeta goal2 /= goalMeta goal1) $ do+ mimerTrace 1 10 $ sep+ [ "Lambda refinement", nest 2 $ prettyGoalInst goal1 ]+ mimerTrace 1 10 $ sep+ [ "Refining goal"+ , nest 2 $ prettyTCM (goalMeta goal2) <+> ":" <+> prettyTCM goalType2+ , nest 2 $ "in context" <+> (inTopContext . prettyTCM =<< getContextTelescope)+ ]++ mimerTrace 2 40 $ vcat+ [ "Components:"+ , nest 2 $ vcat $ map prettyTCM $ concatMap snd components+ ]++ results1 <- tryComponents goal2 goalType2 branch3 components+ results2 <- tryDataRecord goal2 goalType2 branch3+ return $ results1 ++ results2++tryComponents :: Goal -> Type -> SearchBranch -> [(Component, [Component])] -> SM [SearchStepResult]+tryComponents goal goalType branch comps = withBranchAndGoal branch goal $ do+ reportSLn "mimer.search" 45 "tryComponents"+ checkpoint <- viewTC eCurrentCheckpoint+ let tryFor (sourceComp, comps') = do+ -- Clear out components that depend on meta-variables that have been used.+ let newCache = Map.insert sourceComp Nothing (sbCache branch Map.! checkpoint)+ newBranches <- catMaybes <$> mapM (tryRefineWith goal goalType branch) comps'+ return $ map (\br -> br{sbCache = Map.insert checkpoint newCache (sbCache branch)}) newBranches+ newBranches <- concatMapM tryFor comps+ mapM checkSolved newBranches++-- | Like 'tryLamAbs', but returns @Nothing@ if lambda abstraction fails,+-- e.g. because the assignment woke up a postponed constraint that turned out to be unsolvable.+tryLamAbs' :: Goal -> Type -> SearchBranch -> SM (Maybe (Either SearchBranch (Goal, Type, SearchBranch)))+tryLamAbs' goal goalType branch =+ (Just <$> tryLamAbs goal goalType branch) `catchError` \ err -> do+ mimerTrace 1 10 $ vcat+ [ "Failed lambda abstraction for goal" <+> prettyTCM (goalMeta goal)+ , nest 2 $ prettyTCM err ]+ return Nothing++-- | Returns @Right@ for normal lambda abstraction and @Left@ for absurd lambda.+tryLamAbs :: Goal -> Type -> SearchBranch -> SM (Either SearchBranch (Goal, Type, SearchBranch))+tryLamAbs goal goalType branch =+ case unEl goalType of+ Pi dom abs -> isEmptyType dom >>= \case+ True -> do+ reportSDoc "mimer.lam" 40 $ "Trying absurd lambda for pi type" <+> prettyTCM goalType+ f <- liftTCM $ makeAbsurdLambda noRange dom abs+ args <- map Apply <$> getContextArgs+ -- TODO: what happens when assignMeta fails?+ assignMeta (goalMeta goal) (Def f args) goalType+ return $ Left branch+ False -> do+ reportSDoc "mimer.lam" 40 $ "Trying lambda abstraction for pi type" <+> prettyTCM goalType+ let abs' | isNoName (absName abs) = abs { absName = "z" }+ | otherwise = abs+ (metaId', bodyType, metaTerm, env) <- underAbstractionAbs dom abs' $ \bodyType -> do+ reportSDoc "mimer.lam" 40 $ " bodyType = " <+> prettyTCM bodyType+ bodyType <- bench [Bench.Reduce] $ reduce bodyType -- TODO: Good place to reduce?+ reportSDoc "mimer.lam" 40 $ " bodyType (reduced) = " <+> prettyTCM bodyType+ (metaId', metaTerm) <- bench [Bench.Free] $ lift $ newValueMeta DontRunMetaOccursCheck CmpLeq bodyType+ reportSDoc "mimer.lam" 40 $ " metaId' = " <+> prettyTCM metaId'+ env <- askTC+ return (metaId', bodyType, metaTerm, env)++ let argInf = domInfo dom -- TODO: is this the correct arg info?+ newAbs = Abs (absName abs') metaTerm+ -- look at mkLam+ term = Lam argInf newAbs++ assignMeta (goalMeta goal) term goalType++ withEnv env $ tryLamAbs (Goal metaId') bodyType branch+ _ -> done+ where+ done = do+ branch' <- updateBranch [] branch -- TODO: Is this necessary?+ return $ Right (goal, goalType, branch')++-- TODO: Factor out `checkSolved`+tryDataRecord :: Goal -> Type -> SearchBranch -> SM [SearchStepResult]+tryDataRecord goal goalType branch = withBranchAndGoal branch goal $ do+ -- TODO: There is a `isRecord` function, which performs a similar case+ -- analysis as here, but it does not work for data types.+ case unEl goalType of+ Def qname elims -> theDef <$> getConstInfo qname >>= \case+ recordDefn@Record{} -> do+ tryRecord recordDefn+ dataDefn@Datatype{} -> do+ tryData dataDefn+ primitive@Primitive{} -> do+ return []+ -- TODO: Better way of checking that type is Level+ Axiom{}+ | P.prettyShow qname == "Agda.Primitive.Level" -> do+ tryLevel+ | otherwise -> do+ return []+ DataOrRecSig{} -> do+ return []+ GeneralizableVar{} -> do+ return []+ AbstractDefn{} -> do+ return []+ Function{} -> do+ return []+ Constructor{} -> do+ return []+ PrimitiveSort{} -> do+ return []+ Sort (Type level) -> do+ trySet level+ Sort sort -> do+ return []+ _ -> return []+ where+ -- TODO: Alternatively, the constructor can be accessed via `getRecordConstructor`+ -- TODO: There might be a neater way of applying the constructor to new metas+ tryRecord :: Defn -> SM [SearchStepResult]+ tryRecord recordDefn = do+ cost <- asks (costRecordCon . searchCosts) -- TODO: Use lenses for this?+ comp <- qnameToComponent cost $ conName $ recConHead recordDefn+ -- NOTE: at most 1+ newBranches <- maybeToList <$> tryRefineAddMetas goal goalType branch comp+ mapM checkSolved newBranches++ tryData :: Defn -> SM [SearchStepResult]+ tryData dataDefn = do+ let constructors = dataCons dataDefn+ reportSDoc "mimer.try" 40 $ hsep $ "tryData" : map prettyTCM constructors+ cost <- asks (costDataCon . searchCosts)+ comps <- mapM (qnameToComponent cost) constructors+ newBranches <- mapM (tryRefineAddMetas goal goalType branch) comps+ -- TODO: Reduce overlap between e.g. tryLocals, this and tryRecord+ mapM checkSolved (catMaybes newBranches)++ tryLevel :: SM [SearchStepResult]+ tryLevel = do+ levelHints <- asks (hintLevel . searchBaseComponents)+ newBranches <- catMaybes <$> mapM (tryRefineAddMetas goal goalType branch) levelHints+ mapM checkSolved newBranches++ -- TODO: Add an extra filtering on the sort+ trySet :: Level -> SM [SearchStepResult]+ trySet level = do+ reportSDoc "mimer.try" 40 $ "trySet" <+> prettyTCM level+ reducedLevel <- reduce level+ cost <- asks (costSet . searchCosts)+ setCandidates <- case reducedLevel of+ (Max i [])+ | i > 0 -> do+ comp <- newComponent [] cost Nothing 0 (Sort $ Type $ Max (i - 1) []) goalType+ return [(branch, comp)]+ | otherwise -> return []+ (Max i ps) -> do+ (metaId, metaTerm) <- createMeta =<< levelType+ comp <- newComponent [metaId] cost Nothing 0 (Sort $ Type $ Max (max 0 (i - 1)) [Plus 0 metaTerm]) goalType+ reportSDoc "mimer.lam" 45 $ " new metaId =" <+> pretty metaId+ branch' <- updateBranch [metaId] branch+ return [(branch', comp)]+ reportSDoc "mimer.refine.set" 40 $+ "Trying" <+> prettyTCM (map snd setCandidates) <+> "for" <+> prettyTCM goalType+ newBranches <- catMaybes <$> mapM (\(br,c) -> tryRefineWith goal goalType br c) setCandidates+ components <- asks searchBaseComponents+ newBranches' <- catMaybes <$> mapM (tryRefineAddMetas goal goalType branch)+ (concatMap ($ components)+ [ hintDataTypes+ , hintRecordTypes+ , hintAxioms])+ mapM checkSolved (newBranches ++ newBranches')++-- | Type should already be reduced here+-- NOTE: Does not reset the state!+-- TODO: Make sure the type is always reduced+tryRefineWith :: Goal -> Type -> SearchBranch -> Component -> SM (Maybe SearchBranch)+tryRefineWith goal goalType branch comp = withBranchAndGoal branch goal do+ reportSLn "mimer.search" 45 "tryRefineWith"+ ifM (tryRefineWith' goal goalType comp)+ -- Take the metas stored in the component and add them as sub-goals+ {-then-} (Just <$> updateBranchCost comp (compMetas comp) branch)+ {-else-} (return Nothing)++tryRefineWith' :: Goal -> Type -> Component -> SM Bool+tryRefineWith' goal goalType comp = do+ -- 2025-10-17, Jesper (#8097): the calls to dumbUnifier and assignMeta+ -- here might generate new metas (e.g. through pruning existing ones) but+ -- these do not necessarily fall under the same context as the hole we're+ -- solving so we should not consider them as new goals (lest we run into+ -- bad checkpoints later).+ dumbUnifier (compType comp) goalType+ reportSLn "mimer.search" 45 "assignMeta"+ assignMeta (goalMeta goal) (compTerm comp) goalType+ -- Postponed constraints might have been woken up by the assignment.+ solveSearchConstraints++ updateStat incRefineSuccess+ reportSMDoc "mimer.refine" 50 $ "Refinement succeeded"++ mimerTrace 2 10 $ sep+ [ "Found refinement"+ , nest 2 $ sep [ prettyTCM (compTerm comp)+ , ":" <+> prettyTCM (compType comp) ] ]+ return True+ `catchError` \err -> do+ updateStat incRefineFail+ reportSMDoc "mimer.refine" 50 $ "Refinement failed"++ mimerTrace 2 60 $ vcat+ [ "Failed refinement"+ , nest 2 $ sep [ prettyTCM (compTerm comp)+ , ":" <+> prettyTCM (compType comp) ]+ , nest 2 $ prettyTCM err ]+ return False++-- TODO: Make policy for when state should be put+tryRefineAddMetas :: Goal -> Type -> SearchBranch -> Component -> SM (Maybe SearchBranch)+tryRefineAddMetas goal goalType branch comp = withBranchAndGoal branch goal $ do+ -- Apply the hint to new metas (generating @c@, @c ?@, @c ? ?@, etc.)+ -- TODO: Where is the best place to reduce the hint type?+ comp' <- applyToMetasG Nothing comp+ branch' <- updateBranch [] branch+ tryRefineWith goal goalType branch' comp'
@@ -0,0 +1,789 @@+{-# LANGUAGE RecordWildCards #-}++module Agda.Mimer.Monad where++import Control.DeepSeq (NFData(..))+import Control.Monad+import Control.Monad.Except (catchError, MonadError)+import Control.Monad.IO.Class (liftIO)+import Control.Monad.Reader (ReaderT(..), asks, ask, lift)+import Data.Functor ( ($>) )+import Data.IORef (modifyIORef', newIORef)+import Data.Map qualified as Map+import Data.List qualified as List+import Data.List.NonEmpty qualified as NonEmptyList (head)+import Data.Maybe+import Data.Set qualified as Set++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty qualified as P+import Agda.Syntax.Internal+import Agda.Syntax.Position (rangeFile, rangeFilePath)+import Agda.Syntax.Concrete.Name qualified as C+import Agda.Syntax.Abstract (Expr)+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Abstract.Views qualified as A+import Agda.Syntax.Internal.MetaVars (AllMetas(..))+import Agda.Syntax.Translation.AbstractToConcrete (abstractToConcrete_)+import Agda.Syntax.Translation.InternalToAbstract (reify, blankNotInScope)+import Agda.Syntax.Scope.Base qualified as Scope+import Agda.TypeChecking.Monad+import Agda.TypeChecking.MetaVars (newValueMeta)+import Agda.TypeChecking.Primitive (getBuiltinName)+import Agda.TypeChecking.Datatypes (isDataOrRecord)+import Agda.TypeChecking.Reduce (reduce, instantiateFull, instantiate)+import Agda.TypeChecking.Records (isRecord)+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Conversion (equalType)+import Agda.TypeChecking.Telescope (flattenTel, piApplyM)+import Agda.TypeChecking.Substitute (pattern TelV, telView', piApply, apply, applyE)+import Agda.Interaction.BasicOps (normalForm)+import Agda.Interaction.Base (Rewrite(..))+import Agda.Benchmarking qualified as Bench+import Agda.Utils.Benchmark (billTo)+import Agda.Utils.Functor ((<&>), (<.>))+import Agda.Utils.FileName (filePath)+import Agda.Utils.Impossible+import Agda.Utils.Monad (ifM)+import Agda.Utils.Maybe.Strict qualified as SMaybe+import Agda.Utils.Time (CPUTime(..))++import Agda.Mimer.Options+import Agda.Mimer.Types++type SM a = ReaderT SearchOptions TCM a++------------------------------------------------------------------------+-- * Agda internals+------------------------------------------------------------------------++getRecordFields :: (HasConstInfo tcm) => QName -> tcm [QName]+getRecordFields = fmap (map unDom . recFields . theDef) . getConstInfo++getRecordInfo :: (MonadTCM tcm, HasConstInfo tcm) => Type+ -> tcm (Maybe ( QName -- Record name+ , Args -- Record parameters converted to (hidden) arguments+ , [QName] -- Field names+ , Bool -- Is recursive?+ ))+getRecordInfo typ = case unEl typ of+ Def qname elims -> isRecord qname >>= \case+ Nothing -> return Nothing+ Just defn -> do+ fields <- getRecordFields qname+ return $ Just (qname, argsFromElims elims, fields, recRecursive_ defn)+ _ -> return Nothing++allOpenMetas :: (AllMetas t, ReadTCState tcm) => t -> tcm [MetaId]+allOpenMetas t = do+ openMetas <- getOpenMetas+ return $ allMetas (:[]) t `List.intersect` openMetas++assignMeta :: MetaId -> Term -> Type -> SM ()+assignMeta metaId term metaType = bench [Bench.CheckRHS] $ do+ metaVar <- lookupLocalMeta metaId+ metaArgs <- getMetaContextArgs metaVar++ reportSMDoc "mimer.assignMeta" 60 do+ tel <- getContextTelescope+ vcat $ concat+ [ [ "Assigning" <+> pretty term ]+ , [ nest 2 $ "to" <+> pretty metaId <+> ":" <+> pretty metaType ]+ , [ nest 2 $ "in context" <+> pretty tel | not $ null tel ]+ ]++ assignV DirLeq metaId metaArgs term (AsTermsOf metaType)++getLocalVarTerms :: Int -> TCM [(Term, Dom Type)]+getLocalVarTerms localCxt = do+ contextTerms <- getContextTerms+ contextTypes <- flattenTel <$> getContextTelescope+ let inScope i _ | i < localCxt = pure True -- Ignore scope for variables we inserted ourselves+ inScope _ (unDom -> name) = do+ x <- abstractToConcrete_ name+ pure $ C.isInScope x == C.InScope+ scope <- mapM (uncurry inScope) =<< getContextVars+ return [ e | (True, e) <- zip scope $ zip contextTerms contextTypes ]++-- TODO: Rename (see metaInstantiation)+getMetaInstantiation :: (MonadTCM tcm, PureTCM tcm, MonadInteractionPoints tcm, MonadFresh NameId tcm)+ => MetaId -> tcm (Maybe Expr)+getMetaInstantiation = metaInstantiation >=> traverse (instantiateFull >=> reify)++metaInstantiation :: (MonadDebug tcm, ReadTCState tcm) => MetaId -> tcm (Maybe Term)+metaInstantiation metaId = lookupLocalMeta metaId <&> mvInstantiation >>= \case+ InstV inst -> return $ Just $ instBody inst+ _ -> return Nothing++-- TODO: why not also accept pattern record types here?+isTypeDatatype :: (MonadTCM tcm) => Type -> tcm Bool+isTypeDatatype typ = liftTCM do+ reduce typ <&> unEl >>= isDataOrRecord <&> \case+ Just (_, IsData) -> True+ _ -> False++-- | Is an element of the given type computing a level?+--+-- The returned checker is only sound but not complete because the type is taken as-is+-- rather than being reduced.+endsInLevelTester :: TCM (Type -> Bool)+endsInLevelTester = do+ getBuiltinName builtinLevel >>= \case+ Nothing -> return $ const False+ Just level -> return \ t ->+ -- NOTE: We do not reduce the type before checking, so some user definitions+ -- will not be included here.+ case telView' t of+ TelV _ (El _ (Def x _)) -> x == level+ _ -> False++-- | From the scope of the given meta variable,+-- extract all names in scope that we could use during synthesis.+-- (This excludes macros, generalizable variables, pattern synonyms.)+getEverythingInScope :: MetaVariable -> [QName]+getEverythingInScope metaVar = do+ let scope = clScope $ getMetaInfo metaVar+ let nameSpace = Scope.everythingInScope scope+ names = Scope.nsNames nameSpace+ validKind = \ case+ PatternSynName -> False -- could consider allowing pattern synonyms, but the problem is they can't be getConstInfo'd+ GeneralizeName -> False -- and any way finding the underlying constructors should be easy+ DisallowedGeneralizeName -> False+ MacroName -> False+ QuotableName -> False+ ConName -> True+ CoConName -> True+ FldName -> True+ DataName -> True+ RecName -> True+ FunName -> True+ AxiomName -> True+ PrimName -> True+ OtherDefName -> True+ qnames = map anameName+ . filter (validKind . anameKind)+ . map NonEmptyList.head+ $ Map.elems names+ qnames++-- TODO: Make sure the type is reduced the first time this is called+-- TODO: Rewrite with Component?+-- NOTE: The new metas are in left-to-right order -- the opposite of the+-- order they should be solved in.+applyToMetas :: Nat -> Term -> Type -> TCM (Term, Type, [MetaId])+applyToMetas skip term typ = do+ ctx <- getContextTelescope+ case unEl typ of+ Pi dom abs -> do+ let domainType = unDom dom+ -- TODO: What exactly does the occur check do?+ (metaId', metaTerm) <- newValueMeta DontRunMetaOccursCheck CmpLeq domainType+ let arg = setOrigin Inserted $ metaTerm <$ argFromDom dom+ newType <- reduce =<< piApplyM typ metaTerm -- TODO: Is this the best place to reduce?+ -- For records, the parameters are not included in the term+ let newTerm = if skip > 0 then term else apply term [arg]+ (term', typ', metas) <- applyToMetas (max 0 $ skip - 1) newTerm newType+ return (term', typ', metaId' : metas)+ _ -> return (term, typ, [])++------------------------------------------------------------------------+-- * Components+------------------------------------------------------------------------++localVarCount :: SM Int+localVarCount = do+ top <- asks $ length . view eContext . searchTopEnv+ cur <- length <$> getContext+ pure $ cur - top++getOpenComponent :: (MonadTCM tcm, MonadDebug tcm) => Open Component -> tcm Component+getOpenComponent openComp = do+ let comp = openThing openComp+ reportSDoc "mimer.components.open" 40 $ "Opening component" <+> prettyTCM (compId comp) <+> prettyTCM (compName comp)+ term <- getOpen $ compTerm <$> openComp+ reportSDoc "mimer.components.open" 40 $ " term = " <+> prettyTCM term+ typ <- getOpen $ compType <$> openComp+ reportSDoc "mimer.components.open" 40 $ " typ =" <+> prettyTCM typ+ when (not $ null $ compMetas comp) __IMPOSSIBLE__+ return Component+ { compId = compId comp+ , compName = compName comp+ , compPars = compPars comp+ , compTerm = term+ , compType = typ+ , compRec = compRec comp+ , compMetas = compMetas comp+ , compCost = compCost comp+ }++newComponent :: MonadFresh CompId m => [MetaId] -> Cost -> Maybe Name -> Nat -> Term -> Type -> m Component+newComponent metaIds cost mName pars term typ = fresh <&> \cId -> mkComponent cId metaIds cost mName pars term typ++newComponentQ :: MonadFresh CompId m => [MetaId] -> Cost -> QName -> Nat -> Term -> Type -> m Component+newComponentQ metaIds cost qname pars term typ = fresh <&> \cId -> mkComponent cId metaIds cost (Just $ qnameName qname) pars term typ++-- Local variables:+-- getContext :: MonadTCEnv m => m [Dom (Name, Type)]+-- getContextArgs :: (Applicative m, MonadTCEnv m) => m Args+-- getContextTelescope :: (Applicative m, MonadTCEnv m) => m Telescope+-- getContextTerms :: (Applicative m, MonadTCEnv m) => m [Term]+getLocalVars :: Int -> Cost -> TCM [Component]+getLocalVars localCxt cost = do+ typedTerms <- getLocalVarTerms localCxt+ let varZeroDiscount (Var 0 []) = 1+ varZeroDiscount _ = 0+ mapM (\(term, domTyp) -> newComponent [] (cost - varZeroDiscount term) noName 0 term (unDom domTyp)) typedTerms++-- | NOTE: Collects components from the *current* context, not the context of+-- the 'InteractionId'.+collectComponents :: Options+ -> Costs+ -> InteractionId+ -> Maybe QName+ -> [QName]+ -> MetaId+ -> TCM BaseComponents+collectComponents opts costs ii mDefName whereNames metaId = do++ reportSDoc "mimer.components" 30 $ "collectComponents"+ reportSDoc "mimer.components" 40 $ nest 2 $ vcat+ [ "ii =" <+> pretty ii+ , "mDefName =" <+> pretty mDefName+ , "whereNames =" <+> pretty whereNames+ , "metaId =" <+> pretty metaId+ ]++ lhsVars <- collectLHSVars ii+ let recVars = lhsVars <&> \ vars -> [ (tm, NoSubst i) | (tm, Just i) <- vars ]++ reportSDoc "mimer.components" 40 $ "recVars =" <+> pretty recVars++ -- Prepare the initial component record+ letVars <- getLetVars (costLet costs)+ let components = BaseComponents+ { hintFns = []+ , hintDataTypes = []+ , hintRecordTypes = []+ , hintProjections = []+ , hintAxioms = []+ , hintLevel = []+ , hintThisFn = Nothing+ , hintMutualFns = []+ , hintRecVars = recVars+ , hintLetVars = letVars+ }++ -- Names in the same (syntactic) mutual block as the function we are defining (#8783).+ mutualBlockNames <- case mDefName of+ Nothing -> return Set.empty+ Just defName -> do+ mid <- defMutual <$> getConstInfo defName+ if mid == 0 then return Set.empty else mutualNames <$> lookupMutualBlock mid++ -- Extract additional components from the names given as hints.+ hintNames <- getEverythingInScope <$> lookupLocalMeta metaId+ isToLevel <- endsInLevelTester+ scope <- getScope+ components' <- foldM (go isToLevel scope mutualBlockNames) components $+ explicitHints ++ (hintNames List.\\ explicitHints)++ return BaseComponents+ { hintFns = doSort $ hintFns components'+ , hintDataTypes = doSort $ hintDataTypes components'+ , hintRecordTypes = doSort $ hintRecordTypes components'+ , hintProjections = doSort $ hintProjections components'+ , hintAxioms = doSort $ hintAxioms components'+ , hintLevel = doSort $ hintLevel components'+ , hintThisFn = hintThisFn components'+ , hintMutualFns = hintMutualFns components'+ , hintRecVars = recVars+ , hintLetVars = letVars+ }+ where+ hintMode = optHintMode opts+ explicitHints = optExplicitHints opts+ -- Sort by the arity of the type+ doSort = List.sortOn (arity . compType)++ -- A function is mutual with the one we are defining if it is in the+ -- same recursive group (computed by the positivity checker), or if it+ -- is declared in the same mutual block and not a local helper in a @where@.+ isMutual mutualBlockNames qname f = case mDefName of+ Nothing -> False+ Just defName -> defName /= qname && or+ [ fmap (defName `elem`) (funMutual f) == Just True+ , qname `Set.member` mutualBlockNames && qname `notElem` whereNames+ ]++ go isToLevel scope mutualBlockNames comps qname = do+ def <- getConstInfo qname+ let typ = defType def+ case theDef def of+ Axiom{}+ | isToLevel typ -> addLevel+ | shouldKeep -> addAxiom+ | otherwise -> done+ -- We can't use pattern lambdas as components nor with-functions.+ -- If the function is in the same mutual block, we only call it+ -- with structurally smaller arguments, like the function itself (#8783).+ f@Function{ funWith = NoWithFunction, funExtLam = Nothing }+ | Just qname == mDefName -> addThisFn+ | isMutual mutualBlockNames qname f -> addMutualFn+ | isToLevel typ -> addLevel+ | shouldKeep -> addFn+ Function{} -> done+ Datatype{} -> addData+ Record{} -> do+ projections <- mapM (qnameToComponent (costSpeculateProj costs)) =<< getRecordFields qname+ comp <- qnameToComponent (costSet costs) qname+ return comps{ hintRecordTypes = comp : hintRecordTypes comps+ , hintProjections = projections ++ hintProjections comps }+ -- We look up constructors when we need them+ Constructor{} -> done+ -- TODO: special treatment for primitives?+ Primitive{}+ | isToLevel typ -> addLevel+ | shouldKeep -> addFn+ | otherwise -> done+ PrimitiveSort{} -> done+ -- TODO: Check if we want to use these+ DataOrRecSig{} -> done+ GeneralizableVar{} -> done+ AbstractDefn{} -> done+ where+ done = return comps+ -- TODO: There is probably a better way of finding the module name+ mThisModule = qnameModule <$> mDefName++ shouldKeep = or+ [ qname `elem` explicitHints+ , qname `elem` whereNames+ , case hintMode of+ Unqualified -> Scope.isNameInScopeUnqualified qname scope+ AllModules -> True+ Module -> Just (qnameModule qname) == mThisModule+ NoHints -> False+ ]+ addLevel = qnameToComponent (costLevel costs) qname <&> \ comp -> comps{hintLevel = comp : hintLevel comps}+ addAxiom = qnameToComponent (costAxiom costs) qname <&> \ comp -> comps{hintAxioms = comp : hintAxioms comps}+ addThisFn = qnameToComponent (costRecCall costs) qname <&> \ comp -> comps{hintThisFn = Just comp{ compRec = SelfCall }}+ addMutualFn = qnameToComponent (costRecCall costs) qname <&> \ comp -> comps{hintMutualFns = comp{ compRec = MutualCall } : hintMutualFns comps}+ addFn = qnameToComponent (costFn costs) qname <&> \ comp -> comps{hintFns = comp : hintFns comps}+ addData = qnameToComponent (costSet costs) qname <&> \ comp -> comps{hintDataTypes = comp : hintDataTypes comps}+++qnameToComponent :: (HasConstInfo tcm, ReadTCState tcm, MonadFresh CompId tcm)+ => Cost -> QName -> tcm Component+qnameToComponent cost qname = do+ defn <- getConstInfo qname+ -- #7120: we need to apply the module params to everything+ mParams <- freeVarsToApply qname+ let def = (Def qname [] `apply` mParams, 0)+ let (term, pars) = case theDef defn of+ c@Constructor{} -> (Con (conSrcCon c) ConOCon [], conPars c - length mParams)+ Axiom{} -> def+ GeneralizableVar{} -> def+ f@Function{}+ | Right proj <- funProjection f+ , projIndex proj > 0 ->+ let totalToDrop = projIndex proj - 1+ term = Def qname $ map Apply $ drop totalToDrop mParams+ stillToDrop = max 0 $ totalToDrop - length mParams+ in (term , stillToDrop)+ Function{} -> def+ Datatype{} -> def+ Record{} -> def+ Primitive{} -> def+ PrimitiveSort{} -> def+ DataOrRecSig{} -> __IMPOSSIBLE__+ AbstractDefn{} -> __IMPOSSIBLE__+ newComponentQ [] cost qname pars term (defType defn `piApply` mParams)++-- | Turn the let bindings of the current 'TCEnv' into components.+getLetVars :: forall tcm. (MonadFresh CompId tcm, MonadTCM tcm) => Cost -> tcm [Open Component]+getLetVars cost = do+ bindings <- viewTC eLetBindings+ mapM makeComp $ Map.toAscList bindings+ where+ makeComp :: (Name, Open LetBinding) -> tcm (Open Component)+ makeComp (name, opn) = do+ cId <- fresh+ return $ opn <&> \ (LetBinding _isAxiom _origin term typ) ->+ mkComponent cId [] cost (Just name) 0 term (unDom typ)++-- | Returns the variables as terms together with whether they where found under+-- some constructor, and if so which argument of the function they appeared in. This+-- information is used when building recursive calls, where it's important that we don't try to+-- construct non-terminating solutions.+collectLHSVars :: (ReadTCState tcm, MonadError TCErr tcm, MonadTCM tcm, HasConstInfo tcm)+ => InteractionId -> tcm (Open [(Term, Maybe Int)])+collectLHSVars ii = do+ ipc <- ipClause <$> lookupInteractionPoint ii+ case ipc of+ IPNoClause -> makeOpen []+ IPClause{ipcQName = fnName, ipcClauseNo = clauseNr} -> do+ reportSDoc "mimer.components" 40 $ "Collecting LHS vars for" <+> prettyTCM ii+ reportSDoc "mimer.components" 45 $ nest 2 $ vcat+ [ "fnName =" <+> pretty fnName+ , "clauseNr =" <+> pretty clauseNr+ ]+ info <- getConstInfo fnName+ parCount <- liftTCM getCurrentModuleFreeVars+ case theDef info of+ fnDef@Function{} -> do+ let clause = funClauses fnDef !! clauseNr+ naps = namedClausePats clause++ -- Telescope at interaction point+ iTel <- getContextTelescope+ -- Telescope for the body of the clause+ let cTel = clauseTel clause+ -- HACK: To get the correct indices, we shift by the difference in telescope lengths+ let shift = length (telToArgs iTel) - length (telToArgs cTel)++ reportSDoc "mimer" 60 $ vcat+ [ "Tel:"+ , nest 2 $ pretty iTel $$ prettyTCM iTel+ , "CTel:"+ , nest 2 $ pretty cTel $$ prettyTCM cTel+ ]+ reportSDoc "mimer" 60 $ "Shift:" <+> pretty shift++ makeOpen [ (Var (n + shift) [], (i - parCount) <$ guard underCon) -- We count arguments excluding module parameters+ | (i, nap) <- zip [0..] naps+ , (n, underCon) <- go False $ namedThing $ unArg nap+ ]+ _ -> do+ makeOpen []+ where+ go isUnderCon = \case+ VarP patInf x -> [(dbPatVarIndex x, isUnderCon)]+ DotP patInf t -> [] -- Ignore dot patterns+ ConP conHead conPatInf namedArgs -> concatMap (go True . namedThing . unArg) namedArgs+ LitP{} -> []+ ProjP{} -> []+ IApplyP{} -> [] -- Only for Cubical?+ DefP{} -> [] -- Only for Cubical?++declarationQnames :: A.Declaration -> [QName]+declarationQnames dec = [ q | Scope.WithKind _ q <- A.declaredNames dec ]++applyProj :: Args -> Component -> QName -> SM Component+applyProj recordArgs comp' qname = do+ cost <- asks (costProj . searchCosts)+ -- Andreas, 2025-03-31, issue #7662: hack to prevent postfix printing of ♭+ projOrigin <- maybe ProjSystem (\ flat -> if qname == flat then ProjPrefix else ProjSystem)+ <$> asks searchBuiltinFlat+ let newTerm = applyE (compTerm comp') [Proj projOrigin qname]+ projType <- defType <$> getConstInfo qname+ projTypeWithArgs <- piApplyM projType recordArgs+ newType <- piApplyM projTypeWithArgs (compTerm comp')+ newComponentQ (compMetas comp') (compCost comp' + cost) qname 0 newTerm newType+++-- TODO: currently reducing twice+applyToMetasG+ :: Maybe Nat -- ^ Max number of arguments to apply.+ -> Component -> SM Component+applyToMetasG (Just m) comp | m <= 0 = return comp+applyToMetasG maxArgs comp = do+ reportSDoc "mimer.component" 25 $ "Applying component to metas" <+> prettyTCM (compId comp) <+> prettyTCM (compTerm comp)+ ctx <- getContextTelescope+ compTyp <- reduce $ compType comp+ case unEl compTyp of+ Pi dom abs -> do+ let domainType = unDom dom+ (metaId, metaTerm) <- createMeta domainType+ reportSDoc "mimer.component" 30 $ "New arg meta" <+> prettyTCM metaTerm+ let arg = setOrigin Inserted $ metaTerm <$ argFromDom dom+ newType <- reduce =<< piApplyM (compType comp) metaTerm+ -- Constructor parameters are not included in the term+ let skip = compPars comp+ newTerm | skip > 0 = compTerm comp+ | otherwise = apply (compTerm comp) [arg]+ cost <- asks $ (if getHiding arg == Hidden then costNewHiddenMeta else costNewMeta) . searchCosts+ let predNat n | n > 0 = n - 1+ | n == 0 = 0+ | otherwise = __IMPOSSIBLE__+ applyToMetasG (predNat <$> maxArgs)+ comp{ compTerm = newTerm+ , compType = newType+ , compPars = predNat skip+ , compMetas = metaId : compMetas comp+ , compCost = cost + compCost comp+ }+ _ ->+ -- Set the type to the reduced version+ return comp{compType = compTyp}++createMeta :: Type -> SM (MetaId, Term)+createMeta typ = do+ (metaId, metaTerm) <- lift $ newValueMeta DontRunMetaOccursCheck CmpLeq typ+ verboseS "mimer.stats" 20 $ updateStat incMetasCreated+ reportSDoc "mimer.components" 80 $ do+ "Created meta-variable (type in context):" <+> pretty metaTerm <+> ":" <+> (pretty =<< getMetaTypeInContext metaId)+ return (metaId, metaTerm)++------------------------------------------------------------------------+-- * Search branches+------------------------------------------------------------------------++startSearchBranch :: [MetaId] -> TCM SearchBranch+startSearchBranch metaIds = do+ state <- getTC+ pure SearchBranch+ { sbTCState = state+ , sbGoals = map Goal metaIds+ , sbCost = 0+ , sbCache = Map.empty+ , sbComponentsUsed = Map.empty+ }++withBranchState :: SearchBranch -> SM a -> SM a+withBranchState br ma = do+ putTC (sbTCState br)+ ma++withBranchAndGoal :: SearchBranch -> Goal -> SM a -> SM a+withBranchAndGoal br goal ma = inGoalEnv goal $ withBranchState br ma++inGoalEnv :: Goal -> SM a -> SM a+inGoalEnv goal ret = do+ reportSDoc "mimer.env" 70 $ "going into environment of goal" <+> prettyTCM (goalMeta goal)+ withMetaId (goalMeta goal) ret++updateBranch' :: Maybe Component -> [MetaId] -> SearchBranch -> SM SearchBranch+updateBranch' mComp newMetaIds branch = do+ state <- getTC+ let compsUsed = sbComponentsUsed branch+ (deltaCost, compsUsed') <- case mComp of+ Nothing -> return (0, compsUsed)+ Just comp -> do+ case compName comp of+ Nothing -> return (compCost comp, compsUsed)+ Just name -> case compsUsed Map.!? name of+ Nothing -> return (compCost comp, Map.insert name 1 compsUsed)+ Just uses -> do+ reuseCost <- asks (costCompReuse . searchCosts)+ return (compCost comp + reuseCost uses, Map.adjust succ name compsUsed)+ return branch{ sbTCState = state+ , sbGoals = map Goal newMetaIds ++ sbGoals branch+ , sbCost = sbCost branch + deltaCost+ , sbComponentsUsed = compsUsed'+ }++updateBranch :: [MetaId] -> SearchBranch -> SM SearchBranch+updateBranch = updateBranch' Nothing++updateBranchCost :: Component -> [MetaId] -> SearchBranch -> SM SearchBranch+updateBranchCost comp = updateBranch' (Just comp)++checkSolved :: SearchBranch -> SM SearchStepResult+checkSolved branch = do+ reportSDoc "mimer" 20 $ "Checking if branch is solved"+ topMetaId <- asks searchTopMeta+ topMeta <- lookupLocalMeta topMetaId+ ii <- asks searchInteractionId+ withInteractionId ii $ withBranchState branch $ do+ reportSDoc "mimer" 30 $ " remaining subgoals: " <+> prettyTCM (map goalMeta $ sbGoals branch)+ metaArgs <- getMetaContextArgs topMeta+ inst <- normaliseSolution $ apply (MetaV topMetaId []) metaArgs+ -- Issue #7639: The subgoals as generated by `applyToMetasG` (and other functions)+ -- are already stored in the `sbGoals` field of the branch.+ -- Here we just prune the subgoals that are already solved by unification.+ goals <- filterM (isNothing <.> getMetaInstantiation . goalMeta) $ sbGoals branch+ case goals of+ -- Postponed constraints must be solved by the complete solution.+ [] -> ifM (not <$> searchConstraintsSolved) (return NoSolution) $+ -- Issue #378: Blank out variables that are not in scope.+ -- This might leave unsolved metas but is probably better+ -- than generating out-of-scope variables.+ ResultExpr <$> (blankNotInScope =<< reify inst)+ _ -> do+ return $ OpenBranch branch { sbGoals = goals }++normaliseSolution :: Term -> SM Term+normaliseSolution t = do+ norm <- asks searchRewrite+ lift . normalForm norm =<< instantiateFull t++partitionStepResult :: [SearchStepResult] -> SM ([SearchBranch], [MimerResult])+partitionStepResult [] = return ([],[])+partitionStepResult (x:xs) = do+ let rest = partitionStepResult xs+ (brs',sols) <- rest+ case x of+ NoSolution -> rest+ OpenBranch br -> return (br:brs', sols)+ ResultExpr exp -> do+ reportSLn "mimer.search" 45 "partitionStepResult: render ResultExpr"+ str <- P.render <$> prettyTCM exp+ return $ (brs', MimerExpr str : sols)++------------------------------------------------------------------------+-- * Search options+------------------------------------------------------------------------++makeSearchOptions :: Rewrite+ -> Options+ -> InteractionId+ -> TCM SearchOptions+makeSearchOptions norm options ii = do+ metaId <- lookupInteractionId ii+ (mTheFunctionQName, whereNames) <- fmap ipClause (lookupInteractionPoint ii) <&> \case+ clause@IPClause{} -> ( Just $ ipcQName clause+ , case A.whereDecls $ A.clauseWhereDecls $ ipcClause clause of+ Just decl -> declarationQnames decl+ _ -> []+ )+ IPNoClause -> (Nothing, [])++ reportSDoc "mimer.init" 15 $ "Interaction point in function:" <+> pretty mTheFunctionQName+ reportSDoc "mimer.init" 25 $ "Names in where-block" <+> pretty whereNames++ env <- askTC+ costs <- ifM (hasVerbosity "mimer-custom-costs" 123456)+ {- then -} customCosts+ {- else -} (return defaultCosts)+ reportSDoc "mimer-custom-costs" 123456 $ "Using costs:" $$ nest 2 (pretty costs)+ components <- collectComponents options costs ii mTheFunctionQName whereNames metaId+ statsRef <- liftIO $ newIORef emptyMimerStats+ checkpoint <- viewTC eCurrentCheckpoint+ pid <- fresh+ mflat <- getBuiltinName BuiltinFlat+ pure SearchOptions+ { searchBaseComponents = components+ , searchHintMode = optHintMode options+ , searchTimeout = optTimeout options+ , searchGenProjectionsLocal = True+ , searchGenProjectionsLet = True+ , searchGenProjectionsExternal = False+ , searchGenProjectionsRec = True+ , searchSpeculateProjections = True+ , searchTopMeta = metaId+ , searchTopEnv = env+ , searchTopCheckpoint = checkpoint+ , searchProblem = pid+ , searchInteractionId = ii+ , searchFnName = mTheFunctionQName+ , searchCosts = costs+ , searchStats = statsRef+ , searchRewrite = norm+ , searchBuiltinFlat = mflat+ }++------------------------------------------------------------------------+-- * Unification+------------------------------------------------------------------------++-- | Unify the type of a candidate with the goal type.+--+-- Constraints that cannot be solved yet, e.g. @f ?n = f n@ blocked on+-- meta @?n@ which is a subgoal of the candidate, are postponed under+-- the search problem (see 'searchProblem').+-- They are woken up when their blocking metas are solved, and+-- 'checkSolved' only accepts a branch once they are gone.+dumbUnifier :: Type -> Type -> SM ()+dumbUnifier t1 t2 = bench [Bench.UnifyIndices] $ do+ updateStat incTypeEqChecks+ pid <- asks searchProblem+ lift $ solvingProblem pid $ equalType t2 t1++-- | Solve constraints woken up by meta assignments.+-- Throws an error if one of them turns out to be unsolvable.+solveSearchConstraints :: SM ()+solveSearchConstraints = lift solveAwakeConstraints++-- | Are all constraints solved that were postponed during search?+searchConstraintsSolved :: SM Bool+searchConstraintsSolved = do+ pid <- asks searchProblem+ (solveSearchConstraints >> null <$> getConstraintsForProblem pid)+ `catchError` \ _ -> return False++------------------------------------------------------------------------+-- * Debugging+------------------------------------------------------------------------++reportSMDoc :: VerboseKey -> VerboseLevel -> SM Doc -> SM ()+reportSMDoc vk vl md = reportSDoc vk vl . runReaderT md =<< ask++mimerTrace :: Int -> VerboseLevel -> SM Doc -> SM ()+mimerTrace ilvl vlvl doc = reportSMDoc "mimer.trace" vlvl $ nest (2 * ilvl) $ "-" <+> doc++topInstantiationDoc :: SM Doc+topInstantiationDoc = asks searchTopMeta >>= getMetaInstantiation >>= maybe (return "(nothing)") prettyTCM++prettyGoalInst :: Goal -> SM Doc+prettyGoalInst goal = inGoalEnv goal $ do+ args <- map Apply <$> getContextArgs+ prettyTCM =<< instantiate (MetaV (goalMeta goal) args)++branchInstantiationDocCost :: SearchBranch -> SM Doc+branchInstantiationDocCost branch = branchInstantiationDoc branch <+> parens ("cost:" <+> pretty (sbCost branch))++-- | For debug+branchInstantiationDoc :: SearchBranch -> SM Doc+branchInstantiationDoc branch = withBranchState branch topInstantiationDoc++prettyBranch :: SearchBranch -> SM String+prettyBranch branch = withBranchState branch $ do+ metaId <- asks searchTopMeta+ P.render <$> "Branch" <> braces (sep $ punctuate ","+ [ "cost:" <+> pretty (sbCost branch)+ , "metas:" <+> prettyTCM (map goalMeta (sbGoals branch))+ , sep [ "instantiation:"+ , nest 2 $ pretty metaId <+> "=" <+> (prettyTCM =<< getMetaInstantiation metaId) ]+ , "used components:" <+> pretty (Map.toList $ sbComponentsUsed branch)+ ])++-- Hack to let you experiment with costs using verbosity flags.+customCosts :: TCM Costs+customCosts = do+ costLocal <- cost "local"+ costFn <- cost "fn"+ costDataCon <- cost "dataCon"+ costRecordCon <- cost "recordCon"+ costSpeculateProj <- cost "speculateProj"+ costProj <- cost "proj"+ costAxiom <- cost "axiom"+ costLet <- cost "let"+ costLevel <- cost "level"+ costSet <- cost "set"+ costRecCall <- cost "recCall"+ costNewMeta <- cost "newMeta"+ costNewHiddenMeta <- cost "newHiddenMeta"+ compReuse <- cost "compReuse"+ let costCompReuse uses = compReuse * uses ^ 2+ pure Costs{..}+ where+ cost key = getVerbosityLevel ("mimer-cost." ++ key)++------------------------------------------------------------------------+-- * Stats+------------------------------------------------------------------------++updateStat :: (MimerStats -> MimerStats) -> SM ()+updateStat f = verboseS "mimer.stats" 10 $ do+ ref <- asks searchStats+ liftIO $ modifyIORef' ref f++bench :: [Bench.Phase] -> SM a -> SM a+bench k ma = billTo (mimerAccount : k) ma+ where+ -- Dummy account to avoid updating Bench. Doesn't matter since this is only used interactively+ -- to debug Mimer performance.+ mimerAccount = Bench.Sort++writeTime :: (ReadTCState m, MonadError TCErr m, MonadTCM m, MonadDebug m)+ => InteractionId+ -> CPUTime+ -> m ()+writeTime ii (CPUTime time) = do+ file <- rangeFile . ipRange <$> lookupInteractionPoint ii+ case file of+ SMaybe.Nothing ->+ reportSLn "mimer.stats" 2 "No file found for interaction id"+ SMaybe.Just file -> do+ let path = filePath (rangeFilePath file) ++ ".stats"+ liftIO $ appendFile path (show (interactionId ii) ++ " " ++ show time ++ "\n")
@@ -0,0 +1,88 @@+module Agda.Mimer.Options where++import Data.Char+import Data.Maybe+import Text.Read++import Agda.Interaction.BasicOps (parseExprIn)+import Agda.Syntax.Common (Nat)+import Agda.Syntax.Common.Pretty (Pretty, pretty, text)+import Agda.Syntax.Abstract.Name (QName)+import Agda.TypeChecking.Monad.Base (TCM)+import Agda.Syntax.Common (InteractionId)+import Agda.Syntax.Position (Range)+import qualified Agda.Syntax.Abstract as A+import qualified Agda.Syntax.Abstract.Name as AN+import Agda.Utils.Maybe (catMaybes)++type MilliSeconds = Integer++data HintMode = Unqualified | AllModules | Module | NoHints+ deriving (Eq, Show)++data Options = Options+ { optTimeout :: MilliSeconds+ , optHintMode :: HintMode+ , optSkip :: Int -- ^ Skip the first this many solutions+ , optList :: Bool -- ^ List solutions instead of filling the hole+ , optExplicitHints :: [QName]+ } deriving Show++parseOptions :: InteractionId -> Range -> String -> TCM Options+parseOptions ii range argStr = do+ let tokens = readTokens $ words argStr+ -- TODO: Use 'parseName' instead?+ hintExprs <- sequence [parseExprIn ii range h | H h <- tokens]+ let hints = catMaybes $ map hintExprToQName hintExprs+ return Options+ { optTimeout = firstOr 1000 [fromIntegral $ parseTime t | T t <- tokens]+ -- TODO: Do arg properly+ , optHintMode = firstOr NoHints ([Module | M <- tokens] ++ [Unqualified | U <- tokens])+ , optExplicitHints = hints+ , optList = L `elem` tokens+ , optSkip = firstOr 0 [ n | S s <- tokens, n <- maybeToList $ readMaybe s ]+ }++parseTime :: String -> Int+parseTime [] = 0+parseTime xs = read ds * modifier + parseTime r where+ (ds , modr) = span isDigit xs+ (mod , r) = break isDigit modr++ modifier = case mod of+ "ms" -> 1+ "cs" -> 10+ "ds" -> 100+ "s" -> 1000+ _ -> 1000++hintExprToQName :: A.Expr -> Maybe QName+hintExprToQName (A.ScopedExpr _ e) = hintExprToQName e+hintExprToQName (A.Def qname) = Just $ qname+hintExprToQName (A.Proj _ qname) = Just $ AN.headAmbQ qname+hintExprToQName (A.Con qname) = Just $ AN.headAmbQ qname+hintExprToQName _ = Nothing++firstOr :: a -> [a] -> a+firstOr x [] = x+firstOr _ (x:_) = x+++data Token = T String | M | U | C | L | S String | H String+ deriving (Eq, Show)++readTokens :: [String] -> [Token]+readTokens [] = []+readTokens ("-t" : t : ws) = T t : readTokens ws+readTokens ("-s" : n : ws) = S n : readTokens ws+readTokens ("-l" : ws) = L : readTokens ws+readTokens ("-m" : ws) = M : readTokens ws+readTokens ("-c" : ws) = C : readTokens ws+readTokens ("-u" : ws) = U : readTokens ws+readTokens (h : ws) = H h : readTokens ws++instance Pretty HintMode where+ pretty = text . show++-- instance Pretty Options where+-- prettyht
@@ -0,0 +1,412 @@++module Agda.Mimer.Types where++import Control.DeepSeq (NFData)+import Data.Function (on)+import Data.Map (Map)+import Data.List qualified as List+import GHC.Generics (Generic)+import Data.IORef (IORef)++import Agda.Syntax.Abstract (Expr)+import Agda.Syntax.Common.Pretty qualified as P+import Agda.Syntax.Common.Pretty (Pretty)+import Agda.Syntax.Common (InteractionId, Nat)+import Agda.Syntax.Internal+import Agda.TypeChecking.Monad (TCState, CheckpointId, Open, TCEnv, openThing)+import Agda.TypeChecking.Pretty+import Agda.Interaction.Base (Rewrite(..))+import Agda.Utils.Tuple (second)+import Agda.Utils.Impossible++import Agda.Mimer.Options++------------------------------------------------------------------------+-- * Results+------------------------------------------------------------------------++data MimerResult+ = MimerExpr String -- ^ Returns 'String' rather than 'Expr' because the give action expects a string.+ | MimerList [(Int, String)]+ | MimerNoResult+ deriving (Generic)++instance NFData MimerResult++isNoResult :: MimerResult -> Bool+isNoResult MimerNoResult = True+isNoResult _ = False++data SearchStepResult+ = ResultExpr Expr+ | OpenBranch SearchBranch+ | NoSolution+ deriving (Generic)++instance NFData SearchStepResult++------------------------------------------------------------------------+-- * Search branches+------------------------------------------------------------------------++data SearchBranch = SearchBranch+ { sbTCState :: TCState+ , sbGoals :: [Goal]+ , sbCost :: Int+ , sbCache :: Map CheckpointId ComponentCache+ , sbComponentsUsed :: Map Name Int -- ^ Number of times each component has been used+ }+ deriving (Generic)+instance NFData SearchBranch++-- | NOTE: Equality is only on the fields `sbCost` and `sbGoals`+instance Eq SearchBranch where+ sb1 == sb2 = sbCost sb1 == sbCost sb2 && sbGoals sb1 == sbGoals sb2++-- TODO: Explain+instance Ord SearchBranch where+ compare = compare `on` sbCost++data Goal = Goal+ { goalMeta :: MetaId+ }+ deriving (Generic)+instance NFData Goal++-- TODO: Is this a reasonable Eq instance?+instance Eq Goal where+ g1 == g2 = goalMeta g1 == goalMeta g2++-- | Take the first goal off a search branch.+-- Precondition: the set of goals is non-empty.+nextGoal :: SearchBranch -> (Goal, SearchBranch)+nextGoal branch =+ case sbGoals branch of+ [] -> __IMPOSSIBLE__+ goal : goals -> (goal, branch{ sbGoals = goals })++------------------------------------------------------------------------+-- * Components+------------------------------------------------------------------------++-- Map source component to generated components+type ComponentCache = Map Component (Maybe [Component])++-- | Components that are not changed during search. Components that do change+-- (local variables and let bindings) are stored in each 'SearchBranch'.+data BaseComponents = BaseComponents+ { hintFns :: [Component]+ , hintDataTypes :: [Component]+ , hintRecordTypes :: [Component]+ , hintAxioms :: [Component]+ -- ^ Excluding those producing Level+ , hintLevel :: [Component]+ -- ^ A definition in a where clause+ , hintProjections :: [Component]+ -- ^ Variables that are candidates for arguments to recursive calls+ , hintThisFn :: Maybe Component+ , hintMutualFns :: [Component]+ -- ^ Functions mutually defined with the one we are defining (#8783).+ , hintLetVars :: [Open Component]+ , hintRecVars :: Open [(Term, NoSubst Term Int)] -- ^ Variable terms and which argument they come from+ }+ deriving (Generic)++instance NFData BaseComponents++type CompId = Int+data Component = Component+ { compId :: CompId -- ^ Unique id for the component. Used for the cache.+ , compName :: Maybe Name -- ^ Used for keeping track of how many times a component has been used+ , compPars :: Nat -- ^ How many arguments should be dropped (e.g. constructor parameters)+ , compTerm :: Term+ , compType :: Type+ , compRec :: RecCall -- ^ Is this a (mutually) recursive call?+ , compMetas :: [MetaId]+ , compCost :: Cost+ }+ deriving (Eq, Generic)++instance NFData Component++-- | Is a component a call to the function we are defining+-- or a function mutually defined with it?+-- Such calls are only generated with structurally smaller arguments.+data RecCall+ = NotRecCall+ -- ^ Not a recursive call.+ | SelfCall+ -- ^ Recursive call to the function we are defining.+ -- An argument needs to be structurally smaller than the parameter+ -- in the same position.+ | MutualCall+ -- ^ Call to a function mutually defined with the one we are defining (#8783).+ -- As arguments of different functions need not correspond by position,+ -- we accept any structurally smaller variable in any position.+ deriving (Eq, Show, Generic)++instance NFData RecCall++-- TODO: Is this reasonable?+instance Ord Component where+ compare = compare `on` compId++mkComponent :: CompId -> [MetaId] -> Cost -> Maybe Name -> Nat -> Term -> Type -> Component+mkComponent cId metaIds cost mName pars term typ = Component+ { compId = cId+ , compName = mName+ , compPars = pars+ , compTerm = term+ , compType = typ+ , compRec = NotRecCall+ , compMetas = metaIds+ , compCost = cost }++mkComponentQ :: CompId -> Cost -> QName -> Nat -> Term -> Type -> Component+mkComponentQ cId cost qname = mkComponent cId [] cost (Just $ qnameName qname)++noName :: Maybe Name+noName = Nothing++addCost :: Cost -> Component -> Component+addCost cost comp = comp { compCost = cost + compCost comp }++deleteCompMeta :: MetaId -> Component -> Component+deleteCompMeta old c = c{ compMetas = List.delete old (compMetas c) }++------------------------------------------------------------------------+-- * SearchOptions+------------------------------------------------------------------------++data SearchOptions = SearchOptions+ { searchBaseComponents :: BaseComponents+ , searchHintMode :: HintMode+ , searchTimeout :: MilliSeconds+ , searchGenProjectionsLocal :: Bool+ , searchGenProjectionsLet :: Bool+ , searchGenProjectionsExternal :: Bool+ , searchGenProjectionsRec :: Bool+ , searchSpeculateProjections :: Bool+ , searchTopMeta :: MetaId+ , searchTopEnv :: TCEnv+ , searchTopCheckpoint :: CheckpointId+ , searchProblem :: ProblemId+ -- ^ Constraints postponed during search are tagged with this problem.+ -- A branch is only a solution once all of them are solved.+ , searchInteractionId :: InteractionId+ , searchFnName :: Maybe QName+ , searchCosts :: Costs+ , searchStats :: IORef MimerStats+ , searchRewrite :: Rewrite+ , searchBuiltinFlat :: Maybe QName+ -- Cache BUILTIN_FLAT for issue #7662 workaround+ }++type Cost = Int+data Costs = Costs+ { costLocal :: Cost+ , costFn :: Cost+ , costDataCon :: Cost+ , costRecordCon :: Cost+ , costSpeculateProj :: Cost+ , costProj :: Cost+ , costAxiom :: Cost+ , costLet :: Cost+ , costLevel :: Cost+ , costSet :: Cost -- Should probably be replaced with multiple different costs+ , costRecCall :: Cost+ , costNewMeta :: Cost -- ^ Cost of a new meta-variable appearing in a non-implicit position+ , costNewHiddenMeta :: Cost -- ^ Cost of a new meta-variable appearing in an implicit position+ , costCompReuse :: Nat -> Cost -- ^ Cost of reusing a component @n@ times. Only counted when @n>1@.+ }++noCost :: Cost+noCost = 0++defaultCosts :: Costs+defaultCosts = Costs+ { costLocal = 3+ , costFn = 10+ , costDataCon = 3+ , costRecordCon = 3+ , costSpeculateProj = 20+ , costProj = 3+ , costAxiom = 10+ , costLet = 5+ , costLevel = 3+ , costSet = 10+ , costRecCall = 8+ , costNewMeta = 10+ , costNewHiddenMeta = 1+ , costCompReuse = \uses -> 10 * (uses - 1) ^ 2+ }++------------------------------------------------------------------------+-- * Measure performance+------------------------------------------------------------------------++data MimerStats = MimerStats+ { statCompHit :: !Int -- ^ Could make use of an already generated component+ , statCompGen :: !Int -- ^ Could use a generator for a component+ , statCompRegen :: !Int -- ^ Had to regenerate the cache (new context)+ , statCompNoRegen :: !Int -- ^ Did not have to regenerate the cache+ , statMetasCreated :: !Int -- ^ Total number of meta-variables created explicitly (not through unification)+ , statTypeEqChecks :: !Int -- ^ Number of times type equality is tested (with unification)+ , statRefineSuccess :: !Int -- ^ Number of times a refinement has been successful+ , statRefineFail :: !Int -- ^ Number of times a refinement has failed+ } deriving (Show, Eq, Generic)+instance NFData MimerStats++emptyMimerStats :: MimerStats+emptyMimerStats = MimerStats+ { statCompHit = 0, statCompGen = 0, statCompRegen = 0 , statCompNoRegen = 0 , statMetasCreated = 0, statTypeEqChecks = 0, statRefineSuccess = 0 , statRefineFail = 0}++incCompHit, incCompGen, incCompRegen, incCompNoRegen, incMetasCreated, incTypeEqChecks, incRefineSuccess, incRefineFail :: MimerStats -> MimerStats+incCompHit stats = stats {statCompHit = succ $ statCompHit stats}+incCompGen stats = stats {statCompGen = succ $ statCompGen stats}+incCompRegen stats = stats {statCompRegen = succ $ statCompRegen stats}+incCompNoRegen stats = stats {statCompNoRegen = succ $ statCompNoRegen stats}+incMetasCreated stats = stats {statMetasCreated = succ $ statMetasCreated stats}+incTypeEqChecks stats = stats {statTypeEqChecks = succ $ statTypeEqChecks stats}+incRefineSuccess stats = stats {statRefineSuccess = succ $ statRefineSuccess stats}+incRefineFail stats = stats {statRefineFail = succ $ statRefineFail stats}++------------------------------------------------------------------------+-- * Pretty printing+------------------------------------------------------------------------++haskellRecord :: Doc -> [(Doc, Doc)] -> Doc+haskellRecord name fields = P.sep [ name, P.nest 2 $ P.braces (P.sep $ P.punctuate "," [ P.hang (k P.<+> "=") 2 v | (k, v) <- fields ]) ]++keyValueList :: [(Doc, Doc)] -> Doc+keyValueList kvs = P.braces $ P.sep $ P.punctuate "," [ P.hang (k <> ":") 2 v | (k, v) <- kvs ]++instance Pretty Goal where+ pretty goal = P.pretty $ goalMeta goal++instance Pretty SearchBranch where+ pretty branch = keyValueList+ [ ("sbTCState", "[...]")+ , ("sbGoals", P.pretty $ sbGoals branch)+ , ("sbCost", P.pretty $ sbCost branch)+ , ("sbComponentsUsed", P.pretty $ sbComponentsUsed branch)+ ]++instance PrettyTCM BaseComponents where+ prettyTCM comps = do+ let thisFn = case hintThisFn comps of+ Nothing -> "(nothing)"+ Just comp -> prettyComp comp+ vcat [ "Base components:"+ , nest 2 $ vcat+ [ f "hintFns" (hintFns comps)+ , f "hintDataTypes" (hintDataTypes comps)+ , f "hintRecordTypes" (hintRecordTypes comps)+ , f "hintAxioms" (hintAxioms comps)+ , f "hintLevel" (hintLevel comps)+ , f "hintProjections" (hintProjections comps)+ , "hintThisFn:" <+> thisFn+ , f "hintMutualFns" (hintMutualFns comps)+ , g prettyOpenComp "hintLetVars" (hintLetVars comps)+ , "hintRecVars: Open" <+> pretty (second unNoSubst <$> openThing (hintRecVars comps))+ ]+ ]+ where+ prettyComp comp = pretty (compTerm comp) <+> ":" <+> pretty (compType comp)+ prettyOpenComp openComp = "Open" <+> parens (prettyComp $ openThing openComp)+ prettyTCMComp comp = prettyTCM (compTerm comp) <+> ":" <+> prettyTCM (compType comp)+ f = g prettyTCMComp+ g p n [] = n <> ": []"+ g p n xs = (n <> ":") $+$ nest 2 (vcat $ map p xs)++instance Pretty BaseComponents where+ pretty comps = P.vcat+ [ f "hintFns" (hintFns comps)+ , f "hintDataTypes" (hintDataTypes comps)+ , f "hintRecordTypes" (hintRecordTypes comps)+ , f "hintAxioms" (hintAxioms comps)+ , f "hintLevel" (hintLevel comps)+ , f "hintProjections" (hintProjections comps)+ ]+ where+ f n [] = n <> ": []"+ f n xs = (n <> ":") P.$$ P.nest 2 (P.pretty xs)++instance Pretty SearchOptions where+ pretty opts = P.vcat+ [ "searchBaseComponents:"+ , P.nest 2 $ P.pretty $ searchBaseComponents opts+ , keyValueList+ [ ("searchHintMode", P.pretty $ searchHintMode opts)+ , ("searchTimeout", P.pretty $ searchTimeout opts)+ , ("searchTopMeta", P.pretty $ searchTopMeta opts)+ , ("searchTopEnv", "[...]")+ ]+ , "searchCosts:"+ , P.nest 2 (P.pretty $ searchCosts opts)+ ]++instance PrettyTCM SearchOptions where+ prettyTCM opts = vcat+ [ "searchBaseComponents:"+ , nest 2 $ prettyTCM $ searchBaseComponents opts+ , vcat+ [ "searchHintMode:" <+> pretty (searchHintMode opts)+ , "searchTimeout:" <+> pretty (searchTimeout opts)+ , "searchTopMeta:" <+> prettyTCM (searchTopMeta opts)+ , "searchTopEnv: [...]"+ , "searchTopCheckpoint:" <+> prettyTCM (searchTopCheckpoint opts)+ , "searchInteractionId:" <+> pretty (searchInteractionId opts)+ , "searchFnName:" <+> pretty (searchFnName opts)+ , "searchStats: [...]"+ ]+ , "searchCosts:"+ , nest 2 $ pretty $ searchCosts opts+ ]++instance Pretty Component where+ pretty comp = haskellRecord "Component"+ [ ("compId", P.pretty $ compId comp)+ , ("compTerm", P.pretty $ compTerm comp)+ , ("compType", P.pretty $ compType comp)+ , ("compMetas", P.pretty $ compMetas comp)+ , ("compCost", P.pretty $ compCost comp)+ ]++instance Pretty Costs where+ pretty costs = P.align 20 entries+ where+ entries =+ [ ("costLocal:" , P.pretty $ costLocal costs)+ , ("costFn:" , P.pretty $ costFn costs)+ , ("costDataCon:" , P.pretty $ costDataCon costs)+ , ("costRecordCon:" , P.pretty $ costRecordCon costs)+ , ("costSpeculateProj:" , P.pretty $ costSpeculateProj costs)+ , ("costProj:" , P.pretty $ costProj costs)+ , ("costAxiom:" , P.pretty $ costAxiom costs)+ , ("costLet:" , P.pretty $ costLet costs)+ , ("costLevel:" , P.pretty $ costLevel costs)+ , ("costSet:" , P.pretty $ costSet costs)+ , ("costRecCall:" , P.pretty $ costRecCall costs)+ , ("costNewMeta:" , P.pretty $ costNewMeta costs)+ , ("costNewHiddenMeta:" , P.pretty $ costNewHiddenMeta costs)+ , ("costCompReuse:" , "{function}")+ ]++instance PrettyTCM Component where+ prettyTCM Component{ compId, compTerm, compType, compCost, compMetas } =+ parens (prettyTCM compId) <+> sep+ [ sep [ prettyTCM compTerm+ , ":" <+> prettyTCM compType ]+ , parens $ fsep $ punctuate ","+ [ "cost:" <+> prettyTCM compCost+ , "metas:" <+> prettyTCM compMetas+ ]+ ]++instance PrettyTCM MimerResult where+ prettyTCM = \case+ MimerExpr expr -> pretty expr+ MimerNoResult -> "MimerNoResult"+ MimerList sols -> "MimerList" <+> pretty sols+
@@ -1,23 +0,0 @@-module Agda.Packaging.Config where--- FIXME: proper exports--{---- External Library Imports-import qualified Distribution.InstalledPackageInfo- as Cabal- ( InstalledPackageInfo )---- Local Library Imports-import Agda.Packaging.Types-------------------------------------------------------------------------------------- Parametric in `opt' only so that the environment can be decoupled--- from the concrete CLI tool-data AgdaPkgConfig opt- = AgdaPkgConfig- { configOpts :: [opt]- , configOrigBroken :: [Cabal.InstalledPackageInfo]- , configPkgDBStack :: [NamedPackageDB]- , configProgName :: String }--}
@@ -1,234 +0,0 @@-module Agda.Packaging.Database where--- FIXME: proper exports-{---- Standard Library Imports-import Control.Applicative-import qualified Control.Exception-import Control.Monad.Cont-import Control.Monad.Error-import Data.List- ( foldl'- , intersperse- , isSuffixOf- , partition )-import Data.Maybe- ( fromJust )-import System.Directory- ( createDirectoryIfMissing- , getAppUserDataDirectory- , getDirectoryContents- , removeFile )-import System.FilePath-import System.IO- ( IOMode (ReadMode)- , hGetContents- , hSetEncoding- , openFile- , utf8 )-import System.IO.Error- ( isPermissionError- , try )---- External Library Imports-import qualified Distribution.InstalledPackageInfo- as Cabal- ( InstalledPackageInfo- , exposed- , exposedModules- , depends- , hiddenModules- , installedPackageId- , parseInstalledPackageInfo- , showInstalledPackageInfo )-import qualified Distribution.Package- as Cabal- ( PackageIdentifier- , packageId )-import qualified Distribution.ParseUtils- as Cabal- ( ParseResult (..)- , locatedErrorMsg )-import qualified Distribution.Simple.Utils- as Cabal- ( die- , writeUTF8File )-import qualified Distribution.Text- as Cabal- ( display- , simpleParse )---- Local Imports-import Agda.Packaging.Config-import Agda.Packaging.Monad-import Agda.Packaging.Types-import Paths_Agda- ( getDataDir )---------------------------------------------------------------------------------------------------------------- Getting the DB paths -------------------------------getPkgDBPathGlobal :: IO FilePath-getPkgDBPathGlobal = do- result <- try action- case result of- Left ioErr -> Cabal.die $ show ioErr- Right filePath -> return filePath- where- action = pure (</>)- <*> getDataDir- <*> pure "package.conf.d"--getPkgDBPathUser :: IO FilePath-getPkgDBPathUser = do- result <- try action- case result of- Left ioErr -> Cabal.die $ show ioErr- Right filePath -> return filePath- where- action = pure (</>)- <*> getAppUserDataDirectory "Agda"- <*> pure "package.conf.d"---------------------------------------- Loading the DBs into memory --------------------------------------getPkgDBs :: [FilePath] -> IO PackageDBStack-getPkgDBs givenPkgDBNames = do- pkgDBNames <-- -- If no package databases are specified, default to getting the- -- global and user packages.- if null givenPkgDBNames- then- pure (\ db1 db2 -> db1 : db2 : [])- <*> getPkgDBPathGlobal- <*> getPkgDBPathUser- else- return givenPkgDBNames- mapM readParsePkgDB pkgDBNames--readParsePkgDB :: PackageDBName -> IO NamedPackageDB-readParsePkgDB dbName = do- result <- try $ getDirectoryContents dbName- case result of- Left ioErr -> Cabal.die $ show ioErr- Right filePaths -> do- pkgInfos <- mapM parseSingletonPkgConf $ map (dbName </>) dbEntries- return $ NamedPackageDB- { dbName = dbName- , db = pkgInfos }- where- dbEntries = filter (".conf" `isSuffixOf`) filePaths--parseSingletonPkgConf :: FilePath -> IO Cabal.InstalledPackageInfo-parseSingletonPkgConf = (parsePkgInfo =<<) . readUTF8File- where- readUTF8File :: FilePath -> IO String- readUTF8File file = do- handle <- openFile file ReadMode- hSetEncoding handle utf8- hGetContents handle--parsePkgInfo :: String -> IO Cabal.InstalledPackageInfo-parsePkgInfo pkgInfoStr =- case Cabal.parseInstalledPackageInfo pkgInfoStr of- Cabal.ParseOk warnings pkgInfo ->- return pkgInfo- Cabal.ParseFailed err ->- case Cabal.locatedErrorMsg err of- (Nothing , msg) -> Cabal.die msg- (Just lineNo, msg) -> Cabal.die (show lineNo ++ ": " ++ msg)------------------------- DB operations ------------------------data DBOp- = PkgAdd Cabal.InstalledPackageInfo- | PkgModify Cabal.InstalledPackageInfo- | PkgRemove Cabal.InstalledPackageInfo---------------------------------------- Processing the DBs in memory ---------------------------------------brokenPkgs :: PackageDB -> PackageDB-brokenPkgs = snd . transClos []- where- -- Calculate the transitive closure of 'ok' packages, i.e.,- -- packages with all of their dependencies available.- transClos :: PackageDB -> PackageDB -> (PackageDB, PackageDB)- transClos okPkgs pkgs =- case partition (ok okPkgs) pkgs of- ([] , pkgs') -> (okPkgs, pkgs')- (okPkgs', pkgs') -> transClos (okPkgs' ++ okPkgs) pkgs'- where- -- A package is 'ok' with respect to a package database if the- -- packages dependencies are available in the database.- ok :: PackageDB -> Cabal.InstalledPackageInfo -> Bool- ok okPkgs pkg = null dangling- where- dangling = filter (`notElem` pkgIds) (Cabal.depends pkg)- pkgIds = map Cabal.installedPackageId okPkgs--flattenPkgDBs :: PackageDBStack -> PackageDB-flattenPkgDBs = concatMap db--modifyDBWithOps :: PackageDB -> [DBOp] -> PackageDB-modifyDBWithOps pkgDB dbOps = foldl' applyOp pkgDB dbOps- where- applyOp :: PackageDB -> DBOp -> PackageDB- applyOp pkgInfos (PkgAdd pkgInfo) = pkgInfo : pkgInfos- applyOp pkgInfos (PkgModify pkgInfo) = applyOp pkgDB' $ PkgAdd pkgInfo- where- pkgDB' = applyOp pkgInfos $ PkgRemove pkgInfo- applyOp pkgInfos (PkgRemove pkgInfo) = filter fpred pkgInfos- where- fpred = (Cabal.installedPackageId pkgInfo /=)- . Cabal.installedPackageId------------------------------------- Modifying the DBs on disk ------------------------------------modifyAndWriteDBWithOps :: NamedPackageDB -> [DBOp] -> IO ()-modifyAndWriteDBWithOps npkgDB dbOps = do- createDirectoryIfMissing True $ dbName npkgDB- writeDBWithOps npkgDB{ db = db' } dbOps- where- db' = db npkgDB `modifyDBWithOps` dbOps--writeDBWithOps :: NamedPackageDB -> [DBOp] -> IO ()-writeDBWithOps npkgDB = mapM_ doOp- where- fileNameOf pkgInfo = dbName npkgDB- </> Cabal.display (Cabal.installedPackageId pkgInfo)- <.> "conf"-- doOp (PkgAdd pkgInfo) = Cabal.writeUTF8File (fileNameOf pkgInfo)- $ Cabal.showInstalledPackageInfo pkgInfo- doOp (PkgModify pkgInfo) = doOp $ PkgAdd pkgInfo- doOp (PkgRemove pkgInfo) = removeFile (fileNameOf pkgInfo)--modifyPkgInfoAndWriteDBWithFun :: Cabal.PackageIdentifier- -> (Cabal.InstalledPackageInfo -> DBOp)- -> AgdaPkg opt ()-modifyPkgInfoAndWriteDBWithFun pkgId funToOp = asksM (rec . configPkgDBStack)- where- rec :: PackageDBStack -> AgdaPkg opt ()- rec = liftIO . mapM_ (\ npkgDB -> modifyAndWriteDBWithOps npkgDB (generateOps $ db npkgDB))- where- generateOps :: PackageDB -> [DBOp]- generateOps [] = []- generateOps (pkgInfo:pkgInfos)- | Cabal.packageId pkgInfo == pkgId = funToOp pkgInfo : generateOps pkgInfos- | otherwise = generateOps pkgInfos--}
@@ -1,38 +0,0 @@-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Agda.Packaging.Monad where--{-- ( module Control.Monad.Reader- , AgdaPkg (..)- , asksM ) where---- Standard Library Imports-import Control.Applicative-import Control.Monad.Error-import Control.Monad.Reader---- Local Imports-import Agda.Packaging.Config-------------------------------------------------------------------------------------- Parametric in `opt' only so that the environment can be decoupled--- from the concrete CLI tool-newtype AgdaPkg opt a- = AgdaPkg- { runAgdaPkg :: ReaderT (AgdaPkgConfig opt) IO a }- deriving- ( Functor- , Monad- , MonadError IOError- , MonadReader (AgdaPkgConfig opt)- , MonadIO )--instance Applicative (AgdaPkg opt) where- pure = return- (<*>) = ap--asksM :: (MonadReader r m) => (r -> m a) -> m a-asksM = join . asks--}
@@ -1,20 +0,0 @@-module Agda.Packaging.Types where--{---- External Library Imports-import qualified Distribution.InstalledPackageInfo- as Cabal- ( InstalledPackageInfo )-----------------------------------------------------------------------------------type PackageDBName = FilePath-type PackageDB = [Cabal.InstalledPackageInfo]--data NamedPackageDB- = NamedPackageDB- { dbName :: PackageDBName- , db :: PackageDB }--type PackageDBStack = [NamedPackageDB]--}
@@ -1,476 +1,1270 @@-{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable, CPP #-}-{-| The abstract syntax. This is what you get after desugaring and scope- analysis of the concrete syntax. The type checker works on abstract syntax,- producing internal syntax ("Agda.Syntax.Internal").--}-module Agda.Syntax.Abstract- ( module Agda.Syntax.Abstract- , module Agda.Syntax.Abstract.Name- ) where--import Prelude hiding (foldr)-import Control.Applicative-import Data.Sequence (Seq, (<|), (><))-import qualified Data.Sequence as Seq-import Data.Foldable as Fold-import Data.Traversable-import Data.Map (Map)-import Data.Generics (Typeable, Data)--import qualified Agda.Syntax.Concrete as C-import Agda.Syntax.Concrete.Pretty ()-import Agda.Syntax.Info-import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Position-import Agda.Syntax.Abstract.Name-import Agda.Syntax.Literal-import Agda.Syntax.Scope.Base--import Agda.Utils.Tuple--#include "../undefined.h"-import Agda.Utils.Impossible--data Expr- = Var Name -- ^ Bound variables- | Def QName -- ^ Constants (i.e. axioms, functions, and datatypes)- | Con AmbiguousQName -- ^ Constructors- | Lit Literal -- ^ Literals- | QuestionMark MetaInfo -- ^ meta variable for interaction- | Underscore MetaInfo -- ^ meta variable for hidden argument (must be inferred locally)- | App ExprInfo Expr (NamedArg Expr) -- ^- | WithApp ExprInfo Expr [Expr] -- ^ with application- | Lam ExprInfo LamBinding Expr -- ^- | AbsurdLam ExprInfo Hiding- | ExtendedLam ExprInfo DefInfo QName [Clause]- | Pi ExprInfo Telescope Expr -- ^- | Fun ExprInfo (Arg Expr) Expr -- ^ independent function space- | Set ExprInfo Nat -- ^ Set, Set1, Set2, ...- | Prop ExprInfo -- ^- | Let ExprInfo [LetBinding] Expr -- ^- | ETel Telescope -- ^ only used when printing telescopes- | Rec ExprInfo [(C.Name, Expr)] -- ^ record construction- | RecUpdate ExprInfo Expr [(C.Name, Expr)] -- ^ record update- | ScopedExpr ScopeInfo Expr -- ^ scope annotation- | QuoteGoal ExprInfo Name Expr -- ^- | Quote ExprInfo -- ^- | QuoteTerm ExprInfo -- ^- | Unquote ExprInfo -- ^ The splicing construct: unquote ...- | DontCare Expr -- ^ for printing DontCare from Syntax.Internal- deriving (Typeable, Data, Show)--data Declaration- = Axiom DefInfo Relevance QName Expr -- ^ postulate- | Field DefInfo QName (Arg Expr) -- ^ record field- | Primitive DefInfo QName Expr -- ^ primitive function- | Mutual DeclInfo [Declaration] -- ^ a bunch of mutually recursive definitions- | Section ModuleInfo ModuleName [TypedBindings] [Declaration]- | Apply ModuleInfo ModuleName ModuleApplication (Map QName QName) (Map ModuleName ModuleName)- | Import ModuleInfo ModuleName- | Pragma Range Pragma- | Open ModuleInfo ModuleName- -- ^ only retained for highlighting purposes- | FunDef DefInfo QName [Clause]- | DataSig DefInfo QName Telescope Expr -- ^ lone data signature- -- ^ the 'LamBinding's are 'DomainFree' and binds the parameters of the datatype.- | DataDef DefInfo QName [LamBinding] [Constructor]- -- ^ the 'LamBinding's are 'DomainFree' and binds the parameters of the datatype.- | RecSig DefInfo QName Telescope Expr -- ^ lone record signature- | RecDef DefInfo QName (Maybe QName) [LamBinding] Expr [Declaration]- -- ^ The 'Expr' gives the constructor type telescope, @(x1 : A1)..(xn : An) -> Prop@,- -- and the optional name is the constructor's name.- | ScopedDecl ScopeInfo [Declaration] -- ^ scope annotation- deriving (Typeable, Data, Show)--class GetDefInfo a where- getDefInfo :: a -> Maybe DefInfo--instance GetDefInfo Declaration where- getDefInfo (Axiom i _ _ _) = Just i- getDefInfo (Field i _ _) = Just i- getDefInfo (Primitive i _ _) = Just i- getDefInfo (ScopedDecl _ (d:_)) = getDefInfo d- getDefInfo (FunDef i _ _) = Just i- getDefInfo (DataSig i _ _ _) = Just i- getDefInfo (DataDef i _ _ _) = Just i- getDefInfo (RecSig i _ _ _) = Just i- getDefInfo (RecDef i _ _ _ _ _) = Just i- getDefInfo _ = Nothing--data ModuleApplication = SectionApp [TypedBindings] ModuleName [NamedArg Expr]- | RecordModuleIFS ModuleName- deriving (Typeable, Data, Show)--data Pragma = OptionsPragma [String]- | BuiltinPragma String Expr- | CompiledPragma QName String- | CompiledTypePragma QName String- | CompiledDataPragma QName String [String]- | CompiledEpicPragma QName String- | CompiledJSPragma QName String- | StaticPragma QName- | EtaPragma QName- deriving (Typeable, Data, Show)--data LetBinding = LetBind LetInfo Relevance Name Expr Expr -- ^ LetBind info rel name type defn- | LetApply ModuleInfo ModuleName ModuleApplication (Map QName QName) (Map ModuleName ModuleName)- | LetOpen ModuleInfo ModuleName -- ^ only for highlighting and abstractToConcrete- deriving (Typeable, Data, Show)---- | Only 'Axiom's.-type TypeSignature = Declaration-type Constructor = TypeSignature---- | A lambda binding is either domain free or typed.-data LamBinding- = DomainFree Hiding Relevance Name -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@- | DomainFull TypedBindings -- ^ . @(xs:e)@ or @{xs:e}@- deriving (Typeable, Data, Show)---- | Typed bindings with hiding information.-data TypedBindings = TypedBindings Range (Arg TypedBinding)- -- ^ . @(xs : e)@ or @{xs : e}@- deriving (Typeable, Data, Show)---- | A typed binding. Appears in dependent function spaces, typed lambdas, and--- telescopes. I might be tempting to simplify this to only bind a single--- name at a time. This would mean that we would have to typecheck the type--- several times (@x,y:A@ vs. @x:A; y:A@). In most cases this wouldn't--- really be a problem, but it's good principle to not do extra work unless--- you have to.-data TypedBinding = TBind Range [Name] Expr- | TNoBind Expr- deriving (Typeable, Data, Show)--type Telescope = [TypedBindings]---- | We could throw away @where@ clauses at this point and translate them to--- @let@. It's not obvious how to remember that the @let@ was really a--- @where@ clause though, so for the time being we keep it here.-data Clause = Clause LHS RHS [Declaration]- deriving (Typeable, Data, Show)-data RHS = RHS Expr- | AbsurdRHS- | WithRHS QName [Expr] [Clause] -- ^ The 'QName' is the name of the with function.- | RewriteRHS [QName] [Expr] RHS [Declaration]- -- ^ The 'QName's are the names of the generated with functions.- -- One for each 'Expr'.- -- The RHS shouldn't be another RewriteRHS- deriving (Typeable, Data, Show)--data LHS = LHS LHSInfo QName [NamedArg Pattern] [Pattern]- deriving (Typeable, Data, Show)---- | Parameterised over the type of dot patterns.-data Pattern' e = VarP Name- | ConP PatInfo AmbiguousQName [NamedArg (Pattern' e)]- | DefP PatInfo QName [NamedArg (Pattern' e)] -- ^ defined pattern- | WildP PatInfo- | AsP PatInfo Name (Pattern' e)- | DotP PatInfo e- | AbsurdP PatInfo- | LitP Literal- | ImplicitP PatInfo -- ^ generated at type checking for implicit arguments- deriving (Typeable, Data, Show, Functor, Foldable, Traversable)--type Pattern = Pattern' Expr--{--------------------------------------------------------------------------- Instances- --------------------------------------------------------------------------}--instance HasRange LamBinding where- getRange (DomainFree _ _ x) = getRange x- getRange (DomainFull b) = getRange b--instance HasRange TypedBindings where- getRange (TypedBindings r _) = r--instance HasRange TypedBinding where- getRange (TBind r _ _) = r- getRange (TNoBind e) = getRange e--instance HasRange Expr where- getRange (Var x) = getRange x- getRange (Def x) = getRange x- getRange (Con x) = getRange x- getRange (Lit l) = getRange l- getRange (QuestionMark i) = getRange i- getRange (Underscore i) = getRange i- getRange (App i _ _) = getRange i- getRange (WithApp i _ _) = getRange i- getRange (Lam i _ _) = getRange i- getRange (AbsurdLam i _) = getRange i- getRange (ExtendedLam i _ _ _) = getRange i- getRange (Pi i _ _) = getRange i- getRange (Fun i _ _) = getRange i- getRange (Set i _) = getRange i- getRange (Prop i) = getRange i- getRange (Let i _ _) = getRange i- getRange (Rec i _) = getRange i- getRange (RecUpdate i _ _) = getRange i- getRange (ETel tel) = getRange tel- getRange (ScopedExpr _ e) = getRange e- getRange (QuoteGoal _ _ e) = getRange e- getRange (Quote i) = getRange i- getRange (QuoteTerm i) = getRange i- getRange (Unquote i) = getRange i- getRange (DontCare{}) = noRange--instance HasRange Declaration where- getRange (Axiom i _ _ _ ) = getRange i- getRange (Field i _ _ ) = getRange i- getRange (Mutual i _ ) = getRange i- getRange (Section i _ _ _ ) = getRange i- getRange (Apply i _ _ _ _ ) = getRange i- getRange (Import i _ ) = getRange i- getRange (Primitive i _ _ ) = getRange i- getRange (Pragma i _ ) = getRange i- getRange (Open i _ ) = getRange i- getRange (ScopedDecl _ d ) = getRange d- getRange (FunDef i _ _ ) = getRange i- getRange (DataSig i _ _ _ ) = getRange i- getRange (DataDef i _ _ _ ) = getRange i- getRange (RecSig i _ _ _ ) = getRange i- getRange (RecDef i _ _ _ _ _ ) = getRange i--instance HasRange (Pattern' e) where- getRange (VarP x) = getRange x- getRange (ConP i _ _) = getRange i- getRange (DefP i _ _) = getRange i- getRange (WildP i) = getRange i- getRange (ImplicitP i) = getRange i- getRange (AsP i _ _) = getRange i- getRange (DotP i _) = getRange i- getRange (AbsurdP i) = getRange i- getRange (LitP l) = getRange l--instance HasRange LHS where- getRange (LHS i _ _ _) = getRange i--instance HasRange Clause where- getRange (Clause lhs rhs ds) = getRange (lhs,rhs,ds)--instance HasRange RHS where- getRange AbsurdRHS = noRange- getRange (RHS e) = getRange e- getRange (WithRHS _ e cs) = fuseRange e cs- getRange (RewriteRHS _ es rhs wh) = getRange (es, rhs, wh)--instance HasRange LetBinding where- getRange (LetBind i _ _ _ _ ) = getRange i- getRange (LetApply i _ _ _ _ ) = getRange i- getRange (LetOpen i _ ) = getRange i--instance KillRange LamBinding where- killRange (DomainFree h r x) = killRange1 (DomainFree h r) x- killRange (DomainFull b) = killRange1 DomainFull b--instance KillRange TypedBindings where- killRange (TypedBindings r b) = TypedBindings (killRange r) (killRange b)--instance KillRange TypedBinding where- killRange (TBind r xs e) = killRange3 TBind r xs e- killRange (TNoBind e) = killRange1 TNoBind e--instance KillRange Expr where- killRange (Var x) = killRange1 Var x- killRange (Def x) = killRange1 Def x- killRange (Con x) = killRange1 Con x- killRange (Lit l) = killRange1 Lit l- killRange (QuestionMark i) = killRange1 QuestionMark i- killRange (Underscore i) = killRange1 Underscore i- killRange (App i e1 e2) = killRange3 App i e1 e2- killRange (WithApp i e es) = killRange3 WithApp i e es- killRange (Lam i b e) = killRange3 Lam i b e- killRange (AbsurdLam i h) = killRange1 AbsurdLam i h- killRange (ExtendedLam i name di pes) = killRange4 ExtendedLam i name di pes --(\_ -> ExtendedLam i def {-name di si-}) i pes- killRange (Pi i a b) = killRange3 Pi i a b- killRange (Fun i a b) = killRange3 Fun i a b- killRange (Set i n) = Set (killRange i) n- killRange (Prop i) = killRange1 Prop i- killRange (Let i ds e) = killRange3 Let i ds e- killRange (Rec i fs) = Rec (killRange i) (map (id -*- killRange) fs)- killRange (RecUpdate i e fs) = RecUpdate (killRange i) (killRange e) (map (id -*- killRange) fs)- killRange (ETel tel) = killRange1 ETel tel- killRange (ScopedExpr s e) = killRange1 (ScopedExpr s) e- killRange (QuoteGoal i x e)= killRange3 QuoteGoal i x e- killRange (Quote i) = killRange1 Quote i- killRange (QuoteTerm i) = killRange1 QuoteTerm i- killRange (Unquote i) = killRange1 Unquote i- killRange (DontCare e) = DontCare e--instance KillRange Relevance where- killRange rel = rel -- no range to kill--instance KillRange Declaration where- killRange (Axiom i rel a b ) = killRange4 Axiom i rel a b- killRange (Field i a b ) = killRange3 Field i a b- killRange (Mutual i a ) = killRange2 Mutual i a- killRange (Section i a b c ) = killRange4 Section i a b c- killRange (Apply i a b c d ) = killRange3 Apply i a b c d- -- the last two arguments of Apply are name maps, so nothing to kill- killRange (Import i a ) = killRange2 Import i a- killRange (Primitive i a b ) = killRange3 Primitive i a b- killRange (Pragma i a ) = Pragma (killRange i) a- killRange (Open i x ) = killRange2 Open i x- killRange (ScopedDecl a d ) = killRange1 (ScopedDecl a) d- killRange (FunDef i a b ) = killRange3 FunDef i a b- killRange (DataSig i a b c ) = killRange3 DataSig i a b c- killRange (DataDef i a b c ) = killRange4 DataDef i a b c- killRange (RecSig i a b c ) = killRange4 RecSig i a b c- killRange (RecDef i a b c d e ) = killRange6 RecDef i a b c d e--instance KillRange ModuleApplication where- killRange (SectionApp a b c ) = killRange3 SectionApp a b c- killRange (RecordModuleIFS a ) = killRange1 RecordModuleIFS a--instance KillRange x => KillRange (ThingWithFixity x) where- killRange (ThingWithFixity c f) = ThingWithFixity (killRange c) f--instance KillRange e => KillRange (Pattern' e) where- killRange (VarP x) = killRange1 VarP x- killRange (ConP i a b) = killRange3 ConP i a b- killRange (DefP i a b) = killRange3 DefP i a b- killRange (WildP i) = killRange1 WildP i- killRange (ImplicitP i) = killRange1 ImplicitP i- killRange (AsP i a b) = killRange3 AsP i a b- killRange (DotP i a) = killRange2 DotP i a- killRange (AbsurdP i) = killRange1 AbsurdP i- killRange (LitP l) = killRange1 LitP l--instance KillRange LHS where- killRange (LHS i a b c) = killRange4 LHS i a b c--instance KillRange Clause where- killRange (Clause lhs rhs ds) = killRange3 Clause lhs rhs ds--instance KillRange RHS where- killRange AbsurdRHS = AbsurdRHS- killRange (RHS e) = killRange1 RHS e- killRange (WithRHS q e cs) = killRange3 WithRHS q e cs- killRange (RewriteRHS x es rhs wh) = killRange4 RewriteRHS x es rhs wh--instance KillRange LetBinding where- killRange (LetBind i rel a b c ) = killRange5 LetBind i rel a b c- killRange (LetApply i a b c d ) = killRange3 LetApply i a b c d- killRange (LetOpen i x ) = killRange2 LetOpen i x----------------------------------------------------------------------------- Queries----------------------------------------------------------------------------- | Extracts all the names which are declared in a 'Declaration'.--- This does not include open public or let expressions, but it does--- include local modules, where clauses and the names of extended--- lambdas.--allNames :: Declaration -> Seq QName-allNames (Axiom _ _ q _) = Seq.singleton q-allNames (Field _ q _) = Seq.singleton q-allNames (Primitive _ q _) = Seq.singleton q-allNames (Mutual _ defs) = Fold.foldMap allNames defs-allNames (DataSig _ q _ _) = Seq.singleton q-allNames (DataDef _ q _ decls) = q <| Fold.foldMap allNames decls-allNames (RecSig _ q _ _) = Seq.singleton q-allNames (RecDef _ q c _ _ decls) =- q <| foldMap Seq.singleton c >< Fold.foldMap allNames decls-allNames (FunDef _ q cls) = q <| Fold.foldMap allNamesC cls- where- allNamesC :: Clause -> Seq QName- allNamesC (Clause _ rhs decls) = allNamesR rhs ><- Fold.foldMap allNames decls-- allNamesR :: RHS -> Seq QName- allNamesR (RHS e) = allNamesE e- allNamesR AbsurdRHS {} = Seq.empty- allNamesR (WithRHS q _ cls) = q <| Fold.foldMap allNamesC cls- allNamesR (RewriteRHS qs _ rhs cls) =- Seq.fromList qs >< allNamesR rhs- >< Fold.foldMap allNames cls-- allNamesE :: Expr -> Seq QName- allNamesE Var {} = Seq.empty- allNamesE Def {} = Seq.empty- allNamesE Con {} = Seq.empty- allNamesE Lit {} = Seq.empty- allNamesE QuestionMark {} = Seq.empty- allNamesE Underscore {} = Seq.empty- allNamesE (App _ e1 e2) = Fold.foldMap allNamesE [e1, namedThing (unArg e2)]- allNamesE (WithApp _ e es) = Fold.foldMap allNamesE (e : es)- allNamesE (Lam _ b e) = allNamesLam b >< allNamesE e- allNamesE AbsurdLam {} = Seq.empty- allNamesE (ExtendedLam _ _ q cls) = q <| Fold.foldMap allNamesC cls- allNamesE (Pi _ tel e) = Fold.foldMap allNamesBinds tel ><- allNamesE e- allNamesE (Fun _ (Arg _ _ e1) e2) = Fold.foldMap allNamesE [e1, e2]- allNamesE Set {} = Seq.empty- allNamesE Prop {} = Seq.empty- allNamesE (Let _ lbs e) = Fold.foldMap allNamesLet lbs ><- allNamesE e- allNamesE ETel {} = __IMPOSSIBLE__- allNamesE (Rec _ fields) = Fold.foldMap allNamesE (map snd fields)- allNamesE (RecUpdate _ e fs) = allNamesE e >< Fold.foldMap allNamesE (map snd fs)- allNamesE (ScopedExpr _ e) = allNamesE e- allNamesE (QuoteGoal _ _ e) = allNamesE e- allNamesE Quote {} = Seq.empty- allNamesE QuoteTerm {} = Seq.empty- allNamesE Unquote {} = Seq.empty- allNamesE DontCare {} = Seq.empty-- allNamesLam :: LamBinding -> Seq QName- allNamesLam DomainFree {} = Seq.empty- allNamesLam (DomainFull binds) = allNamesBinds binds-- allNamesBinds :: TypedBindings -> Seq QName- allNamesBinds (TypedBindings _ (Arg _ _ (TBind _ _ e))) = allNamesE e- allNamesBinds (TypedBindings _ (Arg _ _ (TNoBind e))) = allNamesE e-- allNamesLet :: LetBinding -> Seq QName- allNamesLet (LetBind _ _ _ e1 e2) = Fold.foldMap allNamesE [e1, e2]- allNamesLet (LetApply _ _ app _ _) = allNamesApp app- allNamesLet LetOpen {} = Seq.empty-- allNamesApp :: ModuleApplication -> Seq QName- allNamesApp (SectionApp bindss _ es) = Fold.foldMap allNamesBinds bindss ><- Fold.foldMap allNamesE (map (namedThing . unArg) es)- allNamesApp RecordModuleIFS {} = Seq.empty--allNames (Section _ _ _ decls) = Fold.foldMap allNames decls-allNames Apply {} = Seq.empty-allNames Import {} = Seq.empty-allNames Pragma {} = Seq.empty-allNames Open {} = Seq.empty-allNames (ScopedDecl _ decls) = Fold.foldMap allNames decls---- | The name defined by the given axiom.------ Precondition: The declaration has to be an 'Axiom'.--axiomName :: Declaration -> QName-axiomName (Axiom _ _ q _) = q-axiomName _ = __IMPOSSIBLE__---- | Are we in an abstract block?------ In that case some definition is abstract.-class AnyAbstract a where- anyAbstract :: a -> Bool--instance AnyAbstract a => AnyAbstract [a] where- anyAbstract = Fold.any anyAbstract--instance AnyAbstract Declaration where- anyAbstract (Axiom i _ _ _) = defAbstract i == AbstractDef- anyAbstract (Field i _ _) = defAbstract i == AbstractDef- anyAbstract (Mutual _ ds) = anyAbstract ds- anyAbstract (ScopedDecl _ ds) = anyAbstract ds- anyAbstract (Section _ _ _ ds) = anyAbstract ds- anyAbstract (FunDef i _ _) = defAbstract i == AbstractDef- anyAbstract (DataDef i _ _ _) = defAbstract i == AbstractDef- anyAbstract (RecDef i _ _ _ _ _) = defAbstract i == AbstractDef- anyAbstract (DataSig i _ _ _) = defAbstract i == AbstractDef- anyAbstract (RecSig i _ _ _) = defAbstract i == AbstractDef- anyAbstract _ = __IMPOSSIBLE__-+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}+{-# LANGUAGE StrictData #-}++{-| The abstract syntax. This is what you get after desugaring and scope+ analysis of the concrete syntax. The type checker works on abstract syntax,+ producing internal syntax ("Agda.Syntax.Internal").+-}+module Agda.Syntax.Abstract+ ( module Agda.Syntax.Abstract+ , module Agda.Syntax.Abstract.Name+ ) where++import Prelude hiding (null)++import Control.DeepSeq++import Data.Bifunctor+import qualified Data.Foldable as Fold+import Data.Function (on)+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe+import qualified Data.Set as Set+import Data.Set (Set)+import Data.Void++import GHC.Generics (Generic)++import Agda.Syntax.Concrete (FieldAssignment'(..), TacticAttribute'(..))+import qualified Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Pretty ()+import Agda.Syntax.Abstract.Name+import qualified Agda.Syntax.Internal as I+import Agda.Syntax.Common+import Agda.Syntax.Common.Aspect (Aspects)+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Info+import Agda.Syntax.Literal+import Agda.Syntax.Position+import Agda.Syntax.Scope.Base++import Agda.TypeChecking.Positivity.Occurrence++import Agda.Utils.List1 (List1, pattern (:|))+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Null+import Agda.Utils.Set1 (Set1)+import qualified Agda.Utils.Set1 as Set1++import Agda.Utils.Impossible++-- | A name in a binding position: we also compare the nameConcrete+-- when comparing the binders for equality.+--+-- With @--caching@ on we compare abstract syntax to determine if we can+-- reuse previous typechecking results: during that comparison two+-- names can have the same nameId but be semantically different,+-- e.g. in @{_ : A} -> ..@ vs. @{r : A} -> ..@.++newtype BindName = BindName { unBind :: Name }+ deriving (Show, HasRange, KillRange, SetRange, NFData)++mkBindName :: Name -> BindName+mkBindName x = BindName x++instance Eq BindName where+ BindName n == BindName m+ = ((==) `on` nameId) n m+ && ((==) `on` nameConcrete) n m++instance Ord BindName where+ BindName n `compare` BindName m+ = (compare `on` nameId) n m+ `mappend` (compare `on` nameConcrete) n m++type Args = [NamedArg Expr]++-- | Types are just expressions.+-- Use this type synonym for hinting that an expression should be a type.+type Type = Expr++-- | Expressions after scope checking (operators parsed, names resolved).+data Expr+ = Var Name -- ^ Bound variable.+ | Def' QName Suffix -- ^ Constant: axiom, function, data or record type,+ -- with a possible suffix.+ | Proj ProjOrigin AmbiguousQName -- ^ Projection (overloaded).+ | Con AmbiguousQName -- ^ Constructor (overloaded).+ | PatternSyn AmbiguousQName -- ^ Pattern synonym.+ | Macro QName -- ^ Macro.+ | Lit ExprInfo Literal -- ^ Literal.+ | QuestionMark MetaInfo InteractionId+ -- ^ Meta variable for interaction.+ -- The 'InteractionId' is usually identical with the+ -- 'metaNumber' of 'MetaInfo'.+ -- However, if you want to print an interaction meta as+ -- just @?@ instead of @?n@, you should set the+ -- 'metaNumber' to 'Nothing' while keeping the 'InteractionId'.+ | Underscore MetaInfo+ -- ^ Meta variable for hidden argument (must be inferred locally).+ | Dot ExprInfo Expr -- ^ @.e@, for postfix projection.+ | App AppInfo Expr (NamedArg Expr) -- ^ Ordinary (binary) application.+ | WithApp ExprInfo Expr (List1 Expr) -- ^ With application.+ | Lam ExprInfo LamBinding Expr -- ^ @λ bs → e@.+ | AbsurdLam ExprInfo Hiding -- ^ @λ()@ or @λ{}@.+ | ExtendedLam ExprInfo DefInfo Erased QName (List1 Clause)+ | Pi ExprInfo Telescope1 Type -- ^ Dependent function space @Γ → A@.+ | Generalized (Set1 QName) Type -- ^ Like a Pi, but the ordering is not known+ | Fun ExprInfo (Arg Type) Type -- ^ Non-dependent function space.+ | Let ExprInfo (List1 LetBinding) Expr+ -- ^ @let bs in e@.+ | Rec KwRange ExprInfo RecordAssigns+ -- ^ Record construction. The 'KwRange' is for the @record@ kewyword.+ | RecUpdate KwRange ExprInfo Expr Assigns+ -- ^ Record update. The 'KwRange' is for the @record@ kewyword.++ | Quote ExprInfo -- ^ Quote an identifier 'QName'.+ | QuoteTerm ExprInfo -- ^ Quote a term.+ | Unquote ExprInfo -- ^ The splicing construct: unquote ...++ -- Wrappers generated by scope checking to remember information that+ -- does not essentially affect type checking:+ | ScopedExpr ScopeInfo Expr -- ^ Scope annotation.+ | Qualified ModuleName Expr -- ^ For remembering the module name of a qualified @do@ block.++ -- Wrappers for internal syntax:+ | Highlighted Aspects Expr -- ^ For printing annotated terms produced by the type checker.+ | DontCare Expr -- ^ For printing @DontCare@ from @Agda.Syntax.Internal@.+ deriving (Show, Generic)++-- | Pattern synonym for regular 'Def'.+pattern Def :: QName -> Expr+pattern Def x = Def' x NoSuffix++-- | Smart constructor for 'Generalized'.+generalized :: Set QName -> Type -> Type+generalized s e = Set1.ifNull s e \ s -> Generalized s e++-- | Record field assignment @f = e@.+type Assign = FieldAssignment' Expr+type Assigns = [Assign]+type RecordAssign = Either Assign ModuleName+type RecordAssigns = [RecordAssign]++-- | Renaming (generic).+type Ren a = Map a (List1 a)++-- | Size of the range of the renaming.+renamingSize :: Ren a -> Int+renamingSize = Map.foldl' (\n xs -> n + length xs) 0++-- | Information created by the scope checker necessary for+-- type-checking a module copy.+data ScopeCopyInfo = ScopeCopyInfo+ { renModules :: Ren ModuleName+ -- ^ Associates to each (original) module name the list of copies+ -- that should be created.+ , renNames :: Ren QName+ -- ^ Same as for 'renModules', but for definitions.+ }+ deriving (Eq, Show, Generic)++instance Pretty ScopeCopyInfo where+ pretty i = vcat [ prRen "renModules =" (renModules i)+ , prRen "renNames =" (renNames i)+ ]+ where+ prRen s r = sep [ text s, nest 2 $ vcat (map pr xs) ]+ where+ xs = [ (k, v) | (k, vs) <- Map.toList r, v <- List1.toList vs ]+ pr (x, y) = pretty x <+> "->" <+> pretty y++-- | How did we get our hands on the 'QName' for the constructor of this+-- record?+data RecordConName+ = NamedRecCon { recordConName :: !QName }+ -- ^ The user wrote it.+ | FreshRecCon { recordConName :: !QName }+ -- ^ We made it up.+ deriving (Eq, Show, Generic)++type RecordDirectives = RecordDirectives' RecordConName++data Declaration+ = Axiom KindOfName DefInfo ArgInfo (Maybe PragmaPolarities) QName Type+ -- ^ Type signature (can be irrelevant, but not hidden).+ --+ -- The fourth argument contains an optional assignment of+ -- polarities to arguments.+ | Generalize (Set QName) DefInfo ArgInfo QName Type+ -- ^ The first argument is the (possibly empty) set of generalizable variables used in the type.+ | Field DefInfo QName (Arg Type) -- ^ record field+ | Primitive DefInfo QName (Arg Type) -- ^ primitive function+ | Mutual MutualInfo (List1 Declaration) -- ^ a bunch of mutually recursive definitions+ | Section Range Erased ModuleName GeneralizeTelescope [Declaration]+ | Apply ModuleInfo Erased ModuleName ModuleApplication+ ScopeCopyInfo ImportDirective+ -- ^ The @ImportDirective@ is for highlighting purposes.+ | Import ModuleInfo ModuleName ImportDirective+ -- ^ The @ImportDirective@ is for highlighting purposes.+ | Pragma Range Pragma+ | Open ModuleInfo ModuleName ImportDirective+ | FunDef DefInfo QName (List1 Clause) -- ^ sequence of function clauses+ | DataSig DefInfo Erased QName GeneralizeTelescope Type -- ^ lone data signature+ | DataDef DefInfo QName PositivityCheck UniverseCheck DataDefParams [Constructor]+ | RecSig DefInfo Erased QName GeneralizeTelescope Type -- ^ lone record signature+ | RecDef DefInfo QName PositivityCheck UniverseCheck ForceRecordEta RecordDirectives DataDefParams Type [Declaration]+ -- ^ The 'Type' gives the constructor type telescope, @(x1 : A1)..(xn : An) -> Dummy@,+ -- and the optional name is the constructor's name.+ -- The optional 'Range' is for the @pattern@ attribute.+ | PatternSynDef QName [WithHiding BindName] (Pattern' Void)+ -- ^ Only for highlighting purposes+ | UnquoteDecl MutualInfo [DefInfo] [QName] Expr+ | UnquoteDef [DefInfo] [QName] Expr+ | UnquoteData [DefInfo] QName UniverseCheck [DefInfo] [QName] Expr+ | ScopedDecl ScopeInfo (List1 Declaration) -- ^ scope annotation+ | UnfoldingDecl Range [QName]+ -- ^ Only for highlighting the unfolded names+ deriving (Show, Generic)++type DefInfo = DefInfo' Expr++type ImportDirective = ImportDirective' QName ModuleName+type Renaming = Renaming' QName ModuleName+type ImportedName = ImportedName' QName ModuleName++data ModuleApplication+ = SectionApp Telescope ModuleName [NamedArg Expr]+ -- ^ @tel. M args@: applies @M@ to @args@ and abstracts @tel@.+ | RecordModuleInstance ModuleName+ -- ^ @M {{...}}@+ deriving (Show, Eq, Generic)++data Pragma+ = OptionsPragma [String]+ | BuiltinPragma RString ResolvedName+ -- ^ 'ResolvedName' is not 'UnknownName'.+ -- Name can be ambiguous e.g. for built-in constructors.+ | BuiltinNoDefPragma RString KindOfName QName+ -- ^ Builtins that do not come with a definition,+ -- but declare a name for an Agda concept.+ | RewritePragma Range [QName]+ -- ^ Range is range of REWRITE keyword.+ | CompilePragma (Ranged BackendName) QName String+ | ForeignPragma (Ranged BackendName) String+ | StaticPragma QName+ | InjectivePragma QName+ | InjectiveForInferencePragma QName+ | InlinePragma Bool QName -- INLINE or NOINLINE+ | NotProjectionLikePragma QName+ -- ^ Mark the definition as not being projection-like+ | OverlapPragma QName OverlapMode+ -- ^ If the definition is an instance, set its overlap mode.+ | DisplayPragma QName [NamedArg Pattern] Expr+ deriving (Show, Eq, Generic)++-- | Bindings that are valid in a @let@.+data LetBinding+ = LetBind LetInfo ArgInfo BindName Type Expr+ -- ^ @LetBind info rel name type defn@+ | LetAxiom LetInfo ArgInfo BindName Type+ -- ^ Function declarations in a let with no matching body.+ | LetPatBind LetInfo ArgInfo Pattern Expr+ -- ^ Irrefutable pattern binding.+ | LetApply ModuleInfo Erased ModuleName ModuleApplication+ ScopeCopyInfo ImportDirective+ -- ^ @LetApply mi newM (oldM args) renamings dir@.+ -- The @ImportDirective@ is for highlighting purposes.+ | LetOpen ModuleInfo ModuleName ImportDirective+ -- ^ only for highlighting and abstractToConcrete+ deriving (Show, Eq, Generic)++-- | Only 'Axiom's.+type TypeSignature = Declaration+type Constructor = TypeSignature+type Field = TypeSignature++type TacticAttribute = TacticAttribute' Expr++-- A Binder @x\@p@, the pattern is optional+data Binder' a = Binder+ { binderPattern :: Maybe Pattern+ , binderNameOrigin :: BinderNameOrigin+ , binderName :: a+ } deriving (Show, Eq, Functor, Foldable, Traversable, Generic)++type Binder = Binder' BindName++mkBinder :: a -> Binder' a+mkBinder = Binder Nothing UserBinderName++mkBinder_ :: Name -> Binder+mkBinder_ = mkBinder . mkBindName++insertedBinder :: a -> Binder' a+insertedBinder = Binder Nothing InsertedBinderName++insertedBinder_ :: Name -> Binder+insertedBinder_ = insertedBinder . mkBindName++extractPattern :: Binder' a -> Maybe (Pattern, a)+extractPattern (Binder p _ a) = (,a) <$> p++-- | A lambda binding is either domain free or typed.+data LamBinding+ = DomainFree TacticAttribute (NamedArg Binder)+ -- ^ . @x@ or @{x}@ or @.x@ or @{x = y}@ or @x\@p@ or @(p)@+ | DomainFull TypedBinding+ -- ^ . @(xs:e)@ or @{xs:e}@ or @(let Ds)@+ deriving (Show, Eq, Generic)++mkDomainFree :: NamedArg Binder -> LamBinding+mkDomainFree = DomainFree empty++-- | Extra information that is attached to a typed binding, that plays a+-- role during type checking but strictly speaking is not part of the+-- @name : type@" relation which a makes up a binding.+data TypedBindingInfo+ = TypedBindingInfo+ { tbTacticAttr :: TacticAttribute+ -- ^ Does this binding have a tactic annotation?+ , tbFinite :: Bool+ -- ^ Does this binding correspond to a Partial binder, rather than+ -- to a Pi binder? Must be present here to be reflected into+ -- abstract syntax later (and to be printed to the user later).+ }+ deriving (Show, Eq, Generic)++instance Null TypedBindingInfo where+ null (TypedBindingInfo tac fin) = null tac && not fin+ empty = TypedBindingInfo empty empty++-- | A typed binding. Appears in dependent function spaces, typed lambdas, and+-- telescopes. It might be tempting to simplify this to only bind a single+-- name at a time, and translate, say, @(x y : A)@ to @(x : A)(y : A)@+-- before type-checking. However, this would be slightly problematic:+--+-- 1. We would have to typecheck the type @A@ several times.+--+-- 2. If @A@ contains a meta variable or hole, it would be duplicated+-- by such a translation.+--+-- While 1. is only slightly inefficient, 2. would be an outright bug.+-- Duplicating @A@ could not be done naively, we would have to make sure+-- that the metas of the copy are aliases of the metas of the original.++data TypedBinding+ = TBind Range TypedBindingInfo (List1 (NamedArg Binder)) Type+ -- ^ As in telescope @(x y z : A)@ or type @(x y z : A) -> B@.+ | TLet Range (List1 LetBinding)+ -- ^ E.g. @(let x = e)@ or @(let open M)@.+ deriving (Show, Eq, Generic)++mkTBind :: Range -> List1 (NamedArg Binder) -> Type -> TypedBinding+mkTBind r = TBind r empty++mkTLet :: Range -> [LetBinding] -> Maybe TypedBinding+mkTLet _ [] = Nothing+mkTLet r (d:ds) = Just $ TLet r (d :| ds)++type Telescope1 = List1 TypedBinding+type Telescope = [TypedBinding]++mkPi :: ExprInfo -> Telescope -> Type -> Type+mkPi _ [] e = e+mkPi i (x:xs) e = Pi i (x :| xs) e++data GeneralizeTelescope = GeneralizeTel+ { generalizeTelVars :: Map QName Name+ -- ^ Maps generalize variables to the corresponding bound variable (to be+ -- introduced by the generalisation).+ , generalizeTel :: Telescope }+ deriving (Show, Eq, Generic)++data DataDefParams = DataDefParams+ { dataDefGeneralizedParams :: Set Name+ -- ^ We don't yet know the position of generalized parameters from the data+ -- sig, so we keep these in a set on the side.+ , dataDefParams :: [LamBinding]+ }+ deriving (Show, Eq, Generic)++noDataDefParams :: DataDefParams+noDataDefParams = DataDefParams Set.empty []++-- | A user pattern together with an internal term that it should be equal to+-- after splitting is complete.+-- Special cases:+-- * User pattern is a variable but internal term isn't:+-- this will be turned into an as pattern.+-- * User pattern is a dot pattern:+-- this pattern won't trigger any splitting but will be checked+-- for equality after all splitting is complete and as patterns have+-- been bound.+-- * User pattern is an absurd pattern:+-- emptiness of the type will be checked after splitting is complete.+-- * User pattern is an annotated wildcard:+-- type annotation will be checked after splitting is complete.+data ProblemEq = ProblemEq+ { problemInPat :: Pattern+ , problemInst :: I.Term+ , problemType :: I.Dom I.Type+ } deriving (Show, Generic)++-- These are not relevant for caching purposes+instance Eq ProblemEq where _ == _ = True++-- | We could throw away @where@ clauses at this point and translate them to+-- @let@. It's not obvious how to remember that the @let@ was really a+-- @where@ clause though, so for the time being we keep it here.+data Clause' lhs = Clause+ { clauseLHS :: lhs+ , clauseStrippedPats :: [ProblemEq]+ -- ^ Only in with-clauses where we inherit some already checked patterns from the parent.+ -- These live in the context of the parent clause left-hand side.+ , clauseRHS :: RHS+ , clauseWhereDecls :: WhereDeclarations+ , clauseCatchall :: Catchall+ } deriving (Show, Functor, Foldable, Traversable, Eq, Generic)++data WhereDeclarations = WhereDecls+ { whereModule :: Maybe ModuleName+ -- #2897: we need to restrict named where modules in refined contexts,+ -- so remember whether it was named here+ , whereAnywhere :: Bool+ -- ^ is it an ordinary unnamed @where@?+ , whereDecls :: Maybe Declaration+ -- ^ The declaration is a 'Section'.+ } deriving (Show, Eq, Generic)++instance Null WhereDeclarations where+ empty = WhereDecls empty False empty++noWhereDecls :: WhereDeclarations+noWhereDecls = empty++type Clause = Clause' LHS+type SpineClause = Clause' SpineLHS+type RewriteEqn = RewriteEqn' QName BindName Pattern Expr+type WithExpr' e = Named BindName (Arg e)+type WithExpr = WithExpr' Expr++data RHS+ = RHS+ { rhsExpr :: Expr+ , rhsConcrete :: Maybe C.Expr+ -- ^ We store the original concrete expression in case+ -- we have to reproduce it during interactive case splitting.+ -- 'Nothing' for internally generated rhss.+ }+ | AbsurdRHS+ | WithRHS QName (List1 WithExpr) (List1 Clause)+ -- ^ The 'QName' is the name of the with function.+ | RewriteRHS+ { rewriteExprs :: [RewriteEqn]+ -- ^ The 'QName's are the names of the generated with functions,+ -- one for each 'Expr'.+ , rewriteStrippedPats :: [ProblemEq]+ -- ^ The patterns stripped by with-desugaring. These are only present+ -- if this rewrite follows a with.+ , rewriteRHS :: RHS+ -- ^ The RHS should not be another @RewriteRHS@.+ , rewriteWhereDecls :: WhereDeclarations+ -- ^ The where clauses are attached to the @RewriteRHS@ by+ --- the scope checker (instead of to the clause).+ }+ deriving (Show, Generic)++-- | Ignore 'rhsConcrete' when comparing 'RHS's.+instance Eq RHS where+ RHS e _ == RHS e' _ = e == e'+ AbsurdRHS == AbsurdRHS = True+ WithRHS a b c == WithRHS a' b' c' = (a == a') && (b == b') && (c == c')+ RewriteRHS a b c d == RewriteRHS a' b' c' d' = and [ a == a', b == b', c == c' , d == d' ]+ _ == _ = False++-- | The lhs of a clause in spine view (inside-out).+-- Projection patterns are contained in @spLhsPats@,+-- represented as @ProjP d@.+data SpineLHS = SpineLHS+ { spLhsInfo :: LHSInfo -- ^ Range.+ , spLhsDefName :: QName -- ^ Name of function we are defining.+ , spLhsPats :: [NamedArg Pattern] -- ^ Elimination by pattern, projections, with-patterns.+ }+ deriving (Show, Eq, Generic)++-- | Ignore 'Range' when comparing 'LHS's.+instance Eq LHS where+ LHS _ core == LHS _ core' = core == core'++-- | The lhs of a clause in focused (projection-application) view (outside-in).+-- Projection patters are represented as 'LHSProj's.+data LHS = LHS+ { lhsInfo :: LHSInfo -- ^ Range.+ , lhsCore :: LHSCore -- ^ Copatterns.+ }+ deriving (Show, Generic)++-- | The lhs in projection-application and with-pattern view.+-- Parameterised over the type @e@ of dot patterns.+data LHSCore' e+ -- | The head applied to ordinary patterns.+ = LHSHead { lhsDefName :: QName+ -- ^ Head @f@.+ , lhsPats :: [NamedArg (Pattern' e)]+ -- ^ Applied to patterns @ps@.+ }+ -- | Projection.+ | LHSProj { lhsDestructor :: AmbiguousQName+ -- ^ Record projection identifier.+ , lhsFocus :: NamedArg (LHSCore' e)+ -- ^ Main argument of projection.+ , lhsPats :: [NamedArg (Pattern' e)]+ -- ^ Further applied to patterns.+ }+ -- | With patterns.+ | LHSWith { lhsHead :: LHSCore' e+ -- ^ E.g. the 'LHSHead'.+ , lhsWithPatterns :: List1 (Arg (Pattern' e))+ -- ^ Applied to with patterns @| p1 | ... | pn@.+ -- These patterns are not prefixed with @WithP@!+ , lhsPats :: [NamedArg (Pattern' e)]+ -- ^ Further applied to patterns.+ }+ deriving (Show, Functor, Foldable, Traversable, Eq, Generic)++type LHSCore = LHSCore' Expr++---------------------------------------------------------------------------+-- * Patterns+---------------------------------------------------------------------------++-- | Parameterised over the type of dot patterns.+data Pattern' e+ = VarP BindName+ | ConP ConPatInfo AmbiguousQName (NAPs e)+ | ProjP PatInfo ProjOrigin AmbiguousQName+ -- ^ Destructor pattern @d@.+ | DefP PatInfo AmbiguousQName (NAPs e)+ -- ^ Defined pattern: function definition @f ps@.+ -- It is also abused to convert destructor patterns into concrete syntax+ -- thus, we put AmbiguousQName here as well.+ | WildP PatInfo+ -- ^ Underscore pattern entered by user.+ -- Or generated at type checking for implicit arguments.+ | AsP PatInfo BindName (Pattern' e)+ | DotP PatInfo e+ -- ^ Dot pattern @.e@+ | AbsurdP PatInfo+ | LitP PatInfo Literal+ | PatternSynP PatInfo AmbiguousQName (NAPs e)+ | RecP KwRange ConPatInfo [FieldAssignment' (Pattern' e)]+ | EqualP PatInfo (List1 (e, e))+ | WithP PatInfo (Pattern' e) -- ^ @| p@, for with-patterns.+ deriving (Show, Functor, Foldable, Traversable, Eq, Generic)++type NAPs e = [NamedArg (Pattern' e)]+type NAPs1 e = List1 (NamedArg (Pattern' e))+type Pattern = Pattern' Expr+type Patterns = [NamedArg Pattern]++instance IsProjP (Pattern' e) where+ -- Andreas, 2018-06-19, issue #3130+ -- Do not interpret things like .(p) as projection pattern any more.+ -- maybePostfixProjP (DotP _ e) = isProjP e <&> \ (_o, d) -> (ProjPostfix, d)+ isProjP (ProjP _ o d) = Just (o, d)+ isProjP _ = Nothing++instance IsProjP Expr where+ isProjP (Proj o ds) = Just (o, ds)+ isProjP (ScopedExpr _ e) = isProjP e+ isProjP _ = Nothing++{--------------------------------------------------------------------------+ Things we parse but are not part of the Agda file syntax+ --------------------------------------------------------------------------}++type HoleContent = C.HoleContent' () BindName Pattern Expr++{--------------------------------------------------------------------------+ Instances+ --------------------------------------------------------------------------}++-- | Does not compare 'ScopeInfo' fields.+-- Does not distinguish between prefix and postfix projections.++instance Eq Expr where+ ScopedExpr _ a1 == ScopedExpr _ a2 = a1 == a2++ Var a1 == Var a2 = a1 == a2+ Def' a1 s1 == Def' a2 s2 = (a1, s1) == (a2, s2)+ Proj _ a1 == Proj _ a2 = a1 == a2+ Con a1 == Con a2 = a1 == a2+ PatternSyn a1 == PatternSyn a2 = a1 == a2+ Macro a1 == Macro a2 = a1 == a2+ Lit r1 a1 == Lit r2 a2 = (r1, a1) == (r2, a2)+ QuestionMark a1 b1 == QuestionMark a2 b2 = (a1, b1) == (a2, b2)+ Underscore a1 == Underscore a2 = a1 == a2+ Dot r1 e1 == Dot r2 e2 = (r1, e1) == (r2, e2)+ App a1 b1 c1 == App a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ WithApp a1 b1 c1 == WithApp a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Lam a1 b1 c1 == Lam a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ AbsurdLam a1 b1 == AbsurdLam a2 b2 = (a1, b1) == (a2, b2)+ ExtendedLam a1 b1 c1 d1 e1 == ExtendedLam a2 b2 c2 d2 e2 = (a1, b1, c1, d1, e1) ==+ (a2, b2, c2, d2, e2)+ Pi a1 b1 c1 == Pi a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Generalized a1 b1 == Generalized a2 b2 = (a1, b1) == (a2, b2)+ Fun a1 b1 c1 == Fun a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Let a1 b1 c1 == Let a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Rec r1 a1 b1 == Rec r2 a2 b2 = (r1, a1, b1) == (r2, a2, b2)+ RecUpdate r1 a1 b1 c1 == RecUpdate r2 a2 b2 c2 = (r1, a1, b1, c1) == (r2, a2, b2, c2)+ Quote a1 == Quote a2 = a1 == a2+ QuoteTerm a1 == QuoteTerm a2 = a1 == a2+ Unquote a1 == Unquote a2 = a1 == a2+ DontCare a1 == DontCare a2 = a1 == a2++ _ == _ = False++-- | Does not compare 'ScopeInfo' fields.++instance Eq Declaration where+ ScopedDecl _ a1 == ScopedDecl _ a2 = a1 == a2++ Axiom a1 b1 c1 d1 e1 f1 == Axiom a2 b2 c2 d2 e2 f2 = (a1, b1, c1, d1, e1, f1) == (a2, b2, c2, d2, e2, f2)+ Generalize a1 b1 c1 d1 e1 == Generalize a2 b2 c2 d2 e2 = (a1, b1, c1, d1, e1) == (a2, b2, c2, d2, e2)+ Field a1 b1 c1 == Field a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Primitive a1 b1 c1 == Primitive a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Mutual a1 b1 == Mutual a2 b2 = (a1, b1) == (a2, b2)+ Section a1 b1 c1 d1 e1 == Section a2 b2 c2 d2 e2 = (a1, b1, c1, d1, e1) == (a2, b2, c2, d2, e2)+ Apply a1 b1 c1 d1 e1 f1 == Apply a2 b2 c2 d2 e2 f2 = (a1, b1, c1, d1, e1, f1) == (a2, b2, c2, d2, e2, f2)+ Import a1 b1 c1 == Import a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ Pragma a1 b1 == Pragma a2 b2 = (a1, b1) == (a2, b2)+ Open a1 b1 c1 == Open a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ FunDef a1 b1 c1 == FunDef a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ DataSig a1 b1 c1 d1 e1 == DataSig a2 b2 c2 d2 e2 = (a1, b1, c1, d1, e1) == (a2, b2, c2, d2, e2)+ DataDef a1 b1 c1 d1 e1 f1 == DataDef a2 b2 c2 d2 e2 f2 = (a1, b1, c1, d1, e1, f1) == (a2, b2, c2, d2, e2, f2)+ RecSig a1 b1 c1 d1 e1 == RecSig a2 b2 c2 d2 e2 = (a1, b1, c1, d1, e1) == (a2, b2, c2, d2, e2)+ RecDef a1 b1 c1 d1 e1 f1 g1 h1 i1 == RecDef a2 b2 c2 d2 e2 f2 g2 h2 i2 = (a1, b1, c1, d1, e1, f1, g1, h1, i1) == (a2, b2, c2, d2, e2, f2, g2, h2, i2)+ PatternSynDef a1 b1 c1 == PatternSynDef a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ UnquoteDecl a1 b1 c1 d1 == UnquoteDecl a2 b2 c2 d2 = (a1, b1, c1, d1) == (a2, b2, c2, d2)+ UnquoteDef a1 b1 c1 == UnquoteDef a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2)+ UnfoldingDecl a1 b1 == UnfoldingDecl a2 b2 = (a1,b1) == (a2,b2)++ _ == _ = False++instance Underscore Expr where+ underscore = Underscore emptyMetaInfo+ isUnderscore = \case+ Underscore _ -> True+ _ -> False++instance LensHiding LamBinding where+ getHiding (DomainFree _ x) = getHiding x+ getHiding (DomainFull tb) = getHiding tb+ mapHiding f (DomainFree t x) = DomainFree t $ mapHiding f x+ mapHiding f (DomainFull tb) = DomainFull $ mapHiding f tb++instance LensHiding TypedBinding where+ getHiding (TBind _ _ (x :| _) _) = getHiding x -- Slightly dubious+ getHiding TLet{} = mempty+ mapHiding f (TBind r t xs e) = TBind r t ((fmap . mapHiding) f xs) e+ mapHiding _ b@TLet{} = b++instance HasRange a => HasRange (Binder' a) where+ getRange (Binder p _ n) = fuseRange p n++instance HasRange LamBinding where+ getRange (DomainFree _ x) = getRange x+ getRange (DomainFull b) = getRange b++instance HasRange TypedBinding where+ getRange (TBind r _ _ _) = r+ getRange (TLet r _) = r++instance HasRange Expr where+ getRange (Var x) = getRange x+ getRange (Def' x _) = getRange x+ getRange (Proj _ x) = getRange x+ getRange (Con x) = getRange x+ getRange (Lit i _) = getRange i+ getRange (QuestionMark i _) = getRange i+ getRange (Underscore i) = getRange i+ getRange (Dot i _) = getRange i+ getRange (App i _ _) = getRange i+ getRange (WithApp i _ _) = getRange i+ getRange (Lam i _ _) = getRange i+ getRange (AbsurdLam i _) = getRange i+ getRange (ExtendedLam i _ _ _ _) = getRange i+ getRange (Pi i _ _) = getRange i+ getRange (Generalized _ x) = getRange x+ getRange (Fun i _ _) = getRange i+ getRange (Let i _ _) = getRange i+ getRange (Rec _ i _) = getRange i+ getRange (RecUpdate _ i _ _) = getRange i+ getRange (ScopedExpr _ e) = getRange e+ getRange (Quote i) = getRange i+ getRange (QuoteTerm i) = getRange i+ getRange (Unquote i) = getRange i+ getRange (DontCare{}) = noRange+ getRange (PatternSyn x) = getRange x+ getRange (Macro x) = getRange x+ getRange (Qualified _ e) = getRange e+ getRange (Highlighted _ e) = getRange e++instance HasRange Declaration where+ getRange (Axiom _ i _ _ _ _ ) = getRange i+ getRange (Generalize _ i _ _ _) = getRange i+ getRange (Field i _ _ ) = getRange i+ getRange (Mutual i _ ) = getRange i+ getRange (Section i _ _ _ _ ) = getRange i+ getRange (Apply i _ _ _ _ _) = getRange i+ getRange (Import i _ _ ) = getRange i+ getRange (Primitive i _ _ ) = getRange i+ getRange (Pragma i _ ) = getRange i+ getRange (Open i _ _ ) = getRange i+ getRange (ScopedDecl _ d ) = getRange d+ getRange (FunDef i _ _ ) = getRange i+ getRange (DataSig i _ _ _ _ ) = getRange i+ getRange (DataDef i _ _ _ _ _) = getRange i+ getRange (RecSig i _ _ _ _ ) = getRange i+ getRange (RecDef i _ _ _ _ _ _ _ _)= getRange i+ getRange (PatternSynDef x _ _ ) = getRange x+ getRange (UnquoteDecl _ i _ _) = getRange i+ getRange (UnquoteDef i _ _) = getRange i+ getRange (UnquoteData i _ _ j _ _) = getRange (i, j)+ getRange (UnfoldingDecl r _) = r++instance HasRange (Pattern' e) where+ getRange (VarP x) = getRange x+ getRange (ConP i _ _) = getRange i+ getRange (ProjP i _ _) = getRange i+ getRange (DefP i _ _) = getRange i+ getRange (WildP i) = getRange i+ getRange (AsP i _ _) = getRange i+ getRange (DotP i _) = getRange i+ getRange (AbsurdP i) = getRange i+ getRange (LitP i _) = getRange i+ getRange (PatternSynP i _ _) = getRange i+ getRange (RecP _kwr i _) = getRange i+ getRange (EqualP i _) = getRange i+ getRange (WithP i _) = getRange i++instance HasRange SpineLHS where+ getRange (SpineLHS i _ _) = getRange i++instance HasRange LHS where+ getRange (LHS i _) = getRange i++instance HasRange (LHSCore' e) where+ getRange (LHSHead f ps) = fuseRange f ps+ getRange (LHSProj d lhscore ps) = d `fuseRange` lhscore `fuseRange` ps+ getRange (LHSWith h wps ps) = h `fuseRange` wps `fuseRange` ps++instance HasRange a => HasRange (Clause' a) where+ getRange (Clause lhs _ rhs ds _catchall) = getRange (lhs, rhs, ds)++instance HasRange RHS where+ getRange AbsurdRHS = noRange+ getRange (RHS e _) = getRange e+ getRange (WithRHS _ e cs) = fuseRange e cs+ getRange (RewriteRHS xes _ rhs wh) = getRange (xes, rhs, wh)++instance HasRange WhereDeclarations where+ getRange (WhereDecls _ _ ds) = getRange ds++instance HasRange LetBinding where+ getRange (LetBind i _ _ _ _) = getRange i+ getRange (LetAxiom i _ _ _) = getRange i+ getRange (LetPatBind i _ _ _) = getRange i+ getRange (LetApply i _ _ _ _ _) = getRange i+ getRange (LetOpen i _ _) = getRange i++-- setRange for patterns applies the range to the outermost pattern constructor+instance SetRange (Pattern' a) where+ setRange r (VarP x) = VarP (setRange r x)+ setRange r (ConP i ns as) = ConP (setRange r i) ns as+ setRange r (ProjP _ o ns) = ProjP (PatRange r) o ns+ setRange r (DefP _ ns as) = DefP (PatRange r) ns as -- (setRange r n) as+ setRange r (WildP _) = WildP (PatRange r)+ setRange r (AsP _ n p) = AsP (PatRange r) (setRange r n) p+ setRange r (DotP _ e) = DotP (PatRange r) e+ setRange r (AbsurdP _) = AbsurdP (PatRange r)+ setRange r (LitP _ l) = LitP (PatRange r) l+ setRange r (PatternSynP _ n as) = PatternSynP (PatRange r) n as+ setRange r (RecP _ i as) = RecP empty (setRange r i) as+ setRange r (EqualP _ es) = EqualP (PatRange r) es+ setRange r (WithP i p) = WithP (setRange r i) p+++instance KillRange a => KillRange (Binder' a) where+ killRange (Binder a o b) = killRangeN Binder a o b++instance KillRange LamBinding where+ killRange (DomainFree t x) = killRangeN DomainFree t x+ killRange (DomainFull b) = killRangeN DomainFull b++instance KillRange GeneralizeTelescope where+ killRange (GeneralizeTel s tel) = GeneralizeTel s (killRange tel)++instance KillRange DataDefParams where+ killRange (DataDefParams s tel) = DataDefParams s (killRange tel)++instance KillRange TypedBindingInfo where+ killRange (TypedBindingInfo a b) = killRangeN TypedBindingInfo a b++instance KillRange TypedBinding where+ killRange (TBind r t xs e) = killRangeN TBind r t xs e+ killRange (TLet r lbs) = killRangeN TLet r lbs++instance KillRange Expr where+ killRange (Var x) = killRangeN Var x+ killRange (Def' x v) = killRangeN Def' x v+ killRange (Proj o x) = killRangeN (Proj o) x+ killRange (Con x) = killRangeN Con x+ killRange (Lit i l) = killRangeN Lit i l+ killRange (QuestionMark i ii) = killRangeN QuestionMark i ii+ killRange (Underscore i) = killRangeN Underscore i+ killRange (Dot i e) = killRangeN Dot i e+ killRange (App i e1 e2) = killRangeN App i e1 e2+ killRange (WithApp i e es) = killRangeN WithApp i e es+ killRange (Lam i b e) = killRangeN Lam i b e+ killRange (AbsurdLam i h) = killRangeN AbsurdLam i h+ killRange (ExtendedLam i n e d ps) = killRangeN ExtendedLam i n e d ps+ killRange (Pi i a b) = killRangeN Pi i a b+ killRange (Generalized s x) = killRangeN (Generalized s) x+ killRange (Fun i a b) = killRangeN Fun i a b+ killRange (Let i ds e) = killRangeN Let i ds e+ killRange (Rec kwr i fs) = killRangeN Rec kwr i fs+ killRange (RecUpdate kwr i e fs) = killRangeN RecUpdate kwr i e fs+ killRange (ScopedExpr s e) = killRangeN (ScopedExpr s) e+ killRange (Quote i) = killRangeN Quote i+ killRange (QuoteTerm i) = killRangeN QuoteTerm i+ killRange (Unquote i) = killRangeN Unquote i+ killRange (DontCare e) = killRangeN DontCare e+ killRange (PatternSyn x) = killRangeN PatternSyn x+ killRange (Macro x) = killRangeN Macro x+ killRange (Qualified a b) = killRangeN Qualified a b+ killRange (Highlighted a b) = killRangeN (Highlighted a) b++instance KillRange Suffix where+ killRange = id++instance KillRange Declaration where+ killRange (Axiom p i a b c d ) = killRangeN (\i a c d -> Axiom p i a b c d) i a c d+ killRange (Generalize s i j x e ) = killRangeN (Generalize s) i j x e+ killRange (Field i a b ) = killRangeN Field i a b+ killRange (Mutual i a ) = killRangeN Mutual i a+ killRange (Section i a b c d ) = killRangeN Section i a b c d+ killRange (Apply i a b c d e ) = killRangeN Apply i a b c d e+ killRange (Import i a b ) = killRangeN Import i a b+ killRange (Primitive i a b ) = killRangeN Primitive i a b+ killRange (Pragma i a ) = Pragma (killRange i) a+ killRange (Open i x dir ) = killRangeN Open i x dir+ killRange (ScopedDecl a d ) = killRangeN (ScopedDecl a) d+ killRange (FunDef i a b ) = killRangeN FunDef i a b+ killRange (DataSig i a b c d ) = killRangeN DataSig i a b c d+ killRange (DataDef i a b c d e ) = killRangeN DataDef i a b c d e+ killRange (RecSig i a b c d ) = killRangeN RecSig i a b c d+ killRange (RecDef i a b c d e f g h) = killRangeN RecDef i a b c d e f g h+ killRange (PatternSynDef x xs p ) = killRangeN PatternSynDef x xs p+ killRange (UnquoteDecl mi i x e ) = killRangeN UnquoteDecl mi i x e+ killRange (UnquoteDef i x e ) = killRangeN UnquoteDef i x e+ killRange (UnquoteData i xs uc j cs e) = killRangeN UnquoteData i xs uc j cs e+ killRange (UnfoldingDecl r xs) = killRangeN UnfoldingDecl r xs++instance KillRange ModuleApplication where+ killRange (SectionApp a b c ) = killRangeN SectionApp a b c+ killRange (RecordModuleInstance a) = killRangeN RecordModuleInstance a++instance KillRange ScopeCopyInfo where+ killRange (ScopeCopyInfo a b) = killRangeN ScopeCopyInfo a b++instance KillRange RecordConName where+ killRange (NamedRecCon x) = killRangeN NamedRecCon x+ killRange (FreshRecCon x) = killRangeN FreshRecCon x++instance KillRange e => KillRange (Pattern' e) where+ killRange (VarP x) = killRangeN VarP x+ killRange (ConP i a b) = killRangeN ConP i a b+ killRange (ProjP i o a) = killRangeN ProjP i o a+ killRange (DefP i a b) = killRangeN DefP i a b+ killRange (WildP i) = killRangeN WildP i+ killRange (AsP i a b) = killRangeN AsP i a b+ killRange (DotP i a) = killRangeN DotP i a+ killRange (AbsurdP i) = killRangeN AbsurdP i+ killRange (LitP i l) = killRangeN LitP i l+ killRange (PatternSynP i a p) = killRangeN PatternSynP i a p+ killRange (RecP kwr i as) = killRangeN RecP kwr i as+ killRange (EqualP i es) = killRangeN EqualP i es+ killRange (WithP i p) = killRangeN WithP i p++instance KillRange SpineLHS where+ killRange (SpineLHS i a b) = killRangeN SpineLHS i a b++instance KillRange LHS where+ killRange (LHS i a) = killRangeN LHS i a++instance KillRange e => KillRange (LHSCore' e) where+ killRange (LHSHead a b) = killRangeN LHSHead a b+ killRange (LHSProj a b c) = killRangeN LHSProj a b c+ killRange (LHSWith a b c) = killRangeN LHSWith a b c++instance KillRange a => KillRange (Clause' a) where+ killRange (Clause lhs spats rhs ds catchall) = killRangeN Clause lhs spats rhs ds catchall++instance KillRange ProblemEq where+ killRange (ProblemEq p v a) = killRangeN ProblemEq p v a++instance KillRange RHS where+ killRange AbsurdRHS = AbsurdRHS+ killRange (RHS e c) = killRangeN RHS e c+ killRange (WithRHS q e cs) = killRangeN WithRHS q e cs+ killRange (RewriteRHS xes spats rhs wh) = killRangeN RewriteRHS xes spats rhs wh++instance KillRange WhereDeclarations where+ killRange (WhereDecls a b c) = killRangeN WhereDecls a b c++instance KillRange LetBinding where+ killRange (LetBind i info a b c) = killRangeN LetBind i info a b c+ killRange (LetAxiom i a b c) = killRangeN LetAxiom i a b c+ killRange (LetPatBind i ai a b) = killRangeN LetPatBind i ai a b+ killRange (LetApply i a b c d e) = killRangeN LetApply i a b c d e+ killRange (LetOpen i x dir) = killRangeN LetOpen i x dir++instance NFData Expr+instance NFData ScopeCopyInfo+instance NFData RecordConName+instance NFData Declaration+instance NFData ModuleApplication+instance NFData Pragma+instance NFData LetBinding+instance NFData a => NFData (Binder' a)+instance NFData LamBinding+instance NFData TypedBinding+instance NFData TypedBindingInfo+instance NFData GeneralizeTelescope+instance NFData DataDefParams+instance NFData ProblemEq+instance NFData lhs => NFData (Clause' lhs)+instance NFData WhereDeclarations+instance NFData RHS+instance NFData SpineLHS+instance NFData LHS+instance NFData e => NFData (LHSCore' e)+instance NFData e => NFData (Pattern' e)++------------------------------------------------------------------------+-- Queries+------------------------------------------------------------------------++-- class AllNames moved to Abstract.Views.DeclaredNames++-- | The name defined by the given axiom.+--+-- Precondition: The declaration has to be a (scoped) 'Axiom'.++axiomName :: Declaration -> QName+axiomName (Axiom _ _ _ _ q _) = q+axiomName (ScopedDecl _ (d :| _)) = axiomName d+axiomName _ = __IMPOSSIBLE__++-- | Are we in an abstract block?+--+-- In that case some definition is abstract.+class AnyAbstract a where+ anyAbstract :: a -> Bool+ default anyAbstract+ :: (Foldable t, AnyAbstract b, t b ~ a)+ => a -> Bool+ anyAbstract = Fold.any anyAbstract++instance AnyAbstract a => AnyAbstract [a]+instance AnyAbstract a => AnyAbstract (List1 a)++instance AnyAbstract Declaration where+ anyAbstract (Axiom _ i _ _ _ _) = defAbstract i == AbstractDef+ anyAbstract (Field i _ _) = defAbstract i == AbstractDef+ anyAbstract (Mutual _ ds) = anyAbstract ds+ anyAbstract (ScopedDecl _ ds) = anyAbstract ds+ anyAbstract (Section _ _ _ _ ds) = anyAbstract ds+ anyAbstract (FunDef i _ _) = defAbstract i == AbstractDef+ anyAbstract (DataDef i _ _ _ _ _) = defAbstract i == AbstractDef+ anyAbstract (RecDef i _ _ _ _ _ _ _ _) = defAbstract i == AbstractDef+ anyAbstract (DataSig i _ _ _ _) = defAbstract i == AbstractDef+ anyAbstract (RecSig i _ _ _ _) = defAbstract i == AbstractDef+ anyAbstract _ = __IMPOSSIBLE__++-- | Turn a name into an expression.++class NameToExpr a where+ nameToExpr :: a -> Expr++-- | Turn an 'AbstractName' into an expression.++instance NameToExpr AbstractName where+ nameToExpr d =+ case anameKind d of+ DataName -> Def x+ RecName -> Def x+ AxiomName -> Def x+ PrimName -> Def x+ FunName -> Def x+ OtherDefName -> Def x+ GeneralizeName -> Def x+ DisallowedGeneralizeName -> Def x+ FldName -> Proj ProjSystem ux+ ConName -> Con ux+ CoConName -> Con ux+ PatternSynName -> PatternSyn ux+ MacroName -> Macro x+ QuotableName -> App (defaultAppInfo r) (Quote i) (defaultNamedArg $ Def x)+ where+ x = anameName d+ ux = unambiguous x+ r = getRange x+ i = ExprRange r++-- | Turn a 'ResolvedName' into an expression.+--+-- Assumes name is not 'UnknownName'.++instance NameToExpr ResolvedName where+ nameToExpr = \case+ VarName x _ -> Var x+ DefinedName _ x s -> withSuffix s $ nameToExpr x -- Can be 'isDefName', 'MacroName', 'QuotableName'.+ FieldName xs -> Proj ProjSystem . ambigName $ xs+ ConstructorName _ xs -> Con . ambigName $ xs+ PatternSynResName xs -> PatternSyn . ambigName $ xs+ UnknownName -> __IMPOSSIBLE__+ where+ withSuffix NoSuffix e = e+ withSuffix s@Suffix{} (Def x) = Def' x s+ withSuffix _ _ = __IMPOSSIBLE__++app :: Expr -> [NamedArg Expr] -> Expr+app = foldl (App defaultAppInfo_)++mkLet :: ExprInfo -> [LetBinding] -> Expr -> Expr+mkLet _ [] e = e+mkLet i (d:ds) e = Let i (d :| ds) e++-- | The definition of a pattern synonym (excluding its name).+data PatternSynDefn = PatternSynDefn+ { patSynParams :: ![WithHiding Name]+ -- ^ The parameters of the pattern synonym.+ , patSynPat :: !(Pattern' Void)+ -- ^ The definiting pattern of the pattern synonym.+ } deriving (Show, Generic)++type PatternSynDefns = Map QName PatternSynDefn++lambdaLiftExpr :: [WithHiding Name] -> Expr -> Expr+lambdaLiftExpr ns e = foldr f e ns+ where+ f (WithHiding h n) = Lam exprNoRange $ setHiding h $ mkDomainFree $ defaultNamedArg $ mkBinder_ n+++-- NOTE: This is only used on expressions that come from right-hand sides of pattern synonyms, and+-- thus does not have to handle all forms of expressions.+class SubstExpr a where+ substExpr :: [(Name, Expr)] -> a -> a++ default substExpr+ :: (Functor t, SubstExpr b, t b ~ a)+ => [(Name, Expr)] -> a -> a+ substExpr = fmap . substExpr++instance SubstExpr a => SubstExpr (Maybe a)+instance SubstExpr a => SubstExpr [a]+instance SubstExpr a => SubstExpr (List1 a)+instance SubstExpr a => SubstExpr (Arg a)+instance SubstExpr a => SubstExpr (Named name a)+instance SubstExpr a => SubstExpr (FieldAssignment' a)++instance (SubstExpr a, SubstExpr b) => SubstExpr (a, b) where+ substExpr s (x, y) = (substExpr s x, substExpr s y)++instance (SubstExpr a, SubstExpr b) => SubstExpr (Either a b) where+ substExpr s (Left x) = Left (substExpr s x)+ substExpr s (Right y) = Right (substExpr s y)++instance SubstExpr C.Name where+ substExpr _ = id++instance SubstExpr ModuleName where+ substExpr _ = id++instance SubstExpr Expr where+ substExpr s e = case e of+ Var n -> fromMaybe e (lookup n s)+ Con _ -> e+ Proj{} -> e+ Def' _ _ -> e+ PatternSyn{} -> e+ Lit _ _ -> e+ Underscore _ -> e+ App i e e' -> App i (substExpr s e) (substExpr s e')+ Rec kwr i nes -> Rec kwr i (substExpr s nes)+ ScopedExpr si e -> ScopedExpr si (substExpr s e)++ -- At the moment we only generate this for @do@, so it can't appear+ -- in a pattern synonym right-hand side, but this is future-proof.+ Qualified q e -> Qualified q (substExpr s e)++ -- The below cannot appear in pattern synonym right-hand sides+ QuestionMark{} -> __IMPOSSIBLE__+ Dot{} -> __IMPOSSIBLE__+ WithApp{} -> __IMPOSSIBLE__+ Lam{} -> __IMPOSSIBLE__+ AbsurdLam{} -> __IMPOSSIBLE__+ ExtendedLam{} -> __IMPOSSIBLE__+ Pi{} -> __IMPOSSIBLE__+ Generalized{} -> __IMPOSSIBLE__+ Fun{} -> __IMPOSSIBLE__+ Let{} -> __IMPOSSIBLE__+ RecUpdate{} -> __IMPOSSIBLE__+ Quote{} -> __IMPOSSIBLE__+ QuoteTerm{} -> __IMPOSSIBLE__+ Unquote{} -> __IMPOSSIBLE__+ DontCare{} -> __IMPOSSIBLE__+ Macro{} -> __IMPOSSIBLE__+ Highlighted{} -> __IMPOSSIBLE__++-- TODO: more informative failure+insertImplicitPatSynArgs :: forall a. HasRange a+ => (Hiding -> Range -> a)+ -- ^ Thing to insert (wildcard).+ -> Range+ -- ^ Range of the whole pattern synonym expression/pattern.+ -> [WithHiding Name]+ -- ^ The parameters of the pattern synonym (from its definition).+ -> [NamedArg a]+ -- ^ The arguments it is used with.+ -> Maybe ([(Name, a)], [WithHiding Name])+ -- ^ Substitution and left-over parameters.+insertImplicitPatSynArgs wild r ns as = matchArgs r ns as+ where+ matchNextArg :: Range -> WithHiding Name -> [NamedArg a] -> Maybe (a, [NamedArg a])+ matchNextArg r n as@(~(a : as'))+ | not (null as)+ , matchNext n a = return (namedArg a, as')+ | visible n = Nothing+ | otherwise = return (wild (getHiding n) r, as)++ matchNext ::+ WithHiding Name -- Pattern synonym parameter+ -> NamedArg a -- Argument given to pattern synonym+ -> Bool+ matchNext n a = sameHiding n a && maybe True (x ==) (bareNameOf a)+ where+ x = C.nameToRawName $ nameConcrete $ whThing n++ matchArgs ::+ Range+ -> [WithHiding Name]+ -> [NamedArg a]+ -> Maybe ([(Name, a)], [WithHiding Name])+ matchArgs _ [] [] = return ([], [])+ matchArgs _ [] (_:_) = Nothing+ matchArgs _ (n:ns) [] | visible n = return ([], n : ns) -- under-applied+ matchArgs r (n:ns) as = do+ (p, as) <- matchNextArg r n as+ first ((whThing n, p) :) <$> matchArgs (getRange p) ns as++------------------------------------------------------------------------+-- Declaration spines+------------------------------------------------------------------------++-- | Declaration spines. Used in debugging to make it easy to see+-- where constructors such as 'ScopedDecl' and 'Mutual' are placed.++data DeclarationSpine+ = AxiomS+ | GeneralizeS+ | FieldS+ | PrimitiveS+ | MutualS (List1 DeclarationSpine)+ | SectionS [DeclarationSpine]+ | ApplyS+ | ImportS+ | PragmaS+ | OpenS+ | FunDefS (List1 ClauseSpine)+ | DataSigS+ | DataDefS+ | RecSigS+ | RecDefS [DeclarationSpine]+ | PatternSynDefS+ | UnquoteDeclS+ | UnquoteDefS+ | UnquoteDataS+ | ScopedDeclS (List1 DeclarationSpine)+ | UnfoldingDeclS+ deriving Show++-- | Clause spines.++data ClauseSpine = ClauseS RHSSpine WhereDeclarationsSpine+ deriving Show++-- | Right-hand side spines.++data RHSSpine+ = RHSS+ | AbsurdRHSS+ | WithRHSS (List1 ClauseSpine)+ | RewriteRHSS RHSSpine WhereDeclarationsSpine+ deriving Show++-- | Spines corresponding to 'WhereDeclarations' values.++data WhereDeclarationsSpine = WhereDeclsS (Maybe DeclarationSpine)+ deriving Show++-- | The declaration spine corresponding to a declaration.++declarationSpine :: Declaration -> DeclarationSpine+declarationSpine = \case+ Axiom _ _ _ _ _ _ -> AxiomS+ Generalize _ _ _ _ _ -> GeneralizeS+ Field _ _ _ -> FieldS+ Primitive _ _ _ -> PrimitiveS+ Mutual _ ds -> MutualS (fmap declarationSpine ds)+ Section _ _ _ _ ds -> SectionS (map declarationSpine ds)+ Apply _ _ _ _ _ _ -> ApplyS+ Import _ _ _ -> ImportS+ Pragma _ _ -> PragmaS+ Open _ _ _ -> OpenS+ FunDef _ _ cs -> FunDefS (fmap clauseSpine cs)+ DataSig _ _ _ _ _ -> DataSigS+ DataDef _ _ _ _ _ _ -> DataDefS+ RecSig _ _ _ _ _ -> RecSigS+ RecDef _ _ _ _ _ _ _ _ ds -> RecDefS (map declarationSpine ds)+ PatternSynDef _ _ _ -> PatternSynDefS+ UnquoteDecl _ _ _ _ -> UnquoteDeclS+ UnquoteDef _ _ _ -> UnquoteDefS+ UnquoteData _ _ _ _ _ _ -> UnquoteDataS+ ScopedDecl _ ds -> ScopedDeclS (fmap declarationSpine ds)+ UnfoldingDecl _ _ -> UnquoteDeclS++-- | The clause spine corresponding to a clause.++clauseSpine :: Clause -> ClauseSpine+clauseSpine (Clause _ _ rhs ws _) =+ ClauseS (rhsSpine rhs) (whereDeclarationsSpine ws)++-- | The right-hand side spine corresponding to a right-hand side.++rhsSpine :: RHS -> RHSSpine+rhsSpine = \case+ RHS _ _ -> RHSS+ AbsurdRHS -> AbsurdRHSS+ WithRHS _ _ cs -> WithRHSS $ fmap clauseSpine cs+ RewriteRHS _ _ rhs ws ->+ RewriteRHSS (rhsSpine rhs) (whereDeclarationsSpine ws)++-- | The spine corresponding to a 'WhereDeclarations' value.++whereDeclarationsSpine :: WhereDeclarations -> WhereDeclarationsSpine+whereDeclarationsSpine (WhereDecls _ _ md) =+ WhereDeclsS (fmap declarationSpine md)++-- Instances++instance KillRange PatternSynDefn where+ killRange (PatternSynDefn a b) = killRangeN PatternSynDefn a b++instance NFData PatternSynDefn
@@ -1,73 +1,297 @@-{-# LANGUAGE CPP, DeriveDataTypeable, GeneralizedNewtypeDeriving, FlexibleContexts #-} -{-| Abstract names should carry unique identifiers and stuff. Not right now though.+{-| Abstract names carry unique identifiers and stuff. -}-module Agda.Syntax.Abstract.Name where+module Agda.Syntax.Abstract.Name+ ( module Agda.Syntax.Abstract.Name+ , IsNoName(..)+ , FreshNameMode(..)+ ) where -import Control.Monad.State-import Data.Generics (Typeable, Data)-import Data.List-import Data.Function+import Prelude hiding (length, null) +import Control.DeepSeq++import Data.Foldable (length)+import Data.Function (on)+import Data.Hashable (Hashable(..))+import qualified Data.List as List+import Data.Maybe+import Data.Map (Map)+import Data.Void++import GHC.Generics (Generic)+ import Agda.Syntax.Position import Agda.Syntax.Common-import Agda.Syntax.Fixity+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete.Name (IsNoName(..), NumHoles(..), NameInScope(..), LensInScope(..), FreshNameMode(..)) import qualified Agda.Syntax.Concrete.Name as C -import Agda.Utils.Fresh-import Agda.Utils.Size-import Agda.Utils.Suffix+import Data.Set (Set)+import Data.Set qualified as Set+import Data.Map (Map)+import Data.Map qualified as Map -import Agda.Syntax.Notation+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List qualified as List+import Agda.Utils.List1 (List1, pattern (:|), (<|))+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Map1 (Map1)+import Agda.Utils.Map1 qualified as Map1+import Agda.Utils.Maybe ( unionMaybeWith )+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.Size -#include "../../undefined.h"+import qualified Agda.Syntax.Common.Aspect as Asp import Agda.Utils.Impossible +---------------------------------------------------------------------------+-- * Types+---------------------------------------------------------------------------+ -- | A name is a unique identifier and a suggestion for a concrete name. The -- concrete name contains the source location (if any) of the name. The -- source location of the binding site is also recorded.-data Name = Name { nameId :: NameId- , nameConcrete :: C.Name- , nameBindingSite :: Range- , nameFixity :: Fixity'- }- deriving (Typeable, Data)+data Name = Name+ { _nameId :: {-# UNPACK #-} !NameId+ , nameConcrete :: C.Name -- ^ The concrete name used for this instance+ , nameCanonical :: C.Name -- ^ The concrete name in the original definition (needed by primShowQName, see #4735)+ , _nameBindingSite :: Range -- ^ Range of the name in its /defining/ occurrence.+ , nameFixity :: Fixity'+ , nameIsRecordName :: Bool+ -- ^ Is this the name of the invisible record variable `self`?+ -- Should not be printed or displayed in the context, see issue #3584.+ } +-- | A name suffix.+data Suffix+ = NoSuffix+ | Suffix !Integer+ deriving (Show, Eq, Ord)+ -- | Qualified names are non-empty lists of names. Equality on qualified names -- are just equality on the last name, i.e. the module part is just -- for show. -- -- The 'SetRange' instance for qualified names sets all individual -- ranges (including those of the module prefix) to the given one.-data QName = QName { qnameModule :: ModuleName- , qnameName :: Name- }- deriving (Typeable, Data)+data QName = QName+ { qnameModule :: ModuleName+ , qnameName :: Name+ } deriving (Generic) +{-# SPECIALIZE Set.insert :: QName -> Set QName -> Set QName #-}+{-# SPECIALIZE Set.delete :: QName -> Set QName -> Set QName #-}+{-# SPECIALIZE Set.member :: QName -> Set QName -> Bool #-}+{-# SPECIALIZE Set.fromList :: [QName] -> Set QName #-}++{-# SPECIALIZE Map.insert :: QName -> v -> Map QName v -> Map QName v #-}+{-# SPECIALIZE Map.lookup :: QName -> Map QName v -> Maybe v #-}+{-# SPECIALIZE Map.delete :: QName -> Map QName v -> Map QName v #-}+{-# SPECIALIZE Map.fromList :: [(QName, v)] -> Map QName v #-}++-- | Something preceeded by a qualified name.+data QNamed a = QNamed+ { qname :: QName+ , qnamed :: a+ }+ deriving (Functor, Foldable, Traversable)+ -- | A module name is just a qualified name. -- -- The 'SetRange' instance for module names sets all individual ranges -- to the given one. newtype ModuleName = MName { mnameToList :: [Name] }- deriving (Eq, Ord, Typeable, Data)+ deriving (Eq, Ord, NFData, Null, Hashable) -- | Ambiguous qualified names. Used for overloaded constructors. ----- Invariant: All the names in the list must have the same concrete,--- unqualified name.-newtype AmbiguousQName = AmbQ { unAmbQ :: [QName] }- deriving (Typeable, Data, HasRange, Show)+-- A 'QName' in this collection might be equipped with lineage information+-- in form of an associated 'AbstractName' (which must contain the same 'QName').+--+-- Invariant: All the names in the map must have the same concrete,+-- unqualified name. (This implies that they all have the same 'Range').+--+-- Don't use the constructor 'AmbQ' directly, use the smart constructors below!+newtype AmbiguousQName = AmbQ { unAmbQ :: Map1 NameId AmbQNameEntry }+ deriving (Eq, Ord, NFData, Sized) -instance HasRange ModuleName where- getRange (MName []) = noRange- getRange (MName xs) = getRange xs+-- | Alternative in 'AmbiguousQName'.+data AmbQNameEntry+ = AmbQName QName+ -- ^ 'QName' without lineage information.+ | AmbAbstractName AbstractName+ -- ^ 'QName' with lineage information, for error reporting.+ deriving (Eq, Ord, Show, Generic) +-- | A decoration of 'Agda.Syntax.Abstract.Name.QName'.+data AbstractName = AbsName+ { anameName :: QName+ -- ^ The resolved qualified name.+ , anameKind :: KindOfName+ -- ^ The kind (definition, constructor, record field etc.).+ , anameLineage :: WhyInScope+ -- ^ Explanation where this name came from.+ , anameMetadata :: NameMetadata+ -- ^ Additional information needed during scope checking. Currently used+ -- for generalized data/record params.+ }+ deriving (Show, Generic)++-- | A decoration of abstract syntax module names.+data AbstractModule = AbsModule+ { amodName :: ModuleName+ -- ^ The resolved module name.+ , amodLineage :: WhyInScope+ -- ^ Explanation where this name came from.+ }+ deriving (Show, Generic)++-- | For the sake of parsing left-hand sides, we distinguish+-- constructor and record field names from defined names.++-- Note: order does matter in this enumeration, see 'isDefName'.+data KindOfName+ = ConName -- ^ Constructor name ('Inductive' or don't know).+ | CoConName -- ^ Constructor name (definitely 'CoInductive').+ | FldName -- ^ Record field name.+ | PatternSynName -- ^ Name of a pattern synonym.+ | GeneralizeName -- ^ Name to be generalized+ | DisallowedGeneralizeName -- ^ Generalizable variable from a let open+ | MacroName -- ^ Name of a macro+ | QuotableName -- ^ A name that can only be quoted.+ -- Previous category @DefName@:+ -- (Refined in a flat manner as Enum and Bounded are not hereditary.)+ | DataName -- ^ Name of a @data@.+ | RecName -- ^ Name of a @record@.+ | FunName -- ^ Name of a defined function.+ | AxiomName -- ^ Name of a @postulate@.+ | PrimName -- ^ Name of a @primitive@.+ | OtherDefName -- ^ A @DefName@, but either other kind or don't know which kind.+ -- End @DefName@. Keep these together in sequence, for sake of @isDefName@!+ deriving (Eq, Ord, Show, Enum, Bounded, Generic)++-- | Where does a name come from?+--+-- This information is solely for reporting to the user,+-- see 'Agda.Interaction.InteractionTop.whyInScope'.+data WhyInScope+ = Defined+ -- ^ Defined in this module.+ | Opened C.QName WhyInScope+ -- ^ Imported from another module.+ | Applied C.QName WhyInScope+ -- ^ Imported by a module application.+ deriving (Show, Generic)++data NameMetadata = NameMetadata+ { nameDataGeneralizedVars :: Map QName Name+ , nameDataIsInstance :: IsInstance+ }+ deriving (Show, Generic)++---------------------------------------------------------------------------+-- * Overloaded 'nameId'+---------------------------------------------------------------------------++class HasNameId a where+ nameId :: a -> NameId++instance HasNameId Name where+ nameId = _nameId++instance HasNameId QName where+ nameId = nameId . qnameName++instance HasNameId AbstractName where+ nameId = nameId . anameName++---------------------------------------------------------------------------+-- * Overloaded 'nameBindingSite'+---------------------------------------------------------------------------++class HasNameBindingSite a where+ nameBindingSite :: a -> Range++instance HasNameBindingSite Name where+ nameBindingSite = _nameBindingSite++instance HasNameBindingSite QName where+ nameBindingSite = nameBindingSite . qnameName++instance HasNameBindingSite ModuleName where+ nameBindingSite = nameBindingSite . mnameToQName++instance HasNameBindingSite AbstractName where+ nameBindingSite = nameBindingSite . anameName++instance HasNameBindingSite AbstractModule where+ nameBindingSite = nameBindingSite . amodName++---------------------------------------------------------------------------+-- * Class 'IsProjP'+---------------------------------------------------------------------------++-- | Check whether we are a projection pattern.+class IsProjP a where+ isProjP :: a -> Maybe (ProjOrigin, AmbiguousQName)++instance IsProjP a => IsProjP (Arg a) where+ isProjP p = case isProjP $ unArg p of+ Just (ProjPostfix , f)+ | getHiding p /= NotHidden -> Nothing+ x -> x++instance IsProjP a => IsProjP (Named n a) where+ isProjP = isProjP . namedThing++instance IsProjP Void where+ isProjP _ = __IMPOSSIBLE__++---------------------------------------------------------------------------+-- * 'Name'+---------------------------------------------------------------------------++-- | Make a 'Name' from some kind of string.+class MkName a where+ -- | The 'Range' sets the /definition site/ of the name, not the use site.+ mkName :: Range -> NameId -> a -> Name++ mkName_ :: NameId -> a -> Name+ mkName_ = mkName noRange++instance MkName String where+ mkName r i s = makeName i (C.Name noRange InScope (C.stringNameParts s)) r noFixity' False++makeName :: NameId -> C.Name -> Range -> Fixity' -> Bool -> Name+makeName i c r f rec = Name i c c r f rec++nameToArgName :: Name -> ArgName+nameToArgName = stringToArgName . prettyShow++namedArgName :: NamedArg Name -> ArgName+namedArgName x = fromMaybe (nameToArgName $ namedArg x) $ bareNameOf x++-- | Ignoring the suffix.+sameRoot :: Name -> Name -> Bool+sameRoot = C.sameRoot `on` nameConcrete++---------------------------------------------------------------------------+-- * 'ModuleName'+---------------------------------------------------------------------------++-- | A module is anonymous if the qualification path ends in an underscore.+isAnonymousModuleName :: ModuleName -> Bool+isAnonymousModuleName (MName mms) = maybe False isNoName $ List.lastMaybe mms+ -- | Sets the ranges of the individual names in the module name to -- match those of the corresponding concrete names. If the concrete -- names are fewer than the number of module name name parts, then the -- initial name parts get the range 'noRange'. ----- @C.D.E `withRangesOf` [A, B]@ returns @C.D.E@ but with ranges set+-- @C.D.E \`withRangesOf\` [A, B]@ returns @C.D.E@ but with ranges set -- as follows: -- -- * @C@: 'noRange'.@@ -79,13 +303,12 @@ -- Precondition: The number of module name name parts has to be at -- least as large as the length of the list. -withRangesOf :: ModuleName -> [C.Name] -> ModuleName-MName ms `withRangesOf` ns- | length ms < length ns = __IMPOSSIBLE__- | otherwise = MName $- reverse $ zipWith setRange- (reverse (map getRange ns) ++ repeat noRange)- (reverse ms)+withRangesOf :: ModuleName -> List1 C.Name -> ModuleName+MName ms `withRangesOf` ns = if m < n then __IMPOSSIBLE__ else MName $+ zipWith setRange (replicate (m - n) noRange ++ map getRange (List1.toList ns)) ms+ where+ m = length ms+ n = length ns -- | Like 'withRangesOf', but uses the name parts (qualifier + name) -- of the qualified name as the list of concrete names.@@ -96,134 +319,199 @@ mnameFromList :: [Name] -> ModuleName mnameFromList = MName +mnameFromList1 :: List1 Name -> ModuleName+mnameFromList1 = MName . List1.toList++mnameToList1 :: ModuleName -> List1 Name+mnameToList1 (MName ns) = List1.ifNull ns __IMPOSSIBLE__ id+ noModuleName :: ModuleName noModuleName = mnameFromList [] --- | The 'Range' sets the /definition site/ of the name, not the use--- site.+commonParentModule :: ModuleName -> ModuleName -> ModuleName+commonParentModule m1 m2 =+ mnameFromList $ List.commonPrefix (mnameToList m1) (mnameToList m2) -mkName :: Range -> NameId -> String -> Name-mkName r i s = Name i (C.Name noRange (parseName s)) r defaultFixity'+mnameToConcrete :: ModuleName -> C.QName+mnameToConcrete (MName []) = __IMPOSSIBLE__ -- C.QName C.noName_ -- should never happen?+mnameToConcrete (MName (x:xs)) = foldr C.Qual (C.QName $ List1.last cs) $ List1.init cs where- parseName "" = []- parseName ('_':s) = C.Hole : parseName s- parseName s = case break (== '_') s of- (s0, s1) -> C.Id s0 : parseName s1+ cs = fmap nameConcrete (x :| xs) -mkName_ :: NameId -> String -> Name-mkName_ = mkName noRange+qualifyM :: ModuleName -> ModuleName -> ModuleName+qualifyM m1 m2 = mnameFromList $ mnameToList m1 ++ mnameToList m2 -qnameToList :: QName -> [Name]-qnameToList (QName m x) = mnameToList m ++ [x]+-- | Is the first module a weak parent of the second?+isLeParentModuleOf :: ModuleName -> ModuleName -> Bool+isLeParentModuleOf = List.isPrefixOf `on` mnameToList -qnameFromList :: [Name] -> QName-qnameFromList [] = __IMPOSSIBLE__-qnameFromList xs = QName (mnameFromList $ init xs) (last xs)+-- | Is the first module a proper parent of the second?+isLtParentModuleOf :: ModuleName -> ModuleName -> Bool+isLtParentModuleOf x y =+ isJust $ (List.stripPrefixBy (==) `on` mnameToList) x y +-- | Is the first module a weak child of the second?+isLeChildModuleOf :: ModuleName -> ModuleName -> Bool+isLeChildModuleOf = flip isLeParentModuleOf++-- | Is the first module a proper child of the second?+isLtChildModuleOf :: ModuleName -> ModuleName -> Bool+isLtChildModuleOf = flip isLtParentModuleOf++-- | Drop anonymous modules at the end of the module name+dropAnonymousModules :: ModuleName -> ModuleName+dropAnonymousModules (MName ms) = MName $ List.dropWhileEnd isNoName ms++---------------------------------------------------------------------------+-- * 'QName'+---------------------------------------------------------------------------++qnameToList0 :: QName -> [Name]+qnameToList0 = List1.toList . qnameToList++qnameToList :: QName -> List1 Name+qnameToList (QName m x) = mnameToList m `List1.snoc` x++qnameFromList :: List1 Name -> QName+qnameFromList xs = QName (mnameFromList $ List1.init xs) (List1.last xs)+ qnameToMName :: QName -> ModuleName-qnameToMName = mnameFromList . qnameToList+qnameToMName = mnameFromList1 . qnameToList mnameToQName :: ModuleName -> QName-mnameToQName = qnameFromList . mnameToList+mnameToQName = qnameFromList . mnameToList1 showQNameId :: QName -> String-showQNameId q = show ns ++ "@" ++ show m+showQNameId q = show (List1.toList ns) ++ "@" ++ show (List1.head ms) where- is = map nameId $ mnameToList (qnameModule q) ++ [qnameName q]- ns = [ n | NameId n _ <- is ]- m = head [ m | NameId _ m <- is ]+ (ns, ms) = List1.unzip $ fmap (unNameId . nameId) $ List1.snoc (mnameToList $ qnameModule q) (qnameName q)+ unNameId (NameId n m) = (n, m) -- | Turn a qualified name into a concrete name. This should only be used as a -- fallback when looking up the right concrete name in the scope fails. qnameToConcrete :: QName -> C.QName-qnameToConcrete (QName m x) =- foldr C.Qual (C.QName $ nameConcrete x) $ map nameConcrete $ mnameToList m--mnameToConcrete :: ModuleName -> C.QName-mnameToConcrete (MName []) = __IMPOSSIBLE__ -- C.QName C.noName_ -- should never happen?-mnameToConcrete (MName xs) = foldr C.Qual (C.QName $ last cs) $ init cs- where- cs = map nameConcrete xs---- | Computes the 'TopLevelModuleName' corresponding to the given--- module name, which is assumed to represent a top-level module name.------ Precondition: The module name must be well-formed.--toTopLevelModuleName :: ModuleName -> C.TopLevelModuleName-toTopLevelModuleName (MName []) = __IMPOSSIBLE__-toTopLevelModuleName (MName ms) = C.TopLevelModuleName (map show ms)--qualifyM :: ModuleName -> ModuleName -> ModuleName-qualifyM m1 m2 = mnameFromList $ mnameToList m1 ++ mnameToList m2+qnameToConcrete (QName m x) = -- Use the canonical name here (#5048)+ foldr (C.Qual . nameConcrete) (C.QName $ nameCanonical x) (mnameToList m) qualifyQ :: ModuleName -> QName -> QName-qualifyQ m x = qnameFromList $ mnameToList m ++ qnameToList x+qualifyQ m x = qnameFromList $ mnameToList m `List1.prependList` qnameToList x qualify :: ModuleName -> Name -> QName-qualify m x = qualifyQ m (qnameFromList [x])+qualify = QName +-- | Convert a 'Name' to a 'QName' (add no module name).+qualify_ :: Name -> QName+qualify_ = qualify noModuleName+ -- | Is the name an operator? isOperator :: QName -> Bool-isOperator q = C.isOperator (nameConcrete (qnameName q))--isSubModuleOf :: ModuleName -> ModuleName -> Bool-isSubModuleOf x y = xs /= ys && isPrefixOf ys xs- where- xs = mnameToList x- ys = mnameToList y+isOperator = C.isOperator . nameConcrete . qnameName isInModule :: QName -> ModuleName -> Bool-isInModule q m = mnameToList m `isPrefixOf` qnameToList q+isInModule q m = mnameToList m `List.isPrefixOf` qnameToList0 q -freshName :: (MonadState s m, HasFresh NameId s) => Range -> String -> m Name-freshName r s = do- i <- fresh- return $ mkName r i s+-- | Get the next version of the concrete name. For instance, @nextName "x" = "x₁"@.+-- The name must not be a 'NoName'.+nextName :: C.FreshNameMode -> Name -> Name+nextName freshNameMode x = x { nameConcrete = C.nextName freshNameMode (nameConcrete x) } -freshName_ :: (MonadState s m, HasFresh NameId s) => String -> m Name-freshName_ = freshName noRange+---------------------------------------------------------------------------+-- * 'AmbiguousQName'+--------------------------------------------------------------------------- -freshNoName :: (MonadState s m, HasFresh NameId s) => Range -> m Name-freshNoName r =- do i <- fresh- return $ Name i (C.NoName noRange i) r defaultFixity'+fromAmbQName :: AmbQNameEntry -> QName+fromAmbQName = \case+ AmbQName x -> x+ AmbAbstractName x -> anameName x -freshNoName_ :: (MonadState s m, HasFresh NameId s) => m Name-freshNoName_ = freshNoName noRange+-- | A singleton "ambiguous" name.+unambiguous :: QName -> AmbiguousQName+unambiguous = ambiguous . singleton --- | Get the next version of the concrete name. For instance, @nextName "x" = "x'"@.--- The name must not be a 'NoName'.-nextName :: Name -> Name-nextName x = x { nameConcrete = C.Name noRange $ nextSuf ps }- where- C.Name _ ps = nameConcrete x- -- NoName cannot appear here- nextSuf [C.Id s] = [C.Id $ nextStr s]- nextSuf [C.Id s, C.Hole] = [C.Id $ nextStr s, C.Hole]- nextSuf (p : ps) = p : nextSuf ps- nextSuf [] = __IMPOSSIBLE__- nextStr s = case suffixView s of- (s0, suf) -> addSuffix s0 (nextSuffix suf)+ambiguous :: List1 QName -> AmbiguousQName+ambiguous = AmbQ . Map1.fromList . fmap \ x -> (nameId x, AmbQName x) -instance Show NameId where- show (NameId x i) = show x ++ "@" ++ show i+-- | Get the first of the ambiguous names.+headAmbQ :: AmbiguousQName -> QName+headAmbQ = List1.head . getAmbiguous +-- | Is a name ambiguous.+isAmbiguous :: AmbiguousQName -> Bool+isAmbiguous (AmbQ m) = size m > 1++-- | Get the name if unambiguous.+getUnambiguous :: AmbiguousQName -> Maybe QName+getUnambiguous m+ | size m == 1 = Just $ headAmbQ m+ | otherwise = Nothing++getAmbiguous :: AmbiguousQName -> List1 QName+getAmbiguous = fmap fromAmbQName . Map1.elems . unAmbQ++ambAbstractNames :: AmbiguousQName -> [AbstractName]+ambAbstractNames (AmbQ xs) = (`List1.mapMaybe` Map1.elems xs) \case+ AmbQName{} -> Nothing+ AmbAbstractName x -> Just x++unambigName :: AbstractName -> AmbiguousQName+unambigName = ambigName . singleton++ambigName :: List1 AbstractName -> AmbiguousQName+ambigName = AmbQ . Map1.fromList . fmap \ x -> (nameId x, AmbAbstractName x)++-- | Preserve lineage information from both maps, left-biased.+mergeAmbQ :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName+mergeAmbQ (AmbQ xs) (AmbQ ys) = AmbQ (Map1.unionWith (<>) xs ys)++-- | Prefer 'AmbAbstractName' over 'AmbQName', left-biased.+instance Semigroup AmbQNameEntry where+ x@AmbAbstractName{} <> _ = x+ _ <> y@AmbAbstractName{} = y+ x <> _ = x++---------------------------------------------------------------------------+-- * 'AbstractName'+---------------------------------------------------------------------------++---------------------------------------------------------------------------+-- * 'NameMetadata'+---------------------------------------------------------------------------++noMetadata :: NameMetadata+noMetadata = empty++generalizedVarsMetadata :: Map QName Name -> NameMetadata+generalizedVarsMetadata m = NameMetadata m empty++instanceMetadata :: IsInstance -> NameMetadata+instanceMetadata i = NameMetadata empty i++instance IsInstanceDef NameMetadata where+ isInstanceDef = isInstanceDef . nameDataIsInstance++instance IsInstanceDef AbstractName where+ isInstanceDef = isInstanceDef . anameMetadata++---------------------------------------------------------------------------+-- * Instances+---------------------------------------------------------------------------++-- | Important instances: 'Eq', 'Ord', 'Hashable'+--+-- For the identity and comparing of names, only the 'NameId' matters!+ instance Eq Name where- x == y = nameId x == nameId y+ (==) = (==) `on` nameId instance Ord Name where- compare x y = compare (nameId x) (nameId y)--instance Show Name where- show x = show (nameConcrete x) -- ++ "|" ++ show (nameId x)+ compare = compare `on` nameId -instance Show QName where- show q = concat $ intersperse "." $ map show $ qnameToList q+instance Hashable Name where+ {-# INLINE hashWithSalt #-}+ hashWithSalt salt = hashWithSalt salt . nameId -instance Show ModuleName where- show m = concat $ intersperse "." $ map show $ mnameToList m+-- QName instance Eq QName where (==) = (==) `on` qnameName@@ -231,12 +519,196 @@ instance Ord QName where compare = compare `on` qnameName +instance Hashable QName where+ {-# INLINE hashWithSalt #-}+ hashWithSalt salt = hashWithSalt salt . qnameName++-- AbstractName++instance Eq AbstractName where+ (==) = (==) `on` anameName++instance Ord AbstractName where+ compare = compare `on` anameName++instance Hashable AbstractName where+ hashWithSalt salt = hashWithSalt salt . anameName++-- AbstractModule++instance Eq AbstractModule where+ (==) = (==) `on` amodName++instance Ord AbstractModule where+ compare = compare `on` amodName++------------------------------------------------------------------------+-- 'IsNoName' and 'Null' instances (checking for "_")+------------------------------------------------------------------------++-- | An abstract name is empty if its concrete name is empty.+instance IsNoName Name where+ isNoName = isNoName . nameConcrete++instance IsNoName ModuleName where+ isNoName (MName xs) = all isNoName xs++instance Null Name where+ empty = Name empty empty empty empty empty empty+ null = isNoName++instance Null QName where+ empty = QName empty empty+ null (QName m x) = null m && null x++instance Null Suffix where+ empty = NoSuffix++instance Null NameMetadata where+ empty = NameMetadata empty empty+ null (NameMetadata m i) = null m && null i++------------------------------------------------------------------------+-- 'NumHoles' instances+------------------------------------------------------------------------++instance NumHoles Name where+ numHoles = numHoles . nameConcrete++instance NumHoles QName where+ numHoles = numHoles . qnameName++-- | We can have an instance for ambiguous names as all share a common concrete name.+instance NumHoles AmbiguousQName where+ numHoles = numHoles . headAmbQ++------------------------------------------------------------------------+-- Name lenses+------------------------------------------------------------------------++lensQNameName :: Lens' QName Name+lensQNameName f (QName m n) = QName m <$> f n++-- | Van Laarhoven lens on 'anameName'.+lensAnameName :: Lens' AbstractName QName+lensAnameName f am = f (anameName am) <&> \ m -> am { anameName = m }++-- | Van Laarhoven lens on 'amodName'.+lensAmodName :: Lens' AbstractModule ModuleName+lensAmodName f am = f (amodName am) <&> \ m -> am { amodName = m }++------------------------------------------------------------------------+-- LensFixity' instances+------------------------------------------------------------------------++instance LensFixity' Name where+ lensFixity' f n = f (nameFixity n) <&> \ fix' -> n { nameFixity = fix' }++instance LensFixity' QName where+ lensFixity' = lensQNameName . lensFixity'++------------------------------------------------------------------------+-- LensFixity instances+------------------------------------------------------------------------++instance LensFixity Name where+ lensFixity = lensFixity' . lensFixity++instance LensFixity QName where+ lensFixity = lensFixity' . lensFixity++instance LensFixity AbstractName where+ lensFixity = lensAnameName . lensFixity++------------------------------------------------------------------------+-- LensInScope instances+------------------------------------------------------------------------++instance LensInScope Name where+ lensInScope f n@Name{ nameConcrete = x } =+ (\y -> n { nameConcrete = y }) <$> lensInScope f x++instance LensInScope QName where+ lensInScope f q@QName{ qnameName = n } =+ (\n' -> q { qnameName = n' }) <$> lensInScope f n++------------------------------------------------------------------------+-- | Show instances (only for debug printing!)+--+-- Use 'prettyShow' to print names to the user.+------------------------------------------------------------------------++deriving instance Show Name+deriving instance Show ModuleName+deriving instance Show QName+deriving instance Show a => Show (QNamed a)+deriving instance Show AmbiguousQName++-- | Useful for debugging scoping problems+uglyShowName :: Name -> String+uglyShowName x = show (nameId x, nameConcrete x)++------------------------------------------------------------------------+-- Pretty instances+------------------------------------------------------------------------++instance Pretty Name where+ pretty n = pretty (nameConcrete n) `definedAt` (nameBindingSite n)++instance Pretty ModuleName where+ pretty = hcat . punctuate "." . map pretty . mnameToList++instance Pretty QName where+ pretty = hcat . punctuate "." . map pretty . qnameToList0 . useCanonical+ where+ -- #4735: When printing a fully qualified name (as done by primShowQName) we need to+ -- use the origincal concrete name, not the possibly renamed concrete name in 'nameConcrete'.+ useCanonical q = q { qnameName = (qnameName q) { nameConcrete = nameCanonical (qnameName q) } }++instance Pretty AmbiguousQName where+ pretty qs = hcat $ punctuate " | " $ fmap pretty $ getAmbiguous qs++instance Pretty a => Pretty (QNamed a) where+ pretty (QNamed a b) = pretty a <> "." <> pretty b++instance Pretty Suffix where+ pretty NoSuffix = mempty+ pretty (Suffix i) = text (show i)++instance Pretty AbstractName where+ pretty = pretty . anameName++instance Pretty AbstractModule where+ pretty = pretty . amodName++------------------------------------------------------------------------+-- Range instances+------------------------------------------------------------------------++-- HasRange+ instance HasRange Name where getRange = getRange . nameConcrete +instance HasRange ModuleName where+ getRange (MName []) = noRange+ getRange (MName xs) = getRange xs+ instance HasRange QName where getRange q = getRange (qnameModule q, qnameName q) +-- | The range of an @AmbiguousQName@ is the range of any of its+-- disambiguations (they are the same concrete name).+instance HasRange AmbiguousQName where+ getRange = getRange . headAmbQ++instance HasRange AmbQNameEntry where+ getRange = \case+ AmbQName x -> getRange x+ AmbAbstractName x -> getRange x++-- SetRange+ instance SetRange Name where setRange r x = x { nameConcrete = setRange r $ nameConcrete x } @@ -246,24 +718,102 @@ } instance SetRange ModuleName where- setRange r (MName ns) = MName (map (setRange r) ns)+ setRange r (MName ns) = MName (zipWith setRange rs ns)+ where+ -- Put the range only on the last name. Otherwise+ -- we get overlapping jump-to-definition links for all+ -- the parts (See #2666).+ rs = replicate (length ns - 1) noRange ++ [r] -instance KillRange QName where- killRange q = q { qnameModule = killRange $ qnameModule q- , qnameName = killRange $ qnameName q- }+-- KillRange instance KillRange Name where- killRange x = x { nameConcrete = killRange $ nameConcrete x }+ killRange (Name a b c d e f) =+ (killRangeN Name a b c d e f) { _nameBindingSite = d }+ -- Andreas, 2017-07-25, issue #2649+ -- Preserve the nameBindingSite for error message.+ --+ -- Older remarks:+ --+ -- Andreas, 2014-03-30+ -- An experiment: what happens if we preserve+ -- the range of the binding site, but kill all+ -- other ranges before serialization?+ --+ -- Andreas, Makoto, 2014-10-18 AIM XX+ -- Kill all ranges in signature, including nameBindingSite. instance KillRange ModuleName where killRange (MName xs) = MName $ killRange xs +instance KillRange QName where+ killRange (QName a b) = killRangeN QName a b+ -- killRange q = q { qnameModule = killRange $ qnameModule q+ -- , qnameName = killRange $ qnameName q+ -- }+ instance KillRange AmbiguousQName where killRange (AmbQ xs) = AmbQ $ killRange xs +instance KillRange AmbQNameEntry where+ killRange = \case+ AmbQName x -> killRangeN AmbQName x+ AmbAbstractName x -> killRangeN AmbAbstractName x++instance KillRange AbstractName where+ killRange (AbsName a b c d) = killRangeN AbsName a b c d++instance KillRange KindOfName where+ killRange = id++instance KillRange WhyInScope where+ killRange = \case+ Defined -> Defined+ Opened a b -> killRangeN Opened a b+ Applied a b -> killRangeN Applied a b++instance KillRange NameMetadata where+ killRange = \case+ NameMetadata a b -> killRangeN NameMetadata a b+++-- AbstractName++instance HasRange AbstractName where+ getRange = getRange . anameName++instance SetRange AbstractName where+ setRange r x = x { anameName = setRange r $ anameName x }++------------------------------------------------------------------------+-- Sized instances+------------------------------------------------------------------------+ instance Sized QName where size = size . qnameToList+ natSize = natSize . qnameToList instance Sized ModuleName where size = size . mnameToList+ natSize = natSize . mnameToList++------------------------------------------------------------------------+-- NFData instances+------------------------------------------------------------------------++-- | The range is not forced.++instance NFData Name where+ rnf (Name _ a b _ c d) = rnf (a, b, c, d)++instance NFData Suffix where+ rnf NoSuffix = ()+ rnf (Suffix _) = ()++instance NFData AbstractModule+instance NFData AbstractName+instance NFData AmbQNameEntry+instance NFData KindOfName+instance NFData NameMetadata+instance NFData QName+instance NFData WhyInScope
@@ -0,0 +1,512 @@++-- | Auxiliary functions to handle patterns in the abstract syntax.+--+-- Generic and specific traversals.++module Agda.Syntax.Abstract.Pattern where++import Prelude hiding (null)++import Control.Monad ( (>=>) )+import Control.Monad.Identity ( Identity(..), runIdentity )+import Control.Monad.Reader ( Reader, runReader, asks, local )+import Control.Applicative ( liftA2 )++import Data.Maybe+import Data.Monoid+import Data.Void (Void)++import Agda.Syntax.Abstract as A+import Agda.Syntax.Common+import Agda.Syntax.Concrete (FieldAssignment')+import qualified Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Pattern (IsWithP(..))+import Agda.Syntax.Info+import Agda.Syntax.Position++import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.Tuple ( (***), second )++import Agda.Utils.Impossible++-- * Generic traversals+------------------------------------------------------------------------++type NAP = NamedArg Pattern++class MapNamedArgPattern a where+ mapNamedArgPattern :: (NAP -> NAP) -> a -> a++ default mapNamedArgPattern+ :: (Functor f, MapNamedArgPattern a', a ~ f a') => (NAP -> NAP) -> a -> a+ mapNamedArgPattern = fmap . mapNamedArgPattern++instance MapNamedArgPattern NAP where+ mapNamedArgPattern f p =+ case namedArg p of+ -- no sub patterns:+ VarP{} -> f p+ WildP{} -> f p+ DotP{} -> f p+ EqualP{} -> f p+ LitP{} -> f p+ AbsurdP{} -> f p+ ProjP{} -> f p+ -- list of NamedArg subpatterns:+ ConP i qs ps -> f $ setNamedArg p $ ConP i qs $ mapNamedArgPattern f ps+ DefP i qs ps -> f $ setNamedArg p $ DefP i qs $ mapNamedArgPattern f ps+ PatternSynP i x ps -> f $ setNamedArg p $ PatternSynP i x $ mapNamedArgPattern f ps+ -- Pattern subpattern(s):+ -- RecP: we copy the NamedArg info to the subpatterns but discard it after recursion+ RecP kwr i fs -> f $ setNamedArg p $ RecP kwr i $ map (fmap namedArg) $ mapNamedArgPattern f $ map (fmap (setNamedArg p)) fs+ -- AsP: we hand the NamedArg info to the subpattern+ AsP i x p0 -> f $ updateNamedArg (AsP i x) $ mapNamedArgPattern f $ setNamedArg p p0+ -- WithP: like AsP+ WithP i p0 -> f $ updateNamedArg (WithP i) $ mapNamedArgPattern f $ setNamedArg p p0++instance MapNamedArgPattern a => MapNamedArgPattern [a] where+instance MapNamedArgPattern a => MapNamedArgPattern (FieldAssignment' a) where+instance MapNamedArgPattern a => MapNamedArgPattern (Maybe a) where++instance (MapNamedArgPattern a, MapNamedArgPattern b) => MapNamedArgPattern (a,b) where+ mapNamedArgPattern f (a, b) = (mapNamedArgPattern f a, mapNamedArgPattern f b)++-- | Generic pattern traversal.++class APatternLike p where+ type ADotT p++ -- | Fold pattern.+ foldrAPattern+ :: Monoid m+ => (Pattern' (ADotT p) -> m -> m)+ -- ^ Combine a pattern and the value computed from its subpatterns.+ -> p -> m++ default foldrAPattern+ :: (Monoid m, Foldable f, APatternLike b, (ADotT p) ~ (ADotT b), f b ~ p)+ => (Pattern' (ADotT p) -> m -> m) -> p -> m+ foldrAPattern = foldMap . foldrAPattern++ -- | Traverse pattern.+ traverseAPatternM+ :: Monad m+ => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -- ^ @pre@: Modification before recursion.+ -> (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -- ^ @post@: Modification after recursion.+ -> p -> m p++ default traverseAPatternM+ :: (Traversable f, APatternLike q, (ADotT p) ~ (ADotT q), f q ~ p, Monad m)+ => (Pattern' (ADotT p) -> m (Pattern' (ADotT p)))+ -> (Pattern' (ADotT p) -> m (Pattern' (ADotT p)))+ -> p -> m p+ traverseAPatternM pre post = traverse $ traverseAPatternM pre post++-- | Compute from each subpattern a value and collect them all in a monoid.++foldAPattern :: (APatternLike p, Monoid m) => (Pattern' (ADotT p) -> m) -> p -> m+foldAPattern f = foldrAPattern $ \ p m -> f p `mappend` m++-- | Traverse pattern(s) with a modification before the recursive descent.++preTraverseAPatternM+ :: (APatternLike p, Monad m )+ => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -- ^ @pre@: Modification before recursion.+ -> p -> m p+preTraverseAPatternM pre p = traverseAPatternM pre return p++-- | Traverse pattern(s) with a modification after the recursive descent.++postTraverseAPatternM+ :: (APatternLike p, Monad m )+ => (Pattern' (ADotT p) -> m (Pattern' (ADotT p))) -- ^ @post@: Modification after recursion.+ -> p -> m p+postTraverseAPatternM post p = traverseAPatternM return post p++-- | Map pattern(s) with a modification after the recursive descent.++mapAPattern :: APatternLike p => (Pattern' (ADotT p) -> Pattern' (ADotT p)) -> p -> p+mapAPattern f = runIdentity . postTraverseAPatternM (Identity . f)++-- Interesting instance:++instance APatternLike (Pattern' a) where+ type ADotT (Pattern' a) = a++ foldrAPattern f p = f p $+ case p of+ AsP _ _ p -> foldrAPattern f p+ ConP _ _ ps -> foldrAPattern f ps+ DefP _ _ ps -> foldrAPattern f ps+ RecP _ _ ps -> foldrAPattern f ps+ PatternSynP _ _ ps -> foldrAPattern f ps+ WithP _ p -> foldrAPattern f p+ VarP _ -> mempty+ ProjP _ _ _ -> mempty+ WildP _ -> mempty+ DotP _ _ -> mempty+ AbsurdP _ -> mempty+ LitP _ _ -> mempty+ EqualP _ _ -> mempty++ traverseAPatternM pre post = pre >=> recurse >=> post+ where+ recurse = \case+ -- Non-recursive cases:+ p@A.VarP{} -> return p+ p@A.WildP{} -> return p+ p@A.DotP{} -> return p+ p@A.LitP{} -> return p+ p@A.AbsurdP{} -> return p+ p@A.ProjP{} -> return p+ p@A.EqualP{} -> return p+ -- Recursive cases:+ A.ConP i ds ps -> A.ConP i ds <$> traverseAPatternM pre post ps+ A.DefP i q ps -> A.DefP i q <$> traverseAPatternM pre post ps+ A.AsP i x p -> A.AsP i x <$> traverseAPatternM pre post p+ A.RecP kwr i ps -> A.RecP kwr i <$> traverseAPatternM pre post ps+ A.PatternSynP i x ps -> A.PatternSynP i x <$> traverseAPatternM pre post ps+ A.WithP i p -> A.WithP i <$> traverseAPatternM pre post p++instance APatternLike a => APatternLike (Arg a) where+ type ADotT (Arg a) = ADotT a++instance APatternLike a => APatternLike (Named n a) where+ type ADotT (Named n a) = ADotT a++instance APatternLike a => APatternLike [a] where+ type ADotT [a] = ADotT a++instance APatternLike a => APatternLike (Maybe a) where+ type ADotT (Maybe a) = ADotT a++instance APatternLike a => APatternLike (FieldAssignment' a) where+ type ADotT (FieldAssignment' a) = ADotT a++instance (APatternLike a, APatternLike b, ADotT a ~ ADotT b) => APatternLike (a, b) where+ type ADotT (a, b) = ADotT a++ foldrAPattern f (p, p') =+ foldrAPattern f p `mappend` foldrAPattern f p'++ traverseAPatternM pre post (p, p') =+ liftA2 (,)+ (traverseAPatternM pre post p)+ (traverseAPatternM pre post p')+++-- * Specific folds+------------------------------------------------------------------------++-- | Collect pattern variables in left-to-right textual order.++patternVars :: APatternLike p => p -> [A.Name]+patternVars p = foldAPattern f p `appEndo` []+ where+ -- We use difference lists @[A.Name] -> [A.Name]@ to avoid reconcatenation.+ f :: Pattern' a -> Endo [A.Name]+ f = \case+ A.VarP x -> Endo (unBind x :)+ A.AsP _ x _ -> Endo (unBind x :)+ A.LitP {} -> mempty+ A.ConP {} -> mempty+ A.RecP {} -> mempty+ A.DefP {} -> mempty+ A.ProjP {} -> mempty+ A.WildP {} -> mempty+ A.DotP {} -> mempty+ A.AbsurdP {} -> mempty+ A.EqualP {} -> mempty+ A.PatternSynP {} -> mempty+ A.WithP _ _ -> mempty++-- | Check if a pattern contains a specific (sub)pattern.++containsAPattern :: APatternLike p => (Pattern' (ADotT p) -> Bool) -> p -> Bool+containsAPattern f = getAny . foldAPattern (Any . f)++-- | Check if a pattern contains an absurd pattern.+-- For instance, @suc ()@, does so.+--+-- Precondition: contains no pattern synonyms.++containsAbsurdPattern :: APatternLike p => p -> Bool+containsAbsurdPattern = containsAPattern $ \case+ A.PatternSynP{} -> __IMPOSSIBLE__+ A.AbsurdP{} -> True+ _ -> False++-- | Check if a pattern contains an @-pattern.+--+containsAsPattern :: APatternLike p => p -> Bool+containsAsPattern = containsAPattern $ \case+ A.AsP{} -> True+ _ -> False++-- | Check if any user-written pattern variables occur more than once,+-- and throw the given error if they do.+checkPatternLinearity :: (Monad m, APatternLike p)+ => p -> (List1 C.Name -> m ()) -> m ()+checkPatternLinearity =+ List1.unlessNull . duplicates . map nameConcrete . patternVars+++-- * Specific traversals+------------------------------------------------------------------------++-- | Pattern substitution.+--+-- For the embedded expression, the given pattern substitution is turned into+-- an expression substitution.++substPattern :: [(Name, Pattern)] -> Pattern -> Pattern+substPattern s = substPattern' (substExpr $ map (second patternToExpr) s) s++-- | Pattern substitution, parametrized by substitution function for embedded expressions.++substPattern'+ :: (e -> e) -- ^ Substitution function for expressions.+ -> [(Name, Pattern' e)] -- ^ (Parallel) substitution.+ -> Pattern' e -- ^ Input pattern.+ -> Pattern' e+substPattern' subE s = mapAPattern $ \ p -> case p of+ VarP x -> fromMaybe p $ lookup (A.unBind x) s+ DotP i e -> DotP i $ subE e+ EqualP i es -> EqualP i $ fmap (subE *** subE) es+ -- No action on the other patterns (besides the recursion):+ ConP _ _ _ -> p+ RecP _ _ _ -> p+ ProjP _ _ _ -> p+ WildP _ -> p+ AbsurdP _ -> p+ LitP _ _ -> p+ DefP _ _ _ -> p+ AsP _ _ _ -> p -- Note: cannot substitute into as-variable+ PatternSynP _ _ _ -> p+ WithP _ _ -> p++-- | Convert a pattern to an expression.+--+-- Does not support all cases of patterns.+-- Result has no 'Range' info, except in identifiers.+--+-- This function is only used in expanding pattern synonyms+-- and in "Agda.Syntax.Translation.InternalToAbstract",+-- so we can cut some corners.+patternToExpr :: Pattern -> Expr+patternToExpr p = patToExpr p `runReader` empty++-- | Converting a pattern to an expression.+--+-- The 'Hiding' context is remembered to create instance metas+-- when translating absurd patterns in instance position.+--+class PatternToExpr p e where+ patToExpr :: p -> Reader Hiding e++ default patToExpr :: (Traversable t, PatternToExpr p' e', p ~ t p', e ~ t e')+ => p -> Reader Hiding e+ patToExpr = traverse patToExpr++instance PatternToExpr p e => PatternToExpr [p] [e]+instance PatternToExpr p e => PatternToExpr (Named n p) (Named n e)+instance PatternToExpr p e => PatternToExpr (FieldAssignment' p) (FieldAssignment' e)++instance PatternToExpr p e => PatternToExpr (Arg p) (Arg e) where+ patToExpr (Arg ai p) = local (const $ getHiding ai) $ Arg ai <$> patToExpr p++instance PatternToExpr Pattern Expr where+ patToExpr = \case+ VarP x -> return $ Var (unBind x)+ ConP _ c ps -> app (Con c) <$> patToExpr ps+ ProjP _ o ds -> return $ Proj o ds+ DefP _ fs ps -> app (Def $ headAmbQ fs) <$> patToExpr ps+ WildP _ -> return $ Underscore emptyMetaInfo+ AsP _ _ p -> patToExpr p+ DotP _ e -> return e+ -- Issue #7176: An absurd pattern in an instance position should turn into an instance meta:+ AbsurdP _ -> asks hidingToMetaKind <&> \ k -> Underscore emptyMetaInfo{ metaKind = k }+ LitP _ l -> return $ Lit empty l+ PatternSynP _ c ps -> app (PatternSyn c) <$> patToExpr ps+ RecP kwr _ as -> Rec kwr exprNoRange . map Left <$> patToExpr as+ EqualP{} -> __IMPOSSIBLE__ -- Andrea TODO: where is this used?+ WithP r p -> __IMPOSSIBLE__++-- | Make sure that there are no dot or equality patterns (called on pattern synonyms).+-- Also disallows annotated patterns.+--+noDotOrEqPattern :: forall m e. Monad m+ => m (A.Pattern' Void) -- ^ Exception or replacement for dot (etc.) patterns.+ -> A.Pattern' e -- ^ In pattern.+ -> m (A.Pattern' Void) -- ^ Out pattern.+noDotOrEqPattern err = dot+ where+ dot :: A.Pattern' e -> m (A.Pattern' Void)+ dot = \case+ A.VarP x -> pure $ A.VarP x+ A.ConP i c args -> A.ConP i c <$> (traverse $ traverse $ traverse dot) args+ A.ProjP i o d -> pure $ A.ProjP i o d+ A.WildP i -> pure $ A.WildP i+ A.AsP i x p -> A.AsP i x <$> dot p+ A.DotP{} -> err+ A.EqualP{} -> err -- Andrea: so we also disallow = patterns, reasonable?+ A.AbsurdP i -> pure $ A.AbsurdP i+ A.LitP i l -> pure $ A.LitP i l+ A.DefP i f args -> A.DefP i f <$> (traverse $ traverse $ traverse dot) args+ A.PatternSynP i c args -> A.PatternSynP i c <$> (traverse $ traverse $ traverse dot) args+ A.RecP kwr i fs -> A.RecP kwr i <$> (traverse $ traverse dot) fs+ A.WithP i p -> A.WithP i <$> dot p+++-- * Other pattern utilities+------------------------------------------------------------------------++-- | Check for with-pattern.+instance IsWithP (Pattern' e) where+ isWithP = \case+ WithP _ p -> Just p+ _ -> Nothing++-- | Split patterns into (patterns, trailing with-patterns).+splitOffTrailingWithPatterns :: A.Patterns -> (A.Patterns, A.Patterns)+splitOffTrailingWithPatterns = spanEnd (isJust . isWithP)++-- | Get the tail of with-patterns of a pattern spine.+trailingWithPatterns :: Patterns -> Patterns+trailingWithPatterns = snd . splitOffTrailingWithPatterns++-- | The next patterns are ...+--+-- (This view discards 'PatInfo'.)+data LHSPatternView e+ = LHSAppP (NAPs1 e)+ -- ^ Application patterns (non-empty list).+ | LHSProjP ProjOrigin AmbiguousQName (NamedArg (Pattern' e))+ -- ^ A projection pattern. Is also stored unmodified here.+ | LHSWithP (List1 (Pattern' e))+ -- ^ With patterns (non-empty list).+ -- These patterns are not prefixed with 'WithP'.+ deriving (Show)++-- | Construct the 'LHSPatternView' of the given list (if not empty).+--+-- Return the view and the remaining patterns.++lhsPatternView :: NAPs e -> Maybe (LHSPatternView e, NAPs e)+lhsPatternView [] = Nothing+lhsPatternView (p0 : ps) =+ case namedArg p0 of+ ProjP _i o d -> Just (LHSProjP o d p0, ps)+ -- If the next pattern is a with-pattern, collect more with-patterns+ WithP _i p -> Just (LHSWithP (p :| map namedArg ps1), ps2)+ where+ (ps1, ps2) = spanJust isWithP ps+ -- If the next pattern is an application pattern, collect more of these+ _ -> Just (LHSAppP (p0 :| ps1), ps2)+ where+ (ps1, ps2) = span (\ p -> isNothing (isProjP p) && isNothing (isWithP p)) ps++-- * Left-hand-side manipulation+------------------------------------------------------------------------++-- | Convert a focused lhs to spine view and back.+class LHSToSpine a b where+ lhsToSpine :: a -> b+ spineToLhs :: b -> a++-- | Clause instance.+instance LHSToSpine Clause SpineClause where+ lhsToSpine = fmap lhsToSpine+ spineToLhs = fmap spineToLhs++-- | List instance (for clauses).+instance LHSToSpine a b => LHSToSpine [a] [b] where+ lhsToSpine = map lhsToSpine+ spineToLhs = map spineToLhs++-- | LHS instance.+instance LHSToSpine LHS SpineLHS where+ lhsToSpine (LHS i core) = SpineLHS i f ps+ where QNamed f ps = lhsCoreToSpine core+ spineToLhs (SpineLHS i f ps) = LHS i (spineToLhsCore $ QNamed f ps)++lhsCoreToSpine :: LHSCore' e -> A.QNamed [NamedArg (Pattern' e)]+lhsCoreToSpine = \case+ LHSHead f ps -> QNamed f ps+ LHSProj d h ps -> lhsCoreToSpine (namedArg h) <&> (++ (p : ps))+ where p = updateNamedArg (const $ ProjP empty ProjPrefix d) h+ LHSWith h wps ps -> lhsCoreToSpine h <&> (++ map fromWithPat (List1.toList wps) ++ ps)+ where+ fromWithPat :: Arg (Pattern' e) -> NamedArg (Pattern' e)+ fromWithPat = fmap (unnamed . mkWithP)+ mkWithP p = WithP (PatRange $ getRange p) p++spineToLhsCore :: IsProjP e => QNamed [NamedArg (Pattern' e)] -> LHSCore' e+spineToLhsCore (QNamed f ps) = lhsCoreAddSpine (LHSHead f []) ps++-- | Add applicative patterns (non-projection / non-with patterns) to the right.+lhsCoreApp :: LHSCore' e -> [NamedArg (Pattern' e)] -> LHSCore' e+lhsCoreApp core ps = core { lhsPats = lhsPats core ++ ps }++-- | Add with-patterns to the right.+lhsCoreWith :: LHSCore' e -> List1 (Arg (Pattern' e)) -> LHSCore' e+lhsCoreWith (LHSWith core wps []) wps' = LHSWith core (wps <> wps') []+lhsCoreWith core wps' = LHSWith core wps' []++lhsCoreAddChunk :: LHSCore' e -> LHSPatternView e -> LHSCore' e+lhsCoreAddChunk core = \case+ LHSAppP ps -> lhsCoreApp core $ List1.toList ps+ LHSWithP wps -> lhsCoreWith core (defaultArg <$> wps)+ LHSProjP ProjPrefix d np -> LHSProj d (setNamedArg np core) [] -- Prefix projection pattern.+ LHSProjP _ _ np -> lhsCoreApp core (singleton np) -- Postfix projection pattern.++-- | Add projection, with, and applicative patterns to the right.+lhsCoreAddSpine :: IsProjP e => LHSCore' e -> [NamedArg (Pattern' e)] -> LHSCore' e+lhsCoreAddSpine core ps =+ -- Recurse on lhsPatternView until no patterns left.+ case lhsPatternView ps of+ Nothing -> core+ Just (v, ps') -> lhsCoreAddChunk core chunk `lhsCoreAddSpine` ps'+ where+ -- Andreas, 2016-06-13+ -- If the projection was written prefix by the user+ -- or it is a fully applied operator+ -- we turn it to prefix projection form.+ chunk = case v of+ LHSProjP ProjPrefix _ _+ -> v+ LHSProjP _ d np | let nh = C.numHoles d, nh > 0, nh <= 1 + length ps'+ -> LHSProjP ProjPrefix d np+ _ -> v++-- | Used for checking pattern linearity.+lhsCoreAllPatterns :: LHSCore' e -> [Pattern' e]+lhsCoreAllPatterns = map namedArg . qnamed . lhsCoreToSpine++-- | Used in ''Agda.Syntax.Translation.AbstractToConcrete''.+-- Returns a 'DefP'.+lhsCoreToPattern :: LHSCore -> Pattern+lhsCoreToPattern lc =+ case lc of+ LHSHead f aps -> DefP noInfo (unambiguous f) aps+ LHSProj d lhscore aps -> DefP noInfo d $+ fmap (fmap lhsCoreToPattern) lhscore : aps+ LHSWith h wps aps -> case lhsCoreToPattern h of+ DefP r q ps -> DefP r q $ ps ++ map fromWithPat (List1.toList wps) ++ aps+ where+ fromWithPat :: Arg Pattern -> NamedArg Pattern+ fromWithPat = fmap (unnamed . mkWithP)+ mkWithP p = WithP (PatRange $ getRange p) p+ _ -> __IMPOSSIBLE__+ where noInfo = empty -- TODO, preserve range!++mapLHSHead :: (QName -> [NamedArg Pattern] -> LHSCore) -> LHSCore -> LHSCore+mapLHSHead f = \case+ LHSHead x ps -> f x ps+ LHSProj d h ps -> LHSProj d (fmap (fmap (mapLHSHead f)) h) ps+ LHSWith h wps ps -> LHSWith (mapLHSHead f h) wps ps
@@ -0,0 +1,91 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Pattern synonym utilities: folding pattern synonym definitions for+-- printing and merging pattern synonym definitions to handle overloaded+-- pattern synonyms.+module Agda.Syntax.Abstract.PatternSynonyms+ ( matchPatternSyn+ , matchPatternSynP+ , mergePatternSynDefs+ ) where++import Control.Applicative ( Alternative(empty) )+import Control.Monad ( foldM, guard, zipWithM, zipWithM_ )+import Control.Monad.Writer ( MonadWriter(..), WriterT, execWriterT )++import Data.Map (Map)+import qualified Data.Map as Map+import Data.Traversable (forM)+import Data.Void++import Agda.Syntax.Common+import Agda.Syntax.Abstract+import Agda.Syntax.Abstract.Views++import Agda.Utils.List1 (List1, pattern (:|))++-- | Merge a list of pattern synonym definitions. Fails unless all definitions+-- have the same shape (i.e. equal up to renaming of variables and constructor+-- names).+mergePatternSynDefs :: List1 PatternSynDefn -> Maybe PatternSynDefn+mergePatternSynDefs (def :| defs) = foldM mergeDef def defs++mergeDef :: PatternSynDefn -> PatternSynDefn -> Maybe PatternSynDefn+mergeDef (PatternSynDefn xs p) (PatternSynDefn ys q) = do+ -- Ensure that the parameter lists are equal up to renaming.+ guard $ map whHiding xs == map whHiding ys+ PatternSynDefn xs <$> merge p q+ where+ ren = zip (map whThing xs) (map whThing ys)++ merge :: Pattern' e -> Pattern' e -> Maybe (Pattern' e)+ merge p@(VarP x) (VarP y) = p <$ guard ((unBind x, unBind y) `elem` ren)+ merge p@(LitP _ l) (LitP _ l') = p <$ guard (l == l')+ merge p@(WildP _) (WildP _) = return p+ merge (ConP i ambC ps) (ConP _ ambC' qs) = do+ guard $ map getArgInfo ps == map getArgInfo qs+ ConP i (mergeAmbQ ambC ambC') <$> zipWithM mergeArg ps qs+ merge _ _ = empty++ mergeArg :: NamedArg (Pattern' e) -> NamedArg (Pattern' e) -> Maybe (NamedArg (Pattern' e))+ mergeArg p q = setNamedArg p <$> merge (namedArg p) (namedArg q)++-- | Match an expression against a pattern synonym.+matchPatternSyn :: PatternSynDefn -> Expr -> Maybe [WithHiding Expr]+matchPatternSyn = runMatch match+ where+ match :: Pattern' e -> Expr -> WriterT (Map Name Expr) Maybe ()+ match (VarP x) e = x ==> e+ match (LitP _ l) (Lit _ l') = guard (l == l')+ match (ConP _ x ps) e = do+ Application (Con x') args <- return (appView e)+ guard $ allPossibleConstructorsAppearInSynonym x x' -- check all possible constructors appear in the synonym+ guard $ map getArgInfo ps == map getArgInfo args -- check that we agree on the hiding (TODO: too strict?)+ zipWithM_ match (map namedArg ps) (map namedArg args)+ match _ _ = empty++-- | Match a pattern against a pattern synonym.+matchPatternSynP :: PatternSynDefn -> Pattern' e -> Maybe [WithHiding (Pattern' e)]+matchPatternSynP = runMatch match+ where+ match (VarP x) q = x ==> q+ match (LitP _ l) (LitP _ l') = guard (l == l')+ match (WildP _) (WildP _) = return ()+ match (ConP _ x ps) (ConP _ x' qs) = do+ guard $ allPossibleConstructorsAppearInSynonym x x'+ guard $ map getArgInfo ps == map getArgInfo qs+ zipWithM_ match (map namedArg ps) (map namedArg qs)+ match _ _ = empty++allPossibleConstructorsAppearInSynonym :: AmbiguousQName -> AmbiguousQName -> Bool+allPossibleConstructorsAppearInSynonym x x' = all (`elem` getAmbiguous x) (getAmbiguous x')++type Match e = WriterT (Map Name e) Maybe++(==>) :: BindName -> e -> Match e ()+x ==> e = tell (Map.singleton (unBind x) e)++runMatch :: (Pattern' Void -> e -> Match e ()) -> PatternSynDefn -> e -> Maybe [WithHiding e]+runMatch match (PatternSynDefn xs pat) e = do+ sub <- execWriterT (match pat e)+ forM xs $ \ x -> (<$ x) <$> Map.lookup (whThing x) sub
@@ -1,27 +1,31 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Syntax.Abstract.Pretty where -import Control.Applicative--import Agda.Syntax.Abstract-import Agda.Syntax.Concrete.Pretty () import Agda.Syntax.Fixity import Agda.Syntax.Translation.AbstractToConcrete-import Agda.TypeChecking.Monad-import Agda.Utils.Pretty+import Agda.Syntax.Common.Pretty -showA :: (Show c, ToConcrete a c) => a -> TCM String+showA :: (ToConcrete a, Show (ConOfAbs a), MonadAbsToCon m) => a -> m String showA x = show <$> abstractToConcrete_ x -prettyA :: (Pretty c, ToConcrete a c) => a -> TCM Doc+prettyA :: (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) => a -> m Doc prettyA x = pretty <$> abstractToConcrete_ x +prettyAs :: (ToConcrete a, ConOfAbs a ~ [ce], Pretty ce, MonadAbsToCon m) => a -> m Doc+prettyAs x = fsep . map pretty <$> abstractToConcreteCtx (ArgumentCtx PreferParen) x+ -- | Variant of 'showA' which does not insert outermost parentheses. -showATop :: (Show c, ToConcrete a c) => a -> TCM String+showATop :: (ToConcrete a, Show (ConOfAbs a), MonadAbsToCon m) => a -> m String showATop x = show <$> abstractToConcreteCtx TopCtx x -- | Variant of 'prettyA' which does not insert outermost parentheses. -prettyATop :: (Pretty c, ToConcrete a c) => a -> TCM Doc+prettyATop :: (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) => a -> m Doc prettyATop x = pretty <$> abstractToConcreteCtx TopCtx x++-- | Variant of 'prettyA' which unqualifies out-of-scope names.++prettyAUnqualify :: (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) => a -> m Doc+prettyAUnqualify x = pretty <$> abstractToConcreteUnqualify x
@@ -0,0 +1,186 @@++module Agda.Syntax.Abstract.UsedNames+ ( allUsedNames+ , allBoundNames+ ) where++import Data.Foldable (foldMap)+import Data.Set (Set)+import qualified Data.Set as Set++import Agda.Syntax.Common+import Agda.Syntax.Abstract+import Agda.Syntax.Concrete (FieldAssignment'(..))+import Agda.Utils.List1 (List1)++import Agda.Utils.Impossible++-- | All names used in an abstract expression. This is used when rendering clauses to figure out+-- which (implicit) pattern variables must be preserved. For example, the for @f : Nat → Nat@, the+-- clause @f {n} = 0@ can be printed as @f = 0@ (dropping the @n@), but @f {n} = n@ must preserve+-- the @n@.+allUsedNames :: Expr -> Set Name+allUsedNames = usedNames . boundAndUsed++allBoundNames :: BoundAndUsed a => a -> Set Name+allBoundNames = boundNames . boundAndUsed++data BoundAndUsedNames = BoundAndUsedNames+ { boundNames :: Set Name+ , usedNames :: Set Name }++-- | Bound names in first argument scope over second argument.+instance Semigroup BoundAndUsedNames where+ BoundAndUsedNames bound1 used1 <> BoundAndUsedNames bound2 used2 =+ BoundAndUsedNames (bound1 <> bound2) (used1 <> Set.difference used2 bound1)++instance Monoid BoundAndUsedNames where+ mempty = BoundAndUsedNames mempty mempty+ mappend = (<>)++singleUse :: Name -> BoundAndUsedNames+singleUse x = BoundAndUsedNames mempty (Set.singleton x)++singleBind :: Name -> BoundAndUsedNames+singleBind x = BoundAndUsedNames (Set.singleton x) mempty++noBindings :: BoundAndUsedNames -> BoundAndUsedNames+noBindings names = names{ boundNames = mempty }++-- | Bound names in first argument do *not* scope over second argument.+parB :: BoundAndUsedNames -> BoundAndUsedNames -> BoundAndUsedNames+parB (BoundAndUsedNames bound1 used1) (BoundAndUsedNames bound2 used2) =+ BoundAndUsedNames (bound1 <> bound2) (used1 <> used2)++parBindings :: (BoundAndUsed a, BoundAndUsed b) => a -> b -> BoundAndUsedNames+parBindings a b = boundAndUsed a `parB` boundAndUsed b++parBoundAndUsed :: (Foldable f, BoundAndUsed a) => f a -> BoundAndUsedNames+parBoundAndUsed = foldr parBindings mempty++class BoundAndUsed a where+ boundAndUsed :: a -> BoundAndUsedNames++ default boundAndUsed :: (a ~ f b, Foldable f, BoundAndUsed b) => a -> BoundAndUsedNames+ boundAndUsed = foldMap boundAndUsed++instance BoundAndUsed BoundAndUsedNames where+ boundAndUsed = id++instance BoundAndUsed a => BoundAndUsed (Arg a)+instance BoundAndUsed a => BoundAndUsed (Named n a)+instance BoundAndUsed a => BoundAndUsed (List1 a)+instance BoundAndUsed a => BoundAndUsed [a]+instance BoundAndUsed a => BoundAndUsed (Maybe a)++instance (BoundAndUsed a, BoundAndUsed b) => BoundAndUsed (Either a b) where+ boundAndUsed = either boundAndUsed boundAndUsed++instance BoundAndUsed ModuleName where+ boundAndUsed _ = mempty++instance (BoundAndUsed a, BoundAndUsed b) => BoundAndUsed (a, b) where+ boundAndUsed (a, b) = boundAndUsed a <> boundAndUsed b++instance BoundAndUsed Expr where+ boundAndUsed = noBindings . \ case+ Var x -> singleUse x+ Def'{} -> mempty+ Proj{} -> mempty+ Con{} -> mempty+ PatternSyn{} -> mempty+ Macro{} -> mempty+ Lit{} -> mempty+ QuestionMark{} -> mempty+ Underscore{} -> mempty+ Dot _ expr -> boundAndUsed expr+ App _ expr arg -> boundAndUsed (expr, arg)+ WithApp _ expr exprs -> boundAndUsed (expr, exprs)+ Lam _ bind expr -> boundAndUsed (bind, expr)+ AbsurdLam{} -> mempty+ ExtendedLam _ _ _ _ cs -> boundAndUsed cs+ Pi _ tel expr -> boundAndUsed (tel, expr)+ Generalized _ expr -> boundAndUsed expr+ Fun _ arg expr -> boundAndUsed (arg, expr)+ Let _ binds expr -> boundAndUsed (binds, expr)+ Rec _ _ as -> boundAndUsed as+ RecUpdate _ _ expr as -> boundAndUsed expr <> boundAndUsed as+ ScopedExpr _ expr -> boundAndUsed expr+ Quote{} -> mempty+ QuoteTerm{} -> mempty+ Unquote{} -> mempty+ DontCare expr -> boundAndUsed expr+ Qualified _ b -> boundAndUsed b+ Highlighted _ b -> boundAndUsed b++instance BoundAndUsed lhs => BoundAndUsed (Clause' lhs) where+ -- Note: where declarations are ignored. We use this only on expressions coming from+ -- InternalToAbstract where there are no where decls.+ boundAndUsed Clause{ clauseLHS = lhs, clauseRHS = rhs } = boundAndUsed (lhs, rhs)++instance BoundAndUsed RHS where+ boundAndUsed = \ case+ RHS body _ -> boundAndUsed body+ AbsurdRHS -> mempty+ WithRHS _ es cs -> boundAndUsed (es, cs)+ RewriteRHS eqns _ rhs _ -> boundAndUsed (eqns, rhs)++instance BoundAndUsed LHS where+ boundAndUsed = boundAndUsed . lhsCore++instance BoundAndUsed e => BoundAndUsed (LHSCore' e) where+ boundAndUsed = \ case+ LHSHead _ ps -> parBoundAndUsed ps+ LHSProj _ lhs ps -> lhs `parBindings` parBoundAndUsed ps+ LHSWith lhs wps ps -> lhs `parBindings` parBoundAndUsed wps+ `parBindings` parBoundAndUsed ps++instance (BoundAndUsed x, BoundAndUsed p, BoundAndUsed e) => BoundAndUsed (RewriteEqn' q x p e) where+ boundAndUsed (Rewrite es) = boundAndUsed $ snd <$> es+ boundAndUsed (Invert _ bs) = parBoundAndUsed (namedThing <$> bs) <> boundAndUsed (nameOf <$> bs)+ boundAndUsed (LeftLet bs) = boundAndUsed bs++instance BoundAndUsed LetBinding where+ boundAndUsed = \ case -- Note: binder last since it's not recursive+ LetBind _ _ x ty e -> boundAndUsed ((ty, e), x)+ LetAxiom _ _ x ty -> boundAndUsed (ty, x)+ LetPatBind _ _ p e -> boundAndUsed (e, p)+ LetApply _ _ _ app _ _ -> boundAndUsed app+ LetOpen{} -> mempty++instance BoundAndUsed LamBinding where+ boundAndUsed (DomainFree _ b) = boundAndUsed b+ boundAndUsed (DomainFull b) = boundAndUsed b++instance BoundAndUsed TypedBinding where+ boundAndUsed (TBind _ _ bs ty) = boundAndUsed (ty, bs)+ boundAndUsed (TLet _ bs) = boundAndUsed bs++instance BoundAndUsed name => BoundAndUsed (Binder' name) where+ boundAndUsed (Binder p _ x) = parBindings p x++instance BoundAndUsed BindName where+ boundAndUsed x = singleBind (unBind x)++instance BoundAndUsed e => BoundAndUsed (Pattern' e) where+ boundAndUsed = \ case+ VarP x -> boundAndUsed x+ ConP _ _ ps -> parBoundAndUsed ps+ ProjP{} -> mempty+ DefP _ _ ps -> parBoundAndUsed ps+ WildP{} -> mempty+ AsP _ x p -> parBindings x p+ DotP _ e -> boundAndUsed e+ AbsurdP{} -> mempty+ LitP{} -> mempty+ PatternSynP _ _ ps -> parBoundAndUsed ps+ RecP _ _ as -> parBoundAndUsed as+ EqualP _ eqs -> parBoundAndUsed eqs+ WithP _ p -> boundAndUsed p++instance BoundAndUsed e => BoundAndUsed (FieldAssignment' e) where+ boundAndUsed (FieldAssignment _ e) = boundAndUsed e++instance BoundAndUsed ModuleApplication where+ boundAndUsed (SectionApp tel _ es) = noBindings $ boundAndUsed (tel, es)+ boundAndUsed RecordModuleInstance{} = mempty
@@ -1,28 +1,666 @@ module Agda.Syntax.Abstract.Views where -import Agda.Syntax.Position+import Prelude hiding (null)++import Control.Applicative ( Const(Const), getConst )+import Control.Monad.Identity++import Data.Bifunctor (second)+import Data.Foldable (foldMap)+import Data.DList qualified as DL+import Data.Void+ import Agda.Syntax.Common-import Agda.Syntax.Abstract+import Agda.Syntax.Abstract as A+import Agda.Syntax.Concrete (FieldAssignment', exprFieldA, TacticAttribute') import Agda.Syntax.Info+import Agda.Syntax.Scope.Base (conKindOfName, WithKind(..)) -data AppView = Application Expr [NamedArg Expr]- -- NonApplication Expr- -- -- ^ TODO: if we allow beta-redexes (which we currently do) there could be one here.- -- 2011-08-24, Dominique: removed..+import Agda.Utils.Either+import Agda.Utils.List1 (List1)+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Null+import Agda.Utils.Singleton --- note: everything is an application, possibly of itself to 0 arguments+import Agda.Utils.Impossible++-- | An 'Expr' viewed as application.+data AppView' arg = Application Expr [NamedArg arg]+ deriving (Functor)++type AppView = AppView' Expr++-- | Gather applications to expose head and spine.+--+-- Note:+--+-- 1. Everything is an application, possibly of itself to 0 arguments.+--+-- 2. If the returned head is a projection originating from a post-fix+-- projection, the 'ArgInfo' of the first argument might be incorrect.+-- (See issue #8300.)+-- For instance @x .f@ is valid postfix syntax for @f {{x}}@,+-- but 'appView' turns the former into @f x@.+-- The correct @f {{x}}@ is produced by 'Agda.TypeChecking.Rules.Term.appViewM'. appView :: Expr -> AppView-appView e =- case e of- App i e1 arg -> apply i (appView e1) arg- ScopedExpr _ e -> appView e- _ -> Application e []- where- apply i v arg =- case v of- Application hd es -> Application hd $ es ++ [arg]+appView = fmap snd . appView' +appView' :: Expr -> AppView' (AppInfo, Expr)+appView' e = f (DL.toList es)+ where+ (f, es) = go e+ go = \case+ App i e1 e2+ | Dot _ e2' <- unScope $ namedArg e2+ , Just (_, f) <- maybeProjTurnPostfix e2'+ , getHiding e2 == NotHidden -- Jesper, 2018-12-13: postfix projections shouldn't be hidden+ -> (Application f, singleton (defaultNamedArg (i, e1)))+ App i e1 arg | (f, es) <- go e1 ->+ (f, es `DL.snoc` (fmap . fmap) (i,) arg)+ ScopedExpr _ e -> go e+ e -> (Application e, mempty)++maybeProjTurnPostfix :: Expr -> Maybe (AmbiguousQName, Expr)+maybeProjTurnPostfix e =+ case e of+ ScopedExpr i e' -> second (ScopedExpr i) <$> maybeProjTurnPostfix e'+ Proj _ x -> return (x, Proj ProjPostfix x)+ _ -> Nothing+ unAppView :: AppView -> Expr unAppView (Application h es) =- foldl (App (ExprRange noRange)) h es+ foldl (App defaultAppInfo_) h es++-- | Collects plain lambdas.+data LamView = LamView [LamBinding] Expr++lamView :: Expr -> LamView+lamView (Lam i b e) = cons b $ lamView e+ where cons b (LamView bs e) = LamView (b : bs) e+lamView (ScopedExpr _ e) = lamView e+lamView e = LamView [] e++-- | Collect @A.Pi@s.+data PiView = PiView [(ExprInfo, Telescope1)] Type++piView :: Expr -> PiView+piView = \case+ Pi i tel b -> cons $ piView b+ where cons (PiView tels t) = PiView ((i,tel) : tels) t+ e -> PiView [] e++unPiView :: PiView -> Expr+unPiView (PiView tels t) = foldr (uncurry Pi) t tels++-- | Gather top-level 'AsP'atterns to expose underlying pattern.+asView :: A.Pattern -> ([Name], A.Pattern)+asView (A.AsP _ x p) = (\(asb, p) -> (unBind x : asb, p)) $ asView p+asView p = ([], p)++-- | Remove top 'ScopedExpr' wrappers.+unScope :: Expr -> Expr+unScope (ScopedExpr scope e) = unScope e+unScope (QuestionMark i ii) = QuestionMark (i {metaScope = empty}) ii+unScope (Underscore i) = Underscore (i {metaScope = empty})+unScope e = e++-- | Remove 'ScopedExpr' wrappers everywhere.+--+-- NB: Unless the implementation of 'ExprLike' for clauses+-- has been finished, this does not work for clauses yet.+deepUnscope :: ExprLike a => a -> a+deepUnscope = mapExpr unScope++class DeepUnscopeDecls t where+ deepUnscopeDecls :: t A.Declaration -> t A.Declaration++instance DeepUnscopeDecls [] where+ deepUnscopeDecls :: [A.Declaration] -> [A.Declaration]+ deepUnscopeDecls = foldMap (List1.toList . deepUnscopeDecl)++instance DeepUnscopeDecls List1 where+ deepUnscopeDecls :: List1 A.Declaration -> List1 A.Declaration+ deepUnscopeDecls = List1.concatMap1 deepUnscopeDecl+ -- Want to use foldMap1 here, but it requires base >= 4.18 (GHC 9.6)++deepUnscopeDecl :: A.Declaration -> List1 A.Declaration+deepUnscopeDecl = \case+ A.ScopedDecl _ ds ->+ deepUnscopeDecls ds++ A.Mutual i ds -> singleton $+ A.Mutual i (deepUnscopeDecls ds)++ A.Section i e m tel ds -> singleton $+ A.Section i e m (deepUnscope tel) (deepUnscopeDecls ds)++ A.RecDef i x pc uc eta dir bs e ds -> singleton $+ A.RecDef i x pc uc eta dir (deepUnscope bs) (deepUnscope e) (deepUnscopeDecls ds)++ d -> singleton $ deepUnscope d++-- * Traversal+---------------------------------------------------------------------------++-- Type aliases to abbreviate the quantified foralls which we use to avoid+-- giving in to NoMonoLocalBinds.+type RecurseExprFn m a = Applicative m => (Expr -> m Expr -> m Expr) -> a -> m a+type RecurseExprRecFn m = forall a. ExprLike a => a -> m a++type FoldExprFn m a = Monoid m => (Expr -> m) -> a -> m+type FoldExprRecFn m = forall a. ExprLike a => a -> m++type TraverseExprFn m a = (Monad m) => (Expr -> m Expr) -> a -> m a+type TraverseExprRecFn m = forall a. ExprLike a => a -> m a++-- | Apply an expression rewriting to every subexpression, inside-out.+-- See "Agda.Syntax.Internal.Generic".+class ExprLike a where+ -- | The first expression is pre-traversal, the second one post-traversal.+ recurseExpr :: RecurseExprFn m a+ default recurseExpr :: (Traversable f, ExprLike a', a ~ f a', Applicative m)+ => (Expr -> m Expr -> m Expr) -> a -> m a+ recurseExpr = traverse . recurseExpr++ foldExpr :: FoldExprFn m a+ foldExpr f = getConst . recurseExpr (\ pre post -> Const (f pre) <* post)++ traverseExpr :: TraverseExprFn m a+ traverseExpr f = recurseExpr (\ pre post -> f =<< post)++ mapExpr :: (Expr -> Expr) -> (a -> a)+ mapExpr f = runIdentity . traverseExpr (Identity . f)++instance ExprLike Expr where+ recurseExpr :: forall m. RecurseExprFn m Expr+ recurseExpr f e0 = f e0 $ do+ let+ recurse :: RecurseExprRecFn m+ recurse e = recurseExpr f e+ case e0 of+ Var{} -> pure e0+ Def'{} -> pure e0+ Proj{} -> pure e0+ Con{} -> pure e0+ Lit{} -> pure e0+ QuestionMark{} -> pure e0+ Underscore{} -> pure e0+ Dot ei e -> Dot ei <$> recurse e+ App ei e arg -> App ei <$> recurse e <*> recurse arg+ WithApp ei e es -> WithApp ei <$> recurse e <*> recurse es+ Lam ei b e -> Lam ei <$> recurse b <*> recurse e+ AbsurdLam{} -> pure e0+ ExtendedLam ei di er x cls -> ExtendedLam ei di er x <$> recurse cls+ Pi ei tel e -> Pi ei <$> recurse tel <*> recurse e+ Generalized s e -> Generalized s <$> recurse e+ Fun ei arg e -> Fun ei <$> recurse arg <*> recurse e+ Let ei bs e -> Let ei <$> recurse bs <*> recurse e+ Rec kwr ei bs -> Rec kwr ei <$> recurse bs+ RecUpdate kwr ei e bs -> RecUpdate kwr ei <$> recurse e <*> recurse bs+ ScopedExpr sc e -> ScopedExpr sc <$> recurse e+ Quote{} -> pure e0+ QuoteTerm{} -> pure e0+ Unquote{} -> pure e0+ DontCare e -> DontCare <$> recurse e+ PatternSyn{} -> pure e0+ Macro{} -> pure e0+ Qualified q e -> Qualified q <$> recurse e+ Highlighted q e -> Highlighted q <$> recurse e++ foldExpr :: forall m. FoldExprFn m Expr+ foldExpr f e =+ case e of+ Var{} -> m+ Def'{} -> m+ Proj{} -> m+ Con{} -> m+ PatternSyn{} -> m+ Macro{} -> m+ Lit{} -> m+ QuestionMark{} -> m+ Underscore{} -> m+ Dot _ e -> m `mappend` fold e+ App _ e e' -> m `mappend` fold e `mappend` fold e'+ WithApp _ e es -> m `mappend` fold e `mappend` fold es+ Lam _ b e -> m `mappend` fold b `mappend` fold e+ AbsurdLam{} -> m+ ExtendedLam _ _ _ _ cs -> m `mappend` fold cs+ Pi _ tel e -> m `mappend` fold tel `mappend` fold e+ Generalized _ e -> m `mappend` fold e+ Fun _ e e' -> m `mappend` fold e `mappend` fold e'+ Let _ bs e -> m `mappend` fold bs `mappend` fold e+ Rec _ _ as -> m `mappend` fold as+ RecUpdate _ _ e as -> m `mappend` fold e `mappend` fold as+ ScopedExpr _ e -> m `mappend` fold e+ Quote{} -> m+ QuoteTerm{} -> m+ Unquote{} -> m+ DontCare e -> m `mappend` fold e+ Qualified _ e -> m `mappend` fold e+ Highlighted _ e -> m `mappend` fold e+ where+ m = f e+ fold :: FoldExprRecFn m+ fold = foldExpr f++ traverseExpr :: forall m. TraverseExprFn m Expr+ traverseExpr f e = do+ let+ trav :: TraverseExprRecFn m+ trav e = traverseExpr f e+ case e of+ Var{} -> f e+ Def'{} -> f e+ Proj{} -> f e+ Con{} -> f e+ Lit{} -> f e+ QuestionMark{} -> f e+ Underscore{} -> f e+ Dot ei e -> f =<< Dot ei <$> trav e+ App ei e arg -> f =<< App ei <$> trav e <*> trav arg+ WithApp ei e es -> f =<< WithApp ei <$> trav e <*> trav es+ Lam ei b e -> f =<< Lam ei <$> trav b <*> trav e+ AbsurdLam{} -> f e+ ExtendedLam ei di re x cls -> f =<< ExtendedLam ei di re x <$> trav cls+ Pi ei tel e -> f =<< Pi ei <$> trav tel <*> trav e+ Generalized s e -> f =<< Generalized s <$> trav e+ Fun ei arg e -> f =<< Fun ei <$> trav arg <*> trav e+ Let ei bs e -> f =<< Let ei <$> trav bs <*> trav e+ Rec kwr ei bs -> f =<< Rec kwr ei <$> trav bs+ RecUpdate kwr ei e bs -> f =<< RecUpdate kwr ei <$> trav e <*> trav bs+ ScopedExpr sc e -> f =<< ScopedExpr sc <$> trav e+ Quote{} -> f e+ QuoteTerm{} -> f e+ Unquote{} -> f e+ DontCare e -> f =<< DontCare <$> trav e+ PatternSyn{} -> f e+ Macro{} -> f e+ Qualified m e -> f =<< Qualified m <$> trav e+ Highlighted q e -> f =<< Highlighted q <$> trav e++instance ExprLike a => ExprLike (Arg a)+instance ExprLike a => ExprLike (Maybe a)+instance ExprLike a => ExprLike (Named x a)+instance ExprLike a => ExprLike (Ranged a)+instance ExprLike a => ExprLike [a]+instance ExprLike a => ExprLike (List1 a)+instance ExprLike a => ExprLike (TacticAttribute' a)++instance (ExprLike a, ExprLike b) => ExprLike (a, b) where+ recurseExpr f (x, y) = (,) <$> recurseExpr f x <*> recurseExpr f y++instance ExprLike Void where+ recurseExpr f = absurd++instance ExprLike a => ExprLike (FieldAssignment' a) where+ recurseExpr = exprFieldA . recurseExpr++instance (ExprLike a, ExprLike b) => ExprLike (Either a b) where+ recurseExpr f = traverseEither (recurseExpr f)+ (recurseExpr f)++instance ExprLike BindName where+ recurseExpr f = pure++instance ExprLike ModuleName where+ recurseExpr f = pure++instance ExprLike QName where+ recurseExpr _ = pure++instance ExprLike LamBinding where+ recurseExpr f e =+ case e of+ DomainFree t x -> DomainFree <$> recurseExpr f t <*> pure x+ DomainFull bs -> DomainFull <$> recurseExpr f bs+ foldExpr f e =+ case e of+ DomainFree t _ -> foldExpr f t+ DomainFull bs -> foldExpr f bs+ traverseExpr f e =+ case e of+ DomainFree t x -> DomainFree <$> traverseExpr f t <*> pure x+ DomainFull bs -> DomainFull <$> traverseExpr f bs++instance ExprLike GeneralizeTelescope where+ recurseExpr f (GeneralizeTel s tel) = GeneralizeTel s <$> recurseExpr f tel+ foldExpr f (GeneralizeTel s tel) = foldExpr f tel+ traverseExpr f (GeneralizeTel s tel) = GeneralizeTel s <$> traverseExpr f tel++instance ExprLike DataDefParams where+ recurseExpr f (DataDefParams s tel) = DataDefParams s <$> recurseExpr f tel+ foldExpr f (DataDefParams s tel) = foldExpr f tel+ traverseExpr f (DataDefParams s tel) = DataDefParams s <$> traverseExpr f tel++instance ExprLike TypedBindingInfo where+ recurseExpr f (TypedBindingInfo s t) = TypedBindingInfo <$> recurseExpr f s <*> pure t+ foldExpr f (TypedBindingInfo s t) = foldExpr f s+ traverseExpr f (TypedBindingInfo s t) = TypedBindingInfo <$> traverseExpr f s <*> pure t++instance ExprLike TypedBinding where+ recurseExpr f e =+ case e of+ TBind r t xs e -> TBind r <$> recurseExpr f t <*> pure xs <*> recurseExpr f e+ TLet r ds -> TLet r <$> recurseExpr f ds+ foldExpr f e =+ case e of+ TBind _ t _ e -> foldExpr f t `mappend` foldExpr f e+ TLet _ ds -> foldExpr f ds+ traverseExpr f e =+ case e of+ TBind r t xs e -> TBind r <$> traverseExpr f t <*> pure xs <*> traverseExpr f e+ TLet r ds -> TLet r <$> traverseExpr f ds++instance ExprLike LetBinding where+ recurseExpr :: forall m. RecurseExprFn m LetBinding+ recurseExpr f e = do+ let+ recurse :: RecurseExprRecFn m+ recurse e = recurseExpr f e+ case e of+ LetBind li ai x e e' -> LetBind li ai x <$> recurse e <*> recurse e'+ LetAxiom li ai x e -> LetAxiom li ai x <$> recurse e+ LetPatBind li ai p e -> LetPatBind li ai <$> recurse p <*> recurse e+ LetApply{} -> pure e+ LetOpen{} -> pure e++ foldExpr :: forall m. FoldExprFn m LetBinding+ foldExpr f e =+ case e of+ LetBind _ _ _ e e' -> fold e `mappend` fold e'+ LetAxiom _ _ _ e -> fold e+ LetPatBind _ _ p e -> fold p `mappend` fold e+ LetApply{} -> mempty+ LetOpen{} -> mempty+ where+ fold :: FoldExprRecFn m+ fold e = foldExpr f e++ traverseExpr :: forall m. TraverseExprFn m LetBinding+ traverseExpr f e = do+ let+ trav :: TraverseExprRecFn m+ trav e = traverseExpr f e+ case e of+ LetBind li ai x e e' -> LetBind li ai x <$> trav e <*> trav e'+ LetAxiom li ai x e -> LetAxiom li ai x <$> trav e+ LetPatBind li ai p e -> LetPatBind li ai <$> trav p <*> trav e+ LetApply{} -> pure e+ LetOpen{} -> pure e++instance ExprLike a => ExprLike (Pattern' a) where++instance ExprLike a => ExprLike (Clause' a) where+ recurseExpr :: forall m. RecurseExprFn m (Clause' a)+ recurseExpr f (Clause lhs spats rhs ds ca) = Clause <$> rec lhs <*> pure spats <*> rec rhs <*> rec ds <*> pure ca+ where+ rec :: RecurseExprRecFn m+ rec = recurseExpr f++instance ExprLike RHS where+ recurseExpr :: forall m. RecurseExprFn m RHS+ recurseExpr f rhs =+ case rhs of+ RHS e c -> RHS <$> rec e <*> pure c+ AbsurdRHS{} -> pure rhs+ WithRHS x es cs -> WithRHS x <$> rec es <*> rec cs+ RewriteRHS xes spats rhs ds -> RewriteRHS <$> rec xes <*> pure spats <*> rec rhs <*> rec ds+ where+ rec :: RecurseExprRecFn m+ rec e = recurseExpr f e++instance (ExprLike qn, ExprLike p, ExprLike e) => ExprLike (RewriteEqn' qn nm p e) where+ recurseExpr f = \case+ Rewrite es -> Rewrite <$> recurseExpr f es+ Invert qn pes -> Invert <$> recurseExpr f qn <*> recurseExpr f pes+ LeftLet pes -> LeftLet <$> recurseExpr f pes++instance ExprLike WhereDeclarations where+ recurseExpr f (WhereDecls a b c) = WhereDecls a b <$> recurseExpr f c++instance ExprLike ModuleApplication where+ recurseExpr :: forall m. RecurseExprFn m ModuleApplication+ recurseExpr f a =+ case a of+ SectionApp tel m es -> SectionApp <$> rec tel <*> rec m <*> rec es+ RecordModuleInstance{} -> pure a+ where+ rec :: RecurseExprRecFn m+ rec e = recurseExpr f e++instance ExprLike Pragma where+ recurseExpr :: forall m. RecurseExprFn m Pragma+ recurseExpr f p =+ case p of+ BuiltinPragma s x -> pure p+ OptionsPragma{} -> pure p+ BuiltinNoDefPragma{} -> pure p+ RewritePragma{} -> pure p+ CompilePragma{} -> pure p+ ForeignPragma{} -> pure p+ StaticPragma{} -> pure p+ InjectivePragma{} -> pure p+ InjectiveForInferencePragma{} -> pure p+ InlinePragma{} -> pure p+ NotProjectionLikePragma{} -> pure p+ OverlapPragma{} -> pure p+ DisplayPragma f xs e -> DisplayPragma f <$> rec xs <*> rec e+ where+ rec :: RecurseExprRecFn m+ rec e = recurseExpr f e++instance ExprLike LHS where+ recurseExpr f (LHS i p) = LHS i <$> recurseExpr f p++instance ExprLike a => ExprLike (LHSCore' a) where+instance ExprLike a => ExprLike (WithHiding a) where++instance ExprLike SpineLHS where+ recurseExpr f (SpineLHS i x ps) = SpineLHS i x <$> recurseExpr f ps++instance ExprLike Declaration where+ recurseExpr :: forall m. RecurseExprFn m Declaration+ recurseExpr f d =+ case d of+ Axiom a d i mp x e -> Axiom a d i mp x <$> rec e+ Generalize s i j x e -> Generalize s i j x <$> rec e+ Field i x e -> Field i x <$> rec e+ Primitive i x e -> Primitive i x <$> rec e+ Mutual i ds -> Mutual i <$> rec ds+ Section i e m tel ds -> Section i e m <$> rec tel <*> rec ds+ Apply i e m a ci d -> (\a -> Apply i e m a ci d) <$> rec a+ Import{} -> pure d+ Pragma i p -> Pragma i <$> rec p+ Open{} -> pure d+ FunDef i f cs -> FunDef i f <$> rec cs+ DataSig i er d tel e -> DataSig i er d <$> rec tel <*> rec e+ DataDef i d pc uc bs cs -> DataDef i d pc uc <$> rec bs <*> rec cs+ RecSig i er r tel e -> RecSig i er r <$> rec tel <*> rec e+ RecDef i r pc uc eta dir bs e ds -> RecDef i r pc uc eta dir <$> rec bs <*> rec e <*> rec ds+ PatternSynDef f xs p -> PatternSynDef f xs <$> rec p+ UnquoteDecl i is xs e -> UnquoteDecl i is xs <$> rec e+ UnquoteDef i xs e -> UnquoteDef i xs <$> rec e+ UnquoteData i xs uc j cs e -> UnquoteData i xs uc j cs <$> rec e+ ScopedDecl s ds -> ScopedDecl s <$> rec ds+ UnfoldingDecl r ds -> UnfoldingDecl r <$> rec ds+ where+ rec :: RecurseExprRecFn m+ rec e = recurseExpr f e+++-- * Getting all declared names+---------------------------------------------------------------------------++type KName = WithKind QName++-- | Extracts "all" names which are declared in a 'Declaration'.+--+-- Includes: local modules and @where@ clauses.+-- Excludes: @open public@, @let@, @with@ function names, extended lambdas.++class DeclaredNames a where+ declaredNames :: Collection KName m => a -> m++ default declaredNames+ :: (Foldable t, DeclaredNames b, t b ~ a)+ => Collection KName m => a -> m+ declaredNames = foldMap declaredNames++instance DeclaredNames a => DeclaredNames [a]+instance DeclaredNames a => DeclaredNames (List1 a)+instance DeclaredNames a => DeclaredNames (Maybe a)+instance DeclaredNames a => DeclaredNames (Arg a)+instance DeclaredNames a => DeclaredNames (Named name a)+instance DeclaredNames a => DeclaredNames (FieldAssignment' a)++instance (DeclaredNames a, DeclaredNames b) => DeclaredNames (Either a b) where+ declaredNames = either declaredNames declaredNames++instance (DeclaredNames a, DeclaredNames b) => DeclaredNames (a,b) where+ declaredNames (a,b) = declaredNames a <> declaredNames b++instance DeclaredNames KName where+ declaredNames = singleton++instance DeclaredNames RecordDirectives where+ declaredNames (RecordDirectives i _ _ c) = kc where+ kc = case c of+ NamedRecCon c -> singleton $ WithKind k c+ FreshRecCon{} -> mempty+ k = maybe ConName (conKindOfName . rangedThing) i++instance DeclaredNames Declaration where+ declaredNames = \case+ Axiom _ di _ _ q _ -> singleton . (`WithKind` q) $+ case defMacro di of+ MacroDef -> MacroName+ NotMacroDef -> AxiomName+ Generalize _ _ _ q _ -> singleton (WithKind GeneralizeName q)+ Field _ q _ -> singleton (WithKind FldName q)+ Primitive _ q _ -> singleton (WithKind PrimName q)+ Mutual _ decls -> declaredNames decls+ DataSig _ _ q _ _ -> singleton (WithKind DataName q)+ DataDef _ q _ _ _ decls -> singleton (WithKind DataName q) <> foldMap con decls+ RecSig _ _ q _ _ -> singleton (WithKind RecName q)+ RecDef _ q _ _ _ dir _ _ decls -> singleton (WithKind RecName q) <> declaredNames dir <> declaredNames decls+ PatternSynDef q _ _ -> singleton (WithKind PatternSynName q)+ UnquoteDecl _ _ qs _ -> fromList $ map (WithKind OtherDefName) qs -- could be Fun or Axiom+ UnquoteDef _ qs _ -> fromList $ map (WithKind FunName) qs -- cannot be Axiom+ UnquoteData _ d _ _ cs _ -> singleton (WithKind DataName d) <> fromList (map (WithKind ConName) cs) -- singleton _ <> map (WithKind ConName) cs+ FunDef _ q cls -> singleton (WithKind FunName q) <> declaredNames cls+ ScopedDecl _ decls -> declaredNames decls+ Section _ _ _ _ decls -> declaredNames decls+ Pragma _ pragma -> declaredNames pragma+ Apply{} -> mempty+ Import{} -> mempty+ Open{} -> mempty+ UnfoldingDecl{} -> mempty+ where+ con = \case+ Axiom _ _ _ _ q _ -> singleton $ WithKind ConName q+ _ -> __IMPOSSIBLE__++instance DeclaredNames Pragma where+ declaredNames = \case+ BuiltinNoDefPragma _b kind x -> singleton $ WithKind kind x+ BuiltinPragma{} -> mempty+ CompilePragma{} -> mempty+ ForeignPragma{} -> mempty+ RewritePragma{} -> mempty+ StaticPragma{} -> mempty+ InjectivePragma{} -> mempty+ InjectiveForInferencePragma{} -> mempty+ InlinePragma{} -> mempty+ NotProjectionLikePragma{} -> mempty+ DisplayPragma{} -> mempty+ OptionsPragma{} -> mempty+ OverlapPragma{} -> mempty++instance DeclaredNames Clause where+ declaredNames (Clause _ _ rhs decls _) = declaredNames rhs <> declaredNames decls++instance DeclaredNames WhereDeclarations where+ declaredNames (WhereDecls _ _ ds) = declaredNames ds++instance DeclaredNames RHS where+ declaredNames = \case+ RHS _ _ -> mempty+ AbsurdRHS -> mempty+ WithRHS _q _es cls -> declaredNames cls+ RewriteRHS _qes _ rhs cls -> declaredNames rhs <> declaredNames cls++-- Andreas, 2020-04-13: Migration from Agda.Syntax.Abstract.AllNames+--+-- Since we are not interested in names of extended lambdas, we do not+-- traverse into expression.+--+-- However, we keep this code (originally Agda.Syntax.Abstract.AllNames) around+-- should arise a need to collect extended lambda names.++-- instance (DeclaredNames a, DeclaredNames b, DeclaredNames c) => DeclaredNames (a,b,c) where+-- declaredNames (a,b,c) = declaredNames a <> declaredNames b <> declaredNames c++-- instance DeclaredNames RHS where+-- declaredNames = \case+-- RHS e _ -> declaredNames e+-- AbsurdRHS{} -> mempty+-- WithRHS q _ cls -> singleton (WithKind FunName q) <> declaredNames cls+-- RewriteRHS qes _ rhs cls -> declaredNames (qes, rhs, cls)++-- instance DeclaredNames ModuleName where+-- declaredNames _ = mempty++-- instance (DeclaredNames qn, DeclaredNames e) => DeclaredNames (RewriteEqn' qn p e) where+-- declaredNames = \case+-- Rewrite es -> declaredNames es+-- Invert qn pes -> declaredNames qn <> declaredNames pes++-- instance DeclaredNames Expr where+-- declaredNames = \case+-- Var{} -> mempty+-- Def{} -> mempty+-- Proj{} -> mempty+-- Con{} -> mempty+-- Lit{} -> mempty+-- QuestionMark{} -> mempty+-- Underscore{} -> mempty+-- Dot _ e -> declaredNames e+-- App _ e1 e2 -> declaredNames e1 <> declaredNames e2+-- WithApp _ e es -> declaredNames e <> declaredNames es+-- Lam _ b e -> declaredNames b <> declaredNames e+-- AbsurdLam{} -> mempty+-- ExtendedLam _ _ q cls -> singleton (WithKind FunName q) <> declaredNames cls+-- Pi _ tel e -> declaredNames tel <> declaredNames e+-- Generalized s e -> declaredNames e -- NOT: fromList (map (WithKind GeneralizeName) $ Set.toList s) <> declaredNames e+-- Fun _ e1 e2 -> declaredNames e1 <> declaredNames e2+-- Set{} -> mempty+-- Prop{} -> mempty+-- Let _ lbs e -> declaredNames lbs <> declaredNames e+-- Rec _ fields -> declaredNames fields+-- RecUpdate _ e fs -> declaredNames e <> declaredNames fs+-- ScopedExpr _ e -> declaredNames e+-- Quote{} -> mempty+-- QuoteTerm{} -> mempty+-- Unquote{} -> mempty+-- DontCare{} -> mempty+-- PatternSyn{} -> mempty+-- Macro{} -> mempty++-- instance DeclaredNames LamBinding where+-- declaredNames DomainFree{} = mempty+-- declaredNames (DomainFull binds) = declaredNames binds++-- instance DeclaredNames TypedBinding where+-- declaredNames (TBind _ t _ e) = declaredNames (t, e)+-- declaredNames (TLet _ lbs) = declaredNames lbs++-- instance DeclaredNames LetBinding where+-- declaredNames (LetBind _ _ _ e1 e2) = declaredNames e1 <> declaredNames e2+-- declaredNames (LetPatBind _ _ e) = declaredNames e+-- declaredNames (LetApply _ _ app _ _) = declaredNames app+-- declaredNames LetOpen{} = mempty++-- instance DeclaredNames ModuleApplication where+-- declaredNames (SectionApp bindss _ es) = declaredNames bindss <> declaredNames es+-- declaredNames RecordModuleInstance{} = mempty
@@ -0,0 +1,1099 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}++-- | This module defines the names of all builtin and primitives used in Agda.+--+-- See "Agda.TypeChecking.Monad.Builtin"+module Agda.Syntax.Builtin where++import GHC.Generics (Generic)++import Control.DeepSeq (NFData)++import qualified Data.Map as M+import Data.Hashable++import Agda.Syntax.Common.Pretty+import Agda.Syntax.Position++import Agda.Utils.List++-- | Either a 'BuiltinId' or 'PrimitiveId', used for some lookups.+data SomeBuiltin+ = BuiltinName !BuiltinId+ | PrimitiveName !PrimitiveId+ deriving (Show, Eq, Ord, Generic)++instance Hashable SomeBuiltin+instance NFData SomeBuiltin++-- | The class of types which can be converted to 'SomeBuiltin'.+class IsBuiltin a where+ -- | Convert this value to a builtin.+ someBuiltin :: a -> SomeBuiltin++ -- | Get the identifier for this builtin, generally used for error messages.+ getBuiltinId :: a -> String++instance IsBuiltin SomeBuiltin where+ someBuiltin = id++ getBuiltinId (BuiltinName x) = getBuiltinId x+ getBuiltinId (PrimitiveName x) = getBuiltinId x++-- * Builtins++-- | A builtin name, defined by the @BUILTIN@ pragma.+data BuiltinId+ = BuiltinNat+ | BuiltinSuc+ | BuiltinZero+ | BuiltinNatPlus+ | BuiltinNatMinus+ | BuiltinNatTimes+ | BuiltinNatDivSucAux+ | BuiltinNatModSucAux+ | BuiltinNatEquals+ | BuiltinNatLess+ | BuiltinWord64+ | BuiltinInteger+ | BuiltinIntegerPos+ | BuiltinIntegerNegSuc+ | BuiltinFloat+ | BuiltinChar+ | BuiltinString+ | BuiltinUnit+ | BuiltinUnitUnit+ | BuiltinSigma+ | BuiltinSigmaCon+ | BuiltinBool+ | BuiltinTrue+ | BuiltinFalse+ | BuiltinList+ | BuiltinNil+ | BuiltinCons+ | BuiltinMaybe+ | BuiltinNothing+ | BuiltinJust+ | BuiltinIO+ | BuiltinPath+ | BuiltinPathP+ | BuiltinIntervalUniv+ | BuiltinInterval+ | BuiltinIZero+ | BuiltinIOne+ | BuiltinPartial+ | BuiltinPartialP+ | BuiltinIsOne+ | BuiltinItIsOne+ | BuiltinEquiv+ | BuiltinEquivFun+ | BuiltinEquivProof+ | BuiltinTranspProof+ | BuiltinIsOne1+ | BuiltinIsOne2+ | BuiltinIsOneEmpty+ | BuiltinSub+ | BuiltinSubIn+ | BuiltinSizeUniv+ | BuiltinSize+ | BuiltinSizeLt+ | BuiltinSizeSuc+ | BuiltinSizeInf+ | BuiltinSizeMax+ | BuiltinInf+ | BuiltinSharp+ | BuiltinFlat+ | BuiltinEquality+ | BuiltinRefl+ | BuiltinRewrite+ | BuiltinLevelMax+ | BuiltinLevel+ | BuiltinLevelZero+ | BuiltinLevelSuc+ | BuiltinProp+ | BuiltinSet+ | BuiltinStrictSet+ | BuiltinPropOmega+ | BuiltinSetOmega+ | BuiltinSSetOmega+ | BuiltinLevelUniv+ | BuiltinFromNat+ | BuiltinFromNeg+ | BuiltinFromString+ | BuiltinQuotientConstructor+ | BuiltinQName+ | BuiltinAgdaSort+ | BuiltinAgdaSortSet+ | BuiltinAgdaSortLit+ | BuiltinAgdaSortProp+ | BuiltinAgdaSortPropLit+ | BuiltinAgdaSortInf+ | BuiltinAgdaSortUnsupported+ | BuiltinHiding+ | BuiltinHidden+ | BuiltinInstance+ | BuiltinVisible+ | BuiltinRelevance+ | BuiltinRelevant+ | BuiltinIrrelevant+ | BuiltinQuantity+ | BuiltinQuantity0+ | BuiltinQuantityω+ | BuiltinModality+ | BuiltinModalityConstructor+ | BuiltinAssoc+ | BuiltinAssocLeft+ | BuiltinAssocRight+ | BuiltinAssocNon+ | BuiltinPrecedence+ | BuiltinPrecRelated+ | BuiltinPrecUnrelated+ | BuiltinFixity+ | BuiltinFixityFixity+ | BuiltinArg+ | BuiltinArgInfo+ | BuiltinArgArgInfo+ | BuiltinArgArg+ | BuiltinAbs+ | BuiltinAbsAbs+ | BuiltinAgdaTerm+ | BuiltinAgdaTermVar+ | BuiltinAgdaTermLam+ | BuiltinAgdaTermExtLam+ | BuiltinAgdaTermDef+ | BuiltinAgdaTermCon+ | BuiltinAgdaTermPi+ | BuiltinAgdaTermSort+ | BuiltinAgdaTermLit+ | BuiltinAgdaTermUnsupported+ | BuiltinAgdaTermMeta+ | BuiltinAgdaErrorPart+ | BuiltinAgdaErrorPartString+ | BuiltinAgdaErrorPartTerm+ | BuiltinAgdaErrorPartPatt+ | BuiltinAgdaErrorPartName+ | BuiltinAgdaLiteral+ | BuiltinAgdaLitNat+ | BuiltinAgdaLitWord64+ | BuiltinAgdaLitFloat+ | BuiltinAgdaLitChar+ | BuiltinAgdaLitString+ | BuiltinAgdaLitQName+ | BuiltinAgdaLitMeta+ | BuiltinAgdaClause+ | BuiltinAgdaClauseClause+ | BuiltinAgdaClauseAbsurd+ | BuiltinAgdaPattern+ | BuiltinAgdaPatVar+ | BuiltinAgdaPatCon+ | BuiltinAgdaPatDot+ | BuiltinAgdaPatLit+ | BuiltinAgdaPatProj+ | BuiltinAgdaPatAbsurd+ | BuiltinAgdaDefinitionFunDef+ | BuiltinAgdaDefinitionDataDef+ | BuiltinAgdaDefinitionRecordDef+ | BuiltinAgdaDefinitionDataConstructor+ | BuiltinAgdaDefinitionPostulate+ | BuiltinAgdaDefinitionPrimitive+ | BuiltinAgdaDefinition+ | BuiltinAgdaMeta+ | BuiltinAgdaTCM+ | BuiltinAgdaTCMReturn+ | BuiltinAgdaTCMBind+ | BuiltinAgdaTCMUnify+ | BuiltinAgdaTCMTypeError+ | BuiltinAgdaTCMInferType+ | BuiltinAgdaTCMCheckType+ | BuiltinAgdaTCMNormalise+ | BuiltinAgdaTCMReduce+ | BuiltinAgdaTCMCatchError+ | BuiltinAgdaTCMGetContext+ | BuiltinAgdaTCMExtendContext+ | BuiltinAgdaTCMInContext+ | BuiltinAgdaTCMFreshName+ | BuiltinAgdaTCMDeclareDef+ | BuiltinAgdaTCMDeclarePostulate+ | BuiltinAgdaTCMDeclareData+ | BuiltinAgdaTCMDefineData+ | BuiltinAgdaTCMDefineFun+ | BuiltinAgdaTCMGetType+ | BuiltinAgdaTCMGetDefinition+ | BuiltinAgdaTCMBlock+ | BuiltinAgdaTCMCommit+ | BuiltinAgdaTCMQuoteTerm+ | BuiltinAgdaTCMUnquoteTerm+ | BuiltinAgdaTCMQuoteOmegaTerm+ | BuiltinAgdaTCMIsMacro+ | BuiltinAgdaTCMWithNormalisation+ | BuiltinAgdaTCMWithReconstructed+ | BuiltinAgdaTCMWithExpandLast+ | BuiltinAgdaTCMWithReduceDefs+ | BuiltinAgdaTCMAskNormalisation+ | BuiltinAgdaTCMAskReconstructed+ | BuiltinAgdaTCMAskExpandLast+ | BuiltinAgdaTCMAskReduceDefs+ | BuiltinAgdaTCMFormatErrorParts+ | BuiltinAgdaTCMDebugPrint+ | BuiltinAgdaTCMNoConstraints+ | BuiltinAgdaTCMWorkOnTypes+ | BuiltinAgdaTCMRunSpeculative+ | BuiltinAgdaTCMExec+ | BuiltinAgdaTCMCheckFromString+ | BuiltinAgdaTCMGetInstances+ | BuiltinAgdaTCMSolveInstances+ | BuiltinAgdaTCMPragmaForeign+ | BuiltinAgdaTCMPragmaCompile+ | BuiltinAgdaBlocker+ | BuiltinAgdaBlockerAny+ | BuiltinAgdaBlockerAll+ | BuiltinAgdaBlockerMeta+ deriving (Show, Eq, Ord, Bounded, Enum, Generic)++instance NFData BuiltinId++instance Hashable BuiltinId where+ s `hashWithSalt` b = s `hashWithSalt` fromEnum b++instance KillRange BuiltinId where+ killRange = id++instance Pretty BuiltinId where+ pretty = text . getBuiltinId++instance IsBuiltin BuiltinId where+ someBuiltin = BuiltinName++ getBuiltinId = \case+ BuiltinNat -> "NATURAL"+ BuiltinSuc -> "SUC"+ BuiltinZero -> "ZERO"+ BuiltinNatPlus -> "NATPLUS"+ BuiltinNatMinus -> "NATMINUS"+ BuiltinNatTimes -> "NATTIMES"+ BuiltinNatDivSucAux -> "NATDIVSUCAUX"+ BuiltinNatModSucAux -> "NATMODSUCAUX"+ BuiltinNatEquals -> "NATEQUALS"+ BuiltinNatLess -> "NATLESS"+ BuiltinWord64 -> "WORD64"+ BuiltinInteger -> "INTEGER"+ BuiltinIntegerPos -> "INTEGERPOS"+ BuiltinIntegerNegSuc -> "INTEGERNEGSUC"+ BuiltinFloat -> "FLOAT"+ BuiltinChar -> "CHAR"+ BuiltinString -> "STRING"+ BuiltinUnit -> "UNIT"+ BuiltinUnitUnit -> "UNITUNIT"+ BuiltinSigma -> "SIGMA"+ BuiltinSigmaCon -> "SIGMACON"+ BuiltinBool -> "BOOL"+ BuiltinTrue -> "TRUE"+ BuiltinFalse -> "FALSE"+ BuiltinList -> "LIST"+ BuiltinNil -> "NIL"+ BuiltinCons -> "CONS"+ BuiltinMaybe -> "MAYBE"+ BuiltinNothing -> "NOTHING"+ BuiltinJust -> "JUST"+ BuiltinIO -> "IO"+ BuiltinPath -> "PATH"+ BuiltinPathP -> "PATHP"+ BuiltinIntervalUniv -> "CUBEINTERVALUNIV"+ BuiltinInterval -> "INTERVAL"+ BuiltinIZero -> "IZERO"+ BuiltinIOne -> "IONE"+ BuiltinPartial -> "PARTIAL"+ BuiltinPartialP -> "PARTIALP"+ BuiltinIsOne -> "ISONE"+ BuiltinItIsOne -> "ITISONE"+ BuiltinEquiv -> "EQUIV"+ BuiltinEquivFun -> "EQUIVFUN"+ BuiltinEquivProof -> "EQUIVPROOF"+ BuiltinTranspProof -> "TRANSPPROOF"+ BuiltinIsOne1 -> "ISONE1"+ BuiltinIsOne2 -> "ISONE2"+ BuiltinIsOneEmpty -> "ISONEEMPTY"+ BuiltinSub -> "SUB"+ BuiltinSubIn -> "SUBIN"+ BuiltinSizeUniv -> "SIZEUNIV"+ BuiltinSize -> "SIZE"+ BuiltinSizeLt -> "SIZELT"+ BuiltinSizeSuc -> "SIZESUC"+ BuiltinSizeInf -> "SIZEINF"+ BuiltinSizeMax -> "SIZEMAX"+ BuiltinInf -> "INFINITY"+ BuiltinSharp -> "SHARP"+ BuiltinFlat -> "FLAT"+ BuiltinEquality -> "EQUALITY"+ BuiltinRefl -> "REFL"+ BuiltinRewrite -> "REWRITE"+ BuiltinLevelMax -> "LEVELMAX"+ BuiltinLevel -> "LEVEL"+ BuiltinLevelZero -> "LEVELZERO"+ BuiltinLevelSuc -> "LEVELSUC"+ BuiltinProp -> "PROP"+ BuiltinSet -> "TYPE"+ BuiltinStrictSet -> "STRICTSET"+ BuiltinPropOmega -> "PROPOMEGA"+ BuiltinSetOmega -> "SETOMEGA"+ BuiltinSSetOmega -> "STRICTSETOMEGA"+ BuiltinLevelUniv -> "LEVELUNIV"+ BuiltinFromNat -> "FROMNAT"+ BuiltinFromNeg -> "FROMNEG"+ BuiltinFromString -> "FROMSTRING"+ BuiltinQuotientConstructor -> "QUOTIENTCONSTRUCTOR"+ BuiltinQName -> "QNAME"+ BuiltinAgdaSort -> "AGDASORT"+ BuiltinAgdaSortSet -> "AGDASORTSET"+ BuiltinAgdaSortLit -> "AGDASORTLIT"+ BuiltinAgdaSortProp -> "AGDASORTPROP"+ BuiltinAgdaSortPropLit -> "AGDASORTPROPLIT"+ BuiltinAgdaSortInf -> "AGDASORTINF"+ BuiltinAgdaSortUnsupported -> "AGDASORTUNSUPPORTED"+ BuiltinHiding -> "HIDING"+ BuiltinHidden -> "HIDDEN"+ BuiltinInstance -> "INSTANCE"+ BuiltinVisible -> "VISIBLE"+ BuiltinRelevance -> "RELEVANCE"+ BuiltinRelevant -> "RELEVANT"+ BuiltinIrrelevant -> "IRRELEVANT"+ BuiltinQuantity -> "QUANTITY"+ BuiltinQuantity0 -> "QUANTITY-0"+ BuiltinQuantityω -> "QUANTITY-ω"+ BuiltinModality -> "MODALITY"+ BuiltinModalityConstructor -> "MODALITY-CONSTRUCTOR"+ BuiltinAssoc -> "ASSOC"+ BuiltinAssocLeft -> "ASSOCLEFT"+ BuiltinAssocRight -> "ASSOCRIGHT"+ BuiltinAssocNon -> "ASSOCNON"+ BuiltinPrecedence -> "PRECEDENCE"+ BuiltinPrecRelated -> "PRECRELATED"+ BuiltinPrecUnrelated -> "PRECUNRELATED"+ BuiltinFixity -> "FIXITY"+ BuiltinFixityFixity -> "FIXITYFIXITY"+ BuiltinArg -> "ARG"+ BuiltinArgInfo -> "ARGINFO"+ BuiltinArgArgInfo -> "ARGARGINFO"+ BuiltinArgArg -> "ARGARG"+ BuiltinAbs -> "ABS"+ BuiltinAbsAbs -> "ABSABS"+ BuiltinAgdaTerm -> "AGDATERM"+ BuiltinAgdaTermVar -> "AGDATERMVAR"+ BuiltinAgdaTermLam -> "AGDATERMLAM"+ BuiltinAgdaTermExtLam -> "AGDATERMEXTLAM"+ BuiltinAgdaTermDef -> "AGDATERMDEF"+ BuiltinAgdaTermCon -> "AGDATERMCON"+ BuiltinAgdaTermPi -> "AGDATERMPI"+ BuiltinAgdaTermSort -> "AGDATERMSORT"+ BuiltinAgdaTermLit -> "AGDATERMLIT"+ BuiltinAgdaTermUnsupported -> "AGDATERMUNSUPPORTED"+ BuiltinAgdaTermMeta -> "AGDATERMMETA"+ BuiltinAgdaErrorPart -> "AGDAERRORPART"+ BuiltinAgdaErrorPartString -> "AGDAERRORPARTSTRING"+ BuiltinAgdaErrorPartTerm -> "AGDAERRORPARTTERM"+ BuiltinAgdaErrorPartPatt -> "AGDAERRORPARTPATT"+ BuiltinAgdaErrorPartName -> "AGDAERRORPARTNAME"+ BuiltinAgdaLiteral -> "AGDALITERAL"+ BuiltinAgdaLitNat -> "AGDALITNAT"+ BuiltinAgdaLitWord64 -> "AGDALITWORD64"+ BuiltinAgdaLitFloat -> "AGDALITFLOAT"+ BuiltinAgdaLitChar -> "AGDALITCHAR"+ BuiltinAgdaLitString -> "AGDALITSTRING"+ BuiltinAgdaLitQName -> "AGDALITQNAME"+ BuiltinAgdaLitMeta -> "AGDALITMETA"+ BuiltinAgdaClause -> "AGDACLAUSE"+ BuiltinAgdaClauseClause -> "AGDACLAUSECLAUSE"+ BuiltinAgdaClauseAbsurd -> "AGDACLAUSEABSURD"+ BuiltinAgdaPattern -> "AGDAPATTERN"+ BuiltinAgdaPatVar -> "AGDAPATVAR"+ BuiltinAgdaPatCon -> "AGDAPATCON"+ BuiltinAgdaPatDot -> "AGDAPATDOT"+ BuiltinAgdaPatLit -> "AGDAPATLIT"+ BuiltinAgdaPatProj -> "AGDAPATPROJ"+ BuiltinAgdaPatAbsurd -> "AGDAPATABSURD"+ BuiltinAgdaDefinitionFunDef -> "AGDADEFINITIONFUNDEF"+ BuiltinAgdaDefinitionDataDef -> "AGDADEFINITIONDATADEF"+ BuiltinAgdaDefinitionRecordDef -> "AGDADEFINITIONRECORDDEF"+ BuiltinAgdaDefinitionDataConstructor -> "AGDADEFINITIONDATACONSTRUCTOR"+ BuiltinAgdaDefinitionPostulate -> "AGDADEFINITIONPOSTULATE"+ BuiltinAgdaDefinitionPrimitive -> "AGDADEFINITIONPRIMITIVE"+ BuiltinAgdaDefinition -> "AGDADEFINITION"+ BuiltinAgdaMeta -> "AGDAMETA"+ BuiltinAgdaTCM -> "AGDATCM"+ BuiltinAgdaTCMReturn -> "AGDATCMRETURN"+ BuiltinAgdaTCMBind -> "AGDATCMBIND"+ BuiltinAgdaTCMUnify -> "AGDATCMUNIFY"+ BuiltinAgdaTCMTypeError -> "AGDATCMTYPEERROR"+ BuiltinAgdaTCMInferType -> "AGDATCMINFERTYPE"+ BuiltinAgdaTCMCheckType -> "AGDATCMCHECKTYPE"+ BuiltinAgdaTCMNormalise -> "AGDATCMNORMALISE"+ BuiltinAgdaTCMReduce -> "AGDATCMREDUCE"+ BuiltinAgdaTCMCatchError -> "AGDATCMCATCHERROR"+ BuiltinAgdaTCMGetContext -> "AGDATCMGETCONTEXT"+ BuiltinAgdaTCMExtendContext -> "AGDATCMEXTENDCONTEXT"+ BuiltinAgdaTCMInContext -> "AGDATCMINCONTEXT"+ BuiltinAgdaTCMFreshName -> "AGDATCMFRESHNAME"+ BuiltinAgdaTCMDeclareDef -> "AGDATCMDECLAREDEF"+ BuiltinAgdaTCMDeclarePostulate -> "AGDATCMDECLAREPOSTULATE"+ BuiltinAgdaTCMDeclareData -> "AGDATCMDECLAREDATA"+ BuiltinAgdaTCMDefineData -> "AGDATCMDEFINEDATA"+ BuiltinAgdaTCMDefineFun -> "AGDATCMDEFINEFUN"+ BuiltinAgdaTCMGetType -> "AGDATCMGETTYPE"+ BuiltinAgdaTCMGetDefinition -> "AGDATCMGETDEFINITION"+ BuiltinAgdaTCMBlock -> "AGDATCMBLOCK"+ BuiltinAgdaTCMCommit -> "AGDATCMCOMMIT"+ BuiltinAgdaTCMQuoteTerm -> "AGDATCMQUOTETERM"+ BuiltinAgdaTCMUnquoteTerm -> "AGDATCMUNQUOTETERM"+ BuiltinAgdaTCMQuoteOmegaTerm -> "AGDATCMQUOTEOMEGATERM"+ BuiltinAgdaTCMIsMacro -> "AGDATCMISMACRO"+ BuiltinAgdaTCMWithNormalisation -> "AGDATCMWITHNORMALISATION"+ BuiltinAgdaTCMWithReconstructed -> "AGDATCMWITHRECONSTRUCTED"+ BuiltinAgdaTCMWithExpandLast -> "AGDATCMWITHEXPANDLAST"+ BuiltinAgdaTCMWithReduceDefs -> "AGDATCMWITHREDUCEDEFS"+ BuiltinAgdaTCMAskNormalisation -> "AGDATCMASKNORMALISATION"+ BuiltinAgdaTCMAskReconstructed -> "AGDATCMASKRECONSTRUCTED"+ BuiltinAgdaTCMAskExpandLast -> "AGDATCMASKEXPANDLAST"+ BuiltinAgdaTCMAskReduceDefs -> "AGDATCMASKREDUCEDEFS"+ BuiltinAgdaTCMFormatErrorParts -> "AGDATCMFORMATERRORPARTS"+ BuiltinAgdaTCMDebugPrint -> "AGDATCMDEBUGPRINT"+ BuiltinAgdaTCMNoConstraints -> "AGDATCMNOCONSTRAINTS"+ BuiltinAgdaTCMWorkOnTypes -> "AGDATCMWORKONTYPES"+ BuiltinAgdaTCMRunSpeculative -> "AGDATCMRUNSPECULATIVE"+ BuiltinAgdaTCMExec -> "AGDATCMEXEC"+ BuiltinAgdaTCMCheckFromString -> "AGDATCMCHECKFROMSTRING"+ BuiltinAgdaTCMGetInstances -> "AGDATCMGETINSTANCES"+ BuiltinAgdaTCMSolveInstances -> "AGDATCMSOLVEINSTANCES"+ BuiltinAgdaTCMPragmaForeign -> "AGDATCMPRAGMAFOREIGN"+ BuiltinAgdaTCMPragmaCompile -> "AGDATCMPRAGMACOMPILE"+ BuiltinAgdaBlocker -> "AGDABLOCKER"+ BuiltinAgdaBlockerAny -> "AGDABLOCKERANY"+ BuiltinAgdaBlockerAll -> "AGDABLOCKERALL"+ BuiltinAgdaBlockerMeta -> "AGDABLOCKERMETA"++-- | Builtins that come without a definition in Agda syntax.+-- These are giving names to Agda internal concepts which+-- cannot be assigned an Agda type.+--+-- An example would be a user-defined name for @Set@.+--+-- {-# BUILTIN TYPE Type #-}+--+-- The type of @Type@ would be @Type : Level → Setω@+-- which is not valid Agda.+isBuiltinNoDef :: BuiltinId -> Bool+isBuiltinNoDef = hasElem builtinsNoDef++builtinsNoDef :: [BuiltinId]+builtinsNoDef =+ sizeBuiltins +++ -- builtinConId,+ [ builtinIntervalUniv+ , builtinInterval+ , builtinPartial+ , builtinPartialP+ , builtinIsOne+ , builtinSub+ , builtinIZero+ , builtinIOne+ , builtinProp+ , builtinSet+ , builtinStrictSet+ , builtinPropOmega+ , builtinSetOmega+ , builtinSSetOmega+ , builtinLevelUniv+ ]++sizeBuiltins :: [BuiltinId]+sizeBuiltins =+ [ builtinSizeUniv+ , builtinSize+ , builtinSizeLt+ , builtinSizeSuc+ , builtinSizeInf+ , builtinSizeMax+ ]++builtinNat, builtinSuc, builtinZero, builtinNatPlus, builtinNatMinus,+ builtinNatTimes, builtinNatDivSucAux, builtinNatModSucAux, builtinNatEquals,+ builtinNatLess, builtinInteger, builtinIntegerPos, builtinIntegerNegSuc,+ builtinWord64,+ builtinFloat, builtinChar, builtinString, builtinUnit, builtinUnitUnit,+ builtinSigma,+ builtinBool, builtinTrue, builtinFalse,+ builtinList, builtinNil, builtinCons, builtinIO,+ builtinMaybe, builtinNothing, builtinJust,+ builtinPath, builtinPathP, builtinInterval, builtinIZero, builtinIOne, builtinPartial, builtinPartialP,+ builtinIsOne, builtinItIsOne, builtinIsOne1, builtinIsOne2, builtinIsOneEmpty,+ builtinSub, builtinSubIn,+ builtinEquiv, builtinEquivFun, builtinEquivProof,+ builtinTranspProof,+ builtinSizeUniv, builtinSize, builtinSizeLt,+ builtinSizeSuc, builtinSizeInf, builtinSizeMax,+ builtinInf, builtinSharp, builtinFlat,+ builtinEquality, builtinRefl, builtinRewrite, builtinLevelMax,+ builtinLevel, builtinLevelZero, builtinLevelSuc,+ builtinProp, builtinSet, builtinStrictSet,+ builtinPropOmega, builtinSetOmega, builtinSSetOmega,+ builtinLevelUniv,+ builtinIntervalUniv,+ builtinFromNat, builtinFromNeg, builtinFromString,+ builtinQuotientConstructor,+ builtinQName, builtinAgdaSort, builtinAgdaSortSet, builtinAgdaSortLit,+ builtinAgdaSortProp, builtinAgdaSortPropLit, builtinAgdaSortInf,+ builtinAgdaSortUnsupported,+ builtinHiding, builtinHidden, builtinInstance, builtinVisible,+ builtinRelevance, builtinRelevant, builtinIrrelevant,+ builtinQuantity, builtinQuantity0, builtinQuantityω,+ builtinModality, builtinModalityConstructor,+ builtinAssoc, builtinAssocLeft, builtinAssocRight, builtinAssocNon,+ builtinPrecedence, builtinPrecRelated, builtinPrecUnrelated,+ builtinFixity, builtinFixityFixity,+ builtinArgInfo, builtinArgArgInfo,+ builtinArg, builtinArgArg,+ builtinAbs, builtinAbsAbs, builtinAgdaTerm,+ builtinAgdaTermVar, builtinAgdaTermLam, builtinAgdaTermExtLam,+ builtinAgdaTermDef, builtinAgdaTermCon, builtinAgdaTermPi,+ builtinAgdaTermSort, builtinAgdaTermLit, builtinAgdaTermUnsupported, builtinAgdaTermMeta,+ builtinAgdaErrorPart, builtinAgdaErrorPartString, builtinAgdaErrorPartTerm, builtinAgdaErrorPartPatt, builtinAgdaErrorPartName,+ builtinAgdaLiteral, builtinAgdaLitNat, builtinAgdaLitWord64, builtinAgdaLitFloat,+ builtinAgdaLitChar, builtinAgdaLitString, builtinAgdaLitQName, builtinAgdaLitMeta,+ builtinAgdaClause, builtinAgdaClauseClause, builtinAgdaClauseAbsurd, builtinAgdaPattern,+ builtinAgdaPatVar, builtinAgdaPatCon, builtinAgdaPatDot, builtinAgdaPatLit,+ builtinAgdaPatProj, builtinAgdaPatAbsurd,+ builtinAgdaDefinitionFunDef,+ builtinAgdaDefinitionDataDef, builtinAgdaDefinitionRecordDef,+ builtinAgdaDefinitionDataConstructor, builtinAgdaDefinitionPostulate,+ builtinAgdaDefinitionPrimitive, builtinAgdaDefinition,+ builtinAgdaMeta,+ builtinAgdaTCM, builtinAgdaTCMReturn, builtinAgdaTCMBind, builtinAgdaTCMUnify,+ builtinAgdaTCMTypeError, builtinAgdaTCMInferType,+ builtinAgdaTCMCheckType, builtinAgdaTCMNormalise, builtinAgdaTCMReduce,+ builtinAgdaTCMCatchError,+ builtinAgdaTCMGetContext, builtinAgdaTCMExtendContext, builtinAgdaTCMInContext,+ builtinAgdaTCMFreshName, builtinAgdaTCMDeclareDef, builtinAgdaTCMDeclarePostulate, builtinAgdaTCMDeclareData, builtinAgdaTCMDefineData, builtinAgdaTCMDefineFun,+ builtinAgdaTCMGetType, builtinAgdaTCMGetDefinition,+ builtinAgdaTCMQuoteTerm, builtinAgdaTCMUnquoteTerm, builtinAgdaTCMQuoteOmegaTerm,+ builtinAgdaTCMCommit, builtinAgdaTCMIsMacro, builtinAgdaTCMBlock,+ builtinAgdaBlocker, builtinAgdaBlockerAll, builtinAgdaBlockerAny, builtinAgdaBlockerMeta,+ builtinAgdaTCMFormatErrorParts, builtinAgdaTCMDebugPrint,+ builtinAgdaTCMWithNormalisation, builtinAgdaTCMWithReconstructed,+ builtinAgdaTCMWithExpandLast, builtinAgdaTCMWithReduceDefs,+ builtinAgdaTCMAskNormalisation, builtinAgdaTCMAskReconstructed,+ builtinAgdaTCMAskExpandLast, builtinAgdaTCMAskReduceDefs,+ builtinAgdaTCMNoConstraints,+ builtinAgdaTCMWorkOnTypes,+ builtinAgdaTCMRunSpeculative,+ builtinAgdaTCMExec,+ builtinAgdaTCMCheckFromString,+ builtinAgdaTCMGetInstances,+ builtinAgdaTCMSolveInstances,+ builtinAgdaTCMPragmaForeign,+ builtinAgdaTCMPragmaCompile+ :: BuiltinId++builtinNat = BuiltinNat+builtinSuc = BuiltinSuc+builtinZero = BuiltinZero+builtinNatPlus = BuiltinNatPlus+builtinNatMinus = BuiltinNatMinus+builtinNatTimes = BuiltinNatTimes+builtinNatDivSucAux = BuiltinNatDivSucAux+builtinNatModSucAux = BuiltinNatModSucAux+builtinNatEquals = BuiltinNatEquals+builtinNatLess = BuiltinNatLess+builtinWord64 = BuiltinWord64+builtinInteger = BuiltinInteger+builtinIntegerPos = BuiltinIntegerPos+builtinIntegerNegSuc = BuiltinIntegerNegSuc+builtinFloat = BuiltinFloat+builtinChar = BuiltinChar+builtinString = BuiltinString+builtinUnit = BuiltinUnit+builtinUnitUnit = BuiltinUnitUnit+builtinSigma = BuiltinSigma+builtinBool = BuiltinBool+builtinTrue = BuiltinTrue+builtinFalse = BuiltinFalse+builtinList = BuiltinList+builtinNil = BuiltinNil+builtinCons = BuiltinCons+builtinMaybe = BuiltinMaybe+builtinNothing = BuiltinNothing+builtinJust = BuiltinJust+builtinIO = BuiltinIO+builtinPath = BuiltinPath+builtinPathP = BuiltinPathP+builtinIntervalUniv = BuiltinIntervalUniv+builtinInterval = BuiltinInterval+builtinIZero = BuiltinIZero+builtinIOne = BuiltinIOne+builtinPartial = BuiltinPartial+builtinPartialP = BuiltinPartialP+builtinIsOne = BuiltinIsOne+builtinItIsOne = BuiltinItIsOne+builtinEquiv = BuiltinEquiv+builtinEquivFun = BuiltinEquivFun+builtinEquivProof = BuiltinEquivProof+builtinTranspProof = BuiltinTranspProof+builtinIsOne1 = BuiltinIsOne1+builtinIsOne2 = BuiltinIsOne2+builtinIsOneEmpty = BuiltinIsOneEmpty+builtinSub = BuiltinSub+builtinSubIn = BuiltinSubIn+builtinSizeUniv = BuiltinSizeUniv+builtinSize = BuiltinSize+builtinSizeLt = BuiltinSizeLt+builtinSizeSuc = BuiltinSizeSuc+builtinSizeInf = BuiltinSizeInf+builtinSizeMax = BuiltinSizeMax+builtinInf = BuiltinInf+builtinSharp = BuiltinSharp+builtinFlat = BuiltinFlat+builtinEquality = BuiltinEquality+builtinRefl = BuiltinRefl+builtinRewrite = BuiltinRewrite+builtinLevelMax = BuiltinLevelMax+builtinLevel = BuiltinLevel+builtinLevelZero = BuiltinLevelZero+builtinLevelSuc = BuiltinLevelSuc+builtinProp = BuiltinProp+builtinSet = BuiltinSet+builtinStrictSet = BuiltinStrictSet+builtinPropOmega = BuiltinPropOmega+builtinSetOmega = BuiltinSetOmega+builtinSSetOmega = BuiltinSSetOmega+builtinLevelUniv = BuiltinLevelUniv+builtinFromNat = BuiltinFromNat+builtinFromNeg = BuiltinFromNeg+builtinFromString = BuiltinFromString+builtinQuotientConstructor = BuiltinQuotientConstructor+builtinQName = BuiltinQName+builtinAgdaSort = BuiltinAgdaSort+builtinAgdaSortSet = BuiltinAgdaSortSet+builtinAgdaSortLit = BuiltinAgdaSortLit+builtinAgdaSortProp = BuiltinAgdaSortProp+builtinAgdaSortPropLit = BuiltinAgdaSortPropLit+builtinAgdaSortInf = BuiltinAgdaSortInf+builtinAgdaSortUnsupported = BuiltinAgdaSortUnsupported+builtinHiding = BuiltinHiding+builtinHidden = BuiltinHidden+builtinInstance = BuiltinInstance+builtinVisible = BuiltinVisible+builtinRelevance = BuiltinRelevance+builtinRelevant = BuiltinRelevant+builtinIrrelevant = BuiltinIrrelevant+builtinQuantity = BuiltinQuantity+builtinQuantity0 = BuiltinQuantity0+builtinQuantityω = BuiltinQuantityω+builtinModality = BuiltinModality+builtinModalityConstructor = BuiltinModalityConstructor+builtinAssoc = BuiltinAssoc+builtinAssocLeft = BuiltinAssocLeft+builtinAssocRight = BuiltinAssocRight+builtinAssocNon = BuiltinAssocNon+builtinPrecedence = BuiltinPrecedence+builtinPrecRelated = BuiltinPrecRelated+builtinPrecUnrelated = BuiltinPrecUnrelated+builtinFixity = BuiltinFixity+builtinFixityFixity = BuiltinFixityFixity+builtinArg = BuiltinArg+builtinArgInfo = BuiltinArgInfo+builtinArgArgInfo = BuiltinArgArgInfo+builtinArgArg = BuiltinArgArg+builtinAbs = BuiltinAbs+builtinAbsAbs = BuiltinAbsAbs+builtinAgdaTerm = BuiltinAgdaTerm+builtinAgdaTermVar = BuiltinAgdaTermVar+builtinAgdaTermLam = BuiltinAgdaTermLam+builtinAgdaTermExtLam = BuiltinAgdaTermExtLam+builtinAgdaTermDef = BuiltinAgdaTermDef+builtinAgdaTermCon = BuiltinAgdaTermCon+builtinAgdaTermPi = BuiltinAgdaTermPi+builtinAgdaTermSort = BuiltinAgdaTermSort+builtinAgdaTermLit = BuiltinAgdaTermLit+builtinAgdaTermUnsupported = BuiltinAgdaTermUnsupported+builtinAgdaTermMeta = BuiltinAgdaTermMeta+builtinAgdaErrorPart = BuiltinAgdaErrorPart+builtinAgdaErrorPartString = BuiltinAgdaErrorPartString+builtinAgdaErrorPartTerm = BuiltinAgdaErrorPartTerm+builtinAgdaErrorPartPatt = BuiltinAgdaErrorPartPatt+builtinAgdaErrorPartName = BuiltinAgdaErrorPartName+builtinAgdaLiteral = BuiltinAgdaLiteral+builtinAgdaLitNat = BuiltinAgdaLitNat+builtinAgdaLitWord64 = BuiltinAgdaLitWord64+builtinAgdaLitFloat = BuiltinAgdaLitFloat+builtinAgdaLitChar = BuiltinAgdaLitChar+builtinAgdaLitString = BuiltinAgdaLitString+builtinAgdaLitQName = BuiltinAgdaLitQName+builtinAgdaLitMeta = BuiltinAgdaLitMeta+builtinAgdaClause = BuiltinAgdaClause+builtinAgdaClauseClause = BuiltinAgdaClauseClause+builtinAgdaClauseAbsurd = BuiltinAgdaClauseAbsurd+builtinAgdaPattern = BuiltinAgdaPattern+builtinAgdaPatVar = BuiltinAgdaPatVar+builtinAgdaPatCon = BuiltinAgdaPatCon+builtinAgdaPatDot = BuiltinAgdaPatDot+builtinAgdaPatLit = BuiltinAgdaPatLit+builtinAgdaPatProj = BuiltinAgdaPatProj+builtinAgdaPatAbsurd = BuiltinAgdaPatAbsurd+builtinAgdaDefinitionFunDef = BuiltinAgdaDefinitionFunDef+builtinAgdaDefinitionDataDef = BuiltinAgdaDefinitionDataDef+builtinAgdaDefinitionRecordDef = BuiltinAgdaDefinitionRecordDef+builtinAgdaDefinitionDataConstructor = BuiltinAgdaDefinitionDataConstructor+builtinAgdaDefinitionPostulate = BuiltinAgdaDefinitionPostulate+builtinAgdaDefinitionPrimitive = BuiltinAgdaDefinitionPrimitive+builtinAgdaDefinition = BuiltinAgdaDefinition+builtinAgdaMeta = BuiltinAgdaMeta+builtinAgdaTCM = BuiltinAgdaTCM+builtinAgdaTCMReturn = BuiltinAgdaTCMReturn+builtinAgdaTCMBind = BuiltinAgdaTCMBind+builtinAgdaTCMUnify = BuiltinAgdaTCMUnify+builtinAgdaTCMTypeError = BuiltinAgdaTCMTypeError+builtinAgdaTCMInferType = BuiltinAgdaTCMInferType+builtinAgdaTCMCheckType = BuiltinAgdaTCMCheckType+builtinAgdaTCMNormalise = BuiltinAgdaTCMNormalise+builtinAgdaTCMReduce = BuiltinAgdaTCMReduce+builtinAgdaTCMCatchError = BuiltinAgdaTCMCatchError+builtinAgdaTCMGetContext = BuiltinAgdaTCMGetContext+builtinAgdaTCMExtendContext = BuiltinAgdaTCMExtendContext+builtinAgdaTCMInContext = BuiltinAgdaTCMInContext+builtinAgdaTCMFreshName = BuiltinAgdaTCMFreshName+builtinAgdaTCMDeclareDef = BuiltinAgdaTCMDeclareDef+builtinAgdaTCMDeclarePostulate = BuiltinAgdaTCMDeclarePostulate+builtinAgdaTCMDeclareData = BuiltinAgdaTCMDeclareData+builtinAgdaTCMDefineData = BuiltinAgdaTCMDefineData+builtinAgdaTCMDefineFun = BuiltinAgdaTCMDefineFun+builtinAgdaTCMGetType = BuiltinAgdaTCMGetType+builtinAgdaTCMGetDefinition = BuiltinAgdaTCMGetDefinition+builtinAgdaTCMBlock = BuiltinAgdaTCMBlock+builtinAgdaTCMCommit = BuiltinAgdaTCMCommit+builtinAgdaTCMQuoteTerm = BuiltinAgdaTCMQuoteTerm+builtinAgdaTCMUnquoteTerm = BuiltinAgdaTCMUnquoteTerm+builtinAgdaTCMQuoteOmegaTerm = BuiltinAgdaTCMQuoteOmegaTerm+builtinAgdaTCMIsMacro = BuiltinAgdaTCMIsMacro+builtinAgdaTCMWithNormalisation = BuiltinAgdaTCMWithNormalisation+builtinAgdaTCMWithReconstructed = BuiltinAgdaTCMWithReconstructed+builtinAgdaTCMWithExpandLast = BuiltinAgdaTCMWithExpandLast+builtinAgdaTCMWithReduceDefs = BuiltinAgdaTCMWithReduceDefs+builtinAgdaTCMAskNormalisation = BuiltinAgdaTCMAskNormalisation+builtinAgdaTCMAskReconstructed = BuiltinAgdaTCMAskReconstructed+builtinAgdaTCMAskExpandLast = BuiltinAgdaTCMAskExpandLast+builtinAgdaTCMAskReduceDefs = BuiltinAgdaTCMAskReduceDefs+builtinAgdaTCMFormatErrorParts = BuiltinAgdaTCMFormatErrorParts+builtinAgdaTCMDebugPrint = BuiltinAgdaTCMDebugPrint+builtinAgdaTCMNoConstraints = BuiltinAgdaTCMNoConstraints+builtinAgdaTCMWorkOnTypes = BuiltinAgdaTCMWorkOnTypes+builtinAgdaTCMRunSpeculative = BuiltinAgdaTCMRunSpeculative+builtinAgdaTCMExec = BuiltinAgdaTCMExec+builtinAgdaTCMCheckFromString = BuiltinAgdaTCMCheckFromString+builtinAgdaTCMGetInstances = BuiltinAgdaTCMGetInstances+builtinAgdaTCMSolveInstances = BuiltinAgdaTCMSolveInstances+builtinAgdaTCMPragmaForeign = BuiltinAgdaTCMPragmaForeign+builtinAgdaTCMPragmaCompile = BuiltinAgdaTCMPragmaCompile+builtinAgdaBlocker = BuiltinAgdaBlocker+builtinAgdaBlockerAny = BuiltinAgdaBlockerAny+builtinAgdaBlockerAll = BuiltinAgdaBlockerAll+builtinAgdaBlockerMeta = BuiltinAgdaBlockerMeta++-- | Lookup a builtin by the string used in the @BUILTIN@ pragma.+builtinById :: String -> Maybe BuiltinId+builtinById = flip M.lookup m where+ m = M.fromList [(getBuiltinId x, x) | x <- [(minBound :: BuiltinId)..]]++-- * Primitives++-- | A primitive name, defined by the @primitive@ block.+data PrimitiveId+ -- Cubical+ = PrimIMin+ | PrimIMax+ | PrimINeg+ | PrimPartial+ | PrimPartialP+ | PrimSubOut+ | PrimGlue+ | Prim_glue+ | Prim_unglue+ | Prim_glueU+ | Prim_unglueU+ | PrimFaceForall+ | PrimComp+ | PrimPOr+ | PrimTrans+ | PrimHComp+ -- Integer+ | PrimShowInteger+ -- Natural+ | PrimNatPlus+ | PrimNatMinus+ | PrimNatTimes+ | PrimNatDivSucAux+ | PrimNatModSucAux+ | PrimNatEquality+ | PrimNatLess+ | PrimShowNat+ -- Word64+ | PrimWord64FromNat+ | PrimWord64ToNat+ | PrimWord64ToNatInjective+ -- Level+ | PrimLevelZero+ | PrimLevelSuc+ | PrimLevelMax+ -- Float+ | PrimFloatEquality+ | PrimFloatInequality+ | PrimFloatLess+ | PrimFloatIsInfinite+ | PrimFloatIsNaN+ | PrimFloatIsNegativeZero+ | PrimFloatIsSafeInteger+ | PrimFloatToWord64+ | PrimFloatToWord64Injective+ | PrimNatToFloat+ | PrimIntToFloat+ | PrimFloatRound+ | PrimFloatFloor+ | PrimFloatCeiling+ | PrimFloatToRatio+ | PrimRatioToFloat+ | PrimFloatDecode+ | PrimFloatEncode+ | PrimShowFloat+ | PrimFloatPlus+ | PrimFloatMinus+ | PrimFloatTimes+ | PrimFloatNegate+ | PrimFloatDiv+ | PrimFloatPow+ | PrimFloatSqrt+ | PrimFloatExp+ | PrimFloatLog+ | PrimFloatSin+ | PrimFloatCos+ | PrimFloatTan+ | PrimFloatASin+ | PrimFloatACos+ | PrimFloatATan+ | PrimFloatATan2+ | PrimFloatSinh+ | PrimFloatCosh+ | PrimFloatTanh+ | PrimFloatASinh+ | PrimFloatACosh+ | PrimFloatATanh+ -- Character+ | PrimCharEquality+ | PrimIsLower+ | PrimIsDigit+ | PrimIsAlpha+ | PrimIsSpace+ | PrimIsAscii+ | PrimIsLatin1+ | PrimIsPrint+ | PrimIsHexDigit+ | PrimToUpper+ | PrimToLower+ | PrimCharToNat+ | PrimCharToNatInjective+ | PrimNatToChar+ | PrimShowChar+ -- String+ | PrimStringToList+ | PrimStringToListInjective+ | PrimStringFromList+ | PrimStringFromListInjective+ | PrimStringAppend+ | PrimStringEquality+ | PrimShowString+ | PrimStringUncons+ -- Quotients+ | PrimQrec+ -- "Other stuff"+ | PrimErase+ | PrimEraseEquality+ | PrimForce+ | PrimForceLemma+ | PrimQNameEquality+ | PrimQNameLess+ | PrimShowQName+ | PrimQNameFixity+ | PrimQNameToWord64s+ | PrimQNameToWord64sInjective+ | PrimMetaEquality+ | PrimMetaLess+ | PrimShowMeta+ | PrimMetaToNat+ | PrimMetaToNatInjective+ | PrimLockUniv+ | PrimRewriteNoMatch+ deriving (Show, Eq, Ord, Bounded, Enum, Generic)++instance NFData PrimitiveId++instance Hashable PrimitiveId where+ s `hashWithSalt` b = s `hashWithSalt` fromEnum b++instance KillRange PrimitiveId where+ killRange = id++instance Pretty PrimitiveId where+ pretty = text . getBuiltinId++instance IsBuiltin PrimitiveId where+ someBuiltin = PrimitiveName++ getBuiltinId = \case+ -- Cubical+ PrimIMin -> "primIMin"+ PrimIMax -> "primIMax"+ PrimINeg -> "primINeg"+ PrimPartial -> "primPartial"+ PrimPartialP -> "primPartialP"+ PrimSubOut -> "primSubOut"+ PrimGlue -> "primGlue"+ Prim_glue -> "prim^glue"+ Prim_unglue -> "prim^unglue"+ Prim_glueU -> "prim^glueU"+ Prim_unglueU -> "prim^unglueU"+ PrimFaceForall -> "primFaceForall"+ PrimComp -> "primComp"+ PrimPOr -> "primPOr"+ PrimTrans -> "primTransp"+ PrimHComp -> "primHComp"+ -- Integer+ PrimShowInteger -> "primShowInteger"+ -- Natural+ PrimNatPlus -> "primNatPlus"+ PrimNatMinus -> "primNatMinus"+ PrimNatTimes -> "primNatTimes"+ PrimNatDivSucAux -> "primNatDivSucAux"+ PrimNatModSucAux -> "primNatModSucAux"+ PrimNatEquality -> "primNatEquality"+ PrimNatLess -> "primNatLess"+ PrimShowNat -> "primShowNat"+ -- Word64+ PrimWord64FromNat -> "primWord64FromNat"+ PrimWord64ToNat -> "primWord64ToNat"+ PrimWord64ToNatInjective -> "primWord64ToNatInjective"+ -- Level+ PrimLevelZero -> "primLevelZero"+ PrimLevelSuc -> "primLevelSuc"+ PrimLevelMax -> "primLevelMax"+ -- Float+ PrimFloatEquality -> "primFloatEquality"+ PrimFloatInequality -> "primFloatInequality"+ PrimFloatLess -> "primFloatLess"+ PrimFloatIsInfinite -> "primFloatIsInfinite"+ PrimFloatIsNaN -> "primFloatIsNaN"+ PrimFloatIsNegativeZero -> "primFloatIsNegativeZero"+ PrimFloatIsSafeInteger -> "primFloatIsSafeInteger"+ PrimFloatToWord64 -> "primFloatToWord64"+ PrimFloatToWord64Injective -> "primFloatToWord64Injective"+ PrimNatToFloat -> "primNatToFloat"+ PrimIntToFloat -> "primIntToFloat"+ PrimFloatRound -> "primFloatRound"+ PrimFloatFloor -> "primFloatFloor"+ PrimFloatCeiling -> "primFloatCeiling"+ PrimFloatToRatio -> "primFloatToRatio"+ PrimRatioToFloat -> "primRatioToFloat"+ PrimFloatDecode -> "primFloatDecode"+ PrimFloatEncode -> "primFloatEncode"+ PrimShowFloat -> "primShowFloat"+ PrimFloatPlus -> "primFloatPlus"+ PrimFloatMinus -> "primFloatMinus"+ PrimFloatTimes -> "primFloatTimes"+ PrimFloatNegate -> "primFloatNegate"+ PrimFloatDiv -> "primFloatDiv"+ PrimFloatPow -> "primFloatPow"+ PrimFloatSqrt -> "primFloatSqrt"+ PrimFloatExp -> "primFloatExp"+ PrimFloatLog -> "primFloatLog"+ PrimFloatSin -> "primFloatSin"+ PrimFloatCos -> "primFloatCos"+ PrimFloatTan -> "primFloatTan"+ PrimFloatASin -> "primFloatASin"+ PrimFloatACos -> "primFloatACos"+ PrimFloatATan -> "primFloatATan"+ PrimFloatATan2 -> "primFloatATan2"+ PrimFloatSinh -> "primFloatSinh"+ PrimFloatCosh -> "primFloatCosh"+ PrimFloatTanh -> "primFloatTanh"+ PrimFloatASinh -> "primFloatASinh"+ PrimFloatACosh -> "primFloatACosh"+ PrimFloatATanh -> "primFloatATanh"+ -- Character+ PrimCharEquality -> "primCharEquality"+ PrimIsLower -> "primIsLower"+ PrimIsDigit -> "primIsDigit"+ PrimIsAlpha -> "primIsAlpha"+ PrimIsSpace -> "primIsSpace"+ PrimIsAscii -> "primIsAscii"+ PrimIsLatin1 -> "primIsLatin1"+ PrimIsPrint -> "primIsPrint"+ PrimIsHexDigit -> "primIsHexDigit"+ PrimToUpper -> "primToUpper"+ PrimToLower -> "primToLower"+ PrimCharToNat -> "primCharToNat"+ PrimCharToNatInjective -> "primCharToNatInjective"+ PrimNatToChar -> "primNatToChar"+ PrimShowChar -> "primShowChar"+ -- String+ PrimStringToList -> "primStringToList"+ PrimStringToListInjective -> "primStringToListInjective"+ PrimStringFromList -> "primStringFromList"+ PrimStringFromListInjective -> "primStringFromListInjective"+ PrimStringAppend -> "primStringAppend"+ PrimStringEquality -> "primStringEquality"+ PrimShowString -> "primShowString"+ PrimStringUncons -> "primStringUncons"+ -- Quotients+ PrimQrec -> "qrec"+ -- "Other stuff"+ PrimErase -> "primErase"+ PrimEraseEquality -> "primEraseEquality"+ PrimForce -> "primForce"+ PrimForceLemma -> "primForceLemma"+ PrimQNameEquality -> "primQNameEquality"+ PrimQNameLess -> "primQNameLess"+ PrimShowQName -> "primShowQName"+ PrimQNameFixity -> "primQNameFixity"+ PrimQNameToWord64s -> "primQNameToWord64s"+ PrimQNameToWord64sInjective -> "primQNameToWord64sInjective"+ PrimMetaEquality -> "primMetaEquality"+ PrimMetaLess -> "primMetaLess"+ PrimShowMeta -> "primShowMeta"+ PrimMetaToNat -> "primMetaToNat"+ PrimMetaToNatInjective -> "primMetaToNatInjective"+ PrimLockUniv -> "primLockUniv"+ PrimRewriteNoMatch -> "primRewriteNoMatch"++builtinSubOut,+ builtinIMin, builtinIMax, builtinINeg,+ builtinGlue, builtin_glue, builtin_unglue, builtin_glueU, builtin_unglueU,+ builtinFaceForall, builtinComp, builtinPOr,+ builtinTrans, builtinHComp, builtinLockUniv, builtinRewriteNoMatch+ :: PrimitiveId+builtinIMin = PrimIMin+builtinIMax = PrimIMax+builtinINeg = PrimINeg+builtinSubOut = PrimSubOut+builtinGlue = PrimGlue+builtin_glue = Prim_glue+builtin_unglue = Prim_unglue+builtin_glueU = Prim_glueU+builtin_unglueU = Prim_unglueU+builtinFaceForall = PrimFaceForall+builtinComp = PrimComp+builtinPOr = PrimPOr+builtinTrans = PrimTrans+builtinHComp = PrimHComp+builtinLockUniv = PrimLockUniv+builtinRewriteNoMatch = PrimRewriteNoMatch++-- | Lookup a primitive by its identifier.+primitiveById :: String -> Maybe PrimitiveId+primitiveById = flip M.lookup m where+ m = M.fromList [(getBuiltinId x, x) | x <- [(minBound :: PrimitiveId)..]]
@@ -1,179 +1,4385 @@-{-# LANGUAGE CPP, FlexibleInstances, DeriveDataTypeable,- DeriveFunctor, DeriveFoldable, DeriveTraversable #-}--{-| Some common syntactic entities are defined in this module.--}-module Agda.Syntax.Common where--import Data.Generics (Typeable, Data)-import Control.Applicative-import Data.Foldable-import Data.Traversable-import Test.QuickCheck--import Agda.Syntax.Position-import Agda.Utils.Monad-import Agda.Utils.Size--#include "../undefined.h"-import Agda.Utils.Impossible--data Induction = Inductive | CoInductive- deriving (Typeable, Data, Show, Eq, Ord)--data Hiding = Hidden | Instance | NotHidden- deriving (Typeable, Data, Show, Eq, Ord)---- | A function argument can be relevant or irrelevant.--- See 'Agda.TypeChecking.Irrelevance'.-data Relevance- = Relevant -- ^ the argument is (possibly) relevant at compile-time- | NonStrict -- ^ the argument may never flow into evaluation position.- -- Therefore, it is irrelevant at run-time.- -- It is treated relevantly during equality checking.- | Irrelevant -- ^ the argument is irrelevant at compile- and runtime- | Forced -- ^ the argument can be skipped during equality checking- deriving (Typeable, Data, Show, Eq)--instance Ord Relevance where- (<=) = moreRelevant---- | Information ordering.--- @Relevant `moreRelevant` Forced `moreRelevant` NonStrict `moreRelevant` Irrelevant@-moreRelevant :: Relevance -> Relevance -> Bool-moreRelevant r r' =- case (r, r') of- -- top- (_, Irrelevant) -> True- (Irrelevant, _) -> False- -- bottom- (Relevant, _) -> True- (_, Relevant) -> False- -- second bottom- (Forced, _) -> True- (_, Forced) -> False- -- remaining case- (NonStrict,NonStrict) -> True--instance KillRange Induction where killRange = id-instance KillRange Hiding where killRange = id---- | A function argument can be hidden and/or irrelevant.-data Arg e = Arg- { argHiding :: Hiding- , argRelevance :: Relevance- , unArg :: e- } deriving (Typeable, Data, Ord, Functor, Foldable, Traversable)--instance Eq a => Eq (Arg a) where- Arg h1 _ x1 == Arg h2 _ x2 = (h1, x1) == (h2, x2)--makeInstance :: Arg a -> Arg a-makeInstance a = a { argHiding = Instance }--hide :: Arg a -> Arg a-hide a = a { argHiding = Hidden }--defaultArg :: a -> Arg a-defaultArg = Arg NotHidden Relevant--isHiddenArg :: Arg a -> Bool-isHiddenArg arg = argHiding arg /= NotHidden---- | @xs `withArgsFrom` args@ translates @xs@ into a list of 'Arg's,--- using the elements in @args@ to fill in the non-'unArg' fields.------ Precondition: The two lists should have equal length.--withArgsFrom :: [a] -> [Arg b] -> [Arg a]-xs `withArgsFrom` args =- zipWith (\x arg -> fmap (const x) arg) xs args--instance HasRange a => HasRange (Arg a) where- getRange = getRange . unArg--instance KillRange a => KillRange (Arg a) where- killRange = fmap killRange--instance Sized a => Sized (Arg a) where- size = size . unArg--instance Show a => Show (Arg a) where- show (Arg h r x) = showR r $ showH h $ show x- where- showH Hidden s = "{" ++ s ++ "}"- showH NotHidden s = "(" ++ s ++ ")"- showH Instance s = "{{" ++ s ++ "}}"- showR Irrelevant s = "." ++ s- showR NonStrict s = "?" ++ s- showR Forced s = "!" ++ s- showR Relevant s = "r" ++ s -- Andreas: I want to see it explicitly--data Named name a =- Named { nameOf :: Maybe name- , namedThing :: a- }- deriving (Eq, Ord, Typeable, Data, Functor, Foldable, Traversable)--unnamed :: a -> Named name a-unnamed = Named Nothing--named :: name -> a -> Named name a-named = Named . Just--instance HasRange a => HasRange (Named name a) where- getRange = getRange . namedThing--instance KillRange a => KillRange (Named name a) where- killRange = fmap killRange--instance Sized a => Sized (Named name a) where- size = size . namedThing--instance Show a => Show (Named String a) where- show (Named Nothing x) = show x- show (Named (Just n) x) = n ++ " = " ++ show x---- | Only 'Hidden' arguments can have names.-type NamedArg a = Arg (Named String a)---- | Functions can be defined in both infix and prefix style. See--- 'Agda.Syntax.Concrete.LHS'.-data IsInfix = InfixDef | PrefixDef- deriving (Typeable, Data, Show, Eq, Ord)---- | Access modifier.-data Access = PrivateAccess | PublicAccess- | OnlyQualified -- ^ Visible from outside, but not exported when opening the module- -- Used for qualified constructors.- deriving (Typeable, Data, Show, Eq, Ord)---- | Abstract or concrete-data IsAbstract = AbstractDef | ConcreteDef- deriving (Typeable, Data, Show, Eq, Ord)--type Nat = Integer-type Arity = Nat---- | The unique identifier of a name. Second argument is the top-level module--- identifier.-data NameId = NameId Nat Integer- deriving (Eq, Ord, Typeable, Data)--instance Enum NameId where- succ (NameId n m) = NameId (n + 1) m- pred (NameId n m) = NameId (n - 1) m- toEnum n = __IMPOSSIBLE__ -- should not be used- fromEnum (NameId n _) = fromIntegral n--newtype Constr a = Constr a----------------------------------------------------------------------------- Arbitrary and CoArbitrary instances--instance Arbitrary Induction where- arbitrary = elements [Inductive, CoInductive]--instance CoArbitrary Induction where- coarbitrary Inductive = variant 0- coarbitrary CoInductive = variant 1+-- {-# OPTIONS_GHC -Wunused-imports #-} -- does not work because of liftA2+{-# OPTIONS_GHC -Wunused-matches #-}++{-| Some common syntactic entities are defined in this module.+-}+module Agda.Syntax.Common+ ( module Agda.Syntax.Common+ , module Agda.Syntax.Common.KeywordRange+ , module Agda.Syntax.TopLevelModuleName.Boot+ , Induction(..)+ )+ where++import Agda.Syntax.TopLevelModuleName.Boot++import Prelude hiding (null)++import Control.DeepSeq+import Control.Applicative ((<|>), liftA2)++import Data.Array (Ix)+import Data.Bifunctor+import Data.ByteString.Char8 (ByteString)+import qualified Data.ByteString.Char8 as ByteString+import qualified Data.Foldable as Fold+import Data.Function (on)+import Data.Hashable (Hashable(..))+import qualified Data.Strict.Maybe as Strict+import Data.Word+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet+import Data.HashSet (HashSet)+import qualified Data.HashSet as HashSet+import Data.Text (Text)++import GHC.Generics (Generic)++import Agda.Syntax.Common.Aspect (Induction(..))+import Agda.Syntax.Common.KeywordRange+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete.Glyph+import Agda.Syntax.Position++import Agda.Utils.Boolean (Boolean(fromBool), IsBool(toBool))+import Agda.Utils.Float (toStringWithoutDotZero)+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.Hash (combineWord)+import Agda.Utils.List ( lastMaybe )+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Null+import Agda.Utils.PartialOrd+import Agda.Utils.POMonoid+import Agda.Utils.Singleton+import Agda.Utils.SmallSet (SmallSetElement)+import Agda.Utils.VarSet (VarSet)+import qualified Agda.Utils.VarSet as VarSet++import Agda.Utils.Impossible++-- | Number @>= 0@.+type Nat = Int+type Arity = Nat++-- | Number @>= 1@.+type Nat1 = Nat++---------------------------------------------------------------------------+-- * IsMain+---------------------------------------------------------------------------++data IsMain = IsMain | NotMain+ deriving (Eq, Show)++-- | Conjunctive semigroup ('NotMain' is absorbing).+instance Semigroup IsMain where+ NotMain <> _ = NotMain+ _ <> NotMain = NotMain+ IsMain <> IsMain = IsMain++instance Monoid IsMain where+ mempty = IsMain+ mappend = (<>)++---------------------------------------------------------------------------+-- * File+---------------------------------------------------------------------------++data FileType = AgdaFileType | MdFileType | RstFileType | TexFileType | OrgFileType | TypstFileType | TreeFileType+ deriving (Eq, Ord, Show, Generic)++instance Pretty FileType where+ pretty = \case+ AgdaFileType -> "Agda"+ MdFileType -> "Markdown"+ RstFileType -> "ReStructedText"+ TexFileType -> "LaTeX"+ OrgFileType -> "org-mode"+ TypstFileType -> "Typst"+ TreeFileType -> "Forester"++instance NFData FileType++---------------------------------------------------------------------------+-- * Agda variants+---------------------------------------------------------------------------++-- | Variants of Cubical Agda.++data Cubical = CWithoutGlue | CErased | CFull+ deriving (Eq, Show, Generic)++instance NFData Cubical++cubicalOptionString :: Cubical -> String+cubicalOptionString = \case+ CWithoutGlue -> "--cubical=no-glue"+ CErased -> "--cubical=erased"+ CFull -> "--cubical[=full]"++-- | Agda variants.+--+-- Only some variants are tracked.++data Language+ = WithoutK+ | WithK+ | Cubical Cubical+ deriving (Eq, Show, Generic)++instance KillRange Language where+ killRange = id++instance NFData Language++------------------------------------------------------------------------+-- Erased matches++-- | What kinds of erased matches are allowed for indexed,+-- single-constructor data types?++data AllowedErasedMatchesIndexed+ = Restricted+ -- ^ @[]-cong@ is allowed.+ | Unrestricted+ -- ^ All erased matches are allowed.+ deriving (Eq, Ord, Show, Generic)++instance NFData AllowedErasedMatchesIndexed++instance Semigroup AllowedErasedMatchesIndexed where+ Restricted <> a2 = a2+ a1 <> _ = a1++instance Monoid AllowedErasedMatchesIndexed where+ mempty = Restricted++-- | What kinds of erased matches are allowed?++data AllowedErasedMatches = AllowedErasedMatches+ { emEmpty :: !Bool+ -- ^ Erased matches are allowed for the empty type.+ , emNonDependent :: !Bool+ -- ^ Erased matches are allowed for single-constructor,+ -- non-indexed data types.+ , emDependent :: !(Strict.Maybe AllowedErasedMatchesIndexed)+ -- ^ What kinds of erased matches, if any, are allowed for+ -- single-constructor, indexed data types?+ }+ deriving (Eq, Ord, Show, Generic)++instance NFData AllowedErasedMatches++instance Semigroup AllowedErasedMatches where+ AllowedErasedMatches e1 n1 d1 <> AllowedErasedMatches e2 n2 d2 =+ AllowedErasedMatches (e1 || e2) (n1 || n2) (d1 <> d2)++instance Monoid AllowedErasedMatches where+ mempty = AllowedErasedMatches+ { emEmpty = False+ , emNonDependent = False+ , emDependent = Strict.Nothing+ }++-- | Is @[]-cong@ allowed?++emRestricted :: AllowedErasedMatches -> Bool+emRestricted = Strict.isJust . emDependent++-- | Are unrestricted erased matches allowed for indexed types?++emUnrestricted :: AllowedErasedMatches -> Bool+emUnrestricted = (Strict.Just Unrestricted ==) . emDependent++-- | A variant of 'AllowedErasedMatches' that supports default values+-- that depend on other flags.++data AllowedErasedMatchesWithDefaults+ = ErasedMatchesDefault+ -- ^ No flag has been given, the default is used. (The default+ -- depends on whether the K rule is allowed or not.)+ | ErasedMatchesDefaultOn+ -- ^ The flag @--erased-matches@ has been given without any+ -- options, the \"default on\" value is used. (The default depends+ -- on whether the K rule is allowed or not.)+ | ErasedMatches AllowedErasedMatches+ -- ^ The flag @--erased-matches@ has been given with (valid)+ -- options.+ deriving (Eq, Show, Generic)++instance NFData AllowedErasedMatchesWithDefaults++instance Semigroup AllowedErasedMatchesWithDefaults where+ ErasedMatches m1 <> ErasedMatches m2 =+ ErasedMatches (m1 <> m2)+ m@ErasedMatches{} <> _ =+ m+ _ <> m@ErasedMatches{} =+ m+ m@ErasedMatchesDefaultOn <> _ =+ m+ ErasedMatchesDefault <> m =+ m++instance Monoid AllowedErasedMatchesWithDefaults where+ mempty = ErasedMatchesDefault++---------------------------------------------------------------------------+-- * Backends+---------------------------------------------------------------------------++type BackendName = Text++---------------------------------------------------------------------------+-- * Some enums+---------------------------------------------------------------------------++-- | Distinguish constructors from pattern synonyms.++data ConstructorOrPatternSynonym = IsConstructor | IsPatternSynonym+ deriving (Show, Generic, Enum, Bounded)++instance Pretty ConstructorOrPatternSynonym where+ pretty = \case+ IsConstructor -> "constructor"+ IsPatternSynonym -> "pattern synonym"++instance NFData ConstructorOrPatternSynonym++-- | Distinguish parsing a DISPLAY pragma from an ordinary left hand side.++data DisplayLHS = YesDisplayLHS | NoDisplayLHS+ deriving (Eq, Show, Generic, Enum, Bounded)++instance Boolean DisplayLHS where+ fromBool = \case+ True -> YesDisplayLHS+ False -> NoDisplayLHS++instance IsBool DisplayLHS where+ toBool = \case+ YesDisplayLHS -> True+ NoDisplayLHS -> False++-- | Expression kinds: Expressions or patterns.++data ExprKind = IsExpr | IsPattern DisplayLHS+ deriving (Eq, Show)++isKindPattern :: ExprKind -> Bool+isKindPattern (IsPattern _) = True+isKindPattern IsExpr = False++---------------------------------------------------------------------------+-- * Record Directives+---------------------------------------------------------------------------++data RecordDirectives' a = RecordDirectives+ { recInductive :: Maybe (Ranged Induction)+ , recHasEta :: Maybe (Ranged HasEta0)+ , recPattern :: Maybe Range+ , recConstructor :: a+ } deriving (Functor, Show, Eq, Foldable, Traversable)++instance Null a => Null (RecordDirectives' a) where+ empty = emptyRecordDirectives+ null (RecordDirectives a b c d) = and [null a, null b, null c, null d]++emptyRecordDirectives :: Null a => RecordDirectives' a+emptyRecordDirectives = RecordDirectives empty empty empty empty++instance HasRange a => HasRange (RecordDirectives' a) where+ getRange (RecordDirectives a b c d) = getRange (a,b,c,d)++instance KillRange a => KillRange (RecordDirectives' a) where+ killRange (RecordDirectives a b c d) = killRangeN RecordDirectives a b c d++instance NFData a => NFData (RecordDirectives' a) where+ rnf (RecordDirectives a b c d) = c `seq` rnf (a, b, d)++---------------------------------------------------------------------------+-- * Eta-equality+---------------------------------------------------------------------------++-- | Does a record come with eta-equality?+data HasEta' a+ = YesEta+ | NoEta a+ deriving (Show, Eq, Ord, Functor, Foldable, Traversable)++instance HasRange a => HasRange (HasEta' a) where+ getRange = foldMap getRange++instance KillRange a => KillRange (HasEta' a) where+ killRange = fmap killRange++instance NFData a => NFData (HasEta' a) where+ rnf YesEta = ()+ rnf (NoEta p) = rnf p++-- | Pattern and copattern matching is allowed in the presence of eta.+--+-- In the absence of eta, we have to choose whether we want to allow+-- matching on the constructor or copattern matching with the projections.+-- Having both leads to breakage of subject reduction (issue #4560).++type HasEta = HasEta' PatternOrCopattern+type HasEta0 = HasEta' ()++-- | For a record without eta, which type of matching do we allow?+data PatternOrCopattern+ = PatternMatching+ -- ^ Can match on the record constructor.+ | CopatternMatching+ -- ^ Can copattern match using the projections. (Default.)+ deriving (Show, Eq, Ord, Enum, Bounded)++instance NFData PatternOrCopattern where+ rnf PatternMatching = ()+ rnf CopatternMatching = ()++instance HasRange PatternOrCopattern where+ getRange _ = noRange++instance KillRange PatternOrCopattern where+ killRange = id++-- | Can we pattern match on the record constructor?+class PatternMatchingAllowed a where+ patternMatchingAllowed :: a -> Bool++instance PatternMatchingAllowed PatternOrCopattern where+ patternMatchingAllowed = (== PatternMatching)++instance PatternMatchingAllowed HasEta where+ patternMatchingAllowed = \case+ YesEta -> True+ NoEta p -> patternMatchingAllowed p+++-- | Can we construct a record by copattern matching?+class CopatternMatchingAllowed a where+ copatternMatchingAllowed :: a -> Bool++instance CopatternMatchingAllowed PatternOrCopattern where+ copatternMatchingAllowed = (== CopatternMatching)++instance CopatternMatchingAllowed HasEta where+ copatternMatchingAllowed = \case+ YesEta -> True+ NoEta p -> copatternMatchingAllowed p++---------------------------------------------------------------------------+-- * Data or record+---------------------------------------------------------------------------++data DataOrRecord' p+ = IsData+ | IsRecord p+ deriving (Show, Eq, Generic)++instance KillRange a => KillRange (DataOrRecord' a) where+ killRange = \case+ IsData -> IsData+ IsRecord a -> killRangeN IsRecord a++type DataOrRecord = DataOrRecord' PatternOrCopattern+type DataOrRecord_ = DataOrRecord' ()+type DataOrRecordEta = DataOrRecord' ForceRecordEta++pattern IsRecord_ :: DataOrRecord_+pattern IsRecord_ = IsRecord ()++{-# COMPLETE IsData, IsRecord_ #-}++instance Boolean DataOrRecord_ where+ fromBool True = IsData+ fromBool False = IsRecord_++instance IsBool DataOrRecord_ where+ toBool IsData = True+ toBool IsRecord_ = False++instance PatternMatchingAllowed DataOrRecord where+ patternMatchingAllowed = \case+ IsData -> True+ IsRecord patCopat -> patternMatchingAllowed patCopat++instance CopatternMatchingAllowed DataOrRecord where+ copatternMatchingAllowed = \case+ IsData -> False+ IsRecord patCopat -> copatternMatchingAllowed patCopat++---------------------------------------------------------------------------+-- * Induction+---------------------------------------------------------------------------++-- | Does a datatype have path constructors, i.e. is it a HIT?+data IsHIT = YesHIT | NotHIT+ deriving (Eq, Ord, Show, Generic)++instance Boolean IsHIT where+ fromBool True = YesHIT+ fromBool False = NotHIT++instance IsBool IsHIT where+ toBool YesHIT = True+ toBool NotHIT = False++instance KillRange IsHIT where+ killRange = id++instance NFData IsHIT++instance Pretty Induction where+ pretty Inductive = "inductive"+ pretty CoInductive = "coinductive"++instance HasRange Induction where+ getRange _ = noRange++instance KillRange Induction where+ killRange = id++instance PatternMatchingAllowed Induction where+ patternMatchingAllowed = (== Inductive)++---------------------------------------------------------------------------+-- * Overlapping instances+---------------------------------------------------------------------------++data Overlappable = YesOverlap | NoOverlap+ deriving (Show, Eq, Ord)++-- | Just for the 'Hiding' instance. Should never combine different+-- overlapping.+instance Semigroup Overlappable where+ NoOverlap <> NoOverlap = NoOverlap+ YesOverlap <> YesOverlap = YesOverlap+ _ <> _ = __IMPOSSIBLE__++instance Monoid Overlappable where+ mempty = NoOverlap+ mappend = (<>)++instance NFData Overlappable where+ rnf NoOverlap = ()+ rnf YesOverlap = ()++-- | The possible overlap modes for an instance, also used for instance candidates.+data OverlapMode+ = Overlappable+ -- ^ User-written OVERLAPPABLE pragma: this candidate can *be removed*+ -- by a more specific candidate.++ | Overlapping+ -- ^ User-written OVERLAPPING pragma: this candidate can *remove* a+ -- less specific candidate.++ | Overlaps+ -- ^ User-written OVERLAPS pragma: both overlappable and overlapping.++ | DefaultOverlap+ -- ^ No user-written overlap pragma. This instance can be overlapped+ -- by an OVERLAPPING instance, and it can overlap OVERLAPPABLE+ -- instances.++ | Incoherent+ -- ^ User-written INCOHERENT pragma: both overlappable and+ -- overlapping; and, if there are multiple candidates after all+ -- overlap has been handled, make an arbitrary choice.++ | FieldOverlap+ -- ^ Overlapping instances in record fields.+ deriving (Show, Eq, Ord, Enum, Bounded)++instance Pretty OverlapMode where+ pretty = \case+ Overlappable -> "OVERLAPPABLE"+ Overlapping -> "OVERLAPPING"+ Incoherent -> "INCOHERENT"+ Overlaps -> "OVERLAPS"+ FieldOverlap -> "overlap"+ DefaultOverlap -> empty++instance KillRange OverlapMode where+ killRange = id++instance NFData OverlapMode where+ rnf = \case+ Overlappable -> ()+ Overlapping -> ()+ Overlaps -> ()+ DefaultOverlap -> ()+ FieldOverlap -> ()+ Incoherent -> ()++class HasOverlapMode a where+ lensOverlapMode :: Lens' a OverlapMode++instance HasOverlapMode OverlapMode where+ lensOverlapMode = id++isIncoherent, isOverlappable, isOverlapping :: HasOverlapMode a => a -> Bool+isIncoherent x = case x ^. lensOverlapMode of+ Incoherent -> True+ _ -> False++isOverlappable x = case x ^. lensOverlapMode of+ Overlappable -> True+ Incoherent -> True+ Overlaps -> True+ _ -> False++isOverlapping x = case x ^. lensOverlapMode of+ Overlapping -> True+ Incoherent -> True+ Overlaps -> True+ _ -> False++---------------------------------------------------------------------------+-- * Hiding+---------------------------------------------------------------------------++data Hiding = Hidden | Instance Overlappable | NotHidden+ deriving (Show, Eq, Ord)++instance Pretty Hiding where+ pretty = text . hidingToString++hidingToString :: Hiding -> String+hidingToString = \case+ Hidden -> "hidden"+ NotHidden -> "visible"+ Instance{} -> "instance"++instance Null Hiding where+ empty = NotHidden++-- | 'Hiding' is an idempotent partial monoid, with unit 'NotHidden'.+-- 'Instance' and 'NotHidden' are incompatible.+instance Semigroup Hiding where+ NotHidden <> h = h+ h <> NotHidden = h+ Hidden <> Hidden = Hidden+ Instance o <> Instance o' = Instance (o <> o')+ _ <> _ = __IMPOSSIBLE__++instance Monoid Hiding where+ mempty = empty+ mappend = (<>)++instance HasRange Hiding where+ getRange _ = noRange++instance KillRange Hiding where+ killRange = id++instance NFData Hiding where+ rnf Hidden = ()+ rnf (Instance o) = rnf o+ rnf NotHidden = ()++-- | Decorating something with 'Hiding' information.+data WithHiding a = WithHiding+ { whHiding :: !Hiding+ , whThing :: a+ }+ deriving (Eq, Ord, Show, Functor, Foldable, Traversable)++instance Decoration WithHiding where+ traverseF f (WithHiding h a) = WithHiding h <$> f a++instance Applicative WithHiding where+ pure = WithHiding mempty+ WithHiding h f <*> WithHiding h' a = WithHiding (mappend h h') (f a)++instance HasRange a => HasRange (WithHiding a) where+ getRange = getRange . dget++instance SetRange a => SetRange (WithHiding a) where+ setRange = fmap . setRange++instance KillRange a => KillRange (WithHiding a) where+ killRange = fmap killRange++instance NFData a => NFData (WithHiding a) where+ rnf (WithHiding _ a) = rnf a++-- | A lens to access the 'Hiding' attribute in data structures.+-- Minimal implementation: @getHiding@ and @mapHiding@ or @LensArgInfo@.+class LensHiding a where++ getHiding :: a -> Hiding++ setHiding :: Hiding -> a -> a+ setHiding h = mapHiding (const h)++ mapHiding :: (Hiding -> Hiding) -> a -> a++ default getHiding :: LensArgInfo a => a -> Hiding+ getHiding = argInfoHiding . getArgInfo++ default mapHiding :: LensArgInfo a => (Hiding -> Hiding) -> a -> a+ mapHiding f = mapArgInfo $ \ ai -> ai { argInfoHiding = f $ argInfoHiding ai }++instance LensHiding Hiding where+ getHiding = id+ setHiding = const+ mapHiding = id++instance LensHiding (WithHiding a) where+ getHiding (WithHiding h _) = h+ setHiding h (WithHiding _ a) = WithHiding h a+ mapHiding f (WithHiding h a) = WithHiding (f h) a++instance LensHiding a => LensHiding (Named nm a) where+ getHiding = getHiding . namedThing+ setHiding = fmap . setHiding+ mapHiding = fmap . mapHiding++-- | Monoidal composition of 'Hiding' information in some data.+mergeHiding :: LensHiding a => WithHiding a -> a+mergeHiding (WithHiding h a) = mapHiding (mappend h) a++-- | 'NotHidden' arguments are @visible@.+visible :: LensHiding a => a -> Bool+visible a = getHiding a == NotHidden++-- | 'Instance' and 'Hidden' arguments are @notVisible@.+notVisible :: LensHiding a => a -> Bool+notVisible a = getHiding a /= NotHidden++-- | 'Hidden' arguments are @hidden@.+hidden :: LensHiding a => a -> Bool+hidden a = getHiding a == Hidden++hide :: LensHiding a => a -> a+hide = setHiding Hidden++hideOrKeepInstance :: LensHiding a => a -> a+hideOrKeepInstance x =+ case getHiding x of+ Hidden -> x+ Instance{} -> x+ NotHidden -> setHiding Hidden x++makeInstance :: LensHiding a => a -> a+makeInstance = makeInstance' NoOverlap++makeInstance' :: LensHiding a => Overlappable -> a -> a+makeInstance' o = setHiding (Instance o)++isYesOverlap :: LensHiding a => a -> Bool+isYesOverlap x =+ case getHiding x of+ Instance YesOverlap -> True+ _ -> False++isInstance :: LensHiding a => a -> Bool+isInstance x =+ case getHiding x of+ Instance{} -> True+ _ -> False++-- | Ignores 'Overlappable'.+sameHiding :: (LensHiding a, LensHiding b) => a -> b -> Bool+sameHiding x y =+ case (getHiding x, getHiding y) of+ (Instance{}, Instance{}) -> True+ (hx, hy) -> hx == hy++-- | @prettyHiding info visible doc@ puts the correct braces+-- around @doc@ according to info @info@ and returns+-- @visible doc@ if the we deal with a visible thing.+prettyHiding :: LensHiding a => a -> (Doc -> Doc) -> Doc -> Doc+prettyHiding a parens =+ case getHiding a of+ Hidden -> braces'+ Instance{} -> dbraces+ NotHidden -> parens++instance Pretty a => Pretty (WithHiding a) where+ pretty w = prettyHiding w id $ pretty $ dget w++unArgKeepHiding :: Arg a -> WithHiding a+unArgKeepHiding (Arg i a) = WithHiding (getHiding i) a++---------------------------------------------------------------------------+-- * Modalities+---------------------------------------------------------------------------++-- | Type wrapper to indicate additive monoid/semigroup context.+newtype UnderAddition t = UnderAddition t deriving (Show, Functor, Eq, Ord, PartialOrd)++instance Applicative UnderAddition where+ pure = UnderAddition+ (<*>) (UnderAddition f) (UnderAddition a) = pure (f a)++-- | Type wrapper to indicate composition or multiplicative monoid/semigroup context.+newtype UnderComposition t = UnderComposition t deriving (Show, Functor, Eq, Ord, PartialOrd)++instance Applicative UnderComposition where+ pure = UnderComposition+ (<*>) (UnderComposition f) (UnderComposition a) = pure (f a)++-- | We have a tuple of modalities, which might not be fully orthogonal.+-- For example, irrelevant stuff is also run-time irrelevant.+data Modality = Modality+ { modRelevance :: !Relevance+ -- ^ Legacy irrelevance.+ -- See Pfenning, LiCS 2001; Abel, Vezzosi and Winterhalter, ICFP 2017.+ , modQuantity :: !Quantity+ -- ^ Cardinality / runtime erasure.+ -- See Conor McBride, I got plenty o' nutting, Wadlerfest 2016.+ -- See Bob Atkey, Syntax and Semantics of Quantitative Type Theory, LiCS 2018.+ , modCohesion :: !Cohesion+ -- ^ Cohesion/what was in Agda-flat.+ -- see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584)+ -- Currently only the comonad is implemented.+ , modPolarity :: !PolarityModality+ -- ^ Polarity annotations (strictly positive, ...)+ } deriving (Eq, Ord, Show, Generic)++{-# NOINLINE noinlineEqModality #-}+-- | Non-inlined equality that's sometimes useful to prevent GHC from ballooning code size.+noinlineEqModality :: Modality -> Modality -> Bool+noinlineEqModality (Modality a b c d) (Modality a' b' c' d') =+ a == a' && b == b' && c == c' && d == d'++-- | Dominance ordering.+instance PartialOrd Modality where+ comparable (Modality r q c p) (Modality r' q' c' p') = comparable (r, (q, (c, p))) (r', (q', (c', p')))++-- | Pointwise composition.+instance Semigroup (UnderComposition Modality) where+ (<>) = liftA2 composeModality++-- | Pointwise composition unit.+instance Monoid (UnderComposition Modality) where+ mempty = pure unitModality+ mappend = (<>)++instance POSemigroup (UnderComposition Modality) where+instance POMonoid (UnderComposition Modality) where++instance LeftClosedPOMonoid (UnderComposition Modality) where+ inverseCompose = liftA2 inverseComposeModality++-- | Pointwise addition.+instance Semigroup (UnderAddition Modality) where+ (<>) = liftA2 addModality++-- | Pointwise additive unit.+instance Monoid (UnderAddition Modality) where+ mempty = pure zeroModality+ mappend = (<>)++instance POSemigroup (UnderAddition Modality) where+instance POMonoid (UnderAddition Modality) where++instance Pretty Modality where+ pretty (Modality r q c p) = hsep+ [ pretty r+ , pretty q+ , pretty c+ , pretty p+ ]++-- | @m `moreUsableModality` m'@ means that an @m@ can be used+-- where ever an @m'@ is required.++moreUsableModality :: Modality -> Modality -> Bool+moreUsableModality m m' = related m POLE m'++usableModality :: LensModality a => a -> Bool+usableModality a = usableRelevance m && usableQuantity m && usableCohesion m && usablePolarity m+ where m = getModality a++-- | Multiplicative monoid (standard monoid).+composeModality :: Modality -> Modality -> Modality+composeModality (Modality r q c p) (Modality r' q' c' p') =+ Modality (r `composeRelevance` r')+ (q `composeQuantity` q')+ (c `composeCohesion` c')+ (p `composePolarity` p')++-- | Compose with modality flag from the left.+-- This function is e.g. used to update the modality information+-- on pattern variables @a@ after a match against something of modality @q@.+applyModality :: LensModality a => Modality -> a -> a+applyModality m = mapModality (m `composeModality`)++-- | @inverseComposeModality r x@ returns the least modality @y@+-- such that forall @x@, @y@ we have+-- @x \`moreUsableModality\` (r \`composeModality\` y)@+-- iff+-- @(r \`inverseComposeModality\` x) \`moreUsableModality\` y@ (Galois connection).+inverseComposeModality :: Modality -> Modality -> Modality+inverseComposeModality (Modality r q c p) (Modality r' q' c' p') =+ Modality (r `inverseComposeRelevance` r')+ (q `inverseComposeQuantity` q')+ (c `inverseComposeCohesion` c')+ (p `inverseComposePolarity` p')++-- | Left division by a 'Modality'.+-- Used e.g. to modify context when going into a @m@ argument.+--+-- Note that this function does not change quantities.+inverseApplyModalityButNotQuantity :: LensModality a => Modality -> a -> a+inverseApplyModalityButNotQuantity m =+ mapModality (m' `inverseComposeModality`)+ where+ m' = setQuantity (Quantity1 Q1Inferred) m++-- | 'Modality' forms a pointwise additive monoid.+addModality :: Modality -> Modality -> Modality+addModality (Modality r q c p) (Modality r' q' c' p') =+ Modality (addRelevance r r')+ (addQuantity q q')+ (addCohesion c c')+ (addPolarity p p')++-- | Identity under addition+zeroModality :: Modality+zeroModality = Modality zeroRelevance zeroQuantity zeroCohesion zeroPolarity++-- | Identity under composition+unitModality :: Modality+unitModality = Modality unitRelevance unitQuantity unitCohesion unitPolarity++-- | Absorptive element under addition.+topModality :: Modality+topModality = Modality topRelevance topQuantity topCohesion topPolarity++-- | The default Modality+-- Beware that this is neither the additive unit nor the unit under+-- composition, because the default quantity is ω.+defaultModality :: Modality+defaultModality = Modality defaultRelevance defaultQuantity defaultCohesion defaultPolarity++-- | The default Modality terms are checked against.+defaultCheckModality :: Modality+defaultCheckModality = defaultModality { modPolarity = withStandardLock StrictlyPositive }++-- | Extract the positional modality components (cohesion and polarity)+-- for checks regarding only them.+positionalModalityComponent :: Modality -> Modality+positionalModalityComponent m =+ defaultModality {modCohesion = modCohesion m, modPolarity = modPolarity m}++-- | Equality ignoring origin.++sameModality :: (LensModality a, LensModality b) => a -> b -> Bool+sameModality x y = case (getModality x , getModality y) of+ (Modality r q c p , Modality r' q' c' p') -> sameRelevance r r' && sameQuantity q q' && sameCohesion c c' && samePolarity p p'++instance Null Modality where+ empty = defaultModality+ null (Modality r q c p) = and [ null r, null q, null c, null p ]++-- boilerplate instances++instance HasRange Modality where+ getRange (Modality r q c p) = getRange (r, q, c, p)++instance KillRange Modality where+ killRange (Modality r q c p) = killRangeN Modality r q c p++instance NFData Modality where++-- Lens stuff++lModRelevance :: Lens' Modality Relevance+lModRelevance f m = f (modRelevance m) <&> \ r -> m { modRelevance = r }++lModQuantity :: Lens' Modality Quantity+lModQuantity f m = f (modQuantity m) <&> \ q -> m { modQuantity = q }++lModCohesion :: Lens' Modality Cohesion+lModCohesion f m = f (modCohesion m) <&> \ q -> m { modCohesion = q }++lModPolarity :: Lens' Modality PolarityModality+lModPolarity f m = f (modPolarity m) <&> \ p -> m { modPolarity = p }++class LensModality a where++ getModality :: a -> Modality++ setModality :: Modality -> a -> a+ setModality = mapModality . const++ mapModality :: (Modality -> Modality) -> a -> a++ default getModality :: LensArgInfo a => a -> Modality+ getModality = argInfoModality . getArgInfo++ default mapModality :: LensArgInfo a => (Modality -> Modality) -> a -> a+ mapModality f = mapArgInfo $ \ ai -> ai { argInfoModality = f $ argInfoModality ai }++instance LensModality Modality where+ getModality = id+ setModality = const+ mapModality = id++instance LensRelevance Modality where+ getRelevance = modRelevance+ setRelevance h m = m { modRelevance = h }+ mapRelevance f m = m { modRelevance = f (modRelevance m) }++instance LensQuantity Modality where+ getQuantity = modQuantity+ setQuantity h m = m { modQuantity = h }+ mapQuantity f m = m { modQuantity = f (modQuantity m) }++instance LensCohesion Modality where+ getCohesion = modCohesion+ setCohesion h m = m { modCohesion = h }+ mapCohesion f m = m { modCohesion = f (modCohesion m) }++instance LensModalPolarity Modality where+ getModalPolarity = modPolarity+ setModalPolarity h m = m { modPolarity = h }+ mapModalPolarity f m = m { modPolarity = f (modPolarity m) }++-- default accessors for Relevance++getRelevanceMod :: LensModality a => LensGet a Relevance+getRelevanceMod = getRelevance . getModality++setRelevanceMod :: LensModality a => LensSet a Relevance+setRelevanceMod = mapModality . setRelevance++mapRelevanceMod :: LensModality a => LensMap a Relevance+mapRelevanceMod = mapModality . mapRelevance++-- default accessors for Quantity++getQuantityMod :: LensModality a => LensGet a Quantity+getQuantityMod = getQuantity . getModality++setQuantityMod :: LensModality a => LensSet a Quantity+setQuantityMod = mapModality . setQuantity++mapQuantityMod :: LensModality a => LensMap a Quantity+mapQuantityMod = mapModality . mapQuantity++-- default accessors for Cohesion++getCohesionMod :: LensModality a => LensGet a Cohesion+getCohesionMod = getCohesion . getModality++setCohesionMod :: LensModality a => LensSet a Cohesion+setCohesionMod = mapModality . setCohesion++mapCohesionMod :: LensModality a => LensMap a Cohesion+mapCohesionMod = mapModality . mapCohesion++-- default accessors for Polarity++getPolarityMod :: LensModality a => LensGet a PolarityModality+getPolarityMod = getModalPolarity . getModality++setPolarityMod :: LensModality a => LensSet a PolarityModality+setPolarityMod = mapModality . setModalPolarity++mapPolarityMod :: LensModality a => LensMap a PolarityModality+mapPolarityMod = mapModality . mapModalPolarity++---------------------------------------------------------------------------+-- * Quantities+---------------------------------------------------------------------------++-- ** Quantity origin.++-- | Origin of 'Quantity0'.+data Q0Origin+ = Q0Inferred -- ^ User wrote nothing.+ | Q0 Range -- ^ User wrote "@0".+ | Q0Erased Range -- ^ User wrote "@erased".+ deriving (Show, Generic, Eq, Ord)++-- | Origin of 'Quantity1'.+data Q1Origin+ = Q1Inferred -- ^ User wrote nothing.+ | Q1 Range -- ^ User wrote "@1".+ | Q1Linear Range -- ^ User wrote "@linear".+ deriving (Show, Generic, Eq, Ord)++-- | Origin of 'Quantityω'.+data QωOrigin+ = QωInferred -- ^ User wrote nothing.+ | Qω Range -- ^ User wrote "@ω".+ | QωPlenty Range -- ^ User wrote "@plenty".+ deriving (Show, Generic, Eq, Ord)++-- *** Instances for 'Q0Origin'.++-- | Right-biased composition, because the left quantity+-- acts as context, and the right one as occurrence.+instance Semigroup Q0Origin where+ (<>) = curry $ \case+ (Q0Inferred, o) -> o+ (o, Q0Inferred) -> o+ (o, Q0 r) -> Q0 $ fuseRange o r+ (o, Q0Erased r) -> Q0 $ fuseRange o r++instance Monoid Q0Origin where+ mempty = Q0Inferred+ mappend = (<>)++instance Null Q0Origin where+ empty = mempty++instance HasRange Q0Origin where+ getRange = \case+ Q0Inferred -> noRange+ Q0 r -> r+ Q0Erased r -> r++instance SetRange Q0Origin where+ setRange r = \case+ Q0Inferred -> Q0Inferred+ Q0 _ -> Q0 r+ Q0Erased _ -> Q0Erased r++instance KillRange Q0Origin where+ killRange = \case+ Q0Inferred -> Q0Inferred+ Q0 _ -> Q0 noRange+ Q0Erased _ -> Q0Erased noRange++instance NFData Q0Origin where+ rnf = \case+ Q0Inferred -> ()+ Q0 _ -> ()+ Q0Erased _ -> ()++instance Pretty Q0Origin where+ pretty = \case+ Q0Inferred -> empty+ Q0{} -> "@0"+ Q0Erased{} -> "@erased"+-- *** Instances for 'Q1Origin'.++-- | Right-biased composition, because the left quantity+-- acts as context, and the right one as occurrence.+instance Semigroup Q1Origin where+ (<>) = curry $ \case+ (Q1Inferred, o) -> o+ (o, Q1Inferred) -> o+ (o, Q1 r) -> Q1 $ fuseRange o r+ (o, Q1Linear r) -> Q1 $ fuseRange o r++instance Monoid Q1Origin where+ mempty = Q1Inferred+ mappend = (<>)++instance Null Q1Origin where+ empty = mempty++instance HasRange Q1Origin where+ getRange = \case+ Q1Inferred -> noRange+ Q1 r -> r+ Q1Linear r -> r++instance SetRange Q1Origin where+ setRange r = \case+ Q1Inferred -> Q1Inferred+ Q1 _ -> Q1 r+ Q1Linear _ -> Q1Linear r++instance KillRange Q1Origin where+ killRange = \case+ Q1Inferred -> Q1Inferred+ Q1 _ -> Q1 noRange+ Q1Linear _ -> Q1Linear noRange++instance NFData Q1Origin where+ rnf = \case+ Q1Inferred -> ()+ Q1 _ -> ()+ Q1Linear _ -> ()++instance Pretty Q1Origin where+ pretty = \case+ Q1Inferred -> empty+ Q1{} -> "@1"+ Q1Linear{} -> "@linear"++-- *** Instances for 'QωOrigin'.++-- | Right-biased composition, because the left quantity+-- acts as context, and the right one as occurrence.+instance Semigroup QωOrigin where+ (<>) = curry $ \case+ (QωInferred, o) -> o+ (o, QωInferred) -> o+ (o, Qω r) -> Qω $ fuseRange o r+ (o, QωPlenty r) -> Qω $ fuseRange o r++instance Monoid QωOrigin where+ mempty = QωInferred+ mappend = (<>)++instance Null QωOrigin where+ empty = mempty++instance HasRange QωOrigin where+ getRange = \case+ QωInferred -> noRange+ Qω r -> r+ QωPlenty r -> r++instance SetRange QωOrigin where+ setRange r = \case+ QωInferred -> QωInferred+ Qω _ -> Qω r+ QωPlenty _ -> QωPlenty r++instance KillRange QωOrigin where+ killRange = \case+ QωInferred -> QωInferred+ Qω _ -> Qω noRange+ QωPlenty _ -> QωPlenty noRange++instance NFData QωOrigin where+ rnf = \case+ QωInferred -> ()+ Qω _ -> ()+ QωPlenty _ -> ()++instance Pretty QωOrigin where+ pretty = \case+ QωInferred -> empty+ Qω{} -> "@ω"+ QωPlenty{} -> "@plenty"++-- ** Quantity.++-- | Quantity for linearity.+--+-- A quantity is a set of natural numbers, indicating possible semantic+-- uses of a variable. A singleton set @{n}@ requires that the+-- corresponding variable is used exactly @n@ times.+--+data Quantity+ = Quantity0 Q0Origin -- ^ Zero uses @{0}@, erased at runtime.+ | Quantity1 Q1Origin -- ^ Linear use @{1}@ (could be updated destructively).+ -- Mostly TODO (needs postponable constraints between quantities to compute uses).+ | Quantityω QωOrigin -- ^ Unrestricted use @ℕ@.+ deriving (Show, Generic, Eq, Ord)+ -- @Ord@ instance in case @Quantity@ is used in keys for maps etc.++-- | Equality ignoring origin.++sameQuantity :: Quantity -> Quantity -> Bool+sameQuantity = curry $ \case+ (Quantity0{}, Quantity0{}) -> True+ (Quantity1{}, Quantity1{}) -> True+ (Quantityω{}, Quantityω{}) -> True+ _ -> False++-- | Composition of quantities (multiplication).+--+-- 'Quantity0' is dominant.+-- 'Quantity1' is neutral.+--+-- Right-biased for origin.+--+instance Semigroup (UnderComposition Quantity) where+ (<>) = liftA2 composeQuantity++-- | In the absense of finite quantities besides 0, ω is the unit.+-- Otherwise, 1 is the unit.+instance Monoid (UnderComposition Quantity) where+ mempty = pure unitQuantity+ mappend = (<>)++instance POSemigroup (UnderComposition Quantity) where+instance POMonoid (UnderComposition Quantity) where++instance LeftClosedPOMonoid (UnderComposition Quantity) where+ inverseCompose = liftA2 inverseComposeQuantity++instance Semigroup (UnderAddition Quantity) where+ (<>) = liftA2 addQuantity++instance Monoid (UnderAddition Quantity) where+ mempty = pure zeroQuantity+ mappend = (<>)++instance POSemigroup (UnderAddition Quantity) where+instance POMonoid (UnderAddition Quantity) where++-- | Note that the order is @ω ≤ 0,1@, more options is smaller.+instance PartialOrd Quantity where+ comparable = curry $ \case+ (q, q') | sameQuantity q q' -> POEQ+ -- ω is least+ (Quantityω{}, _) -> POLT+ (_, Quantityω{}) -> POGT+ -- others are uncomparable+ _ -> POAny++instance Pretty Quantity where+ pretty = \case+ Quantity0 o -> ifNull (pretty o) "@0" id+ Quantity1 o -> ifNull (pretty o) "@1" id+ Quantityω o -> pretty o++-- | 'Quantity' forms an additive monoid with zero Quantity0.+addQuantity :: Quantity -> Quantity -> Quantity+addQuantity = curry $ \case+ -- ω is absorptive+ (q@Quantityω{}, _) -> q+ (_, q@Quantityω{}) -> q+ -- 0 is neutral+ (Quantity0{}, q) -> q+ (q, Quantity0{}) -> q+ -- 1 + 1 = ω+ (Quantity1 _, Quantity1 _) -> topQuantity++-- | Identity element under addition+zeroQuantity :: Quantity+zeroQuantity = Quantity0 mempty++-- | Absorptive element!+-- This differs from Relevance and Cohesion whose default+-- is the multiplicative unit.+defaultQuantity :: Quantity+defaultQuantity = topQuantity++-- | Identity element under composition+unitQuantity :: Quantity+unitQuantity = Quantityω mempty++-- | Absorptive element is ω.+topQuantity :: Quantity+topQuantity = Quantityω mempty++-- | 'null' means no information, not even origin or range.+instance Null Quantity where+ empty = defaultQuantity+ null = \case+ Quantityω o -> null o+ _ -> False++-- | @m `moreUsableQuantity` m'@ means that an @m@ can be used+-- where ever an @m'@ is required.++moreQuantity :: Quantity -> Quantity -> Bool+moreQuantity m m' = related m POLE m'++-- | Composition of quantities (multiplication).+--+-- 'Quantity0' is dominant.+-- 'Quantity1' is neutral.+--+-- Right-biased for origin.+--+composeQuantity :: Quantity -> Quantity -> Quantity+composeQuantity = curry $ \case+ (Quantity1 o, Quantity1 o') -> Quantity1 (o <> o')+ (Quantity1{}, q ) -> q+ (q , Quantity1{} ) -> q+ (Quantity0 o, Quantity0 o') -> Quantity0 (o <> o')+ (_ , Quantity0 o ) -> Quantity0 o+ (Quantity0 o, _ ) -> Quantity0 o+ (Quantityω o, Quantityω o') -> Quantityω (o <> o')++-- | Compose with quantity flag from the left.+-- This function is e.g. used to update the quantity information+-- on pattern variables @a@ after a match against something of quantity @q@.++applyQuantity :: LensQuantity a => Quantity -> a -> a+applyQuantity q = mapQuantity (q `composeQuantity`)++-- | @inverseComposeQuantity r x@ returns the least quantity @y@+-- such that forall @x@, @y@ we have+-- @x \`moreQuantity\` (r \`composeQuantity\` y)@+-- iff+-- @(r \`inverseComposeQuantity\` x) \`moreQuantity\` y@ (Galois connection).++inverseComposeQuantity :: Quantity -> Quantity -> Quantity+inverseComposeQuantity = curry $ \case+ (Quantity1{} , x) -> x -- going to linear arg: nothing changes+ (Quantity0{} , _) -> topQuantity -- going to erased arg: every thing usable+ (Quantityω{} , x@Quantityω{}) -> x+ (Quantityω{} , _) -> zeroQuantity -- linear resources are unusable as arguments to unrestricted functions++-- | Left division by a 'Quantity'.+-- Used e.g. to modify context when going into a @q@ argument.++inverseApplyQuantity :: LensQuantity a => Quantity -> a -> a+inverseApplyQuantity q = mapQuantity (q `inverseComposeQuantity`)++-- | Check for 'Quantity0'.+{-# INLINE hasQuantity0 #-}+hasQuantity0 :: LensQuantity a => a -> Bool+hasQuantity0 a+ | Quantity0{} <- getQuantity a = True+ | otherwise = False++-- | Check for 'Quantity1'.+{-# INLINE hasQuantity1 #-}+hasQuantity1 :: LensQuantity a => a -> Bool+hasQuantity1 a+ | Quantity1{} <- getQuantity a = True+ | otherwise = False++-- | Check for 'Quantityω'.+{-# INLINE hasQuantityω #-}+hasQuantityω :: LensQuantity a => a -> Bool+hasQuantityω a+ | Quantityω{} <- getQuantity a = True+ | otherwise = False++-- | Did the user supply a quantity annotation?++noUserQuantity :: LensQuantity a => a -> Bool+noUserQuantity a = case getQuantity a of+ Quantity0 o -> null o+ Quantity1 o -> null o+ Quantityω o -> null o++-- | A thing of quantity 0 is unusable, all others are usable.++usableQuantity :: LensQuantity a => a -> Bool+usableQuantity = not . hasQuantity0++-- boilerplate instances++class LensQuantity a where++ getQuantity :: a -> Quantity++ setQuantity :: Quantity -> a -> a+ setQuantity = mapQuantity . const++ mapQuantity :: (Quantity -> Quantity) -> a -> a++ default getQuantity :: LensModality a => a -> Quantity+ getQuantity = modQuantity . getModality++ default mapQuantity :: LensModality a => (Quantity -> Quantity) -> a -> a+ mapQuantity f = mapModality $ \ ai -> ai { modQuantity = f $ modQuantity ai }++instance LensQuantity Quantity where+ getQuantity = id+ setQuantity = const+ mapQuantity = id++instance HasRange Quantity where+ getRange = \case+ Quantity0 o -> getRange o+ Quantity1 o -> getRange o+ Quantityω o -> getRange o++instance SetRange Quantity where+ setRange r = \case+ Quantity0 o -> Quantity0 $ setRange r o+ Quantity1 o -> Quantity1 $ setRange r o+ Quantityω o -> Quantityω $ setRange r o++instance KillRange Quantity where+ killRange = \case+ Quantity0 o -> Quantity0 $ killRange o+ Quantity1 o -> Quantity1 $ killRange o+ Quantityω o -> Quantityω $ killRange o++instance NFData Quantity where+ rnf (Quantity0 o) = rnf o+ rnf (Quantity1 o) = rnf o+ rnf (Quantityω o) = rnf o++isQuantity0 :: LensQuantity a => a -> Bool+isQuantity0 a = case getQuantity a of+ Quantity0{} -> True+ _ -> False++isQuantityω :: LensQuantity a => a -> Bool+isQuantityω a = case getQuantity a of+ Quantityω{} -> True+ _ -> False++prettyQuantity :: LensQuantity a => a -> Doc -> Doc+prettyQuantity a = (pretty (getQuantity a) <+>)++-- ** Erased.++-- | A special case of 'Quantity': erased or not.+--+-- Note that the 'Ord' instance does *not* ignore the origin+-- arguments.++data Erased+ = Erased Q0Origin+ | NotErased QωOrigin+ deriving (Show, Eq, Ord, Generic)++-- | The default value of type 'Erased': not erased.++defaultErased :: Erased+defaultErased = NotErased QωInferred++-- | 'Erased' can be embedded into 'Quantity'.++asQuantity :: Erased -> Quantity+asQuantity (Erased o) = Quantity0 o+asQuantity (NotErased o) = Quantityω o++-- | 'Quantity' can be projected onto 'Erased'.++erasedFromQuantity :: Quantity -> Maybe Erased+erasedFromQuantity = \case+ Quantity1{} -> Nothing+ Quantity0 o -> Just $ Erased o+ Quantityω o -> Just $ NotErased o++-- | Equality ignoring origin.++sameErased :: Erased -> Erased -> Bool+sameErased = sameQuantity `on` asQuantity++-- | Is the value \"erased\"?++isErased :: Erased -> Bool+isErased = hasQuantity0 . asQuantity++instance NFData Erased++instance HasRange Erased where+ getRange = getRange . asQuantity++instance KillRange Erased where+ killRange = \case+ Erased o -> Erased $ killRange o+ NotErased o -> NotErased $ killRange o++instance Pretty Erased where+ pretty = pretty . asQuantity++-- | Composition of values of type 'Erased'.+--+-- 'Erased' is dominant.+-- 'NotErased' is neutral.+--+-- Right-biased for the origin.++composeErased :: Erased -> Erased -> Erased+composeErased = curry $ \case+ (Erased o, Erased o') -> Erased (o <> o')+ (NotErased _, Erased o) -> Erased o+ (Erased o, NotErased _) -> Erased o+ (NotErased o, NotErased o') -> NotErased (o <> o')++instance Semigroup (UnderComposition Erased) where+ (<>) = liftA2 composeErased++prettyErased :: Erased -> Doc -> Doc+prettyErased = prettyQuantity . asQuantity++---------------------------------------------------------------------------+-- * Relevance+---------------------------------------------------------------------------++-- ** Relevance origin++-- | Origin of 'Relevant'.++data OriginRelevant+ = ORelInferred -- ^ User wrote nothing.+ | ORelRelevant Range -- ^ User wrote "@relevant".+ deriving (Show, Generic)++-- | Origin of 'Irrelevant'.++data OriginIrrelevant+ = OIrrInferred -- ^ User wrote nothing.+ | OIrrDot Range -- ^ User wrote ".".+ | OIrrIrr Range -- ^ User wrote "@irr".+ | OIrrIrrelevant Range -- ^ User wrote "@irrelevant".+ deriving (Show, Generic)++-- | Origin of 'ShapeIrrelevant'.++data OriginShapeIrrelevant+ = OShIrrInferred -- ^ User wrote nothing.+ | OShIrrDotDot Range -- ^ User wrote "..".+ | OShIrrShIrr Range -- ^ User wrote "@shirr".+ | OShIrrShapeIrrelevant Range -- ^ User wrote "@shape-irrelevant".+ deriving (Show, Generic)++-- *** Instances for 'OriginRelevant'++instance Null OriginRelevant where+ empty = ORelInferred+ null = \case+ ORelInferred -> True+ _ -> False++instance Semigroup OriginRelevant where+ (<>) = curry \case+ (ORelInferred, o ) -> o+ (o, ORelInferred ) -> o+ (o, ORelRelevant r) -> ORelRelevant $ fuseRange o r++instance Monoid OriginRelevant where+ mempty = empty++instance HasRange OriginRelevant where+ getRange = \case+ ORelInferred -> noRange+ ORelRelevant r -> r++instance SetRange OriginRelevant where+ setRange r = \case+ ORelInferred -> ORelInferred+ ORelRelevant _ -> ORelRelevant r++instance KillRange OriginRelevant where+ killRange = setRange noRange++instance NFData OriginRelevant where+ rnf = \case+ ORelInferred -> ()+ ORelRelevant _ -> ()++-- *** Instances for 'OriginIrrelevant'++instance Null OriginIrrelevant where+ empty = OIrrInferred+ null = \case+ OIrrInferred -> True+ _ -> False++-- | Right-biased composition, because the left relevance+-- acts as context, and the right one as occurrence.++instance Semigroup OriginIrrelevant where+ (<>) = curry \case+ (OIrrInferred, o ) -> o+ (o, OIrrInferred ) -> o+ (o, OIrrDot r) -> OIrrDot $ fuseRange o r+ (o, OIrrIrr r) -> OIrrIrr $ fuseRange o r+ (o, OIrrIrrelevant r) -> OIrrIrrelevant $ fuseRange o r++instance Monoid OriginIrrelevant where+ mempty = empty++instance HasRange OriginIrrelevant where+ getRange = \case+ OIrrInferred -> noRange+ OIrrDot r -> r+ OIrrIrr r -> r+ OIrrIrrelevant r -> r++instance SetRange OriginIrrelevant where+ setRange r = \case+ OIrrInferred -> OIrrInferred+ OIrrDot _ -> OIrrDot r+ OIrrIrr _ -> OIrrIrr r+ OIrrIrrelevant _ -> OIrrIrrelevant r++instance KillRange OriginIrrelevant where+ killRange = setRange noRange++instance NFData OriginIrrelevant where+ rnf = \case+ OIrrInferred -> ()+ OIrrDot _ -> ()+ OIrrIrr _ -> ()+ OIrrIrrelevant _ -> ()++-- *** Instances for 'OriginShapeIrrelevant'++instance Null OriginShapeIrrelevant where+ empty = OShIrrInferred+ null = \case+ OShIrrInferred -> True+ _ -> False++-- | Right-biased composition, because the left relevance+-- acts as context, and the right one as occurrence.++instance Semigroup OriginShapeIrrelevant where+ (<>) = curry \case+ (OShIrrInferred, o ) -> o+ (o, OShIrrInferred ) -> o+ (o, OShIrrDotDot r) -> OShIrrDotDot $ fuseRange o r+ (o, OShIrrShIrr r) -> OShIrrShIrr $ fuseRange o r+ (o, OShIrrShapeIrrelevant r) -> OShIrrShapeIrrelevant $ fuseRange o r++instance Monoid OriginShapeIrrelevant where+ mempty = empty++instance HasRange OriginShapeIrrelevant where+ getRange = \case+ OShIrrInferred -> noRange+ OShIrrDotDot r -> r+ OShIrrShIrr r -> r+ OShIrrShapeIrrelevant r -> r++instance SetRange OriginShapeIrrelevant where+ setRange r = \case+ OShIrrInferred -> OShIrrInferred+ OShIrrDotDot _ -> OShIrrDotDot r+ OShIrrShIrr _ -> OShIrrShIrr r+ OShIrrShapeIrrelevant _ -> OShIrrShapeIrrelevant r++instance KillRange OriginShapeIrrelevant where+ killRange = setRange noRange++instance NFData OriginShapeIrrelevant where+ rnf = \case+ OShIrrInferred -> ()+ OShIrrDotDot _ -> ()+ OShIrrShIrr _ -> ()+ OShIrrShapeIrrelevant _ -> ()++instance Pretty OriginRelevant where+ pretty = \case+ ORelInferred {} -> empty+ ORelRelevant {} -> "@relevant"++instance Pretty OriginIrrelevant where+ pretty = \case+ OIrrInferred {} -> empty+ OIrrDot {} -> "."+ OIrrIrr {} -> "@irr"+ OIrrIrrelevant {} -> "@irrelevant"++instance Pretty OriginShapeIrrelevant where+ pretty = \case+ OShIrrInferred {} -> empty+ OShIrrDotDot {} -> ".."+ OShIrrShIrr {} -> "@shirr"+ OShIrrShapeIrrelevant {} -> "@shape-irrelevant"++-- ** Relevance levels++-- | A function argument can be relevant or irrelevant.+-- See "Agda.TypeChecking.Irrelevance".+data Relevance+ = Relevant !OriginRelevant+ -- ^ The argument is (possibly) relevant at compile-time.+ | ShapeIrrelevant !OriginShapeIrrelevant+ -- ^ Like 'Quantity0', the argument may never flow into evaluation position.+ -- So it is irrelevant at run-time,+ -- yet treated relevantly during equality checking.+ --+ -- Unlike 'Quantity0', it is used to type 'Irrelevant' arguments in functions:+ -- If you enable @--experimental-irrelevance@,+ -- then the type of an irrelevant function is forced to be shape-irrelevant.+ -- See:+ -- - <https://doi.org/10.2168/LMCS-8(1:29)2012> example 2.8+ -- (Not enforcing shape-irrelevant codomains can break subject reduction!)+ -- - <https://dl.acm.org/doi/10.1145/3110277>+ -- - <https://doi.org/10.1145/3209108.3209119>+ | Irrelevant !OriginIrrelevant+ -- ^ The argument is irrelevant at compile- and runtime.+ deriving (Show, Generic)++instance Eq Relevance where+ (==) = sameRelevance++instance HasRange Relevance where+ getRange = \case+ Relevant o -> getRange o+ ShapeIrrelevant o -> getRange o+ Irrelevant o -> getRange o++instance SetRange Relevance where+ setRange r = \case+ Relevant o -> Relevant $ setRange r o+ ShapeIrrelevant o -> ShapeIrrelevant $ setRange r o+ Irrelevant o -> Irrelevant $ setRange r o++instance KillRange Relevance where+ killRange = setRange noRange++instance NFData Relevance where+ rnf = \case+ Relevant o -> rnf o+ ShapeIrrelevant o -> rnf o+ Irrelevant o -> rnf o++-- | A lens to access the 'Relevance' attribute in data structures.+-- Minimal implementation: @getRelevance@ and @mapRelevance@ or @LensModality@.+class LensRelevance a where++ getRelevance :: a -> Relevance++ {-# inline setRelevance #-}+ setRelevance :: Relevance -> a -> a+ setRelevance h = mapRelevance (const h)++ mapRelevance :: (Relevance -> Relevance) -> a -> a++ {-# INLINE getRelevance #-}+ default getRelevance :: LensModality a => a -> Relevance+ getRelevance = modRelevance . getModality++ {-# INLINE mapRelevance #-}+ default mapRelevance :: LensModality a => (Relevance -> Relevance) -> a -> a+ mapRelevance f = mapModality $ \ ai -> ai { modRelevance = f $ modRelevance ai }++instance LensRelevance Relevance where+ getRelevance = id+ setRelevance = const+ mapRelevance = id++relevant :: Relevance+relevant = Relevant empty++irrelevant :: Relevance+irrelevant = Irrelevant empty++shapeIrrelevant :: Relevance+shapeIrrelevant = ShapeIrrelevant empty++{-# INLINE isRelevant #-}+isRelevant :: LensRelevance a => a -> Bool+isRelevant a = case getRelevance a of+ Relevant{} -> True+ _ -> False++{-# INLINE isIrrelevant #-}+isIrrelevant :: LensRelevance a => a -> Bool+isIrrelevant a = case getRelevance a of+ Irrelevant{} -> True+ _ -> False++{-# INLINE isShapeIrrelevant #-}+isShapeIrrelevant :: LensRelevance a => a -> Bool+isShapeIrrelevant a = case getRelevance a of+ ShapeIrrelevant{} -> True+ _ -> False++-- | Information ordering.+-- @Relevant \`moreRelevant\`+-- ShapeIrrelevant \`moreRelevant\`+-- Irrelevant@+moreRelevant :: Relevance -> Relevance -> Bool+moreRelevant = (<=)++-- | Equality ignoring origin.+sameRelevance :: Relevance -> Relevance -> Bool+sameRelevance = curry $ \case+ (Relevant {}, Relevant {}) -> True+ (Irrelevant {}, Irrelevant {}) -> True+ (ShapeIrrelevant {}, ShapeIrrelevant {}) -> True+ _ -> False++-- | More relevant is smaller.+instance Ord Relevance where+ compare = curry \case+ (r, r') | sameRelevance r r' -> EQ+ -- top+ (_, Irrelevant{}) -> LT+ (Irrelevant{}, _) -> GT+ -- bottom+ (Relevant{}, _) -> LT+ (_, Relevant{}) -> GT+ -- redundant case+ (ShapeIrrelevant{}, ShapeIrrelevant{}) -> EQ++-- | More relevant is smaller.+instance PartialOrd Relevance where+ comparable = comparableOrd++-- | @usableRelevance rel == False@ iff we cannot use a variable of @rel@.+usableRelevance :: LensRelevance a => a -> Bool+usableRelevance = isRelevant++-- | 'Relevance' composition.+-- 'Irrelevant' is dominant, 'Relevant' is neutral.+-- Composition coincides with 'max'.+composeRelevance :: Relevance -> Relevance -> Relevance+composeRelevance = curry \case+ (Relevant o , Relevant o' ) -> Relevant (o <> o')+ (Relevant{} , r ) -> r+ (r , Relevant{} ) -> r+ (Irrelevant o , Irrelevant o' ) -> Irrelevant (o <> o')+ (_ , Irrelevant o ) -> Irrelevant o+ (Irrelevant o , _ ) -> Irrelevant o+ (ShapeIrrelevant o , ShapeIrrelevant o') -> ShapeIrrelevant (o <> o')++-- | Compose with relevance flag from the left.+-- This function is e.g. used to update the relevance information+-- on pattern variables @a@ after a match against something @rel@.+applyRelevance :: LensRelevance a => Relevance -> a -> a+applyRelevance rel = mapRelevance (rel `composeRelevance`)++-- | @inverseComposeRelevance r x@ returns the most irrelevant @y@+-- such that forall @x@, @y@ we have+-- @x \`moreRelevant\` (r \`composeRelevance\` y)@+-- iff+-- @(r \`inverseComposeRelevance\` x) \`moreRelevant\` y@ (Galois connection).+inverseComposeRelevance :: Relevance -> Relevance -> Relevance+inverseComposeRelevance = curry \case+ (_ , Relevant o ) -> Relevant o -- can't get more relevant+ (Relevant{} , x ) -> x -- going to relevant arg.: nothing changes+ -- because Relevant is comp.-neutral+ (Irrelevant{} , _ ) -> relevant -- going irrelevant: every thing usable+ (ShapeIrrelevant{} , Irrelevant o ) -> Irrelevant o -- otherwise: irrelevant things remain unusable+ (ShapeIrrelevant{} , ShapeIrrelevant{}) -> relevant -- but @ShapeIrrelevant@s become usable++-- | Left division by a 'Relevance'.+-- Used e.g. to modify context when going into a @rel@ argument.+inverseApplyRelevance :: LensRelevance a => Relevance -> a -> a+inverseApplyRelevance rel = mapRelevance (rel `inverseComposeRelevance`)++-- | 'Relevance' forms a semigroup under composition.+instance Semigroup (UnderComposition Relevance) where+ (<>) = liftA2 composeRelevance++-- | 'Relevant' is the unit under composition.+instance Monoid (UnderComposition Relevance) where+ mempty = pure unitRelevance+ mappend = (<>)++instance POSemigroup (UnderComposition Relevance) where+instance POMonoid (UnderComposition Relevance) where++instance LeftClosedPOMonoid (UnderComposition Relevance) where+ inverseCompose = liftA2 inverseComposeRelevance++instance Semigroup (UnderAddition Relevance) where+ (<>) = liftA2 addRelevance++instance Monoid (UnderAddition Relevance) where+ mempty = pure zeroRelevance+ mappend = (<>)++instance POSemigroup (UnderAddition Relevance) where+instance POMonoid (UnderAddition Relevance) where++-- | Combine inferred 'Relevance'.+-- The unit is 'Irrelevant'.+addRelevance :: Relevance -> Relevance -> Relevance+addRelevance = min++-- | 'Relevance' forms a monoid under addition, and even a semiring.+zeroRelevance :: Relevance+zeroRelevance = irrelevant++-- | Identity element under composition+unitRelevance :: Relevance+unitRelevance = relevant++-- | Absorptive element under addition.+topRelevance :: Relevance+topRelevance = relevant++-- | Default Relevance is the identity element under composition+defaultRelevance :: Relevance+defaultRelevance = unitRelevance++-- | 'null' means no information, not even origin or range.+instance Null Relevance where+ empty = defaultRelevance+ null = \case+ Relevant o -> null o+ _ -> False++-- | Irrelevant function arguments may appear non-strictly in the codomain type.+irrelevantToShapeIrrelevant :: Relevance -> Relevance+irrelevantToShapeIrrelevant Irrelevant{} = shapeIrrelevant+irrelevantToShapeIrrelevant rel = rel++-- | Applied when working on types (unless --experimental-irrelevance).+shapeIrrelevantToRelevant :: Relevance -> Relevance+shapeIrrelevantToRelevant ShapeIrrelevant{} = relevant+shapeIrrelevantToRelevant rel = rel++shapeIrrelevantToIrrelevant :: Relevance -> Relevance+shapeIrrelevantToIrrelevant ShapeIrrelevant{} = irrelevant+shapeIrrelevantToIrrelevant rel = rel++prettyRelevance :: LensRelevance a => a -> Doc -> Doc+prettyRelevance a = if lastMaybe (render d) == Just '.' then (d <>) else (d <+>)+ where+ d = pretty $ getRelevance a++instance Pretty Relevance where+ pretty = \case+ Relevant o -> pretty o+ Irrelevant o -> ifNull (pretty o) "." id+ ShapeIrrelevant o -> ifNull (pretty o) ".." id+++---------------------------------------------------------------------------+-- * Annotations+---------------------------------------------------------------------------++-- | We have a tuple of annotations, which might not be fully orthogonal.+data Annotation = Annotation+ { annLock :: Lock+ -- ^ Fitch-style dependent right adjoints.+ -- See Modal Dependent Type Theory and Dependent Right Adjoints, arXiv:1804.05236.+ , annRewrite :: RewriteAnn+ } deriving (Eq, Ord, Show, Generic)++instance HasRange Annotation where+ getRange _ = noRange++instance KillRange Annotation where+ killRange = id++defaultAnnotation :: Annotation+defaultAnnotation = Annotation defaultLock defaultRewrite++instance Null Annotation where+ empty = defaultAnnotation+ null (Annotation lock rew) = null lock && null rew++instance NFData Annotation where+ rnf (Annotation l r) = rnf (l, r)++class LensAnnotation a where++ getAnnotation :: a -> Annotation++ setAnnotation :: Annotation -> a -> a++ mapAnnotation :: (Annotation -> Annotation) -> a -> a+ mapAnnotation f a = setAnnotation (f $ getAnnotation a) a++ default getAnnotation :: LensArgInfo a => a -> Annotation+ getAnnotation = argInfoAnnotation . getArgInfo++ default setAnnotation :: LensArgInfo a => Annotation -> a -> a+ setAnnotation a = mapArgInfo $ \ ai -> ai { argInfoAnnotation = a }++instance LensAnnotation Annotation where+ getAnnotation = id+ setAnnotation = const+ mapAnnotation = id++instance LensAnnotation (Arg t) where+ getAnnotation = getAnnotation . getArgInfo+ setAnnotation = mapArgInfo . setAnnotation+++---------------------------------------------------------------------------+-- * Locks+---------------------------------------------------------------------------++data LockOrigin+ = LockOLock -- ^ The user wrote @lock.+ | LockOTick -- ^ The user wrote @tick.+ deriving (Show, Generic, Eq, Enum, Bounded, Ord)++data Lock+ = IsNotLock+ | IsLock LockOrigin+ -- ^ In the future there might be different kinds of them.+ -- For now we assume lock weakening.+ deriving (Show, Generic, Eq, Ord)++defaultLock :: Lock+defaultLock = IsNotLock++instance Null Lock where+ empty = defaultLock++instance NFData Lock where+ rnf IsNotLock = ()+ rnf (IsLock LockOLock) = ()+ rnf (IsLock LockOTick) = ()++class LensLock a where++ getLock :: a -> Lock++ setLock :: Lock -> a -> a+ setLock = mapLock . const++ mapLock :: (Lock -> Lock) -> a -> a+ mapLock f a = setLock (f $ getLock a) a++ {-# MINIMAL getLock , (setLock | mapLock) #-}++instance LensLock Lock where+ getLock = id+ setLock = const+ mapLock = id++instance LensLock ArgInfo where+ getLock = annLock . argInfoAnnotation+ setLock l info = info { argInfoAnnotation = (argInfoAnnotation info){ annLock = l } }++instance LensLock (Arg t) where+ getLock = getLock . getArgInfo+ setLock = mapArgInfo . setLock++instance Pretty Lock where+ pretty = \case+ IsLock LockOLock -> "@lock"+ IsLock LockOTick -> "@tick"+ IsNotLock -> empty++prettyLock :: LensLock a => a -> Doc -> Doc+prettyLock a = (pretty (getLock a) <+>)++---------------------------------------------------------------------------+-- * Rewrite arguments+---------------------------------------------------------------------------++data RewriteAnn+ = IsNotRewrite+ | IsRewrite Range+ deriving (Show, Generic)++defaultRewrite :: RewriteAnn+defaultRewrite = IsNotRewrite++instance HasRange RewriteAnn where+ getRange = \case+ IsRewrite r -> r+ IsNotRewrite -> noRange++instance SetRange RewriteAnn where+ setRange r = \case+ IsRewrite _ -> IsRewrite r+ IsNotRewrite -> IsNotRewrite++instance KillRange RewriteAnn where+ killRange = setRange noRange++instance Eq RewriteAnn where+ (==) = (==) `on` isRewrite++instance Ord RewriteAnn where+ compare = compare `on` isRewrite++instance Null RewriteAnn where+ empty = defaultRewrite++instance NFData RewriteAnn where+ rnf IsNotRewrite = ()+ rnf (IsRewrite _) = ()++instance Pretty RewriteAnn where+ pretty = \case+ (IsRewrite _) -> "@rewrite"+ IsNotRewrite -> empty++class LensRewriteAnn a where++ getRewriteAnn :: a -> RewriteAnn++ setRewriteAnn :: RewriteAnn -> a -> a+ setRewriteAnn = mapRewriteAnn . const++ mapRewriteAnn :: (RewriteAnn -> RewriteAnn) -> a -> a+ mapRewriteAnn f a = setRewriteAnn (f $ getRewriteAnn a) a++ {-# MINIMAL getRewriteAnn , (setRewriteAnn | mapRewriteAnn) #-}++instance LensRewriteAnn RewriteAnn where+ getRewriteAnn = id+ setRewriteAnn = const+ mapRewriteAnn = id++instance LensRewriteAnn ArgInfo where+ getRewriteAnn = annRewrite . argInfoAnnotation+ setRewriteAnn r info = info { argInfoAnnotation = (argInfoAnnotation info){ annRewrite = r } }++instance LensRewriteAnn (Arg t) where+ getRewriteAnn = getRewriteAnn . getArgInfo+ setRewriteAnn = mapArgInfo . setRewriteAnn++isRewrite :: LensRewriteAnn a => a -> Bool+isRewrite a = case getRewriteAnn a of+ IsRewrite _ -> True+ IsNotRewrite -> False++ignoreRew :: Monad m => LensRewriteAnn a => (RewriteAnn -> m ()) -> a -> m a+ignoreRew warn info+ | isRewrite info = do+ warn $ getRewriteAnn info+ return $ setRewriteAnn IsNotRewrite info+ | otherwise = return info++prettyRewriteAnn :: LensRewriteAnn a => a -> Doc -> Doc+prettyRewriteAnn a = (pretty (getRewriteAnn a) <+>)++---------------------------------------------------------------------------+-- * Cohesion+---------------------------------------------------------------------------++-- | Cohesion modalities+-- see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584)+-- types are now given an additional topological layer which the modalities interact with.+data Cohesion+ = Flat -- ^ same points, discrete topology, idempotent comonad, box-like.+ | Continuous -- ^ identity modality.+ | Sharp -- ^ same points, codiscrete topology, idempotent monad, diamond-like.+ | Squash -- ^ single point space, artificially added for Flat left-composition.+ deriving (Show, Eq, Enum, Bounded, Generic)++allCohesions :: [Cohesion]+allCohesions = [minBound..maxBound]++instance HasRange Cohesion where+ getRange _ = noRange++instance SetRange Cohesion where+ setRange _ = id++instance KillRange Cohesion where+ killRange rel = rel -- no range to kill++instance NFData Cohesion where+ rnf Flat = ()+ rnf Continuous = ()+ rnf Sharp = ()+ rnf Squash = ()++instance Pretty Cohesion where+ pretty Flat = "@♭"+ pretty Continuous = mempty+ pretty Sharp = "@♯"+ pretty Squash = "@⊤"++-- | A lens to access the 'Cohesion' attribute in data structures.+-- Minimal implementation: @getCohesion@ and @mapCohesion@ or @LensModality@.+class LensCohesion a where++ getCohesion :: a -> Cohesion++ setCohesion :: Cohesion -> a -> a+ setCohesion h = mapCohesion (const h)++ mapCohesion :: (Cohesion -> Cohesion) -> a -> a++ default getCohesion :: LensModality a => a -> Cohesion+ getCohesion = modCohesion . getModality++ default mapCohesion :: LensModality a => (Cohesion -> Cohesion) -> a -> a+ mapCohesion f = mapModality $ \ ai -> ai { modCohesion = f $ modCohesion ai }++instance LensCohesion Cohesion where+ getCohesion = id+ setCohesion = const+ mapCohesion = id++isContinuous :: LensCohesion a => a -> Bool+isContinuous = (Continuous ==) . getCohesion++-- | Information ordering.+-- @Flat \`moreCohesion\`+-- Continuous \`moreCohesion\`+-- Sharp \`moreCohesion\`+-- Squash@+moreCohesion :: Cohesion -> Cohesion -> Bool+moreCohesion = (<=)++-- | Equality ignoring origin. TODO: add origin to 'Cohesion'.+sameCohesion :: Cohesion -> Cohesion -> Bool+sameCohesion = (==)++-- | Order is given by implication: flatter is smaller.+instance Ord Cohesion where+ compare = curry $ \case+ (r, r') | r == r' -> EQ+ -- top+ (_, Squash) -> LT+ (Squash, _) -> GT+ -- id < ♯+ (Sharp,Continuous) -> GT+ (Continuous,Sharp) -> LT+ -- bottom+ (Flat, _) -> LT+ (_, Flat) -> GT+ -- redundant cases+ (Continuous,Continuous) -> EQ+ (Sharp,Sharp) -> EQ++-- | Flatter is smaller.+instance PartialOrd Cohesion where+ comparable = comparableOrd++-- | @usableCohesion rel == False@ iff we cannot use a variable of @rel@.+usableCohesion :: LensCohesion a => a -> Bool+usableCohesion a = getCohesion a `moreCohesion` Continuous++-- | 'Cohesion' composition.+-- 'Squash' is dominant, 'Continuous' is neutral.+composeCohesion :: Cohesion -> Cohesion -> Cohesion+composeCohesion r r' =+ case (r, r') of+ (Squash, _) -> Squash+ (_, Squash) -> Squash+ (Sharp, _) -> Sharp+ (Flat, _) -> Flat+ (_, Flat) -> Flat+ (_, Sharp) -> Sharp+ (Continuous, Continuous) -> Continuous++-- | Compose with cohesion flag from the left.+-- This function is e.g. used to update the cohesion information+-- on pattern variables @a@ after a match against something of cohesion @rel@.+applyCohesion :: LensCohesion a => Cohesion -> a -> a+applyCohesion rel = mapCohesion (rel `composeCohesion`)++-- | @inverseComposeCohesion r x@ returns the least @y@+-- such that forall @x@, @y@ we have+-- @x \`moreCohesion\` (r \`composeCohesion\` y)@+-- iff+-- @(r \`inverseComposeCohesion\` x) \`moreCohesion\` y@ (Galois connection).+-- The above law fails for @r = Squash@.+inverseComposeCohesion :: Cohesion -> Cohesion -> Cohesion+inverseComposeCohesion r x =+ case (r, x) of+ (Continuous , x) -> x -- going to continous arg.: nothing changes+ -- because Continuous is comp.-neutral+ (Squash, _) -> Flat -- in squash position everything is usable+ (Flat , Flat) -> Flat -- otherwise: Flat things remain Flat+ (Flat , _) -> Squash -- but everything else becomes unusable.+ (Sharp, Squash) -> Squash -- in sharp everything is usable apart from+ (Sharp, _) -> Flat -- squash++-- | Left division by a 'Cohesion'.+-- Used e.g. to modify context when going into a @rel@ argument.+inverseApplyCohesion :: LensCohesion a => Cohesion -> a -> a+inverseApplyCohesion rel = mapCohesion (rel `inverseComposeCohesion`)++-- | 'Cohesion' forms a semigroup under composition.+instance Semigroup (UnderComposition Cohesion) where+ (<>) = liftA2 composeCohesion++-- | 'Continous' is the multiplicative unit.+instance Monoid (UnderComposition Cohesion) where+ mempty = pure unitCohesion+ mappend = (<>)++instance POSemigroup (UnderComposition Cohesion) where+instance POMonoid (UnderComposition Cohesion) where++instance LeftClosedPOMonoid (UnderComposition Cohesion) where+ inverseCompose = liftA2 inverseComposeCohesion++-- | 'Cohesion' forms a semigroup under addition.+instance Semigroup (UnderAddition Cohesion) where+ (<>) = liftA2 addCohesion++-- | 'Squash' is the additive unit.+instance Monoid (UnderAddition Cohesion) where+ mempty = pure zeroCohesion+ mappend = (<>)++instance POSemigroup (UnderAddition Cohesion) where+instance POMonoid (UnderAddition Cohesion) where++-- | Combine inferred 'Cohesion'.+-- The unit is 'Squash'.+addCohesion :: Cohesion -> Cohesion -> Cohesion+addCohesion = min++-- | 'Cohesion' forms a monoid under addition, and even a semiring.+zeroCohesion :: Cohesion+zeroCohesion = Squash++-- | Identity under composition+unitCohesion :: Cohesion+unitCohesion = Continuous++-- | Absorptive element under addition.+topCohesion :: Cohesion+topCohesion = Flat++-- | Default Cohesion is the identity element under composition+defaultCohesion :: Cohesion+defaultCohesion = unitCohesion++-- | 'null' shall mean no information, not even origin or range.+instance Null Cohesion where+ empty = defaultCohesion+ null = \case+ Continuous -> True+ _ -> False++prettyCohesion :: LensCohesion a => a -> Doc -> Doc+prettyCohesion a = (pretty (getCohesion a) <+>)++---------------------------------------------------------------------------+-- * Polarity+---------------------------------------------------------------------------++-- | The different polarity options+data ModalPolarity+ = UnusedPolarity -- ^ argument will not be used.+ | StrictlyPositive -- ^ argument will only be used in strictly positive position.+ | Positive -- ^ argument will only be used in positive position.+ | Negative -- ^ argument will only be used in negative position.+ | MixedPolarity -- ^ we don't know anything, argument can be used anywhere.+ deriving (Show, Ord, Enum, Eq, Bounded, Generic)++allModalPolarities :: [ModalPolarity]+allModalPolarities = [minBound..maxBound]++-- | The derived Ord instance for ModalPolarity is just used for+-- serialisation and has no particular meaning. The actual order on+-- modalities is a partial order.+instance PartialOrd ModalPolarity where+ comparable x y | x == y = POEQ+ comparable _ UnusedPolarity = POLT+ comparable UnusedPolarity _ = POGT+ comparable _ MixedPolarity = POGT+ comparable MixedPolarity _ = POLT+ comparable _ Negative = POAny+ comparable Negative _ = POAny+ comparable Positive StrictlyPositive = POLT+ comparable StrictlyPositive Positive = POGT+ comparable _ _ = __IMPOSSIBLE__++instance Pretty ModalPolarity where+ pretty p = case p of+ UnusedPolarity -> "@unused"+ StrictlyPositive -> "@++"+ Positive -> "@+"+ Negative -> "@-"+ MixedPolarity -> mempty++-- | @morePolarity' x y@ is True whenever a variable of polarity x can be+-- used anywhere where a variable of polarity y is expected.+-- Note that @morePolarity' x y@ actually means x <= y.+morePolarity' :: ModalPolarity -> ModalPolarity -> Bool+morePolarity' x y = case comparable x y of+ POLT -> True+ POLE -> True+ POEQ -> True+ _ -> False++-- | @splittablePolarity pol == False@ iff we cannot split on a variable of @pol@.+splittablePolarity :: LensModalPolarity a => a -> Bool+splittablePolarity a = modPolarityAnn (getModalPolarity a) `morePolarity'` MixedPolarity++-- | 'ModalPolarity' composition.+-- 'UnusedPolarity' is dominant, 'StrictlyPositive' is neutral.+composePolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity+composePolarity' p p' =+ case (p, p') of+ (UnusedPolarity, _) -> UnusedPolarity+ (_, UnusedPolarity) -> UnusedPolarity+ (MixedPolarity, _) -> MixedPolarity+ (_, MixedPolarity) -> MixedPolarity+ (Negative, Negative) -> Positive+ (Negative, _) -> Negative+ (_, Negative) -> Negative+ (StrictlyPositive, StrictlyPositive) -> StrictlyPositive+ (_, _) -> Positive++-- | @inverseComposePolarity r x@ returns the least @y@+-- such that forall @x@, @y@ we have+-- @x \`morePolarity'\` (r \`composePolarity\` y)@+-- iff+-- @(r \`inverseComposePolarity\` x) \`morePolarity'\` y@ (Galois connection).+inverseComposePolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity+inverseComposePolarity' p x =+ case (p, x) of+ (MixedPolarity, MixedPolarity) -> MixedPolarity+ (MixedPolarity, _) -> UnusedPolarity+ (StrictlyPositive , x) -> x+ (UnusedPolarity, _) -> MixedPolarity+ (Positive, StrictlyPositive) -> UnusedPolarity+ (Positive, x) -> x+ (Negative, Positive) -> Negative+ (Negative, Negative) -> Positive+ (Negative, MixedPolarity) -> MixedPolarity+ (Negative, _) -> UnusedPolarity++-- | Combine inferred 'ModalPolarity'.+-- The unit is 'UnusedPolarity'.+addPolarity' :: ModalPolarity -> ModalPolarity -> ModalPolarity+addPolarity' p p' = case (p, p') of+ (MixedPolarity, _) -> MixedPolarity+ (_, MixedPolarity) -> MixedPolarity+ (UnusedPolarity, x) -> x+ (x, UnusedPolarity) -> x+ (Negative, Negative) -> Negative+ (Negative, _) -> MixedPolarity+ (_, Negative) -> MixedPolarity+ (Positive, _) -> Positive+ (_, Positive) -> Positive+ (StrictlyPositive, StrictlyPositive) -> StrictlyPositive+++data PolarityModality = PolarityModality+ { modPolarityAnn :: ModalPolarity -- ^ The actual polarity of the variable+ , modPolarityOrigin :: ModalPolarity -- ^ The original polarity annotation by the user+ , modPolarityLock :: ModalPolarity -- ^ The locks of the variable (= composition of all denominators the variable has been left divided by)+ } deriving (Show, Ord, Bounded, Generic)++instance Eq PolarityModality where+ (PolarityModality p _o _l) == (PolarityModality p' _o' _l') = p == p'++withStandardLock :: ModalPolarity -> PolarityModality+withStandardLock p = PolarityModality p p StrictlyPositive++instance HasRange PolarityModality where+ getRange _ = noRange++instance SetRange PolarityModality where+ setRange _ = id++instance KillRange PolarityModality where+ killRange rel = rel -- no range to kill++instance NFData PolarityModality where+ rnf (PolarityModality _p _o _l) = ()++instance Pretty PolarityModality where+ pretty (PolarityModality p _ _) = pretty p++instance PartialOrd PolarityModality where+ comparable (PolarityModality p _ _) (PolarityModality p' _ _) = comparable p p'++-- | A lens to access the 'PolarityModality' attribute in data structures.+-- Minimal implementation: @getModalPolarity@ and @mapModalPolarity@ or @LensModality@.+class LensModalPolarity a where++ getModalPolarity :: a -> PolarityModality++ setModalPolarity :: PolarityModality -> a -> a+ setModalPolarity h = mapModalPolarity (const h)++ mapModalPolarity :: (PolarityModality -> PolarityModality) -> a -> a++ default getModalPolarity :: LensModality a => a -> PolarityModality+ getModalPolarity = modPolarity . getModality++ default mapModalPolarity :: LensModality a => (PolarityModality -> PolarityModality) -> a -> a+ mapModalPolarity f = mapModality $ \ ai -> ai { modPolarity = f $ modPolarity ai }++instance LensModalPolarity PolarityModality where+ getModalPolarity = id+ setModalPolarity = const+ mapModalPolarity = id++-- | Equality for polarities.+samePolarity :: PolarityModality -> PolarityModality -> Bool+samePolarity (PolarityModality p _ _) (PolarityModality p' _ _) = p == p'++morePolarity :: PolarityModality -> PolarityModality -> Bool+morePolarity (PolarityModality p _ _) (PolarityModality p' _ _) = morePolarity' p p'++-- | @usablePolarity pol == False@ iff we cannot use a variable of @pol@.+usablePolarity :: LensModalPolarity a => a -> Bool+usablePolarity a = modPolarityAnn pol `morePolarity'` StrictlyPositive+ where+ pol = getModalPolarity a++-- | 'PolarityModality' composition.+--+composePolarity :: PolarityModality -> PolarityModality -> PolarityModality+composePolarity (PolarityModality p _o _l) (PolarityModality p' o' l') =+ PolarityModality (composePolarity' p p') o' l'++-- | Compose with polarity flag from the left.+-- This function is e.g. used to update the polarity information+-- on pattern variables @a@ after a match against something of polarity @pol@.+applyPolarity :: LensModalPolarity a => PolarityModality -> a -> a+applyPolarity pol = mapModalPolarity (pol `composePolarity`)++-- | @inverseComposePolarity r x@ returns the least @y@+-- such that forall @x@, @y@ we have+-- @x \`morePolarity'\` (r \`composePolarity\` y)@+-- iff+-- @(r \`inverseComposePolarity\` x) \`morePolarity'\` y@ (Galois connection).+inverseComposePolarity :: PolarityModality -> PolarityModality -> PolarityModality+inverseComposePolarity (PolarityModality p _o _l) (PolarityModality p' o' l') =+ PolarityModality (inverseComposePolarity' p p') o' (composePolarity' l' p)++-- | Left division by a 'PolarityModality'.+-- Used e.g. to modify context when going into a @pol@ argument.+inverseApplyPolarity :: LensModalPolarity a => PolarityModality -> a -> a+inverseApplyPolarity pol = mapModalPolarity (pol `inverseComposePolarity`)++-- | 'ModalPolarity' forms a semigroup under composition.+instance Semigroup (UnderComposition PolarityModality) where+ (<>) = liftA2 composePolarity++-- | 'Continous' is the multiplicative unit.+instance Monoid (UnderComposition PolarityModality) where+ mempty = pure unitPolarity+ mappend = (<>)++instance POSemigroup (UnderComposition PolarityModality) where+instance POMonoid (UnderComposition PolarityModality) where++instance LeftClosedPOMonoid (UnderComposition PolarityModality) where+ inverseCompose = liftA2 inverseComposePolarity++-- | 'ModalPolarity' forms a semigroup under addition.+instance Semigroup (UnderAddition PolarityModality) where+ (<>) = liftA2 addPolarity++-- | '' is the additive unit.+instance Monoid (UnderAddition PolarityModality) where+ mempty = pure zeroPolarity+ mappend = (<>)++instance POSemigroup (UnderAddition PolarityModality) where+instance POMonoid (UnderAddition PolarityModality) where++-- | Combine inferred 'PolarityModality'.+--+addPolarity :: PolarityModality -> PolarityModality -> PolarityModality+addPolarity (PolarityModality p _o _l) (PolarityModality p' o' l') =+ PolarityModality (addPolarity' p p') o' l'++-- | 'ModalPolarity' forms a monoid under addition, and even a semiring.+zeroPolarity :: PolarityModality+zeroPolarity = withStandardLock UnusedPolarity++-- | Identity under composition.+unitPolarity :: PolarityModality+unitPolarity = withStandardLock StrictlyPositive++-- | Alias for 'Negative' polarity.+negativePolarity :: PolarityModality+negativePolarity = withStandardLock Negative++-- | Alias for 'Mixed' polarity.+mixedPolarity :: PolarityModality+mixedPolarity = withStandardLock MixedPolarity++-- | Absorptive element under addition.+topPolarity :: PolarityModality+topPolarity = mixedPolarity++-- | Default used when not caring about polarity+defaultPolarity :: PolarityModality+defaultPolarity = mixedPolarity++instance Null PolarityModality where+ empty = defaultPolarity++prettyPolarity :: LensModalPolarity a => a -> Doc -> Doc+prettyPolarity a = (pretty (getModalPolarity a) <+>)++---------------------------------------------------------------------------+-- * Origin of arguments (user-written, inserted or reflected)+---------------------------------------------------------------------------++-- | Origin of arguments.+data Origin+ = UserWritten -- ^ From the source file / user input. (Preserve!)+ | Inserted -- ^ E.g. inserted hidden arguments.+ | Reflected -- ^ Produced by the reflection machinery.+ | CaseSplit -- ^ Produced by an interactive case split.+ | Substitution -- ^ Named application produced to represent a substitution. E.g. "?0 (x = n)" instead of "?0 n"+ | ExpandedPun -- ^ An expanded hidden argument pun.+ | Generalization -- ^ Inserted by the generalization process+ | ConversionFail+ -- ^ Inserted by the conversion checker in an argument spine at the+ -- position where they differ.+ --+ -- Indicates that the argument at this position should always be+ -- reified, even if the visibility/modality would be skipped with+ -- the current flags.+ | RecordSelf+ -- ^ Inserted to stand for the record "self" variable when checking a+ -- declaration inside a record module.+ deriving (Show, Eq, Ord, Enum, Bounded, Ix)++instance SmallSetElement Origin++instance HasRange Origin where+ getRange _ = noRange++instance KillRange Origin where+ killRange = id++instance NFData Origin where+ rnf UserWritten = ()+ rnf Inserted = ()+ rnf Reflected = ()+ rnf CaseSplit = ()+ rnf Substitution = ()+ rnf ExpandedPun = ()+ rnf Generalization = ()+ rnf ConversionFail = ()+ rnf RecordSelf = ()++-- | Decorating something with 'Origin' information.+data WithOrigin a = WithOrigin+ { woOrigin :: !Origin+ , woThing :: a+ }+ deriving (Eq, Ord, Show, Functor, Foldable, Traversable)++instance Decoration WithOrigin where+ traverseF f (WithOrigin h a) = WithOrigin h <$> f a++instance Pretty a => Pretty (WithOrigin a) where+ prettyPrec p = prettyPrec p . woThing++instance HasRange a => HasRange (WithOrigin a) where+ getRange = getRange . dget++instance SetRange a => SetRange (WithOrigin a) where+ setRange = fmap . setRange++instance KillRange a => KillRange (WithOrigin a) where+ killRange = fmap killRange++instance NFData a => NFData (WithOrigin a) where+ rnf (WithOrigin _ a) = rnf a++-- | A lens to access the 'Origin' attribute in data structures.+-- Minimal implementation: @getOrigin@ and @mapOrigin@ or @LensArgInfo@.++class LensOrigin a where++ getOrigin :: a -> Origin++ setOrigin :: Origin -> a -> a+ setOrigin o = mapOrigin (const o)++ mapOrigin :: (Origin -> Origin) -> a -> a++ default getOrigin :: LensArgInfo a => a -> Origin+ getOrigin = argInfoOrigin . getArgInfo++ default mapOrigin :: LensArgInfo a => (Origin -> Origin) -> a -> a+ mapOrigin f = mapArgInfo $ \ ai -> ai { argInfoOrigin = f $ argInfoOrigin ai }++instance LensOrigin Origin where+ getOrigin = id+ setOrigin = const+ mapOrigin = id++instance LensOrigin (WithOrigin a) where+ getOrigin (WithOrigin h _) = h+ setOrigin h (WithOrigin _ a) = WithOrigin h a+ mapOrigin f (WithOrigin h a) = WithOrigin (f h) a++------------------------------------------------------------------------+-- Origin of binder names+------------------------------------------------------------------------++data BinderNameOrigin+ = UserBinderName+ | InsertedBinderName+ deriving (Show, Eq, Generic)++instance KillRange BinderNameOrigin where+ killRange = \case+ InsertedBinderName -> InsertedBinderName+ UserBinderName -> UserBinderName++instance NFData BinderNameOrigin++-----------------------------------------------------------------------------+-- * Free variable annotations+-----------------------------------------------------------------------------++data FreeVariables = UnknownFVs | KnownFVs !VarSet+ deriving (Eq, Ord, Show)++instance Semigroup FreeVariables where+ UnknownFVs <> _ = UnknownFVs+ _ <> UnknownFVs = UnknownFVs+ KnownFVs vs1 <> KnownFVs vs2 = KnownFVs (VarSet.union vs1 vs2)++instance Monoid FreeVariables where+ mempty = KnownFVs empty+ mappend = (<>)++instance KillRange FreeVariables where+ killRange = id++instance NFData FreeVariables where+ rnf UnknownFVs = ()+ rnf (KnownFVs fv) = rnf fv++unknownFreeVariables :: FreeVariables+unknownFreeVariables = UnknownFVs++noFreeVariables :: FreeVariables+noFreeVariables = mempty++oneFreeVariable :: Int -> FreeVariables+oneFreeVariable = KnownFVs . singleton++freeVariablesFromList :: [Int] -> FreeVariables+freeVariablesFromList = mconcat . map oneFreeVariable++-- | A lens to access the 'FreeVariables' attribute in data structures.+-- Minimal implementation: @getFreeVariables@ and @mapFreeVariables@ or @LensArgInfo@.+class LensFreeVariables a where++ getFreeVariables :: a -> FreeVariables++ setFreeVariables :: FreeVariables -> a -> a+ setFreeVariables o = mapFreeVariables (const o)++ mapFreeVariables :: (FreeVariables -> FreeVariables) -> a -> a++ default getFreeVariables :: LensArgInfo a => a -> FreeVariables+ getFreeVariables = argInfoFreeVariables . getArgInfo++ default mapFreeVariables :: LensArgInfo a => (FreeVariables -> FreeVariables) -> a -> a+ mapFreeVariables f = mapArgInfo $ \ ai -> ai { argInfoFreeVariables = f $ argInfoFreeVariables ai }++instance LensFreeVariables FreeVariables where+ getFreeVariables = id+ setFreeVariables = const+ mapFreeVariables = id++hasNoFreeVariables :: LensFreeVariables a => a -> Bool+hasNoFreeVariables x =+ case getFreeVariables x of+ UnknownFVs -> False+ KnownFVs fv -> null fv++---------------------------------------------------------------------------+-- * Argument decoration+---------------------------------------------------------------------------++-- | A function argument can be hidden and/or irrelevant.++data ArgInfo = ArgInfo+ { argInfoHiding :: Hiding+ , argInfoModality :: Modality+ , argInfoOrigin :: Origin+ , argInfoFreeVariables :: FreeVariables+ , argInfoAnnotation :: Annotation+ -- ^ Sometimes we want a different kind of binder/pi-type, without it+ -- supporting any of the @Modality@ interface.+ } deriving (Eq, Ord, Show)++instance HasRange ArgInfo where+ getRange (ArgInfo h m o _fv a) = getRange (h, m, o, a)++instance KillRange ArgInfo where+ killRange (ArgInfo h m o fv a) = killRangeN ArgInfo h m o fv a++class LensArgInfo a where+ getArgInfo :: a -> ArgInfo+ setArgInfo :: ArgInfo -> a -> a+ setArgInfo ai = mapArgInfo (const ai)+ mapArgInfo :: (ArgInfo -> ArgInfo) -> a -> a+ mapArgInfo f a = setArgInfo (f $ getArgInfo a) a+ {-# MINIMAL getArgInfo , (setArgInfo | mapArgInfo) #-}++instance LensArgInfo ArgInfo where+ getArgInfo = id+ setArgInfo = const+ mapArgInfo = id++instance NFData ArgInfo where+ rnf (ArgInfo a b c d e) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf e++instance LensHiding ArgInfo where+ getHiding = argInfoHiding+ setHiding h ai = ai { argInfoHiding = h }+ mapHiding f ai = ai { argInfoHiding = f (argInfoHiding ai) }++instance LensModality ArgInfo where+ getModality = argInfoModality+ setModality m ai = ai { argInfoModality = m }+ mapModality f ai = ai { argInfoModality = f (argInfoModality ai) }++instance LensOrigin ArgInfo where+ getOrigin = argInfoOrigin+ setOrigin o ai = ai { argInfoOrigin = o }+ mapOrigin f ai = ai { argInfoOrigin = f (argInfoOrigin ai) }++instance LensFreeVariables ArgInfo where+ getFreeVariables = argInfoFreeVariables+ setFreeVariables o ai = ai { argInfoFreeVariables = o }+ mapFreeVariables f ai = ai { argInfoFreeVariables = f (argInfoFreeVariables ai) }++instance LensAnnotation ArgInfo where+ getAnnotation = argInfoAnnotation+ setAnnotation m ai = ai { argInfoAnnotation = m }+ mapAnnotation f ai = ai { argInfoAnnotation = f (argInfoAnnotation ai) }++-- inherited instances++instance LensRelevance ArgInfo where+ getRelevance = getRelevanceMod+ setRelevance = setRelevanceMod+ mapRelevance = mapRelevanceMod++instance LensQuantity ArgInfo where+ getQuantity = getQuantityMod+ setQuantity = setQuantityMod+ mapQuantity = mapQuantityMod++instance LensCohesion ArgInfo where+ getCohesion = getCohesionMod+ setCohesion = setCohesionMod+ mapCohesion = mapCohesionMod++instance LensModalPolarity ArgInfo where+ getModalPolarity = getPolarityMod+ setModalPolarity = setPolarityMod+ mapModalPolarity = mapPolarityMod++instance Null ArgInfo where+ empty = defaultArgInfo+ null (ArgInfo h m _o _fv ann) = and [ null h, null m, null ann ]++defaultArgInfo :: ArgInfo+defaultArgInfo = ArgInfo+ { argInfoHiding = NotHidden+ , argInfoModality = defaultModality+ , argInfoOrigin = UserWritten+ , argInfoFreeVariables = UnknownFVs+ , argInfoAnnotation = defaultAnnotation+ }++defaultIrrelevantArgInfo :: ArgInfo+defaultIrrelevantArgInfo = setRelevance irrelevant defaultArgInfo+++-- Accessing through ArgInfo++-- default accessors for Hiding++getHidingArgInfo :: LensArgInfo a => LensGet a Hiding+getHidingArgInfo = getHiding . getArgInfo++setHidingArgInfo :: LensArgInfo a => LensSet a Hiding+setHidingArgInfo = mapArgInfo . setHiding++mapHidingArgInfo :: LensArgInfo a => LensMap a Hiding+mapHidingArgInfo = mapArgInfo . mapHiding++-- default accessors for Modality++getModalityArgInfo :: LensArgInfo a => LensGet a Modality+getModalityArgInfo = getModality . getArgInfo++setModalityArgInfo :: LensArgInfo a => LensSet a Modality+setModalityArgInfo = mapArgInfo . setModality++mapModalityArgInfo :: LensArgInfo a => LensMap a Modality+mapModalityArgInfo = mapArgInfo . mapModality++-- default accessors for Origin++getOriginArgInfo :: LensArgInfo a => LensGet a Origin+getOriginArgInfo = getOrigin . getArgInfo++setOriginArgInfo :: LensArgInfo a => LensSet a Origin+setOriginArgInfo = mapArgInfo . setOrigin++mapOriginArgInfo :: LensArgInfo a => LensMap a Origin+mapOriginArgInfo = mapArgInfo . mapOrigin++-- default accessors for FreeVariables++getFreeVariablesArgInfo :: LensArgInfo a => LensGet a FreeVariables+getFreeVariablesArgInfo = getFreeVariables . getArgInfo++setFreeVariablesArgInfo :: LensArgInfo a => LensSet a FreeVariables+setFreeVariablesArgInfo = mapArgInfo . setFreeVariables++mapFreeVariablesArgInfo :: LensArgInfo a => LensMap a FreeVariables+mapFreeVariablesArgInfo = mapArgInfo . mapFreeVariables++-- inserted hidden arguments++isInsertedHidden :: (LensHiding a, LensOrigin a) => a -> Bool+isInsertedHidden a = getHiding a == Hidden && getOrigin a == Inserted++---------------------------------------------------------------------------+-- * Arguments+---------------------------------------------------------------------------++data Arg e = Arg+ { argInfo :: ArgInfo+ , unArg :: e+ } deriving (Eq, Ord, Show, Foldable, Traversable)++instance Functor Arg where+ fmap f = \(Arg x y) -> Arg x $! f y++instance Decoration Arg where+ traverseF f (Arg ai a) = Arg ai <$> f a++instance HasRange a => HasRange (Arg a) where+ getRange = getRange . unArg++instance SetRange a => SetRange (Arg a) where+ setRange r = fmap $ setRange r++instance KillRange a => KillRange (Arg a) where+ killRange (Arg info a) = killRangeN Arg info a++-- Andreas, 2019-07-05, issue #3889+-- A dedicated equality for with-abstraction now exists,+-- thus, we can use intensional equality for Arg.+--+-- -- | Ignores 'Quantity', 'Relevance', 'Origin', and 'FreeVariables'.+-- -- Ignores content of argument if 'Irrelevant'.+-- --+-- instance Eq a => Eq (Arg a) where+-- Arg (ArgInfo h1 m1 _ _) x1 == Arg (ArgInfo h2 m2 _ _) x2 =+-- h1 == h2 && (isIrrelevant m1 || isIrrelevant m2 || x1 == x2)+-- -- Andreas, 2017-10-04, issue #2775, ignore irrelevant arguments during with-abstraction.+-- -- This is a hack, we should not use '(==)' in with-abstraction+-- -- and more generally not use it on Syntax.+-- -- Andrea: except for caching.++-- instance Show a => Show (Arg a) where+-- show (Arg (ArgInfo h (Modality r q) o fv) a) = showFVs fv $ showQ q $ showR r $ showO o $ showH h $ show a+-- where+-- showH Hidden s = "{" ++ s ++ "}"+-- showH NotHidden s = "(" ++ s ++ ")"+-- showH (Instance o) s = showOv o ++ "{{" ++ s ++ "}}"+-- where showOv YesOverlap = "overlap "+-- showOv NoOverlap = ""+-- showR r s = case r of+-- Irrelevant -> "." ++ s+-- ShapeIrrelevant -> "?" ++ s+-- Relevant -> "r" ++ s -- Andreas: I want to see it explicitly+-- showQ q s = case q of+-- Quantity0 -> "0" ++ s+-- Quantity1 -> "1" ++ s+-- Quantityω -> "ω" ++ s+-- showO o s = case o of+-- UserWritten -> "u" ++ s+-- Inserted -> "i" ++ s+-- Reflected -> "g" ++ s -- generated by reflection+-- CaseSplit -> "c" ++ s -- generated by case split+-- Substitution -> "s" ++ s+-- showFVs UnknownFVs s = s+-- showFVs (KnownFVs fv) s = "fv" ++ show (IntSet.toList fv) ++ s++-- Andreas 2010-09-21: do not print relevance in general, only in function types!+-- Andreas 2010-09-24: and in record fields+instance Pretty a => Pretty (Arg a) where+ prettyPrec p (Arg ai e) = prettyHiding ai localParens $ prettyPrec p' e+ where p' | visible ai = p+ | otherwise = 0+ localParens | getOrigin ai == Substitution = parens+ | otherwise = id++instance NFData e => NFData (Arg e) where+ rnf (Arg a b) = rnf a `seq` rnf b++instance LensArgInfo (Arg a) where+ getArgInfo = argInfo+ setArgInfo ai arg = arg { argInfo = ai }+ mapArgInfo f arg = arg { argInfo = f $ argInfo arg }++-- The other lenses are defined through LensArgInfo++instance LensHiding (Arg e) where+ getHiding = getHidingArgInfo+ setHiding = setHidingArgInfo+ mapHiding = mapHidingArgInfo++instance LensModality (Arg e) where+ getModality = getModalityArgInfo+ setModality = setModalityArgInfo+ mapModality = mapModalityArgInfo++instance LensOrigin (Arg e) where+ getOrigin = getOriginArgInfo+ setOrigin = setOriginArgInfo+ mapOrigin = mapOriginArgInfo++instance LensFreeVariables (Arg e) where+ getFreeVariables = getFreeVariablesArgInfo+ setFreeVariables = setFreeVariablesArgInfo+ mapFreeVariables = mapFreeVariablesArgInfo++-- Since we have LensModality, we get relevance and quantity by default++instance LensRelevance (Arg e) where+ getRelevance = getRelevanceMod+ setRelevance = setRelevanceMod+ mapRelevance = mapRelevanceMod++instance LensQuantity (Arg e) where+ getQuantity = getQuantityMod+ setQuantity = setQuantityMod+ mapQuantity = mapQuantityMod++instance LensCohesion (Arg e) where+ getCohesion = getCohesionMod+ setCohesion = setCohesionMod+ mapCohesion = mapCohesionMod++instance LensModalPolarity (Arg e) where+ getModalPolarity = getPolarityMod+ setModalPolarity = setPolarityMod+ mapModalPolarity = mapPolarityMod++{-# INLINE defaultArg #-}+defaultArg :: a -> Arg a+defaultArg = Arg defaultArgInfo++-- | @xs \`withArgsFrom\` args@ translates @xs@ into a list of 'Arg's,+-- using the elements in @args@ to fill in the non-'unArg' fields.+--+-- Precondition: The two lists should have equal length.++withArgsFrom :: [a] -> [Arg b] -> [Arg a]+xs `withArgsFrom` args =+ zipWith (\x arg -> fmap (const x) arg) xs args++withNamedArgsFrom :: [a] -> [NamedArg b] -> [NamedArg a]+xs `withNamedArgsFrom` args =+ zipWith (\x -> fmap (x <$)) xs args++---------------------------------------------------------------------------+-- * Names+---------------------------------------------------------------------------++class Eq a => Underscore a where+ underscore :: a+ isUnderscore :: a -> Bool+ isUnderscore = (== underscore)++instance Underscore String where+ underscore = "_"++instance Underscore ByteString where+ underscore = ByteString.pack underscore++instance Underscore Doc where+ underscore = text underscore++---------------------------------------------------------------------------+-- * Named arguments+---------------------------------------------------------------------------++-- | Something potentially carrying a name.+data Named name a =+ Named { nameOf :: Maybe name+ , namedThing :: a+ }+ deriving (Eq, Ord, Show, Functor, Foldable, Traversable)++-- | Standard naming.+type Named_ = Named NamedName++-- | Standard argument names.+type NamedName = WithOrigin (Ranged ArgName)++-- | Equality of argument names of things modulo 'Range' and 'Origin'.+sameName :: NamedName -> NamedName -> Bool+sameName = (==) `on` (rangedThing . woThing)++unnamed :: a -> Named name a+unnamed = Named Nothing++isUnnamed :: Named name a -> Maybe a+isUnnamed = \case+ Named Nothing a -> Just a+ Named Just{} _ -> Nothing++named :: name -> a -> Named name a+named = Named . Just++userNamed :: Ranged ArgName -> a -> Named_ a+userNamed = Named . Just . WithOrigin UserWritten++-- | Accessor/editor for the 'nameOf' component.+class LensNamed a where+ -- | The type of the name+ type NameOf a+ lensNamed :: Lens' a (Maybe (NameOf a))++ -- Lenses lift through decorations:+ default lensNamed :: (Decoration f, LensNamed b, NameOf b ~ NameOf a, f b ~ a) => Lens' a (Maybe (NameOf a))+ lensNamed = traverseF . lensNamed++instance LensNamed a => LensNamed (Arg a) where+ type NameOf (Arg a) = NameOf a++instance LensNamed (Maybe a) where+ type NameOf (Maybe a) = a+ lensNamed = id++instance LensNamed (Named name a) where+ type NameOf (Named name a) = name++ lensNamed f (Named mn a) = f mn <&> \ mn' -> Named mn' a++getNameOf :: LensNamed a => a -> Maybe (NameOf a)+getNameOf a = a ^. lensNamed++setNameOf :: LensNamed a => Maybe (NameOf a) -> a -> a+setNameOf = set lensNamed++mapNameOf :: LensNamed a => (Maybe (NameOf a) -> Maybe (NameOf a)) -> a -> a+mapNameOf = over lensNamed++bareNameOf :: (LensNamed a, NameOf a ~ NamedName) => a -> Maybe ArgName+bareNameOf a = rangedThing . woThing <$> getNameOf a++bareNameWithDefault :: (LensNamed a, NameOf a ~ NamedName) => ArgName -> a -> ArgName+bareNameWithDefault x a = maybe x (rangedThing . woThing) $ getNameOf a++-- | Equality of argument names of things modulo 'Range' and 'Origin'.+namedSame :: (LensNamed a, LensNamed b, NameOf a ~ NamedName, NameOf b ~ NamedName) => a -> b -> Bool+namedSame a b = case (getNameOf a, getNameOf b) of+ (Nothing, Nothing) -> True+ (Just x , Just y ) -> sameName x y+ _ -> False++-- | Does an argument @arg@ fit the shape @dom@ of the next expected argument?+--+-- The hiding has to match, and if the argument has a name, it should match+-- the name of the domain.+--+-- 'Nothing' should be '__IMPOSSIBLE__', so use as+-- @@+-- fromMaybe __IMPOSSIBLE__ $ fittingNamedArg arg dom+-- @@+--+fittingNamedArg+ :: ( LensNamed arg, NameOf arg ~ NamedName, LensHiding arg+ , LensNamed dom, NameOf dom ~ NamedName, LensHiding dom )+ => arg -> dom -> Maybe Bool+fittingNamedArg arg dom+ | not $ sameHiding arg dom = no+ | visible arg = yes+ | otherwise =+ caseMaybe (bareNameOf arg) yes $ \ x ->+ caseMaybe (bareNameOf dom) impossible $ \ y ->+ return $ x == y+ where+ yes = return True+ no = return False+ impossible = Nothing++-- Standard instances for 'Named':++instance Decoration (Named name) where+ traverseF f (Named n a) = Named n <$> f a++instance HasRange a => HasRange (Named name a) where+ getRange = getRange . namedThing++instance SetRange a => SetRange (Named name a) where+ setRange r = fmap $ setRange r++instance (KillRange name, KillRange a) => KillRange (Named name a) where+ killRange (Named n a) = Named (killRange n) (killRange a)++-- instance Show a => Show (Named_ a) where+-- show (Named Nothing a) = show a+-- show (Named (Just n) a) = rawNameToString (rangedThing n) ++ " = " ++ show a++-- -- Defined in Concrete.Pretty+-- instance Pretty a => Pretty (Named_ a) where+-- pretty (Named Nothing a) = pretty a+-- pretty (Named (Just n) a) = text (rawNameToString (rangedThing n)) <+> "=" <+> pretty a++instance (NFData name, NFData a) => NFData (Named name a) where+ rnf (Named a b) = rnf a `seq` rnf b++instance Pretty e => Pretty (Named_ e) where+ prettyPrec p (Named nm e)+ | Just s <- bareNameOf nm = mparens (p > 0) $ sep [ text s <+> "=", pretty e ]+ | otherwise = prettyPrec p e++-- | Only 'Hidden' arguments can have names.+type NamedArg a = Arg (Named_ a)++-- | Get the content of a 'NamedArg'.+namedArg :: NamedArg a -> a+namedArg = namedThing . unArg++defaultNamedArg :: a -> NamedArg a+defaultNamedArg = unnamedArg defaultArgInfo++unnamedArg :: ArgInfo -> a -> NamedArg a+unnamedArg info = Arg info . unnamed++-- | The functor instance for 'NamedArg' would be ambiguous,+-- so we give it another name here.+updateNamedArg :: (a -> b) -> NamedArg a -> NamedArg b+updateNamedArg = fmap . fmap++updateNamedArgA :: Applicative f => (a -> f b) -> NamedArg a -> f (NamedArg b)+updateNamedArgA = traverse . traverse++-- | @setNamedArg a b = updateNamedArg (const b) a@+setNamedArg :: NamedArg a -> b -> NamedArg b+setNamedArg a b = (b <$) <$> a++-- ** ArgName++-- | Names in binders and arguments.+type ArgName = String++argNameToString :: ArgName -> String+argNameToString = id++stringToArgName :: String -> ArgName+stringToArgName = id++appendArgNames :: ArgName -> ArgName -> ArgName+appendArgNames = (++)++---------------------------------------------------------------------------+-- * Range decoration.+---------------------------------------------------------------------------++-- | Thing with range info.+data Ranged a = Ranged+ { rangeOf :: Range+ , rangedThing :: a+ }+ deriving (Show, Functor, Foldable, Traversable)++-- | Thing with no range info.+unranged :: a -> Ranged a+unranged = Ranged noRange++-- | Ignores range.+instance Pretty a => Pretty (Ranged a) where+ pretty = pretty . rangedThing++-- | Ignores range.+instance Eq a => Eq (Ranged a) where+ (==) = (==) `on` rangedThing++-- | Ignores range.+instance Ord a => Ord (Ranged a) where+ compare = compare `on` rangedThing++instance HasRange (Ranged a) where+ getRange = rangeOf++instance KillRange (Ranged a) where+ killRange (Ranged _ x) = Ranged noRange x++instance Decoration Ranged where+ traverseF f (Ranged r x) = Ranged r <$> f x++-- | Ranges are not forced.++instance NFData a => NFData (Ranged a) where+ rnf (Ranged _ a) = rnf a++---------------------------------------------------------------------------+-- * Raw names (before parsing into name parts).+---------------------------------------------------------------------------++-- | A @RawName@ is some sort of string.+type RawName = String++rawNameToString :: RawName -> String+rawNameToString = id++stringToRawName :: String -> RawName+stringToRawName = id++-- | String with range info.+type RString = Ranged RawName++---------------------------------------------------------------------------+-- * Further constructor and projection info+---------------------------------------------------------------------------++-- | Where does the 'ConP' or 'Con' come from?+data ConOrigin+ = ConOSystem -- ^ Inserted by system or expanded from an implicit pattern.+ | ConOCon -- ^ User wrote a constructor (pattern).+ | ConORec -- ^ User wrote a record (pattern).+ | ConOSplit -- ^ Generated by interactive case splitting.+ deriving (Show, Eq, Ord, Enum, Bounded, Generic)++instance NFData ConOrigin++instance KillRange ConOrigin where+ killRange = id++-- | Prefer user-written over system-inserted.+bestConInfo :: ConOrigin -> ConOrigin -> ConOrigin+bestConInfo ConOSystem o = o+bestConInfo o _ = o++-- | Where does a projection come from?+data ProjOrigin+ = ProjPrefix -- ^ User wrote a prefix projection.+ | ProjPostfix -- ^ User wrote a postfix projection.+ | ProjSystem -- ^ Projection was generated by the system.+ deriving (Show, Eq, Ord, Enum, Bounded, Generic)++instance NFData ProjOrigin++instance KillRange ProjOrigin where+ killRange = id++---------------------------------------------------------------------------+-- * Infixity, access, abstract, etc.+---------------------------------------------------------------------------++-- | Functions can be defined in both infix and prefix style. See+-- 'Agda.Syntax.Concrete.LHS'.+data IsInfix = InfixDef | PrefixDef+ deriving (Show, Eq, Ord)++-- ** private blocks, public imports++-- | Access modifier.+data Access+ = PrivateAccess KwRange Origin+ -- ^ Store the 'Origin' of the private block that lead to this qualifier.+ -- This is needed for more faithful printing of declarations.+ -- 'KwRange' is the range of the @private@ keyword.+ | PublicAccess+ deriving (Show, Eq, Ord)++instance Pretty Access where+ pretty = text . \case+ PrivateAccess _ _ -> "private"+ PublicAccess -> "public"++instance NFData Access where+ rnf _ = ()++instance HasRange Access where+ getRange _ = noRange++instance KillRange Access where+ killRange = id++privateAccessInserted :: Access+privateAccessInserted = PrivateAccess empty Inserted++-- ** abstract blocks++-- | Abstract or concrete.+data IsAbstract = AbstractDef | ConcreteDef+ deriving (Show, Eq, Ord, Generic)++-- | Semigroup computes if any of several is an 'AbstractDef'.+instance Semigroup IsAbstract where+ AbstractDef <> _ = AbstractDef+ ConcreteDef <> a = a++-- | Default is 'ConcreteDef'.+instance Monoid IsAbstract where+ mempty = ConcreteDef+ mappend = (<>)++instance Boolean IsAbstract where+ fromBool True = AbstractDef+ fromBool False = ConcreteDef++instance IsBool IsAbstract where+ toBool AbstractDef = True+ toBool ConcreteDef = False++instance KillRange IsAbstract where+ killRange = id++instance NFData IsAbstract++class LensIsAbstract a where+ lensIsAbstract :: Lens' a IsAbstract++instance LensIsAbstract IsAbstract where+ lensIsAbstract = id++-- | Is any element of a collection an 'AbstractDef'.+class AnyIsAbstract a where+ anyIsAbstract :: a -> IsAbstract++ default anyIsAbstract :: (Foldable t, AnyIsAbstract b, t b ~ a) => a -> IsAbstract+ anyIsAbstract = Fold.foldMap anyIsAbstract++instance AnyIsAbstract IsAbstract where+ anyIsAbstract = id++instance AnyIsAbstract a => AnyIsAbstract [a] where+instance AnyIsAbstract a => AnyIsAbstract (Maybe a) where++-- ** instance blocks++-- | Is this definition eligible for instance search?+data IsInstance+ = InstanceDef KwRange -- ^ Range of the @instance@ keyword.+ | NotInstanceDef+ deriving (Show, Eq, Ord)++instance Null IsInstance where+ empty = NotInstanceDef++instance KillRange IsInstance where+ killRange = \case+ InstanceDef _ -> InstanceDef empty+ i@NotInstanceDef -> i++instance HasRange IsInstance where+ getRange = \case+ InstanceDef r -> getRange r+ NotInstanceDef -> noRange++instance NFData IsInstance where+ rnf (InstanceDef _) = ()+ rnf NotInstanceDef = ()++class IsInstanceDef a where+ isInstanceDef :: a -> Maybe KwRange++instance IsInstanceDef IsInstance where+ isInstanceDef = \case+ InstanceDef r -> Just r+ NotInstanceDef -> Nothing++-- ** macro blocks++-- | Is this a macro definition?+data IsMacro = MacroDef | NotMacroDef+ deriving (Show, Eq, Ord, Generic)++instance KillRange IsMacro where killRange = id+instance HasRange IsMacro where getRange _ = noRange++instance NFData IsMacro++-- ** opaque blocks++-- | Opaque or transparent.+data IsOpaque+ = OpaqueDef {-# UNPACK #-} !OpaqueId+ -- ^ This definition is opaque, and it is guarded by the given+ -- opaque block.+ | TransparentDef+ deriving (Show, Eq, Ord, Generic)++instance KillRange IsOpaque where+ killRange = id++instance NFData IsOpaque++class LensIsOpaque a where+ lensIsOpaque :: Lens' a IsOpaque++instance LensIsOpaque IsOpaque where+ lensIsOpaque = id++-- | Monoid representing the combined opaque blocks of a 'Foldable'+-- containing possibly-opaque declarations.+data JointOpacity+ = UniqueOpaque {-# UNPACK #-} !OpaqueId+ -- ^ Every definition agrees on what opaque block they belong to.+ | DifferentOpaque !(HashSet OpaqueId)+ -- ^ More than one opaque block was found.+ | NoOpaque+ -- ^ Nothing here is opaque.++instance Semigroup JointOpacity where+ UniqueOpaque i <> UniqueOpaque j+ | i == j = UniqueOpaque i+ | otherwise = DifferentOpaque (HashSet.fromList [i, j])++ DifferentOpaque is <> UniqueOpaque j = DifferentOpaque (HashSet.insert j is)+ UniqueOpaque i <> DifferentOpaque js = DifferentOpaque (HashSet.insert i js)+ DifferentOpaque is <> DifferentOpaque js = DifferentOpaque (HashSet.union is js)++ NoOpaque <> x = x+ x <> NoOpaque = x++instance Monoid JointOpacity where+ mappend = (<>)+ mempty = NoOpaque++class AllAreOpaque a where+ jointOpacity :: a -> JointOpacity++ default jointOpacity :: (Foldable t, AllAreOpaque b, t b ~ a) => a -> JointOpacity+ jointOpacity = Fold.foldMap jointOpacity++instance AllAreOpaque IsOpaque where+ jointOpacity = \case+ TransparentDef -> NoOpaque+ OpaqueDef i -> UniqueOpaque i++instance AllAreOpaque a => AllAreOpaque [a] where+instance AllAreOpaque a => AllAreOpaque (Maybe a) where++---------------------------------------------------------------------------+-- * NameId+---------------------------------------------------------------------------++-- | The unique identifier of a name. Second argument is the top-level module+-- identifier.+data NameId = NameId {-# UNPACK #-} !Word64 {-# UNPACK #-} !ModuleNameHash+ deriving (Eq, Ord, Generic, Show)++instance Null NameId where+ empty = NameId empty empty+ null (NameId n m) = null n && null m++instance KillRange NameId where+ killRange = id++instance Pretty NameId where+ pretty (NameId n m) = text $ show n ++ "@" ++ show m++instance Enum NameId where+ succ (NameId n m) = NameId (n + 1) m+ pred (NameId n m) = NameId (n - 1) m+ toEnum _ = __IMPOSSIBLE__ -- should not be used+ fromEnum (NameId n _) = fromIntegral n++instance NFData NameId where+ rnf (NameId _ _) = ()++instance Hashable NameId where+ {-# INLINE hashWithSalt #-}+ hashWithSalt salt (NameId n (ModuleNameHash m)) =+ fromIntegral+ (fromIntegral salt `combineWord` fromIntegral n `combineWord` fromIntegral m)++---------------------------------------------------------------------------+-- * Meta variables+---------------------------------------------------------------------------++-- | Meta-variable identifiers use the same structure as 'NameId's.++data MetaId = MetaId+ { metaId :: {-# UNPACK #-} !Word64+ , metaModule :: {-# UNPACK #-} !ModuleNameHash+ }+ deriving (Eq, Ord, Generic)++instance Pretty MetaId where+ pretty (MetaId n m) =+ text $ "_" ++ show n ++ "@" ++ show (moduleNameHash m)++instance Enum MetaId where+ succ m@MetaId{ metaId } = m { metaId = succ metaId }+ pred m@MetaId{ metaId } = m { metaId = pred metaId }++ -- The following functions should not be used.+ toEnum = __IMPOSSIBLE__+ fromEnum = __IMPOSSIBLE__++-- | The record selectors are not included in the resulting strings.++instance Show MetaId where+ showsPrec p (MetaId n m) = showParen (p > 0) $+ showString "MetaId " .+ showsPrec 11 n .+ showString " " .+ showsPrec 11 m++instance NFData MetaId where+ rnf (MetaId x y) = rnf x `seq` rnf y++instance Hashable MetaId where+ {-# INLINE hashWithSalt #-}+ hashWithSalt salt (MetaId n m) = hashWithSalt salt (n, m)++newtype Constr a = Constr a++-----------------------------------------------------------------------------+-- * Problems+-----------------------------------------------------------------------------++-- | A "problem" consists of a set of constraints and the same constraint can be part of multiple+-- problems.+newtype ProblemId = ProblemId Word64+ deriving (Eq, Ord, Enum, Real, Integral, Num, NFData)++-- This particular Show instance is ok because of the Num instance.+instance Show ProblemId where show (ProblemId n) = show n+instance Pretty ProblemId where pretty (ProblemId n) = pretty n++-- | The unique identifier of an opaque block. Second argument is the+-- top-level module identifier.+data OpaqueId = OpaqueId {-# UNPACK #-} !Word64 {-# UNPACK #-} !ModuleNameHash+ deriving (Eq, Ord, Generic, Show)++instance KillRange OpaqueId where+ killRange = id++instance Pretty OpaqueId where+ pretty (OpaqueId n m) = text $ show n ++ "@" ++ show m++instance Enum OpaqueId where+ succ (OpaqueId n m) = OpaqueId (n + 1) m+ pred (OpaqueId n m) = OpaqueId (n - 1) m+ toEnum _ = __IMPOSSIBLE__ -- should not be used+ fromEnum (OpaqueId n _) = fromIntegral n++instance NFData OpaqueId where+ rnf (OpaqueId _ _) = ()++instance Hashable OpaqueId where+ {-# INLINE hashWithSalt #-}+ hashWithSalt salt (OpaqueId n (ModuleNameHash m)) = hashWithSalt salt (n, m)++------------------------------------------------------------------------+-- * Placeholders (used to parse sections)+------------------------------------------------------------------------++-- | The position of a name part or underscore in a name.++data PositionInName+ = Beginning+ -- ^ The following underscore is at the beginning of the name:+ -- @_foo@.+ | Middle+ -- ^ The following underscore is in the middle of the name:+ -- @foo_bar@.+ | End+ -- ^ The following underscore is at the end of the name: @foo_@.+ deriving (Show, Eq, Ord)++-- | Placeholders are used to represent the underscores in a section.++data MaybePlaceholder e+ = Placeholder !PositionInName+ | NoPlaceholder !(Strict.Maybe PositionInName) e+ -- ^ The second argument is used only (but not always) for name+ -- parts other than underscores.+ deriving (Eq, Ord, Functor, Foldable, Traversable, Show)++-- | An abbreviation: @noPlaceholder = 'NoPlaceholder'+-- 'Strict.Nothing'@.++noPlaceholder :: e -> MaybePlaceholder e+noPlaceholder = NoPlaceholder Strict.Nothing++instance HasRange a => HasRange (MaybePlaceholder a) where+ getRange Placeholder{} = noRange+ getRange (NoPlaceholder _ e) = getRange e++instance KillRange a => KillRange (MaybePlaceholder a) where+ killRange p@Placeholder{} = p+ killRange (NoPlaceholder p e) = killRangeN (NoPlaceholder p) e++instance NFData a => NFData (MaybePlaceholder a) where+ rnf (Placeholder _) = ()+ rnf (NoPlaceholder _ a) = rnf a++---------------------------------------------------------------------------+-- * Interaction meta variables+---------------------------------------------------------------------------++newtype InteractionId = InteractionId { interactionId :: Nat }+ deriving ( Eq+ , Ord+ , Show+ , Num+ , Integral+ , Real+ , Enum+ , NFData+ )++instance Pretty InteractionId where+ pretty (InteractionId i) = text $ "?" ++ show i++instance KillRange InteractionId where killRange = id++---------------------------------------------------------------------------+-- * Fixity+---------------------------------------------------------------------------++-- | Precedence levels for operators.++type PrecedenceLevel = Double++data FixityLevel+ = Unrelated+ -- ^ No fixity declared.+ | Related !PrecedenceLevel+ -- ^ Fixity level declared as the number.+ deriving (Eq, Ord, Show)++instance Null FixityLevel where+ null Unrelated = True+ null Related{} = False+ empty = Unrelated++instance NFData FixityLevel where+ rnf Unrelated = ()+ rnf (Related _) = ()++instance Pretty FixityLevel where+ pretty = \case+ Unrelated -> empty+ Related d -> text $ toStringWithoutDotZero d++-- | Associativity.++data Associativity = NonAssoc | LeftAssoc | RightAssoc+ deriving (Eq, Ord, Show)++instance Pretty Associativity where+ pretty = \case+ LeftAssoc -> "infixl"+ RightAssoc -> "infixr"+ NonAssoc -> "infix"++-- | Fixity of operators.++data Fixity = Fixity+ { fixityRange :: Range+ -- ^ Range of the whole fixity declaration.+ , fixityLevel :: !FixityLevel+ , fixityAssoc :: !Associativity+ }+ deriving Show++noFixity :: Fixity+noFixity = Fixity noRange Unrelated NonAssoc++defaultFixity :: Fixity+defaultFixity = Fixity noRange (Related 20) NonAssoc++-- For @instance Pretty Fixity@, see Agda.Syntax.Concrete.Pretty++instance Eq Fixity where+ f1 == f2 = compare f1 f2 == EQ++instance Ord Fixity where+ compare = compare `on` (fixityLevel &&& fixityAssoc)++instance Null Fixity where+ null = null . fixityLevel+ empty = noFixity++instance HasRange Fixity where+ getRange = fixityRange++instance KillRange Fixity where+ killRange f = f { fixityRange = noRange }++instance NFData Fixity where+ rnf (Fixity _ _ _) = () -- Ranges are not forced, the other fields are strict.++instance Pretty Fixity where+ pretty (Fixity _ level ass) = case level of+ Unrelated -> empty+ Related{} -> pretty ass <+> pretty level++-- ** Notation coupled with 'Fixity'++-- | The notation is handled as the fixity in the renamer.+-- Hence, they are grouped together in this type.+data Fixity' = Fixity'+ { theFixity :: !Fixity+ , theNotation :: Notation+ , theNameRange :: Range+ -- ^ Range of the name in the fixity declaration+ -- (used for correct highlighting, see issue #2140).+ }+ deriving Show++noFixity' :: Fixity'+noFixity' = Fixity' noFixity noNotation noRange++instance Eq Fixity' where+ Fixity' f n _ == Fixity' f' n' _ = f == f' && n == n'++instance Null Fixity' where+ null (Fixity' f n _) = null f && null n+ empty = noFixity'++instance NFData Fixity' where+ rnf (Fixity' _ a _) = rnf a++-- Note that there are ranges also in 'Fixity' and 'Notation',+-- but we are biased here on the range for the error reporting.+instance HasRange Fixity' where+ getRange = theNameRange++-- Kills all ranges, not just 'theNameRange'.+instance KillRange Fixity' where+ killRange (Fixity' f n r) = killRangeN Fixity' f n r++instance Pretty Fixity' where+ pretty (Fixity' fix nota _range)+ | null nota = pretty fix+ | otherwise = hlKeyword "syntax" <+> pretty nota++-- lenses++_fixityAssoc :: Lens' Fixity Associativity+_fixityAssoc f r = f (fixityAssoc r) <&> \x -> r { fixityAssoc = x }++_fixityLevel :: Lens' Fixity FixityLevel+_fixityLevel f r = f (fixityLevel r) <&> \x -> r { fixityLevel = x }++-- Lens focusing on Fixity++class LensFixity a where+ lensFixity :: Lens' a Fixity++instance LensFixity Fixity where+ lensFixity = id++instance LensFixity Fixity' where+ lensFixity f fix' = f (theFixity fix') <&> \ fx -> fix' { theFixity = fx }++-- Lens focusing on Fixity'++class LensFixity' a where+ lensFixity' :: Lens' a Fixity'++instance LensFixity' Fixity' where+ lensFixity' = id++---------------------------------------------------------------------------+-- * Import directive+---------------------------------------------------------------------------++-- | The things you are allowed to say when you shuffle names between name+-- spaces (i.e. in @import@, @namespace@, or @open@ declarations).+data ImportDirective' n m = ImportDirective+ { importDirRange :: Range+ , using :: Using' n m+ , hiding :: HidingDirective' n m+ , impRenaming :: RenamingDirective' n m+ , publicOpen :: Maybe KwRange+ -- ^ Only for @open@. Exports the opened names from the current module.+ -- Range of the @public@ keyword.+ }+ deriving (Eq, Show)++type HidingDirective' n m = [ImportedName' n m]+type RenamingDirective' n m = [Renaming' n m]++-- | @null@ for import directives holds when everything is imported unchanged+-- (no names are hidden or renamed).+instance Null (ImportDirective' n m) where+ null = \case+ ImportDirective _ UseEverything [] [] _ -> True+ _ -> False+ empty = defaultImportDir++instance Semigroup (ImportDirective' n m) where+ i1 <> i2 = ImportDirective+ { importDirRange = fuseRange i1 i2+ , using = using i1 <> using i2+ , hiding = hiding i1 ++ hiding i2+ , impRenaming = impRenaming i1 ++ impRenaming i2+ , publicOpen = publicOpen i1 <|> publicOpen i2+ }++instance Monoid (ImportDirective' n m) where+ mempty = empty+ mappend = (<>)++-- | Default is directive is @private@ (use everything, but do not export).+defaultImportDir :: ImportDirective' n m+defaultImportDir = ImportDirective noRange UseEverything [] [] Nothing++-- | @isDefaultImportDir@ implies @null@, but not the other way round.+isDefaultImportDir :: ImportDirective' n m -> Bool+isDefaultImportDir dir = null dir && null (publicOpen dir)++-- | The @using@ clause of import directive.+data Using' n m+ = UseEverything -- ^ No @using@ clause given.+ | Using [ImportedName' n m] -- ^ @using@ the specified names.+ deriving (Eq, Show)++instance Semigroup (Using' n m) where+ UseEverything <> u = u+ u <> UseEverything = u+ Using xs <> Using ys = Using (xs ++ ys)++instance Monoid (Using' n m) where+ mempty = UseEverything+ mappend = (<>)++instance Null (Using' n m) where+ null UseEverything = True+ null Using{} = False+ empty = mempty++mapUsing :: ([ImportedName' n1 m1] -> [ImportedName' n2 m2]) -> Using' n1 m1 -> Using' n2 m2+mapUsing f = \case+ UseEverything -> UseEverything+ Using xs -> Using $ f xs++-- | An imported name can be a module or a defined name.+data ImportedName' n m+ = ImportedModule m -- ^ Imported module name of type @m@.+ | ImportedName n -- ^ Imported name of type @n@.+ deriving (Eq, Ord, Show)++fromImportedName :: ImportedName' a a -> a+fromImportedName = \case+ ImportedModule x -> x+ ImportedName x -> x++setImportedName :: ImportedName' a a -> a -> ImportedName' a a+setImportedName (ImportedName _) y = ImportedName y+setImportedName (ImportedModule _) y = ImportedModule y++-- | Like 'partitionEithers'.+partitionImportedNames :: [ImportedName' n m] -> ([n], [m])+partitionImportedNames = flip foldr ([], []) $ \case+ ImportedName n -> first (n:)+ ImportedModule m -> second (m:)++-- -- Defined in Concrete.Pretty+-- instance (Pretty n, Pretty m) => Pretty (ImportedName' n m) where+-- pretty (ImportedModule x) = "module" <+> pretty x+-- pretty (ImportedName x) = pretty x++-- instance (Show n, Show m) => Show (ImportedName' n m) where+-- show (ImportedModule x) = "module " ++ show x+-- show (ImportedName x) = show x++data Renaming' n m = Renaming+ { renFrom :: ImportedName' n m+ -- ^ Rename from this name.+ , renTo :: ImportedName' n m+ -- ^ To this one. Must be same kind as 'renFrom'.+ , renFixity :: Maybe Fixity+ -- ^ New fixity of 'renTo' (optional).+ , renToRange :: Range+ -- ^ The range of the \"to\" keyword. Retained for highlighting purposes.+ }+ deriving (Eq, Show)++-- ** HasRange instances++instance HasRange (ImportDirective' a b) where+ getRange = importDirRange++instance (HasRange a, HasRange b) => HasRange (Using' a b) where+ getRange (Using xs) = getRange xs+ getRange UseEverything = noRange++instance (HasRange a, HasRange b) => HasRange (Renaming' a b) where+ getRange r = getRange (renFrom r, renTo r)++instance (HasRange a, HasRange b) => HasRange (ImportedName' a b) where+ getRange (ImportedName x) = getRange x+ getRange (ImportedModule x) = getRange x++-- ** KillRange instances++instance (KillRange a, KillRange b) => KillRange (ImportDirective' a b) where+ killRange (ImportDirective _ u h r p) =+ killRangeN (\u h r -> ImportDirective noRange u h r (p $> empty)) u h r++instance (KillRange a, KillRange b) => KillRange (Using' a b) where+ killRange (Using i) = killRangeN Using i+ killRange UseEverything = UseEverything++instance (KillRange a, KillRange b) => KillRange (Renaming' a b) where+ killRange (Renaming i n mf _to) = killRangeN (\ i n mf -> Renaming i n mf noRange) i n mf++instance (KillRange a, KillRange b) => KillRange (ImportedName' a b) where+ killRange (ImportedModule n) = killRangeN ImportedModule n+ killRange (ImportedName n) = killRangeN ImportedName n++-- ** Pretty instances++instance (Pretty a, Pretty b) => Pretty (ImportDirective' a b) where+ pretty i =+ sep [ public (publicOpen i)+ , pretty $ using i+ , prettyHiding $ hiding i+ , rename $ impRenaming i+ ]+ where+ public Just{} = "public"+ public Nothing = empty++ prettyHiding [] = empty+ prettyHiding xs = "hiding" <+> parens (fsep $ punctuate ";" $ map pretty xs)++ rename [] = empty+ rename xs = hsep [ "renaming"+ , parens $ fsep $ punctuate ";" $ map pretty xs+ ]++instance (Pretty a, Pretty b) => Pretty (Using' a b) where+ pretty UseEverything = empty+ pretty (Using xs) =+ "using" <+> parens (fsep $ punctuate ";" $ map pretty xs)++instance (Pretty a, Pretty b) => Pretty (ImportedName' a b) where+ pretty (ImportedName a) = pretty a+ pretty (ImportedModule b) = "module" <+> pretty b++instance (Pretty a, Pretty b) => Pretty (Renaming' a b) where+ pretty (Renaming from to mfx _r) = hsep+ [ pretty from+ , "to"+ , maybe empty pretty mfx+ , case to of+ ImportedName a -> pretty a+ ImportedModule b -> pretty b -- don't print "module" here+ ]++-- ** NFData instances++-- | Ranges are not forced.++instance (NFData a, NFData b) => NFData (ImportDirective' a b) where+ rnf (ImportDirective _ a b c _) = rnf a `seq` rnf b `seq` rnf c++instance (NFData a, NFData b) => NFData (Using' a b) where+ rnf UseEverything = ()+ rnf (Using a) = rnf a++-- | Ranges are not forced.++instance (NFData a, NFData b) => NFData (Renaming' a b) where+ rnf (Renaming a b c _) = rnf a `seq` rnf b `seq` rnf c++instance (NFData a, NFData b) => NFData (ImportedName' a b) where+ rnf (ImportedModule a) = rnf a+ rnf (ImportedName a) = rnf a++-----------------------------------------------------------------------------+-- * Termination+-----------------------------------------------------------------------------++-- | Termination check? (Default = TerminationCheck).+data TerminationCheck m+ = TerminationCheck+ -- ^ Run the termination checker.+ | NoTerminationCheck+ -- ^ Skip termination checking (unsafe).+ | NonTerminating+ -- ^ Treat as non-terminating.+ | Terminating+ -- ^ Treat as terminating (unsafe). Same effect as 'NoTerminationCheck'.+ | TerminationMeasure Range m+ -- ^ Skip termination checking but use measure instead.+ deriving (Show, Eq, Functor)++instance KillRange m => KillRange (TerminationCheck m) where+ killRange (TerminationMeasure _ m) = TerminationMeasure noRange (killRange m)+ killRange t = t++instance NFData a => NFData (TerminationCheck a) where+ rnf TerminationCheck = ()+ rnf NoTerminationCheck = ()+ rnf NonTerminating = ()+ rnf Terminating = ()+ rnf (TerminationMeasure _ a) = rnf a++-----------------------------------------------------------------------------+-- * Positivity+-----------------------------------------------------------------------------++-- | Positivity check? (Default = True).+data PositivityCheck = YesPositivityCheck | NoPositivityCheck+ deriving (Eq, Ord, Show, Bounded, Enum, Generic)++instance KillRange PositivityCheck where+ killRange = id++-- Semigroup and Monoid via conjunction+instance Semigroup PositivityCheck where+ NoPositivityCheck <> _ = NoPositivityCheck+ _ <> NoPositivityCheck = NoPositivityCheck+ _ <> _ = YesPositivityCheck++instance Null PositivityCheck where+ empty = YesPositivityCheck++instance Monoid PositivityCheck where+ mempty = empty++instance NFData PositivityCheck++-----------------------------------------------------------------------------+-- * Universe checking+-----------------------------------------------------------------------------++-- | Universe check? (Default is yes).+data UniverseCheck = YesUniverseCheck | NoUniverseCheck+ deriving (Eq, Ord, Show, Bounded, Enum, Generic)++instance KillRange UniverseCheck where+ killRange = id++instance NFData UniverseCheck++instance Null UniverseCheck where+ empty = YesUniverseCheck++instance Semigroup UniverseCheck where+ NoUniverseCheck <> _ = NoUniverseCheck+ YesUniverseCheck <> uc = uc++instance Monoid UniverseCheck where+ mempty = empty++-----------------------------------------------------------------------------+-- * Force record to have eta equality+-----------------------------------------------------------------------------++-- | Force record type to have eta equality? (Default is no).+data ForceRecordEta = YesForceRecordEta | NoForceRecordEta+ deriving (Eq, Ord, Show, Bounded, Enum, Generic)++instance KillRange ForceRecordEta where+ killRange = id++instance NFData ForceRecordEta++instance Null ForceRecordEta where+ empty = NoForceRecordEta++instance Semigroup ForceRecordEta where+ YesForceRecordEta <> _ = YesForceRecordEta+ NoForceRecordEta <> eta = eta++instance Monoid ForceRecordEta where+ mempty = empty++-----------------------------------------------------------------------------+-- * Coverage+-----------------------------------------------------------------------------++-- | 'Range' of the CATCHALL pragma for a clause, if any.+-- 'Nothing' means no such pragma.+data Catchall = YesCatchall Range | NoCatchall+ deriving (Eq, Show, Generic)++-- | Composition is left-biased, taking the left 'Range' if both have one.+instance Semigroup Catchall where+ NoCatchall <> c = c+ c <> NoCatchall = c+ c1@(YesCatchall r) <> c2@(YesCatchall _r) = if null r then c2 else c1++instance Monoid Catchall where+ mempty = empty++instance Null Catchall where+ empty = NoCatchall++instance KillRange Catchall where+ killRange = \case+ YesCatchall _ -> YesCatchall noRange+ NoCatchall -> NoCatchall++instance NFData Catchall where+ rnf = \case+ YesCatchall _ -> ()+ NoCatchall -> ()++-- | Coverage check? (Default is yes).+data CoverageCheck = YesCoverageCheck | NoCoverageCheck+ deriving (Eq, Ord, Show, Bounded, Enum, Generic)++instance KillRange CoverageCheck where+ killRange = id++-- Semigroup and Monoid via conjunction+instance Semigroup CoverageCheck where+ NoCoverageCheck <> _ = NoCoverageCheck+ _ <> NoCoverageCheck = NoCoverageCheck+ _ <> _ = YesCoverageCheck++instance Monoid CoverageCheck where+ mempty = YesCoverageCheck+ mappend = (<>)++instance NFData CoverageCheck++-----------------------------------------------------------------------------+-- * Rewrite Directives on the LHS+-----------------------------------------------------------------------------++-- | @RewriteEqn' qn p e@ represents the @rewrite@ and irrefutable @with@+-- clauses of the LHS.+-- @qn@ stands for the QName of the auxiliary function generated to implement the feature+-- @nm@ is the type of names for pattern variables+-- @p@ is the type of patterns+-- @e@ is the type of expressions++data RewriteEqn' qn nm p e+ = Rewrite (List1 (qn, e)) -- ^ @rewrite e@+ | Invert qn (List1 (Named nm (p, e))) -- ^ @with p <- e in eq@+ | LeftLet (List1 (p, e)) -- ^ @using p <- e@+ deriving (Eq, Show, Functor, Foldable, Traversable)++instance (NFData qn, NFData nm, NFData p, NFData e) => NFData (RewriteEqn' qn nm p e) where+ rnf = \case+ Rewrite es -> rnf es+ Invert qn pes -> rnf (qn, pes)+ LeftLet pes -> rnf pes++instance (Pretty nm, Pretty p, Pretty e) => Pretty (RewriteEqn' qn nm p e) where+ pretty = \case+ Rewrite es -> prefixedThings (text "rewrite") $ List1.toList (pretty . snd <$> es)+ LeftLet pes -> prefixedThings (text "using") [pretty p <+> "<-" <+> pretty e | (p, e) <- List1.toList pes]+ Invert _ pes -> prefixedThings (text "with") $ List1.toList (namedWith <$> pes) where++ namedWith (Named nm (p, e)) =+ let patexp = pretty p <+> "<-" <+> pretty e in+ case nm of+ Nothing -> patexp+ Just nm -> pretty nm <+> ":" <+> patexp++instance (HasRange qn, HasRange p, HasRange e) => HasRange (RewriteEqn' qn nm p e) where+ getRange = \case+ Rewrite es -> getRange es+ Invert qn pes -> getRange (qn, pes)+ LeftLet pes -> getRange pes++instance (KillRange qn, KillRange nm, KillRange e, KillRange p) => KillRange (RewriteEqn' qn nm p e) where+ killRange = \case+ Rewrite es -> killRangeN Rewrite es+ Invert qn pes -> killRangeN Invert qn pes+ LeftLet pes -> killRangeN LeftLet pes++-----------------------------------------------------------------------------+-- * Information on expanded ellipsis (@...@)+-----------------------------------------------------------------------------++-- ^ When the ellipsis in a clause is expanded, we remember that we+-- did so. We also store the number of with-arguments that are+-- included in the expanded ellipsis.+data ExpandedEllipsis+ = ExpandedEllipsis+ { ellipsisRange :: Range+ , ellipsisWithArgs :: Int+ }+ | NoEllipsis+ deriving (Show, Eq)++instance Null ExpandedEllipsis where+ empty = NoEllipsis++instance Semigroup ExpandedEllipsis where+ NoEllipsis <> e = e+ e <> NoEllipsis = e+ (ExpandedEllipsis r1 k1) <> (ExpandedEllipsis r2 k2) = ExpandedEllipsis (r1 <> r2) (k1 + k2)++instance Monoid ExpandedEllipsis where+ mempty = NoEllipsis+ mappend = (<>)++instance KillRange ExpandedEllipsis where+ killRange (ExpandedEllipsis _ k) = ExpandedEllipsis noRange k+ killRange NoEllipsis = NoEllipsis++instance NFData ExpandedEllipsis where+ rnf (ExpandedEllipsis _ a) = rnf a+ rnf NoEllipsis = ()++-- | Notation as provided by the @syntax@ declaration.+type Notation = [NotationPart]++noNotation :: Notation+noNotation = []++-- | Positions of variables in syntax declarations.++data BoundVariablePosition = BoundVariablePosition+ { holeNumber :: !Int+ -- ^ The position (in the left-hand side of the syntax+ -- declaration) of the hole in which the variable is bound,+ -- counting from zero (and excluding parts that are not holes).+ -- For instance, for @syntax Σ A (λ x → B) = B , A , x@ the number+ -- for @x@ is @1@, corresponding to @B@ (@0@ would correspond to+ -- @A@).+ , varNumber :: !Int+ -- ^ The position in the list of variables for this particular+ -- variable, counting from zero, and including wildcards. For+ -- instance, for @syntax F (λ x _ y → A) = y ! A ! x@ the number+ -- for @x@ is @0@, the number for @_@ is @1@, and the number for+ -- @y@ is @2@.+ }+ deriving (Eq, Ord, Show)++-- | Notation parts.++data NotationPart+ = IdPart RString+ -- ^ An identifier part. For instance, for @_+_@ the only+ -- identifier part is @+@.+ | HolePart Range (NamedArg (Ranged Int))+ -- ^ A hole: a place where argument expressions can be written.+ -- For instance, for @_+_@ the two underscores are holes, and for+ -- @syntax Σ A (λ x → B) = B , A , x@ the variables @A@ and @B@+ -- are holes. The number is the position of the hole, counting+ -- from zero. For instance, the number for @A@ is @0@, and the+ -- number for @B@ is @1@.+ | VarPart Range (Ranged BoundVariablePosition)+ -- ^ A bound variable.+ --+ -- The first range is the range of the variable in the right-hand+ -- side of the syntax declaration, and the second range is the+ -- range of the variable in the left-hand side.+ | WildPart (Ranged BoundVariablePosition)+ -- ^ A wildcard (an underscore in binding position).+ deriving Show++instance Eq NotationPart where+ VarPart _ i == VarPart _ j = i == j+ HolePart _ x == HolePart _ y = x == y+ WildPart i == WildPart j = i == j+ IdPart x == IdPart y = x == y+ _ == _ = False++instance Ord NotationPart where+ VarPart _ i `compare` VarPart _ j = i `compare` j+ HolePart _ x `compare` HolePart _ y = x `compare` y+ WildPart i `compare` WildPart j = i `compare` j+ IdPart x `compare` IdPart y = x `compare` y+ VarPart{} `compare` _ = LT+ _ `compare` VarPart{} = GT+ HolePart{} `compare` _ = LT+ _ `compare` HolePart{} = GT+ WildPart{} `compare` _ = LT+ _ `compare` WildPart{} = GT++instance HasRange NotationPart where+ getRange = \case+ IdPart x -> getRange x+ VarPart r _ -> r+ WildPart i -> getRange i+ HolePart r _ -> r++instance SetRange NotationPart where+ setRange r = \case+ IdPart x -> IdPart x+ VarPart _ i -> VarPart r i+ WildPart i -> WildPart i+ HolePart _ i -> HolePart r i++instance KillRange NotationPart where+ killRange = \case+ IdPart x -> IdPart $ killRange x+ VarPart _ i -> VarPart noRange $ killRange i+ WildPart i -> WildPart $ killRange i+ HolePart _ x -> HolePart noRange $ killRange x++instance NFData BoundVariablePosition where+ rnf = (`seq` ())++instance NFData NotationPart where+ rnf (VarPart _ a) = rnf a+ rnf (HolePart _ a) = rnf a+ rnf (WildPart a) = rnf a+ rnf (IdPart a) = rnf a++instance Pretty NotationPart where+ pretty (IdPart x) = text $ rangedThing x+ pretty HolePart{} = underscore+ pretty VarPart{} = underscore+ pretty WildPart{} = underscore++ prettyList = hcat . map pretty
@@ -0,0 +1,205 @@+module Agda.Syntax.Common.Aspect where++import Prelude hiding (null)++import GHC.Generics ( Generic )+import Control.DeepSeq ( NFData(..) )+import Data.Set (Set)+import Data.Text (Text)++import Agda.Syntax.TopLevelModuleName.Boot (TopLevelModuleName')+import Agda.Syntax.Position (Range, rangeModule, rStart, Position'(posPos), HasRange(..))+import Agda.Utils.Maybe ( unionMaybeWith )+import Agda.Utils.Null ( Null(..) )++data Induction = Inductive | CoInductive -- Keep in this order!+ deriving (Eq, Ord, Generic, Show)++data Aspect+ = Comment+ | Keyword+ | String+ | Number+ | Hole+ | Symbol+ -- ^ Symbols like @forall@, @=@, @->@, etc.+ | PrimitiveType+ -- ^ Things like @Set@ and @Prop@.+ | Name (Maybe NameKind) Bool+ -- ^ 'Bool': Is the name an operator part?+ | Pragma+ -- ^ Text occurring in pragmas+ -- that does not have a more specific aspect.+ | Background+ -- ^ Non-code contents in literate Agda.+ | Markup+ -- ^ Delimiters used to separate the Agda code blocks+ -- from the other contents in literate Agda.+ | URL Text+ -- ^ Uniform Resource Locator aka clickable link.+ deriving (Eq, Show, Generic)++-- | @NameKind@s are figured out during scope checking.++data NameKind+ = Bound -- ^ Bound variable.+ | Generalizable -- ^ Generalizable variable.+ -- (This includes generalizable+ -- variables that have been+ -- generalized).+ | Constructor Induction -- ^ Inductive or coinductive constructor.+ | Datatype+ | Field -- ^ Record field.+ | Function+ | Module -- ^ Module name.+ | Postulate+ | Primitive -- ^ Primitive.+ | Record -- ^ Record type.+ | Argument -- ^ Named argument, like x in {x = v}+ | Macro -- ^ Macro.+ deriving (Eq, Show, Generic)++-- | Other aspects, generated by type checking.+-- (These can overlap with each other and with 'Aspect's.)++data OtherAspect+ = Error+ | ErrorWarning+ -- ^ A warning that is considered fatal in the end.+ | DottedPattern+ | UnsolvedMeta+ | UnsolvedConstraint+ -- ^ Unsolved constraint not connected to meta-variable. This+ -- could for instance be an emptyness constraint.+ | TerminationProblem+ | PositivityProblem+ | Deadcode+ -- ^ Used for highlighting unreachable clauses, unreachable RHS+ -- (because of an absurd pattern), etc.+ | ShadowingInTelescope+ -- ^ Used for shadowed repeated variable names in telescopes.+ | CoverageProblem+ | TypeChecks+ -- ^ Code which is being type-checked.+ | MissingDefinition+ -- ^ Function declaration without matching definition.+ | InstanceProblem+ -- ^ Unusable instance etc.++ -- NB: We put CatchallClause and CosmeticProblem last+ -- so that they are overwritten by other,+ -- more important, aspects in the emacs mode.+ | CosmeticProblem+ -- ^ Nothing serious, just a beauty flaw.+ | CatchallClause+ | ConfluenceProblem+ deriving (Eq, Ord, Show, Enum, Bounded, Generic)++-- | Some 'NameKind's are more informative than others.+instance Semigroup NameKind where+ -- During scope-checking of record, we build a constructor+ -- whose arguments (@Bound@ variables) are the fields.+ -- Later, we process them as @Field@s proper.+ Field <> Bound = Field+ Bound <> Field = Field+ -- -- Projections are special functions.+ -- -- TODO necessary?+ -- Field <> Function = Field+ -- Function <> Field = Field+ -- TODO: more overwrites?+ k1 <> k2 | k1 == k2 = k1+ | otherwise = k1 -- TODO: __IMPOSSIBLE__++-- | @NameKind@ in @Name@ can get more precise.+instance Semigroup Aspect where+ Name mk1 op1 <> Name mk2 op2 = Name (unionMaybeWith (<>) mk1 mk2) op1+ -- (op1 || op2) breaks associativity+ a1 <> a2 | a1 == a2 = a1+ | otherwise = a1 -- TODO: __IMPOSSIBLE__++------------------------------------------------------------------------+-- Highlighting information++-- | Syntactic aspects of the code. (These cannot overlap.)++-- | Meta information which can be associated with a+-- character\/character range.++data Aspects = Aspects+ { aspect :: Maybe Aspect+ , otherAspects :: Set OtherAspect+ , note :: String+ -- ^ This note, if not null, can be displayed as a tool-tip or+ -- something like that. It should contain useful information about+ -- the range (like the module containing a certain identifier, or+ -- the fixity of an operator).+ , definitionSite :: Maybe DefinitionSite+ -- ^ The definition site of the annotated thing, if applicable and+ -- known.+ , tokenBased :: !TokenBased+ -- ^ Is this entry token-based?+ }+ deriving (Show, Generic)++data DefinitionSite = DefinitionSite+ { defSiteModule :: (TopLevelModuleName' Range)+ -- ^ The defining module.+ , defSitePos :: Int+ -- ^ The file position in that module. File positions are+ -- counted from 1.+ , defSiteHere :: Bool+ -- ^ Has this @DefinitionSite@ been created at the defining site of the name?+ , defSiteAnchor :: Maybe String+ -- ^ A pretty name for the HTML linking.+ }+ deriving (Show, Generic)++instance Eq DefinitionSite where+ DefinitionSite m p _ _ == DefinitionSite m' p' _ _ = m == m' && p == p'++-- | Is the highlighting \"token-based\", i.e. based only on+-- information from the lexer?++data TokenBased = TokenBased | NotOnlyTokenBased+ deriving (Eq, Generic, Show)++instance Null TokenBased where+ empty = TokenBased++instance Null Aspects where+ empty = Aspects Nothing mempty "" Nothing TokenBased+ null (Aspects a o s d t) = null a && null o && null s && null d && null t++instance Eq Aspects where+ Aspects a o _ d t == Aspects a' o' _ d' t' =+ (a, o, d, t) == (a', o', d', t')++-- | Compute the 'Aspects' which (possibly) contain a 'DefinitionSite'+-- for the given thing-with-range.+rangeDefinitionSite :: HasRange a => a -> Aspects+rangeDefinitionSite thing = do+ let+ r = getRange thing++ defs :: Maybe DefinitionSite+ defs = do+ mod <- rangeModule r+ pos <- posPos <$> rStart r+ pure DefinitionSite+ { defSiteModule = mod+ , defSitePos = fromIntegral pos+ , defSiteHere = False+ , defSiteAnchor = Nothing+ }+ empty{ definitionSite = defs }++------------------------------------------------------------------------+-- NFData instances++instance NFData DefinitionSite+instance NFData OtherAspect+instance NFData TokenBased+instance NFData Induction+instance NFData NameKind+instance NFData Aspects+instance NFData Aspect
@@ -0,0 +1,41 @@+-- | A abstract 'Range' type dedicated to keyword occurrences in the source.++module Agda.Syntax.Common.KeywordRange+ ( KwRange -- Do not export the constructor.+ , kwRange+ ) where++import Control.DeepSeq ( NFData(rnf) )++import Agda.Syntax.Common.Pretty+import Agda.Syntax.Position++import Agda.Utils.Null++-- | Range dedicated to a keyword or fixed token sequence.+--+-- Motivation: by lacking a 'SetRange' instance we indicate that it cannot be updated.++newtype KwRange = KwRange { theKwRange :: Range }+ deriving (Eq, Ord, Show, Null)++-- | Create a keyword range.++kwRange :: HasRange a => a -> KwRange+kwRange = KwRange . getRange++-- Instances++instance HasRange KwRange where+ getRange = theKwRange++instance KillRange KwRange where+ killRange _ = empty++-- no SetRange instance!!++instance NFData KwRange where+ rnf _ = ()++instance Pretty KwRange where+ prettyPrec i = prettyPrec i . theKwRange
@@ -0,0 +1,438 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-| Pretty printing functions.+-}+module Agda.Syntax.Common.Pretty+ ( module Agda.Syntax.Common.Pretty+ , module Text.PrettyPrint.Annotated+ ) where++import Prelude hiding (null)++import Control.DeepSeq++import qualified Data.List as List+import qualified Data.Foldable as Fold+import qualified Data.IntSet as IntSet+import qualified Data.IntMap as IntMap+import qualified Data.Text as T+import qualified Data.Map as Map+import qualified Data.Set as Set+import Data.IntSet (IntSet)+import Data.IntMap (IntMap)+import Data.Word (Word64, Word32)+import Data.Text (Text)+import Data.Text qualified as Text+import Data.Int (Int32)+import Data.Map (Map)+import Data.Set (Set)+import Data.Tree (Tree(Node))++import qualified Text.PrettyPrint.Annotated as P+import Text.PrettyPrint.Annotated hiding+ ( Doc, TextDetails(Str), empty, (<>), sep, fsep, hsep, hcat, vcat, punctuate++ , parens, brackets, braces, quotes, doubleQuotes++ , semi, comma, colon, space, equals, lparen, rparen, lbrack, rbrack+ , lbrace, rbrace+ , annotate+ )++import Agda.Syntax.Common.Aspect+import Agda.Syntax.Position++import Agda.Utils.DocTree qualified as DocTree+import Agda.Utils.FileName+import Agda.Utils.Float+import Agda.Utils.List1 (List1)+import Agda.Utils.List1 qualified as List1+import Agda.Utils.List2 (List2)+import Agda.Utils.List2 qualified as List2+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Null+import Agda.Utils.Size++type DocTree = DocTree.DocTree Aspects++---------------------------------------------------------------------------+-- * Pretty class++-- | The type of documents. We use documents annotated by 'Aspects' to+-- record syntactic highlighting information that is generated during+-- pretty-printing.+type Doc = P.Doc Aspects++-- | While 'Show' is for rendering data in Haskell syntax,+-- 'Pretty' is for displaying data to the world, i.e., the+-- user and the environment.+--+-- Atomic data has no inner document structure, so just+-- implement 'pretty' as @pretty a = text $ ... a ...@.++class Pretty a where+ pretty :: a -> Doc+ prettyPrec :: Int -> a -> Doc+ prettyList :: [a] -> Doc++ pretty = prettyPrec 0+ prettyPrec = const pretty+ prettyList = brackets . prettyList_++ {-# MINIMAL pretty | prettyPrec #-}++-- | Use instead of 'show' when printing to world.++prettyShow :: Pretty a => a -> String+prettyShow = render . pretty++---------------------------------------------------------------------------+-- * Pretty instances++instance Pretty Bool where pretty = text . show+instance Pretty Int where pretty = text . show+instance Pretty Int32 where pretty = text . show+instance Pretty Integer where pretty = text . show+instance Pretty Word32 where pretty = text . show+instance Pretty Word64 where pretty = text . show+instance Pretty Double where pretty = text . toStringWithoutDotZero+instance Pretty Text where pretty = text . T.unpack++instance Pretty Char where+ pretty c = text [c]+ prettyList = text+++-- The equational constraint forces GHC to pick this instance and unify+-- the type variable, instead of deferring selection to when the type of+-- annotations is solved.+instance a ~ Aspects => Pretty (P.Doc a) where+ pretty = id++instance a ~ Aspects => Pretty (DocTree.DocTree a) where+ pretty = DocTree.prettyDocTree++instance Pretty () where+ pretty _ = P.empty++instance (Pretty a, Pretty b) => Pretty (a, b) where+ pretty (a, b) = parens $ (pretty a <> comma) <+> pretty b++instance Pretty a => Pretty (Maybe a) where+ prettyPrec p Nothing = P.empty+ prettyPrec p (Just x) = prettyPrec p x++instance Pretty a => Pretty (Strict.Maybe a) where+ prettyPrec p Strict.Nothing = P.empty+ prettyPrec p (Strict.Just x) = prettyPrec p x++instance Pretty a => Pretty [a] where+ pretty = prettyList++instance Pretty a => Pretty (List1 a) where+ pretty = prettyList . List1.toList++instance Pretty a => Pretty (List2 a) where+ pretty = prettyList . List2.toList++instance Pretty IntSet where+ pretty = prettySet . IntSet.toList++instance Pretty a => Pretty (Set a) where+ pretty = prettySet . Set.toList++instance Pretty a => Pretty (IntMap a) where+ pretty = prettyMap . IntMap.toList++instance (Pretty k, Pretty v) => Pretty (Map k v) where+ pretty = prettyMap . Map.toList++-- Pretty instances for dependencies of this module (to avoid dependency cycles)++instance Pretty AbsolutePath where+ pretty = text . filePath++instance Pretty RangeFile where+ pretty = pretty . rangeFilePath++prettyLineColumn :: Position' a -> Doc+prettyLineColumn (Pn _ _ l c) = pretty l <> dot <> pretty c++instance Pretty a => Pretty (Position' (Strict.Maybe a)) where+ pretty p = case srcFile p of+ Strict.Nothing -> prettyLineColumn p+ Strict.Just f -> pretty f <> colon <> prettyLineColumn p++instance Pretty PositionWithoutFile where+ pretty = prettyLineColumn++prettyInterval :: Eq a => Position' a -> Position' a -> Doc+prettyInterval s e+ | s == e = start+ | otherwise = start <> "-" <> end+ where+ sl = posLine s+ el = posLine e+ sc = posCol s+ ec = posCol e++ start :: Doc+ start = pretty sl <> dot <> pretty sc++ end :: Doc+ | sl == el = pretty ec+ | otherwise = pretty el <> dot <> pretty ec++instance Pretty a => Pretty (Interval' a) where+ pretty :: Interval' a -> Doc+ pretty i@(Interval f s e) = applyUnlessNull (pretty f) (\ d -> ((d <> colon) <>)) (prettyInterval s e)++instance Pretty a => Pretty (Range' a) where+ pretty r = maybe empty pretty (rangeToIntervalWithFile r)++instance (Pretty a, HasRange a) => Pretty (PrintRange a) where+ pretty (PrintRange a) = pretty a <+> parens ("at" <+> pretty (getRange a))+++---------------------------------------------------------------------------+-- * Generalizing the original type from list to Foldable++sep, fsep, hsep, hcat, vcat :: Foldable t => t Doc -> Doc+sep = P.sep . Fold.toList+fsep = P.fsep . Fold.toList+hsep = P.hsep . Fold.toList+hcat = P.hcat . Fold.toList+vcat = P.vcat . Fold.toList++punctuate :: Foldable t => Doc -> t Doc -> [Doc]+punctuate d = P.punctuate d . Fold.toList++---------------------------------------------------------------------------+-- * 'Doc' utilities++vsep :: [Doc] -> Doc+vsep = vcat . List.intersperse ""++twords :: Text -> [Doc]+twords = map pretty . Text.words++pwords :: String -> [Doc]+pwords = map text . words++fwords :: String -> Doc+fwords = fsep . pwords++-- | Separate, but only if both separees are not null.++hsepWith :: Doc -> Doc -> Doc -> Doc+hsepWith sep d1 d2+ | null d2 = d1+ | null d1 = d2+ | otherwise = d1 <+> sep <+> d2++-- | Comma separated list, without the brackets.+prettyList_ :: Pretty a => [a] -> Doc+prettyList_ = fsep . punctuate comma . map pretty++-- | Pretty print a set.+prettySet :: Pretty a => [a] -> Doc+prettySet = braces . prettyList_++-- | Pretty print an association list.+prettyMap :: (Pretty k, Pretty v) => [(k,v)] -> Doc+prettyMap = braces . fsep . punctuate comma . map prettyAssign++-- | Pretty print a single association.+prettyAssign :: (Pretty k, Pretty v) => (k,v) -> Doc+prettyAssign (k, v) = sep [ prettyPrec 1 k <+> hlSymbol "->", nest 2 $ pretty v ]++-- ASR (2016-12-13): In pretty >= 1.1.2.0 the below function 'mparens'+-- is called 'maybeParens'. I didn't use that name due to the issue+-- https://github.com/haskell/pretty/issues/40.++-- | Apply 'parens' to 'Doc' if boolean is true.+mparens :: Bool -> Doc -> Doc+mparens True = parens+mparens False = id++-- | Only wrap in parens if not 'empty'+parensNonEmpty :: Doc -> Doc+parensNonEmpty d = if null d then empty else parens d++-- | Return 'empty' for empty strings.+textNonEmpty :: String -> Doc+textNonEmpty = \case+ "" -> empty+ s -> text s++-- | @align max rows@ lays out the elements of @rows@ in two columns,+-- with the second components aligned. The alignment column of the+-- second components is at most @max@ characters to the right of the+-- left-most column.+--+-- Precondition: @max > 0@.++align :: Int -> [(String, Doc)] -> Doc+align max rows =+ vcat $ map (\(s, d) -> text s $$ nest (maxLen + 1) d) $ rows+ where maxLen = maximum $ 0 : filter (< max) (map (length . fst) rows)++-- | Glyphs for drawing a tree with 'prettyTree'.+data TreeGlyphs = TreeGlyphs+ { treeBranch :: Doc -- ^ Connector to a child that has siblings below.+ , treeLastBranch :: Doc -- ^ Connector to the last child.+ , treeContinue :: Doc -- ^ Indentation under a child that has siblings below.+ , treeEmpty :: Doc -- ^ Indentation under the last child.+ }++-- | Render a tree, one line per node, e.g.+--+-- @+-- root+-- ├─ child+-- │ └─ grandchild+-- └─ last child+-- @+prettyTree :: Pretty a => TreeGlyphs -> Tree a -> Doc+prettyTree g (Node root ts0) = vcat $ pretty root : children " " ts0+ where+ children :: Pretty a => Doc -> [Tree a] -> [Doc]+ children pre ts = concat $ zipWith (child pre) (map (const False) (drop 1 ts) ++ [True]) ts++ child :: Pretty a => Doc -> Bool -> Tree a -> [Doc]+ child pre lastChild (Node d ts) =+ (pre <> (if lastChild then treeLastBranch g else treeBranch g) <> pretty d) :+ children (pre <> if lastChild then treeEmpty g else treeContinue g) ts++-- | Handles strings with newlines properly (preserving indentation)+multiLineText :: String -> Doc+multiLineText = vcat . map text . lines++infixl 6 <?>+-- | @a <?> b = hang a 2 b@+(<?>) :: Doc -> Doc -> Doc+a <?> b = hang a 2 b++-- | @pshow = text . show@+pshow :: Show a => a -> Doc+pshow = text . show++singPlural :: Sized a => a -> c -> c -> c+singPlural xs singular plural = if natSize xs == 1 then singular else plural++pluralS :: Sized a => a -> Doc -> Doc+pluralS xs d = singPlural xs d (d <> "s")++-- | Used for with-like 'telescopes'++prefixedThings :: Doc -> [Doc] -> Doc+prefixedThings kw = \case+ [] -> P.empty+ (doc : docs) -> fsep $ (kw <+> doc) : map (hlSymbol "|" <+>) docs++---------------------------------------------------------------------------+-- * Annotations++-- | Only adds an annotation node if the 'Aspects' is non-'null'.+annotate :: Aspects -> Doc -> Doc+annotate a x+ | null a = x+ | otherwise = rnf a `seq` P.annotate a x++-- | Attach a simple 'Aspect', rather than a full set of 'Aspects', to a+-- document.+annotateAspect :: Aspect -> Doc -> Doc+annotateAspect a = annotate a' where+ a' = Aspects+ { aspect = Just a+ , otherAspects = mempty+ , note = ""+ , definitionSite = Nothing+ , tokenBased = TokenBased+ }++-- * Hyperlink annotations++-- | Attach a link to a document (cf. LaTeX @\href@).+href :: Text -> Doc -> Doc+href = annotateAspect . URL++-- | A URL formatted as link (cf. LaTeX @\url@).+url :: String -> Doc+url s = href (Text.pack s) (text s)++-- | Link to an issue on the Agda bug tracker.+githubIssue :: Int -> Doc+githubIssue = url . ("https://github.com/agda/agda/issues/" ++) . show++-- | Attach the position of something as the "binding site" of a 'Doc'.+definedAt :: HasRange a => Doc -> a -> Doc+definedAt doc p = annotate (rangeDefinitionSite p) doc++-- ** Basic syntax highlighting helpers++hlComment, hlSymbol, hlKeyword, hlString, hlNumber, hlHole, hlPrimitiveType, hlPragma+ :: Doc -> Doc++hlComment = annotateAspect Comment+hlSymbol = annotateAspect Symbol+hlKeyword = annotateAspect Keyword+hlString = annotateAspect String+hlNumber = annotateAspect Number+hlHole = annotateAspect Hole+hlPrimitiveType = annotateAspect PrimitiveType+hlPragma = annotateAspect Pragma++-- ** Helpers introducing 'NameKind's++hlNameKind :: NameKind -> Doc -> Doc+hlNameKind k = annotateAspect (Name (Just k) False)++hlBound, hlGeneralizable, hlDatatype, hlField,+ hlFunction, hlModule, hlPostulate, hlPrimitive, hlRecord, hlArgument,+ hlMacro :: Doc -> Doc++hlBound = hlNameKind Bound+hlGeneralizable = hlNameKind Generalizable+hlDatatype = hlNameKind Datatype+hlField = hlNameKind Field+hlFunction = hlNameKind Function+hlModule = hlNameKind Module+hlPostulate = hlNameKind Postulate+hlPrimitive = hlNameKind Primitive+hlRecord = hlNameKind Record+hlArgument = hlNameKind Argument+hlMacro = hlNameKind Macro++hlConstructor :: Induction -> Doc -> Doc+hlConstructor = hlNameKind . Constructor++---------------------------------------------------------------------------+-- * Delimiter wrappers+--+-- These use the 'Symbol' highlight for the punctuation characters.++parens :: Doc -> Doc -- ^ Wrap document in @(...)@+brackets :: Doc -> Doc -- ^ Wrap document in @[...]@+braces :: Doc -> Doc -- ^ Wrap document in @{...}@+quotes :: Doc -> Doc -- ^ Wrap document in @\'...\'@+doubleQuotes :: Doc -> Doc -- ^ Wrap document in @\"...\"@+quotes p = hlSymbol (char '\'') <> p <> hlSymbol (char '\'')+doubleQuotes p = hlSymbol (char '"') <> p <> hlSymbol (char '"')+parens p = lparen <> p <> rparen+brackets p = lbrack <> p <> rbrack+braces p = lbrace <> p <> rbrace++semi, comma, colon, dot, pipe, equals, lparen, rparen, lbrack, rbrack, lbrace, rbrace :: Doc+semi = hlSymbol $ char ';'+comma = hlSymbol $ char ','+colon = hlSymbol $ char ':'+dot = hlSymbol $ char '.'+pipe = hlSymbol $ char '|'+equals = hlSymbol $ char '='+lparen = hlSymbol $ char '('+rparen = hlSymbol $ char ')'+lbrack = hlSymbol $ char '['+rbrack = hlSymbol $ char ']'+lbrace = hlSymbol $ char '{'+rbrace = hlSymbol $ char '}'
@@ -0,0 +1,112 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Syntax.Common.Pretty.ANSI ( printTreeAnsi, putDocLn, putDocTree, putDocTreeLn ) where++import Control.Monad.IO.Class ( MonadIO(..) )+import Data.Functor ( (<&>) )+import Data.Text qualified as Text+import Data.Text.IO qualified as Text++import System.Console.ANSI+import System.Console.ANSI.Codes ( osc )++-- UNUSED:+-- import Text.PrettyPrint.Annotated.HughesPJ ( renderDecoratedM )++import Agda.Interaction.Options.HasOptions ( HasOptions(commandLineOptions) )+import Agda.Interaction.Options.Base++import Agda.Syntax.Common.Aspect as Aspect+import Agda.Syntax.Common.Pretty ( Doc, DocTree )++import Agda.Utils.DocTree ( renderTree', renderToTree, treeToTextNoAnn )+import Agda.Utils.IO.Terminal ( stdoutSupportsANSI )++-- | Print an annotated, pretty-printing 'DocTree' onto a VT100-compatible terminal.+printTreeAnsi :: DocTree -> IO ()+printTreeAnsi = renderTree' Text.putStr \ ann t -> startAnn ann <> t <> endAnn ann++startAnn :: Aspects -> IO ()+startAnn ann = maybe mempty (\ a -> setSGR (aspSGR a) <> startIO a) $ aspect ann++endAnn :: Aspects -> IO ()+endAnn ann = maybe mempty endIO (aspect ann) <> setSGR [Reset]++-- Andreas, 2025-07-28+-- ansi-terminal has no good interface for hyperlinks in the start/end style,+-- so we have to implement this manually here, breaking the abstraction.+startIO :: Aspect -> IO ()+startIO = \case+ URL ref -> putStr $ osc "8" (";" ++ Text.unpack ref)+ _ -> return ()++endIO :: Aspect -> IO ()+endIO = \case+ URL _ -> putStr $ osc "8" ";"+ _ -> return ()++aspSGR :: Aspect -> [SGR]+aspSGR = \case+ URL _url -> [SetUnderlining SingleUnderline]+ String -> [SetColor Foreground Dull Red]+ Number -> [SetColor Foreground Dull Magenta]+ PrimitiveType -> [SetColor Foreground Dull Blue]+ Name Nothing _ -> []+ Name (Just nk) _ -> case nk of+ Bound -> []+ Generalizable -> []+ Argument -> []++ Constructor Inductive -> [SetColor Foreground Dull Green]+ Constructor CoInductive -> [SetColor Foreground Dull Green]++ Field -> [SetColor Foreground Vivid Magenta]++ Module -> [SetColor Foreground Vivid Magenta]++ Function -> [SetColor Foreground Dull Blue]+ Postulate -> [SetColor Foreground Dull Blue]+ Datatype -> [SetColor Foreground Dull Blue]+ Record -> [SetColor Foreground Dull Blue]+ Primitive -> [SetColor Foreground Dull Blue]++ Macro -> [SetColor Foreground Dull Cyan]+ Aspect.Background -> []+ Comment -> []+ Hole -> []+ Keyword -> []+ Markup -> []+ Pragma -> []+ Symbol -> []++-- UNUSED:+-- -- | Render an annotated, pretty-printing 'Doc'ument to a VT100-compatible terminal.+-- renderAnsiIO :: Doc -> IO ()+-- renderAnsiIO = renderDecoratedM startAnn endAnn putStr (putStr "\n")++putDocTree :: (MonadIO m, HasOptions m) => DocTree -> m ()+putDocTree doc = do+ col <- commandLineOptions <&> optDiagnosticsColour >>= \case+ AutoColour -> liftIO stdoutSupportsANSI+ AlwaysColour -> pure True+ NeverColour -> pure False++ liftIO do+ if col+ then printTreeAnsi doc+ else Text.putStr (treeToTextNoAnn doc)++putDocTreeLn :: (MonadIO m, HasOptions m) => DocTree -> m ()+putDocTreeLn doc = do+ putDocTree doc+ liftIO $ putStr "\n"++putDoc :: (MonadIO m, HasOptions m) => Doc -> m ()+putDoc = putDocTree . renderToTree++putDocLn :: (MonadIO m, HasOptions m) => Doc -> m ()+putDocLn doc = do+ putDoc doc+ liftIO $ putStr "\n"
@@ -1,502 +1,1573 @@-{-# LANGUAGE CPP, DeriveDataTypeable, DeriveFunctor, DeriveTraversable, DeriveFoldable #-}--{-| The concrete syntax is a raw representation of the program text- without any desugaring at all. This is what the parser produces.- The idea is that if we figure out how to keep the concrete syntax- around, it can be printed exactly as the user wrote it.--}-module Agda.Syntax.Concrete- ( -- * Expressions- Expr(..)- , OpApp(..), fromOrdinary- , module Agda.Syntax.Concrete.Name- , appView, AppView(..)- -- * Bindings- , LamBinding(..)- , TypedBindings(..)- , TypedBinding(..)- , BoundName(..), mkBoundName_- , Telescope -- (..)- -- * Declarations- , Declaration(..)- , ModuleApplication(..)- , TypeSignature- , Constructor- , Field- , ImportDirective(..), UsingOrHiding(..), ImportedName(..)- , Renaming(..), AsName(..)- , defaultImportDir- , OpenShortHand(..)- , LHS(..), Pattern(..)- , RHS(..), WhereClause(..)- , Pragma(..)- , Module- , ThingWithFixity(..)- , topLevelModuleName- -- * Pattern tools- , patternHead, patternNames- )- where--import Data.Generics (Typeable, Data)-import Data.Foldable hiding (concatMap)-import Data.Traversable-import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Literal--import Agda.Syntax.Concrete.Name--import Agda.Utils.Impossible-#include "../undefined.h"--data OpApp e- = SyntaxBindingLambda !Range [LamBinding] e -- ^ an abstraction inside a special syntax declaration (see Issue 358 why we introduce this).- | Ordinary e- deriving (Typeable, Data, Functor)--fromOrdinary :: e -> OpApp e -> e-fromOrdinary d (Ordinary e) = e-fromOrdinary d _ = d---- | Concrete expressions. Should represent exactly what the user wrote.-data Expr- = Ident QName -- ^ ex: @x@- | Lit Literal -- ^ ex: @1@ or @\"foo\"@- | QuestionMark !Range (Maybe Nat) -- ^ ex: @?@ or @{! ... !}@- | Underscore !Range (Maybe Nat) -- ^ ex: @_@- | RawApp !Range [Expr] -- ^ before parsing operators- | App !Range Expr (NamedArg Expr) -- ^ ex: @e e@, @e {e}@, or @e {x = e}@- | OpApp !Range Name [OpApp Expr] -- ^ ex: @e + e@- | WithApp !Range Expr [Expr] -- ^ ex: @e | e1 | .. | en@- | HiddenArg !Range (Named String Expr) -- ^ ex: @{e}@ or @{x=e}@- | InstanceArg !Range (Named String Expr) -- ^ ex: @{{e}}@ or @{{x=e}}@- | Lam !Range [LamBinding] Expr -- ^ ex: @\\x {y} -> e@ or @\\(x:A){y:B} -> e@- | AbsurdLam !Range Hiding -- ^ ex: @\\ ()@- | ExtendedLam !Range [(LHS,RHS,WhereClause)] -- ^ ex: @\\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }@- | Fun !Range Expr Expr -- ^ ex: @e -> e@ or @.e -> e@ (NYI: @{e} -> e@)- | Pi Telescope Expr -- ^ ex: @(xs:e) -> e@ or @{xs:e} -> e@- | Set !Range -- ^ ex: @Set@- | Prop !Range -- ^ ex: @Prop@- | SetN !Range Nat -- ^ ex: @Set0, Set1, ..@- | Rec !Range [(Name, Expr)] -- ^ ex: @record {x = a; y = b}@- | RecUpdate !Range Expr [(Name, Expr)] -- ^ ex: @record e {x = a; y = b}@- | Let !Range [Declaration] Expr -- ^ ex: @let Ds in e@- | Paren !Range Expr -- ^ ex: @(e)@- | Absurd !Range -- ^ ex: @()@ or @{}@, only in patterns- | As !Range Name Expr -- ^ ex: @x\@p@, only in patterns- | Dot !Range Expr -- ^ ex: @.p@, only in patterns- | ETel Telescope -- ^ only used for printing telescopes- | QuoteGoal !Range Name Expr -- ^ ex: @quoteGoal x in e@- | Quote !Range -- ^ ex: @quote@, should be applied to a name- | QuoteTerm !Range -- ^ ex: @quoteTerm@, should be applied to a term- | Unquote !Range -- ^ ex: @unquote@, should be applied to a term of type @Term@- | DontCare Expr -- ^ to print irrelevant things- deriving (Typeable, Data)----- | Concrete patterns. No literals in patterns at the moment.-data Pattern- = IdentP QName- | AppP Pattern (NamedArg Pattern)- | RawAppP !Range [Pattern]- | OpAppP !Range Name [Pattern]- | HiddenP !Range (Named String Pattern)- | InstanceP !Range (Named String Pattern)- | ParenP !Range Pattern- | WildP !Range- | AbsurdP !Range- | AsP !Range Name Pattern- | DotP !Range Expr- | LitP Literal- deriving (Typeable, Data)----- | A lambda binding is either domain free or typed.-data LamBinding- = DomainFree Hiding Relevance BoundName -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@ or @{.x}@- | DomainFull TypedBindings -- ^ . @(xs : e)@ or @{xs : e}@- deriving (Typeable, Data)----- | A sequence of typed bindings with hiding information. Appears in dependent--- function spaces, typed lambdas, and telescopes.-data TypedBindings = TypedBindings !Range (Arg TypedBinding)- -- ^ . @(xs : e)@ or @{xs : e}@- deriving (Typeable, Data)---data BoundName = BName { boundName :: Name- , bnameFixity :: Fixity'- }- deriving (Typeable, Data)--mkBoundName_ :: Name -> BoundName-mkBoundName_ x = BName x defaultFixity'---- | A typed binding.-data TypedBinding- = TBind !Range [BoundName] Expr -- Binding @x1,..,xn:A@- | TNoBind Expr -- No binding @A@, equivalent to @_ : A@.- deriving (Typeable, Data)----- | A telescope is a sequence of typed bindings. Bound variables are in scope--- in later types.-type Telescope = [TypedBindings]--{-| Left hand sides can be written in infix style. For example:-- > n + suc m = suc (n + m)- > (f ∘ g) x = f (g x)-- We use fixity information to see which name is actually defined.--}-data LHS = LHS { lhsOriginalPattern :: Pattern- , lhsWithPattern :: [Pattern]- , lhsRewriteEqn :: [RewriteEqn]- , lhsWithExpr :: [WithExpr]- }- -- ^ original pattern, with-patterns, rewrite equations and with-expressions- | Ellipsis Range [Pattern] [RewriteEqn] [WithExpr]- -- ^ new with-patterns, rewrite equations and with-expressions- deriving (Typeable, Data)--type RewriteEqn = Expr-type WithExpr = Expr--data RHS = AbsurdRHS- | RHS Expr- deriving (Typeable, Data)--data WhereClause = NoWhere | AnyWhere [Declaration] | SomeWhere Name [Declaration]- deriving (Typeable, Data)----- | The things you are allowed to say when you shuffle names between name--- spaces (i.e. in @import@, @namespace@, or @open@ declarations).-data ImportDirective- = ImportDirective- { importDirRange :: !Range- , usingOrHiding :: UsingOrHiding- , renaming :: [Renaming]- , publicOpen :: Bool -- ^ Only for @open@. Exports the opened names from the current module.- }- deriving (Typeable, Data)--defaultImportDir :: ImportDirective-defaultImportDir = ImportDirective noRange (Hiding []) [] False--data UsingOrHiding- = Hiding [ImportedName]- | Using [ImportedName]- deriving (Typeable, Data)---- | An imported name can be a module or a defined name-data ImportedName = ImportedModule { importedName :: Name }- | ImportedName { importedName :: Name }- deriving (Typeable, Data, Eq, Ord)--instance Show ImportedName where- show (ImportedModule x) = "module " ++ show x- show (ImportedName x) = show x--data Renaming = Renaming { renFrom :: ImportedName- -- ^ Rename from this name.- , renTo :: Name- -- ^ To this one.- , renToRange :: Range- -- ^ The range of the \"to\" keyword. Retained- -- for highlighting purposes.- }- deriving (Typeable, Data)--data AsName = AsName { asName :: Name- -- ^ The \"as\" name.- , asRange :: Range- -- ^ The range of the \"as\" keyword. Retained- -- for highlighting purposes.- }- deriving (Typeable, Data, Show)--{--------------------------------------------------------------------------- Declarations- --------------------------------------------------------------------------}---- | Just type signatures.-type TypeSignature = Declaration---- | A constructor or field declaration is just a type signature.-type Constructor = TypeSignature-type Field = TypeSignature--{-| The representation type of a declaration. The comments indicate- which type in the intended family the constructor targets.--}--data Declaration- = TypeSig Relevance Name Expr -- ^ Axioms and functions can be irrelevant.- | Field Name (Arg Expr) -- ^ Record field, can be hidden and/or irrelevant.- | FunClause LHS RHS WhereClause- | DataSig !Range Induction Name [LamBinding] Expr -- ^ lone data signature in mutual block- | Data !Range Induction Name [LamBinding] (Maybe Expr) [Constructor]- | RecordSig !Range Name [LamBinding] Expr -- ^ lone record signature in mutual block- | Record !Range Name (Maybe Name) [LamBinding] (Maybe Expr) [Declaration]- -- ^ The optional name is a name for the record constructor.- | Infix Fixity [Name]- | Syntax Name Notation -- ^ notation declaration for a name- | Mutual !Range [Declaration]- | Abstract !Range [Declaration]- | Private !Range [Declaration]- | Postulate !Range [TypeSignature]- | Primitive !Range [TypeSignature]- | Open !Range QName ImportDirective- | Import !Range QName (Maybe AsName) OpenShortHand ImportDirective- | ModuleMacro !Range Name ModuleApplication OpenShortHand ImportDirective- | Module !Range QName [TypedBindings] [Declaration]- | Pragma Pragma- deriving (Typeable, Data)--data ModuleApplication = SectionApp Range [TypedBindings] Expr- | RecordModuleIFS Range QName- deriving (Typeable, Data)--data OpenShortHand = DoOpen | DontOpen- deriving (Typeable, Data, Show)---- Pragmas ------------------------------------------------------------------data Pragma = OptionsPragma !Range [String]- | BuiltinPragma !Range String Expr- | CompiledDataPragma !Range QName String [String]- | CompiledTypePragma !Range QName String- | CompiledPragma !Range QName String- | CompiledEpicPragma !Range QName String- | CompiledJSPragma !Range QName String- | StaticPragma !Range QName- | ImportPragma !Range String- -- ^ Invariant: The string must be a valid Haskell- -- module name.- | ImpossiblePragma !Range- | EtaPragma !Range QName- deriving (Typeable, Data)--------------------------------------------------------------------------------- | Modules: Top-level pragmas plus other top-level declarations.--type Module = ([Pragma], [Declaration])---- | Computes the top-level module name.------ Precondition: The 'Module' has to be well-formed.--topLevelModuleName :: Module -> TopLevelModuleName-topLevelModuleName (_, []) = __IMPOSSIBLE__-topLevelModuleName (_, ds) = case last ds of- Module _ n _ _ -> toTopLevelModuleName n- _ -> __IMPOSSIBLE__--{--------------------------------------------------------------------------- Views- --------------------------------------------------------------------------}---- | The 'Expr' is not an application.-data AppView = AppView Expr [NamedArg Expr]--appView :: Expr -> AppView-appView (App r e1 e2) = vApp (appView e1) e2- where- vApp (AppView e es) arg = AppView e (es ++ [arg])-appView (RawApp _ (e:es)) = AppView e $ map arg es- where- arg (HiddenArg _ e) = Arg Hidden Relevant e- arg e = Arg NotHidden Relevant (unnamed e)-appView e = AppView e []--{--------------------------------------------------------------------------- Patterns- --------------------------------------------------------------------------}---- | Get the leftmost symbol in a pattern.-patternHead :: Pattern -> Maybe Name-patternHead p =- case p of- IdentP x -> return $ unqualify x- AppP p p' -> patternHead p- RawAppP _ [] -> __IMPOSSIBLE__- RawAppP _ (p:_) -> patternHead p- OpAppP _ name ps -> return $ name- HiddenP _ (namedPat) -> patternHead (namedThing namedPat)- ParenP _ p -> patternHead p- WildP _ -> Nothing- AbsurdP _ -> Nothing- AsP _ x p -> patternHead p- DotP{} -> Nothing- LitP (LitQName _ x) -> Nothing -- return $ unqualify x -- does not compile- LitP _ -> Nothing- InstanceP _ (namedPat) -> patternHead (namedThing namedPat)----- | Get all the identifiers in a pattern in left-to-right order.-patternNames :: Pattern -> [Name]-patternNames p =- case p of- IdentP x -> [unqualify x]- AppP p p' -> concatMap patternNames [p, namedThing $ unArg p']- RawAppP _ ps -> concatMap patternNames ps- OpAppP _ name ps -> name : concatMap patternNames ps- HiddenP _ (namedPat) -> patternNames (namedThing namedPat)- ParenP _ p -> patternNames p- WildP _ -> []- AbsurdP _ -> []- AsP _ x p -> patternNames p- DotP{} -> []- LitP _ -> []- InstanceP _ (namedPat) -> patternNames (namedThing namedPat)--{--------------------------------------------------------------------------- Instances- --------------------------------------------------------------------------}--instance HasRange e => HasRange (OpApp e) where- getRange e = case e of- Ordinary e -> getRange e- SyntaxBindingLambda r _ _ -> r--instance HasRange Expr where- getRange e =- case e of- Ident x -> getRange x- Lit x -> getRange x- QuestionMark r _ -> r- Underscore r _ -> r- App r _ _ -> r- RawApp r _ -> r- OpApp r _ _ -> r- WithApp r _ _ -> r- Lam r _ _ -> r- AbsurdLam r _ -> r- ExtendedLam r _ -> r- Fun r _ _ -> r- Pi b e -> fuseRange b e- Set r -> r- Prop r -> r- SetN r _ -> r- Let r _ _ -> r- Paren r _ -> r- As r _ _ -> r- Dot r _ -> r- Absurd r -> r- HiddenArg r _ -> r- InstanceArg r _ -> r- Rec r _ -> r- RecUpdate r _ _ -> r- ETel tel -> getRange tel- QuoteGoal r _ _ -> r- Quote r -> r- QuoteTerm r -> r- Unquote r -> r- DontCare{} -> noRange---- instance HasRange Telescope where--- getRange (TeleBind bs) = getRange bs--- getRange (TeleFun x y) = fuseRange x y--instance HasRange TypedBindings where- getRange (TypedBindings r _) = r--instance HasRange TypedBinding where- getRange (TBind r _ _) = r- getRange (TNoBind e) = getRange e--instance HasRange LamBinding where- getRange (DomainFree _ _ x) = getRange x- getRange (DomainFull b) = getRange b--instance HasRange BoundName where- getRange = getRange . boundName--instance HasRange WhereClause where- getRange NoWhere = noRange- getRange (AnyWhere ds) = getRange ds- getRange (SomeWhere _ ds) = getRange ds--instance HasRange ModuleApplication where- getRange (SectionApp r _ _) = r- getRange (RecordModuleIFS r _) = r--instance HasRange Declaration where- getRange (TypeSig _ x t) = fuseRange x t- getRange (Field x t) = fuseRange x t- getRange (FunClause lhs rhs wh) = fuseRange lhs rhs `fuseRange` wh- getRange (DataSig r _ _ _ _) = r- getRange (Data r _ _ _ _ _) = r- getRange (RecordSig r _ _ _) = r- getRange (Record r _ _ _ _ _) = r- getRange (Mutual r _) = r- getRange (Abstract r _) = r- getRange (Open r _ _) = r- getRange (ModuleMacro r _ _ _ _) = r- getRange (Import r _ _ _ _) = r- getRange (Private r _) = r- getRange (Postulate r _) = r- getRange (Primitive r _) = r- getRange (Module r _ _ _) = r- getRange (Infix f _) = getRange f- getRange (Syntax n _) = getRange n- getRange (Pragma p) = getRange p--instance HasRange LHS where- getRange (LHS p ps eqns ws) = fuseRange p (fuseRange ps (eqns ++ ws))- getRange (Ellipsis r _ _ _) = r--instance HasRange RHS where- getRange AbsurdRHS = noRange- getRange (RHS e) = getRange e--instance HasRange Pragma where- getRange (OptionsPragma r _) = r- getRange (BuiltinPragma r _ _) = r- getRange (CompiledDataPragma r _ _ _) = r- getRange (CompiledTypePragma r _ _) = r- getRange (CompiledPragma r _ _) = r- getRange (CompiledEpicPragma r _ _) = r- getRange (CompiledJSPragma r _ _) = r- getRange (StaticPragma r _) = r- getRange (ImportPragma r _) = r- getRange (ImpossiblePragma r) = r- getRange (EtaPragma r _) = r--instance HasRange UsingOrHiding where- getRange (Using xs) = getRange xs- getRange (Hiding xs) = getRange xs--instance HasRange ImportDirective where- getRange = importDirRange--instance HasRange ImportedName where- getRange (ImportedName x) = getRange x- getRange (ImportedModule x) = getRange x--instance HasRange Renaming where- getRange r = getRange (renFrom r, renTo r)--instance HasRange AsName where- getRange a = getRange (asRange a, asName a)--instance HasRange Pattern where- getRange (IdentP x) = getRange x- getRange (AppP p q) = fuseRange p q- getRange (OpAppP r _ _) = r- getRange (RawAppP r _) = r- getRange (ParenP r _) = r- getRange (WildP r) = r- getRange (AsP r _ _) = r- getRange (AbsurdP r) = r- getRange (LitP l) = getRange l- getRange (HiddenP r _) = r- getRange (InstanceP r _) = r- getRange (DotP r _) = r+{-# LANGUAGE CPP #-}+{-# LANGUAGE ApplicativeDo #-} -- see exprToPattern++{-| The concrete syntax is a raw representation of the program text+ without any desugaring at all. This is what the parser produces.+ The idea is that if we figure out how to keep the concrete syntax+ around, it can be printed exactly as the user wrote it.+-}+module Agda.Syntax.Concrete+ ( -- * Expressions+ Expr(..)+ , OpApp(..), fromOrdinary+ , OpAppArgs, OpAppArgs', OpAppArgs0+ , module Agda.Syntax.Concrete.Name+ , AppView(..), appView, unAppView+ , toNamedArg, unNamedArg+ , rawApp, rawAppP+ , isSingleIdentifierP, removeParenP+ , isPattern, isAbsurdP, isBinderP+ , PossiblyProjectionPattern(..)+ , observeHiding+ , observeRelevance+ , observeModifiers+ , exprToPatternWithHoles+ , returnExpr+ -- * Bindings+ , Binder'(..)+ , Binder+ , mkBinder_+ , mkBinder+ , LamBinding+ , LamBinding'(..)+ , DefParameters, parametersToDefParameters, defParametersToParameters+ , TypedBinding+ , TypedBinding'(..)+ , RecordAssignment+ , RecordAssignments+ , FieldAssignment, FieldAssignment'(..), nameFieldA, exprFieldA+ , ModuleAssignment(..)+ , BoundName(..), mkBoundName_, mkBoundName+ , TacticAttribute+ , TacticAttribute'(..)+ , Telescope, Telescope1+ , Parameters, parametersToTelescope+ , makePi+ , mkLam, mkLet, mkTLet+ -- * Declarations+ , Declaration(..)+ , isPragma+ , RecordDirective(..)+ , RecordDirectives+ , ModuleApplication(..)+ , TypeSignature+ , TypeSignatureOrInstanceBlock+ , ImportDirective, Using, ImportedName+ , Renaming, RenamingDirective, HidingDirective+ , AsName'(..), AsName, RawOpenArgs+ , OpenShortHand(..)+ , RewriteEqn, WithExpr+ , LHS(..), Pattern(..), LHSCore(..)+ , LamClause(..)+ , RHS, RHS'(..)+ , WhereClause, WhereClause'(..), WhereClause_(..), ExprWhere(..)+ , whereClause_+ , DoStmt(..)+ , Pragma(..)+ , Module(..)+ , ThingWithFixity(..)+ , HoleContent, HoleContent'(..)+ , spanAllowedBeforeModule+ , ungatherRecordDirectives+ )+ where++import Prelude hiding (null)++import Control.DeepSeq++import Data.Bifunctor ( second )+import Data.DList ( DList )+import qualified Data.DList as DL+import Data.Function ( (&) )+import Data.Functor.Identity+import Data.Maybe+import Data.Text ( Text )+-- import Data.Traversable ( forM )++import GHC.Generics ( Generic )++import Agda.Syntax.Position+import Agda.Syntax.Common+import Agda.Syntax.Common.Aspect (Aspects)+import Agda.Syntax.Fixity+import Agda.Syntax.Literal++import Agda.Syntax.Concrete.Name+import qualified Agda.Syntax.Abstract.Name as A++import Agda.TypeChecking.Positivity.Occurrence++import Agda.Utils.Applicative ( forA )+import Agda.Utils.Either ( maybeLeft )+import Agda.Utils.Lens+import Agda.Utils.List1 ( List1, pattern (:|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.List2 ( List2, pattern List2 )+import Agda.Utils.Null+import Agda.Utils.Set1 ( Set1 )+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Singleton++import Agda.Utils.Impossible++data OpApp e+ = SyntaxBindingLambda Range (List1 LamBinding) e+ -- ^ An abstraction inside a special syntax declaration+ -- (see Issue 358 why we introduce this).+ | Ordinary e+ deriving (Functor, Foldable, Traversable, Eq)++fromOrdinary :: e -> OpApp e -> e+fromOrdinary d (Ordinary e) = e+fromOrdinary d _ = d++data FieldAssignment' a = FieldAssignment { _nameFieldA :: Name, _exprFieldA :: a }+ deriving (Functor, Foldable, Traversable, Show, Eq)++type FieldAssignment = FieldAssignment' Expr++data ModuleAssignment = ModuleAssignment+ { _qnameModA :: QName+ , _exprModA :: [Expr]+ , _importDirModA :: ImportDirective+ }+ deriving Eq++type RecordAssignment = Either FieldAssignment ModuleAssignment+type RecordAssignments = [RecordAssignment]++nameFieldA :: Lens' (FieldAssignment' a) Name+nameFieldA f r = f (_nameFieldA r) <&> \x -> r { _nameFieldA = x }++exprFieldA :: Lens' (FieldAssignment' a) a+exprFieldA f r = f (_exprFieldA r) <&> \x -> r { _exprFieldA = x }++-- UNUSED Liang-Ting Chen 2019-07-16+--qnameModA :: Lens' ModuleAssignment QName+--qnameModA f r = f (_qnameModA r) <&> \x -> r { _qnameModA = x }+--+--exprModA :: Lens' [Expr] ModuleAssignment+--exprModA f r = f (_exprModA r) <&> \x -> r { _exprModA = x }+--+--importDirModA :: Lens' ModuleAssignment ImportDirective+--importDirModA f r = f (_importDirModA r) <&> \x -> r { _importDirModA = x }++-- | Concrete expressions. Should represent exactly what the user wrote.+data Expr+ = Ident QName -- ^ ex: @x@+ | Lit Range Literal -- ^ ex: @1@ or @\"foo\"@+ | QuestionMark Range (Maybe Nat) -- ^ ex: @?@ or @{! ... !}@+ | Underscore Range (Maybe String) -- ^ ex: @_@ or @_A_5@+ | RawApp Range (List2 Expr) -- ^ before parsing operators+ | App Range Expr (NamedArg Expr) -- ^ ex: @e e@, @e {e}@, or @e {x = e}@+ | OpApp Range QName (Set1 A.Name) OpAppArgs -- ^ ex: @e + e@+ -- The 'QName' is possibly ambiguous,+ -- but it must correspond to one of the names in the set.+ | WithApp Range Expr (List1 Expr) -- ^ ex: @e | e1 | .. | en@+ | HiddenArg Range (Named_ Expr) -- ^ ex: @{e}@ or @{x=e}@+ | InstanceArg Range (Named_ Expr) -- ^ ex: @{{e}}@ or @{{x=e}}@+ | Lam Range (List1 LamBinding) Expr -- ^ ex: @\\x {y} -> e@ or @\\(x:A){y:B} -> e@+ | AbsurdLam Range Hiding -- ^ ex: @\\ ()@+ | ExtendedLam Range Erased+ (List1 LamClause) -- ^ ex: @\\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }@+ | Fun Range (Arg Expr) Expr -- ^ ex: @e -> e@ or @.e -> e@ (NYI: @{e} -> e@)+ | Pi Telescope1 Expr -- ^ ex: @(xs:e) -> e@ or @{xs:e} -> e@+ | Rec KwRange Range RecordAssignments -- ^ ex: @record {x = a; y = b}@, or @record { x = a; M1; M2 }@+ -- The 'KwRange' is for the @record@ keyword.+ | RecUpdate KwRange Range Expr [FieldAssignment]+ -- ^ ex: @record e {x = a; y = b}@+ -- The 'KwRange' is for the @record@ keyword.+ | Let Range (List1 Declaration) (Maybe Expr) -- ^ ex: @let Ds in e@, missing body when parsing do-notation let+ | Paren Range Expr -- ^ ex: @(e)@+ | IdiomBrackets Range (Maybe QName) [Expr] -- ^ ex: @(| e1 | e2 | .. | en |)@ or @(|)@+ | DoBlock KwRange (Maybe QName) (List1 DoStmt)+ -- ^ ex: @do x <- m1; m2@+ -- The 'KwRange' is for the @do@ keyword.+ | Absurd Range -- ^ ex: @()@ or @{}@, only in patterns+ | As Range Name Expr -- ^ ex: @x\@p@, only in patterns+ | Dot KwRange Expr -- ^ ex: @.p@, only in patterns+ | DoubleDot KwRange Expr -- ^ ex: @..A@, used for parsing @..A -> B@+ | Quote Range -- ^ ex: @quote@, should be applied to a name+ | QuoteTerm Range -- ^ ex: @quoteTerm@, should be applied to a term+ | Tactic Range Expr -- ^ ex: @\@(tactic t)@, used to declare tactic arguments+ | Unquote Range -- ^ ex: @unquote@, should be applied to a term of type @Term@+ | DontCare Expr -- ^ to print irrelevant things+ | Equal Range Expr Expr -- ^ ex: @a = b@, used internally in the parser+ | Ellipsis Range -- ^ @...@, used internally to parse patterns.+ | KnownIdent Aspects QName+ -- ^ An identifier coming from abstract syntax, for which we know a+ -- precise syntactic highlighting class (used in printing).+ | KnownOpApp Aspects Range QName (Set1 A.Name) OpAppArgs+ -- ^ An operator application coming from abstract syntax, for which+ -- we know a precise syntactic highlighting class (used in+ -- printing).+ | Highlighted Aspects Expr+ -- ^ An arbitrary expression bundled with highlighting information+ -- from abstract (or internal) syntax+ | Generalized Expr+ deriving Eq++type OpAppArgs = OpAppArgs' Expr+type OpAppArgs' e = List1 (NamedArg (MaybePlaceholder (OpApp e)))+type OpAppArgs0 e = [NamedArg (MaybePlaceholder (OpApp e))]++-- | Concrete patterns. No literals in patterns at the moment.+data Pattern+ = IdentP Bool QName -- ^ @c@ or @x@+ --+ -- If the boolean is+ -- 'False', then the+ -- 'QName' must not refer+ -- to a constructor or a+ -- pattern synonym. The+ -- value 'False' is used+ -- when a hidden argument+ -- pun is expanded.+ | QuoteP Range -- ^ @quote@+ | AppP Pattern (NamedArg Pattern) -- ^ @p p'@ or @p {x = p'}@+ | RawAppP Range (List2 Pattern) -- ^ @p1..pn@ before parsing operators+ | OpAppP Range QName (Set1 A.Name)+ (List1 (NamedArg Pattern)) -- ^ eg: @p => p'@ for operator @_=>_@+ -- The 'QName' is possibly+ -- ambiguous, but it must+ -- correspond to one of+ -- the names in the set.+ | HiddenP Range (Named_ Pattern) -- ^ @{p}@ or @{x = p}@+ | InstanceP Range (Named_ Pattern) -- ^ @{{p}}@ or @{{x = p}}@+ | ParenP Range Pattern -- ^ @(p)@+ | WildP Range -- ^ @_@+ | AbsurdP Range -- ^ @()@+ | AsP Range Name Pattern -- ^ @x\@p@+ | DotP KwRange Range !PossiblyProjectionPattern Expr+ -- ^ @.e@, the 'KwRange' is for the dot, the 'Range' for the whole thing (including the dot).+ -- If the dot pattern came from parsing e.g. @.{e}@ it cannot be a projection pattern.+ | LitP Range Literal -- ^ @0@, @1@, etc.+ | RecP KwRange Range [FieldAssignment' Pattern]+ -- ^ @record {x = p; y = q}@. The 'KwRange' is for the @record@ keyword.+ | EqualP Range (List1 (Expr,Expr)) -- ^ @i = i1@ i.e. cubical face lattice generator+ | EllipsisP Range (Maybe Pattern) -- ^ @...@, only as left-most pattern.+ -- Second arg is @Nothing@ before expansion, and+ -- @Just p@ after expanding ellipsis to @p@.+ | WithP Range Pattern -- ^ @| p@, for with-patterns.+ deriving Eq++-- | Can a dot pattern be interpreted as projection pattern?+data PossiblyProjectionPattern+ = CouldBeProjectionPattern -- ^ Yes.+ | CannotBeProjectionPattern -- ^ No.+ deriving (Eq, Show)++data DoStmt+ = DoBind Range Pattern Expr [LamClause] -- ^ @p ← e where cs@+ | DoThen Expr+ | DoLet Range (List1 Declaration)+ deriving Eq++-- | A Binder @x\@p@, the pattern is optional+data Binder' a = Binder+ { binderPattern :: Maybe Pattern+ , binderNameOrigin :: BinderNameOrigin+ , binderName :: a+ } deriving (Eq, Functor, Foldable, Traversable)++type Binder = Binder' BoundName++mkBinder_ :: Name -> Binder+mkBinder_ = mkBinder . mkBoundName_++mkBinder :: a -> Binder' a+mkBinder = Binder Nothing UserBinderName++-- | Parameters supplied to data and record definitions (as opposed to their signatures)+-- are stripped of their type information.+-- They also cannot contain @let@ or pattern bindings or tactic attributes.+type DefParameters = [WithHiding (Named_ Name)]++-- | A lambda binding is either untyped (domain free) or typed ('TypedBinding').++type LamBinding = LamBinding' TypedBinding+data LamBinding' a+ = DomainFree (NamedArg Binder)+ -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@ or @{.x}@ or @x\@p@ or @(p)@+ | DomainFull a+ -- ^ . @(xs : e)@ or @{xs : e}@+ deriving (Functor, Foldable, Traversable, Eq)++-- | Parameters are sequences of typed or untyped bindings.+type Parameters = [LamBinding]++-- | Drop type annotations and modalities from bindings.+-- Also drop let, patterns, fixity, and tactics,+-- but those should not be present in the first place when using this function,+-- because all such cannot occur in data and record parameters.+parametersToDefParameters :: Parameters -> DefParameters+parametersToDefParameters = concatMap \case+ DomainFree x -> [strip x]+ DomainFull (TBind _ xs _) -> map strip $ List1.toList xs+ DomainFull TLet{} -> __IMPOSSIBLE__+ where+ strip :: NamedArg Binder -> WithHiding (Named_ Name)+ strip = unArgKeepHiding . fmap (fmap (boundName . binderName))++defParametersToParameters :: DefParameters -> Parameters+defParametersToParameters = map \ (WithHiding h n) ->+ DomainFree $ setHiding h $ defaultArg $ mkBinder_ <$> n++data BoundName = BName+ { boundName :: Name+ , bnameFixity :: Fixity'+ , bnameTactic :: TacticAttribute+ -- ^ From @\@tactic@ attribute.+ , bnameIsFinite :: Bool+ -- ^ The @\@finite@ cannot be parsed, it comes from the builtin @Partial@ only.+ }+ deriving Eq++newtype TacticAttribute' a = TacticAttribute { theTacticAttribute :: Maybe (Ranged a) }+ deriving (Eq, Show, NFData, Functor, Foldable, Traversable, KillRange)+type TacticAttribute = TacticAttribute' Expr++instance Null (TacticAttribute' a) where+ null = isNothing . theTacticAttribute+ empty = TacticAttribute Nothing++mkBoundName_ :: Name -> BoundName+mkBoundName_ x = mkBoundName x noFixity'++mkBoundName :: Name -> Fixity' -> BoundName+mkBoundName x f = BName x f empty False++-- | A typed binding.++type TypedBinding = TypedBinding' Expr++data TypedBinding' e+ = TBind Range (List1 (NamedArg Binder)) e+ -- ^ Binding @(x1\@p1 ... xn\@pn : A)@.+ | TLet Range (List1 Declaration)+ -- ^ Let binding @(let Ds)@ or @(open M args)@.+ deriving (Functor, Foldable, Traversable, Eq)++-- | A telescope is a sequence of typed bindings. Bound variables are in scope+-- in later types.+type Telescope1 = List1 TypedBinding+type Telescope = [TypedBinding]++-- | We can get a @Telescope@ from @Parameters@.+-- If we have a type annotation already, we're happy.+-- Otherwise we manufacture a binder with an underscore for the type.+parametersToTelescope :: Range -> Parameters -> Telescope+parametersToTelescope r = fmap $ \case+ DomainFull ty -> ty+ DomainFree nm -> TBind r (List1.singleton nm) $ Underscore r Nothing++-- | Smart constructor for @Pi@: check whether the @Telescope@ is empty++makePi :: Telescope -> Expr -> Expr+makePi [] = id+makePi (b:bs) = Pi (b :| bs)++-- | Smart constructor for @Lam@: check for non-zero bindings.++mkLam :: Range -> [LamBinding] -> Expr -> Expr+mkLam r [] e = e+mkLam r (x:xs) e = Lam r (x :| xs) e++-- | Smart constructor for @Let@: check for non-zero let bindings.++mkLet :: Range -> [Declaration] -> Expr -> Expr+mkLet r [] e = e+mkLet r (d:ds) e = Let r (d :| ds) (Just e)++-- | Smart constructor for @TLet@: check for non-zero let bindings.++mkTLet :: Range -> [Declaration] -> Maybe (TypedBinding' e)+mkTLet r [] = Nothing+mkTLet r (d:ds) = Just $ TLet r (d :| ds)++{-| Left hand sides can be written in infix style. For example:++ > n + suc m = suc (n + m)+ > (f ∘ g) x = f (g x)++ We use fixity information to see which name is actually defined.+-}+data LHS = LHS -- ^ Original pattern (including with-patterns), rewrite equations and with-expressions.+ { lhsOriginalPattern :: Pattern+ -- ^ e.g. @f ps | wps@+ , lhsRewriteEqn :: [RewriteEqn]+ -- ^ @(rewrite e | with p <- e in eq)@ (many)+ , lhsWithExpr :: [WithExpr]+ -- ^ @with e1 in eq | {e2} | ...@ (many)+ }+ deriving Eq++type RewriteEqn = RewriteEqn' () Name Pattern Expr+type WithExpr = Named Name (Arg Expr)++-- | Processed (operator-parsed) intermediate form of the core @f ps@ of 'LHS'.+-- Corresponds to 'lhsOriginalPattern'.+data LHSCore+ = LHSHead { lhsDefName :: QName -- ^ @f@+ , lhsPats :: [NamedArg Pattern] -- ^ @ps@+ }+ | LHSProj { lhsDestructor :: QName -- ^ Record projection.+ , lhsPatsLeft :: [NamedArg Pattern] -- ^ Patterns for record indices (currently none).+ , lhsFocus :: NamedArg LHSCore -- ^ Main argument.+ , lhsPats :: [NamedArg Pattern] -- ^ More application patterns.+ }+ | LHSWith { lhsHead :: LHSCore+ , lhsWithPatterns :: List1 Pattern -- ^ At least one @(| p)@.+ , lhsPats :: [NamedArg Pattern] -- ^ More application patterns.+ }+ | LHSEllipsis+ { lhsEllipsisRange :: Range+ , lhsEllipsisPat :: LHSCore -- ^ Pattern that was expanded from an ellipsis @...@.+ }+ deriving Eq++type RHS = RHS' Expr+data RHS' e+ = AbsurdRHS -- ^ No right hand side because of absurd match.+ | RHS e+ deriving (Functor, Foldable, Traversable, Eq)++-- | @where@ block following a clause.+type WhereClause = WhereClause' [Declaration]++-- | The generalization @WhereClause'@ is for the sake of "Agda.Concrete.Generic".+data WhereClause' decls+ = NoWhere+ -- ^ No @where@ clauses.+ | AnyWhere Range decls+ -- ^ Ordinary @where@. 'Range' of the @where@ keyword.+ -- List of declarations can be empty.+ | SomeWhere Range Erased Name Access decls+ -- ^ Named where: @module M where ds@.+ -- 'Range' of the keywords @module@ and @where@.+ -- The 'Access' flag applies to the 'Name' (not the module contents!)+ -- and is propagated from the parent function.+ -- List of declarations can be empty.+ deriving (Eq, Functor, Foldable, Traversable)++-- | Type of @where@ block following a clause.+data WhereClause_+ = NoWhere_ -- ^ No @where@ clauses.+ | AnyWhere_ -- ^ Ordinary @where@.+ | SomeWhere_ -- ^ Named where: @module M where ...@.+ deriving (Eq, Generic)++whereClause_ :: WhereClause' a -> WhereClause_+whereClause_ = \case+ NoWhere {} -> NoWhere_+ AnyWhere {} -> AnyWhere_+ SomeWhere{} -> SomeWhere_++data LamClause = LamClause+ { lamLHS :: [Pattern] -- ^ Possibly empty sequence.+ , lamRHS :: RHS+ , lamCatchall :: Catchall+ }+ deriving Eq++-- | An expression followed by a where clause.+-- Currently only used to give better a better error message in interaction.+data ExprWhere = ExprWhere Expr WhereClause++-- | The things you are allowed to say when you shuffle names between name+-- spaces (i.e. in @import@, @namespace@, or @open@ declarations).+type ImportDirective = ImportDirective' Name Name+type Using = Using' Name Name+type Renaming = Renaming' Name Name+type RenamingDirective = RenamingDirective' Name Name+type HidingDirective = HidingDirective' Name Name -- 'Hiding' is already taken++-- | An imported name can be a module or a defined name.+type ImportedName = ImportedName' Name Name++-- | The content of the @as@-clause of the import statement.+data AsName' a = AsName+ { asName :: a+ -- ^ The \"as\" name.+ , asRange :: Range+ -- ^ The range of the \"as\" keyword. Retained for highlighting purposes.+ }+ deriving (Show, Functor, Foldable, Traversable, Eq)++-- | From the parser, we get an expression for the @as@-'Name', which+-- we have to parse into a 'Name'.+type AsName = AsName' Name++{--------------------------------------------------------------------------+ Declarations+ --------------------------------------------------------------------------}++-- | Just type signatures.+type TypeSignature = Declaration++-- | Just field signatures+type FieldSignature = Declaration++-- | Just type signatures or instance blocks.+type TypeSignatureOrInstanceBlock = Declaration++-- | Isolated record directives parsed as Declarations+data RecordDirective+ = Induction (Ranged Induction)+ -- ^ Range of keyword @[co]inductive@.+ | Constructor Name IsInstance+ | Eta (Ranged HasEta0)+ -- ^ Range of @[no-]eta-equality@ keyword.+ | PatternOrCopattern Range+ -- ^ If declaration @pattern@ is present, give its range.+ deriving (Eq, Show)++type RecordDirectives = RecordDirectives' (Maybe (Name, IsInstance))++ungatherRecordDirectives :: RecordDirectives -> [RecordDirective]+ungatherRecordDirectives (RecordDirectives ind eta pat con) = catMaybes+ [ Induction <$> ind+ , Eta <$> eta+ , PatternOrCopattern <$> pat+ , uncurry Constructor <$> con+ ]+++{-| The representation type of a declaration. The comments indicate+ which type in the intended family the constructor targets.+-}++data Declaration+ = TypeSig ArgInfo TacticAttribute Name Expr+ -- ^ Axioms and functions can be irrelevant. ('Hiding' should be 'NotHidden')+ -- 'TacticAttribute' makes only sense in 'Generalize' blocks.+ | FieldSig IsInstance TacticAttribute Name (Arg Expr)+ | Generalize KwRange [TypeSignature] -- ^ Variables to be generalized, can be hidden and/or irrelevant.+ | Field KwRange [FieldSignature]+ | FunClause ArgInfo LHS RHS WhereClause Catchall -- ^ Only 'Modality' is used in 'ArgInfo'.+ | DataSig Range Erased Name Parameters Expr -- ^ lone data signature in mutual block+ | Data Range Erased Name Parameters Expr+ [TypeSignatureOrInstanceBlock]+ | DataDef Range Name Parameters [TypeSignatureOrInstanceBlock]+ | RecordSig Range Erased Name Parameters Expr -- ^ lone record signature in mutual block+ | RecordDef Range Name [RecordDirective] Parameters [Declaration]+ | Record Range Erased Name [RecordDirective] Parameters Expr+ [Declaration]+ | Infix Fixity (List1 Name)+ | Syntax Name Notation -- ^ notation declaration for a name+ | PatternSyn Range Name [WithHiding Name] Pattern+ | Mutual KwRange [Declaration]+ | InterleavedMutual KwRange [Declaration]+ | Abstract KwRange [Declaration]+ | Private KwRange Origin [Declaration]+ -- ^ In "Agda.Syntax.Concrete.Definitions" we generate private blocks+ -- temporarily, which should be treated different that user-declared+ -- private blocks. Thus the 'Origin'.+ | InstanceB KwRange [Declaration]+ -- ^ The 'KwRange' here only refers to the range of the+ -- @instance@ keyword. The range of the whole block @InstanceB r ds@+ -- is @fuseRange r ds@.+ | LoneConstructor KwRange [Declaration]+ | Macro KwRange [Declaration]+ | Postulate KwRange [TypeSignatureOrInstanceBlock]+ | Primitive KwRange [TypeSignature]+ | Open KwRange QName ImportDirective+ | Import OpenShortHand KwRange QName (Either AsName RawOpenArgs) ImportDirective+ | ModuleMacro Range Erased Name ModuleApplication !OpenShortHand+ ImportDirective+ | Module Range Erased QName Telescope [Declaration]+ | UnquoteDecl Range [Name] Expr+ -- ^ @unquoteDecl xs = e@+ | UnquoteDef Range [Name] Expr+ -- ^ @unquoteDef xs = e@+ | UnquoteData Range Name [Name] Expr+ -- ^ @unquoteDecl data d constructor xs = e@+ | Pragma Pragma+ | Opaque KwRange [Declaration]+ -- ^ @opaque ...@+ | Unfolding KwRange [QName]+ -- ^ @unfolding ...@+ deriving Eq++-- | Expressions usually instantiating module parameters as in+-- @+-- open import Monoid Carrier _==_+-- @+-- that might also code an @as@ clause e.g. in+-- @+-- open import File as M+-- @+-- The parser does not distinguish these so we do it in the nicifier.+type RawOpenArgs = [Expr]++-- | Return 'Pragma' if 'Declaration' is 'Pragma'.+{-# SPECIALIZE isPragma :: Declaration -> Maybe Pragma #-}+{-# SPECIALIZE isPragma :: Declaration -> [Pragma] #-}+isPragma :: CMaybe Pragma m => Declaration -> m+isPragma = \case+ Pragma p -> singleton p+ Private _ _ _ -> empty+ Abstract _ _ -> empty+ InstanceB _ _ -> empty+ Mutual _ _ -> empty+ Module _ _ _ _ _ -> empty+ Macro _ _ -> empty+ Record _ _ _ _ _ _ _ -> empty+ RecordDef _ _ _ _ _ -> empty+ TypeSig _ _ _ _ -> empty+ FieldSig _ _ _ _ -> empty+ Generalize _ _ -> empty+ Field _ _ -> empty+ FunClause _ _ _ _ _ -> empty+ DataSig _ _ _ _ _ -> empty+ Data _ _ _ _ _ _ -> empty+ DataDef _ _ _ _ -> empty+ RecordSig _ _ _ _ _ -> empty+ Infix _ _ -> empty+ Syntax _ _ -> empty+ PatternSyn _ _ _ _ -> empty+ InterleavedMutual _ _ -> empty+ LoneConstructor _ _ -> empty+ Postulate _ _ -> empty+ Primitive _ _ -> empty+ Open _ _ _ -> empty+ Import _ _ _ _ _ -> empty+ ModuleMacro _ _ _ _ _ _ -> empty+ UnquoteDecl _ _ _ -> empty+ UnquoteDef _ _ _ -> empty+ UnquoteData _ _ _ _ -> empty+ Opaque _ _ -> empty+ Unfolding _ _ -> empty++data ModuleApplication+ = SectionApp Range Telescope QName [Expr]+ -- ^ @tel M exprs@ where @M exprs@ is a 'RawApp' just after parsing.+ | RecordModuleInstance Range QName+ -- ^ @M {{...}}@+ deriving Eq++data OpenShortHand+ = DoOpen KwRange -- ^ Range of the @open@ keyword.+ | DontOpen+ deriving (Eq, Show, Generic)++-- Pragmas ----------------------------------------------------------------++data Pragma+ = OptionsPragma Range [String]+ | BuiltinPragma Range RString QName+ | RewritePragma Range Range [QName] -- ^ Second Range is for REWRITE keyword.+ | ForeignPragma Range (Ranged BackendName) String+ | CompilePragma Range (Ranged BackendName) QName String+ | StaticPragma Range QName+ | InlinePragma Range Bool QName -- ^ INLINE or NOINLINE++ | ImpossiblePragma Range [String]+ -- ^ Throws an internal error in the scope checker.+ -- The 'String's are words to be displayed with the error.+ | EtaPragma Range QName+ -- ^ Removed, replaced by 'EtaEqualityPragma'.+ | WarningOnUsage Range QName Text+ -- ^ Applies to the named function+ | WarningOnImport Range Text+ -- ^ Applies to the current module+ | InjectivePragma Range QName+ -- ^ Mark a definition as injective for the pattern matching unifier.+ | InjectiveForInferencePragma Range QName+ -- ^ Mark a definition as injective for the conversion checker+ | DisplayPragma Range Pattern Expr+ -- ^ Display lhs as rhs (modifies the printer).++ -- Attached (more or less) pragmas handled in the nicifier (Concrete.Definitions):+ | CatchallPragma Range+ -- ^ Applies to the following function clause.+ | EtaEqualityPragma Range+ -- ^ Applies to the following record type.+ -- Force @eta-equality@ for the attached @record@ type for unguarded and @coinductive@ records.+ | TerminationCheckPragma Range (TerminationCheck Name)+ -- ^ Applies to the following function (and all that are mutually recursive with it)+ -- or to the functions in the following mutual block.+ | NoCoverageCheckPragma Range+ -- ^ Applies to the following function (and all that are mutually recursive with it)+ -- or to the functions in the following mutual block.+ | NoPositivityCheckPragma Range+ -- ^ Applies to the following data/record type or mutual block.+ | PolarityPragma Range Name [Ranged Occurrence]+ | NoUniverseCheckPragma Range+ -- ^ Applies to the following data/record type.+ | NotProjectionLikePragma Range QName+ -- ^ Applies to the stated function+ | OverlapPragma Range [QName] OverlapMode+ -- ^ Applies to the given name(s), which must be instance names+ -- (checked by the type checker).+ deriving Eq++---------------------------------------------------------------------------++-- | Modules: Top-level pragmas plus other top-level declarations.++data Module = Mod+ { modName :: QName+ -- ^ The module name as inferred by the parser.+ -- Could be @_@ if the parser inserted a top-level module declaration.+ , modPragmas :: [Pragma]+ -- ^ The top-level OPTIONS pragmas.+ , modDecls :: [Declaration]+ -- ^ All the other declarations, including the top-level module.+ }++-- | Splits off allowed (= import) declarations before the first+-- non-allowed declaration.+-- After successful parsing, the first non-allowed declaration+-- should be a module declaration.+spanAllowedBeforeModule :: [Declaration] -> ([Declaration], [Declaration])+spanAllowedBeforeModule = span isAllowedBeforeModule+ where+ isAllowedBeforeModule (Pragma OptionsPragma{}) = True+ isAllowedBeforeModule (Pragma BuiltinPragma{}) = True+ isAllowedBeforeModule (Private _ _ ds) = all isAllowedBeforeModule ds+ isAllowedBeforeModule Import{} = True+ isAllowedBeforeModule ModuleMacro{} = True+ isAllowedBeforeModule Open{} = True+ isAllowedBeforeModule _ = False++{--------------------------------------------------------------------------+ Things we parse but are not part of the Agda file syntax+ --------------------------------------------------------------------------}++-- | Extended content of an interaction hole.+data HoleContent' qn nm p e+ = HoleContentExpr e -- ^ @e@+ | HoleContentRewrite [RewriteEqn' qn nm p e] -- ^ @(rewrite | invert) e0 | ... | en@+ deriving (Functor, Foldable, Traversable)++type HoleContent = HoleContent' () Name Pattern Expr++---------------------------------------------------------------------------+-- * Smart constructors+---------------------------------------------------------------------------++rawApp :: List1 Expr -> Expr+rawApp es@(e1 :| e2 : rest) = RawApp (getRange es) $ List2 e1 e2 rest+rawApp (e :| []) = e++rawAppP :: List1 Pattern -> Pattern+rawAppP ps@(p1 :| p2 : rest) = RawAppP (getRange ps) $ List2 p1 p2 rest+rawAppP (p :| []) = p++{--------------------------------------------------------------------------+ Views+ --------------------------------------------------------------------------}++-- | The 'Expr' is not an application.+data AppView = AppView Expr [NamedArg Expr]++appView :: Expr -> AppView+appView e = f (DL.toList ess)+ where+ (f, ess) = appView' e++ appView' :: Expr -> ([NamedArg Expr] -> AppView, DList (NamedArg Expr))+ appView' = \case+ App r e1 e2 -> appView' e1 & second (`DL.snoc` e2)+ RawApp _ (List2 e1 e2 es)+ -> (AppView e1, DL.fromList (map toNamedArg (e2 : es)))+ e -> (AppView e, mempty)++unAppView :: AppView -> Expr+unAppView (AppView e nargs) = rawApp (e :| map unNamedArg nargs)++-- | Parse outermost hiding information.+toNamedArg :: Expr -> NamedArg Expr+toNamedArg = \case+ HiddenArg _ e -> hide $ defaultArg e+ InstanceArg _ e -> makeInstance $ defaultArg e+ e -> defaultNamedArg e++-- | Unparse hiding information.+unNamedArg :: NamedArg Expr -> Expr+unNamedArg narg = ($ unArg narg) $ case getHiding narg of+ Hidden -> HiddenArg (getRange narg)+ NotHidden -> namedThing+ Instance{} -> InstanceArg (getRange narg)++isSingleIdentifierP :: Pattern -> Maybe Name+isSingleIdentifierP = \case+ IdentP _ (QName x) -> Just x+ WildP r -> Just $ noName r+ ParenP _ p -> isSingleIdentifierP p+ _ -> Nothing++removeParenP :: Pattern -> Pattern+removeParenP = \case+ ParenP _ p -> removeParenP p+ p -> p++-- | Observe the hiding status of an expression+observeHiding :: Expr -> WithHiding Expr+observeHiding = \case+ HiddenArg _ (Named Nothing e) -> WithHiding Hidden e+ InstanceArg _ (Named Nothing e) -> WithHiding (Instance NoOverlap) e+ e -> WithHiding NotHidden e++-- | Observe the relevance status of an expression+observeRelevance :: Expr -> (Relevance, Expr)+observeRelevance = \case+ Dot kwr e -> (Irrelevant (OIrrDot (getRange kwr)), e)+ DoubleDot kwr e -> (ShapeIrrelevant (OShIrrDotDot (getRange kwr)), e)+ e -> (Relevant empty, e)++-- | Observe various modifiers applied to an expression+observeModifiers :: Expr -> Arg Expr+observeModifiers e =+ let (rel, WithHiding hid e') = fmap observeHiding (observeRelevance e) in+ setRelevance rel $ setHiding hid $ defaultArg e'++returnExpr :: Expr -> Maybe Expr+returnExpr (Pi _ e) = returnExpr e+returnExpr (Fun _ _ e) = returnExpr e+returnExpr (Let _ _ e) = returnExpr =<< e+returnExpr (Paren _ e) = returnExpr e+returnExpr (Generalized e) = returnExpr e+returnExpr e = pure e++-- | Turn an expression into a pattern. Fails if the expression is not a+-- valid pattern.++isPattern :: Expr -> Maybe Pattern+isPattern = exprToPattern (const Nothing)++-- | Turn an expression into a pattern, turning non-pattern subexpressions into 'WildP'.++exprToPatternWithHoles :: Expr -> Pattern+exprToPatternWithHoles = runIdentity . exprToPattern (Identity . WildP . getRange)++-- | Generic expression to pattern conversion.++exprToPattern :: Applicative m+ => (Expr -> m Pattern) -- ^ Default result for non-pattern things.+ -> Expr -- ^ The expression to translate.+ -> m Pattern -- ^ The translated pattern (maybe).+exprToPattern fallback = loop+ where+ loop = \case+ Ident x -> pure $ IdentP True x+ App _ e1 e2 -> AppP <$> loop e1 <*> traverse (traverse loop) e2+ Paren r e -> ParenP r <$> loop e+ Underscore r _ -> pure $ WildP r+ Absurd r -> pure $ AbsurdP r+ As r x e -> pushUnderBracesP r (AsP r x) <$> loop e+ e0@(Dot kwr e) -> pure $ pushDotUnderBraces kwr (getRange e0) e+ -- Wen, 2020-08-27: We disallow Float patterns, since equality for floating+ -- point numbers is not stable across architectures and with different+ -- compiler flags.+ e@(Lit _ LitFloat{}) -> fallback e+ Lit r l -> pure $ LitP r l+ HiddenArg r e -> HiddenP r <$> traverse loop e+ InstanceArg r e -> InstanceP r <$> traverse loop e+ RawApp r es -> RawAppP r <$> traverse loop es+ Quote r -> pure $ QuoteP r+ Equal r e1 e2 -> pure $ EqualP r $ singleton (e1, e2)+ Ellipsis r -> pure $ EllipsisP r Nothing+ e@(Rec kwr r es)+ -- We cannot translate record expressions with module parts.+ | Just fs <- mapM maybeLeft es -> RecP kwr r <$> traverse (traverse loop) fs+ | otherwise -> fallback e+ -- WithApp has already lost the range information of the bars '|'+ WithApp r e es -> do -- ApplicativeDo+ p <- loop e+ ps <- forA es $ \ e -> do -- ApplicativeDo+ p <- loop e+ pure $ defaultNamedArg $ WithP (getRange e) p -- TODO #2822: Range!+ pure $ foldl AppP p ps+ e -> fallback e++ pushUnderBracesP :: Range -> (Pattern -> Pattern) -> (Pattern -> Pattern)+ pushUnderBracesP r f = \case+ HiddenP _ p -> HiddenP r $ fmap f p+ InstanceP _ p -> InstanceP r $ fmap f p+ p -> f p++ pushDotUnderBraces :: KwRange -> Range -> Expr -> Pattern+ pushDotUnderBraces kwr r = \case+ HiddenArg _ e -> HiddenP r $ fmap (DotP kwr r CannotBeProjectionPattern) e+ InstanceArg _ e -> InstanceP r $ fmap (DotP kwr r CannotBeProjectionPattern) e+ Paren _ e -> DotP kwr r CannotBeProjectionPattern e+ e -> DotP kwr r CouldBeProjectionPattern e++isAbsurdP :: Pattern -> Maybe (Range, Hiding)+isAbsurdP = \case+ AbsurdP r -> pure (r, NotHidden)+ AsP _ _ p -> isAbsurdP p+ ParenP _ p -> isAbsurdP p+ HiddenP _ np -> (Hidden <$) <$> isAbsurdP (namedThing np)+ InstanceP _ np -> (Instance YesOverlap <$) <$> isAbsurdP (namedThing np)+ _ -> Nothing++isBinderP :: Pattern -> Maybe Binder+isBinderP = \case+ IdentP _ qn+ -> mkBinder_ <$> isUnqualified qn+ WildP r -> pure $ mkBinder_ $ setRange r simpleHole+ AsP r n p -> pure $ Binder (Just p) UserBinderName $ mkBoundName_ n+ ParenP r p -> pure $ Binder (Just p) UserBinderName $ mkBoundName_ $ setRange r simpleHole+ _ -> Nothing++{--------------------------------------------------------------------------+ Instances+ --------------------------------------------------------------------------}++-- Null+------------------------------------------------------------------------++instance Null OpenShortHand where+ empty = DontOpen++-- | A 'WhereClause' is 'null' when the @where@ keyword is absent.+-- An empty list of declarations does not count as 'null' here.++instance Null (WhereClause' a) where+ empty = NoWhere+ null NoWhere = True+ null AnyWhere{} = False+ null SomeWhere{} = False++instance Null WhereClause_ where+ empty = NoWhere_+ null NoWhere_ = True+ null AnyWhere_ = False+ null SomeWhere_ = False++-- Lenses+------------------------------------------------------------------------++instance LensHiding LamBinding where+ getHiding (DomainFree x) = getHiding x+ getHiding (DomainFull a) = getHiding a+ mapHiding f (DomainFree x) = DomainFree $ mapHiding f x+ mapHiding f (DomainFull a) = DomainFull $ mapHiding f a++instance LensHiding TypedBinding where+ getHiding (TBind _ (x :| _) _) = getHiding x -- Slightly dubious+ getHiding TLet{} = mempty+ mapHiding f (TBind r xs e) = TBind r (fmap (mapHiding f) xs) e+ mapHiding f b@TLet{} = b++instance LensRelevance TypedBinding where+ getRelevance (TBind _ (x :| _) _) = getRelevance x -- Slightly dubious+ getRelevance TLet{} = unitRelevance+ mapRelevance f (TBind r xs e) = TBind r (fmap (mapRelevance f) xs) e+ mapRelevance f b@TLet{} = b++-- HasRange instances+------------------------------------------------------------------------++instance HasRange OpenShortHand where+ getRange = \case+ DoOpen kwr -> getRange kwr+ DontOpen -> empty++instance HasRange e => HasRange (OpApp e) where+ getRange = \case+ Ordinary e -> getRange e+ SyntaxBindingLambda r _ _ -> r++instance HasRange Expr where+ getRange = \case+ Ident x -> getRange x+ Lit r _ -> r+ QuestionMark r _ -> r+ Underscore r _ -> r+ App r _ _ -> r+ RawApp r _ -> r+ OpApp r _ _ _ -> r+ WithApp r _ _ -> r+ Lam r _ _ -> r+ AbsurdLam r _ -> r+ ExtendedLam r _ _ -> r+ Fun r _ _ -> r+ Pi b e -> fuseRange b e+ Let r _ _ -> r+ Paren r _ -> r+ IdiomBrackets r _ _ -> r+ DoBlock r q ds -> getRange (r, q, ds)+ As r _ _ -> r+ Dot r e -> getRange (r, e)+ DoubleDot r e -> getRange (r, e)+ Absurd r -> r+ HiddenArg r _ -> r+ InstanceArg r _ -> r+ Rec _ r _ -> r+ RecUpdate _ r _ _ -> r+ Quote r -> r+ QuoteTerm r -> r+ Unquote r -> r+ Tactic r _ -> r+ DontCare{} -> noRange+ Equal r _ _ -> r+ Ellipsis r -> r+ Generalized e -> getRange e+ KnownIdent _ q -> getRange q+ KnownOpApp _ r _ _ _ -> r+ Highlighted _ e -> getRange e++-- instance HasRange Telescope where+-- getRange (TeleBind bs) = getRange bs+-- getRange (TeleFun x y) = fuseRange x y++instance HasRange Binder where+ getRange (Binder a _ b) = fuseRange a b++instance HasRange (TacticAttribute' a) where+ getRange = maybe noRange getRange . theTacticAttribute++instance HasRange TypedBinding where+ getRange (TBind r _ _) = r+ getRange (TLet r _) = r++instance HasRange LamBinding where+ getRange (DomainFree x) = getRange x+ getRange (DomainFull b) = getRange b++instance HasRange BoundName where+ getRange = getRange . boundName++instance HasRange WhereClause where+ getRange NoWhere = noRange+ getRange (AnyWhere r ds) = getRange (r, ds)+ getRange (SomeWhere r e x _ ds) = getRange (r, e, x, ds)++instance HasRange ModuleApplication where+ getRange (SectionApp r _ _ _) = r+ getRange (RecordModuleInstance r _) = r++instance HasRange a => HasRange (FieldAssignment' a) where+ getRange (FieldAssignment a b) = fuseRange a b++instance HasRange ModuleAssignment where+ getRange (ModuleAssignment a b c) = fuseRange a b `fuseRange` c++instance HasRange RecordDirective where+ getRange (Induction a) = getRange a+ getRange (Eta a ) = getRange a+ getRange (Constructor a b) = getRange (a, b)+ getRange (PatternOrCopattern r) = r++instance HasRange Declaration where+ getRange (TypeSig _ _ x t) = fuseRange x t+ getRange (FieldSig _ _ x t) = fuseRange x t+ getRange (Field kwr ds) = fuseRange kwr ds+ getRange (FunClause ai lhs rhs wh _) = ai `fuseRange` lhs `fuseRange` rhs `fuseRange` wh+ getRange (DataSig r _ _ _ _) = r+ getRange (Data r _ _ _ _ _) = r+ getRange (DataDef r _ _ _) = r+ getRange (RecordSig r _ _ _ _) = r+ getRange (RecordDef r _ _ _ _) = r+ getRange (Record r _ _ _ _ _ _) = r+ getRange (Mutual kwr ds) = fuseRange kwr ds+ getRange (InterleavedMutual kwr ds) = fuseRange kwr ds+ getRange (LoneConstructor kwr ds)= fuseRange kwr ds+ getRange (Abstract kwr ds) = fuseRange kwr ds+ getRange (Generalize kwr ds) = fuseRange kwr ds+ getRange (Open kwr x dir) = getRange (kwr, x, dir)+ getRange (ModuleMacro r _ _ _ _ _)+ = r+ getRange (Import a b c d e) = getRange (a, b, c, d, e)+ getRange (InstanceB kwr _) = getRange kwr+ getRange (Macro kwr ds) = fuseRange kwr ds+ getRange (Private kwr _ ds) = fuseRange kwr ds+ getRange (Postulate kwr ds) = fuseRange kwr ds+ getRange (Primitive kwr ds) = fuseRange kwr ds+ getRange (Module r _ _ _ _) = r+ getRange (Infix f _) = getRange f+ getRange (Syntax n _) = getRange n+ getRange (PatternSyn r _ _ _) = r+ getRange (UnquoteDecl r _ _) = r+ getRange (UnquoteDef r _ _) = r+ getRange (UnquoteData r _ _ _) = r+ getRange (Pragma p) = getRange p+ getRange (Opaque kwr ds) = fuseRange kwr ds+ getRange (Unfolding kwr ds) = fuseRange kwr ds++instance HasRange LHS where+ getRange (LHS p eqns ws) = p `fuseRange` eqns `fuseRange` ws++instance HasRange LHSCore where+ getRange (LHSHead f ps) = fuseRange f ps+ getRange (LHSProj d ps1 lhscore ps2) = d `fuseRange` ps1 `fuseRange` lhscore `fuseRange` ps2+ getRange (LHSWith f wps ps) = f `fuseRange` wps `fuseRange` ps+ getRange (LHSEllipsis r p) = r++instance HasRange RHS where+ getRange AbsurdRHS = noRange+ getRange (RHS e) = getRange e++instance HasRange LamClause where+ getRange (LamClause lhs rhs _) = getRange (lhs, rhs)++instance HasRange DoStmt where+ getRange (DoBind r _ _ _) = r+ getRange (DoThen e) = getRange e+ getRange (DoLet r _) = r++instance HasRange Pragma where+ getRange (OptionsPragma r _) = r+ getRange (BuiltinPragma r _ _) = r+ getRange (RewritePragma r _ _) = r+ getRange (CompilePragma r _ _ _) = r+ getRange (ForeignPragma r _ _) = r+ getRange (StaticPragma r _) = r+ getRange (InjectivePragma r _) = r+ getRange (InjectiveForInferencePragma r _) = r+ getRange (InlinePragma r _ _) = r+ getRange (ImpossiblePragma r _) = r+ getRange (EtaPragma r _) = r+ getRange (EtaEqualityPragma r) = r+ getRange (TerminationCheckPragma r _) = r+ getRange (NoCoverageCheckPragma r) = r+ getRange (WarningOnUsage r _ _) = r+ getRange (WarningOnImport r _) = r+ getRange (CatchallPragma r) = r+ getRange (DisplayPragma r _ _) = r+ getRange (NoPositivityCheckPragma r) = r+ getRange (PolarityPragma r _ _) = r+ getRange (NoUniverseCheckPragma r) = r+ getRange (NotProjectionLikePragma r _) = r+ getRange (OverlapPragma r _ _) = r++instance HasRange AsName where+ getRange a = getRange (asRange a, asName a)++instance HasRange Pattern where+ getRange (IdentP _ x) = getRange x+ getRange (AppP p q) = fuseRange p q+ getRange (OpAppP r _ _ _) = r+ getRange (RawAppP r _) = r+ getRange (ParenP r _) = r+ getRange (WildP r) = r+ getRange (AsP r _ _) = r+ getRange (AbsurdP r) = r+ getRange (LitP r _) = r+ getRange (QuoteP r) = r+ getRange (HiddenP r _) = r+ getRange (InstanceP r _) = r+ getRange (DotP _kwr r _ _) = r+ getRange (RecP _kwr r _) = r+ getRange (EqualP r _) = r+ getRange (EllipsisP r _) = r+ getRange (WithP r _) = r++-- SetRange instances+------------------------------------------------------------------------++instance SetRange Pattern where+ setRange r (IdentP c x) = IdentP c (setRange r x)+ setRange r (AppP p q) = AppP (setRange r p) (setRange r q)+ setRange r (OpAppP _ x ns ps) = OpAppP r x ns ps+ setRange r (RawAppP _ ps) = RawAppP r ps+ setRange r (ParenP _ p) = ParenP r p+ setRange r (WildP _) = WildP r+ setRange r (AsP _ x p) = AsP r (setRange r x) p+ setRange r (AbsurdP _) = AbsurdP r+ setRange r (LitP _ l) = LitP r l+ setRange r (QuoteP _) = QuoteP r+ setRange r (HiddenP _ p) = HiddenP r p+ setRange r (InstanceP _ p) = InstanceP r p+ setRange r (DotP _ _ ppp e) = DotP empty r ppp e+ setRange r (RecP _ _ fs) = RecP empty r fs+ setRange r (EqualP _ es) = EqualP r es+ setRange r (EllipsisP _ mp) = EllipsisP r mp+ setRange r (WithP _ p) = WithP r p++instance SetRange TypedBinding where+ setRange r (TBind _ xs e) = TBind r xs e+ setRange r (TLet _ ds) = TLet r ds++-- KillRange instances+------------------------------------------------------------------------++instance KillRange OpenShortHand where+ killRange = \case+ DoOpen _ -> DoOpen empty+ DontOpen -> DontOpen++instance KillRange a => KillRange (FieldAssignment' a) where+ killRange (FieldAssignment a b) = killRangeN FieldAssignment a b++instance KillRange ModuleAssignment where+ killRange (ModuleAssignment a b c) = killRangeN ModuleAssignment a b c++instance KillRange AsName where+ killRange (AsName n _) = killRangeN (flip AsName noRange) n++instance KillRange Binder where+ killRange (Binder a o b) = killRangeN Binder a o b++instance KillRange BoundName where+ killRange (BName n f t b) = killRangeN BName n f t b++instance KillRange RecordDirective where+ killRange (Induction a) = killRangeN Induction a+ killRange (Eta a ) = killRangeN Eta a+ killRange (Constructor a b) = killRangeN Constructor a b+ killRange (PatternOrCopattern _) = PatternOrCopattern noRange++instance KillRange Declaration where+ killRange (TypeSig ai t n e) = killRangeN TypeSig ai t n e+ killRange (FieldSig i t n e) = killRangeN FieldSig i t n e+ killRange (Generalize r ds ) = killRangeN (Generalize empty) ds+ killRange (Field r fs) = killRangeN (Field empty) fs+ killRange (FunClause ai l r w ca) = killRangeN FunClause ai l r w ca+ killRange (DataSig _ er n l e) = killRangeN (DataSig noRange) er n l e+ killRange (Data _ er n l e c) = killRangeN (Data noRange) er n l e c+ killRange (DataDef _ n l c) = killRangeN (DataDef noRange) n l c+ killRange (RecordSig _ er n l e) = killRangeN (RecordSig noRange) er n l e+ killRange (RecordDef _ n dir k d) = killRangeN (RecordDef noRange) n dir k d+ killRange (Record _ er n dir k e d)+ = killRangeN (Record noRange) er n dir k e d+ killRange (Infix f n) = killRangeN Infix f n+ killRange (Syntax n no) = killRangeN (\n -> Syntax n no) n+ killRange (PatternSyn _ n ns p) = killRangeN (PatternSyn noRange) n ns p+ killRange (Mutual _ d) = killRangeN (Mutual empty) d+ killRange (InterleavedMutual _ d) = killRangeN (InterleavedMutual empty) d+ killRange (LoneConstructor _ d) = killRangeN (LoneConstructor empty) d+ killRange (Abstract _ d) = killRangeN (Abstract empty) d+ killRange (Private _ o d) = killRangeN (Private empty) o d+ killRange (InstanceB _ d) = killRangeN (InstanceB empty) d+ killRange (Macro _ d) = killRangeN (Macro empty) d+ killRange (Postulate _ t) = killRangeN (Postulate empty) t+ killRange (Primitive _ t) = killRangeN (Primitive empty) t+ killRange (Open _ q i) = killRangeN (Open empty) q i+ killRange (Import a b c d e) = killRangeN Import a b c d e+ killRange (ModuleMacro _ e n m o i)+ = killRangeN+ (\e n m -> ModuleMacro noRange e n m o)+ e n m i+ killRange (Module _ e q t d) = killRangeN (Module noRange) e q t d+ killRange (UnquoteDecl _ x t) = killRangeN (UnquoteDecl noRange) x t+ killRange (UnquoteDef _ x t) = killRangeN (UnquoteDef noRange) x t+ killRange (UnquoteData _ xs cs t) = killRangeN (UnquoteData noRange) xs cs t+ killRange (Pragma p) = killRangeN Pragma p+ killRange (Opaque r xs) = killRangeN (Opaque empty) xs+ killRange (Unfolding r xs) = killRangeN (Unfolding empty) xs++instance KillRange Expr where+ killRange (Ident q) = killRangeN Ident q+ killRange (Lit _ l) = killRangeN (Lit noRange) l+ killRange (QuestionMark _ n) = QuestionMark noRange n+ killRange (Underscore _ n) = Underscore noRange n+ killRange (RawApp _ e) = killRangeN (RawApp noRange) e+ killRange (App _ e a) = killRangeN (App noRange) e a+ killRange (OpApp _ n ns o) = killRangeN (OpApp noRange) n ns o+ killRange (WithApp _ e es) = killRangeN (WithApp noRange) e es+ killRange (HiddenArg _ n) = killRangeN (HiddenArg noRange) n+ killRange (InstanceArg _ n) = killRangeN (InstanceArg noRange) n+ killRange (Lam _ l e) = killRangeN (Lam noRange) l e+ killRange (AbsurdLam _ h) = killRangeN (AbsurdLam noRange) h+ killRange (ExtendedLam _ e lrw) = killRangeN (ExtendedLam noRange) e lrw+ killRange (Fun _ e1 e2) = killRangeN (Fun noRange) e1 e2+ killRange (Pi t e) = killRangeN Pi t e+ killRange (Rec _ _ ne) = killRangeN (Rec empty noRange) ne+ killRange (RecUpdate _ _ e ne) = killRangeN (RecUpdate empty noRange) e ne+ killRange (Let _ d e) = killRangeN (Let noRange) d e+ killRange (Paren _ e) = killRangeN (Paren noRange) e+ killRange (IdiomBrackets _ q es) = killRangeN (IdiomBrackets noRange) q es+ killRange (DoBlock _ q ss) = killRangeN (DoBlock empty) q ss+ killRange (Absurd _) = Absurd noRange+ killRange (As _ n e) = killRangeN (As noRange) n e+ killRange (Dot _ e) = killRangeN (Dot empty) e+ killRange (DoubleDot _ e) = killRangeN (DoubleDot empty) e+ killRange (Quote _) = Quote noRange+ killRange (QuoteTerm _) = QuoteTerm noRange+ killRange (Unquote _) = Unquote noRange+ killRange (Tactic _ t) = killRangeN (Tactic noRange) t+ killRange (DontCare e) = killRangeN DontCare e+ killRange (Equal _ x y) = Equal noRange x y+ killRange (Ellipsis _) = Ellipsis noRange+ killRange (Generalized e) = killRangeN Generalized e+ killRange (KnownIdent a b) = killRangeN (KnownIdent a) b+ killRange (KnownOpApp a b c d e) = killRangeN (KnownOpApp a) b c d e+ killRange (Highlighted a b) = killRangeN (Highlighted a) b++instance KillRange LamBinding where+ killRange (DomainFree b) = killRangeN DomainFree b+ killRange (DomainFull t) = killRangeN DomainFull t++instance KillRange LHS where+ killRange (LHS p r w) = killRangeN LHS p r w++instance KillRange LamClause where+ killRange (LamClause a b c) = killRangeN LamClause a b c++instance KillRange DoStmt where+ killRange (DoBind r p e w) = killRangeN DoBind r p e w+ killRange (DoThen e) = killRangeN DoThen e+ killRange (DoLet r ds) = killRangeN DoLet r ds++instance KillRange ModuleApplication where+ killRange (SectionApp _ t x es) = killRangeN (SectionApp noRange) t x es+ killRange (RecordModuleInstance _ q) = killRangeN (RecordModuleInstance noRange) q++instance KillRange e => KillRange (OpApp e) where+ killRange (SyntaxBindingLambda _ l e) = killRangeN (SyntaxBindingLambda noRange) l e+ killRange (Ordinary e) = killRangeN Ordinary e++instance KillRange Pattern where+ killRange (IdentP c q) = killRangeN IdentP c q+ killRange (AppP p ps) = killRangeN AppP p ps+ killRange (RawAppP _ p) = killRangeN (RawAppP noRange) p+ killRange (OpAppP _ n ns p) = killRangeN (OpAppP noRange) n ns p+ killRange (HiddenP _ n) = killRangeN (HiddenP noRange) n+ killRange (InstanceP _ n) = killRangeN (InstanceP noRange) n+ killRange (ParenP _ p) = killRangeN (ParenP noRange) p+ killRange (WildP _) = WildP noRange+ killRange (AbsurdP _) = AbsurdP noRange+ killRange (AsP _ n p) = killRangeN (AsP noRange) n p+ killRange (DotP _ _ ppp e) = killRangeN (DotP empty noRange ppp) e+ killRange (LitP _ l) = killRangeN (LitP noRange) l+ killRange (QuoteP _) = QuoteP noRange+ killRange (RecP _ _ fs) = killRangeN (RecP empty noRange) fs+ killRange (EqualP _ es) = killRangeN (EqualP noRange) es+ killRange (EllipsisP _ mp) = killRangeN (EllipsisP noRange) mp+ killRange (WithP _ p) = killRangeN (WithP noRange) p++instance KillRange Pragma where+ killRange (OptionsPragma _ s) = OptionsPragma noRange s+ killRange (BuiltinPragma _ s e) = killRangeN (BuiltinPragma noRange s) e+ killRange (RewritePragma _ _ qs) = killRangeN (RewritePragma noRange noRange) qs+ killRange (StaticPragma _ q) = killRangeN (StaticPragma noRange) q+ killRange (InjectivePragma _ q) = killRangeN (InjectivePragma noRange) q+ killRange (InjectiveForInferencePragma _ q) = killRangeN (InjectiveForInferencePragma noRange) q+ killRange (InlinePragma _ b q) = killRangeN (InlinePragma noRange b) q+ killRange (CompilePragma _ b q s) = killRangeN (\ q -> CompilePragma noRange b q s) q+ killRange (ForeignPragma _ b s) = ForeignPragma noRange b s+ killRange (ImpossiblePragma _ strs) = ImpossiblePragma noRange strs+ killRange (TerminationCheckPragma _ t) = TerminationCheckPragma noRange (killRange t)+ killRange (NoCoverageCheckPragma _) = NoCoverageCheckPragma noRange+ killRange (WarningOnUsage _ nm str) = WarningOnUsage noRange (killRange nm) str+ killRange (WarningOnImport _ str) = WarningOnImport noRange str+ killRange (CatchallPragma _) = CatchallPragma noRange+ killRange (DisplayPragma _ lhs rhs) = killRangeN (DisplayPragma noRange) lhs rhs+ killRange (EtaPragma _ q) = killRangeN (EtaPragma noRange) q+ killRange (EtaEqualityPragma _) = EtaEqualityPragma noRange+ killRange (NoPositivityCheckPragma _) = NoPositivityCheckPragma noRange+ killRange (PolarityPragma _ q occs) = killRangeN (\q -> PolarityPragma noRange q occs) q+ killRange (NoUniverseCheckPragma _) = NoUniverseCheckPragma noRange+ killRange (NotProjectionLikePragma _ q) = NotProjectionLikePragma noRange q+ killRange (OverlapPragma _ q i) = OverlapPragma noRange q i++instance KillRange RHS where+ killRange AbsurdRHS = AbsurdRHS+ killRange (RHS e) = killRangeN RHS e++instance KillRange TypedBinding where+ killRange (TBind _ b e) = killRangeN (TBind noRange) b e+ killRange (TLet r ds) = killRangeN TLet r ds++instance KillRange WhereClause where+ killRange NoWhere = NoWhere+ killRange (AnyWhere r d) = killRangeN (AnyWhere noRange) d+ killRange (SomeWhere r e n a d) =+ killRangeN (SomeWhere noRange) e n a d++------------------------------------------------------------------------+-- NFData instances++-- | Ranges are not forced.++instance NFData Expr where+ rnf (Ident a) = rnf a+ rnf (Lit _ a) = rnf a+ rnf (QuestionMark _ a) = rnf a+ rnf (Underscore _ a) = rnf a+ rnf (RawApp _ a) = rnf a+ rnf (App _ a b) = rnf a `seq` rnf b+ rnf (OpApp _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (WithApp _ a b) = rnf a `seq` rnf b+ rnf (HiddenArg _ a) = rnf a+ rnf (InstanceArg _ a) = rnf a+ rnf (Lam _ a b) = rnf a `seq` rnf b+ rnf (AbsurdLam _ a) = rnf a+ rnf (ExtendedLam _ a b) = rnf a `seq` rnf b+ rnf (Fun _ a b) = rnf a `seq` rnf b+ rnf (Pi a b) = rnf a `seq` rnf b+ rnf (Rec _ _ a) = rnf a+ rnf (RecUpdate _ _ a b) = rnf a `seq` rnf b+ rnf (Let _ a b) = rnf a `seq` rnf b+ rnf (Paren _ a) = rnf a+ rnf (IdiomBrackets _ a b) = rnf a `seq` rnf b+ rnf (DoBlock _ a b) = rnf a `seq` rnf b+ rnf (Absurd _) = ()+ rnf (As _ a b) = rnf a `seq` rnf b+ rnf (Dot _ a) = rnf a+ rnf (DoubleDot _ a) = rnf a+ rnf (Quote _) = ()+ rnf (QuoteTerm _) = ()+ rnf (Tactic _ a) = rnf a+ rnf (Unquote _) = ()+ rnf (DontCare a) = rnf a+ rnf (Equal _ a b) = rnf a `seq` rnf b+ rnf (Ellipsis _) = ()+ rnf (Generalized e) = rnf e+ rnf (KnownIdent a b) = rnf b+ rnf (KnownOpApp a b c d e) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf c+ rnf (Highlighted a b) = rnf a `seq` rnf b++-- | Ranges are not forced.++instance NFData Pattern where+ rnf (IdentP a b) = rnf a `seq` rnf b+ rnf (QuoteP _) = ()+ rnf (AppP a b) = rnf a `seq` rnf b+ rnf (RawAppP _ a) = rnf a+ rnf (OpAppP _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (HiddenP _ a) = rnf a+ rnf (InstanceP _ a) = rnf a+ rnf (ParenP _ a) = rnf a+ rnf (WildP _) = ()+ rnf (AbsurdP _) = ()+ rnf (AsP _ a b) = rnf a `seq` rnf b+ rnf (DotP _ _ _ a) = rnf a+ rnf (LitP _ a) = rnf a+ rnf (RecP _ _ a) = rnf a+ rnf (EqualP _ es) = rnf es+ rnf (EllipsisP _ mp) = rnf mp+ rnf (WithP _ a) = rnf a++-- | Ranges are not forced.++instance NFData RecordDirective where+ rnf (Induction a) = rnf a+ rnf (Eta a ) = rnf a+ rnf (Constructor a b) = rnf (a, b)+ rnf (PatternOrCopattern _) = ()++instance NFData Declaration where+ rnf (TypeSig a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ rnf (FieldSig a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ rnf (Generalize _ a) = rnf a+ rnf (Field _ fs) = rnf fs+ rnf (FunClause a b c d e) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf e+ rnf (DataSig _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ rnf (Data _ a b c d e) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ `seq` rnf e+ rnf (DataDef _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (RecordSig _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ rnf (RecordDef _ a b c d) = rnf (a, b, c, d)+ rnf (Record _ a b c d e f) = rnf (a, b, c, d, e, f)+ rnf (Infix a b) = rnf a `seq` rnf b+ rnf (Syntax a b) = rnf a `seq` rnf b+ rnf (PatternSyn _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (Mutual _ a) = rnf a+ rnf (InterleavedMutual _ a) = rnf a+ rnf (LoneConstructor _ a) = rnf a+ rnf (Abstract _ a) = rnf a+ rnf (Private _ _ a) = rnf a+ rnf (InstanceB _ a) = rnf a+ rnf (Macro _ a) = rnf a+ rnf (Postulate _ a) = rnf a+ rnf (Primitive _ a) = rnf a+ rnf (Open _ a b) = rnf a `seq` rnf b+ rnf (Import _ a b _ c) = rnf a `seq` rnf b `seq` rnf c+ rnf (ModuleMacro _ a b c _ d)+ = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ rnf (Module _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ rnf (UnquoteDecl _ a b) = rnf a `seq` rnf b+ rnf (UnquoteDef _ a b) = rnf a `seq` rnf b+ rnf (UnquoteData _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (Pragma a) = rnf a+ rnf (Opaque r xs) = rnf r `seq` rnf xs+ rnf (Unfolding r xs) = rnf r `seq` rnf xs++instance NFData OpenShortHand++-- | Ranges are not forced.++instance NFData Pragma where+ rnf (OptionsPragma _ a) = rnf a+ rnf (BuiltinPragma _ a b) = rnf a `seq` rnf b+ rnf (RewritePragma _ _ a) = rnf a+ rnf (CompilePragma _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (ForeignPragma _ b s) = rnf b `seq` rnf s+ rnf (StaticPragma _ a) = rnf a+ rnf (InjectivePragma _ a) = rnf a+ rnf (InjectiveForInferencePragma _ a) = rnf a+ rnf (InlinePragma _ _ a) = rnf a+ rnf (ImpossiblePragma _ a) = rnf a+ rnf (EtaPragma _ a) = rnf a+ rnf (EtaEqualityPragma _) = ()+ rnf (TerminationCheckPragma _ a) = rnf a+ rnf (NoCoverageCheckPragma _) = ()+ rnf (WarningOnUsage _ a b) = rnf a `seq` rnf b+ rnf (WarningOnImport _ a) = rnf a+ rnf (CatchallPragma _) = ()+ rnf (DisplayPragma _ a b) = rnf a `seq` rnf b+ rnf (NoPositivityCheckPragma _) = ()+ rnf (PolarityPragma _ a b) = rnf a `seq` rnf b+ rnf (NoUniverseCheckPragma _) = ()+ rnf (NotProjectionLikePragma _ q) = rnf q+ rnf (OverlapPragma _ q i) = rnf q `seq` rnf i++-- | Ranges are not forced.++instance NFData AsName where+ rnf (AsName a _) = rnf a++-- | Ranges are not forced.++instance NFData a => NFData (TypedBinding' a) where+ rnf (TBind _ a b) = rnf a `seq` rnf b+ rnf (TLet _ a) = rnf a++-- | Ranges are not forced.++instance NFData ModuleApplication where+ rnf (SectionApp _ a b c) = rnf a `seq` rnf b `seq` rnf c+ rnf (RecordModuleInstance _ a) = rnf a++-- | Ranges are not forced.++instance NFData a => NFData (OpApp a) where+ rnf (SyntaxBindingLambda _ a b) = rnf a `seq` rnf b+ rnf (Ordinary a) = rnf a++-- | Ranges are not forced.++instance NFData LHS where+ rnf (LHS a b c) = rnf a `seq` rnf b `seq` rnf c++instance NFData a => NFData (FieldAssignment' a) where+ rnf (FieldAssignment a b) = rnf a `seq` rnf b++instance NFData ModuleAssignment where+ rnf (ModuleAssignment a b c) = rnf a `seq` rnf b `seq` rnf c++instance NFData a => NFData (WhereClause' a) where+ rnf NoWhere = ()+ rnf (AnyWhere _ a) = rnf a+ rnf (SomeWhere _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d++instance NFData WhereClause_++instance NFData LamClause where+ rnf (LamClause a b c) = rnf (a, b, c)++instance NFData a => NFData (LamBinding' a) where+ rnf (DomainFree a) = rnf a+ rnf (DomainFull a) = rnf a++instance NFData Binder where+ rnf (Binder a o b) = rnf (a, o, b)++instance NFData BoundName where+ rnf (BName a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d++instance NFData a => NFData (RHS' a) where+ rnf AbsurdRHS = ()+ rnf (RHS a) = rnf a++instance NFData DoStmt where+ rnf (DoBind _ p e w) = rnf (p, e, w)+ rnf (DoThen e) = rnf e+ rnf (DoLet _ ds) = rnf ds
@@ -0,0 +1,315 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++{-# LANGUAGE CPP #-}++-- | Attributes: concrete syntax for ArgInfo, esp. modalities.++module Agda.Syntax.Concrete.Attribute where++import Prelude hiding (null)++import Control.Monad (foldM)++#if !MIN_VERSION_base(4,20,0)+import Data.List (foldl')+#endif++import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe++import Agda.Syntax.Common+import Agda.Syntax.Concrete (Expr(..), TacticAttribute)+import qualified Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Pretty () --instance only+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Syntax.Position++import Agda.Utils.Null+import Agda.Utils.Tuple (second)++import Agda.Utils.Impossible++-- | An attribute is a modifier for `ArgInfo`.++data Attribute+ = RelevanceAttribute Relevance+ | QuantityAttribute Quantity+ | TacticAttribute (Ranged Expr)+ | CohesionAttribute Cohesion+ | PolarityAttribute PolarityModality+ | LockAttribute Lock+ | RewriteAttribute RewriteAnn+ deriving (Show)++instance HasRange Attribute where+ getRange = \case+ RelevanceAttribute r -> getRange r+ QuantityAttribute q -> getRange q+ CohesionAttribute c -> getRange c+ PolarityAttribute p -> getRange p+ TacticAttribute e -> getRange e+ LockAttribute _l -> NoRange+ RewriteAttribute _r -> NoRange++instance SetRange Attribute where+ setRange r = \case+ RelevanceAttribute a -> RelevanceAttribute $ setRange r a+ QuantityAttribute q -> QuantityAttribute $ setRange r q+ CohesionAttribute c -> CohesionAttribute $ setRange r c+ PolarityAttribute p -> PolarityAttribute $ setRange r p+ TacticAttribute e -> TacticAttribute e -- -- $ setRange r e -- SetRange Expr not yet implemented+ LockAttribute l -> LockAttribute l+ RewriteAttribute r -> RewriteAttribute r++instance KillRange Attribute where+ killRange = \case+ RelevanceAttribute a -> RelevanceAttribute $ killRange a+ QuantityAttribute q -> QuantityAttribute $ killRange q+ CohesionAttribute c -> CohesionAttribute $ killRange c+ PolarityAttribute p -> PolarityAttribute $ killRange p+ TacticAttribute e -> TacticAttribute $ killRange e+ LockAttribute l -> LockAttribute l+ RewriteAttribute r -> RewriteAttribute r++-- | Parsed attribute.++data Attr = Attr+ { attrRange :: Range -- ^ Range includes the @.+ , attrName :: String -- ^ Concrete, user written attribute for error reporting, not including the "@".+ , theAttr :: Attribute -- ^ Parsed attribute.+ } deriving (Show)++instance HasRange Attr where+ getRange = attrRange++instance SetRange Attr where+ setRange r (Attr _ x a) = Attr r x a++instance KillRange Attr where+ killRange (Attr _ x a) = Attr noRange x (killRange a)++-- | (Conjunctive constraint.)++type LensAttribute a = (LensRelevance a, LensQuantity a, LensCohesion a, LensModalPolarity a, LensLock a, LensRewriteAnn a)++-- | Modifiers for 'Relevance'.++relevanceAttributeTable :: [(String, Relevance)]+relevanceAttributeTable =+ [ ("irr" , Irrelevant $ OIrrIrr noRange)+ , ("irrelevant" , Irrelevant $ OIrrIrrelevant noRange)+ , ("shirr" , ShapeIrrelevant $ OShIrrShIrr noRange)+ , ("shape-irrelevant", ShapeIrrelevant $ OShIrrShapeIrrelevant noRange)+ , ("relevant" , Relevant $ ORelRelevant noRange)+ ]++-- | Modifiers for 'Quantity'.++quantityAttributeTable :: [(String, Quantity)]+quantityAttributeTable =+ [ ("0" , Quantity0 $ Q0 noRange)+ , ("erased" , Quantity0 $ Q0Erased noRange)+ -- TODO: linearity+ -- , ("1" , Quantity1 $ Q1 noRange)+ -- , ("linear" , Quantity1 $ Q1Linear noRange)+ , ("ω" , Quantityω $ Qω noRange)+ , ("plenty" , Quantityω $ QωPlenty noRange)+ ]+-- quantityAttributeTable = concat+-- [ map (, Quantity0) [ "0", "erased" ] -- , "static", "compile-time" ]+-- , map (, Quantityω) [ "ω", "plenty" ] -- , "dynamic", "runtime", "unrestricted", "abundant" ]+-- -- , map (, Quantity1) [ "1", "linear" ]+-- -- , map (, Quantity01) [ "01", "affine" ]+-- ]++cohesionAttributeTable :: [(String, Cohesion)]+cohesionAttributeTable =+ [ ("♭" , Flat)+ , ("flat" , Flat)+ , ("♯" , Sharp)+ , ("sharp", Sharp)+ ]++-- | Information about attributes (attribute, range, printed+-- representation).+--+-- This information is returned by the parser. Code that calls the+-- parser should, if appropriate, complain if support for the given+-- attributes has not been enabled. This can be taken care of by+-- 'Agda.Syntax.Translation.ConcreteToAbstract.checkAttributes', which+-- should not be called until after pragma options have been set.++type Attributes = [Attr]++-- | Modifiers for 'Polarity'.++polarityAttributeTable :: [(String, PolarityModality)]+polarityAttributeTable =+ [ ("unused" , withStandardLock UnusedPolarity)+ , ("++" , withStandardLock StrictlyPositive)+ , ("+" , withStandardLock Positive)+ , ("-" , withStandardLock Negative)+ , ("mixed" , withStandardLock MixedPolarity)]++-- | Modifiers for 'Lock'.++lockAttributeTable :: [(String, Lock)]+lockAttributeTable = concat+ [ map (, IsNotLock) [ "notlock" ] -- default, shouldn't be used much+ , map (, IsLock LockOTick) [ "tick" ] -- @tick+ , map (, IsLock LockOLock) [ "lock" ] -- @lock+ ]++-- | Modifiers for @RewriteAnn@+-- I don't think we ever actually hit this because 'rewrite' is a keyword+-- Of course, we might want to add aliases+rewriteAttributeTable :: [(String, RewriteAnn)]+rewriteAttributeTable =+ [ ("rewrite" , IsRewrite noRange)+ ]++-- | Concrete syntax for all attributes.++attributesMap :: Map String Attribute+attributesMap = Map.fromListWith __IMPOSSIBLE__ $ concat+ [ map (second RelevanceAttribute) relevanceAttributeTable+ , map (second QuantityAttribute) quantityAttributeTable+ , map (second CohesionAttribute) cohesionAttributeTable+ , map (second PolarityAttribute) polarityAttributeTable+ , map (second LockAttribute) lockAttributeTable+ , map (second RewriteAttribute) rewriteAttributeTable+ ]++-- | Parsing a string into an attribute.++stringToAttribute :: String -> Maybe Attribute+stringToAttribute = (`Map.lookup` attributesMap)++-- | Parsing an expression into an attribute.++exprToAttribute :: Range -> Expr -> Maybe Attribute+exprToAttribute r = \case+ Paren _ (Tactic _ t) -> Just $ TacticAttribute $ Ranged r t+ e -> setRange r $ stringToAttribute $ prettyShow e++-- | Setting an attribute (in e.g. an 'Arg'). Overwrites previous value.++setAttribute :: (LensAttribute a) => Attribute -> a -> a+setAttribute = \case+ RelevanceAttribute r -> setRelevance r+ QuantityAttribute q -> setQuantity q+ CohesionAttribute c -> setCohesion c+ PolarityAttribute p -> setModalPolarity p+ LockAttribute l -> setLock l+ RewriteAttribute r -> setRewriteAnn r+ TacticAttribute _ -> id+++-- | Setting some attributes in left-to-right order.+-- Blindly overwrites previous settings.++setAttributes :: (LensAttribute a) => [Attribute] -> a -> a+setAttributes attrs arg = foldl' (flip setAttribute) arg attrs++---------------------------------------------------------------------------+-- * Applying attributes only if they have not been set already.+-- No overwriting.+---------------------------------------------------------------------------++-- | Setting 'Relevance' if unset.++setPristineRelevance :: (LensRelevance a) => Relevance -> a -> Maybe a+setPristineRelevance r a+ | null (getRelevance a) = Just $ setRelevance r a+ | otherwise = Nothing++-- | Setting 'Quantity' if unset.++setPristineQuantity :: (LensQuantity a) => Quantity -> a -> Maybe a+setPristineQuantity q a+ | noUserQuantity a = Just $ setQuantity q a+ | otherwise = Nothing++-- | Setting 'Cohesion' if unset.++setPristineCohesion :: (LensCohesion a) => Cohesion -> a -> Maybe a+setPristineCohesion c a+ | null (getCohesion a) = Just $ setCohesion c a+ | otherwise = Nothing++-- | Setting 'ModalPolarity' if unset.++setPristinePolarity :: (LensModalPolarity a) => PolarityModality -> a -> Maybe a+setPristinePolarity c a+ | getModalPolarity a == defaultPolarity = Just $ setModalPolarity c a+ | otherwise = Nothing++-- | Setting 'Lock' if unset.++setPristineLock :: (LensLock a) => Lock -> a -> Maybe a+setPristineLock q a+ | getLock a == defaultLock = Just $ setLock q a+ | otherwise = Nothing++-- | Setting 'RewriteAnn' if unset.++setPristineRewriteAnn :: (LensRewriteAnn a) => RewriteAnn -> a -> Maybe a+setPristineRewriteAnn q a+ | getRewriteAnn a == defaultRewrite = Just $ setRewriteAnn q a+ | otherwise = Nothing++-- | Setting an unset attribute (to e.g. an 'Arg').++setPristineAttribute :: (LensAttribute a) => Attribute -> a -> Maybe a+setPristineAttribute = \case+ RelevanceAttribute r -> setPristineRelevance r+ QuantityAttribute q -> setPristineQuantity q+ CohesionAttribute c -> setPristineCohesion c+ PolarityAttribute p -> setPristinePolarity p+ LockAttribute l -> setPristineLock l+ RewriteAttribute r -> setPristineRewriteAnn r+ TacticAttribute{} -> Just++-- | Setting a list of unset attributes.++setPristineAttributes :: (LensAttribute a) => [Attribute] -> a -> Maybe a+setPristineAttributes attrs arg = foldM (flip setPristineAttribute) arg attrs++---------------------------------------------------------------------------+-- * Filtering attributes+---------------------------------------------------------------------------++isRelevanceAttribute :: Attribute -> Maybe Relevance+isRelevanceAttribute = \case+ RelevanceAttribute q -> Just q+ _ -> Nothing++isQuantityAttribute :: Attribute -> Maybe Quantity+isQuantityAttribute = \case+ QuantityAttribute q -> Just q+ _ -> Nothing++isTacticAttribute :: Attribute -> TacticAttribute+isTacticAttribute = C.TacticAttribute . \case+ TacticAttribute t -> Just t+ _ -> Nothing++isRewriteAttribute :: Attribute -> Maybe RewriteAnn+isRewriteAttribute = \case+ RewriteAttribute q -> Just q+ _ -> Nothing++relevanceAttributes :: [Attribute] -> [Attribute]+relevanceAttributes = filter $ isJust . isRelevanceAttribute++quantityAttributes :: [Attribute] -> [Attribute]+quantityAttributes = filter $ isJust . isQuantityAttribute++tacticAttributes :: [Attribute] -> [Attribute]+tacticAttributes = filter $ isJust . C.theTacticAttribute . isTacticAttribute++rewAttributes :: [Attribute] -> [Attribute]+rewAttributes = filter $ isJust . isRewriteAttribute
@@ -1,674 +1,1761 @@-{-# LANGUAGE CPP, PatternGuards, DeriveDataTypeable #-}--module Agda.Syntax.Concrete.Definitions- ( NiceDeclaration(..)- , NiceConstructor, NiceTypeSignature- , Clause(..)- , DeclarationException(..)- , Nice, runNice- , niceDeclarations- , notSoNiceDeclarations- ) where--import Control.Arrow ((***), (&&&))-import Control.Applicative-import Data.Generics (Typeable, Data)-import Data.Foldable hiding (concatMap, mapM_, notElem, elem, all)-import qualified Data.Map as Map-import Data.Map (Map)-import Control.Monad.Error-import Control.Monad.State-import Data.List-import Data.Maybe-import Data.Traversable (traverse)--import Debug.Trace (trace)-import Agda.Syntax.Concrete-import Agda.Syntax.Common-import Agda.Syntax.Position-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Concrete.Pretty-import Agda.Utils.Pretty-import Agda.Utils.List (mhead, isSublistOf)-import Agda.Utils.Monad--#include "../../undefined.h"-import Agda.Utils.Impossible--import Control.Applicative-import Control.Monad.Error-import Data.Char--import Debug.Trace--{--------------------------------------------------------------------------- Types- --------------------------------------------------------------------------}--{-| The nice declarations. No fixity declarations and function definitions are- contained in a single constructor instead of spread out between type- signatures and clauses. The @private@, @postulate@, and @abstract@- modifiers have been distributed to the individual declarations.--}-data NiceDeclaration- = Axiom Range Fixity' Access Relevance Name Expr- -- ^ Axioms and functions can be declared irrelevant.- | NiceField Range Fixity' Access IsAbstract Name (Arg Expr)- | PrimitiveFunction Range Fixity' Access IsAbstract Name Expr- | NiceMutual Range [NiceDeclaration]- | NiceModule Range Access IsAbstract QName Telescope [Declaration]- | NiceModuleMacro Range Access IsAbstract Name ModuleApplication OpenShortHand ImportDirective- | NiceOpen Range QName ImportDirective- | NiceImport Range QName (Maybe AsName) OpenShortHand ImportDirective- | NicePragma Range Pragma- | NiceRecSig Range Fixity' Access Name [LamBinding] Expr- | NiceDataSig Range Fixity' Access Name [LamBinding] Expr- | FunSig Range Fixity' Access Relevance Name Expr- | FunDef Range [Declaration] Fixity' IsAbstract Name [Clause] -- ^ block of function clauses (we have seen the type signature before)- | DataDef Range Fixity' IsAbstract Name [LamBinding] [NiceConstructor]- | RecDef Range Fixity' IsAbstract Name (Maybe (ThingWithFixity Name)) [LamBinding] [NiceDeclaration]- deriving (Typeable, Data, Show)---- | Only 'Axiom's.-type NiceConstructor = NiceTypeSignature---- | Only 'Axiom's.-type NiceTypeSignature = NiceDeclaration---- | One clause in a function definition. There is no guarantee that the 'LHS'--- actually declares the 'Name'. We will have to check that later.-data Clause = Clause Name LHS RHS WhereClause [Clause]- deriving (Typeable, Data, Show)---- | The exception type.-data DeclarationException- = MultipleFixityDecls [(Name, [Fixity'])]- | MissingDefinition Name- | MissingWithClauses Name- | MissingTypeSignature LHS- | MissingDataSignature Name- | NotAllowedInMutual NiceDeclaration- | UnknownNamesInFixityDecl [Name]- | Codata Range- | DeclarationPanic String- | UselessPrivate Range- | UselessAbstract Range- | AmbiguousFunClauses LHS [Name] -- ^ in a mutual block, a clause could belong to any of the @[Name]@ type signatures- deriving (Typeable)--instance HasRange DeclarationException where- getRange (MultipleFixityDecls xs) = getRange (fst $ head xs)- getRange (MissingDefinition x) = getRange x- getRange (MissingWithClauses x) = getRange x- getRange (MissingTypeSignature x) = getRange x- getRange (MissingDataSignature x) = getRange x- getRange (AmbiguousFunClauses lhs xs) = getRange lhs- getRange (NotAllowedInMutual x) = getRange x- getRange (UnknownNamesInFixityDecl xs) = getRange . head $ xs- getRange (Codata r) = r- getRange (DeclarationPanic _) = noRange- getRange (UselessPrivate r) = r- getRange (UselessAbstract r) = r--instance HasRange NiceDeclaration where- getRange (Axiom r _ _ _ _ _) = r- getRange (NiceField r _ _ _ _ _) = r- getRange (NiceMutual r _) = r- getRange (NiceModule r _ _ _ _ _) = r- getRange (NiceModuleMacro r _ _ _ _ _ _) = r- getRange (NiceOpen r _ _) = r- getRange (NiceImport r _ _ _ _) = r- getRange (NicePragma r _) = r- getRange (PrimitiveFunction r _ _ _ _ _) = r- getRange (FunSig r _ _ _ _ _) = r- getRange (FunDef r _ _ _ _ _) = r- getRange (DataDef r _ _ _ _ _) = r- getRange (RecDef r _ _ _ _ _ _) = r- getRange (NiceRecSig r _ _ _ _ _) = r- getRange (NiceDataSig r _ _ _ _ _) = r--instance Error DeclarationException where- noMsg = strMsg ""- strMsg = DeclarationPanic--instance Show DeclarationException where- show (MultipleFixityDecls xs) = show $- sep [ fsep $ pwords "Multiple fixity declarations for"- , vcat $ map f xs- ]- where- f (x, fs) = pretty x <> text ":" <+> fsep (map (text . show) fs)- show (MissingDefinition x) = show $ fsep $- pwords "Missing definition for" ++ [pretty x]- show (MissingWithClauses x) = show $ fsep $- pwords "Missing with-clauses for function" ++ [pretty x]- show (MissingTypeSignature x) = show $ fsep $- pwords "Missing type signature for left hand side" ++ [pretty x]- show (MissingDataSignature x) = show $ fsep $- pwords "Missing type signature for " ++ [pretty x]- show (AmbiguousFunClauses lhs xs) = show $ fsep $- pwords "More than one matching type signature for left hand side" ++ [pretty lhs] ++- pwords "it could belong to any of:" ++ map pretty xs- show (UnknownNamesInFixityDecl xs) = show $ fsep $- pwords "Names out of scope in fixity declarations:" ++ map pretty xs- show (UselessPrivate _) = show $ fsep $- pwords "Using private here has no effect. Move it to the type signatures to make the definitions private."- show (UselessAbstract _) = show $ fsep $- pwords "Using abstract here has no effect. Move it to the definitions to make them abstract."- show (NotAllowedInMutual nd) = show $ fsep $- [text $ decl nd] ++ pwords "are not allowed in mutual blocks"- where- decl (Axiom{}) = "Postulates"- decl (NiceField{}) = "Fields"- decl (NiceMutual{}) = "Mutual blocks"- decl (NiceModule{}) = "Modules"- decl (NiceModuleMacro{}) = "Modules"- decl (NiceOpen{}) = "Open declarations"- decl (NiceImport{}) = "Import statements"- decl (NicePragma{}) = "Pragmas"- decl (PrimitiveFunction{}) = "Primitive declarations"- decl _ = __IMPOSSIBLE__- show (Codata _) =- "The codata construction has been removed. " ++- "Use the INFINITY builtin instead."- show (DeclarationPanic s) = s--{--------------------------------------------------------------------------- The niceifier- --------------------------------------------------------------------------}--data InMutual- = InMutual -- ^ we are nicifying a mutual block- | NotInMutual -- ^ we are nicifying decls not in a mutual block- deriving (Eq, Show)--data DataRecOrFun = DataName | RecName | FunName- deriving (Eq, Ord)--data NiceEnv = NiceEnv- { loneSigs :: [(DataRecOrFun, Name)] -- ^ lone type signatures that wait for their fun.clauses- , fixs :: Map Name Fixity'- }--initNiceEnv :: NiceEnv-initNiceEnv = NiceEnv- { loneSigs = []- , fixs = Map.empty- }--type Nice = StateT NiceEnv (Either DeclarationException)--localState :: Nice a -> Nice a-localState m = bracket get put (const m)--addLoneSig :: DataRecOrFun -> Name -> Nice ()-addLoneSig k x = modify $ \ niceEnv -> niceEnv { loneSigs = (k, x) : loneSigs niceEnv }--removeLoneSig :: DataRecOrFun -> Name -> Nice ()-removeLoneSig k x = modify $ \ niceEnv -> niceEnv { loneSigs = delete (k, x) $ loneSigs niceEnv }--hasSig :: DataRecOrFun -> Name -> Nice Bool-hasSig k x = gets $ elem (k, x) . loneSigs--noLoneSigs :: Nice Bool-noLoneSigs = gets $ null . loneSigs--checkLoneSigs :: Nice ()-checkLoneSigs = do- xs <- gets loneSigs- case xs of- [] -> return ()- (_, x):_ -> throwError $ MissingDefinition x--getFixity :: Name -> Nice Fixity'-getFixity x = gets $ Map.findWithDefault defaultFixity' x . fixs--runNice :: Nice a -> Either DeclarationException a-runNice nice = nice `evalStateT` initNiceEnv--data DeclKind = LoneSig DataRecOrFun Name | LoneDef DataRecOrFun Name | OtherDecl--declKind (FunSig _ _ _ _ x _) = LoneSig FunName x-declKind (NiceRecSig _ _ _ x _ _) = LoneSig RecName x-declKind (NiceDataSig _ _ _ x _ _) = LoneSig DataName x-declKind (FunDef _ _ _ _ x _) = LoneDef FunName x-declKind (DataDef _ _ _ x _ _) = LoneDef DataName x-declKind (RecDef _ _ _ x _ _ _) = LoneDef RecName x-declKind _ = OtherDecl--niceDeclarations :: [Declaration] -> Nice [NiceDeclaration]-niceDeclarations ds = do- fixs <- fixities ds- case Map.keys fixs \\ concatMap declaredNames ds of- [] -> localState $ do- put $ initNiceEnv { fixs = fixs }- ds <- nice ds- checkLoneSigs- modify $ \s -> s { loneSigs = [] }- inferMutualBlocks ds- xs -> throwError $ UnknownNamesInFixityDecl xs- where- -- Compute the names defined in a declaration- declaredNames :: Declaration -> [Name]- declaredNames d = case d of- TypeSig _ x _ -> [x]- Field x _ -> [x]- FunClause (LHS p [] _ _) _ _- | IdentP (QName x) <- removeSingletonRawAppP p -> [x]- FunClause{} -> []- DataSig _ _ x _ _ -> [x]- Data _ _ x _ _ cs -> x : concatMap declaredNames cs- RecordSig _ x _ _ -> [x]- Record _ x c _ _ _ -> x : foldMap (:[]) c- Infix _ _ -> []- Syntax _ _ -> []- Mutual _ ds -> concatMap declaredNames ds- Abstract _ ds -> concatMap declaredNames ds- Private _ ds -> concatMap declaredNames ds- Postulate _ ds -> concatMap declaredNames ds- Primitive _ ds -> concatMap declaredNames ds- Open{} -> []- Import{} -> []- ModuleMacro{} -> []- Module{} -> []- Pragma{} -> []-- inferMutualBlocks :: [NiceDeclaration] -> Nice [NiceDeclaration]- inferMutualBlocks [] = return []- inferMutualBlocks (d : ds) =- case declKind d of- OtherDecl -> (d :) <$> inferMutualBlocks ds- LoneDef _ x -> __IMPOSSIBLE__- LoneSig k x -> do- addLoneSig k x- (ds0, ds1) <- untilAllDefined ds- (NiceMutual (getRange (d : ds0)) (d : ds0) :) <$> inferMutualBlocks ds1- where- untilAllDefined ds = do- done <- noLoneSigs- if done then return ([], ds) else- case ds of- [] -> __IMPOSSIBLE__ <$ checkLoneSigs- d : ds -> case declKind d of- LoneSig k x -> addLoneSig k x >> cons d (untilAllDefined ds)- LoneDef k x -> removeLoneSig k x >> cons d (untilAllDefined ds)- OtherDecl -> cons d (untilAllDefined ds)- where- cons d = fmap ((d :) *** id)-- nice :: [Declaration] -> Nice [NiceDeclaration]- nice [] = return []- nice (d:ds) = do- case d of- TypeSig rel x t -> do- fx <- getFixity x- -- register x as lone type signature, to recognize clauses later- addLoneSig FunName x- ds <- nice ds- return $ FunSig (getRange d) fx PublicAccess rel x t : ds- cl@(FunClause lhs _ _) -> do- xs <- gets $ map snd . filter ((== FunName) . fst) . loneSigs- -- for each type signature 'x' waiting for clauses, we try- -- if we have some clauses for 'x'- fixs <- gets fixs- case filter (\ (x,(fits,rest)) -> not $ null fits) $- map (\ x -> (x, span (couldBeFunClauseOf (Map.lookup x fixs) x) $ d : ds)) xs of- -- case: clauses match none of the sigs- -- treat it as a function clause without a type signature- [] -> case lhs of- LHS p [] _ _ | IdentP (QName x) <- removeSingletonRawAppP p -> do- ds <- nice ds- d <- mkFunDef Relevant x Nothing [cl] -- fun def without type signature is relevant- return $ d ++ ds- _ -> throwError $ MissingTypeSignature lhs- -- case: clauses match exactly one of the sigs- [(x,(fits,rest))] -> do- removeLoneSig FunName x- cs <- mkClauses x $ expandEllipsis fits- ds1 <- nice rest- fx <- getFixity x- d <- return $ FunDef (getRange fits) fits fx ConcreteDef x cs- return $ d : ds1- -- case: clauses match more than one sigs (ambiguity)- l -> throwError $ AmbiguousFunClauses lhs (map fst l) -- "ambiguous function clause; cannot assign it uniquely to one type signature"-- Field x t -> (++) <$> niceAxioms [ d ] <*> nice ds- DataSig r CoInductive x tel t -> throwError (Codata r)- Data r CoInductive x tel t cs -> throwError (Codata r)- DataSig r Inductive x tel t -> do- addLoneSig DataName x- (++) <$> dataOrRec DataDef NiceDataSig niceAxioms r x tel (Just t) Nothing- <*> nice ds- Data r Inductive x tel t cs -> do- t <- defaultTypeSig DataName x t- (++) <$> dataOrRec DataDef NiceDataSig niceAxioms r x tel t (Just cs)- <*> nice ds- RecordSig r x tel t -> do- addLoneSig RecName x- fx <- getFixity x- (NiceRecSig r fx PublicAccess x tel t :) <$> nice ds- Record r x c tel t cs -> do- t <- defaultTypeSig RecName x t- c <- traverse (\c -> ThingWithFixity c <$> getFixity c) c- (++) <$> dataOrRec (\x1 x2 x3 x4 -> RecDef x1 x2 x3 x4 c) NiceRecSig- niceDeclarations r x tel t (Just cs)- <*> nice ds- Mutual r ds' ->- (:) <$> (mkOldMutual r =<< nice ds') <*> nice ds-- Abstract r ds' ->- (++) <$> (abstractBlock r =<< nice ds') <*> nice ds-- Private r ds' ->- (++) <$> (privateBlock r =<< nice ds') <*> nice ds-- Postulate _ ds' -> (++) <$> niceAxioms ds' <*> nice ds-- Primitive _ ds' -> (++) <$> (map toPrim <$> niceAxioms ds') <*> nice ds-- Module r x tel ds' ->- (NiceModule r PublicAccess ConcreteDef x tel ds' :) <$> nice ds-- ModuleMacro r x modapp op is ->- (NiceModuleMacro r PublicAccess ConcreteDef x modapp op is :)- <$> nice ds-- Infix _ _ -> nice ds- Syntax _ _ -> nice ds- Open r x is -> (NiceOpen r x is :) <$> nice ds- Import r x as op is -> (NiceImport r x as op is :) <$> nice ds-- Pragma p -> (NicePragma (getRange p) p :) <$> nice ds-- -- We could add a default type signature here, but at the moment we can't- -- infer the type of a record or datatype, so better to just fail here.- defaultTypeSig k x t@Just{} = return t- defaultTypeSig k x Nothing =- ifM (hasSig k x)- (Nothing <$ removeLoneSig k x)- (throwError $ MissingDataSignature x)-- dataOrRec mkDef mkSig niceD r x tel mt mcs = do- mds <- traverse niceD mcs- f <- getFixity x- return $- [mkSig (fuseRange x t) f PublicAccess x tel t | Just t <- [mt] ] ++- [mkDef (getRange x) f ConcreteDef x (concatMap dropType tel) ds | Just ds <- [mds] ]- where- dropType (DomainFull (TypedBindings r (Arg h rel TNoBind{}))) =- [DomainFree h rel $ mkBoundName_ $ noName r]- dropType (DomainFull (TypedBindings r (Arg h rel (TBind _ xs _)))) =- map (DomainFree h rel) xs- dropType b@DomainFree{} = [b]-- -- Translate axioms- niceAxioms :: [TypeSignature] -> Nice [NiceDeclaration]- niceAxioms ds = mapM niceAxiom ds-- niceAxiom :: TypeSignature -> Nice NiceDeclaration- niceAxiom d@(TypeSig rel x t) = do- fx <- getFixity x- return $ Axiom (getRange d) fx PublicAccess rel x t- niceAxiom d@(Field x argt) = do- fx <- getFixity x- return $ NiceField (getRange d) fx PublicAccess ConcreteDef x argt- niceAxiom _ = __IMPOSSIBLE__-- toPrim :: NiceDeclaration -> NiceDeclaration- toPrim (Axiom r f a rel x t) = PrimitiveFunction r f a ConcreteDef x t- toPrim _ = __IMPOSSIBLE__-- -- Create a function definition.- mkFunDef rel x mt ds0 = do- cs <- mkClauses x $ expandEllipsis ds0- f <- getFixity x- return [ FunSig (fuseRange x t) f PublicAccess rel x t- , FunDef (getRange ds0) ds0 f ConcreteDef x cs ]- where- t = case mt of- Just t -> t- Nothing -> underscore (getRange x)-- underscore r = Underscore r Nothing--- expandEllipsis :: [Declaration] -> [Declaration]- expandEllipsis [] = []- expandEllipsis (d@(FunClause Ellipsis{} _ _) : ds) =- d : expandEllipsis ds- expandEllipsis (d@(FunClause lhs@(LHS p ps _ _) _ _) : ds) =- d : expand p ps ds- where- expand _ _ [] = []- expand p ps (FunClause (Ellipsis _ ps' eqs []) rhs wh : ds) =- FunClause (LHS p (ps ++ ps') eqs []) rhs wh : expand p ps ds- expand p ps (FunClause (Ellipsis _ ps' eqs es) rhs wh : ds) =- FunClause (LHS p (ps ++ ps') eqs es) rhs wh : expand p (ps ++ ps') ds- expand p ps (d@(FunClause (LHS _ _ _ []) _ _) : ds) =- d : expand p ps ds- expand _ _ (d@(FunClause (LHS p ps _ (_ : _)) _ _) : ds) =- d : expand p ps ds- expand _ _ (_ : ds) = __IMPOSSIBLE__- expandEllipsis (_ : ds) = __IMPOSSIBLE__--- -- Turn function clauses into nice function clauses.- mkClauses :: Name -> [Declaration] -> Nice [Clause]- mkClauses _ [] = return []- mkClauses x (FunClause lhs@(LHS _ _ _ []) rhs wh : cs) =- (Clause x lhs rhs wh [] :) <$> mkClauses x cs- mkClauses x (FunClause lhs@(LHS _ ps _ es) rhs wh : cs) = do- when (null with) $ throwError $ MissingWithClauses x- wcs <- mkClauses x with- (Clause x lhs rhs wh wcs :) <$> mkClauses x cs'- where- (with, cs') = span subClause cs-- -- A clause is a subclause if the number of with-patterns is- -- greater or equal to the current number of with-patterns plus the- -- number of with arguments.- subClause (FunClause (LHS _ ps' _ _) _ _) =- length ps' >= length ps + length es- subClause (FunClause (Ellipsis _ ps' _ _) _ _) = True- subClause _ = __IMPOSSIBLE__- mkClauses x (FunClause lhs@Ellipsis{} rhs wh : cs) =- (Clause x lhs rhs wh [] :) <$> mkClauses x cs -- Will result in an error later.- mkClauses _ _ = __IMPOSSIBLE__-- -- for finding clauses for a type sig in mutual blocks- couldBeFunClauseOf :: Maybe Fixity' -> Name -> Declaration -> Bool- couldBeFunClauseOf mFixity x (FunClause Ellipsis{} _ _) = True- couldBeFunClauseOf mFixity x (FunClause (LHS p _ _ _) _ _) =- let- pns = patternNames p- xStrings = nameStringParts x- patStrings = concatMap nameStringParts pns- in--- trace ("x = " ++ show x) $--- trace ("pns = " ++ show pns) $--- trace ("xStrings = " ++ show xStrings) $--- trace ("patStrings = " ++ show patStrings) $--- trace ("mFixity = " ++ show mFixity) $- case (mhead pns, mFixity) of- -- first identifier in the patterns is the fun.symbol?- (Just y, _) | x == y -> True -- trace ("couldBe since y = " ++ show y) $ True- -- are the parts of x contained in p- _ | xStrings `isSublistOf` patStrings -> True -- trace ("couldBe since isSublistOf") $ True- -- looking for a mixfix fun.symb- (_, Just fix) -> -- also matches in case of a postfix- let notStrings = stringParts (theNotation fix)- in -- trace ("notStrings = " ++ show notStrings) $- -- trace ("patStrings = " ++ show patStrings) $- (not $ null notStrings) && (notStrings `isSublistOf` patStrings)- -- not a notation, not first id: give up- _ -> False -- trace ("couldBe not (case default)") $ False- couldBeFunClauseOf _ _ _ = False -- trace ("couldBe not (fun default)") $ False-- -- @isFunClauseOf@ is for non-mutual blocks where clauses must follow the- -- type sig immediately- isFunClauseOf :: Name -> Declaration -> Bool- isFunClauseOf x (FunClause Ellipsis{} _ _) = True- isFunClauseOf x (FunClause (LHS p _ _ _) _ _) =- -- p is the whole left hand side, excluding "with" patterns and clauses- case removeSingletonRawAppP p of- IdentP (QName q) -> x == q- _ -> True- -- more complicated lhss must come with type signatures, so we just assume- -- it's part of the current definition- isFunClauseOf _ _ = False-- removeSingletonRawAppP :: Pattern -> Pattern- removeSingletonRawAppP (RawAppP _ [p]) = removeSingletonRawAppP p- removeSingletonRawAppP p = p-- -- Make an old style mutual block from a list of mutual declarations- mkOldMutual :: Range -> [NiceDeclaration] -> Nice NiceDeclaration- mkOldMutual r ds = do- -- Check that there aren't any missing definitions- case filter (`notElem` defNames) sigNames of- [] -> return ()- (_, x):_ -> throwError $ MissingDefinition x- -- Check that there are no declarations that aren't allowed in old style mutual blocks- case [ d | (d, OtherDecl) <- zip ds $ map declKind ds ] of- [] -> return ()- d:_ -> throwError $ NotAllowedInMutual d- return $ NiceMutual r $ sigs ++ other- where- -- Pull type signatures to the top- (sigs, other) = partition isTypeSig ds- isTypeSig d | LoneSig{} <- declKind d = True- isTypeSig _ = False-- sigNames = [ (k, x) | LoneSig k x <- map declKind ds ]- defNames = [ (k, x) | LoneDef k x <- map declKind ds ]-- abstractBlock _ [] = return []- abstractBlock r ds- -- hack to avoid failing on inherited abstract blocks in where clauses- | r == noRange = return $ map mkAbstract ds- | all uselessAbstract ds = throwError $ UselessAbstract r- | otherwise = return $ map mkAbstract ds-- uselessAbstract d = case d of- FunDef{} -> False- DataDef{} -> False- RecDef{} -> False- _ -> True-- privateBlock _ [] = return []- privateBlock r ds- | all uselessPrivate ds = throwError $ UselessPrivate r- | otherwise = return $ map mkPrivate ds-- uselessPrivate d = case d of- FunDef{} -> True- DataDef{} -> True- RecDef{} -> True- _ -> False-- -- Make a declaration abstract- mkAbstract d =- case d of- NiceField r f a _ x e -> NiceField r f a AbstractDef x e- PrimitiveFunction r f a _ x e -> PrimitiveFunction r f a AbstractDef x e- NiceMutual r ds -> NiceMutual r (map mkAbstract ds)- NiceModuleMacro r a _ x ma op is -> NiceModuleMacro r a AbstractDef x ma op is- FunDef r ds f _ x cs -> FunDef r ds f AbstractDef x (map mkAbstractClause cs)- DataDef r f _ x ps cs -> DataDef r f AbstractDef x ps $ map mkAbstract cs- RecDef r f _ x c ps cs -> RecDef r f AbstractDef x c ps $ map mkAbstract cs- NiceModule{} -> d- Axiom{} -> d- NicePragma{} -> d- NiceOpen{} -> d- NiceImport{} -> d- FunSig{} -> d- NiceRecSig{} -> d- NiceDataSig{} -> d-- mkAbstractClause (Clause x lhs rhs wh with) =- Clause x lhs rhs (mkAbstractWhere wh) (map mkAbstractClause with)-- mkAbstractWhere NoWhere = NoWhere- mkAbstractWhere (AnyWhere ds) = AnyWhere [Abstract noRange ds]- mkAbstractWhere (SomeWhere m ds) = SomeWhere m [Abstract noRange ds]-- -- Make a declaration private- mkPrivate d =- case d of- Axiom r f _ rel x e -> Axiom r f PrivateAccess rel x e- NiceField r f _ a x e -> NiceField r f PrivateAccess a x e- PrimitiveFunction r f _ a x e -> PrimitiveFunction r f PrivateAccess a x e- NiceMutual r ds -> NiceMutual r (map mkPrivate ds)- NiceModule r _ a x tel ds -> NiceModule r PrivateAccess a x tel ds- NiceModuleMacro r _ a x ma op is -> NiceModuleMacro r PrivateAccess a x ma op is- FunSig r f _ rel x e -> FunSig r f PrivateAccess rel x e- NiceRecSig r f _ x ls t -> NiceRecSig r f PrivateAccess x ls t- NiceDataSig r f _ x ls t -> NiceDataSig r f PrivateAccess x ls t- NicePragma _ _ -> d- NiceOpen _ _ _ -> d- NiceImport _ _ _ _ _ -> d- FunDef{} -> d- DataDef{} -> d- RecDef{} -> d-- mkPrivateClause (Clause x lhs rhs wh with) =- Clause x lhs rhs (mkPrivateWhere wh) (map mkPrivateClause with)-- mkPrivateWhere NoWhere = NoWhere- mkPrivateWhere (AnyWhere ds) = AnyWhere [Private (getRange ds) ds]- mkPrivateWhere (SomeWhere m ds) = SomeWhere m [Private (getRange ds) ds]---- | Add more fixities. Throw an exception for multiple fixity declarations.-plusFixities :: Map.Map Name Fixity' -> Map.Map Name Fixity' -> Nice (Map.Map Name Fixity')-plusFixities m1 m2- | not (null isect) = throwError $ MultipleFixityDecls isect- | otherwise = return $ Map.unionWithKey mergeFixites m1 m2- where mergeFixites name (Fixity' f1 s1) (Fixity' f2 s2) = Fixity' f s- where f | f1 == noFixity = f2- | f2 == noFixity = f1- | otherwise = __IMPOSSIBLE__- s | s1 == noNotation = s2- | s2 == noNotation = s1- | otherwise = __IMPOSSIBLE__- isect = [decls x | (x,compat) <- Map.assocs (Map.intersectionWith compatible m1 m2), not compat]-- decls x = (x, map (Map.findWithDefault __IMPOSSIBLE__ x) [m1,m2])- -- cpp doesn't know about primes- compatible (Fixity' f1 s1) (Fixity' f2 s2) = (f1 == noFixity || f2 == noFixity) &&- (s1 == noNotation || s2 == noNotation)---- | Get the fixities from the current block. Doesn't go inside /any/ blocks.--- The reason for this is that fixity declarations have to appear at the same--- level (or possibly outside an abstract or mutual block) as its target--- declaration.-fixities :: [Declaration] -> Nice (Map.Map Name Fixity')-fixities (d:ds) = case d of- Syntax x syn -> plusFixities (Map.singleton x (Fixity' noFixity syn)) =<< fixities ds- Infix f xs -> plusFixities (Map.fromList [ (x,Fixity' f noNotation) | x <- xs ]) =<< fixities ds- Mutual _ ds' -> fixities (ds' ++ ds)- Abstract _ ds' -> fixities (ds' ++ ds)- Private _ ds' -> fixities (ds' ++ ds)- _ -> fixities ds-fixities [] = return $ Map.empty--notSoNiceDeclarations :: [NiceDeclaration] -> [Declaration]-notSoNiceDeclarations = concatMap notNice- where- notNice d = case d of- Axiom _ _ _ rel x e -> [TypeSig rel x e]- NiceField _ _ _ _ x argt -> [Field x argt]- PrimitiveFunction r _ _ _ x e -> [Primitive r [TypeSig Relevant x e]]- NiceMutual _ ds -> concatMap notNice ds- NiceModule r _ _ x tel ds -> [Module r x tel ds]- NiceModuleMacro r _ _ x ma o dir -> [ModuleMacro r x ma o dir]- NiceOpen r x dir -> [Open r x dir]- NiceImport r x as o dir -> [Import r x as o dir]- NicePragma _ p -> [Pragma p]- NiceRecSig r _ _ x bs e -> [RecordSig r x bs e]- NiceDataSig r _ _ x bs e -> [DataSig r Inductive x bs e]- FunSig _ _ _ rel x e -> [TypeSig rel x e]- FunDef _ ds _ _ _ _ -> ds- DataDef r _ _ x bs cs -> [Data r Inductive x bs Nothing $ concatMap notNice cs]- RecDef r _ _ x c bs ds -> [Record r x (unThing <$> c) bs Nothing $ concatMap notNice ds]- where unThing (ThingWithFixity c _) = c+-- | Preprocess 'Agda.Syntax.Concrete.Declaration's, producing 'NiceDeclaration's.+--+-- * Attach fixity and syntax declarations to the definition they refer to.+--+-- * Distribute the following attributes to the individual definitions:+-- @abstract@,+-- @instance@,+-- @postulate@,+-- @primitive@,+-- @private@,+-- termination pragmas.+--+-- * Gather the function clauses belonging to one function definition.+--+-- * Expand ellipsis @...@ in function clauses following @with@.+--+-- * Infer mutual blocks.+-- A block starts when a lone signature is encountered, and ends when+-- all lone signatures have seen their definition.+--+-- * Handle interleaved mutual blocks.+-- In an `interleaved mutual' block we:+-- * leave the data and fun sigs in place+-- * classify signatures in `constructor' block based on their return type+-- and group them all as a data def at the position in the block where the+-- first constructor for the data sig in question occured+-- * classify fun clauses based on the declared function used and group them+-- all as a fundef at the position in the block where the first such fun+-- clause appeared+--+-- * Report basic well-formedness error,+-- when one of the above transformation fails.+-- When possible, errors should be deferred to the scope checking phase+-- (ConcreteToAbstract), where we are in the TCM and can produce more+-- informative error messages.++{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Syntax.Concrete.Definitions+ ( NiceDeclaration(..)+ , NiceConstructor, NiceTypeSignature+ , Clause(..)+ , DeclarationException(..)+ , DeclarationWarning(..), DeclarationWarning'(..), unsafeDeclarationWarning+ , Nice, NiceEnv(..), runNice+ , niceDeclarations+ , notSoNiceDeclarations+ , niceHasAbstract+ , Measure+ , declarationWarningName+ ) where+++import Prelude hiding (null)++import Control.Monad.Except ( )+import Control.Monad.Reader ( asks )+import Control.Monad.State ( MonadState(..), gets, runStateT )++import Data.Either ( isRight )+import Data.Foldable qualified as Fold+import Data.Function ( on )+import Data.List qualified as List+import Data.Map qualified as Map+import Data.Maybe+import Data.Semigroup ( sconcat )+import Data.Set qualified as Set+import Data.Text ( Text )++import Agda.Syntax.Common hiding (TerminationCheck())+import Agda.Syntax.Concrete+import Agda.Syntax.Concrete.Definitions.Errors+import Agda.Syntax.Concrete.Definitions.Monad+import Agda.Syntax.Concrete.Definitions.Types+import Agda.Syntax.Concrete.Fixity+import Agda.Syntax.Concrete.Pattern+import Agda.Syntax.Notation+import Agda.Syntax.Position++import Agda.Utils.AffineHole+import Agda.Utils.CallStack ( HasCallStack, withCallerCallStack )+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List ( spanJust )+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.Three+import Agda.Utils.Tuple+import Agda.Utils.Update++import Agda.Utils.Impossible++{--------------------------------------------------------------------------+ The niceifier+ --------------------------------------------------------------------------}++-- | Check that declarations in a mutual block are consistently+-- equipped with MEASURE pragmas, or whether there is a+-- NO_TERMINATION_CHECK pragma.+combineTerminationChecks :: Range -> [TerminationCheck] -> Nice TerminationCheck+combineTerminationChecks r = loop+ where+ loop :: [TerminationCheck] -> Nice TerminationCheck+ loop [] = return TerminationCheck+ loop (tc : tcs) = do+ tc' <- loop tcs+ case (tc, tc') of+ (TerminationCheck , tc' ) -> return tc'+ (tc , TerminationCheck ) -> return tc+ (NonTerminating , NonTerminating ) -> return NonTerminating+ (NoTerminationCheck , NoTerminationCheck ) -> return NoTerminationCheck+ (NoTerminationCheck , Terminating ) -> return Terminating+ (Terminating , NoTerminationCheck ) -> return Terminating+ (Terminating , Terminating ) -> return Terminating+ (TerminationMeasure{} , TerminationMeasure{} ) -> return tc+ (TerminationMeasure r _, NoTerminationCheck ) -> failure r+ (TerminationMeasure r _, Terminating ) -> failure r+ (NoTerminationCheck , TerminationMeasure r _) -> failure r+ (Terminating , TerminationMeasure r _) -> failure r+ (TerminationMeasure r _, NonTerminating ) -> failure r+ (NonTerminating , TerminationMeasure r _) -> failure r+ (NoTerminationCheck , NonTerminating ) -> failure r+ (Terminating , NonTerminating ) -> failure r+ (NonTerminating , NoTerminationCheck ) -> failure r+ (NonTerminating , Terminating ) -> failure r+ failure r = declarationException $ InvalidMeasureMutual r++combineCoverageChecks :: [CoverageCheck] -> CoverageCheck+combineCoverageChecks = Fold.fold++combinePositivityChecks :: [PositivityCheck] -> PositivityCheck+combinePositivityChecks = Fold.fold++data DeclKind+ = LoneSigDecl Range DataRecOrFun Name+ | LoneDefs DataRecOrFun [Name]+ | OtherDecl+ deriving (Eq, Show)++declKind :: NiceDeclaration -> DeclKind+declKind (FunSig r _ _ _ _ ai tc cc x _) = LoneSigDecl r (FunName ai tc cc) x+declKind (NiceRecSig r _ _ _ pc uc eta x _ _)= LoneSigDecl r (RecName pc uc eta) x+declKind (NiceDataSig r _ _ _ pc uc x _ _) = LoneSigDecl r (DataName pc uc) x+declKind (FunDef _r _ _ _ tc cc x (cl :| _)) = LoneDefs (FunName (getArgInfo cl) tc cc) [x]+declKind (NiceDataDef _ _ _ pc uc x _par _) = LoneDefs (DataName pc uc) [x]+declKind (NiceUnquoteData _ _ _ pc uc x _ _) = LoneDefs (DataName pc uc) [x]+declKind (NiceRecDef _ _ _ pc uc eta x _ _par _) = LoneDefs (RecName pc uc eta) [x]+declKind (NiceUnquoteDef _ _ _ tc cc xs _) = LoneDefs (FunName empty tc cc) xs+declKind Axiom{} = OtherDecl+declKind NiceField{} = OtherDecl+declKind PrimitiveFunction{} = OtherDecl+declKind NiceMutual{} = OtherDecl+declKind NiceModule{} = OtherDecl+declKind NiceModuleMacro{} = OtherDecl+declKind NiceOpen{} = OtherDecl+declKind NiceImport{} = OtherDecl+declKind NicePragma{} = OtherDecl+declKind NiceFunClause{} = OtherDecl+declKind NicePatternSyn{} = OtherDecl+declKind NiceGeneralize{} = OtherDecl+declKind NiceUnquoteDecl{} = OtherDecl+declKind NiceLoneConstructor{} = OtherDecl+declKind NiceOpaque{} = OtherDecl+++-- | Ensure that every signature got its definition.+-- Signatures ('FunSig', 'NiceDataSig', 'NiceRecSig'), that are /lone/,+-- i.e., did not get a definition,+-- are replaced by 'Axiom's so that the scope checker will not+-- look for accompanying definitions ('FunDef', 'NiceDataDef', 'NiceRecDef').+-- Throws also a 'MissingDefinitions' warning for the lone names.+turnLoneSignaturesIntoAxioms ::+ [NiceDeclaration]+ -- ^ Containing @(Data/Rec/Fun)Sigs@ for the lone signatures.+ -> LoneSigs+ -- ^ The signatures that are not accompanied by a definition.+ -> Nice [NiceDeclaration]+ -- ^ The indicated lone signatures have been replaced by @Axiom@s.+ -- Length and ordering of the declaration list are not affected.+turnLoneSignaturesIntoAxioms ds ps = do+ -- Clear the lone sigs in the state, throw a warning for @ps@.+ checkLoneSigs ps+ -- Replace in @ds@ as indicated by @ps@.+ return $ replaceSigs ps ds++-- | Replace @(Data/Rec/Fun)Sigs@ with @Axiom@s for postulated names.+-- The first argument is a list of axioms only.+replaceSigs+ :: LoneSigs -- ^ Lone signatures to be turned into Axioms.+ -> [NiceDeclaration] -- ^ Declarations containing them.+ -> [NiceDeclaration] -- ^ In the output, everything should be defined.+replaceSigs ps = if Map.null ps then id else \case+ [] -> __IMPOSSIBLE__+ (d:ds) ->+ case replaceable d of+ -- If declaration d of x is mentioned in the map of lone signatures then replace+ -- it with an axiom.+ Just (x, axiom)+ | (Just (LoneSig _ x' _), ps') <- Map.updateLookupWithKey (\ _ _ -> Nothing) x ps+ , getRange x == getRange x'+ -- Use the range as UID to ensure we do not replace the wrong signature.+ -- This could happen if the user wrote a duplicate definition.+ -> axiom : replaceSigs ps' ds+ _ -> d : replaceSigs ps ds++ where++ -- A @replaceable@ declaration is a signature. It has a name and we can make an+ -- @Axiom@ out of it.+ replaceable :: NiceDeclaration -> Maybe (Name, NiceDeclaration)+ replaceable = \case+ FunSig r acc abst inst _ argi _ _ x' e -> do+ -- #4881: Don't use the unique NameId for NoName lookups.+ let x = if isNoName x' then noName (nameRange x') else x'+ let ai = setOrigin Inserted argi+ Just (x, Axiom r acc abst inst ai x' e)+ NiceRecSig r erased acc abst _ _ _ x pars t -> retAx r erased acc abst x pars t+ NiceDataSig r erased acc abst _ _ x pars t -> retAx r erased acc abst x pars t+ _ -> Nothing+ where+ retAx r erased acc abst x pars t = do+ let e = Generalized $ makePi (parametersToTelescope r pars) t+ let ai = setOrigin Inserted (setQuantity (asQuantity erased) defaultArgInfo)+ return (x, Axiom r acc abst NotInstanceDef ai x e)++-- | Main. Fixities (or more precisely syntax declarations) are needed when+-- grouping function clauses.+niceDeclarations :: Fixities -> [Declaration] -> Nice [NiceDeclaration]+niceDeclarations fixs ds = do++ -- Run the nicifier in an initial environment. But keep the warnings.+ st <- get+ put $ initNiceState { niceWarn = niceWarn st }+ nds <- nice ds++ -- Check that every signature got its definition.+ -- We postulate the missing ones and insert them as @Axiom@s+ -- in place of the corresponding @FunSig@, @NiceDataSig@ or @NiceRecSig@.+ -- This ensures that their names will be in scope but the scope checker+ -- will not search for a corresponding definition (@FunDef@, @NiceDataDef@, @NiceRecDef@).+ -- We also throw a @MissingDefinitions@ warning.+ ds <- turnLoneSignaturesIntoAxioms nds =<< use loneSigs++ -- Note that loneSigs is ensured to be empty.+ -- (Important, since inferMutualBlocks also uses loneSigs state).+ res <- inferMutualBlocks ds++ -- Restore the old state, but keep the warnings.+ warns <- gets niceWarn+ put $ st { niceWarn = warns }+ return res++ where++ inferMutualBlocks :: [NiceDeclaration] -> Nice [NiceDeclaration]+ inferMutualBlocks [] = return []+ inferMutualBlocks (d : ds) =+ case declKind d of+ OtherDecl -> (d :) <$> inferMutualBlocks ds+ LoneDefs{} -> (d :) <$> inferMutualBlocks ds -- Andreas, 2017-10-09, issue #2576: report error in ConcreteToAbstract+ LoneSigDecl r k x -> do+ _ <- addLoneSig r x k+ InferredMutual checks nds0 ds1 <- untilAllDefined (mutualChecks k) ds+ -- If we still have lone signatures without any accompanying definition,+ -- we postulate the definition and substitute the axiom for the lone signature.+ ds0 <- List1.fromListSafe __IMPOSSIBLE__ <$> do+ turnLoneSignaturesIntoAxioms (d : nds0) =<< use loneSigs+ -- NB: don't forget the LoneSig that the block started with!+ -- We then keep processing the rest of the block+ tc <- combineTerminationChecks (getRange d) (mutualTermination checks)+ let cc = combineCoverageChecks (mutualCoverage checks)+ let pc = combinePositivityChecks (mutualPositivity checks)+ (NiceMutual empty tc cc pc ds0 :) <$> inferMutualBlocks ds1+ where+ untilAllDefined :: MutualChecks -> [NiceDeclaration] -> Nice InferredMutual+ untilAllDefined checks ds = do+ done <- noLoneSigs+ if done then return (InferredMutual checks [] ds) else+ case ds of+ [] -> return (InferredMutual checks [] ds)+ d : ds -> case declKind d of+ LoneSigDecl r k x -> do+ void $ addLoneSig r x k+ extendInferredBlock d <$> untilAllDefined (mutualChecks k <> checks) ds+ LoneDefs k xs -> do+ mapM_ removeLoneSig xs+ extendInferredBlock d <$> untilAllDefined (mutualChecks k <> checks) ds+ OtherDecl -> extendInferredBlock d <$> untilAllDefined checks ds++ nice :: [Declaration] -> Nice [NiceDeclaration]+ nice [] = return []+ nice ds = do+ (xs , ys) <- nice1 ds+ (xs ++) <$> nice ys++ nice1 :: [Declaration] -> Nice ([NiceDeclaration], [Declaration])+ nice1 [] = return ([], []) -- Andreas, 2017-09-16, issue #2759: no longer __IMPOSSIBLE__+ nice1 (d:ds) = do+ let justWarning :: HasCallStack => DeclarationWarning' -> Nice ([NiceDeclaration], [Declaration])+ justWarning w = do+ -- NOTE: This is the location of the invoker of justWarning, not here.+ withCallerCallStack $ declarationWarning' w+ nice1 ds++ case d of++ TypeSig info tac x t -> do+ dropTactic tac+ info <- dropRew info+ termCheck <- use terminationCheckPragma+ covCheck <- use coverageCheckPragma+ -- Andreas, 2020-09-28, issue #4950: take only range of identifier,+ -- since parser expands type signatures with several identifiers+ -- (like @x y z : A@) into several type signatures (with imprecise ranges).+ let r = getRange x+ -- register x as lone type signature, to recognize clauses later+ x' <- addLoneSig r x $ FunName info termCheck covCheck+ return ([FunSig r PublicAccess ConcreteDef NotInstanceDef NotMacroDef info termCheck covCheck x' t] , ds)++ -- Should not show up: all FieldSig are part of a Field block+ FieldSig{} -> __IMPOSSIBLE__++ Generalize r [] -> justWarning $ EmptyGeneralize r+ Generalize _ sigs -> do+ gs <- forM sigs $ \case+ sig@(TypeSig info tac x t) -> do+ -- Andreas, 2022-03-25, issue #5850:+ -- Warn about @variable {x} : A@ which is equivalent to @variable x : A@.+ when (getHiding info == Hidden) $+ declarationWarning $ HiddenGeneralize $ getRange x+ -- Generalised variables cannot be local rewrite rules+ info <- dropRew info+ return $ NiceGeneralize (getRange sig) PublicAccess info tac x t+ _ -> __IMPOSSIBLE__+ return (gs, ds)++ FunClause ai lhs _ _ _ -> do+ termCheck <- use terminationCheckPragma+ covCheck <- use coverageCheckPragma+ catchall <- popCatchallPragma+ xs <- loneFuns <$> use loneSigs+ -- for each type signature 'x' waiting for clauses, we try+ -- if we have some clauses for 'x'+ case [ (x, (x', fits, rest))+ | (x, x') <- xs+ , let (fits0, rest) =+ -- Anonymous declarations only have 1 clause each!+ if isNoName x then ([d], ds)+ else span (couldBeFunClauseOf (Map.lookup x fixs) x) (d : ds)+ , fits <- maybeToList $ List1.nonEmpty fits0+ ] of++ -- case: clauses match none of the sigs+ [] -> case lhs of+ -- Subcase: The lhs is single identifier (potentially anonymous).+ -- Treat it as a function clause without a type signature.+ LHS p [] [] | Just x <- isSingleIdentifierP p -> do+ d <- mkFunDef (setOrigin Inserted ai) termCheck covCheck x Nothing $ singleton d -- fun def without type signature can have modality+ return (d , ds)+ -- Subcase: The lhs is a proper pattern.+ -- This could be a let-pattern binding. Pass it on.+ -- A missing type signature error might be raised in ConcreteToAbstract+ _ -> do+ return ([NiceFunClause (getRange d) PublicAccess ConcreteDef termCheck covCheck catchall d] , ds)++ -- case: clauses match exactly one of the sigs+ [(x, (Arg info x', fits, rest))] -> do+ -- The x'@NoName{} is the unique version of x@NoName{}.+ removeLoneSig x+ ds <- expandEllipsis1 fits+ cs <- mkClauses1 info x' ds empty+ return ([FunDef (getRange fits) fits ConcreteDef NotInstanceDef termCheck covCheck x' cs] , rest)++ -- case: clauses match more than one sigs (ambiguity)+ xf:xfs -> declarationException $ AmbiguousFunClauses lhs $ List1.reverse $ fmap fst $ xf :| xfs+ -- "ambiguous function clause; cannot assign it uniquely to one type signature"++ Field r [] -> justWarning $ EmptyField r+ Field _ fs -> (,ds) <$> do+ forM fs \case+ d@(FieldSig i tac x argt) -> pure $ NiceField (getRange d) PublicAccess ConcreteDef i tac x argt+ d -> declarationException $ WrongContentBlock FieldBlock $ getRange d++ DataSig r erased x tel t -> do+ pc <- use positivityCheckPragma+ uc <- use universeCheckPragma+ _ <- addLoneSig r x $ DataName pc uc+ (,ds) <$> dataOrRec pc uc empty+ (\ r o a pc uc _eta x tel cs -> NiceDataDef r o a pc uc x tel cs)+ (\ r p a pc uc _eta x tel t -> NiceDataSig r erased p a pc uc x tel t)+ (niceAxioms DataBlock) r+ x (Just (tel, t)) Nothing++ Data r erased x tel t cs -> do+ pc <- use positivityCheckPragma+ uc <- use universeCheckPragma+ (,ds) <$> dataOrRec pc uc empty+ (\ r o a pc uc _eta x tel cs -> NiceDataDef r o a pc uc x tel cs)+ (\ r p a pc uc _eta x tel t -> NiceDataSig r erased p a pc uc x tel t)+ (niceAxioms DataBlock) r+ x (Just (tel, t)) (Just (parametersToDefParameters tel, cs))++ DataDef r x tel cs -> do+ pc <- use positivityCheckPragma+ -- Andreas, 2018-10-27, issue #3327+ -- Propagate {-# NO_UNIVERSE_CHECK #-} pragma from signature to definition.+ -- Universe check is performed if both the current value of+ -- 'universeCheckPragma' AND the one from the signature say so.+ uc <- use universeCheckPragma+ (pc, uc) <- retrieveTypeSig (DataName pc uc) x >>= \case+ DataName pc uc -> pure (pc, uc)+ _ -> __IMPOSSIBLE__+ defpars <- niceDefParameters IsData tel+ (,ds) <$> dataOrRec pc uc empty+ (\ r o a pc uc _eta x tel cs -> NiceDataDef r o a pc uc x tel cs)+ (\ r p a pc uc _eta x tel t -> NiceDataSig r defaultErased p a pc uc x tel t)+ (niceAxioms DataBlock) r+ x Nothing (Just (defpars, cs))++ RecordSig r erased x tel t -> do+ pc <- use positivityCheckPragma+ uc <- use universeCheckPragma+ eta <- use etaEqualityPragma+ _ <- addLoneSig r x $ RecName pc uc eta+ return ( [NiceRecSig r erased PublicAccess ConcreteDef pc uc eta x+ tel t]+ , ds+ )++ Record r erased x dir tel t cs -> do+ pc <- use positivityCheckPragma+ uc <- use universeCheckPragma+ eta <- use etaEqualityPragma+ (,ds) <$> dataOrRec pc uc eta+ (\r o a pc uc eta x tel cs ->+ NiceRecDef r o a pc uc eta x dir tel cs)+ (flip NiceRecSig erased) return r x+ (Just (tel, t)) (Just (parametersToDefParameters tel, cs))++ RecordDef r x dir tel cs -> do+ pc <- use positivityCheckPragma+ -- Andreas, 2018-10-27, issue #3327+ -- Propagate {-# NO_UNIVERSE_CHECK #-} pragma from signature to definition.+ -- Universe check is performed if both the current value of+ -- 'universeCheckPragma' AND the one from the signature say so.+ uc <- use universeCheckPragma+ eta <- use etaEqualityPragma+ (pc, uc, eta) <- retrieveTypeSig (RecName pc uc eta) x >>= \case+ RecName pc uc eta -> pure (pc, uc, eta)+ _ -> __IMPOSSIBLE__+ defpars <- niceDefParameters (IsRecord ()) tel+ (,ds) <$> dataOrRec pc uc eta+ (\r o a pc uc eta x tel cs ->+ NiceRecDef r o a pc uc eta x dir tel cs)+ (flip NiceRecSig defaultErased) return r x+ Nothing (Just (defpars, cs))++ Mutual r ds' -> do+ -- The lone signatures encountered so far are not in scope+ -- for the mutual definition+ breakImplicitMutualBlock r "`mutual` blocks"+ case ds' of+ [] -> justWarning $ EmptyMutual r+ _ -> (,ds) . maybeToList <$> (mkOldMutual r =<< nice ds')++ InterleavedMutual r ds' -> do+ -- The lone signatures encountered so far are not in scope+ -- for the mutual definition+ breakImplicitMutualBlock r "`interleaved mutual` blocks"+ case ds' of+ [] -> justWarning $ EmptyMutual r+ _ -> (,ds) . maybeToList <$> (mkInterleavedMutual r =<< nice ds')++ Abstract r [] -> justWarning $ EmptyAbstract r+ Abstract r ds' ->+ (,ds) <$> (abstractBlock r =<< nice ds')++ Private r UserWritten [] -> justWarning $ EmptyPrivate r+ Private r o ds' ->+ (,ds) <$> (privateBlock r o =<< nice ds')++ InstanceB r [] -> justWarning $ EmptyInstance r+ InstanceB r ds' ->+ (,ds) <$> (instanceBlock r =<< nice ds')++ Macro r [] -> justWarning $ EmptyMacro r+ Macro r ds' ->+ (,ds) <$> (macroBlock r =<< nice ds')++ LoneConstructor r ds' -> (,ds) <$> do+ constructorBlock r =<< niceAxioms ConstructorBlock ds'++ Postulate r ds' -> (,ds) <$> do+ postulateBlock r =<< niceAxioms PostulateBlock ds'++ Primitive r ds' -> (,ds) <$> do+ primitiveBlock r =<< niceAxioms PrimitiveBlock ds'++ Module r erased x tel ds' -> return $+ ([NiceModule r PublicAccess ConcreteDef erased x tel ds'], ds)++ ModuleMacro r erased x modapp op is -> return $+ ([NiceModuleMacro r PublicAccess erased x modapp op is], ds)++ -- Fixity and syntax declarations and polarity pragmas have+ -- already been processed.+ Infix _ _ -> return ([], ds)+ Syntax _ _ -> return ([], ds)++ PatternSyn r n as p -> do+ return ([NicePatternSyn r PublicAccess n as p] , ds)+ Open kwr x is -> return ([NiceOpen kwr x is] , ds)+ Import opn r x as is-> return ([NiceImport opn r x as is], ds)++ UnquoteDecl r xs e -> do+ tc <- use terminationCheckPragma+ cc <- use coverageCheckPragma+ return ([NiceUnquoteDecl r PublicAccess ConcreteDef NotInstanceDef tc cc xs e] , ds)++ UnquoteDef r xs e -> do+ sigs <- map fst . loneFuns <$> use loneSigs+ List1.ifNotNull (filter (`notElem` sigs) xs)+ {-then-} (declarationException . UnquoteDefRequiresSignature)+ {-else-} $ do+ mapM_ removeLoneSig xs+ return ([NiceUnquoteDef r PublicAccess ConcreteDef TerminationCheck YesCoverageCheck xs e] , ds)++ UnquoteData r xs cs e -> do+ pc <- use positivityCheckPragma+ uc <- use universeCheckPragma+ return ([NiceUnquoteData r PublicAccess ConcreteDef pc uc xs cs e], ds)++ Pragma p -> do+ -- Warn about unsafe pragmas unless we are in a builtin module.+ whenM (asks safeButNotBuiltin) $+ whenJust (unsafePragma p) $ \ w ->+ declarationWarning w+ nicePragma p ds++ Opaque r ds' -> do+ breakImplicitMutualBlock r "`opaque` blocks"++ -- Split the enclosed declarations into an initial run of+ -- 'unfolding' statements and the rest of the body.+ let+ (unfoldings, body) = flip spanMaybe ds' $ \case+ Unfolding _ ns -> pure ns+ _ -> Nothing++ -- The body of an 'opaque' definition can have mutual+ -- recursion by interleaving type signatures and definitions,+ -- just like the body of a module.+ decls0 <- nice body+ decls <- turnLoneSignaturesIntoAxioms decls0 =<< use loneSigs+ body <- inferMutualBlocks decls+ pure ([NiceOpaque r (concat unfoldings) body], ds)++ Unfolding r _ -> declarationException $ UnfoldingOutsideOpaque r++ -- Some pragmas attach to the following declarations,+ -- handle this situation here.++ nicePragma :: Pragma -> [Declaration] -> Nice ([NiceDeclaration], [Declaration])+ nicePragma p ds = case p of++ TerminationCheckPragma r NoTerminationCheck -> do+ -- This PRAGMA has been deprecated in favour of (NON_)TERMINATING+ -- We warn the user about it and then assume the function is NON_TERMINATING.+ declarationWarning $ PragmaNoTerminationCheck r+ nicePragma (TerminationCheckPragma r NonTerminating) ds++ TerminationCheckPragma r (TerminationMeasure _ x) ->+ if canHaveTerminationMeasure ds then+ withTerminationCheckPragma (TerminationMeasure r x) $ nice1 ds+ else do+ declarationWarning $ InvalidTerminationCheckPragma r+ nice1 ds++ TerminationCheckPragma r tc ->+ if canHaveTerminationCheckPragma ds then+ withTerminationCheckPragma tc $ nice1 ds+ else do+ declarationWarning $ InvalidTerminationCheckPragma r+ nice1 ds++ NoCoverageCheckPragma r ->+ if canHaveCoverageCheckPragma ds then+ withCoverageCheckPragma NoCoverageCheck $ nice1 ds+ else do+ declarationWarning $ InvalidCoverageCheckPragma r+ nice1 ds++ CatchallPragma r ->+ if canHaveCatchallPragma ds then+ withCatchallPragma (YesCatchall r) $ nice1 ds+ else do+ declarationWarning $ InvalidCatchallPragma r+ nice1 ds++ NoPositivityCheckPragma r ->+ if canHaveNoPositivityCheckPragma ds then+ withPositivityCheckPragma NoPositivityCheck $ nice1 ds+ else do+ declarationWarning $ InvalidNoPositivityCheckPragma r+ nice1 ds++ NoUniverseCheckPragma r ->+ if canHaveNoUniverseCheckPragma ds then+ withUniverseCheckPragma NoUniverseCheck $ nice1 ds+ else do+ declarationWarning $ InvalidNoUniverseCheckPragma r+ nice1 ds++ EtaEqualityPragma r ->+ if canHaveEtaEqualityPragma ds then+ withEtaEqualityPragma YesForceRecordEta $ nice1 ds+ else do+ declarationWarning $ InvalidEtaEqualityPragma r+ nice1 ds++ -- Polarity pragmas have been handled with fixity declarations, can be deleted.+ PolarityPragma{} -> return ([], ds)++ -- The other pragmas are less context-sensitive, so nothing to do:+ BuiltinPragma{} -> keep+ CompilePragma{} -> keep+ DisplayPragma{} -> keep+ EtaPragma{} -> keep+ ForeignPragma{} -> keep+ ImpossiblePragma{} -> keep+ InjectiveForInferencePragma{} -> keep+ InjectivePragma{} -> keep+ InlinePragma{} -> keep+ NotProjectionLikePragma{} -> keep+ OptionsPragma{} -> keep+ OverlapPragma{} -> keep+ RewritePragma{} -> keep+ StaticPragma{} -> keep+ WarningOnImport{} -> keep+ WarningOnUsage{} -> keep++ where keep = return ([NicePragma (getRange p) p], ds)++ canHaveTerminationMeasure :: [Declaration] -> Bool+ canHaveTerminationMeasure [] = False+ canHaveTerminationMeasure (d:ds) = case d of+ TypeSig{} -> True+ (Pragma p) | isAttachedPragma p -> canHaveTerminationMeasure ds+ _ -> False++ canHaveTerminationCheckPragma :: [Declaration] -> Bool+ canHaveTerminationCheckPragma [] = False+ canHaveTerminationCheckPragma (d:ds) = case d of+ Mutual _ ds -> any (canHaveTerminationCheckPragma . singleton) ds+ TypeSig{} -> True+ FunClause{} -> True+ UnquoteDecl{} -> True+ (Pragma p) | isAttachedPragma p -> canHaveTerminationCheckPragma ds+ _ -> False++ canHaveCoverageCheckPragma :: [Declaration] -> Bool+ canHaveCoverageCheckPragma = canHaveTerminationCheckPragma++ canHaveCatchallPragma :: [Declaration] -> Bool+ canHaveCatchallPragma [] = False+ canHaveCatchallPragma (d:ds) = case d of+ FunClause{} -> True+ (Pragma p) | isAttachedPragma p -> canHaveCatchallPragma ds+ _ -> False++ canHaveNoPositivityCheckPragma :: [Declaration] -> Bool+ canHaveNoPositivityCheckPragma [] = False+ canHaveNoPositivityCheckPragma (d:ds) = case d of+ Mutual _ ds -> any (canHaveNoPositivityCheckPragma . singleton) ds+ Data{} -> True+ DataSig{} -> True+ DataDef{} -> True+ Record{} -> True+ RecordSig{} -> True+ RecordDef{} -> True+ Pragma p | isAttachedPragma p -> canHaveNoPositivityCheckPragma ds+ _ -> False++ canHaveNoUniverseCheckPragma :: [Declaration] -> Bool+ canHaveNoUniverseCheckPragma [] = False+ canHaveNoUniverseCheckPragma (d:ds) = case d of+ Data{} -> True+ DataSig{} -> True+ DataDef{} -> True+ Record{} -> True+ RecordSig{} -> True+ RecordDef{} -> True+ Pragma p | isAttachedPragma p -> canHaveNoUniverseCheckPragma ds+ _ -> False++ canHaveEtaEqualityPragma :: [Declaration] -> Bool+ canHaveEtaEqualityPragma [] = False+ canHaveEtaEqualityPragma (d:ds) = case d of+ Record{} -> True+ RecordSig{} -> True+ RecordDef{} -> True+ Pragma p | isAttachedPragma p -> canHaveEtaEqualityPragma ds+ _ -> False++ -- Pragma that attaches to the following declaration.+ isAttachedPragma :: Pragma -> Bool+ isAttachedPragma = \case+ TerminationCheckPragma{} -> True+ CatchallPragma{} -> True+ NoPositivityCheckPragma{} -> True+ NoUniverseCheckPragma{} -> True+ EtaEqualityPragma{} -> True+ _ -> False++ -- Remove the data or record type signature,+ -- using its positivity check / universe check information+ -- to refine the given one.+ retrieveTypeSig :: DataRecOrFun -> Name -> Nice DataRecOrFun+ retrieveTypeSig k x = do+ caseMaybeM (getSig x) (return k) $ \ k' -> do+ removeLoneSig x+ case mergeDataRecOrFun k k' of+ Just k -> return k+ Nothing -> declarationException $ WrongDefinition x k' k++ dataOrRec :: forall a decl.+ PositivityCheck+ -> UniverseCheck+ -> ForceRecordEta+ -> (Range -> Origin -> IsAbstract -> PositivityCheck -> UniverseCheck -> ForceRecordEta -> Name -> DefParameters -> [decl] -> NiceDeclaration)+ -- Construct definition.+ -> (Range -> Access -> IsAbstract -> PositivityCheck -> UniverseCheck -> ForceRecordEta -> Name -> Parameters -> Expr -> NiceDeclaration)+ -- Construct signature.+ -> ([a] -> Nice [decl]) -- Constructor checking.+ -> Range+ -> Name -- Data/record type name.+ -> Maybe (Parameters, Expr) -- Parameters and type. If not @Nothing@ a signature is created.+ -> Maybe (DefParameters, [a]) -- Parameters and constructors. If not @Nothing@, a definition body is created.+ -> Nice [NiceDeclaration]+ dataOrRec pc uc eta mkDef mkSig niceD r x mt mcs = do+ mds <- mapM (secondM niceD) mcs+ -- We set origin to UserWritten if the user split the data/rec herself,+ -- and to Inserted if the she wrote a single declaration that we're+ -- splitting up here. We distinguish these because the scoping rules for+ -- generalizable variables differ in these cases.+ let o | isJust mt && isJust mcs = Inserted+ | otherwise = UserWritten+ return $ catMaybes $+ [ mt <&> \ (tel, t) -> mkSig (fuseRange x t) PublicAccess ConcreteDef pc uc eta x tel t+ , mds <&> \ (tel, ds) -> mkDef r o ConcreteDef pc uc eta x tel ds+ -- If a type is given (mt /= Nothing), we have to delete the types in @tel@+ -- for the data definition, lest we duplicate them. And also drop modalities (#1886).+ ]++ -- Translate axioms+ niceAxioms :: KindOfBlock -> [TypeSignatureOrInstanceBlock] -> Nice [NiceDeclaration]+ niceAxioms b ds = List.concat <$> mapM niceAxiom ds+ where+ niceAxiom :: TypeSignatureOrInstanceBlock -> Nice [NiceDeclaration]+ niceAxiom = \case+ d@(TypeSig rel tac x t) -> do+ dropTactic tac+ rel <- dropRew rel+ return [ Axiom (getRange d) PublicAccess ConcreteDef NotInstanceDef rel x t ]+ -- @instance@ and @private@ blocks mix well with other blocks.+ InstanceB r ds -> instanceBlock r =<< niceAxioms b ds+ Private r o ds | privateAllowed -> privateBlock r o =<< niceAxioms b ds+ -- @data _ where@, @postulate@ and @primitive@ blocks exclude each other.+ Pragma p@(RewritePragma r _ _) -> return [ NicePragma r p ]+ Pragma p@(OverlapPragma r _ _) -> return [ NicePragma r p ]+ d -> declarationException $ WrongContentBlock b $ getRange d+ -- @private@ is not allowed for constructors.+ privateAllowed :: Bool+ privateAllowed = case b of+ PrimitiveBlock -> True+ PostulateBlock -> True+ DataBlock -> False+ ConstructorBlock -> False+ -- We do not handle @field@ blocks here.+ FieldBlock -> __IMPOSSIBLE__++ constructorBlock :: KwRange -> [NiceDeclaration] -> Nice [NiceDeclaration]+ constructorBlock r [] = [] <$ declarationWarning (EmptyConstructor r)+ constructorBlock r ds = return $ singleton $ NiceLoneConstructor r ds++ postulateBlock :: KwRange -> [NiceDeclaration] -> Nice [NiceDeclaration]+ postulateBlock r [] = [] <$ declarationWarning (EmptyPostulate r)+ postulateBlock _ ds = return ds++ primitiveBlock :: KwRange -> [NiceDeclaration] -> Nice [NiceDeclaration]+ primitiveBlock r [] = [] <$ declarationWarning (EmptyPrimitive r)+ primitiveBlock _ ds = mapM toPrim ds++ toPrim :: NiceDeclaration -> Nice NiceDeclaration+ toPrim (Axiom r p a inst rel x t) = do+ case inst of+ InstanceDef r -> declarationWarning $ UselessInstance r+ NotInstanceDef -> pure ()+ return $ PrimitiveFunction r p a x (Arg rel t)+ toPrim _ = __IMPOSSIBLE__++ -- Create a function definition.+ mkFunDef ::+ ArgInfo+ -> TerminationCheck+ -> CoverageCheck+ -> Name+ -> Maybe Expr+ -> List1 Declaration+ -> Nice [NiceDeclaration]+ mkFunDef info termCheck covCheck x mt ds0 = do+ ds <- expandEllipsis1 ds0+ cs <- mkClauses1 info x ds empty+ return [ FunSig (fuseRange x t) PublicAccess ConcreteDef NotInstanceDef NotMacroDef info termCheck covCheck x t+ , FunDef (getRange ds0) ds0 ConcreteDef NotInstanceDef termCheck covCheck x cs ]+ where+ t = fromMaybe (underscore (getRange x)) mt++ underscore r = Underscore r Nothing++ -- Search for the first clause that does not have an ellipsis (usually the very first one)+ -- and then use its lhs pattern to replace ellipses in the subsequent clauses (if any).+ expandEllipsis :: [Declaration] -> Nice [Declaration]+ expandEllipsis [] = return []+ expandEllipsis (d : ds) = List1.toList <$> expandEllipsis1 (d :| ds)++ expandEllipsis1 :: List1 Declaration -> Nice (List1 Declaration)+ expandEllipsis1 (d@(FunClause _ (LHS p _ _) _ _ _) :| ds)+ | hasEllipsis p = (d :|) <$> expandEllipsis ds+ | otherwise = (d :|) <$> expand (killRange p) ds+ where+ expand :: Pattern -> [Declaration] -> Nice [Declaration]+ expand _ [] = return []+ expand p (d : ds) = do+ case d of+ Pragma (CatchallPragma _) -> do+ (d :) <$> expand p ds+ FunClause ai (LHS p0 eqs es) rhs wh ca -> do+ case hasEllipsis' p0 of+ ManyHoles -> declarationException $ MultipleEllipses p0+ OneHole cxt ~(EllipsisP r Nothing) -> do+ -- Replace the ellipsis by @p@.+ let p1 = cxt $ EllipsisP r $ Just $ setRange r p+ let d' = FunClause ai (LHS p1 eqs es) rhs wh ca+ -- If we have with-expressions (es /= []) then the following+ -- ellipses also get the additional patterns in p0.+ (d' :) <$> expand (if null es then p else killRange p1) ds+ ZeroHoles _ -> do+ -- We can have ellipses after a fun clause without.+ -- They refer to the last clause that introduced new with-expressions.+ -- Same here: If we have new with-expressions, the next ellipses will+ -- refer to us.+ -- Andreas, Jesper, 2017-05-13, issue #2578+ -- Need to update the range also on the next with-patterns.+ (d :) <$> expand (if null es then p else killRange p0) ds+ _ -> __IMPOSSIBLE__+ expandEllipsis1 _ = __IMPOSSIBLE__++ -- Turn function clauses into nice function clauses.+ mkClauses1 ::+ ArgInfo+ -- Clauses need to conform to this 'Modality'.+ -> Name -> List1 Declaration -> Catchall -> Nice (List1 Clause)+ mkClauses1 info x ds ca = List1.fromListSafe __IMPOSSIBLE__ <$> mkClauses info x (List1.toList ds) ca++ mkClauses ::+ ArgInfo+ -- Clauses need to conform to this 'Modality'.+ -> Name -> [Declaration] -> Catchall -> Nice [Clause]+ mkClauses _ _ [] _ = return []++ -- A CATCHALL pragma after the last clause is useless.+ mkClauses _ _ [Pragma (CatchallPragma r)] _ = [] <$ do+ declarationWarning $ InvalidCatchallPragma r++ mkClauses info x (Pragma (CatchallPragma r) : cs) catchall = do+ -- Warn about consecutive CATCHALL pragmas+ unless (null catchall) $ declarationWarning $ InvalidCatchallPragma r+ mkClauses info x cs (YesCatchall r)++ mkClauses info x (FunClause ai lhs rhs wh ca : cs) catchall+ | null (lhsWithExpr lhs) || hasEllipsis lhs = do+ ai <- checkModality info ai+ (Clause x (ca <> catchall) ai lhs rhs wh [] :) <$> mkClauses info x cs empty++ mkClauses info x (FunClause ai lhs rhs wh ca : cs) catchall = do+ ai <- checkModality info ai+ when (null withClauses) $ declarationException $ MissingWithClauses x lhs+ wcs <- mkClauses info x withClauses empty+ (Clause x (ca <> catchall) ai lhs rhs wh wcs :) <$> mkClauses info x cs' empty+ where+ (withClauses, cs') = subClauses cs++ -- A clause is a subclause if the number of with-patterns is+ -- greater or equal to the current number of with-patterns plus the+ -- number of with arguments.+ numWith = numberOfWithPatterns p + length (filter visible es)+ where LHS p _ es = lhs++ subClauses :: [Declaration] -> ([Declaration],[Declaration])+ subClauses (c@(FunClause _ (LHS p0 _ _) _ _ _) : cs)+ | isEllipsis p0 ||+ numberOfWithPatterns p0 >= numWith = first (c:) (subClauses cs)+ | otherwise = ([], c:cs)+ subClauses (c@(Pragma (CatchallPragma _r)) : cs) = case subClauses cs of+ ([], cs') -> ([], c:cs')+ (cs, cs') -> (c:cs, cs')+ subClauses [] = ([],[])+ subClauses _ = __IMPOSSIBLE__+ mkClauses _ _ _ _ = __IMPOSSIBLE__++ checkModality ::+ ArgInfo -- Authoritative 'Modality' from type signature.+ -> ArgInfo -- 'Modality' from clause, has to conform.+ -> Nice ArgInfo -- Deviant 'Modality' conformed to authoritative source.+ checkModality info ai+ | (null ai || sameModality info ai) = return ai+ | otherwise = info <$ declarationWarning (DivergentModalityInClause info ai)++ couldBeCallOf :: Maybe Fixity' -> Name -> Pattern -> Bool+ couldBeCallOf mFixity x p =+ let+ pns = patternQNames p+ xStrings = nameStringParts x+ patStrings = concatMap nameStringParts $ mapMaybe isUnqualified pns+ in+-- trace ("x = " ++ prettyShow x) $+-- trace ("pns = " ++ show pns) $+-- trace ("xStrings = " ++ show xStrings) $+-- trace ("patStrings = " ++ show patStrings) $+-- trace ("mFixity = " ++ show mFixity) $+ case (listToMaybe pns, mFixity) of+ -- first identifier in the patterns is the fun.symbol?+ (Just y, _) | Just x == isUnqualified y -> True -- trace ("couldBe since y = " ++ prettyShow y) $ True+ -- are the parts of x contained in p+ _ | xStrings `List.isSubsequenceOf` patStrings -> True+ -- looking for a mixfix fun.symb+ (_, Just fix) -> -- also matches in case of a postfix+ let notStrings = stringParts (theNotation fix)+ in -- trace ("notStrings = " ++ show notStrings) $+ -- trace ("patStrings = " ++ show patStrings) $+ not (null notStrings) && (notStrings `List.isSubsequenceOf` patStrings)+ -- not a notation, not first id: give up+ _ -> False -- trace ("couldBe not (case default)") $ False+++ -- for finding nice clauses for a type sig in mutual blocks+ couldBeNiceFunClauseOf :: Maybe Fixity' -> Name -> NiceDeclaration+ -> Maybe (MutualChecks, Declaration)+ couldBeNiceFunClauseOf mf n (NiceFunClause _ _ _ tc cc _ d)+ = (MutualChecks [tc] [cc] [], d) <$ guard (couldBeFunClauseOf mf n d)+ couldBeNiceFunClauseOf _ _ _ = Nothing++ -- for finding clauses for a type sig in mutual blocks+ couldBeFunClauseOf :: Maybe Fixity' -> Name -> Declaration -> Bool+ couldBeFunClauseOf _ _ (Pragma (CatchallPragma{})) = True+ couldBeFunClauseOf mFixity x (FunClause _ (LHS p _ _) _ _ _) =+ hasEllipsis p || couldBeCallOf mFixity x p+ couldBeFunClauseOf _ _ _ = False -- trace ("couldBe not (fun default)") $ False++ -- Turn a new style `interleaved mutual' block into a new style mutual block+ -- by grouping the declarations in blocks.+ mkInterleavedMutual+ :: KwRange -- Range of the @interleaved mutual@ keywords.+ -> [NiceDeclaration] -- Declarations inside the block.+ -> Nice (Maybe NiceDeclaration) -- Returns a 'NiceMutual' unless empty.+ mkInterleavedMutual kwr ds' = do+ (other, ISt m checks _) <- runStateT (groupByBlocks kwr ds') $ ISt empty mempty 0+ idecls <- (other ++) . concat <$> mapM (uncurry interleavedDecl) (Map.toList m)+ let decls0 = map snd $ List.sortBy (compare `on` fst) idecls+ decls <- turnLoneSignaturesIntoAxioms decls0 =<< use loneSigs+ -- process the checks+ let r = fuseRange kwr ds'+ tc <- combineTerminationChecks r (mutualTermination checks)+ let cc = combineCoverageChecks (mutualCoverage checks)+ let pc = combinePositivityChecks (mutualPositivity checks)+ return $ fmap (NiceMutual kwr tc cc pc) $ List1.nonEmpty decls++ where++ ------------------------------------------------------------------------------+ -- Adding Signatures+ addType :: Name -> (DeclNum -> InterleavedDecl) -> MutualChecks -> INice ()+ addType n c mc = do+ ISt m checks i <- get+ whenJust (Map.lookup n m) \ y -> lift $ declarationException $ DuplicateDefinition n $ getRange y+ put $ ISt (Map.insert n (c i) m) (mc <> checks) (i + 1)++ addFunType d@(FunSig _ _ _ _ _ _ tc cc n _) = do+ let checks = MutualChecks [tc] [cc] []+ addType n (\ i -> InterleavedFun i d Nothing) checks+ addFunType _ = __IMPOSSIBLE__++ addDataType d@(NiceDataSig _ _ _ _ pc _uc n _ _) = do+ let checks = MutualChecks [] [] [pc]+ addType n (\ i -> InterleavedData i d Nothing) checks+ addDataType _ = __IMPOSSIBLE__++ ------------------------------------------------------------------------------+ -- Adding constructors & clauses++ addDataConstructors ::+ Maybe (Name, DefParameters)+ -- Data type the constructors belong to, and parameter telescope of the data definition.+ -> [NiceConstructor]+ -- Constructors to add.+ -> INice ()+ -- if we know the type's name, we can go ahead+ addDataConstructors (Just (n, pars)) ds = do+ ISt m checks i <- get+ case Map.lookup n m of+ Just (InterleavedData i0 sig cs) -> do+ lift $ removeLoneSig n+ -- add the constructors to the existing ones (if any)+ let (cs', i') = case cs of+ Nothing -> ((i , (pars, ds) :| [] ), i + 1)+ Just (i1, ds1) -> ((i1, (pars, ds) <| ds1), i)+ put $ ISt (Map.insert n (InterleavedData i0 sig (Just cs')) m) checks i'+ _ -> lift $ declarationWarning $ MissingDataDeclaration n++ addDataConstructors Nothing [] = pure ()++ -- Otherwise we try to guess which datasig the constructor is referring to+ addDataConstructors Nothing (d : ds) = do+ -- get the candidate data types that are in this interleaved mutual block+ ISt m _ _ <- get+ let sigs = mapMaybe (\ (n, d) -> n <$ isInterleavedData d) $ Map.toList m+ -- check whether this constructor matches any of them+ case isConstructor sigs d of+ Right n -> do+ -- if so grab the whole block that may work and add them+ let (ds0, ds1) = span (isRight . isConstructor [n]) ds+ addDataConstructors (Just (n, [])) (d : ds0)+ -- and then repeat the process for the rest of the block+ addDataConstructors Nothing ds1+ Left (n, ns) -> lift $ declarationException $ AmbiguousConstructor (getRange d) n ns++ addFunDef :: NiceDeclaration -> INice ()+ addFunDef (FunDef _ ds _ _ tc cc n cs) = do+ addInterleavedFun n ds cs $ MutualChecks [tc] [cc] []+ addFunDef _ = __IMPOSSIBLE__++ addInterleavedFun :: Name -> List1 Declaration -> List1 Clause -> MutualChecks -> INice ()+ addInterleavedFun n ds cs checks' = do+ ISt m checks i <- get+ case Map.lookup n m of+ Just (InterleavedFun i0 sig cs0) -> do+ let (cs', i') = case cs0 of+ Nothing -> ((i, (ds, cs) :| [] ), i + 1)+ Just (i1, cs1) -> ((i1, (ds, cs) <| cs1), i)+ put $ ISt (Map.insert n (InterleavedFun i0 sig (Just cs')) m) (checks' <> checks) i'+ _ -> __IMPOSSIBLE__ -- A FunDef always come after an existing FunSig!++ addFunClauses ::+ KwRange+ -- Range of the @interleaved mutual@ keyword.+ -> [NiceDeclaration]+ -> INice [(DeclNum, NiceDeclaration)]+ addFunClauses r (nd@(NiceFunClause _ _ _ tc cc _ (FunClause ai lhs _ _ _)) : ds) = do+ -- get the candidate functions that are in this interleaved mutual block+ ISt m checks i <- get+ let sigs = mapMaybe (\ (n, d) -> n <$ isInterleavedFun d) $ Map.toList m+ -- find the funsig candidates for the funclause of interest+ case [ (x, fits, rest)+ | x <- sigs+ , let (fits0, rest) = spanJust (couldBeNiceFunClauseOf (Map.lookup x fixs) x) (nd : ds)+ , fits <- maybeToList $ List1.nonEmpty fits0+ ] of+ -- no candidate: keep the isolated fun clause, we'll complain about it later+ [] -> do+ let check = MutualChecks [tc] [cc] []+ put $ ISt m (check <> checks) (i + 1)+ ((i,nd) :) <$> groupByBlocks r ds+ -- exactly one candidate: attach the funclause to the definition+ [(n, fits0, rest)] -> do+ let (checkss, fits) = List1.unzip fits0+ ds <- lift $ expandEllipsis1 fits+ cs <- lift $ mkClauses1 ai n ds empty+ addInterleavedFun n fits {- or? ds -} cs $ Fold.fold checkss+ groupByBlocks r rest+ -- more than one candidate: fail, complaining about the ambiguity!+ xf:xfs -> lift $ declarationException+ $ AmbiguousFunClauses lhs+ $ List1.reverse $ fmap (\ (a,_,_) -> a) $ xf :| xfs+ addFunClauses _ _ = __IMPOSSIBLE__++ groupByBlocks ::+ KwRange+ -- Range of the @interleaved mutual@ keyword.+ -> [NiceDeclaration]+ -> INice [(DeclNum, NiceDeclaration)]+ groupByBlocks _kwr [] = pure []+ groupByBlocks kwr (d : ds) = do+ -- for most branches we deal with the one declaration and move on+ let oneOff act = act >>= \ ns -> (ns ++) <$> groupByBlocks kwr ds+ case d of+ NiceDataSig{} -> oneOff $ [] <$ addDataType d+ NiceDataDef _ _ _ _ _ n pars ds+ -> oneOff $ [] <$ addDataConstructors (Just (n, pars)) ds+ NiceLoneConstructor _ ds -> oneOff $ [] <$ addDataConstructors Nothing ds+ FunSig{} -> oneOff $ [] <$ addFunType d+ FunDef _ _ _ _ _ _ n _cs+ | not (isNoName n) -> oneOff $ [] <$ addFunDef d+ -- It's a bit different for fun clauses because we may need to grab a lot+ -- of clauses to handle ellipses properly.+ NiceFunClause{} -> addFunClauses kwr (d:ds)+ -- We do not need to worry about RecSig vs. RecDef: we know there's exactly one+ -- of each for record definitions and leaving them in place should be enough!+ _ -> oneOff $ do+ ISt m c i <- get -- TODO: grab checks from c?+ put $ ISt m c (i + 1)+ pure [(i,d)]++ -- Extract the name of the return type (if any) of a potential constructor.+ -- In case of failure return the name of the constructor and the list of candidates+ -- for the return type.+ -- A `constructor' block should only contain NiceConstructors so we crash with+ -- an IMPOSSIBLE otherwise+ isConstructor :: [Name] -> NiceDeclaration -> Either (Name, [Name]) Name+ isConstructor ns (Axiom _ _ _ _ _ n e)+ -- extract the return type & see it as an LHS-style pattern+ | Just p <- exprToPatternWithHoles <$> returnExpr e =+ case [ x | x <- ns+ , couldBeCallOf (Map.lookup x fixs) x p+ ] of+ [x] -> Right x+ xs -> Left (n, xs)+ -- which may fail (e.g. if the "return type" is a hole+ | otherwise = Left (n, [])+ isConstructor _ _ = __IMPOSSIBLE__++ -- Turn an old-style mutual block into a new style mutual block+ -- by pushing the definitions to the end.+ mkOldMutual+ :: KwRange -- Range of the @mutual@ keyword (if any).+ -> [NiceDeclaration] -- Declarations inside the block.+ -> Nice (Maybe NiceDeclaration)+ -- Returns a 'NiceMutual' unless empty.+ mkOldMutual kwr ds' = do+ -- Turn the missing definitions into postulates.+ ds <- turnLoneSignaturesIntoAxioms ds' $ loneSigsFromLoneNames loneSigNames++ -- -- Remove the declarations that aren't allowed in old style mutual blocks+ -- ds <- fmap catMaybes $ forM ds $ \ d -> let success = pure (Just d) in case d of+ -- -- Andreas, 2013-11-23 allow postulates in mutual blocks+ -- Axiom{} -> success+ -- -- Andreas, 2017-10-09, issue #2576, raise error about missing type signature+ -- -- in ConcreteToAbstract rather than here.+ -- NiceFunClause{} -> success+ -- -- Andreas, 2018-05-11, issue #3052, allow pat.syn.s in mutual blocks+ -- NicePatternSyn{} -> success+ -- -- Otherwise, only categorized signatures and definitions are allowed:+ -- -- Data, Record, Fun+ -- _ -> if (declKind d /= OtherDecl) then success+ -- else Nothing <$ declarationWarning (NotAllowedInMutual (getRange d) $ declName d)+ -- Sort the declarations in the mutual block.+ -- Declarations of names go to the top. (Includes module definitions.)+ -- Definitions of names go to the bottom.+ -- Some declarations are forbidden, as their positioning could confuse+ -- the user.+ (top, bottom, _invalid) <- forEither3M ds $ \ d -> do+ let top = return (In1 d)+ bottom = return (In2 d)+ invalid s = In3 d <$ do declarationWarning $ NotAllowedInMutual (getRange d) s+ case d of+ -- Andreas, 2013-11-23 allow postulates in mutual blocks+ Axiom{} -> top+ NiceField{} -> top+ PrimitiveFunction{} -> top+ -- Andreas, 2019-07-23 issue #3932:+ -- Nested mutual blocks are not supported.+ NiceMutual{} -> invalid "mutual blocks"+ -- Andreas, 2018-10-29, issue #3246+ -- We could allow modules (top), but this is potentially confusing.+ NiceModule{} -> invalid "Module definitions"+ -- Lone constructors are only allowed in new-style mutual blocks+ NiceLoneConstructor{} -> invalid "Lone constructors"+ NiceModuleMacro{} -> top+ NiceOpen{} -> top+ NiceImport{} -> top+ NiceRecSig{} -> top+ NiceDataSig{} -> top+ -- Andreas, 2017-10-09, issue #2576, keep NiceFunClause in+ -- to raise error about missing type signature+ -- in ConcreteToAbstract rather than here.+ -- Andreas, 2026-02-28, issue #4150: sort it up to give the+ -- MissingTypeSignature error priority over potential NotInScope errors.+ NiceFunClause{} -> top+ FunSig{} -> top+ FunDef{} -> bottom+ -- Andreas, 2026-02-28, issue #4150:+ -- Sort lone defs up to prioritise MissingTypeSignature error.+ NiceDataDef _ _ _ _ _ x _ _ -> if x `Set.member` loneDefNames then top else bottom+ NiceRecDef _ _ _ _ _ _ x _ _ _-> if x `Set.member` loneDefNames then top else bottom+ -- Andreas, 2018-05-11, issue #3051, allow pat.syn.s in mutual blocks+ -- Andreas, 2018-10-29: We shift pattern synonyms to the bottom+ -- since they might refer to constructors defined in a data types+ -- just above them.+ NicePatternSyn{} -> bottom+ NiceGeneralize{} -> top+ NiceUnquoteDecl{} -> top+ NiceUnquoteDef{} -> bottom+ NiceUnquoteData{} -> top++ -- Opaque blocks can not participate in old-style mutual+ -- recursion. If some of the definitions are opaque then+ -- they all need to be.+ NiceOpaque r _ _ ->+ In3 d <$ do declarationException $ OpaqueInMutual r+ NicePragma _r pragma -> case pragma of++ OptionsPragma{} -> top -- error thrown in the type checker++ -- Some builtins require a definition, and they affect type checking+ -- Thus, we do not handle BUILTINs in mutual blocks (at least for now).+ BuiltinPragma{} -> invalid "BUILTIN pragmas"++ -- The REWRITE pragma behaves differently before or after the def.+ -- and affects type checking. Thus, we refuse it here.+ RewritePragma{} -> invalid "REWRITE pragmas"++ -- Compiler pragmas are not needed for type checking, thus,+ -- can go to the bottom.+ ForeignPragma{} -> bottom+ CompilePragma{} -> bottom++ StaticPragma{} -> bottom+ InlinePragma{} -> bottom+ NotProjectionLikePragma{} -> bottom++ OverlapPragma{} -> top++ ImpossiblePragma{} -> top -- error thrown in scope checker+ EtaPragma{} -> top -- does not matter, pragma removed+ WarningOnUsage{} -> top+ WarningOnImport{} -> top+ InjectivePragma{} -> top -- only needs name, not definition+ InjectiveForInferencePragma{} -> top+ DisplayPragma{} -> top -- only for printing++ -- The attached pragmas have already been handled at this point.+ CatchallPragma{} -> __IMPOSSIBLE__+ EtaEqualityPragma{} -> __IMPOSSIBLE__+ TerminationCheckPragma{} -> __IMPOSSIBLE__+ NoPositivityCheckPragma{} -> __IMPOSSIBLE__+ PolarityPragma{} -> __IMPOSSIBLE__+ NoUniverseCheckPragma{} -> __IMPOSSIBLE__+ NoCoverageCheckPragma{} -> __IMPOSSIBLE__+++ -- -- Pull type signatures to the top+ -- let (sigs, other) = List.partition isTypeSig ds++ -- -- Push definitions to the bottom+ -- let (other, defs) = flip List.partition ds $ \case+ -- FunDef{} -> False+ -- NiceDataDef{} -> False+ -- NiceRecDef{} -> False+ -- NiceFunClause{} -> False+ -- NicePatternSyn{} -> False+ -- NiceUnquoteDef{} -> False+ -- _ -> True++ -- Compute termination checking flag for mutual block+ tc0 <- use terminationCheckPragma+ let tcs = map termCheck ds+ let r = fuseRange kwr ds'+ tc <- combineTerminationChecks r (tc0:tcs)++ -- Compute coverage checking flag for mutual block+ cc0 <- use coverageCheckPragma+ let ccs = map covCheck ds+ let cc = combineCoverageChecks (cc0:ccs)++ -- Compute positivity checking flag for mutual block+ pc0 <- use positivityCheckPragma+ let pcs = map positivityCheckOldMutual ds+ let pc = combinePositivityChecks (pc0:pcs)++ return $ fmap (NiceMutual kwr tc cc pc) $ List1.nonEmpty $ top ++ bottom++ where+ sigNames = [ (r, x, k) | LoneSigDecl r k x <- map declKind ds' ]+ defNames = [ (x, k) | LoneDefs k xs <- map declKind ds', x <- xs ]+ -- compute the set difference with equality just on names+ loneSigNames = [ (r, x, k) | (r, x, k) <- sigNames, List.all ((x /=) . fst) defNames ]+ loneDefNames = Set.fromList [ x | (x, _) <- defNames, x `Set.notMember` sigNameSet ]+ sigNameSet = Set.fromList [ x | (_, x, _) <- sigNames ]++ termCheck :: NiceDeclaration -> TerminationCheck+ -- Andreas, 2013-02-28 (issue 804):+ -- do not termination check a mutual block if any of its+ -- inner declarations comes with a {-# NO_TERMINATION_CHECK #-}+ termCheck (FunSig _ _ _ _ _ _ tc _ _ _) = tc+ termCheck (FunDef _ _ _ _ tc _ _ _) = tc+ -- ASR (28 December 2015): Is this equation necessary?+ termCheck (NiceMutual _ tc _ _ _) = tc+ termCheck (NiceUnquoteDecl _ _ _ _ tc _ _ _) = tc+ termCheck (NiceUnquoteDef _ _ _ tc _ _ _) = tc+ termCheck Axiom{} = TerminationCheck+ termCheck NiceField{} = TerminationCheck+ termCheck PrimitiveFunction{} = TerminationCheck+ termCheck NiceModule{} = TerminationCheck+ termCheck NiceModuleMacro{} = TerminationCheck+ termCheck NiceOpen{} = TerminationCheck+ termCheck NiceImport{} = TerminationCheck+ termCheck NicePragma{} = TerminationCheck+ termCheck NiceRecSig{} = TerminationCheck+ termCheck NiceDataSig{} = TerminationCheck+ termCheck NiceFunClause{} = TerminationCheck+ termCheck NiceDataDef{} = TerminationCheck+ termCheck NiceRecDef{} = TerminationCheck+ termCheck NicePatternSyn{} = TerminationCheck+ termCheck NiceGeneralize{} = TerminationCheck+ termCheck NiceLoneConstructor{} = TerminationCheck+ termCheck NiceUnquoteData{} = TerminationCheck+ termCheck NiceOpaque{} = TerminationCheck++ covCheck :: NiceDeclaration -> CoverageCheck+ covCheck (FunSig _ _ _ _ _ _ _ cc _ _) = cc+ covCheck (FunDef _ _ _ _ _ cc _ _) = cc+ -- ASR (28 December 2015): Is this equation necessary?+ covCheck (NiceMutual _ _ cc _ _) = cc+ covCheck (NiceUnquoteDecl _ _ _ _ _ cc _ _) = cc+ covCheck (NiceUnquoteDef _ _ _ _ cc _ _) = cc+ covCheck Axiom{} = YesCoverageCheck+ covCheck NiceField{} = YesCoverageCheck+ covCheck PrimitiveFunction{} = YesCoverageCheck+ covCheck NiceModule{} = YesCoverageCheck+ covCheck NiceModuleMacro{} = YesCoverageCheck+ covCheck NiceOpen{} = YesCoverageCheck+ covCheck NiceImport{} = YesCoverageCheck+ covCheck NicePragma{} = YesCoverageCheck+ covCheck NiceRecSig{} = YesCoverageCheck+ covCheck NiceDataSig{} = YesCoverageCheck+ covCheck NiceFunClause{} = YesCoverageCheck+ covCheck NiceDataDef{} = YesCoverageCheck+ covCheck NiceRecDef{} = YesCoverageCheck+ covCheck NicePatternSyn{} = YesCoverageCheck+ covCheck NiceGeneralize{} = YesCoverageCheck+ covCheck NiceLoneConstructor{} = YesCoverageCheck+ covCheck NiceUnquoteData{} = YesCoverageCheck+ covCheck NiceOpaque{} = YesCoverageCheck++ -- ASR (26 December 2015): Do not positivity check a mutual+ -- block if any of its inner declarations comes with a+ -- NO_POSITIVITY_CHECK pragma. See Issue 1614.+ positivityCheckOldMutual :: NiceDeclaration -> PositivityCheck+ positivityCheckOldMutual (NiceDataDef _ _ _ pc _ _ _ _) = pc+ positivityCheckOldMutual (NiceDataSig _ _ _ _ pc _ _ _ _) = pc+ positivityCheckOldMutual (NiceMutual _ _ _ pc _) = pc+ positivityCheckOldMutual (NiceRecSig _ _ _ _ pc _ _ _ _ _) = pc+ positivityCheckOldMutual (NiceRecDef _ _ _ pc _ _ _ _ _ _) = pc+ positivityCheckOldMutual _ = YesPositivityCheck++ -- A mutual block cannot have a measure,+ -- but it can skip termination check.++ abstractBlock+ :: KwRange -- Range of @abstract@ keyword.+ -> [NiceDeclaration]+ -> Nice [NiceDeclaration]+ abstractBlock r ds = do+ (ds', anyChange) <- runChangeT $ mkAbstract r ds+ let inherited = null r+ if anyChange then return ds' else do+ -- hack to avoid failing on inherited abstract blocks in where clauses+ unless inherited $ declarationWarning $ UselessAbstract r+ return ds -- no change!++ privateBlock ::+ KwRange -- Range of @private@ keyword.+ -> Origin -- Origin of the private block.+ -> [NiceDeclaration]+ -> Nice [NiceDeclaration]+ privateBlock r o ds = do+ (ds', anyChange) <- runChangeT $ mkPrivate r o ds+ -- Warn if user-written 'private' does not accomplish anything.+ when (o == UserWritten) do+ if anyChange then+ -- Andreas, 2025-03-29, user-written 'private' is useless in anonymous 'where' modules+ -- since Agda automatically inserts a 'private' there.+ whenM ((AnyWhere_ ==) <$> asks checkingWhere) warn+ else warn+ return $ if anyChange then ds' else ds+ where+ warn = declarationWarning $ UselessPrivate r++ instanceBlock ::+ KwRange -- Range of @instance@ keyword.+ -> [NiceDeclaration]+ -> Nice [NiceDeclaration]+ instanceBlock r ds = do+ let (ds', anyChange) = runChange $ mapM (mkInstance r) ds+ if anyChange then return ds' else do+ declarationWarning $ UselessInstance r+ return ds -- no change!++ -- Make a declaration eligible for instance search.+ mkInstance ::+ KwRange -- Range of @instance@ keyword.+ -> Updater NiceDeclaration+ mkInstance r0 = \case+ Axiom r p a i rel x e -> (\ i -> Axiom r p a i rel x e) <$> setInstance r0 i+ FunSig r p a i m rel tc cc x e -> (\ i -> FunSig r p a i m rel tc cc x e) <$> setInstance r0 i+ -- Andreas, 2026-10-19, AIM XLIII, issue 8847+ -- The type checker ignores the IsInstanceDef for UnquoteDecl, so it does not help to propagate it here.+ -- NiceUnquoteDecl r p a i tc cc x e -> (\ i -> NiceUnquoteDecl r p a i tc cc x e) <$> setInstance r0 i+ NiceMutual r tc cc pc ds -> NiceMutual r tc cc pc <$> mapM (mkInstance r0) ds+ NiceLoneConstructor r ds -> NiceLoneConstructor r <$> mapM (mkInstance r0) ds+ d@NiceFunClause{} -> return d+ FunDef r ds a i tc cc x cs -> (\ i -> FunDef r ds a i tc cc x cs) <$> setInstance r0 i+ NiceOpaque r ns i -> (\ i -> NiceOpaque r ns i) <$> traverse (mkInstance r0) i+ d@NiceField{} -> return d -- Field instance are handled by the parser+ d@PrimitiveFunction{} -> return d+ d@NiceUnquoteDecl{} -> return d+ d@NiceUnquoteDef{} -> return d+ d@NiceRecSig{} -> return d+ d@NiceDataSig{} -> return d+ d@NiceModuleMacro{} -> return d+ d@NiceModule{} -> return d+ d@NicePragma{} -> return d+ d@NiceOpen{} -> return d+ d@NiceImport{} -> return d+ d@NiceDataDef{} -> return d+ d@NiceRecDef{} -> return d+ d@NicePatternSyn{} -> return d+ d@NiceGeneralize{} -> return d+ d@NiceUnquoteData{} -> return d++ setInstance+ :: KwRange -- Range of @instance@ keyword.+ -> Updater IsInstance+ setInstance r0 = \case+ i@InstanceDef{} -> return i+ _ -> dirty $ InstanceDef r0++ macroBlock+ :: KwRange -- Range of @macro@ keyword.+ -> [NiceDeclaration]+ -> Nice [NiceDeclaration]+ macroBlock r ds = do+ (ds', anyChange) <- runChangeT $ mkMacro ds+ if anyChange then return ds' else do+ declarationWarning $ UselessMacro r+ return ds -- no change!++class MakeMacro a where+ mkMacro :: UpdaterT Nice a++ default mkMacro :: (Traversable f, MakeMacro a', a ~ f a') => UpdaterT Nice a+ mkMacro = traverse mkMacro++instance MakeMacro a => MakeMacro [a]++instance MakeMacro NiceDeclaration where+ mkMacro = \case+ FunSig r p a i _ rel tc cc x e -> dirty $ FunSig r p a i MacroDef rel tc cc x e+ d@FunDef{} -> return d+ d -> lift $ declarationException $ BadMacroDef d++-- | Make a declaration abstract.+--+-- Mark computation as 'dirty' if there was a declaration that could be made abstract.+-- If no abstraction is taking place, we want to complain about 'UselessAbstract'.+--+-- Alternatively, we could only flag 'dirty' if a non-abstract thing was abstracted.+-- Then, nested @abstract@s would sometimes also be complained about.++class MakeAbstract a where+ mkAbstract ::+ KwRange+ -- ^ Range of the keyword @abstract@.+ -> UpdaterT Nice a++ default mkAbstract :: (Traversable f, MakeAbstract a', a ~ f a') => KwRange -> UpdaterT Nice a+ mkAbstract = traverse . mkAbstract++instance MakeAbstract a => MakeAbstract [a]+instance MakeAbstract a => MakeAbstract (List1 a)++-- Leads to overlap with 'WhereClause':+-- instance (Traversable f, MakeAbstract a) => MakeAbstract (f a) where+-- mkAbstract = traverse mkAbstract++instance MakeAbstract IsAbstract where+ mkAbstract _ = \case+ a@AbstractDef -> return a+ ConcreteDef -> dirty $ AbstractDef++instance MakeAbstract NiceDeclaration where+ mkAbstract :: KwRange -> UpdaterT Nice NiceDeclaration+ mkAbstract kwr = \case+ NiceMutual r termCheck cc pc ds -> NiceMutual r termCheck cc pc <$> mkAbstract kwr ds+ NiceLoneConstructor r ds -> NiceLoneConstructor r <$> mkAbstract kwr ds+ FunDef r ds a i tc cc x cs -> (\ a -> FunDef r ds a i tc cc x) <$> mkAbstract kwr a <*> mkAbstract kwr cs+ NiceDataDef r o a pc uc x ps cs -> (\ a -> NiceDataDef r o a pc uc x ps) <$> mkAbstract kwr a <*> mkAbstract kwr cs+ NiceRecDef r o a pc uc eta x dir ps cs -> (\ a -> NiceRecDef r o a pc uc eta x dir ps cs) <$> mkAbstract kwr a+ NiceFunClause r p a tc cc catchall d -> (\ a -> NiceFunClause r p a tc cc catchall d) <$> mkAbstract kwr a+ -- The following declarations have an @InAbstract@ field+ -- but are not really definitions, so we do count them into+ -- the declarations which can be made abstract+ -- (thus, do not notify progress with @dirty@).+ Axiom r p _ i rel x e -> return $ Axiom r p AbstractDef i rel x e+ FunSig r p _ i m rel tc cc x e -> return $ FunSig r p AbstractDef i m rel tc cc x e+ NiceRecSig r er p _ pc uc eta x ls t-> return $ NiceRecSig r er p AbstractDef pc uc eta x ls t+ NiceDataSig r er p _ pc uc x ls t -> return $ NiceDataSig r er p AbstractDef pc uc x ls t+ NiceField r p _ i tac x e -> return $ NiceField r p AbstractDef i tac x e+ PrimitiveFunction r p _ x e -> return $ PrimitiveFunction r p AbstractDef x e+ -- Andreas, 2016-07-17 it does have effect on unquoted defs.+ -- Need to set updater state to dirty!+ NiceUnquoteDecl r p _ i tc cc x e -> tellDirty $> NiceUnquoteDecl r p AbstractDef i tc cc x e+ NiceUnquoteDef r p _ tc cc x e -> tellDirty $> NiceUnquoteDef r p AbstractDef tc cc x e+ NiceUnquoteData r p _ tc cc x xs e -> tellDirty $> NiceUnquoteData r p AbstractDef tc cc x xs e+ d@NiceModule{} -> return d+ d@NiceModuleMacro{} -> return d+ d@NicePragma{} -> return d+ d@NiceOpen{} -> d <$ do+ unless (null kwr) $+ lift $ declarationWarning $ OpenImportAbstract (getRange d) kwr OpenNotImport+ d@NiceImport{} -> d <$ do+ unless (null kwr) $+ lift $ declarationWarning $ OpenImportAbstract (getRange d) kwr ImportMayOpen+ d@NicePatternSyn{} -> return d+ d@NiceGeneralize{} -> return d+ NiceOpaque r ns ds -> NiceOpaque r ns <$> mkAbstract kwr ds++instance MakeAbstract Clause where+ mkAbstract kwr (Clause x catchall ai lhs rhs wh with) = do+ Clause x catchall ai lhs rhs <$> mkAbstract kwr wh <*> mkAbstract kwr with++-- | Contents of a @where@ clause are abstract if the parent is.+--+-- These are inherited 'Abstract' blocks, indicated by an empty range+-- for the @abstract@ keyword.+instance MakeAbstract WhereClause where+ mkAbstract _ NoWhere = return $ NoWhere+ mkAbstract _ (AnyWhere r ds) = dirty $ AnyWhere r+ [Abstract empty ds]+ mkAbstract _ (SomeWhere r e m a ds) = dirty $ SomeWhere r e m a+ [Abstract empty ds]++-- | Make a declaration private.+--+-- Andreas, 2012-11-17:+-- Mark computation as 'dirty' if there was a declaration that could be privatized.+-- If no privatization is taking place, we want to complain about 'UselessPrivate'.+--+-- Alternatively, we could only flag 'dirty' if a non-private thing was privatized.+-- Then, nested @private@s would sometimes also be complained about.++class MakePrivate a where+ mkPrivate ::+ KwRange+ -- ^ Range of the @private@ keyword.+ -> Origin+ -- ^ Origin of the @private@ block.+ -> UpdaterT Nice a++ default mkPrivate :: (Traversable f, MakePrivate a', a ~ f a') => KwRange -> Origin -> UpdaterT Nice a+ mkPrivate kwr o = traverse $ mkPrivate kwr o++instance MakePrivate a => MakePrivate [a]+instance MakePrivate a => MakePrivate (List1 a)++-- Leads to overlap with 'WhereClause':+-- instance (Traversable f, MakePrivate a) => MakePrivate (f a) where+-- mkPrivate = traverse mkPrivate++instance MakePrivate Access where+ mkPrivate kwr o = \case+ p@PrivateAccess{} -> return p -- OR? return $ PrivateAccess o+ _ -> dirty $ PrivateAccess kwr o++instance MakePrivate NiceDeclaration where+ mkPrivate kwr o = \case+ Axiom r p a i rel x e -> (\ p -> Axiom r p a i rel x e) <$> mkPrivate kwr o p+ NiceField r p a i tac x e -> (\ p -> NiceField r p a i tac x e) <$> mkPrivate kwr o p+ PrimitiveFunction r p a x e -> (\ p -> PrimitiveFunction r p a x e) <$> mkPrivate kwr o p+ NiceMutual r tc cc pc ds -> (\ ds-> NiceMutual r tc cc pc ds) <$> mkPrivate kwr o ds+ NiceModule r p a e x tel ds -> (\ p -> NiceModule r p a e x tel ds) <$> mkPrivate kwr o p+ NiceModuleMacro r p e x ma op is -> (\ p -> NiceModuleMacro r p e x ma op is) <$> mkPrivate kwr o p+ FunSig r p a i m rel tc cc x e -> (\ p -> FunSig r p a i m rel tc cc x e) <$> mkPrivate kwr o p+ NiceRecSig r er p a pc uc eta x ls t -> (\ p -> NiceRecSig r er p a pc uc eta x ls t) <$> mkPrivate kwr o p+ NiceDataSig r er p a pc uc x ls t -> (\ p -> NiceDataSig r er p a pc uc x ls t) <$> mkPrivate kwr o p+ NiceFunClause r p a tc cc catchall d -> (\ p -> NiceFunClause r p a tc cc catchall d) <$> mkPrivate kwr o p+ NiceUnquoteDecl r p a i tc cc x e -> (\ p -> NiceUnquoteDecl r p a i tc cc x e) <$> mkPrivate kwr o p+ NiceUnquoteDef r p a tc cc x e -> (\ p -> NiceUnquoteDef r p a tc cc x e) <$> mkPrivate kwr o p+ NicePatternSyn r p x xs p' -> (\ p -> NicePatternSyn r p x xs p') <$> mkPrivate kwr o p+ NiceGeneralize r p i tac x t -> (\ p -> NiceGeneralize r p i tac x t) <$> mkPrivate kwr o p+ NiceOpaque r ns ds -> (\ p -> NiceOpaque r ns p) <$> mkPrivate kwr o ds+ d@NicePragma{} -> return d+ d@(NiceOpen _kwr _x dir) -> d <$ do+ unless (null kwr) $+ whenJust (publicOpen dir) \ kwrPublic ->+ lift $ declarationWarning $ OpenImportPrivate (getRange d) kwrPublic kwr OpenNotImport+ d@(NiceImport opn impR x args dir) -> d <$ do+ unless (null kwr) $+ whenJust (publicOpen dir) \ kwrPublic ->+ lift $ declarationWarning $ OpenImportPrivate (getRange (opn, impR, x, args, dir)) kwrPublic kwr ImportMayOpen+ -- Andreas, 2016-07-08, issue #2089+ -- we need to propagate 'private' to the named where modules+ FunDef r ds a i tc cc x cls -> FunDef r ds a i tc cc x <$> mkPrivate kwr o cls+ d@NiceLoneConstructor{} -> return d -- Issue #7998: constructors cannot be private+ d@NiceDataDef{} -> return d+ d@NiceRecDef{} -> return d+ d@NiceUnquoteData{} -> return d++instance MakePrivate Clause where+ mkPrivate kwr o (Clause x catchall ai lhs rhs wh with) = do+ Clause x catchall ai lhs rhs <$> mkPrivate kwr o wh <*> mkPrivate kwr o with++instance MakePrivate WhereClause where+ mkPrivate kwr o = \case+ d@NoWhere -> return d+ -- @where@-declarations are protected behind an anonymous module,+ -- thus, they are effectively private by default.+ d@AnyWhere{} -> return d+ -- Andreas, 2016-07-08+ -- A named @where@-module is private if the parent function is private.+ -- The contents of this module are not private, unless declared so!+ -- Thus, we do not recurse into the @ds@ (could not anyway).+ SomeWhere r e m a ds ->+ mkPrivate kwr o a <&> \a' -> SomeWhere r e m a' ds++-- | Check data/record definition parameters for parts that are not allowed+-- (allowed if at all in data/record signatures).+niceDefParameters :: DataOrRecord_ -> Parameters -> Nice DefParameters+niceDefParameters dataOrRec = concatMapM \case+ DomainFree x ->+ singleton <$> strip x+ DomainFull (TBind _r xs a) -> do+ warn a "parameter type"+ mapM strip $ List1.toList xs+ DomainFull (TLet r _ds) ->+ [] <$ warn r "parameter `let'"+ where+ warn :: HasRange a => a -> Text -> Nice ()+ warn a what = declarationWarning $+ InvalidDataOrRecDefParameter (getRange a) dataOrRec what $+ "(note: parameters may not repeat information from signature)"++ strip :: NamedArg Binder -> Nice (WithHiding (Named_ Name))+ strip (Arg (ArgInfo h m _o _fv ann) (Named mn (Binder mp _bo (BName x fx tac _)))) =+ WithHiding h (Named mn x) <$ do+ unless (null m) $ warn m "parameter modality"+ unless (null ann) $ warn ann "parameter annotation"+ unless (null mp) $ warn mp "pattern attached to parameter"+ unless (null tac) $ warn tac "tactic argument"+ unless (null fx) $ __IMPOSSIBLE__++-- | Emit bits attached to the given name+-- that have been accumulated during processing of the interleaved mutual block+-- as 'NiceDeclaration'.+--+-- Warns about mistakes in parameters in data definition blocks;+-- but those parameters are finally ignored, taking the parameters of+-- the data signature instead.+interleavedDecl :: Name -> InterleavedDecl -> Nice [(DeclNum, NiceDeclaration)]+interleavedDecl k = \case++ InterleavedData i d@(NiceDataSig _ _ _acc abs pc uc _ pars _) ds -> do+ let+ fpars = parametersToDefParameters pars+ r = getRange (k, fpars)+ ddef cs = NiceDataDef (getRange (r, cs)) UserWritten abs pc uc k fpars cs+ case ds of+ Nothing -> return [(i, d)] -- signature only+ Just (j, dds) -> do+ dds' <- forM (List1.reverse dds) \ (defpars, cs) -> do+ unless (null defpars || defpars == fpars) $ declarationWarning $+ InvalidDataOrRecDefParameter (getRange defpars) IsData "parameter names" $+ "(in `interleaved mutual' blocks, parameters of a data definition must either be omitted or match exactly the parameters given in the data signature)"+ pure cs+ return [(i, d), (j, ddef $ sconcat dds')]++ InterleavedFun i d@(FunSig r _acc abs inst _mac _info tc cc n _e) dcs -> do+ let+ fdef dcss = FunDef r (sconcat dss) abs inst tc cc n (sconcat css)+ where (dss, css) = List1.unzip $ List1.reverse dcss+ return . ((i,d) :) . maybeToList $ fmap (second fdef) dcs++ _ -> __IMPOSSIBLE__ -- someone messed up and broke the invariant++-- | Make sure that the 'TacticAttribute' is empty.+dropTactic :: TacticAttribute -> Nice ()+dropTactic = \case+ TacticAttribute Nothing -> return ()+ TacticAttribute (Just re) -> declarationWarning $ InvalidTacticAttribute $ getRange re++-- | Ensure there is no local rewrite attribute+dropRew :: LensRewriteAnn a => a -> Nice a+dropRew = ignoreRew $ declarationWarning . InvalidRewriteAttribute . getRange++-- The following function is (at the time of writing) only used three+-- times: for building Lets, and for printing error messages.++-- | (Approximately) convert a 'NiceDeclaration' back to a list of+-- 'Declaration's.+notSoNiceDeclarations :: NiceDeclaration -> List1 Declaration+notSoNiceDeclarations = \case+ Axiom _ _ _ i rel x e -> inst i $ TypeSig rel empty x e+ NiceField _ _ _ i tac x argt -> singleton $ FieldSig i tac x argt+ PrimitiveFunction _ _ _ x e -> singleton $ Primitive empty $ singleton $ TypeSig (argInfo e) empty x (unArg e)+ NiceMutual r _ _ _ ds -> singleton $ Mutual r $ List1.toList $ sconcat $ fmap notSoNiceDeclarations ds+ NiceLoneConstructor r ds -> singleton $ LoneConstructor r $ List1.concat $ fmap notSoNiceDeclarations ds+ NiceModule r _ _ e x tel ds -> singleton $ Module r e x tel ds+ NiceModuleMacro r _ e x ma o dir+ -> singleton $ ModuleMacro r e x ma o dir+ NiceOpen kwr x dir -> singleton $ Open kwr x dir+ NiceImport o r x as dir -> singleton $ Import o r x as dir+ NicePragma _ p -> singleton $ Pragma p+ NiceRecSig r er _ _ _ _ _ x bs e -> singleton $ RecordSig r er x bs e+ NiceDataSig r er _ _ _ _ x bs e -> singleton $ DataSig r er x bs e+ NiceFunClause _ _ _ _ _ _ d -> singleton $ d+ FunSig _ _ _ i _ rel _ _ x e -> inst i $ TypeSig rel empty x e+ FunDef _ ds _ _ _ _ _ _ -> ds+ NiceDataDef r _ _ _ _ x bs cs -> singleton $ DataDef r x (defParametersToParameters bs) $ List1.concat $ fmap notSoNiceDeclarations cs+ NiceRecDef r _ _ _ _ _ x dir bs ds -> singleton $ RecordDef r x dir (defParametersToParameters bs) ds+ NicePatternSyn r _ n as p -> singleton $ PatternSyn r n as p+ NiceGeneralize _ _ i tac n e -> singleton $ Generalize empty $ singleton $ TypeSig i tac n e+ NiceUnquoteDecl r _ _ i _ _ x e -> inst i $ UnquoteDecl r x e+ NiceUnquoteDef r _ _ _ _ x e -> singleton $ UnquoteDef r x e+ NiceUnquoteData r _ _ _ _ x xs e -> singleton $ UnquoteData r x xs e+ NiceOpaque r ns ds -> singleton $ Opaque r $ (Unfolding r ns :) $ List1.concat $ fmap notSoNiceDeclarations ds+ where+ inst (InstanceDef r) d = singleton $ InstanceB r $ singleton d+ inst NotInstanceDef d = singleton d++-- | Has the 'NiceDeclaration' a field of type 'IsAbstract'?+niceHasAbstract :: NiceDeclaration -> Maybe IsAbstract+niceHasAbstract = \case+ Axiom{} -> Nothing+ NiceField _ _ a _ _ _ _ -> Just a+ PrimitiveFunction _ _ a _ _ -> Just a+ NiceMutual{} -> Nothing+ NiceLoneConstructor{} -> Nothing+ NiceModule _ _ a _ _ _ _ -> Just a+ NiceModuleMacro{} -> Nothing+ NiceOpen{} -> Nothing+ NiceImport{} -> Nothing+ NicePragma{} -> Nothing+ NiceRecSig{} -> Nothing+ NiceDataSig{} -> Nothing+ NiceFunClause _ _ a _ _ _ _ -> Just a+ FunSig{} -> Nothing+ FunDef _ _ a _ _ _ _ _ -> Just a+ NiceDataDef _ _ a _ _ _ _ _ -> Just a+ NiceRecDef _ _ a _ _ _ _ _ _ _ -> Just a+ NicePatternSyn{} -> Nothing+ NiceGeneralize{} -> Nothing+ NiceUnquoteDecl _ _ a _ _ _ _ _ -> Just a+ NiceUnquoteDef _ _ a _ _ _ _ -> Just a+ NiceUnquoteData _ _ a _ _ _ _ _ -> Just a+ NiceOpaque{} -> Nothing
@@ -0,0 +1,651 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Syntax.Concrete.Definitions.Errors where++import Control.DeepSeq+import Data.Text (Text)++import GHC.Generics (Generic)++import Agda.Syntax.Position+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete+import Agda.Syntax.Concrete.Definitions.Types++import Agda.Interaction.Options.Warnings++import Agda.Utils.Boolean ( ifThenElse )+import Agda.Utils.CallStack ( CallStack )+import Agda.Utils.List1 ( List1 )+import Agda.Utils.List1 qualified as List1+import Agda.Utils.List2 ( List2 )+import Agda.Utils.Null ( empty )+import Agda.Utils.Set1 ( Set1 )+import Agda.Utils.Set1 qualified as Set1+import Agda.Utils.Singleton++------------------------------------------------------------------------+-- Errors++-- | Exception with internal source code callstack+data DeclarationException = DeclarationException+ { deLocation :: CallStack+ , deException :: DeclarationException'+ }++-- | The exception type.+data DeclarationException'+ = MultipleEllipses Pattern+ | DuplicateDefinition Name Range+ -- ^ The 'Range' is the range of the previous definition.+ | DuplicateAnonDeclaration Range Range+ -- ^ The first 'Range' is the range of the current declaration of _.+ -- The second 'Range' is the range of the previous declaration of _.+ | MissingWithClauses Name LHS+ | WrongDefinition Name DataRecOrFun DataRecOrFun+ | WrongContentBlock KindOfBlock Range+ | AmbiguousFunClauses LHS (List1 Name)+ -- ^ In a mutual block, a clause could belong to any of the ≥2 type signatures ('Name').+ | AmbiguousConstructor Range Name [Name]+ -- ^ In an interleaved mutual block, a constructor could belong to any of the data signatures ('Name')+ | InvalidMeasureMutual Range+ -- ^ In a mutual block, all or none need a MEASURE pragma.+ -- 'Range' is the one of the offending pragma or the mutual block.+ | UnquoteDefRequiresSignature (List1 Name)+ | BadMacroDef NiceDeclaration+ | UnfoldingOutsideOpaque KwRange+ -- ^ An unfolding declaration was not the first declaration+ -- contained in an opaque block.+ | OpaqueInMutual KwRange+ -- ^ @opaque@ block nested in a @mutual@ block.+ -- This can never happen, even with reordering.+ -- The 'KwRange' is the one of the @opaque@ keyword.+ | DisallowedInterleavedMutual KwRange String (List1 Name)+ -- ^ A declaration that breaks an implicit mutual block (named by+ -- the String argument) was present while the given lone type+ -- signatures were still without their definitions.+ deriving (Show, Generic)++-- | The name of the error.+declarationExceptionString :: DeclarationException' -> String+declarationExceptionString = \case+ MultipleEllipses {} -> "MultipleEllipses"+ DuplicateDefinition {} -> "DuplicateDefinition"+ DuplicateAnonDeclaration {} -> "DuplicateAnonDeclaration"+ MissingWithClauses {} -> "MissingWithClauses"+ WrongDefinition {} -> "WrongDefinition"+ WrongContentBlock {} -> "WrongContentBlock"+ AmbiguousFunClauses {} -> "AmbiguousFunClauses"+ AmbiguousConstructor {} -> "AmbiguousConstructor"+ InvalidMeasureMutual {} -> "InvalidMeasureMutual"+ UnquoteDefRequiresSignature {} -> "UnquoteDefRequiresSignature"+ BadMacroDef {} -> "BadMacroDef"+ UnfoldingOutsideOpaque {} -> "UnfoldingOutsideOpaque"+ OpaqueInMutual {} -> "OpaqueInMutual"+ DisallowedInterleavedMutual {} -> "DisallowedInterleavedMutual"++------------------------------------------------------------------------+-- Warnings++data DeclarationWarning = DeclarationWarning+ { dwLocation :: CallStack+ , dwWarning :: DeclarationWarning'+ } deriving (Show, Generic)++-- | Non-fatal errors encountered in the Nicifier.+data DeclarationWarning'+ -- Please keep in (mostly) alphabetical order.+ = DivergentModalityInClause ArgInfo ArgInfo+ -- ^ The modality of the clause (second 'ArgInfo', range of the warning)+ -- is different from the modality of the type signature (first 'ArgInfo').+ | EmptyAbstract KwRange -- ^ Empty @abstract@ block.+ | EmptyConstructor KwRange -- ^ Empty @data _ where@ block.+ | EmptyField KwRange -- ^ Empty @field@ block.+ | EmptyGeneralize KwRange -- ^ Empty @variable@ block.+ | EmptyInstance KwRange -- ^ Empty @instance@ block+ | EmptyMacro KwRange -- ^ Empty @macro@ block.+ | EmptyMutual KwRange -- ^ Empty @mutual@ block.+ | EmptyPostulate KwRange -- ^ Empty @postulate@ block.+ | EmptyPrivate KwRange -- ^ Empty @private@ block.+ | EmptyPrimitive KwRange -- ^ Empty @primitive@ block.+ | EmptyPolarityPragma Range+ -- ^ POLARITY pragma without any polarities.+ | FixityDeclarationForNonOperator Range Name+ -- ^ A fixity declaration for a closed operator or syntax.+ | HiddenGeneralize Range+ -- ^ A 'Hidden' identifier in a @variable@ declaration.+ -- Hiding has no effect there as generalized variables are always hidden+ -- (or instance variables).+ | InvalidCatchallPragma Range+ -- ^ A {-\# CATCHALL \#-} pragma+ -- that does not precede a function clause.+ | InvalidConstructorBlock Range+ -- ^ Invalid constructor block (not inside an interleaved mutual block)+ | InvalidCoverageCheckPragma Range+ -- ^ A {-\# NON_COVERING \#-} pragma that does not apply to any function.+ | InvalidDataOrRecDefParameter Range DataOrRecord_ Text Text+ -- ^ An entry in a data or record definition parameter that is not allowed here.+ -- Such parameters can only be names with hiding.+ -- The first 'Text' says what is wrong and thus ignored.+ -- The second 'Text' may contain extra details or clarification.+ | InvalidEtaEqualityPragma Range+ -- ^ A {-\# ETA_EQUALITY \#-} pragma+ -- that does not apply to any record type.+ | InvalidNoPositivityCheckPragma Range+ -- ^ A {-\# NO_POSITIVITY_CHECK \#-} pragma+ -- that does not apply to any data or record type.+ | InvalidNoUniverseCheckPragma Range+ -- ^ A {-\# NO_UNIVERSE_CHECK \#-} pragma+ -- that does not apply to a data or record type.+ | InvalidTerminationCheckPragma Range+ -- ^ A {-\# TERMINATING \#-} and {-\# NON_TERMINATING \#-} pragma+ -- that does not apply to any function.+ | InvalidTacticAttribute Range+ -- ^ A misplaced @tactic@ attribute.+ | InvalidRewriteAttribute Range+ -- ^ A misplaced @rewrite@ attribute.+ | MissingDataDeclaration Name+ -- ^ A @data@ definition without a @data@ signature.+ | MissingDefinitions (List1 (Name, Range))+ -- ^ Declarations (e.g. type signatures) without a definition.+ | NotAllowedInMutual Range String+ | OpenImportPrivate Range KwRange KwRange OpenOrImport+ -- ^ @private@ has no effect on @open (import) public@. (But the user might think so.)+ -- 'Range' is the range of the @open public@ or @open import public@ declaration.+ -- The first 'KwRange' is the range of the @public@ keyword.+ -- The second 'KwRange' is the range of the @private@ keyword.+ | OpenImportAbstract Range KwRange OpenOrImport+ -- ^ @abstract@ has no effect on @open@ or @import@. (But the user might think so.)+ -- 'Range' is the range of the @open@ or @import@ declaration.+ -- 'KwRange' is the range of the @abstract@ keyword.+ | PolarityPragmasButNotPostulates (Set1 Name)+ | PragmaNoTerminationCheck Range+ -- ^ Pragma @{-\# NO_TERMINATION_CHECK \#-}@ has been replaced+ -- by @{-\# TERMINATING \#-}@ and @{-\# NON_TERMINATING \#-}@.+ | PragmaCompiled Range+ -- ^ @COMPILE@ pragmas are not allowed in safe mode.+ | SafeFlagInjective Range -- ^ @INJECTIVE@ pragma is unsafe.+ | SafeFlagNoCoverageCheck Range -- ^ @NON_COVERING@ pragma is unsafe.+ | SafeFlagNoPositivityCheck Range -- ^ @NO_POSITIVITY_CHECK@ pragma is unsafe.+ | SafeFlagNoUniverseCheck Range -- ^ @NO_UNIVERSE_CHECK@ pragma is unsafe.+ | SafeFlagNonTerminating Range -- ^ @NON_TERMINATING@ pragma is unsafe.+ | SafeFlagPolarity Range -- ^ @POLARITY@ pragma is unsafe.+ | SafeFlagTerminating Range -- ^ @TERMINATING@ pragma is unsafe.+ | ShadowingInTelescope (List1 (Name, List2 Range))+ | UnknownFixityInMixfixDecl (Set1 Name)+ -- ^ Public mixfix identifiers without a fixity declaration.+ | UnknownNamesInFixityDecl (Set1 Name)+ | UnknownNamesInPolarityPragmas (Set1 Name)+ | UselessAbstract KwRange+ -- ^ @abstract@ block with nothing that can (newly) be made abstract.+ | UselessInstance KwRange+ -- ^ @instance@ block with nothing that can (newly) become an instance.+ | UselessMacro KwRange+ -- ^ @macro@ block with nothing that can (newly) be made macro.+ | UselessPrivate KwRange+ -- ^ @private@ block with nothing that can (newly) be made private.+ | UselessImport Range+ -- ^ An @import@ that is applied to parameters by neither bound not opened.+ deriving (Show, Generic)++-- | @open@ or @import@+data OpenOrImport+ = OpenNotImport -- ^ @open@.+ | ImportMayOpen -- ^ @import@ or @open import@.+ deriving (Show, Generic, Enum, Bounded)++declarationWarningName :: DeclarationWarning -> WarningName+declarationWarningName = declarationWarningName' . dwWarning++declarationWarningName' :: DeclarationWarning' -> WarningName+declarationWarningName' = \case+ -- Please keep in alphabetical order.+ DivergentModalityInClause {} -> DivergentModalityInClause_+ EmptyAbstract {} -> EmptyAbstract_+ EmptyConstructor {} -> EmptyConstructor_+ EmptyField {} -> EmptyField_+ EmptyGeneralize {} -> EmptyGeneralize_+ EmptyInstance {} -> EmptyInstance_+ EmptyMacro {} -> EmptyMacro_+ EmptyMutual {} -> EmptyMutual_+ EmptyPrivate {} -> EmptyPrivate_+ EmptyPostulate {} -> EmptyPostulate_+ EmptyPrimitive {} -> EmptyPrimitive_+ EmptyPolarityPragma {} -> EmptyPolarityPragma_+ FixityDeclarationForNonOperator {} -> FixityDeclarationForNonOperator_+ HiddenGeneralize {} -> HiddenGeneralize_+ InvalidCatchallPragma {} -> InvalidCatchallPragma_+ InvalidConstructorBlock {} -> InvalidConstructorBlock_+ InvalidDataOrRecDefParameter {} -> InvalidDataOrRecDefParameter_+ InvalidEtaEqualityPragma {} -> InvalidEtaEqualityPragma_+ InvalidNoPositivityCheckPragma {} -> InvalidNoPositivityCheckPragma_+ InvalidNoUniverseCheckPragma {} -> InvalidNoUniverseCheckPragma_+ InvalidTerminationCheckPragma {} -> InvalidTerminationCheckPragma_+ InvalidCoverageCheckPragma {} -> InvalidCoverageCheckPragma_+ InvalidTacticAttribute {} -> InvalidTacticAttribute_+ InvalidRewriteAttribute {} -> MisplacedRewrite_+ MissingDataDeclaration {} -> MissingDataDeclaration_+ MissingDefinitions {} -> MissingDefinitions_+ NotAllowedInMutual {} -> NotAllowedInMutual_+ OpenImportPrivate {} -> OpenImportPrivate_+ OpenImportAbstract {} -> OpenImportAbstract_+ PolarityPragmasButNotPostulates {} -> PolarityPragmasButNotPostulates_+ PragmaNoTerminationCheck {} -> PragmaNoTerminationCheck_+ PragmaCompiled {} -> PragmaCompiled_+ SafeFlagInjective {} -> SafeFlagInjective_+ SafeFlagNoCoverageCheck {} -> SafeFlagNoCoverageCheck_+ SafeFlagNoPositivityCheck {} -> SafeFlagNoPositivityCheck_+ SafeFlagNoUniverseCheck {} -> SafeFlagNoUniverseCheck_+ SafeFlagNonTerminating {} -> SafeFlagNonTerminating_+ SafeFlagPolarity {} -> SafeFlagPolarity_+ SafeFlagTerminating {} -> SafeFlagTerminating_+ ShadowingInTelescope {} -> ShadowingInTelescope_+ UnknownFixityInMixfixDecl {} -> UnknownFixityInMixfixDecl_+ UnknownNamesInFixityDecl {} -> UnknownNamesInFixityDecl_+ UnknownNamesInPolarityPragmas {} -> UnknownNamesInPolarityPragmas_+ UselessAbstract {} -> UselessAbstract_+ UselessImport {} -> UselessImport_+ UselessInstance {} -> UselessInstance_+ UselessMacro {} -> UselessMacro_+ UselessPrivate {} -> UselessPrivate_++-- | Nicifier warnings turned into errors in @--safe@ mode.+unsafeDeclarationWarning :: DeclarationWarning -> Bool+unsafeDeclarationWarning = unsafeDeclarationWarning' . dwWarning++unsafeDeclarationWarning' :: DeclarationWarning' -> Bool+unsafeDeclarationWarning' = \case+ -- Please keep in alphabetical order.+ DivergentModalityInClause{} -> False+ EmptyAbstract{} -> False+ EmptyConstructor{} -> False+ EmptyField{} -> False+ EmptyGeneralize{} -> False+ EmptyInstance{} -> False+ EmptyMacro{} -> False+ EmptyMutual{} -> False+ EmptyPrivate{} -> False+ EmptyPostulate{} -> False+ EmptyPrimitive{} -> False+ EmptyPolarityPragma{} -> False+ FixityDeclarationForNonOperator{} -> False+ HiddenGeneralize{} -> False+ InvalidCatchallPragma{} -> False+ InvalidConstructorBlock{} -> False+ InvalidDataOrRecDefParameter{} -> False+ InvalidEtaEqualityPragma{} -> False+ InvalidNoPositivityCheckPragma{} -> False+ InvalidNoUniverseCheckPragma{} -> False+ InvalidTerminationCheckPragma{} -> False+ InvalidCoverageCheckPragma{} -> False+ InvalidTacticAttribute{} -> False+ InvalidRewriteAttribute{} -> False+ MissingDataDeclaration{} -> True -- not safe+ MissingDefinitions{} -> False -- not safe but deferred until after typechecking+ NotAllowedInMutual{} -> False -- really safe?+ OpenImportPrivate{} -> False+ OpenImportAbstract{} -> False+ PolarityPragmasButNotPostulates{} -> False+ PragmaNoTerminationCheck{} -> True -- not safe+ PragmaCompiled{} -> True -- not safe+ SafeFlagInjective {} -> True+ SafeFlagNoCoverageCheck {} -> True+ SafeFlagNoPositivityCheck {} -> True+ SafeFlagNoUniverseCheck {} -> True+ SafeFlagNonTerminating {} -> True+ SafeFlagPolarity {} -> True+ SafeFlagTerminating {} -> True+ ShadowingInTelescope{} -> False+ UnknownFixityInMixfixDecl{} -> False+ UnknownNamesInFixityDecl{} -> False+ UnknownNamesInPolarityPragmas{} -> False+ UselessAbstract{} -> False+ UselessImport{} -> False+ UselessInstance{} -> False+ UselessMacro{} -> False+ UselessPrivate{} -> False++-- | Pragmas not allowed in @--safe@ mode produce an 'unsafeDeclarationWarning'.+--+unsafePragma :: CMaybe DeclarationWarning' m => Pragma -> m+unsafePragma p =+ case p of+ BuiltinPragma{} -> empty+ CatchallPragma{} -> empty+ CompilePragma{} -> singleton $ PragmaCompiled r+ DisplayPragma{} -> empty+ EtaPragma{} -> empty+ EtaEqualityPragma{} -> empty+ ForeignPragma{} -> empty+ ImpossiblePragma{} -> empty+ InjectivePragma{} -> singleton $ SafeFlagInjective r+ InjectiveForInferencePragma{} -> empty+ InlinePragma{} -> empty+ NoCoverageCheckPragma{} -> singleton $ SafeFlagNoCoverageCheck r+ NoPositivityCheckPragma{} -> singleton $ SafeFlagNoPositivityCheck r+ NoUniverseCheckPragma{} -> singleton $ SafeFlagNoUniverseCheck r+ NotProjectionLikePragma{} -> empty+ OptionsPragma{} -> empty+ PolarityPragma{} -> singleton $ SafeFlagPolarity r+ RewritePragma{} -> empty+ -- @RewritePragma@ already requires --rewriting which is incompatible with --safe+ StaticPragma{} -> empty+ TerminationCheckPragma _ m ->+ case m of+ NonTerminating -> singleton $ SafeFlagNonTerminating r+ Terminating -> singleton $ SafeFlagTerminating r+ TerminationCheck -> empty+ TerminationMeasure{} -> empty+ -- @NO_TERMINATION_CHECK@ pragma was removed, but still parses. See Issue #1763.+ -- There is the unsafe @'PragmaNoTerminationCheck'@ warning thrown already,+ -- so we need not throw anything here.+ NoTerminationCheck -> empty+ WarningOnImport{} -> empty+ WarningOnUsage{} -> empty+ OverlapPragma{} -> empty+ where+ r = getRange p++------------------------------------------------------------------------+-- Instances++instance HasRange DeclarationException where+ getRange (DeclarationException _ err) = getRange err++instance HasRange DeclarationException' where+ getRange (MultipleEllipses d) = getRange d+ getRange (DuplicateDefinition x _) = getRange x+ getRange (DuplicateAnonDeclaration r _) = r+ getRange (MissingWithClauses _x lhs) = getRange lhs+ getRange (WrongDefinition x _k _k') = getRange x+ getRange (AmbiguousFunClauses lhs _xs) = getRange lhs+ getRange (AmbiguousConstructor r _ _) = r+ getRange (WrongContentBlock _ r) = r+ getRange (InvalidMeasureMutual r) = r+ getRange (UnquoteDefRequiresSignature xs) = getRange xs+ getRange (BadMacroDef d) = getRange d+ getRange (UnfoldingOutsideOpaque kwr) = getRange kwr+ getRange (OpaqueInMutual kwr) = getRange kwr+ getRange (DisallowedInterleavedMutual kwr _ _)= getRange kwr++instance HasRange DeclarationWarning where+ getRange (DeclarationWarning _ w) = getRange w++instance HasRange DeclarationWarning' where+ getRange = \case+ DivergentModalityInClause _ ai -> getRange ai+ EmptyAbstract kwr -> getRange kwr+ EmptyConstructor kwr -> getRange kwr+ EmptyField kwr -> getRange kwr+ EmptyGeneralize kwr -> getRange kwr+ EmptyInstance kwr -> getRange kwr+ EmptyMacro kwr -> getRange kwr+ EmptyMutual kwr -> getRange kwr+ EmptyPostulate kwr -> getRange kwr+ EmptyPrimitive kwr -> getRange kwr+ EmptyPrivate kwr -> getRange kwr+ EmptyPolarityPragma r -> r+ FixityDeclarationForNonOperator r _ -> r+ HiddenGeneralize r -> r+ InvalidCatchallPragma r -> r+ InvalidConstructorBlock r -> r+ InvalidCoverageCheckPragma r -> r+ InvalidDataOrRecDefParameter r _ _ _ -> r+ InvalidEtaEqualityPragma r -> r+ InvalidNoPositivityCheckPragma r -> r+ InvalidNoUniverseCheckPragma r -> r+ InvalidTerminationCheckPragma r -> r+ InvalidTacticAttribute r -> r+ InvalidRewriteAttribute r -> r+ MissingDataDeclaration x -> getRange x+ MissingDefinitions xs -> getRange xs+ NotAllowedInMutual r _x -> r+ OpenImportAbstract r _kwr _ -> getRange r+ OpenImportPrivate _r kwr _kwr _ -> getRange kwr+ PolarityPragmasButNotPostulates xs -> getRange xs+ PragmaCompiled r -> r+ PragmaNoTerminationCheck r -> r+ SafeFlagInjective r -> r+ SafeFlagNoCoverageCheck r -> r+ SafeFlagNoPositivityCheck r -> r+ SafeFlagNoUniverseCheck r -> r+ SafeFlagNonTerminating r -> r+ SafeFlagPolarity r -> r+ SafeFlagTerminating r -> r+ ShadowingInTelescope ns -> getRange ns+ UnknownFixityInMixfixDecl xs -> getRange xs+ UnknownNamesInFixityDecl xs -> getRange xs+ UnknownNamesInPolarityPragmas xs -> getRange xs+ UselessAbstract kwr -> getRange kwr+ UselessImport r -> r+ UselessInstance kwr -> getRange kwr+ UselessMacro kwr -> getRange kwr+ UselessPrivate kwr -> getRange kwr++-- These error messages can (should) be terminated by a dot ".",+-- there is no error context printed after them.+instance Pretty DeclarationException' where+ pretty (MultipleEllipses p) = fsep $+ pwords "Multiple ellipses in left-hand side" ++ [pretty p]+ pretty (DuplicateDefinition x y) = fsep $+ pwords "Duplicate definition of" ++ [pretty x <> "."] +++ pwords "Previous definition at" ++ [pretty y]+ pretty (DuplicateAnonDeclaration _ y) = fsep $+ pwords "Duplicate declaration of _." +++ pwords "Previous definition at" ++ [pretty y]+ pretty (MissingWithClauses x _lhs) = fsep $+ pwords "Missing with-clauses for function" ++ [pretty x]++ pretty (WrongDefinition x k k') = fsep $ pretty x :+ pwords ("has been declared as a " ++ prettyShow k +++ ", but is being defined as a " ++ prettyShow k')+ pretty (AmbiguousFunClauses lhs xs) = vcat $+ "More than one matching type signature for left hand side" :+ pretty lhs :+ "Candidates:" :+ map (("-" <+>) . pretty . PrintRange) (List1.toList xs)+ pretty (AmbiguousConstructor _ n ns) = sep+ [ fsep (pwords "Could not find a matching data signature for constructor " ++ [pretty n])+ , vcat (case ns of+ [] -> [fsep $ pwords "There was no candidate."]+ _ -> fsep (pwords "It could be any of:") : fmap (pretty . PrintRange) ns+ )+ ]+ pretty (WrongContentBlock b _) = fsep . pwords $+ case b of+ PostulateBlock -> "A `postulate` block can only contain type signatures, possibly under keywords `instance` and `private`"+ DataBlock -> "A data definition can only contain type signatures, possibly under keyword instance"+ _ -> "Unexpected declaration"+ pretty (InvalidMeasureMutual _) = fsep $+ pwords "In a mutual block, either all functions must have the same (or no) termination checking pragma."+ pretty (UnquoteDefRequiresSignature xs) = fsep $+ pwords "Missing type signatures for unquoteDef" ++ map pretty (List1.toList xs)+ pretty (BadMacroDef nd) = fsep $+ text (declName nd) : pwords "are not allowed in macro blocks"+ pretty (UnfoldingOutsideOpaque _) = fsep . pwords $+ "Unfolding declarations can only appear as the first declaration immediately contained in an opaque block."+ pretty (OpaqueInMutual _) = fsep $+ pwords "Opaque blocks can not participate in mutual recursion. If the opaque definitions are to be mutually recursive, move the `mutual` block inside the `opaque` block."+ pretty (DisallowedInterleavedMutual _ what xs) = vcat $ List1.concat+ [ singleton $ fsep $ pwords "The following names are declared, but not accompanied by a definition:"+ -- Andreas, 2023-09-07, issue #6823: print also the range.+ -- Print a bullet list; thus, the plural version of this error message is sufficient.+ , fmap (("-" <+>) . pretty . PrintRange) xs+ , singleton $ fwords $ "Since " ++ what ++ " can not participate in mutual recursion, their definition must be given before this point."+ ]++instance Pretty DeclarationWarning where+ pretty (DeclarationWarning _ w) = pretty w++instance Pretty DeclarationWarning' where+ pretty = \case++ DivergentModalityInClause sigInfo clInfo -> fsep $ concat+ [ pwords "Ignoring the modality"+ , [ pretty (getModality clInfo) ]+ , pwords "of the clause that diverges from the declared modality"+ , [ pretty (getModality sigInfo) ]+ , pwords "of the function"+ ]++ UnknownNamesInFixityDecl xs ->+ fwords "The following names are not declared in the same scope as their syntax or fixity declaration (i.e., either not in scope at all, imported from another module, or declared in a super module):"+ <?>+ fsep (fmap pretty $ Set1.toList xs)++ UnknownFixityInMixfixDecl xs ->+ fwords "The following mixfix names lack an associated fixity declaration:"+ <?>+ fsep (fmap pretty $ Set1.toList xs)++ UnknownNamesInPolarityPragmas xs ->+ fwords "The following names are not declared in the same scope as their polarity pragmas (they could for instance be out of scope, imported from another module, or declared in a super module):"+ <?>+ fsep (fmap pretty $ Set1.toList xs)++ MissingDataDeclaration x -> fsep $ concat+ [ pwords "Data definition"+ , [ pretty x ]+ , pwords "misses a data declaration"+ ]++ MissingDefinitions xs ->+ fwords "The following names are declared but lack a definition:"+ <?>+ fsep (fmap (pretty . fst) xs)++ NotAllowedInMutual _r nd -> fsep $+ text nd : pwords "in mutual blocks are not supported. Suggestion: get rid of the mutual block by manually ordering declarations"++ PolarityPragmasButNotPostulates xs ->+ fwords "Polarity pragmas have been given for the following identifiers which are not postulates:"+ <?>+ fsep (fmap pretty $ Set1.toList xs)++ UselessPrivate _ -> fsep $+ pwords "Using private here has no effect. Private applies only to declarations that introduce new identifiers into the module, like type signatures except for constructors, and data, record, and module declarations"++ UselessAbstract _ -> fsep $+ pwords "Using abstract here has no effect. Abstract applies to only definitions like data definitions, record type definitions and function clauses."++ UselessImport _ -> fsep $+ pwords "An import statement with module instantiation is useless without either an `open' keyword or an `as` binding giving a name to the instantiated module."++ UselessInstance _ -> fsep $+ pwords "Using instance here has no effect. Instance applies only to (function) definitions, constructor declarations and axioms (other than primitives)."++ UselessMacro _ -> fsep $+ pwords "Using a macro block here has no effect. `macro' applies only to function definitions."++ EmptyMutual _ -> fsep $ pwords "Empty mutual block."++ EmptyConstructor{} -> fsep $ pwords "Empty constructor block."++ EmptyAbstract _ -> fsep $ pwords "Empty abstract block."++ EmptyPrivate _ -> fsep $ pwords "Empty private block."++ EmptyInstance _ -> fsep $ pwords "Empty instance block."++ EmptyMacro _ -> fsep $ pwords "Empty macro block."++ EmptyPostulate _ -> fsep $ pwords "Empty postulate block."++ EmptyGeneralize _ -> fsep $ pwords "Empty variable block."++ EmptyPrimitive _ -> fsep $ pwords "Empty primitive block."++ EmptyField _ -> fsep $ pwords "Empty field block."++ EmptyPolarityPragma _ -> fsep $ pwords "POLARITY pragma without polarities (ignored)."++ FixityDeclarationForNonOperator _r x -> fsep $+ pwords "Deprecated: fixity declaration for" ++ [d, pretty x]+ where+ -- Precondition: x is not an in-, pre- or post-fix operator.+ d | any isHole (nameParts x) = "closed operator"+ | otherwise = "non-operator"++ HiddenGeneralize _ -> fsep $ pwords "Declaring a variable as hidden has no effect in a variable block. Generalization never introduces visible arguments."++ InvalidDataOrRecDefParameter _ dataOrRec what explanation -> fsep $ concat+ [ [ "Ignoring" ]+ , twords what+ , pwords "in"+ , [ ifThenElse dataOrRec "data" "record", "definition" ]+ , twords explanation+ ]++ InvalidTacticAttribute _ -> fsep $+ pwords "Ignoring misplaced tactic attribute."++ InvalidRewriteAttribute _ -> fsep $+ pwords "Ignoring misplaced local rewrite attribute."++ InvalidTerminationCheckPragma _ -> fsep $+ pwords "Termination checking pragmas can only precede a function definition or a mutual block (that contains a function definition)."++ InvalidConstructorBlock{} -> fsep $+ pwords "No `data _ where' blocks outside of `interleaved mutual' blocks."++ InvalidCoverageCheckPragma _ -> fsep $+ pwords "Coverage checking pragmas can only precede a function definition or a mutual block (that contains a function definition)."++ InvalidNoPositivityCheckPragma _ -> fsep $+ pwords "NO_POSITIVITY_CHECKING pragmas can only precede a data/record definition or a mutual block (that contains a data/record definition)."++ InvalidCatchallPragma _ -> fsep $+ pwords "The CATCHALL pragma can only precede a function clause."++ InvalidEtaEqualityPragma _ -> fsep $+ pwords "The ETA_EQUALITY pragma can only precede a record definition."++ InvalidNoUniverseCheckPragma _ -> fsep $+ pwords "NO_UNIVERSE_CHECKING pragmas can only precede a data/record definition."++ PragmaNoTerminationCheck _ -> fsep $+ pwords "Pragma {-# NO_TERMINATION_CHECK #-} has been removed. To skip the termination check, label your definitions either as {-# TERMINATING #-} or {-# NON_TERMINATING #-}."++ PragmaCompiled _ -> fsep $+ pwords "COMPILE pragma not allowed in safe mode."++ OpenImportAbstract _ _ openOrImport -> fsep $ concat+ [ pwords "`abstract' does not have any effect on"+ , [ pretty openOrImport ]+ , pwords "so better place this statement outside of the abstract block"+ ]++ OpenImportPrivate _ _ _ _openOrImport -> fsep $ concat+ [ pwords "`private' does not have any effect on"+ , pwords "`open public'"+ , pwords "so better place this statement outside of the private block"+ ]++ ShadowingInTelescope nrs ->+ fwords "Shadowing in telescope, repeated variable names:"+ <?>+ fsep (fmap (pretty . fst) nrs)++ SafeFlagInjective _ -> unsafePragma "INJECTIVE"+ SafeFlagNoCoverageCheck _ -> unsafePragma "NON_COVERING"+ SafeFlagNoPositivityCheck _ -> unsafePragma "NO_POSITIVITY_CHECK"+ SafeFlagNoUniverseCheck _ -> unsafePragma "NO_UNIVERSE_CHECK"+ SafeFlagNonTerminating _ -> unsafePragma "NON_TERMINATING"+ SafeFlagPolarity _ -> unsafePragma "POLARITY"+ SafeFlagTerminating _ -> unsafePragma "TERMINATING"++ where+ unsafePragma s = fsep $ ["Cannot", "use", s] ++ pwords "pragma with safe flag."++instance Pretty OpenOrImport where+ pretty = \case+ OpenNotImport -> "`open'"+ ImportMayOpen -> "`import'"++instance NFData DeclarationException'+instance NFData DeclarationWarning+instance NFData DeclarationWarning'+instance NFData OpenOrImport
@@ -0,0 +1,284 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Syntax.Concrete.Definitions.Monad where++import Prelude hiding ( null )++import Control.Monad ( )+import Control.Monad.Except ( MonadError(..), ExceptT, runExceptT )+import Control.Monad.Reader ( MonadReader, ReaderT, runReaderT )+import Control.Monad.State ( MonadState(..), modify, State, StateT, runState )++import Data.Bifunctor (second)+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe (catMaybes)++import Agda.Syntax.Position+import Agda.Syntax.Common hiding (TerminationCheck())+import Agda.Syntax.Concrete ( WhereClause_ )+import Agda.Syntax.Concrete.Name+import Agda.Syntax.Concrete.Definitions.Types+import Agda.Syntax.Concrete.Definitions.Errors++import Agda.Utils.CallStack ( CallStack, HasCallStack, withCallerCallStack )+import Agda.Utils.Lens+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Null (Null(..))++import Agda.Utils.Impossible++-- | Nicifier monad.+-- Preserve the state when throwing an exception.++newtype Nice a = Nice { unNice :: ReaderT NiceEnv (ExceptT DeclarationException (State NiceState)) a }+ deriving ( Functor, Applicative, Monad+ , MonadReader NiceEnv, MonadState NiceState, MonadError DeclarationException+ )++-- | Extension of the nicifier monad with state to process interleaved mutual blocks.+type INice = StateT InterleavedState Nice++-- | Run a Nicifier computation, return result and warnings+-- (in chronological order).+runNice :: NiceEnv -> Nice a -> (Either DeclarationException a, NiceWarnings)+runNice env m = second (reverse . niceWarn) $+ runExceptT (unNice m `runReaderT` env) `runState` initNiceState++instance Null a => Null (Nice a) where+ empty = pure empty+ null _ = __IMPOSSIBLE__++-- | Nicifier parameters.++data NiceEnv = NiceEnv+ { safeButNotBuiltin :: Bool+ -- ^ We are in a module declared @--safe@ which is not a builtin module.+ , checkingWhere :: WhereClause_+ -- ^ Are we checking a @where@ module?+ }++-- | Nicifier state.++data NiceState = NiceState+ { _loneSigs :: LoneSigs+ -- ^ Lone type signatures that wait for their definition.+ , _termChk :: TerminationCheck+ -- ^ Termination checking pragma waiting for a definition.+ , _posChk :: PositivityCheck+ -- ^ Positivity checking pragma waiting for a definition.+ , _uniChk :: UniverseCheck+ -- ^ Universe checking pragma waiting for a data/rec signature or definition.+ , _forceEta :: ForceRecordEta+ -- ^ @ETA_EQUALITY@ pragma waiting for a record signature or definition.+ , _catchall :: Catchall+ -- ^ Catchall pragma waiting for a function clause.+ , _covChk :: CoverageCheck+ -- ^ Coverage pragma waiting for a definition.+ , niceWarn :: NiceWarnings+ -- ^ Stack of warnings. Head is last warning.+ , _nameId :: NameId+ -- ^ We distinguish different 'NoName's (anonymous definitions) by a unique 'NameId'.+ }++data LoneSig = LoneSig+ { loneSigRange :: Range+ , loneSigName :: Name+ -- ^ If 'isNoName', this name can have a different 'NameId'+ -- than the key of 'LoneSigs' pointing to it.+ , loneSigKind :: DataRecOrFun+ }+ deriving Show++type LoneSigs = Map Name LoneSig+ -- ^ We retain the 'Name' also in the codomain since+ -- 'Name' as a key is up to @Eq Name@ which ignores the range.+ -- However, without range names are not unique in case the+ -- user gives a second definition of the same name.+ -- This causes then problems in 'replaceSigs' which might+ -- replace the wrong signature.+ --+ -- Another reason is that we want to distinguish different+ -- occurrences of 'NoName' in a mutual block (issue #4157).+ -- The 'NoName' in the codomain will have a unique 'NameId'.++type NiceWarnings = [DeclarationWarning]+ -- ^ Stack of warnings. Head is last warning.++-- | Initial nicifier state.++initNiceState :: NiceState+initNiceState = NiceState+ { _loneSigs = Map.empty+ , _termChk = TerminationCheck+ , _posChk = YesPositivityCheck+ , _uniChk = YesUniverseCheck+ , _forceEta = empty+ , _catchall = empty+ , _covChk = YesCoverageCheck+ , niceWarn = []+ , _nameId = NameId 1 noModuleNameHash+ }++lensNameId :: Lens' NiceState NameId+lensNameId f e = f (_nameId e) <&> \ i -> e { _nameId = i }++nextNameId :: Nice NameId+nextNameId = do+ i <- use lensNameId+ lensNameId %= succ+ return i++-- * Handling the lone signatures, stored to infer mutual blocks.++-- | Lens for field '_loneSigs'.++loneSigs :: Lens' NiceState LoneSigs+loneSigs f e = f (_loneSigs e) <&> \ s -> e { _loneSigs = s }++-- | Adding a lone signature to the state.+-- Return the name (which is made unique if 'isNoName').++addLoneSig :: Range -> Name -> DataRecOrFun -> Nice Name+addLoneSig r x k = do+ -- Andreas, 2020-05-19, issue #4157, make '_' unique.+ x' <- case x of+ Name{} -> pure x+ NoName r _ -> NoName r <$> nextNameId+ loneSigs %== \ s -> do+ let (mr, s') = Map.insertLookupWithKey (\ _k new _old -> new) x (LoneSig r x' k) s+ case mr of+ Nothing -> return s'+ Just y -> declarationException $+ if not $ isNoName x then DuplicateDefinition x (loneSigRange y) else DuplicateAnonDeclaration r (loneSigRange y)+ return x'++-- | Remove a lone signature from the state.++removeLoneSig :: Name -> Nice ()+removeLoneSig x = loneSigs %= Map.delete x++-- | Search for forward type signature.++getSig :: Name -> Nice (Maybe DataRecOrFun)+getSig x = fmap loneSigKind . Map.lookup x <$> use loneSigs++-- | Check that no lone signatures are left in the state.++noLoneSigs :: Nice Bool+noLoneSigs = null <$> use loneSigs++forgetLoneSigs :: Nice ()+forgetLoneSigs = loneSigs .= Map.empty++-- | Ensure that all forward declarations have been given a definition.+checkLoneSigs :: LoneSigs -> Nice ()+checkLoneSigs xs = do+ forgetLoneSigs+ List1.unlessNull (Map.elems xs) \ ss -> declarationWarning $ MissingDefinitions $+ fmap (\s -> (loneSigName s , loneSigRange s)) ss++-- | Ensure that all forward declarations have been given a definition,+-- raising an error indicating *why* they would have had to have been+-- defined.+breakImplicitMutualBlock :: KwRange -> String -> Nice ()+breakImplicitMutualBlock r why = do+ m <- use loneSigs+ List1.unlessNull (Map.elems m) $ \ xs ->+ declarationException $ DisallowedInterleavedMutual r why $+ -- Andreas, 2023-09-07: We discard the 'loneSigRange's because the 'Name' already has a range.+ fmap loneSigName xs++-- | Get names of lone function signatures, plus their unique names.++loneFuns :: LoneSigs -> [(Name, Arg Name)]+loneFuns ls = catMaybes $+ Map.toList ls <&> \case+ (x, LoneSig _ x' (FunName ai _ _)) -> Just (x, Arg ai x')+ _ -> Nothing++-- | Create a 'LoneSigs' map from an association list.++loneSigsFromLoneNames :: [(Range, Name, DataRecOrFun)] -> LoneSigs+loneSigsFromLoneNames = Map.fromListWith __IMPOSSIBLE__ . map (\(r,x,k) -> (x, LoneSig r x k))++-- | Lens for field '_termChk'.++terminationCheckPragma :: Lens' NiceState TerminationCheck+terminationCheckPragma f e = f (_termChk e) <&> \ s -> e { _termChk = s }++-- | Set 'terminationCheckPragma' to given value for a local computation.++withTerminationCheckPragma :: TerminationCheck -> Nice a -> Nice a+withTerminationCheckPragma = locallyState terminationCheckPragma . const++-- | Lens for field '_covChk'.++coverageCheckPragma :: Lens' NiceState CoverageCheck+coverageCheckPragma f e = f (_covChk e) <&> \ s -> e { _covChk = s }++-- | Set 'coverageCheckPragma' to given value for a local computation.++withCoverageCheckPragma :: CoverageCheck -> Nice a -> Nice a+withCoverageCheckPragma = locallyState coverageCheckPragma . const++-- | Lens for field '_forceEta'.++etaEqualityPragma :: Lens' NiceState ForceRecordEta+etaEqualityPragma f e = f (_forceEta e) <&> \ s -> e { _forceEta = s }++withEtaEqualityPragma :: ForceRecordEta -> Nice a -> Nice a+withEtaEqualityPragma = locallyState etaEqualityPragma . const++-- | Lens for field '_posChk'.++positivityCheckPragma :: Lens' NiceState PositivityCheck+positivityCheckPragma f e = f (_posChk e) <&> \ s -> e { _posChk = s }++-- | Set 'positivityCheckPragma' to given value for a local computation.++withPositivityCheckPragma :: PositivityCheck -> Nice a -> Nice a+withPositivityCheckPragma = locallyState positivityCheckPragma . const++-- | Lens for field '_uniChk'.++universeCheckPragma :: Lens' NiceState UniverseCheck+universeCheckPragma f e = f (_uniChk e) <&> \ s -> e { _uniChk = s }++-- | Set 'universeCheckPragma' to given value for a local computation.++withUniverseCheckPragma :: UniverseCheck -> Nice a -> Nice a+withUniverseCheckPragma = locallyState universeCheckPragma . const++-- | Lens for field '_catchall'.++catchallPragma :: Lens' NiceState Catchall+catchallPragma f e = f (_catchall e) <&> \ s -> e { _catchall = s }++-- | Get current catchall pragma, and reset it for the next clause.++popCatchallPragma :: Nice Catchall+popCatchallPragma = do+ ca <- use catchallPragma+ catchallPragma .= empty+ return ca++-- | Set 'catchallPragma' to given value for a local computation.++withCatchallPragma :: Catchall -> Nice a -> Nice a+withCatchallPragma = locallyState catchallPragma . const++-- | Add a new warning.+niceWarning :: DeclarationWarning -> Nice ()+niceWarning w = modify $ \ st -> st { niceWarn = w : niceWarn st }++declarationException :: HasCallStack => DeclarationException' -> Nice a+declarationException e = withCallerCallStack $ throwError . flip DeclarationException e++declarationWarning' :: DeclarationWarning' -> CallStack -> Nice ()+declarationWarning' w loc = niceWarning $ DeclarationWarning loc w++declarationWarning :: HasCallStack => DeclarationWarning' -> Nice ()+declarationWarning = withCallerCallStack . declarationWarning'
@@ -0,0 +1,360 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Syntax.Concrete.Definitions.Types where++import Control.DeepSeq++import Data.Map (Map)++import GHC.Generics (Generic)++import Agda.Syntax.Position+import Agda.Syntax.Common hiding (TerminationCheck())+import qualified Agda.Syntax.Common as Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete+import Agda.Syntax.Concrete.Name ()+import Agda.Syntax.Concrete.Pretty ()++import Agda.Utils.List1 (List1)++{--------------------------------------------------------------------------+ Types+ --------------------------------------------------------------------------}++{-| The nice declarations. No fixity declarations and function definitions are+ contained in a single constructor instead of spread out between type+ signatures and clauses. The @private@, @postulate@, @abstract@ and @instance@+ modifiers have been distributed to the individual declarations.++ Observe the order of components:++ Range+ Fixity'+ Access+ IsAbstract+ IsInstance+ TerminationCheck+ PositivityCheck++ further attributes++ (Q)Name++ content (Expr, Declaration ...)+-}+data NiceDeclaration+ = Axiom Range Access IsAbstract IsInstance ArgInfo Name Expr+ -- ^ 'IsAbstract' argument: We record whether a declaration was made in an @abstract@ block.+ --+ -- 'ArgInfo' argument: Axioms and functions can be declared irrelevant.+ -- ('Hiding' should be 'NotHidden'.)+ | NiceField Range Access IsAbstract IsInstance TacticAttribute Name (Arg Expr)+ | PrimitiveFunction Range Access IsAbstract Name (Arg Expr)+ | NiceMutual KwRange TerminationCheck CoverageCheck PositivityCheck (List1 NiceDeclaration)+ | NiceModule Range Access IsAbstract Erased QName Telescope+ [Declaration]+ | NiceModuleMacro Range Access Erased Name ModuleApplication+ OpenShortHand ImportDirective+ | NiceOpen KwRange QName ImportDirective+ | NiceImport OpenShortHand KwRange QName (Either AsName RawOpenArgs) ImportDirective+ | NicePragma Range Pragma+ | NiceRecSig Range Erased Access IsAbstract PositivityCheck+ UniverseCheck ForceRecordEta Name Parameters Expr+ | NiceDataSig Range Erased Access IsAbstract PositivityCheck+ UniverseCheck Name Parameters Expr+ | NiceFunClause Range Access IsAbstract TerminationCheck CoverageCheck Catchall Declaration+ -- ^ An uncategorized function clause, could be a function clause+ -- without type signature or a pattern lhs (e.g. for irrefutable let).+ -- The 'Declaration' is the actual 'FunClause'.+ | FunSig Range Access IsAbstract IsInstance IsMacro ArgInfo TerminationCheck CoverageCheck Name Expr+ | FunDef Range (List1 Declaration) IsAbstract IsInstance TerminationCheck CoverageCheck Name (List1 Clause)+ -- ^ Block of function clauses (we have seen the type signature before).+ -- The 'Declaration's are the original declarations that were processed+ -- into this 'FunDef' and are only used in 'notSoNiceDeclaration'.+ -- Andreas, 2017-01-01: Because of issue #2372, we add 'IsInstance' here.+ -- An alias should know that it is an instance.+ | NiceDataDef Range Origin IsAbstract PositivityCheck UniverseCheck Name DefParameters [NiceConstructor]+ | NiceLoneConstructor KwRange [NiceConstructor]+ | NiceRecDef Range Origin IsAbstract PositivityCheck UniverseCheck ForceRecordEta Name [RecordDirective] DefParameters [Declaration]+ -- ^ @(Maybe Range)@ gives range of the 'pattern' declaration.+ | NicePatternSyn Range Access Name [WithHiding Name] Pattern+ | NiceGeneralize Range Access ArgInfo TacticAttribute Name Expr+ | NiceUnquoteDecl Range Access IsAbstract IsInstance TerminationCheck CoverageCheck [Name] Expr+ | NiceUnquoteDef Range Access IsAbstract TerminationCheck CoverageCheck [Name] Expr+ | NiceUnquoteData Range Access IsAbstract PositivityCheck UniverseCheck Name [Name] Expr+ | NiceOpaque KwRange [QName] [NiceDeclaration]+ deriving (Show, Generic)++instance NFData NiceDeclaration++type TerminationCheck = Common.TerminationCheck Measure++-- | Termination measure is, for now, a variable name.+type Measure = Name++-- | Only 'Axiom's.+type NiceConstructor = NiceTypeSignature++-- | Only 'Axiom's.+type NiceTypeSignature = NiceDeclaration++-- | One clause in a function definition. There is no guarantee that the 'LHS'+-- actually declares the 'Name'. We will have to check that later.+data Clause = Clause Name Catchall ArgInfo LHS RHS WhereClause [Clause]+ deriving (Show, Generic)++instance NFData Clause++instance LensArgInfo Clause where+ getArgInfo (Clause _ _ ai _ _ _ _) = ai+ mapArgInfo f (Clause x ca ai lhs rhs wh cs) = Clause x ca (f ai) lhs rhs wh cs++-- | When processing a mutual block we collect the various checks present in the block+-- before combining them.++data MutualChecks = MutualChecks+ { mutualTermination :: [TerminationCheck]+ , mutualCoverage :: [CoverageCheck]+ , mutualPositivity :: [PositivityCheck]+ }++instance Semigroup MutualChecks where+ MutualChecks a b c <> MutualChecks a' b' c'+ = MutualChecks (a <> a') (b <> b') (c <> c')++instance Monoid MutualChecks where+ mempty = MutualChecks [] [] []+ mappend = (<>)++-- | In an inferred `mutual' block we keep accumulating nice declarations until all+-- of the lone signatures have an attached definition. The type is therefore a bit+-- span-like: we return an initial segment (the inferred mutual block) together+-- with leftovers.++data InferredMutual = InferredMutual+ { inferredChecks :: MutualChecks -- checks for this block+ , inferredBlock :: [NiceDeclaration] -- mutual block+ , inferredLeftovers :: [NiceDeclaration] -- leftovers+ }++extendInferredBlock :: NiceDeclaration -> InferredMutual -> InferredMutual+extendInferredBlock d (InferredMutual cs ds left) = InferredMutual cs (d : ds) left++-- | In an `interleaved mutual' block we collect the data signatures, function signatures,+-- as well as their associated constructors and function clauses respectively.+-- Each signature is given a position in the block (from 0 onwards) and each set+-- of constructor / clauses is given a *distinct* one. This allows for interleaved+-- forward declarations similar to what one gets in a new-style mutual block.+type InterleavedMutual = Map Name InterleavedDecl++data InterleavedDecl+ = InterleavedData+ { interleavedDeclNum :: DeclNum+ -- ^ Internal number of the data signature.+ , interleavedDeclSig :: NiceDeclaration+ -- ^ The data signature.+ , interleavedDataCons :: Maybe (DeclNum, List1 (DefParameters, [NiceConstructor]))+ -- ^ Constructors associated to the data signature.+ }+ | InterleavedFun+ { interleavedDeclNum :: DeclNum+ -- ^ Internal number of the function signature.+ , interleavedDeclSig :: NiceDeclaration+ -- ^ The function signature.+ , interleavedFunClauses :: Maybe (DeclNum, List1 (List1 Declaration, List1 Clause))+ -- ^ Function clauses associated to the function signature.+ }++-- | Extra state for the 'Nice' monad to process interleaved mutual blocks.+data InterleavedState = ISt+ { interleavedMutual :: InterleavedMutual+ , interleavedMutualChecks :: MutualChecks+ , interleavedCurrentDeclNum :: DeclNum+ }++-- | Numbering declarations in an @interleaved mutual@ block.+type DeclNum = Int++instance HasRange InterleavedDecl where+ getRange :: InterleavedDecl -> Range+ getRange (InterleavedFun _ d _) = getRange d+ getRange (InterleavedData _ d _) = getRange d++isInterleavedFun :: InterleavedDecl -> Maybe ()+isInterleavedFun InterleavedFun{} = Just ()+isInterleavedFun _ = Nothing++isInterleavedData :: InterleavedDecl -> Maybe ()+isInterleavedData InterleavedData{} = Just ()+isInterleavedData _ = Nothing++-- | Several declarations expect only type signatures as sub-declarations. These are:+data KindOfBlock+ = PostulateBlock -- ^ @postulate@.+ | PrimitiveBlock -- ^ @primitive@.+ | FieldBlock -- ^ @field@. Ensured by parser.+ | DataBlock -- ^ @data ... where@. Here we got a bad error message for Agda-2.5 (Issue 1698).+ | ConstructorBlock -- ^ @constructor@, in @interleaved mutual@.+ deriving (Eq, Ord, Show, Generic)++instance NFData KindOfBlock++instance HasRange NiceDeclaration where+ getRange (Axiom r _ _ _ _ _ _) = r+ getRange (NiceField r _ _ _ _ _ _) = r+ getRange (NiceMutual kwr _ _ _ ds) = fuseRange kwr ds+ getRange (NiceModule r _ _ _ _ _ _ ) = r+ getRange (NiceModuleMacro r _ _ _ _ _ _) = r+ getRange (NiceOpen kwr x dir) = getRange (kwr, x, dir)+ getRange (NiceImport o r x as dir) = getRange (o, r, x, as, dir)+ getRange (NicePragma r _) = r+ getRange (PrimitiveFunction r _ _ _ _) = r+ getRange (FunSig r _ _ _ _ _ _ _ _ _) = r+ getRange (FunDef r _ _ _ _ _ _ _) = r+ getRange (NiceDataDef r _ _ _ _ _ _ _) = r+ getRange (NiceLoneConstructor kwr ds) = fuseRange kwr ds+ getRange (NiceRecDef r _ _ _ _ _ _ _ _ _)= r+ getRange (NiceRecSig r _ _ _ _ _ _ _ _ _)= r+ getRange (NiceDataSig r _ _ _ _ _ _ _ _) = r+ getRange (NicePatternSyn r _ _ _ _) = r+ getRange (NiceGeneralize r _ _ _ _ _) = r+ getRange (NiceFunClause r _ _ _ _ _ _) = r+ getRange (NiceUnquoteDecl r _ _ _ _ _ _ _) = r+ getRange (NiceUnquoteDef r _ _ _ _ _ _) = r+ getRange (NiceUnquoteData r _ _ _ _ _ _ _) = r+ getRange (NiceOpaque kwr xs ds) = getRange (kwr, xs, ds)++instance Pretty NiceDeclaration where+ pretty = \case+ Axiom _ _ _ _ _ x _ -> text "postulate" <+> pretty x <+> colon <+> text "_"+ NiceField _ _ _ _ _ x _ -> text "field" <+> pretty x+ PrimitiveFunction _ _ _ x _ -> text "primitive" <+> pretty x+ NiceMutual{} -> text "mutual"+ NiceOpaque _ _ ds -> text "opaque" <+> nest 2 (vcat (map pretty ds))+ NiceModule _ _ _ _ x _ _ -> text "module" <+> pretty x <+> text "where"+ NiceModuleMacro _ _ _ x _ _ _ -> text "module" <+> pretty x <+> text "= ..."+ NiceOpen _ x _ -> text "open" <+> pretty x+ NiceImport _ x _ _ _ -> text "import" <+> pretty x+ NicePragma{} -> text "{-# ... #-}"+ NiceRecSig _ _ _ _ _ _ _ x _ _ -> text "record" <+> pretty x+ NiceDataSig _ _ _ _ _ _ x _ _ -> text "data" <+> pretty x+ NiceFunClause{} -> text "<function clause>"+ FunSig _ _ _ _ _ _ _ _ x _ -> pretty x <+> colon <+> text "_"+ FunDef _ _ _ _ _ _ x _ -> pretty x <+> text "= _"+ NiceDataDef _ _ _ _ _ x _ _ -> text "data" <+> pretty x <+> text "where"+ NiceLoneConstructor _ _ -> text "data _ where"+ NiceRecDef _ _ _ _ _ _ x _ _ _ -> text "record" <+> pretty x <+> text "where"+ NicePatternSyn _ _ x _ _ -> text "pattern" <+> pretty x+ NiceGeneralize _ _ _ _ x _ -> text "variable" <+> pretty x+ NiceUnquoteDecl _ _ _ _ _ _ _xs _ -> text "<unquote declarations>"+ NiceUnquoteDef _ _ _ _ _ _xs _ -> text "<unquote definitions>"+ NiceUnquoteData _ _ _ _ _ _x _xs _ -> text "<unquote data types>"++declName :: NiceDeclaration -> String+declName Axiom{} = "Postulates"+declName NiceField{} = "Fields"+declName NiceMutual{} = "Mutual blocks"+declName NiceModule{} = "Modules"+declName NiceModuleMacro{} = "Modules"+declName NiceOpen{} = "Open declarations"+declName NiceImport{} = "Import statements"+declName NicePragma{} = "Pragmas"+declName PrimitiveFunction{} = "Primitive declarations"+declName NicePatternSyn{} = "Pattern synonyms"+declName NiceGeneralize{} = "Generalized variables"+declName NiceUnquoteDecl{} = "Unquoted declarations"+declName NiceUnquoteDef{} = "Unquoted definitions"+declName NiceUnquoteData{} = "Unquoted data types"+declName NiceRecSig{} = "Records"+declName NiceDataSig{} = "Data types"+declName NiceFunClause{} = "Functions without a type signature"+declName FunSig{} = "Type signatures"+declName FunDef{} = "Function definitions"+declName NiceRecDef{} = "Records"+declName NiceDataDef{} = "Data types"+declName NiceLoneConstructor{} = "Constructors"+declName NiceOpaque{} = "Opaque blocks"+++data InMutual+ = InMutual -- ^ we are nicifying a mutual block+ | NotInMutual -- ^ we are nicifying decls not in a mutual block+ deriving (Eq, Show)++-- | The kind of the forward declaration.++data DataRecOrFun+ = DataName+ { _kindPosCheck :: PositivityCheck+ , _kindUniCheck :: UniverseCheck+ }+ -- ^ Name of a data type+ | RecName+ { _kindPosCheck :: PositivityCheck+ , _kindUniCheck :: UniverseCheck+ , _kindForceEta :: ForceRecordEta+ }+ -- ^ Name of a record type+ | FunName ArgInfo TerminationCheck CoverageCheck+ -- ^ Name of a function.+ deriving (Show, Generic)++instance NFData DataRecOrFun++-- Ignore pragmas when checking equality+instance Eq DataRecOrFun where+ (==) = sameKind++sameKind :: DataRecOrFun -> DataRecOrFun -> Bool+sameKind = curry \case+ (DataName{} , DataName{}) -> True+ (RecName{} , RecName{} ) -> True+ (FunName{} , FunName{} ) -> True+ _ -> False++-- | Monoidal for 'DataName' and 'RecName'.+-- Returns just first 'FunName' discarding the second one.+mergeDataRecOrFun :: DataRecOrFun -> DataRecOrFun -> Maybe DataRecOrFun+mergeDataRecOrFun = curry \case+ (DataName pc uc , DataName pc' uc') -> Just $ DataName (pc <> pc') (uc <> uc')+ (RecName pc uc eta, RecName pc' uc' eta') -> Just $ RecName (pc <> pc') (uc <> uc') (eta <> eta')+ (f@FunName{} , FunName{} ) -> Just f+ _ -> Nothing++instance Pretty DataRecOrFun where+ pretty DataName{} = "data type"+ pretty RecName{} = "record type"+ pretty FunName{} = "function"++isFunName :: DataRecOrFun -> Bool+isFunName (FunName{}) = True+isFunName _ = False++terminationCheck :: DataRecOrFun -> TerminationCheck+terminationCheck (FunName _ tc _) = tc+terminationCheck _ = TerminationCheck++coverageCheck :: DataRecOrFun -> CoverageCheck+coverageCheck (FunName _ _ cc) = cc+coverageCheck _ = YesCoverageCheck++positivityCheck :: DataRecOrFun -> PositivityCheck+positivityCheck (DataName pc _) = pc+positivityCheck (RecName pc _ _)= pc+positivityCheck (FunName _ _ _) = YesPositivityCheck++mutualChecks :: DataRecOrFun -> MutualChecks+mutualChecks k = MutualChecks [terminationCheck k] [coverageCheck k] [positivityCheck k]++universeCheck :: DataRecOrFun -> UniverseCheck+universeCheck (DataName _ uc) = uc+universeCheck (RecName _ uc _)= uc+universeCheck (FunName _ _ _) = YesUniverseCheck++forceRecordEta :: DataRecOrFun -> ForceRecordEta+forceRecordEta (DataName _ _) = mempty+forceRecordEta (RecName _ _ eta) = eta+forceRecordEta (FunName _ _ _) = mempty
@@ -0,0 +1,306 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++-- | Collecting fixity declarations (and polarity pragmas) for concrete+-- declarations.++module Agda.Syntax.Concrete.Fixity+ ( Fixities, Polarities, MonadFixityError(..)+ , DoWarn(..)+ , fixitiesAndPolarities+ ) where++import Prelude hiding (null)++import Control.Monad+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe+import Data.Set (Set)+import qualified Data.Set as Set++import Agda.Syntax.Builtin (builtinById, isBuiltinNoDef)+import Agda.Syntax.Common+import Agda.Syntax.Concrete+import Agda.Syntax.Position+import Agda.Syntax.Notation (isPrePostOrInfixNotation)+import Agda.TypeChecking.Positivity.Occurrence (PragmaPolarities)++import Agda.Utils.CallStack (HasCallStack)+import Agda.Utils.Functor+import Agda.Utils.List1 (List1)+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Null+import Agda.Utils.Set1 (Set1)+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Tuple (Pair(Pair))++import Agda.Utils.Impossible++type Fixities = Map Name Fixity'+type Polarities = Map Name PragmaPolarities++class Monad m => MonadFixityError m where+ throwMultipleFixityDecls :: List1 (Name, Pair Fixity') -> m a+ throwMultiplePolarityPragmas :: List1 Name -> m a+ warnUnknownNamesInFixityDecl :: HasCallStack => Set1 Name -> m ()+ warnUnknownNamesInPolarityPragmas :: HasCallStack => Set1 Name -> m ()+ warnUnknownFixityInMixfixDecl :: HasCallStack => Set1 Name -> m ()+ warnPolarityPragmasButNotPostulates :: HasCallStack => Set1 Name -> m ()+ warnEmptyPolarityPragma :: HasCallStack => Range -> m ()+ warnFixityDeclarationForNonOperator :: HasCallStack => Range -> Name -> m ()++-- | Add more fixities. Throw an exception for multiple fixity declarations.+-- OR: Disjoint union of fixity maps. Throws exception if not disjoint.++plusFixities :: MonadFixityError m => Fixities -> Fixities -> m Fixities+plusFixities m1 m2+ -- If maps are not disjoint, report conflicts as exception.+ | Just ds <- List1.nonEmpty isect = throwMultipleFixityDecls ds+ -- Otherwise, do the union.+ | otherwise = return $ Map.unionWithKey mergeFixites m1 m2+ where+ -- Merge two fixities, assuming there is no conflict+ mergeFixites _name (Fixity' f1 s1 r1) (Fixity' f2 s2 r2) = Fixity' f s r+ where+ (f, rf)+ | null f1 = (f2, r2)+ | null f2 = (f1, r1)+ | otherwise = __IMPOSSIBLE__+ (s, rs)+ | null s1 = (s2, r2)+ | null s2 = (s1, r1)+ | otherwise = __IMPOSSIBLE__+ -- Andreas, 2026-09-07, issue #1438+ -- If we have both a fixity and a syntax declaration,+ -- take the range of the fixity declaration.+ r | null rf = rs+ | otherwise = rf++ -- Compute a list of conflicts in a format suitable for error reporting.+ isect = [ (x, fmap (Map.findWithDefault __IMPOSSIBLE__ x) $ Pair m1 m2)+ | (x, False) <- Map.assocs $ Map.intersectionWith compatible m1 m2 ]++ -- Check for no conflict.+ compatible (Fixity' f1 s1 _) (Fixity' f2 s2 _) =+ (null f1 || null f2) &&+ (null s1 || null s2)++-- | While 'Fixities' and Polarities are not semigroups under disjoint+-- union (which might fail), we get a semigroup instance for the+-- monadic @m (Fixities, Polarities)@ which propagates the first+-- error.+newtype MonadicFixPol m = MonadicFixPol { runMonadicFixPol :: m (Fixities, Polarities) }++returnFix :: Monad m => Fixities -> MonadicFixPol m+returnFix fx = MonadicFixPol $ return (fx, Map.empty)++returnPol :: Monad m => Polarities -> MonadicFixPol m+returnPol pol = MonadicFixPol $ return (Map.empty, pol)++instance MonadFixityError m => Semigroup (MonadicFixPol m) where+ c1 <> c2 = MonadicFixPol $ do+ (f1, p1) <- runMonadicFixPol c1+ (f2, p2) <- runMonadicFixPol c2+ f <- plusFixities f1 f2+ p <- mergePolarities p1 p2+ return (f, p)+ where+ -- Merge disjoint maps.+ mergePolarities p1 p2 =+ List1.ifNull (Map.keys $ Map.intersection p1 p2)+ {-then-} (return $ Map.union p1 p2)+ {-else-} \ ks -> throwMultiplePolarityPragmas ks++instance MonadFixityError m => Monoid (MonadicFixPol m) where+ mempty = MonadicFixPol $ return (Map.empty, Map.empty)+ mappend = (<>)++data DoWarn = NoWarn | DoWarn+ deriving (Eq, Show)++-- | Get the fixities and polarity pragmas from the current block.+-- Doesn't go inside modules and where blocks.+-- The reason for this is that these declarations have to appear at the same+-- level (or possibly outside an abstract or mutual block) as their target+-- declaration.+fixitiesAndPolarities :: MonadFixityError m => DoWarn -> [Declaration] -> m (Fixities, Polarities)+fixitiesAndPolarities doWarn ds = do+ (fixs, pols) <- runMonadicFixPol $ fixitiesAndPolarities' ds+ let DeclaredNames declared postulates privateNames = foldMap declaredNames ds+ let publicNames = declared Set.\\ privateNames++ -- If we have names in fixity declarations which are not defined in the+ -- appropriate scope, raise a warning and delete them from fixs.+ fixs <- Set1.ifNull (Map.keysSet fixs Set.\\ declared) (return fixs) $ \ unknownFixs -> do+ when (doWarn == DoWarn) $ warnUnknownNamesInFixityDecl unknownFixs+ -- Note: Data.Map.restrictKeys requires containers >= 0.5.8.2+ -- return $ Map.restrictKeys fixs declared+ return $ Map.filterWithKey (\ k _ -> Set.member k declared) fixs++ -- Same for undefined names in polarity declarations.+ pols <- Set1.ifNull (Map.keysSet pols Set.\\ declared) (return pols) $+ \ unknownPols -> do+ when (doWarn == DoWarn) $ warnUnknownNamesInPolarityPragmas unknownPols+ -- Note: Data.Map.restrictKeys requires containers >= 0.5.8.2+ -- return $ Map.restrictKeys polarities declared+ return $ Map.filterWithKey (\ k _ -> Set.member k declared) pols++ -- Andreas, 2026-09-07, issue #1438+ -- Fixity does not make sense for names that are not operators+ -- or do not have any @syntax@ declaration attached to it,+ -- so we discard respective declarations with a warning.+ _useless <- forM (Map.toList fixs) \ (x, Fixity' fx nota r) ->+ -- Nothing to do if there is no fixity declaration or it belongs+ -- to a pre-, post-, or infix operator/syntax.+ if null fx || isPrePostOrInfixOperator x || isPrePostOrInfixNotation nota then pure Nothing+ else do+ when (doWarn == DoWarn) $ warnFixityDeclarationForNonOperator r x+ -- Discard useless fixity declarations that have no syntax notation.+ pure $ if null nota then Just x else Nothing+ -- Andreas, do not remove fixity declarations (yet) since Agda.Primitive.Cubical+ -- abuses the feature, e.g. @infix 20 primINeg@ (as of 2026-09-07).+ -- TODO: do remove them in the future (past 2.9.0). See also 'applyImportDirectiveM'.+ -- fixs <- return $ Map.withoutKeys fixs $ Set.fromList $ catMaybes useless++ -- If we have public mixfix identifiers without a corresponding fixity+ -- declaration, we raise a warning+ Set1.unlessNull (Set.filter isPrePostOrInfixOperator publicNames Set.\\ Map.keysSet fixs) $+ when (doWarn == DoWarn) . warnUnknownFixityInMixfixDecl++ -- Check that every polarity pragma is used for a postulate.+ Set1.unlessNull (Map.keysSet pols Set.\\ postulates) $+ when (doWarn == DoWarn) . warnPolarityPragmasButNotPostulates++ return (fixs, pols)++fixitiesAndPolarities' :: MonadFixityError m => [Declaration] -> MonadicFixPol m+fixitiesAndPolarities' = foldMap $ \case+ -- These declarations define polarities:+ Pragma (PolarityPragma r x occs) ->+ List1.ifNull occs (MonadicFixPol $ warnEmptyPolarityPragma r $> mempty) {-else-} \ occs ->+ returnPol $ Map.singleton x occs+ -- These declarations define fixities:+ Syntax x syn -> returnFix $ Map.singleton x (Fixity' noFixity syn $ getRange x)+ Infix f xs1 -> flip foldMap xs1 \ x ->+ -- Andreas, 2025-07-25, issue #5224: Warn when @xs1@ contains duplicates.+ -- We achieve this through 'plusFixities'.+ returnFix $ Map.singleton x $ Fixity' f noNotation $ getRange x+ -- We look into these blocks:+ Mutual _ ds' -> fixitiesAndPolarities' ds'+ InterleavedMutual _ ds' -> fixitiesAndPolarities' ds'+ Abstract _ ds' -> fixitiesAndPolarities' ds'+ Private _ _ ds' -> fixitiesAndPolarities' ds'+ InstanceB _ ds' -> fixitiesAndPolarities' ds'+ Macro _ ds' -> fixitiesAndPolarities' ds'+ Opaque _ ds' -> fixitiesAndPolarities' ds'+ -- All other declarations are ignored.+ -- We expand these boring cases to trigger a revisit+ -- in case the @Declaration@ type is extended in the future.+ TypeSig {} -> mempty+ FieldSig {} -> mempty+ Generalize {} -> mempty+ Field {} -> mempty+ FunClause {} -> mempty+ DataSig {} -> mempty+ DataDef {} -> mempty+ Data {} -> mempty+ RecordSig {} -> mempty+ RecordDef {} -> mempty+ Record {} -> mempty+ LoneConstructor {} -> mempty+ PatternSyn {} -> mempty+ Postulate {} -> mempty+ Primitive {} -> mempty+ Open {} -> mempty+ Import {} -> mempty+ ModuleMacro {} -> mempty+ Module {} -> mempty+ UnquoteDecl {} -> mempty+ UnquoteDef {} -> mempty+ UnquoteData {} -> mempty+ Pragma {} -> mempty+ Unfolding {} -> mempty++data DeclaredNames = DeclaredNames+ { _allNames :: Set Name+ , _postulates :: Set Name+ -- ^ Subset of postulates within '_allNames'.+ , _privateNames :: Set Name+ -- ^ Subset of private names within '_allNames'.+ }++instance Semigroup DeclaredNames where+ DeclaredNames xs ps as <> DeclaredNames ys qs bs =+ DeclaredNames (xs <> ys) (ps <> qs) (as <> bs)++instance Monoid DeclaredNames where+ mempty = DeclaredNames Set.empty Set.empty Set.empty+ mappend = (<>)++-- | Mark all declared names as postulates.+allPostulates :: DeclaredNames -> DeclaredNames+allPostulates (DeclaredNames xs _ps as) = DeclaredNames xs xs as+ -- Note that @_ps@ is a subset of @xs@ so we can discard it.++-- | Mark all declared names as private.+allPrivateNames :: DeclaredNames -> DeclaredNames+allPrivateNames (DeclaredNames xs ps _as) = DeclaredNames xs ps xs+ -- Note that @_as@ is a subset of @xs@ so we can discard it.++declaresNames :: [Name] -> DeclaredNames+declaresNames xs = DeclaredNames (Set.fromList xs) Set.empty Set.empty++declaresName :: Name -> DeclaredNames+declaresName x = declaresNames [x]++-- | Compute the names defined in a declaration. We stay in the current scope,+-- i.e., do not go into modules.+declaredNames :: Declaration -> DeclaredNames+declaredNames = \case+ TypeSig _ _ x _ -> declaresName x+ FieldSig _ _ x _ -> declaresName x+ Field _ fs -> foldMap declaredNames fs+ FunClause _ (LHS p [] []) _ _ _+ | IdentP _ (QName x) <- removeParenP p+ -> declaresName x+ FunClause{} -> mempty+ DataSig _ _ x _ _ -> declaresName x+ DataDef _ _ _ cs -> foldMap declaredNames cs+ Data _ _ x _ _ cs -> declaresName x <> foldMap declaredNames cs+ RecordSig _ _ x _ _ -> declaresName x+ RecordDef _ _x ds _ _ -> declaresNames $ maybeToList (recDirConstructor ds)+ Record _ _ x ds _ _ _ -> declaresNames $ x : maybeToList (recDirConstructor ds)+ Infix _ _ -> mempty+ Syntax _ _ -> mempty+ PatternSyn _ x _ _ -> declaresName x+ Mutual _ ds -> foldMap declaredNames ds+ InterleavedMutual _ ds -> foldMap declaredNames ds+ LoneConstructor _ ds -> foldMap declaredNames ds+ Abstract _ ds -> foldMap declaredNames ds+ Private _ _ ds -> allPrivateNames $ foldMap declaredNames ds+ InstanceB _ ds -> foldMap declaredNames ds+ Macro _ ds -> foldMap declaredNames ds+ Postulate _ ds -> allPostulates $ foldMap declaredNames ds+ Primitive _ ds -> foldMap declaredNames ds+ Generalize _ ds -> foldMap declaredNames ds+ Opaque _ ds -> foldMap declaredNames ds+ Open{} -> mempty+ Unfolding{} -> mempty+ Import{} -> mempty+ ModuleMacro{} -> mempty+ Module{} -> mempty+ UnquoteDecl _ xs _ -> declaresNames xs+ UnquoteDef{} -> mempty+ UnquoteData _ x cs _ -> declaresNames (x:cs)+ -- BUILTIN pragmas which do not require an accompanying definition declare+ -- the (unqualified) name they mention.+ Pragma (BuiltinPragma _ b (QName x))+ | any isBuiltinNoDef . builtinById $ rangedThing b -> declaresName x+ Pragma{} -> mempty++recDirConstructor :: [RecordDirective] -> Maybe Name+recDirConstructor = listToMaybe . mapMaybe \case+ Constructor x _ -> Just x+ _ -> Nothing
@@ -0,0 +1,398 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++-- | Generic traversal and reduce for concrete syntax,+-- in the style of "Agda.Syntax.Internal.Generic".+--+-- However, here we use the terminology of 'Data.Traversable'.++module Agda.Syntax.Concrete.Generic where++import Data.Bifunctor+import Data.Functor++import Agda.Syntax.Common+import Agda.Syntax.Concrete++import Agda.Utils.Either+import Agda.Utils.List1 (List1)+import Agda.Utils.List2 (List2)++import Agda.Utils.Impossible++-- Generic traversals for concrete expressions.+-- ========================================================================++-- | Generic traversals for concrete expressions.+--+-- Note: does not go into patterns!+class ExprLike a where+ mapExpr :: (Expr -> Expr) -> a -> a+ -- ^ This corresponds to 'map'.++ foldExpr :: Monoid m => (Expr -> m) -> a -> m+ -- ^ This corresponds to 'foldMap'.++ traverseExpr :: Monad m => (Expr -> m Expr) -> a -> m a+ -- ^ This corresponds to 'mapM'.++ default mapExpr :: (Functor t, ExprLike b, t b ~ a) => (Expr -> Expr) -> a -> a+ mapExpr = fmap . mapExpr++ default foldExpr+ :: (Monoid m, Foldable t, ExprLike b, t b ~ a)+ => (Expr -> m) -> a -> m+ foldExpr = foldMap . foldExpr++ default traverseExpr+ :: (Monad m, Traversable t, ExprLike b, t b ~ a)+ => (Expr -> m Expr) -> a -> m a+ traverseExpr = traverse . traverseExpr+++-- Instances for things that do not contain expressions.+---------------------------------------------------------------------------++instance ExprLike () where+ mapExpr _ = id+ foldExpr _ _ = mempty+ traverseExpr _ = return++instance ExprLike Name where+ mapExpr _ = id+ foldExpr _ _ = mempty+ traverseExpr _ = return++instance ExprLike QName where+ mapExpr _ = id+ foldExpr _ _ = mempty+ traverseExpr _ = return++instance ExprLike Bool where+ mapExpr _ = id+ foldExpr _ _ = mempty+ traverseExpr _ = return++-- Instances for collections and decorations.+---------------------------------------------------------------------------++instance ExprLike a => ExprLike [a]+instance ExprLike a => ExprLike (List1 a)+instance ExprLike a => ExprLike (List2 a)+instance ExprLike a => ExprLike (Maybe a)++instance ExprLike a => ExprLike (Arg a)+instance ExprLike a => ExprLike (Named name a)+instance ExprLike a => ExprLike (Ranged a)+instance ExprLike a => ExprLike (WithHiding a)++instance ExprLike a => ExprLike (MaybePlaceholder a)+instance ExprLike a => ExprLike (RHS' a)+instance ExprLike a => ExprLike (TacticAttribute' a)+instance ExprLike a => ExprLike (TypedBinding' a)+instance ExprLike a => ExprLike (WhereClause' a)++instance (ExprLike a, ExprLike b) => ExprLike (Either a b) where+ mapExpr f = bimap (mapExpr f) (mapExpr f)+ traverseExpr f = traverseEither (traverseExpr f) (traverseExpr f)+ foldExpr f = either (foldExpr f) (foldExpr f)++instance (ExprLike a, ExprLike b) => ExprLike (a, b) where+ mapExpr f (x, y) = (mapExpr f x, mapExpr f y)+ traverseExpr f (x, y) = (,) <$> traverseExpr f x <*> traverseExpr f y+ foldExpr f (x, y) = foldExpr f x `mappend` foldExpr f y++instance (ExprLike a, ExprLike b, ExprLike c) => ExprLike (a, b, c) where+ mapExpr f (x, y, z) = (mapExpr f x, mapExpr f y, mapExpr f z)+ traverseExpr f (x, y, z) = (,,) <$> traverseExpr f x <*> traverseExpr f y <*> traverseExpr f z+ foldExpr f (x, y, z) = foldExpr f x `mappend` foldExpr f y `mappend` foldExpr f z++instance (ExprLike a, ExprLike b, ExprLike c, ExprLike d) => ExprLike (a, b, c, d) where+ mapExpr f (x, y, z, w) = (mapExpr f x, mapExpr f y, mapExpr f z, mapExpr f w)+ traverseExpr f (x, y, z, w) = (,,,) <$> traverseExpr f x <*> traverseExpr f y <*> traverseExpr f z <*> traverseExpr f w+ foldExpr f (x, y, z, w) = foldExpr f x `mappend` foldExpr f y `mappend` foldExpr f z `mappend` foldExpr f w++-- Interesting instances+---------------------------------------------------------------------------++instance ExprLike Expr where+ mapExpr f e0 = case e0 of+ Ident{} -> f $ e0+ Lit{} -> f $ e0+ QuestionMark{} -> f $ e0+ Underscore{} -> f $ e0+ RawApp r es -> f $ RawApp r $ mapE es+ App r e es -> f $ App r (mapE e) $ mapE es+ OpApp r q ns es -> f $ OpApp r q ns $ mapE es+ WithApp r e es -> f $ WithApp r (mapE e) $ mapE es+ HiddenArg r e -> f $ HiddenArg r $ mapE e+ InstanceArg r e -> f $ InstanceArg r $ mapE e+ Lam r bs e -> f $ Lam r (mapE bs) $ mapE e+ AbsurdLam{} -> f $ e0+ ExtendedLam r e cs -> f $ ExtendedLam r e $ mapE cs+ Fun r a b -> f $ Fun r (mapE <$> a) $ mapE b+ Pi tel e -> f $ Pi (mapE tel) $ mapE e+ Rec kwr r es -> f $ Rec kwr r $ mapE es+ RecUpdate k r e es -> f $ RecUpdate k r (mapE e) $ mapE es+ Let r ds e -> f $ Let r (mapE ds) $ mapE e+ Paren r e -> f $ Paren r $ mapE e+ IdiomBrackets r q es -> f $ IdiomBrackets r q $ mapE es+ DoBlock r q ss -> f $ DoBlock r q $ mapE ss+ Absurd{} -> f $ e0+ As r x e -> f $ As r x $ mapE e+ Dot r e -> f $ Dot r $ mapE e+ DoubleDot r e -> f $ DoubleDot r $ mapE e+ Tactic r e -> f $ Tactic r (mapE e)+ Quote{} -> f $ e0+ QuoteTerm{} -> f $ e0+ Unquote{} -> f $ e0+ DontCare e -> f $ DontCare $ mapE e+ Equal{} -> f $ e0+ Ellipsis{} -> f $ e0+ Generalized e -> f $ Generalized $ mapE e+ KnownIdent{} -> f $ e0+ KnownOpApp nk r q ns es -> f $ KnownOpApp nk r q ns $ mapE es+ Highlighted r e -> f $ Highlighted r $ mapE e+ where+ mapE :: ExprLike e => e -> e+ mapE = mapExpr f++ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike FieldAssignment where+ mapExpr f (FieldAssignment x e) = FieldAssignment x (mapExpr f e)+ traverseExpr f (FieldAssignment x e) = (\e' -> FieldAssignment x e') <$> traverseExpr f e+ foldExpr f (FieldAssignment _ e) = foldExpr f e++instance ExprLike ModuleAssignment where+ mapExpr f (ModuleAssignment m es i) = ModuleAssignment m (mapExpr f es) i+ traverseExpr f (ModuleAssignment m es i) = (\es' -> ModuleAssignment m es' i) <$> traverseExpr f es+ foldExpr f (ModuleAssignment _ es _) = foldExpr f es++instance ExprLike a => ExprLike (OpApp a) where+ mapExpr f = \case+ SyntaxBindingLambda r bs e -> SyntaxBindingLambda r (mapE bs) $ mapE e+ Ordinary e -> Ordinary $ mapE e+ where+ mapE :: ExprLike e => e -> e+ mapE = mapExpr f+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike LamBinding where+ mapExpr f = \case+ e@DomainFree{}-> e+ DomainFull bs -> DomainFull $ mapE bs+ where mapE e = mapExpr f e+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike LHS where+ mapExpr f = \case+ LHS ps res wes -> LHS ps (mapE res) (mapE wes)+ where+ mapE :: ExprLike a => a -> a+ mapE = mapExpr f+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance (ExprLike qn, ExprLike e) => ExprLike (RewriteEqn' qn nm p e) where+ mapExpr f = \case+ Rewrite es -> Rewrite (mapExpr f es)+ Invert qn pes -> Invert qn $ (fmap . fmap . fmap . mapExpr) f pes+ LeftLet pes -> LeftLet $ (fmap . fmap . mapExpr) f pes+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike LamClause where+ mapExpr f (LamClause ps rhs ca) = LamClause ps (mapExpr f rhs) ca+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike DoStmt where+ mapExpr f (DoBind r p e cs) = DoBind r p (mapExpr f e) (mapExpr f cs)+ mapExpr f (DoThen e) = DoThen (mapExpr f e)+ mapExpr f (DoLet r ds) = DoLet r (mapExpr f ds)++ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike ModuleApplication where+ mapExpr f = \case+ SectionApp r bs x es -> SectionApp r (mapE bs) x $ mapE es+ e@RecordModuleInstance{} -> e+ where+ mapE :: ExprLike e => e -> e+ mapE = mapExpr f+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++instance ExprLike Declaration where+ mapExpr f = \case+ TypeSig ai t x e -> TypeSig ai (mapE t) x (mapE e)+ FieldSig i t n e -> FieldSig i (mapE t) n (mapE e)+ Field r fs -> Field r $ map (mapExpr f) fs+ FunClause ai lhs rhs wh ca-> FunClause ai (mapE lhs) (mapE rhs) (mapE wh) ca+ DataSig r er x bs e -> DataSig r er x (mapE bs) $ mapE e+ DataDef r n bs cs -> DataDef r n (mapE bs) $ mapE cs+ Data r er n bs e cs -> Data r er n (mapE bs) (mapE e) $ mapE cs+ RecordSig r er ind bs e -> RecordSig r er ind (mapE bs) $ mapE e+ RecordDef r n dir tel ds -> RecordDef r n dir (mapE tel) $ mapE ds+ Record r er n dir tel e ds+ -> Record r er n dir (mapE tel) (mapE e)+ $ mapE ds+ e@Infix{} -> e+ e@Syntax{} -> e+ e@PatternSyn{} -> e+ Mutual r ds -> Mutual r $ mapE ds+ InterleavedMutual r ds -> InterleavedMutual r $ mapE ds+ LoneConstructor r ds -> LoneConstructor r $ mapE ds+ Abstract r ds -> Abstract r $ mapE ds+ Private r o ds -> Private r o $ mapE ds+ InstanceB r ds -> InstanceB r $ mapE ds+ Macro r ds -> Macro r $ mapE ds+ Postulate r ds -> Postulate r $ mapE ds+ Primitive r ds -> Primitive r $ mapE ds+ Generalize r ds -> Generalize r $ mapE ds+ Opaque r ds -> Opaque r $ mapE ds+ e@Open{} -> e+ e@Import{} -> e+ ModuleMacro r e n es op dir+ -> ModuleMacro r e n (mapE es) op dir+ Module r e n tel ds -> Module r e n (mapE tel) $ mapE ds+ UnquoteDecl r x e -> UnquoteDecl r x (mapE e)+ UnquoteDef r x e -> UnquoteDef r x (mapE e)+ UnquoteData r x xs e -> UnquoteData r x xs (mapE e)+ e@Pragma{} -> e+ e@Unfolding{} -> e+ where+ mapE :: ExprLike e => e -> e+ mapE = mapExpr f++ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__+++{- Template++instance ExprLike a where+ mapExpr f = \case+ where mapE e = mapExpr f e+ foldExpr = __IMPOSSIBLE__+ traverseExpr = __IMPOSSIBLE__++-}++-- Generic traversals for concrete declarations.+-- ========================================================================++class FoldDecl a where++ -- | Collect declarations and subdeclarations, transitively.+ -- Prefix-order tree traversal.+ foldDecl :: Monoid m => (Declaration -> m) -> a -> m++ default foldDecl :: (Monoid m, Foldable t, FoldDecl b, t b ~ a)+ => (Declaration -> m) -> a -> m+ foldDecl = foldMap . foldDecl++instance FoldDecl a => FoldDecl [a]+instance FoldDecl a => FoldDecl (List1 a)+instance FoldDecl a => FoldDecl (List2 a)+instance FoldDecl a => FoldDecl (WhereClause' a)++-- | Note: this instance discards top-level OPTIONS pragmas.+instance FoldDecl Module where+ foldDecl f (Mod _name _pragmas ds) = foldDecl f ds++instance FoldDecl Declaration where+ foldDecl f d = f d <> case d of+ Private _ _ ds -> foldDecl f ds+ Abstract _ ds -> foldDecl f ds+ InstanceB _ ds -> foldDecl f ds+ InterleavedMutual _ ds -> foldDecl f ds+ LoneConstructor _ ds -> foldDecl f ds+ Mutual _ ds -> foldDecl f ds+ Module _ _ _ _ ds -> foldDecl f ds+ Macro _ ds -> foldDecl f ds+ Record _ _ _ _ _ _ ds -> foldDecl f ds+ RecordDef _ _ _ _ ds -> foldDecl f ds+ TypeSig _ _ _ _ -> mempty+ FieldSig _ _ _ _ -> mempty+ Generalize _ _ -> mempty+ Field _ _ -> mempty+ FunClause _ _ _ wh _ -> foldDecl f wh+ DataSig _ _ _ _ _ -> mempty+ Data _ _ _ _ _ _ -> mempty+ DataDef _ _ _ _ -> mempty+ RecordSig _ _ _ _ _ -> mempty+ Infix _ _ -> mempty+ Syntax _ _ -> mempty+ PatternSyn _ _ _ _ -> mempty+ Postulate _ _ -> mempty+ Primitive _ _ -> mempty+ Open _ _ _ -> mempty+ Import _ _ _ _ _ -> mempty+ ModuleMacro _ _ _ _ _ _ -> mempty+ UnquoteDecl _ _ _ -> mempty+ UnquoteDef _ _ _ -> mempty+ UnquoteData _ _ _ _ -> mempty+ Pragma _ -> mempty+ Opaque _ ds -> foldDecl f ds+ Unfolding _ _ -> mempty++class TraverseDecl a where++ -- | Update declarations and their subdeclarations.+ -- Prefix-order traversal: traverses subdeclarations of updated declaration.+ --+ preTraverseDecl :: Monad m => (Declaration -> m Declaration) -> a -> m a++ default preTraverseDecl :: (Monad m, Traversable t, TraverseDecl b, t b ~ a)+ => (Declaration -> m Declaration) -> a -> m a+ preTraverseDecl = traverse . preTraverseDecl++instance TraverseDecl a => TraverseDecl [a]+instance TraverseDecl a => TraverseDecl (List1 a)+instance TraverseDecl a => TraverseDecl (List2 a)+instance TraverseDecl a => TraverseDecl (WhereClause' a)++instance TraverseDecl Declaration where+ preTraverseDecl f d0 = do+ d <- f d0+ case d of+ Private r o ds -> Private r o <$> preTraverseDecl f ds+ Abstract r ds -> Abstract r <$> preTraverseDecl f ds+ InstanceB r ds -> InstanceB r <$> preTraverseDecl f ds+ InterleavedMutual r ds -> InterleavedMutual r <$> preTraverseDecl f ds+ LoneConstructor r ds -> LoneConstructor r <$> preTraverseDecl f ds+ Mutual r ds -> Mutual r <$> preTraverseDecl f ds+ Module r er n tel ds -> Module r er n tel <$> preTraverseDecl f ds+ Macro r ds -> Macro r <$> preTraverseDecl f ds+ Opaque r ds -> Opaque r <$> preTraverseDecl f ds+ Record r er n dir tel t ds -> Record r er n dir tel t <$> preTraverseDecl f ds+ RecordDef r n dir tel ds -> RecordDef r n dir tel <$> preTraverseDecl f ds+ TypeSig _ _ _ _ -> return d+ FieldSig _ _ _ _ -> return d+ Generalize _ _ -> return d+ Field _ _ -> return d+ FunClause ai lhs rhs wh ca -> preTraverseDecl f wh <&> \ wh' -> FunClause ai lhs rhs wh' ca+ DataSig _ _ _ _ _ -> return d+ Data _ _ _ _ _ _ -> return d+ DataDef _ _ _ _ -> return d+ RecordSig _ _ _ _ _ -> return d+ Infix _ _ -> return d+ Syntax _ _ -> return d+ PatternSyn _ _ _ _ -> return d+ Postulate _ _ -> return d+ Primitive _ _ -> return d+ Open _ _ _ -> return d+ Import _ _ _ _ _ -> return d+ ModuleMacro _ _ _ _ _ _ -> return d+ UnquoteDecl _ _ _ -> return d+ UnquoteDef _ _ _ -> return d+ UnquoteData _ _ _ _ -> return d+ Pragma _ -> return d+ Unfolding _ _ -> return d
@@ -0,0 +1,154 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++{-| Choice of Unicode or ASCII glyphs.+-}+module Agda.Syntax.Concrete.Glyph+ ( UnicodeOrAscii(..)+ , unsafeSetUnicodeOrAscii+ , specialCharactersForGlyphs+ , braces', dbraces+ , forallQ+ , leftIdiomBrkt, rightIdiomBrkt, emptyIdiomBrkt+ , arrow, lambda, fromArrow+ , treeGlyphs+ , SpecialCharacters(..)+ ) where++import Control.DeepSeq++import qualified System.IO.Unsafe as UNSAFE (unsafePerformIO)++import GHC.Generics (Generic)++import Agda.Utils.Boolean+import Agda.Utils.List+import qualified Agda.Utils.IORef.Strict as Strict+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty++-- | We want to know whether we are allowed to insert unicode characters or not.+data UnicodeOrAscii+ = UnicodeOk -- ^ 'true': Unicode characters are allowed.+ | AsciiOnly -- ^ 'false: Stick to ASCII.+ deriving (Show, Eq, Enum, Bounded, Generic)++instance NFData UnicodeOrAscii++instance Boolean UnicodeOrAscii where+ fromBool = \case+ True -> UnicodeOk+ False -> AsciiOnly++instance IsBool UnicodeOrAscii where+ toBool = \case+ UnicodeOk -> True+ AsciiOnly -> False++{-# NOINLINE unsafeUnicodeOrAsciiIORef #-}+unsafeUnicodeOrAsciiIORef :: Strict.IORef UnicodeOrAscii+unsafeUnicodeOrAsciiIORef = UNSAFE.unsafePerformIO $ Strict.newIORef UnicodeOk++{-# NOINLINE unsafeSetUnicodeOrAscii #-}+unsafeSetUnicodeOrAscii :: UnicodeOrAscii -> IO ()+unsafeSetUnicodeOrAscii = Strict.writeIORef unsafeUnicodeOrAsciiIORef++-- | Are we allowed to use unicode supscript characters?+unsafeUnicodeOrAscii :: UnicodeOrAscii+unsafeUnicodeOrAscii = UNSAFE.unsafePerformIO (Strict.readIORef unsafeUnicodeOrAsciiIORef)++-- | Picking the appropriate set of special characters depending on+-- whether we are allowed to use unicode or have to limit ourselves+-- to ascii.++data SpecialCharacters = SpecialCharacters+ { _dbraces :: Doc -> Doc+ , _lambda :: Doc+ , _arrow :: Doc+ , _forallQ :: Doc+ , _leftIdiomBrkt :: Doc+ , _rightIdiomBrkt :: Doc+ , _emptyIdiomBrkt :: Doc+ , _fromArrow :: Doc+ , _treeBranch :: Doc -- ^ Connector to a child that has siblings below.+ , _treeLastBranch :: Doc -- ^ Connector to the last child.+ , _treeContinue :: Doc -- ^ Indentation under a child that has siblings below.+ }++specialCharactersUnicode :: SpecialCharacters+specialCharactersUnicode = SpecialCharacters+ { _dbraces = ((hlSymbol "\x2983 " <>) . (<> hlSymbol " \x2984"))+ , _lambda = hlSymbol "\x03bb"+ , _arrow = hlSymbol "\x2192"+ , _forallQ = hlSymbol "\x2200"+ , _leftIdiomBrkt = hlSymbol "\x2987"+ , _rightIdiomBrkt = hlSymbol "\x2988"+ , _emptyIdiomBrkt = hlSymbol "\x2987\x2988"+ , _fromArrow = hlSymbol "←"+ , _treeBranch = "├─ "+ , _treeLastBranch = "└─ "+ , _treeContinue = "│ "+ }++specialCharactersAscii :: SpecialCharacters+specialCharactersAscii = SpecialCharacters+ { _dbraces = braces . braces'+ , _lambda = hlSymbol "\\"+ , _arrow = hlSymbol "->"+ , _forallQ = hlSymbol "forall"+ , _leftIdiomBrkt = hlSymbol "(|"+ , _rightIdiomBrkt = hlSymbol "|)"+ , _emptyIdiomBrkt = hlSymbol "(|)"+ , _fromArrow = hlSymbol "<-"+ , _treeBranch = "|- "+ , _treeLastBranch = "`- "+ , _treeContinue = "| "+ }++-- | Return the glyph set based on a given (unicode or ascii) glyph mode+specialCharactersForGlyphs :: UnicodeOrAscii -> SpecialCharacters+specialCharactersForGlyphs UnicodeOk = specialCharactersUnicode+specialCharactersForGlyphs AsciiOnly = specialCharactersAscii++-- | Choose the glyph set based on the unsafe IORef.+{-# NOINLINE specialCharacters #-}+specialCharacters :: SpecialCharacters+specialCharacters = specialCharactersForGlyphs unsafeUnicodeOrAscii++braces' :: Doc -> Doc+braces' d = caseList (render d) (braces d) {-else-} $ \ c cs ->+ braces (spaceIfDash c <> d <> spaceIfDash (last1 c cs))+ -- Add space to avoid starting a comment (Ulf, 2010-09-13, #269)+ -- Andreas, 2018-07-21, #3161: Also avoid ending a comment+ where+ spaceIfDash '-' = " "+ spaceIfDash _ = empty++-- double braces...+dbraces :: Doc -> Doc+dbraces = _dbraces specialCharacters++-- forall quantifier+forallQ :: Doc+forallQ = hlSymbol $ _forallQ specialCharacters++-- left, right, and empty idiom bracket+leftIdiomBrkt, rightIdiomBrkt, emptyIdiomBrkt :: Doc+leftIdiomBrkt = _leftIdiomBrkt specialCharacters+rightIdiomBrkt = _rightIdiomBrkt specialCharacters+emptyIdiomBrkt = _emptyIdiomBrkt specialCharacters++arrow, lambda, fromArrow :: Doc+arrow = _arrow specialCharacters+lambda = _lambda specialCharacters+fromArrow = _fromArrow specialCharacters++-- | Glyphs for drawing trees with 'prettyTree'.+treeGlyphs :: TreeGlyphs+treeGlyphs = TreeGlyphs+ { treeBranch = _treeBranch specialCharacters+ , treeLastBranch = _treeLastBranch specialCharacters+ , treeContinue = _treeContinue specialCharacters+ , treeEmpty = " "+ }
@@ -1,27 +1,35 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-} {-| Names in the concrete syntax are just strings (or lists of strings for qualified names). -} module Agda.Syntax.Concrete.Name where -import Control.Applicative+import Prelude hiding (null) -import Data.List-import Data.Maybe-import Data.Generics (Typeable, Data)+import Control.DeepSeq -import System.FilePath+import Data.ByteString.Char8 (ByteString)+import Data.Function (on)+import qualified Data.Foldable as Fold -import Test.QuickCheck+import GHC.Generics (Generic) import Agda.Syntax.Common import Agda.Syntax.Position-import Agda.Utils.FileName-import Agda.Utils.Pretty -#include "../../undefined.h"+import Agda.Utils.Lens+import Agda.Utils.List (last1)+import Agda.Utils.List1 (List1, pattern (:|), (<|))+import qualified Agda.Utils.List1 as List1+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton+import Agda.Utils.Suffix+ import Agda.Utils.Impossible+import Agda.Utils.Null (Null (empty, null)) {-| A name is a non-empty list of alternating 'Id's and 'Hole's. A normal name is represented by a singleton list, and operators are represented by a list@@ -31,61 +39,49 @@ Equality and ordering on @Name@s are defined to ignore range so same names in different locations are equal. -}-data Name = Name !Range [NamePart]- | NoName !Range NameId- deriving (Typeable, Data)--data NamePart = Hole | Id String- deriving (Typeable, Data)---- | @noName_ = 'noName' 'noRange'@-noName_ :: Name-noName_ = noName noRange---- | @noName r = 'Name' r ['Hole']@-noName :: Range -> Name-noName r = NoName r (NameId 0 0)--isNoName :: Name -> Bool-isNoName (NoName _ _) = True-isNoName (Name _ [Hole]) = True -- TODO: Track down where these come from-isNoName (Name _ []) = True-isNoName _ = False---- | Is the name an operator?+data Name+ = Name -- ^ A (mixfix) identifier.+ { nameRange :: Range+ , nameInScope :: NameInScope+ , nameNameParts :: NameParts+ }+ | NoName -- ^ @_@.+ { nameRange :: Range+ , nameId :: NameId+ } -isOperator :: Name -> Bool-isOperator (NoName {}) = False-isOperator (Name _ ps) = length ps > 1+type NameParts = List1 NamePart -nameParts :: Name -> [NamePart]-nameParts (Name _ ps) = ps-nameParts (NoName _ _) = [Hole]+-- | An open mixfix identifier is either prefix, infix, or suffix.+-- That is to say: at least one of its extremities is a @Hole@ -nameStringParts :: Name -> [String]-nameStringParts n = [ s | Id s <- nameParts n ]+isPrePostOrInfixOperator :: Name -> Bool+isPrePostOrInfixOperator = \case+ Name _ _ (x :| x' : xs) -> x == Hole || last1 x' xs == Hole+ _ -> False --- | @qualify A.B x == A.B.x@-qualify :: QName -> Name -> QName-qualify (QName m) x = Qual m (QName x)-qualify (Qual m m') x = Qual m $ qualify m' x+instance Underscore Name where+ underscore = NoName noRange __IMPOSSIBLE__+ isUnderscore NoName{} = True+ isUnderscore (Name {nameNameParts = Id x :| []}) = isUnderscore x+ isUnderscore (Name {nameNameParts = Hole :| []}) = True+ isUnderscore _ = False --- | @unqualify A.B.x == x@------ The range is preserved.-unqualify :: QName -> Name-unqualify q = unqualify' q `withRangeOf` q- where- unqualify' (QName x) = x- unqualify' (Qual _ x) = unqualify' x+instance Null Name where+ empty = NoName empty empty+ null = \case+ NoName _r i -> null i+ Name{} -> False --- | @qnameParts A.B.x = [A, B, x]@-qnameParts :: QName -> [Name]-qnameParts (Qual x q) = x : qnameParts q-qnameParts (QName x) = [x]+-- | Mixfix identifiers are composed of words and holes,+-- e.g. @_+_@ or @if_then_else_@ or @[_/_]@.+data NamePart+ = Hole -- ^ @_@ part.+ | Id RawName -- ^ Identifier part.+ deriving Generic --- Define equality on @Name@ to ignore range so same names in different--- locations are equal.+-- | Define equality on @Name@ to ignore range so same names in different+-- locations are equal. -- -- Is there a reason not to do this? -Jeff --@@ -94,15 +90,15 @@ -- right to be able to do a lookup. -Ulf instance Eq Name where- Name _ xs == Name _ ys = xs == ys- NoName _ i == NoName _ j = i == j- _ == _ = False+ Name _ _ xs == Name _ _ ys = xs == ys+ NoName _ i == NoName _ j = i == j+ _ == _ = False instance Ord Name where- compare (Name _ xs) (Name _ ys) = compare xs ys- compare (NoName _ i) (NoName _ j) = compare i j- compare (NoName {}) (Name {}) = LT- compare (Name {}) (NoName {}) = GT+ compare (Name _ _ xs) (Name _ _ ys) = compare xs ys+ compare (NoName _ i) (NoName _ j) = compare i j+ compare (NoName {}) (Name {}) = LT+ compare (Name {}) (NoName {}) = GT instance Eq NamePart where Hole == Hole = True@@ -122,94 +118,378 @@ -- equality. We will have to define an equality instance to -- non-generative namespaces (as well as having some sort of -- lookup table for namespace names).-data QName = Qual Name QName- | QName Name- deriving (Typeable, Data, Eq, Ord)+data QName+ = Qual Name QName -- ^ @A.rest@.+ | QName Name -- ^ @x@.+ deriving (Eq, Ord) --- | Top-level module names.------ Invariant: The list must not be empty.+instance Underscore QName where+ underscore = QName underscore+ isUnderscore (QName x) = isUnderscore x+ isUnderscore Qual{} = False -newtype TopLevelModuleName- = TopLevelModuleName { moduleNameParts :: [String] }- deriving (Show, Eq, Ord, Typeable, Data)+instance Null QName where+ empty = QName empty+ null = \case+ QName x -> null x+ Qual{} -> False --- | Turns a qualified name into a 'TopLevelModuleName'. The qualified--- name is assumed to represent a top-level module name.+------------------------------------------------------------------------+-- * Constructing simple 'Name's.+------------------------------------------------------------------------ -toTopLevelModuleName :: QName -> TopLevelModuleName-toTopLevelModuleName = TopLevelModuleName . map show . qnameParts+-- | Create an ordinary 'InScope' name.+simpleName :: RawName -> Name+simpleName = Name noRange InScope . singleton . Id --- | Turns a top-level module name into a file name with the given--- suffix.+-- | Create a binary operator name in scope.+simpleBinaryOperator :: RawName -> Name+simpleBinaryOperator s = Name noRange InScope $ Hole :| Id s : Hole : [] -moduleNameToFileName :: TopLevelModuleName -> String -> FilePath-moduleNameToFileName (TopLevelModuleName []) ext = __IMPOSSIBLE__-moduleNameToFileName (TopLevelModuleName ms) ext =- joinPath (init ms) </> last ms <.> ext+-- | Create an ordinary 'InScope' name containing a single 'Hole'.+simpleHole :: Name+simpleHole = Name noRange InScope $ singleton Hole --- | Finds the current project's \"root\" directory, given a project--- file and the corresponding top-level module name.------ Example: If the module \"A.B.C\" is located in the file--- \"/foo/A/B/C.agda\", then the root is \"/foo/\".+-- | Check whether a name is a simple identifier without holes.+isSimpleName :: Name -> Maybe RawName+isSimpleName = \case+ Name _ _ (Id x :| []) -> Just x+ _ -> Nothing++------------------------------------------------------------------------+-- * Operations on 'Name' and 'NamePart'+------------------------------------------------------------------------++-- | Don't use on 'NoName{}'.+lensNameParts :: Lens' Name NameParts+lensNameParts f = \case+ n@Name{} -> f (nameNameParts n) <&> \ ps -> n { nameNameParts = ps }+ NoName{} -> __IMPOSSIBLE__++nameToRawName :: Name -> RawName+nameToRawName = prettyShow++nameParts :: Name -> NameParts+nameParts (Name _ _ ps) = ps+nameParts (NoName _ _) = singleton $ Id "_" -- To not return an empty list++nameStringParts :: Name -> [RawName]+nameStringParts n = [ s | Id s <- List1.toList $ nameParts n ]++-- | Parse a string to parts of a concrete name. ----- Precondition: The module name must be well-formed.+-- Note: @stringNameParts "_" == [Id "_"] == nameParts NoName{}@ -projectRoot :: AbsolutePath -> TopLevelModuleName -> AbsolutePath-projectRoot file (TopLevelModuleName m) =- mkAbsolute $- foldr (.) id (replicate (length m - 1) takeDirectory) $- takeDirectory $- filePath file+stringNameParts :: String -> NameParts+stringNameParts "" = singleton $ Id "_" -- NoName+stringNameParts "_" = singleton $ Id "_" -- NoName+stringNameParts s = List1.fromListSafe __IMPOSSIBLE__ $ loop s+ where+ loop "" = []+ loop ('_':s) = Hole : loop s+ loop s | (x, s') <- break (== '_') s = Id (stringToRawName x) : loop s' +-- | Number of holes in a 'Name' (i.e., arity of a mixfix-operator).+class NumHoles a where+ numHoles :: a -> Int++instance NumHoles NameParts where+ numHoles = length . List1.filter (== Hole)++instance NumHoles Name where+ numHoles NoName{} = 0+ numHoles (Name { nameNameParts = parts }) = numHoles parts++instance NumHoles QName where+ numHoles (QName x) = numHoles x+ numHoles (Qual _ x) = numHoles x++-- | Is the name an operator?+-- Needs at least 2 'NamePart's.+isOperator :: Name -> Bool+isOperator = \case+ Name _ _ (_ :| _ : _) -> True+ _ -> False+ isHole :: NamePart -> Bool isHole Hole = True isHole _ = False isPrefix, isPostfix, isInfix, isNonfix :: Name -> Bool-isPrefix x = not (isHole (head xs)) && isHole (last xs) where xs = nameParts x-isPostfix x = isHole (head xs) && not (isHole (last xs)) where xs = nameParts x-isInfix x = isHole (head xs) && isHole (last xs) where xs = nameParts x-isNonfix x = not (isHole (head xs)) && not (isHole (last xs)) where xs = nameParts x+isPrefix x = not (isHole (List1.head xs)) && isHole (List1.last xs) where xs = nameParts x+isPostfix x = isHole (List1.head xs) && not (isHole (List1.last xs)) where xs = nameParts x+isInfix x = isHole (List1.head xs) && isHole (List1.last xs) where xs = nameParts x+isNonfix x = not (isHole (List1.head xs)) && not (isHole (List1.last xs)) where xs = nameParts x -instance Show Name where- show (Name _ xs) = concatMap show xs- show (NoName _ _) = "_" -instance Show NamePart where- show Hole = "_"- show (Id s) = s+------------------------------------------------------------------------+-- * Keeping track of which names are (not) in scope+------------------------------------------------------------------------ -instance Show QName where- show (Qual m x) = show m ++ "." ++ show x- show (QName x) = show x+data NameInScope = InScope | NotInScope+ deriving (Eq, Show) -instance Pretty TopLevelModuleName where- pretty (TopLevelModuleName ms) = text $ intercalate "." ms+class LensInScope a where+ lensInScope :: Lens' a NameInScope -instance Arbitrary TopLevelModuleName where- arbitrary = TopLevelModuleName <$> listOf1 (listOf1 $ elements "AB")+ isInScope :: a -> NameInScope+ isInScope x = x ^. lensInScope -instance CoArbitrary TopLevelModuleName where- coarbitrary (TopLevelModuleName m) = coarbitrary m+ mapInScope :: (NameInScope -> NameInScope) -> a -> a+ mapInScope = over lensInScope + setInScope :: a -> a+ setInScope = mapInScope $ const InScope++ setNotInScope :: a -> a+ setNotInScope = mapInScope $ const NotInScope++instance LensInScope NameInScope where+ lensInScope = id++instance LensInScope Name where+ lensInScope f = \case+ n@Name{ nameInScope = nis } -> (\nis' -> n { nameInScope = nis' }) <$> f nis+ n@NoName{} -> n <$ f InScope++instance LensInScope QName where+ lensInScope f = \case+ Qual x xs -> (`Qual` xs) <$> lensInScope f x+ QName x -> QName <$> lensInScope f x++------------------------------------------------------------------------+-- * Generating fresh names+------------------------------------------------------------------------++-- | Method by which to generate fresh unshadowed names.+data FreshNameMode+ = UnicodeSubscript+ -- ^ Append an integer Unicode subscript: x, x₁, x₂, …+ | AsciiCounter+ -- ^ Append an integer ASCII counter: x, x1, x2, …++ -- Note that @Agda.Utils.Suffix@ supports an additional style, @Prime@, but+ -- we currently only encounter it when extending an existing name of that+ -- format, (x', x'', …), not for an initially-generated permutation. There's+ -- no reason we couldn't, except that we currently choose between+ -- subscript/counter styles based on the --no-unicode mode rather than any+ -- finer-grained option.+ -- | PrimeTickCount+ -- ^ Append an ASCII prime/apostrophe: x, x', x'', …++nextRawName :: FreshNameMode -> RawName -> RawName+nextRawName freshNameMode s = addSuffix root (maybe initialSuffix nextSuffix suffix)+ where+ (root, suffix) = suffixView s+ initialSuffix = case freshNameMode of+ UnicodeSubscript -> Subscript 1+ AsciiCounter -> Index 1++-- | Get the next version of the concrete name. For instance,+-- @nextName "x" = "x₁"@. The name must not be a 'NoName'.+nextName :: FreshNameMode -> Name -> Name+nextName freshNameMode x@Name{} = setNotInScope $ over (lensNameParts . lastIdPart) (nextRawName freshNameMode) x+nextName _ NoName{} = __IMPOSSIBLE__++-- | Zoom on the last non-hole in a name.+lastIdPart :: Lens' NameParts RawName+lastIdPart f = loop+ where+ loop = \case+ Id s :| [] -> f s <&> \ s -> Id s :| []+ Id s :| [Hole] -> f s <&> \ s -> Id s :| [Hole]+ p1 :| p2 : ps -> (p1 <|) <$> loop (p2 :| ps)+ Hole :| [] -> __IMPOSSIBLE__++-- | Get the first version of the concrete name that does not satisfy+-- the given predicate.+firstNonTakenName :: FreshNameMode -> (Name -> Bool) -> Name -> Name+firstNonTakenName freshNameMode taken x =+ if taken x+ then firstNonTakenName freshNameMode taken (nextName freshNameMode x)+ else x++-- | Lens for accessing and modifying the suffix of a name.+-- The suffix of a @NoName@ is always @Nothing@, and should not be+-- changed.+nameSuffix :: Lens' Name (Maybe Suffix)+nameSuffix (f :: Maybe Suffix -> f (Maybe Suffix)) = \case++ n@NoName{} -> f Nothing <&> \case+ Nothing -> n+ Just {} -> __IMPOSSIBLE__++ n@Name{} -> lensNameParts (lastIdPart idSuf) n+ where+ idSuf s =+ let (root, suffix) = suffixView s+ in maybe root (addSuffix root) <$> (f suffix)++-- | Split a name into a base name plus a suffix.+nameSuffixView :: Name -> (Maybe Suffix, Name)+nameSuffixView = nameSuffix (,Nothing)++-- | Replaces the suffix of a name. Unless the suffix is @Nothing@,+-- the name should not be @NoName@.+setNameSuffix :: Maybe Suffix -> Name -> Name+setNameSuffix = set nameSuffix++-- | Get a raw version of the name with all suffixes removed. For+-- instance, @nameRoot "x₁₂₃" = "x"@.+nameRoot :: Name -> RawName+nameRoot x = nameToRawName $ snd $ nameSuffixView x++sameRoot :: Name -> Name -> Bool+sameRoot = (==) `on` nameRoot++------------------------------------------------------------------------+-- * Operations on qualified names+------------------------------------------------------------------------++-- | Lens for the unqualified part of a QName+lensQNameName :: Lens' QName Name+lensQNameName f (QName n) = QName <$> f n+lensQNameName f (Qual m n) = Qual m <$> lensQNameName f n++-- | @qualify A.B x == A.B.x@+qualify :: QName -> Name -> QName+qualify (QName m) x = Qual m (QName x)+qualify (Qual m m') x = Qual m $ qualify m' x++-- | @unqualify A.B.x == x@+--+-- The range is preserved.+unqualify :: QName -> Name+unqualify q = unqualify' q `withRangeOf` q+ where+ unqualify' (QName x) = x+ unqualify' (Qual _ x) = unqualify' x++-- | @qnameParts A.B.x = [A, B, x]@+qnameParts :: QName -> List1 Name+qnameParts (Qual x q) = x <| qnameParts q+qnameParts (QName x) = singleton x++-- | Is the name (un)qualified?++isQualified :: QName -> Bool+isQualified Qual{} = True+isQualified QName{} = False++isUnqualified :: QName -> Maybe Name+isUnqualified Qual{} = Nothing+isUnqualified (QName n) = Just n++------------------------------------------------------------------------+-- * No name stuff+------------------------------------------------------------------------++-- | @noName_ = 'noName' 'noRange'@+noName_ :: Name+noName_ = noName noRange++noName :: Range -> Name+noName r = NoName r (NameId 0 noModuleNameHash)++-- | Check whether a name is the empty name "_".+class IsNoName a where+ isNoName :: a -> Bool++ default isNoName :: (Foldable t, IsNoName b, t b ~ a) => a -> Bool+ isNoName = Fold.all isNoName++instance IsNoName String where+ isNoName = isUnderscore++instance IsNoName ByteString where+ isNoName = isUnderscore++instance IsNoName Name where+ isNoName = \case+ NoName{} -> True+ Name _ _ (Hole :| []) -> True+ Name _ _ (Id x :| []) -> isNoName x+ _ -> False++instance IsNoName QName where+ isNoName (QName x) = isNoName x+ isNoName Qual{} = False -- M.A._ does not qualify as empty name++instance IsNoName a => IsNoName (Ranged a) where+instance IsNoName a => IsNoName (WithOrigin a) where++------------------------------------------------------------------------+-- * Showing names+------------------------------------------------------------------------++deriving instance Show Name+deriving instance Show NamePart+deriving instance Show QName++------------------------------------------------------------------------+-- * Printing names+------------------------------------------------------------------------++instance Pretty Name where+ pretty (Name _ _ xs) = hcat $ fmap pretty xs+ pretty (NoName _ _) = "_"++instance Pretty NamePart where+ pretty Hole = "_"+ pretty (Id s) = text $ rawNameToString s++instance Pretty QName where+ pretty (Qual m x)+ | isUnderscore m = pretty x -- don't print anonymous modules+ | otherwise = pretty m <> "." <> pretty x+ pretty (QName x) = pretty x++------------------------------------------------------------------------+-- * Range instances+------------------------------------------------------------------------+ instance HasRange Name where- getRange (Name r ps) = r- getRange (NoName r _) = r+ getRange (Name r _ _ps) = r+ getRange (NoName r _) = r instance HasRange QName where getRange (QName x) = getRange x- getRange (Qual n x) = fuseRange n x+ getRange (Qual n x) = fuseRange n x instance SetRange Name where- setRange r (Name _ ps) = Name r ps- setRange r (NoName _ i) = NoName r i+ setRange r (Name _ nis ps) = Name r nis ps+ setRange r (NoName _ i) = NoName r i +instance SetRange QName where+ setRange r (QName x) = QName (setRange r x)+ setRange r (Qual n x) = Qual (setRange r n) (setRange r x)+ instance KillRange QName where killRange (QName x) = QName $ killRange x killRange (Qual n x) = killRange n `Qual` killRange x instance KillRange Name where- killRange (Name r ps) = Name (killRange r) ps- killRange (NoName r i) = NoName (killRange r) i+ killRange (Name r nis ps) = Name (killRange r) nis ps+ killRange (NoName r i) = NoName (killRange r) i++------------------------------------------------------------------------+-- * NFData instances+------------------------------------------------------------------------++instance NFData NameInScope where+ rnf InScope = ()+ rnf NotInScope = ()++-- | Ranges are not forced.++instance NFData Name where+ rnf (Name _ nis ns) = rnf nis `seq` rnf ns+ rnf (NoName _ n) = rnf n++instance NFData NamePart where+ rnf Hole = ()+ rnf (Id s) = rnf s++instance NFData QName where+ rnf (Qual a b) = rnf a `seq` rnf b+ rnf (QName a) = rnf a
@@ -1,411 +1,987 @@-{-# LANGUAGE CPP, ScopedTypeVariables #-}--{-| The parser doesn't know about operators and parses everything as normal- function application. This module contains the functions that parses the- operators properly. For a stand-alone implementation of this see- @src\/prototyping\/mixfix@.-- It also contains the function that puts parenthesis back given the- precedence of the context.--}-module Agda.Syntax.Concrete.Operators- ( parseApplication- , parseLHS- , paren- , mparen- ) where--import Control.Applicative-import Control.Monad.Trans-import Data.Typeable-import Data.Traversable (traverse)-import qualified Data.Map as Map-import qualified Data.Set as Set-import Data.Set (Set)-import Data.List-import Data.Function--import Agda.Syntax.Concrete.Pretty ()-import Agda.Syntax.Common-import Agda.Syntax.Concrete-import Agda.Syntax.Concrete.Operators.Parser-import qualified Agda.Syntax.Abstract.Name as A-import Agda.Syntax.Position-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad--import Agda.TypeChecking.Monad.Base (typeError, TypeError(..))-import Agda.TypeChecking.Monad.State (getScope)-import Agda.TypeChecking.Monad.Options-import Agda.TypeChecking.Monad.Statistics--import Agda.Utils.ReadP-import Agda.Utils.Monad-import Agda.Utils.Tuple-import Agda.Utils.List--import Debug.Trace--#include "../../undefined.h"-import Agda.Utils.Impossible-------------------------------------------------------------------------------- * Building the parser------------------------------------------------------------------------------partsInScope :: ScopeM (Set Name)-partsInScope = do- (names, ops) <- localNames- let xs = concatMap parts names ++ concatMap notationNames ops- return $ Set.fromList xs- where- parts (NoName _ _) = []- parts x@(Name _ [_]) = [x]- parts x@(Name _ xs) = x : [ Name noRange [i] | i@(Id {}) <- xs ]---- | Compute all unqualified defined names in scope and their fixities.-getDefinedNames :: [KindOfName] -> ScopeM [(Name, Fixity')]-getDefinedNames kinds = do- names <- nsNames . everythingInScope <$> getScope- reportSLn "scope.operators" 20 $ "everythingInScope: " ++ show names- return [ (x, A.nameFixity $ A.qnameName $ anameName d)- | (x, ds) <- Map.assocs names- , d <- take 1 ds- , anameKind d `elem` kinds- ]---- | Compute all names (first component) and operators (second component) in--- scope.-localNames :: ScopeM ([Name], [NewNotation])-localNames = do- defs <- getDefinedNames [DefName, ConName]- locals <- scopeLocals <$> getScope- return $ split $ uniqBy fst $ map localOp locals ++ defs- where- localOp (x, y) = (x, A.nameFixity y)- split ops = ([ x | Left x <- zs], [ y | Right y <- zs ])- where- zs = concatMap opOrNot ops-- opOrNot (x, Fixity' fx syn) = Left x- : case x of- Name _ [_] -> []- _ -> [Right (x, fx, syntaxOf x)]- ++ case syn of- [] -> []- _ -> [Right (x, fx, syn)]--data UseBoundNames = UseBoundNames | DontUseBoundNames------{-| Builds parser for operator applications from all the operators and function- symbols in scope. When parsing a pattern we use 'DontUseBoundNames'.-- The effect is that operator parts (that are not constructor parts)- can be used as atomic names in the pattern (so they can be- rebound). See test/succeed/OpBind.agda for an example.-- To avoid problems with operators of the same precedence but different- associativity we decide (completely arbitrary) to fix the precedences of- operators with the same given precedence in the following order (from- loosest to hardest):-- - non-associative-- - left associative-- - right associative-- - prefix-- - postfix-- This has the effect that if you mix operators with the same precedence but- different associativity the parser won't complain. One could argue that- this is a Bad Thing, but since it's not trivial to implement the check it- will stay this way until people start complaining about it.---}--data NotationStyle = InfixS | Prefix | Postfix | Nonfix | None- deriving (Eq)--fixStyle :: Notation -> NotationStyle-fixStyle [] = None-fixStyle syn = case (isAHole (head syn), isAHole (last syn)) of- (True,True) -> InfixS- (True,False) -> Postfix- (False,True) -> Prefix- (False,False) -> Nonfix---notationNames :: NewNotation -> [Name]-notationNames (_, _, ps) = [Name noRange [Id x] | IdPart x <- ps ]--buildParser :: forall e. IsExpr e => Range -> UseBoundNames -> ScopeM (ReadP e e)-buildParser r use = do- (names, ops) <- localNames- cons <- getDefinedNames [ConName]- let conparts = Set.fromList $ concatMap notationNames $ map oldToNewNotation cons- opsparts = Set.fromList $ concatMap notationNames $ ops- allParts = Set.union conparts opsparts- connames = Set.fromList $ map fst cons- (non, fix) = partition nonfix ops- set = Set.fromList names- isAtom x = case use of- UseBoundNames -> not (Set.member x allParts) || Set.member x set- DontUseBoundNames -> not (Set.member x conparts) || Set.member x connames- -- If string is a part of notation, it cannot be used as an identifier,- -- unless it is also used as an identifier. See issue 307.- return $ -- traceShow ops $- recursive $ \p -> -- p is a parser for an arbitrary expression- concatMap (mkP p) (order fix) -- for infix operators (with outer "holes")- ++ [ appP p ] -- parser for simple applications- ++ map (nonfixP . opP p) non -- for things with no outer "holes"- ++ [ const $ atomP isAtom ]- where--- level :: NewNotation -> Nat- level (_name, fixity, _syn) = fixityLevel fixity-- on f g x y = f (g x) (g y)-- isinfixl, isinfixr, isinfix, nonfix, isprefix, ispostfix :: NewNotation -> Bool-- isinfixl (_, LeftAssoc _ _, syn) = isInfix syn- isinfixl _ = False-- isinfixr (_, RightAssoc _ _, syn) = isInfix syn- isinfixr _ = False-- isinfix (_, NonAssoc _ _,syn) = isInfix syn- isinfix _ = False-- nonfix (_,_,syn) = fixStyle syn == Nonfix- isprefix (_,_,syn) = fixStyle syn == Prefix- ispostfix (_,_,syn) = fixStyle syn == Postfix- isInfix :: Notation -> Bool- isInfix syn = fixStyle syn == InfixS-- -- | Group operators by precedence level- order :: [NewNotation] -> [[NewNotation]]- order = groupBy ((==) `on` level) . sortBy (compare `on` level)-- -- | Each element of the returned list takes the parser for an- -- expression of higher precedence as parameter.- mkP :: ReadP e e -> [NewNotation] -> [ReadP e e -> ReadP e e]- mkP p0 ops = case concat [infx, inlfx, inrfx, prefx, postfx] of- [] -> [id]- fs -> fs- where- inlfx = fixP infixlP isinfixl- inrfx = fixP infixrP isinfixr- infx = fixP infixP isinfix- prefx = fixP prefixP isprefix- postfx = fixP postfixP ispostfix-- fixP :: (ReadP e (NewNotation,Range,[e]) -> ReadP e e -> ReadP e e) -> (NewNotation -> Bool) -> [ReadP e e -> ReadP e e]- fixP f g =- case filter g ops of- [] -> []- ops -> [ f $ choice $ map (opP p0) ops ]-------------------------------------------------------------------------------- * Expression instances------------------------------------------------------------------------------instance IsExpr Expr where- exprView e = case e of- Ident (QName x) -> LocalV x- App _ e1 e2 -> AppV e1 e2- OpApp r d es -> OpAppV d es- HiddenArg _ e -> HiddenArgV e- InstanceArg _ e -> InstanceArgV e- Paren _ e -> ParenV e- Lam _ bs e -> LamV bs e- Underscore{} -> WildV e- _ -> OtherV e- unExprView e = case e of- LocalV x -> Ident (QName x)- AppV e1 e2 -> App (fuseRange e1 e2) e1 e2- OpAppV d es -> OpApp (fuseRange d es) d es- HiddenArgV e -> HiddenArg (getRange e) e- InstanceArgV e -> InstanceArg (getRange e) e- ParenV e -> Paren (getRange e) e- LamV bs e -> Lam (fuseRange bs e) bs e- WildV e -> e- OtherV e -> e---instance IsExpr Pattern where- exprView e = case e of- IdentP (QName x) -> LocalV x- AppP e1 e2 -> AppV e1 e2- OpAppP r d es -> OpAppV d (map Ordinary es)- HiddenP _ e -> HiddenArgV e- InstanceP _ e -> InstanceArgV e- ParenP _ e -> ParenV e- WildP{} -> WildV e- _ -> OtherV e- unExprView e = case e of- LocalV x -> IdentP (QName x)- AppV e1 e2 -> AppP e1 e2- OpAppV d es -> let ess :: [Pattern]- ess = (map (fromOrdinary __IMPOSSIBLE__) es)- in OpAppP (fuseRange d es) d ess- HiddenArgV e -> HiddenP (getRange e) e- InstanceArgV e -> InstanceP (getRange e) e- ParenV e -> ParenP (getRange e) e- LamV _ _ -> __IMPOSSIBLE__- WildV e -> e- OtherV e -> e---------------------------------------------------------------------------------- * Parse functions-------------------------------------------------------------------------------- | Returns the list of possible parses.-parsePattern :: ReadP Pattern Pattern -> Pattern -> [Pattern]-parsePattern prs p = case p of- AppP p (Arg h r q) -> fullParen' <$> (AppP <$> parsePattern prs p <*> (Arg h r <$> traverse (parsePattern prs) q))- RawAppP _ ps -> fullParen' <$> (parsePattern prs =<< parse prs ps)- OpAppP r d ps -> fullParen' . OpAppP r d <$> mapM (parsePattern prs) ps- HiddenP _ _ -> fail "bad hidden argument"- InstanceP _ _ -> fail "bad instance argument"- AsP r x p -> AsP r x <$> parsePattern prs p- DotP r e -> return $ DotP r e- ParenP r p -> fullParen' <$> parsePattern prs p- WildP _ -> return p- AbsurdP _ -> return p- LitP _ -> return p- IdentP _ -> return p----- | Parses a left-hand side, and makes sure that it defined the expected name.--- TODO: check the arities of constructors. There is a possible ambiguity with--- postfix constructors:--- Assume _ * is a constructor. Then 'true *' can be parsed as either the--- intended _* applied to true, or as true applied to a variable *. If we--- check arities this problem won't appear.-parseLHS :: Maybe Name -> Pattern -> ScopeM Pattern-parseLHS top p = do- patP <- buildParser (getRange p) DontUseBoundNames- cons <- getNames [ConName]- case filter (validPattern top cons) $ parsePattern patP p of- [p] -> return p- [] -> typeError $ NoParseForLHS p- ps -> typeError $ AmbiguousParseForLHS p $ map fullParen ps- where- getNames kinds = map fst <$> getDefinedNames kinds-- validPattern :: Maybe Name -> [Name] -> Pattern -> Bool- validPattern (Just top) cons p = case appView p of- IdentP (QName x) : ps -> x == top && all (validPat cons) ps- _ -> False- validPattern Nothing cons p = validPat cons p-- validPat :: [Name] -> Pattern -> Bool- validPat cons p = case appView p of- [_] -> True- IdentP (QName x) : ps -> elem x cons && all (validPat cons) ps- ps -> all (validPat cons) ps-- appView :: Pattern -> [Pattern]- appView p = case p of- AppP p a -> appView p ++ [namedThing (unArg a)]- OpAppP _ op ps -> IdentP (QName op) : ps- ParenP _ p -> appView p- RawAppP _ _ -> __IMPOSSIBLE__- HiddenP _ _ -> __IMPOSSIBLE__- InstanceP _ _ -> __IMPOSSIBLE__- _ -> [p]--parseApplication :: [Expr] -> ScopeM Expr-parseApplication [e] = return e-parseApplication es = do- -- Build the parser- p <- buildParser (getRange es) UseBoundNames-- -- Parse- case parse p es of- [e] -> return e- [] -> do- -- When the parser fails and a name is not in scope, it is more- -- useful to say that to the user rather than just "failed".- inScope <- partsInScope- case [ QName x | Ident (QName x) <- es, not (Set.member x inScope) ] of- [] -> typeError $ NoParseForApplication es- xs -> typeError $ NotInScope xs-- es' -> typeError $ AmbiguousParseForApplication es $ map fullParen es'---- Inserting parenthesis ----------------------------------------------------fullParen :: IsExpr e => e -> e-fullParen e = case exprView $ fullParen' e of- ParenV e -> e- e' -> unExprView e'--fullParen' :: IsExpr e => e -> e-fullParen' e = case exprView e of- LocalV _ -> e- WildV _ -> e- OtherV _ -> e- HiddenArgV _ -> e- InstanceArgV _ -> e- ParenV _ -> e- AppV e1 (Arg h r e2) -> par $ unExprView $ AppV (fullParen' e1) (Arg h r e2')- where- e2' = case h of- Hidden -> e2- Instance -> e2- NotHidden -> fullParen' <$> e2- OpAppV x es -> par $ unExprView $ OpAppV x $ map (fmap fullParen') es- LamV bs e -> par $ unExprView $ LamV bs (fullParen e)- where- par = unExprView . ParenV--paren :: Monad m => (Name -> m Fixity) -> Expr -> m (Precedence -> Expr)-paren _ e@(App _ _ _) = return $ \p -> mparen (appBrackets p) e-paren f e@(OpApp _ op _) = do fx <- f op; return $ \p -> mparen (opBrackets fx p) e-paren _ e@(Lam _ _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(AbsurdLam _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(ExtendedLam _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(Fun _ _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(Pi _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(Let _ _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(Rec _ _) = return $ \p -> mparen (appBrackets p) e-paren _ e@(RecUpdate _ _ _) = return $ \p -> mparen (appBrackets p) e-paren _ e@(WithApp _ _ _) = return $ \p -> mparen (withAppBrackets p) e-paren _ e@(Ident _) = return $ \p -> e-paren _ e@(Lit _) = return $ \p -> e-paren _ e@(QuestionMark _ _) = return $ \p -> e-paren _ e@(Underscore _ _) = return $ \p -> e-paren _ e@(Set _) = return $ \p -> e-paren _ e@(SetN _ _) = return $ \p -> e-paren _ e@(Prop _) = return $ \p -> e-paren _ e@(Paren _ _) = return $ \p -> e-paren _ e@(As _ _ _) = return $ \p -> e-paren _ e@(Dot _ _) = return $ \p -> e-paren _ e@(Absurd _) = return $ \p -> e-paren _ e@(ETel _) = return $ \p -> e-paren _ e@(RawApp _ _) = __IMPOSSIBLE__-paren _ e@(HiddenArg _ _) = __IMPOSSIBLE__-paren _ e@(InstanceArg _ _) = __IMPOSSIBLE__-paren _ e@(QuoteGoal _ _ _) = return $ \p -> mparen (lamBrackets p) e-paren _ e@(Quote _) = return $ \p -> e-paren _ e@(QuoteTerm _) = return $ \p -> e-paren _ e@(Unquote _) = return $ \p -> e-paren _ e@(DontCare _) = return $ \p -> e--mparen :: Bool -> Expr -> Expr-mparen True e = Paren (getRange e) e-mparen False e = e+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++{-# LANGUAGE DataKinds #-}++{-| The parser doesn't know about operators and parses everything as normal+ function application. This module contains the functions that parses the+ operators properly. For a stand-alone implementation of this see+ @src\/prototyping\/mixfix\/old@.++ It also contains the function that puts parenthesis back given the+ precedence of the context.+-}++module Agda.Syntax.Concrete.Operators+ ( parseApplication+ , parseArguments+ , parseLHS+ , parsePattern+ , parsePatternSyn+ ) where++import Prelude hiding (null)++import Control.Applicative ( Alternative( (<|>) ) )+import Control.Monad.Except (throwError)+import Control.Monad ((<$!>))++import Data.Either (partitionEithers)+import qualified Data.Function+import Data.Foldable+import qualified Data.List as List+import Data.Maybe+import Data.Set (Set)+import qualified Data.Set as Set+import qualified Data.Traversable as Trav++import Agda.Syntax.Abstract.Name (KindOfName(..))+import Agda.Syntax.Common+import Agda.Syntax.Concrete hiding (appView)+import Agda.Syntax.Concrete.Operators.Parser+import Agda.Syntax.Concrete.Operators.Parser.Monad hiding (parse)+import Agda.Syntax.Concrete.Pattern+import Agda.Syntax.Position+import Agda.Syntax.Notation+import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Operator+import Agda.Syntax.Scope.Monad++import Agda.TypeChecking.Monad.Base (typeError, TypeError(..), LHSOrPatSyn(..))+import qualified Agda.TypeChecking.Monad.Benchmark as Bench+import Agda.TypeChecking.Monad.Debug+import Agda.TypeChecking.Monad.State (getScope)++import Agda.Utils.Function (applyWhen, applyWhenJust)+import Agda.Utils.Either+import Agda.Syntax.Common.Pretty+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|), (<|))+import Agda.Utils.List2 (List2, pattern List2)+import Agda.Utils.Null+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2+import Agda.Utils.Maybe+import Agda.Utils.Monad (guardWithError)+import Agda.Utils.Trie (Trie)+import qualified Agda.Utils.Trie as Trie++import Agda.Utils.Impossible++---------------------------------------------------------------------------+-- * Billing+---------------------------------------------------------------------------++-- | Bills the operator parser.++billToParser :: ExprKind -> ScopeM a -> ScopeM a+billToParser k = Bench.billTo $! case k of+ IsExpr -> [Bench.Parsing, Bench.OperatorsExpr]+ IsPattern _ -> [Bench.Parsing, Bench.OperatorsPattern]++---------------------------------------------------------------------------+-- * Building the parser+---------------------------------------------------------------------------++-- | A data structure used internally by 'buildParsers'.+data InternalParsers e = InternalParsers+ { pTop :: Parser e e+ , pApp :: Parser e e+ , pArgs :: Parser e [NamedArg e]+ , pNonfix :: Parser e e+ , pAtom :: Parser e e+ }++-- | The data returned by 'buildParsers'.++data Parsers e = Parsers+ { parser :: !([e] -> [e])+ -- ^ A parser for expressions or patterns (depending on the+ -- 'ExprKind' argument given to 'buildParsers').+ , argsParser :: !([e] -> [[NamedArg e]])+ -- ^ A parser for sequences of arguments.+ , operators :: ![NotationSection]+ -- ^ All operators, notations, and sections that were used to generate+ -- the grammar.+ -- Only used for error reporting via 'OperatorInformation'.+ , operatorScope :: !OperatorScope+ -- ^ A flattened scope that only contains names such that+ -- they occur in the expression or at least one of their+ -- name parts occurs in the expression.+ }++{-# SPECIALIZE buildParsersFromOperatorScope ::+ ExprKind -> Maybe QName -> Set QName -> OperatorScope -> ScopeM (Parsers Expr) #-}+{-# SPECIALIZE buildParsersFromOperatorScope ::+ ExprKind -> Maybe QName -> Set QName -> OperatorScope -> ScopeM (Parsers Pattern) #-}++-- | Builds parsers for operator applications from all the operators+-- and function symbols in scope.+--+-- When parsing a pattern we do not use bound names. The effect is+-- that unqualified operator parts (that are not constructor parts)+-- can be used as atomic names in the pattern (so they can be+-- rebound). See @test/succeed/OpBind.agda@ for an example.+--+-- When parsing a pattern we also disallow the use of sections, mainly+-- because there is little need for sections in patterns. Note that+-- sections are parsed by splitting up names into multiple tokens+-- (@_+_@ is replaced by @_@, @+@ and @_@), and if we were to support+-- sections in patterns, then we would have to accept certain such+-- sequences of tokens as single pattern variables.++buildParsersFromOperatorScope ::+ forall e. IsExpr e+ => ExprKind+ -> Maybe QName+ -> Set QName+ -> OperatorScope+ -> ScopeM (Parsers e)+buildParsersFromOperatorScope kind top namesInExpr opScope = do++ (names, ops0) <- localNames kind top opScope+ let ops | isKindPattern kind = filter' (not . isLambdaNotation) ops0+ | otherwise = ops0++ let+ partListsInExpr' = map' (List1.toList . nameParts . unqualify)+ (Set.toList namesInExpr)++ partListTrie f =+ foldr' (\ps -> Trie.union (Trie.everyPrefix ps ()))+ Trie.empty+ (f partListsInExpr')++ -- All names.+ partListsInExpr :: Trie NamePart ()+ partListsInExpr = partListTrie id++ -- All names, with the name parts in reverse order.+ reversedPartListsInExpr :: Trie NamePart ()+ reversedPartListsInExpr = partListTrie (map' reverse)++ -- Every regular name part (not holes etc.).+ partsInExpr :: Set RawName+ partsInExpr =+ Set.fromList [ s | Id s <- concat' partListsInExpr']++ -- Are all name parts present in the expression?+ partsPresent n = map' (\p -> Set.member p partsInExpr) (stringParts (notation n))++ addHole True p = [Hole, Id p]+ addHole False p = [Id p]++ -- Is the first identifier part present in n present in the+ -- expression, without any preceding name parts, except for a+ -- leading underscore iff withHole is True?+ firstPartPresent withHole n =+ Trie.member (addHole withHole p) partListsInExpr+ where+ p = case n of+ HolePart{} : IdPart p : _ -> rangedThing p+ IdPart p : _ -> rangedThing p+ _ -> __IMPOSSIBLE__++ -- Is the last identifier part present in n present in the+ -- expression, without any succeeding name parts, except for a+ -- trailing underscore iff withHole is True?+ lastPartPresent withHole n =+ Trie.member (addHole withHole p) reversedPartListsInExpr+ where+ p = case reverse n of+ HolePart{} : IdPart p : _ -> rangedThing p+ IdPart p : _ -> rangedThing p+ _ -> __IMPOSSIBLE__++ -- Are the initial and final identifier parts present with+ -- the right mix of leading and trailing underscores?+ correctUnderscores :: Bool -> Bool -> Notation -> Bool+ correctUnderscores withInitialHole withFinalHole n =+ firstPartPresent withInitialHole n+ &&+ lastPartPresent withFinalHole n++ -- Should be used with operators (not sections) and notations+ -- coming from syntax declarations.+ filterCorrectUnderscoresOp :: [NewNotation] -> [NotationSection]+ filterCorrectUnderscoresOp ns =+ [ noSection n+ | n <- ns+ , if notaIsOperator n+ then correctUnderscores False False (notation n)+ else all (\s -> Trie.member [Id s] partListsInExpr)+ (stringParts $ notation n)+ ]++ -- Should be used with sections.+ correctUnderscoresSect :: NotationKind -> Notation -> Bool+ correctUnderscoresSect k n = case (k, notationKind n) of+ (PrefixNotation, InfixNotation) -> correctUnderscores True False n+ (PostfixNotation, InfixNotation) -> correctUnderscores False True n+ (NonfixNotation, InfixNotation) -> correctUnderscores True True n+ (NonfixNotation, PrefixNotation) -> correctUnderscores False True n+ (NonfixNotation, PostfixNotation) -> correctUnderscores True False n+ _ -> __IMPOSSIBLE__++ -- If "or" is replaced by "and" in conParts/allParts below,+ -- then the misspelled operator application "if x thenn x else+ -- x" can be parsed as "if" applied to five arguments,+ -- resulting in a confusing error message claiming that "if"+ -- is not in scope.++ (non, fix) = partition' nonfix (filter' (and . partsPresent) ops)++ cons :: [List1 NewNotation]+ cons = getDefinedNames+ (someKindsOfNames [ConName, CoConName, FldName, PatternSynName]) opScope+ conNames :: Set QName+ conNames = Set.fromList $+ filter' (flip Set.member namesInExpr) $+ map' (notaName . List1.head) cons+ conParts :: Set QName+ conParts = Set.fromList $ concatMap' notationNames conPartNotations+ conPartNotations :: [NewNotation]+ conPartNotations = filter' (or . partsPresent) $ List1.concat' cons++ allNames :: Set QName+ allNames = Set.fromList $+ filter' (flip Set.member namesInExpr) names+ allParts :: Set QName+ allParts = Set.union conParts+ (Set.fromList $+ concatMap' notationNames $+ filter' (or . partsPresent) ops)++ isAtom x+ | isKindPattern kind && not (isQualified x) =+ not (Set.member x conParts) || Set.member x conNames+ | otherwise =+ not (Set.member x allParts) || Set.member x allNames+ -- If string is a part of notation, it cannot be used as an identifier,+ -- unless it is also used as an identifier. See issue 307.++ parseSections = case kind of+ IsPattern _ -> DoNotParseSections+ IsExpr -> ParseSections++ let nonClosedSections l ns =+ case parseSections of+ DoNotParseSections -> []+ ParseSections ->+ [ NotationSection n k (Just l) True+ | n <- ns+ , isinfix n && notaIsOperator n+ , k <- [PrefixNotation, PostfixNotation]+ , correctUnderscoresSect k (notation n)+ ]++ unrelatedOperators :: [NotationSection]+ unrelatedOperators =+ filterCorrectUnderscoresOp unrelated+ ++!+ nonClosedSections Unrelated unrelated+ where+ unrelated = filter' ((== Unrelated) . level) fix++ nonWithSections :: [NotationSection]+ nonWithSections =+ map' (\s -> s { sectLevel = Nothing }) (filterCorrectUnderscoresOp non)+ ++!+ case parseSections of+ DoNotParseSections -> []+ ParseSections ->+ [ NotationSection n NonfixNotation Nothing True+ | n <- fix+ , notaIsOperator n+ , correctUnderscoresSect NonfixNotation (notation n)+ ]++ -- The triples have the form (level, operators). The lowest+ -- level comes first.+ relatedOperators :: [(PrecedenceLevel, [NotationSection])]+ relatedOperators =+ map' (\((l, ns) :| rest) -> (l, ns ++! concatMap' snd rest)) .+ List1.groupOn fst .+ mapMaybe' (\n -> case level n of+ Unrelated -> Nothing+ r@(Related l) ->+ Just (l, filterCorrectUnderscoresOp [n] +++ nonClosedSections r [n])) $+ fix++ almostEverything :: [NotationSection]+ almostEverything =+ concatMap' snd relatedOperators ++!+ unrelatedOperators ++!+ nonWithSections++ -- Andreas, 2026-02-21, issue #5839+ -- Add constructor parts to the used-operators list,+ -- so that failing lhs parses become more comprehensible.+ -- Disclaimer: I don't know my way around this code,+ -- and the expert did get active on this issue, see+ -- https://github.com/agda/agda/issues/5839#issuecomment-1073286909+ -- so I apologize if this is done in a non-idiomatic of clumsy fashion.+ everything :: [NotationSection]+ everything =+ almostEverything ++!+ map' noSection (filter' ((`Set.notMember` keys) . key) conPartNotations)+ where+ key = notaName+ keys = Set.fromList $ map' (key . sectNotation) almostEverything++ reportS "scope.operators" 50+ [ "unrelatedOperators = " ++ prettyShow unrelatedOperators+ , "nonWithSections = " ++ prettyShow nonWithSections+ , "relatedOperators = " ++ prettyShow relatedOperators+ , "conPartNotations = " ++ prettyShow conPartNotations+ ]++ let g = Data.Function.fix $ \p -> InternalParsers+ { pTop = memoise TopK $+ Agda.Utils.List.asum $+ foldr' (\(l, ns) higher ->+ mkP (RightPK l) parseSections+ (pTop p) ns higher True) (pApp p)+ relatedOperators :+ zipWith' (\ k n ->+ mkP (LeftPK k) parseSections+ (pTop p) [n] (pApp p) False) [0..] unrelatedOperators+ , pApp = memoise AppK $ appP (pNonfix p) (pArgs p)+ , pArgs = argsP (pNonfix p)+ , pNonfix = memoise NonfixK $+ Agda.Utils.List.asum $+ (pAtom p :) $!+ map' (\sect ->+ let n = sectNotation sect++ inner :: forall k. NK k ->+ Parser e (OperatorType k e)+ inner = opP parseSections (pTop p) n+ in+ case notationKind (notation n) of+ InfixNotation ->+ flip ($) <$> placeholder Beginning+ <*> inner In+ <*> placeholder End+ PrefixNotation ->+ inner Pre <*> placeholder End+ PostfixNotation ->+ flip ($) <$> placeholder Beginning+ <*> inner Post+ NonfixNotation -> inner Non+ NoNotation -> __IMPOSSIBLE__) nonWithSections+ , pAtom = atomP isAtom+ }++ -- Andreas, 2020-06-03 #4712+ -- Note: needs Agda to be compiled with DEBUG_PARSING to print the grammar.+ reportS "scope.grammar" 20 $+ "Operator grammar:" $$ nest 2 (grammar (pTop g))++ return $ Parsers+ { parser = parse (parseSections, pTop g)+ , argsParser = parse (parseSections, pArgs g)+ , operators = everything+ , operatorScope = opScope+ }+ where+ level :: NewNotation -> FixityLevel+ level = fixityLevel . notaFixity++ nonfix, isinfix, isprefix, ispostfix :: NewNotation -> Bool+ nonfix = (== NonfixNotation) . notationKind . notation+ isinfix = (== InfixNotation) . notationKind . notation+ isprefix = (== PrefixNotation) . notationKind . notation+ ispostfix = (== PostfixNotation) . notationKind . notation++ isPrefix, isPostfix :: NotationSection -> Bool+ isPrefix = (== PrefixNotation) . sectKind+ isPostfix = (== PostfixNotation) . sectKind++ isInfix :: Associativity -> NotationSection -> Bool+ isInfix ass s =+ sectKind s == InfixNotation+ &&+ fixityAssoc (notaFixity (sectNotation s)) == ass++ mkP :: PrecedenceKey -- Memoisation key.+ -> ParseSections+ -> Parser e e+ -> [NotationSection]+ -> Parser e e -- A parser for an expression of higher precedence.+ -> Bool -- Include the \"expression of higher precedence\"+ -- parser as one of the choices?+ -> Parser e e+ mkP key parseSections p0 ops higher includeHigher =+ memoise (NodeK key) $+ Agda.Utils.List.asum $+ applyWhen includeHigher (higher :) $!+ catMaybes [nonAssoc, preRights, postLefts]+ where+ -- Andreas, 2025-02-27+ -- Break up the choice function into its three cases,+ -- so that matching on @k@ does not have to be performed+ -- inside the mapped function @(\ sect -> ...)@.+ --+ -- choice :: forall k.+ -- NK k -> [NotationSection] ->+ -- Parser e (OperatorType k e)+ -- choice k =+ -- Agda.Utils.List.asum .+ -- map (\sect ->+ -- let n = sectNotation sect++ -- inner :: forall k.+ -- NK k -> Parser e (OperatorType k e)+ -- inner = opP parseSections p0 n+ -- in+ -- case k of+ -- In -> inner In++ -- Pre -> if isinfix n || ispostfix n+ -- then flip ($) <$> placeholder Beginning+ -- <*> inner In+ -- else inner Pre++ -- Post -> if isinfix n || isprefix n+ -- then flip <$> inner In+ -- <*> placeholder End+ -- else inner Post++ -- Non -> __IMPOSSIBLE__)++ choiceIn :: [NotationSection] -> Parser e (OperatorType 'InfixNotation e)+ choiceIn =+ Agda.Utils.List.asum .+ map' \ sect -> opP parseSections p0 (sectNotation sect) In++ choicePre :: [NotationSection] -> Parser e (OperatorType 'PrefixNotation e)+ choicePre =+ Agda.Utils.List.asum .+ map' \ sect -> do+ let n = sectNotation sect+ if isinfix n || ispostfix n+ then flip ($) <$> placeholder Beginning+ <*> opP parseSections p0 n In+ else opP parseSections p0 n Pre++ choicePost :: [NotationSection] -> Parser e (OperatorType 'PostfixNotation e)+ choicePost =+ Agda.Utils.List.asum .+ map' \ sect -> do+ let n = sectNotation sect+ if isinfix n || isprefix n+ then flip <$> opP parseSections p0 n In+ <*> placeholder End+ else opP parseSections p0 n Post++ nonAssoc :: Maybe (Parser e e)+ nonAssoc = case filter (isInfix NonAssoc) ops of+ [] -> Nothing+ ops -> Just $+ (\x f y -> f (noPlaceholder x) (noPlaceholder y))+ <$> higher+ <*> choiceIn ops+ <*> higher++ or _ [] _ [] = Nothing+ or _ [] p2 ops2 = Just (p2 ops2)+ or p1 ops1 _ [] = Just (p1 ops1)+ or p1 ops1 p2 ops2 = Just (p1 ops1 <|> p2 ops2)++ preRight :: Maybe (Parser e (MaybePlaceholder e -> e))+ preRight =+ or choicePre+ (filter' isPrefix ops)+ (\ops -> flip ($) <$> (noPlaceholder <$> higher)+ <*> choiceIn ops)+ (filter' (isInfix RightAssoc) ops)++ preRights :: Maybe (Parser e e)+ preRights = do+ preRight <- preRight+ return $ Data.Function.fix $ \preRights ->+ memoiseIfPrinting (PreRightsK key) $+ preRight <*> (noPlaceholder <$> (preRights <|> higher))++ postLeft :: Maybe (Parser e (MaybePlaceholder e -> e))+ postLeft =+ or choicePost+ (filter isPostfix ops)+ (\ops -> flip <$> choiceIn ops+ <*> (noPlaceholder <$> higher))+ (filter' (isInfix LeftAssoc) ops)++ postLefts :: Maybe (Parser e e)+ postLefts = do+ postLeft <- postLeft+ return $ Data.Function.fix $ \postLefts ->+ memoise (PostLeftsK key) $+ flip ($) <$> (noPlaceholder <$> (postLefts <|> higher))+ <*> postLeft++-- | Only build parsers if there's at least one relevant operator or notation in+-- scope.+buildParsers ::+ forall e. IsExpr e+ => ExprKind+ -- ^ Should expressions or patterns be parsed?+ -> Maybe QName+ -- ^ Are we trying to parse the lhs of the function given here?+ -> [QName]+ -- ^ This list must include every name part in the+ -- expression/pattern to be parsed (excluding name parts inside+ -- things like parenthesised subexpressions that are treated as+ -- atoms). The list is used to optimise the parser. For+ -- instance, a given notation is only included in the generated+ -- grammar if all of the notation's name parts are present in+ -- the list of names.+ -> ScopeM (Maybe (Parsers e))+buildParsers kind top exprNames0 = do+ let namesInExpr = Set.fromList $ applyWhenJust top (:) exprNames0+ opScope <- getOperatorScope namesInExpr <$> getScope+ if osHasOps opScope+ then Just <$!> buildParsersFromOperatorScope kind top namesInExpr opScope+ else pure Nothing++-- | Build parsers regardless of there being operators or notations in the relevant scope.+alwaysBuildParsers ::+ forall e. IsExpr e+ => ExprKind+ -- ^ Should expressions or patterns be parsed?+ -> Maybe QName+ -- ^ Are we trying to parse the lhs of the function given here?+ -> [QName]+ -- ^ This list must include every name part in the+ -- expression/pattern to be parsed (excluding name parts inside+ -- things like parenthesised subexpressions that are treated as+ -- atoms). The list is used to optimise the parser. For+ -- instance, a given notation is only included in the generated+ -- grammar if all of the notation's name parts are present in+ -- the list of names.+ -> ScopeM (Parsers e)+alwaysBuildParsers kind top exprNames0 = do+ let namesInExpr = Set.fromList $ applyWhenJust top (:) exprNames0+ opScope <- getOperatorScope namesInExpr <$> getScope+ buildParsersFromOperatorScope kind top namesInExpr opScope++---------------------------------------------------------------------------+-- * Parse functions+---------------------------------------------------------------------------++-- | Parses all 'RawAppP' in the given pattern using the given parser.+-- Returns the list of possible parses.+--+-- Naturally, does not recurse into 'DotP' as this contains no pattern.+--+-- Returns the empty list if the given parser does so+-- or if a 'HiddenP' or 'InstanceP' is encountered.+parsePat+ :: ([Pattern] -> [Pattern]) -- ^ Turns a 'RawAppP' into possible parses.+ -> Pattern -- ^ Pattern possibly containing 'RawAppP's.+ -> [Pattern] -- ^ Possible parses, not containing 'RawAppP's.+parsePat parse = loop+ where+ loop = \case+ AppP p (Arg info q) ->+ fullParen' <$> (AppP <$> loop p <*> (Arg info <$> traverse loop q))+ RawAppP _ ps -> fullParen' <$> (loop =<< parse (List2.toList ps))+ OpAppP r d ns ps -> fullParen' . OpAppP r d ns <$> (mapM . traverse . traverse) loop ps+ HiddenP _ _ -> fail "bad hidden argument"+ InstanceP _ _ -> fail "bad instance argument"+ AsP r x p -> AsP r x <$> loop p+ p@DotP{} -> return p+ ParenP _r p -> fullParen' <$> loop p+ p@WildP{} -> return p+ p@AbsurdP{} -> return p+ p@LitP{} -> return p+ p@QuoteP{} -> return p+ p@IdentP{} -> return p+ RecP kwr r fs -> RecP kwr r <$> mapM (traverse loop) fs+ p@EqualP{} -> return p -- Andrea: cargo culted from DotP+ EllipsisP r mp -> caseMaybe mp (fail "bad ellipsis") $ \p ->+ EllipsisP r . Just <$> loop p+ WithP r p -> WithP r <$> loop p+++{- Implement parsing of copattern left hand sides, e.g.++ record Tree (A : Set) : Set where+ field+ label : A+ child : Bool -> Tree A++ -- corecursive function defined by copattern matching+ alternate : {A : Set}(a b : A) -> Tree A+ -- shallow copatterns+ label (alternate a b) = a+ child (alternate a b) True = alternate b a+ -- deep copatterns:+ label (child (alternate a b) False) = b+ child (child (alternate a b) False) True = alternate a b+ child (child (alternate a b) False) False = alternate a b++ Delivers an infinite tree++ a+ b b+ a a a a+ b b b b b b b b+ ...++ Each lhs is a pattern tree with a distinct path of destructors+ ("child", "label") from the root to the defined symbol ("alternate").+ All branches besides this distinct path are patterns.++ Syntax.Concrete.LHSCore represents a lhs+ - the destructor path+ - the side patterns+ - the defined function symbol+ - the applied patterns+-}++-- | The result of 'parseLHS'.+data ParseLHS+ = ParsePattern Pattern -- ^ We parsed a pattern.+ | ParseLHS QName LHSCore -- ^ We parsed a lhs.++instance Pretty ParseLHS where+ pretty = \case+ ParsePattern p -> pretty p+ ParseLHS _f lhs -> pretty lhs++-- | Parses a left-hand side, workhorse for 'parseLHS'.+--+parseLHS' ::+ DisplayLHS+ -- ^ Are we parsing a 'DisplayPragma'?+ -- Then defined names are recognized as constructors.+ --+ -- In this case, 'LHSOrPatSyn' is 'IsLHS' and 'Maybe QName' is 'Just'.+ -> LHSOrPatSyn+ -- ^ Are we trying to parse a lhs or a pattern synonym?+ -- For error reporting only!+ -> Maybe QName+ -- ^ Name of the function/patSyn definition if we parse a lhs.+ -- 'Nothing' if we parse a pattern.+ -> Pattern+ -- ^ Thing to parse.+ -> ScopeM (ParseLHS, [NotationSection], OperatorScope)+ -- ^ The returned list contains all operators\/notations\/sections that+ -- were used to generate the grammar.++parseLHS' NoDisplayLHS IsLHS (Just qn) WildP{} =+ return (ParseLHS qn $ LHSHead qn [], [], empty)++parseLHS' displayLhs lhsOrPatSyn top p = do++ -- Build parser.+ patP <- alwaysBuildParsers (IsPattern displayLhs) top (patternQNames p)++ -- Run parser, forcing result.+ let ps = let result = parsePat (parser patP) p+ in foldr' seq () result `seq` result++ -- Classify parse results.+ let cons = getNames (someKindsOfNames $ applyWhen displayLhs (defNameKinds ++) conLikeNameKinds)+ (operatorScope patP)+ let flds = getNames (someKindsOfNames [FldName])+ (operatorScope patP)+ let conf = PatternCheckConfig top (hasElem cons) (hasElem flds)++ let (errs, results) = partitionEithers' $ map' (validPattern conf) ps+ reportS "scope.operators" 60 $ vcat $+ [ "Possible parses for lhs:" ] ++ map (nest 2 . pretty . snd) results+ case results of+ -- Unique result.+ [(_,lhs)] -> (lhs, operators patP, operatorScope patP) <$ do+ reportS "scope.operators" 50 $ "Parsed lhs:" <+> pretty lhs+ -- No result.+ [] -> typeError $ OperatorInformation (operators patP) (operatorScope patP) $+ NoParseForLHS lhsOrPatSyn (catMaybes errs) p+ -- Ambiguous result.+ r0:r1:rs -> typeError $ OperatorInformation (operators patP) (operatorScope patP) $+ AmbiguousParseForLHS lhsOrPatSyn p $+ fmap (fullParen . fst) $ List2 r0 r1 rs+ where+ getNames kinds flat =+ map' (notaName . List1.head) $ getDefinedNames kinds flat++ -- The pattern is retained for error reporting in case of ambiguous parses.+ validPattern :: PatternCheckConfig -> Pattern -> PM (Pattern, ParseLHS)+ validPattern conf p = do+ res <- classifyPattern conf p+ case (res, top) of+ (ParsePattern{}, Nothing) -> return (p, res) -- expect pattern+ (ParseLHS{} , Just{} ) -> return (p, res) -- expect lhs+ _ -> throwError Nothing++-- | Name sets for classifying a pattern.+data PatternCheckConfig = PatternCheckConfig+ { topName :: Maybe QName -- ^ Name of defined symbol.+ , conName :: QName -> Bool -- ^ Valid constructor name?+ , fldName :: QName -> Bool -- ^ Valid field name?+ }++-- | The monad for pattern checking and classification.+--+-- The error message is either empty or a subpattern that was found to be invalid.+type PM = Either (Maybe Pattern)++-- | Returns zero or one classified patterns.+-- In case of zero, return the offending subpattern.+classifyPattern :: PatternCheckConfig -> Pattern -> PM ParseLHS+classifyPattern conf p =+ case patternAppView p of++ -- case @f ps@+ Arg _ (Named _ (IdentP _ x)) :| ps | Just x == topName conf -> do+ mapM_ (valid . namedArg) ps+ return $ ParseLHS x $ lhsCoreAddSpine (LHSHead x []) ps++ -- case @d ps@+ -- Andreas, 2026-08-21, issue #8599:+ -- A field can only head a projection (copattern) if we are parsing a lhs,+ -- i.e., if we are looking for the defined name @topName@.+ -- When parsing a mere pattern, a field name has to be treated+ -- like an ordinary identifier, falling through to the last case.+ Arg _ (Named _ (IdentP _ x)) :| ps | isJust (topName conf), fldName conf x -> do++ -- Step 1: check for valid copattern lhs.+ ps0 :: [NamedArg ParseLHS] <- mapM classPat ps+ let (ps1, rest) = span (isParsePattern . namedArg) ps0+ (p2, ps3) <- maybeToEither Nothing $ uncons rest+ -- when (null rest): no field pattern or def pattern found++ -- Ensure that the @ps3@ are patterns rather than lhss.+ mapM_ (guardWithError Nothing . isParsePattern . namedArg) ps3++ -- Step 2: construct the lhs.+ let (f, lhs0) = fromParseLHS $ namedArg p2+ lhs = setNamedArg p2 lhs0+ (ps', _:ps'') = splitAt (length ps1) ps+ return $ ParseLHS f $ lhsCoreAddSpine (LHSProj x ps' lhs []) ps''++ -- case @...@+ Arg _ (Named _ (EllipsisP r (Just p))) :| ps -> do+ classifyPattern conf p >>= \case -- TODO: avoid re-parsing+ ParsePattern{} -> throwError Nothing+ (ParseLHS f core) -> do+ mapM_ (valid . namedArg) ps+ let ellcore = LHSEllipsis r core+ return $ ParseLHS f $ lhsCoreAddSpine ellcore ps++ -- case: ordinary pattern+ _ -> ParsePattern p <$ valid p++ where+ valid = validConPattern $ conName conf++ classPat :: NamedArg Pattern -> PM (NamedArg ParseLHS)+ classPat = Trav.mapM (Trav.mapM (classifyPattern conf))++ isParsePattern = \case+ ParsePattern{} -> True+ ParseLHS{} -> False++ fromParseLHS :: ParseLHS -> (QName, LHSCore)+ fromParseLHS = \case+ ParseLHS f lhs -> (f, lhs)+ ParsePattern{} -> __IMPOSSIBLE__+++-- | Parses a left-hand side, and makes sure that it defined the expected name.+parseLHS ::+ DisplayLHS+ -- ^ Are we parsing a 'DisplayPragma'?+ -> QName+ -- ^ Name of the definition.+ -> Pattern+ -- ^ Full left hand side.+ -> ScopeM LHSCore+parseLHS displayLhs top p = billToParser (IsPattern displayLhs) $ do+ (res, ops, opScope) <- parseLHS' displayLhs IsLHS (Just top) p+ case res of+ ParseLHS _f lhs -> return lhs+ _ -> typeError $ OperatorInformation ops opScope+ $ NoParseForLHS IsLHS [] p++-- | Parses a pattern.+parsePattern :: Pattern -> ScopeM Pattern+parsePattern = parsePatternOrSyn IsLHS++parsePatternSyn :: Pattern -> ScopeM Pattern+parsePatternSyn = parsePatternOrSyn IsPatSyn++parsePatternOrSyn :: LHSOrPatSyn -> Pattern -> ScopeM Pattern+parsePatternOrSyn lhsOrPatSyn p = billToParser (IsPattern NoDisplayLHS) $ do+ (res, ops, opScope) <- parseLHS' NoDisplayLHS lhsOrPatSyn Nothing p+ case res of+ ParsePattern p -> return p+ _ -> typeError $ OperatorInformation ops opScope+ $ NoParseForLHS lhsOrPatSyn [] p++-- | Helper function for 'parseLHS' and 'parsePattern'.+--+-- Returns a subpattern that is not a valid constructor pattern+-- or nothing if the whole pattern is a valid constructor pattern.+validConPattern+ :: (QName -> Bool) -- ^ Test for constructor name.+ -> Pattern -- ^ Supposedly a constructor pattern.+ -> PM () -- ^ Offending subpattern or nothing.+validConPattern cons = loop+ where+ loop p = case appView p of++ -- Eliminated by appView:+ AppP{} :| _ -> __IMPOSSIBLE__+ OpAppP{} :| _ -> __IMPOSSIBLE__+ ParenP{} :| _ -> __IMPOSSIBLE__+ RawAppP{} :| _ -> __IMPOSSIBLE__+ HiddenP{} :| _ -> __IMPOSSIBLE__+ InstanceP{} :| _ -> __IMPOSSIBLE__++ -- Hopeful cases:+ WithP _ p :| [] -> loop p+ _ :| [] -> ok+ IdentP _ x :| ps+ | cons x -> mapM_ loop ps+ | otherwise -> failure+ QuoteP _ :| [_] -> ok+ DotP _ _ _ _ :| ps -> mapM_ loop ps++ -- Failures:+ AbsurdP{} :| _:_ -> failure+ AsP{} :| _:_ -> failure+ EllipsisP{} :| _:_ -> failure+ EqualP{} :| _:_ -> failure+ LitP{} :| _:_ -> failure+ QuoteP{} :| _:_ -> failure+ RecP{} :| _:_ -> failure+ WildP{} :| _:_ -> failure+ WithP{} :| _:_ -> failure+ where+ ok = return ()+ failure = throwError $ Just p+++-- | Helper function for 'parseLHS' and 'parsePattern'.+appView :: Pattern -> List1 Pattern+appView = loop []+ where+ loop acc = \case+ AppP p a -> loop (namedArg a : acc) p+ OpAppP _ op _ ps -> (IdentP True op <| fmap namedArg ps)+ `List1.appendList`+ reverse acc+ ParenP _ p -> loop acc p+ RawAppP _ _ -> __IMPOSSIBLE__+ HiddenP _ _ -> __IMPOSSIBLE__+ InstanceP _ _ -> __IMPOSSIBLE__+ p@IdentP{} -> ret p+ p@WildP{} -> ret p+ p@AsP{} -> ret p+ p@AbsurdP{} -> ret p+ p@LitP{} -> ret p+ p@QuoteP{} -> ret p+ p@DotP{} -> ret p+ p@RecP{} -> ret p+ p@EqualP{} -> ret p+ p@EllipsisP{} -> ret p+ p@WithP{} -> ret p+ where+ ret p = p :| reverse acc++-- | Parse a list of expressions (typically from a 'RawApp') into an application.+parseApplication :: List2 Expr -> ScopeM Expr+parseApplication es = billToParser IsExpr $ do+ let es0 = List2.toList es+ p <- buildParsers IsExpr Nothing [ q | Ident q <- es0 ]+ case p of++ -- no operators or notations in scope+ Nothing -> do+ let hd :| rest = List2.toList1 es+ app :: Expr -> Expr -> Expr+ app !acc !e = let+ range = fuseRange acc e+ !arg = case e of+ HiddenArg _ e -> hide (defaultArg e)+ InstanceArg _ e -> makeInstance (defaultArg e)+ e -> defaultArg (unnamed e)+ in App range acc arg+ !res = foldl' app hd rest+ pure res++ -- operators or notations in scope+ Just p -> case parser p es0 of+ [e] -> do+ reportS "scope.operators" 50 $+ "Parsed an operator application:" <+> pretty e+ return $! e+ [] -> typeError $ OperatorInformation (operators p) (operatorScope p)+ $ NoParseForApplication es+ e:es' -> typeError $ OperatorInformation (operators p) (operatorScope p)+ $ AmbiguousParseForApplication es+ $ fmap fullParen (e :| es')++-- | Parse the arguments of a raw application with known head.+--+parseArguments ::+ Expr -- ^ Head+ -> [Expr] -- ^ Raw arguments+ -> ScopeM [NamedArg Expr] -- ^ Operator-parsed arguments+parseArguments hd = \case+ [] -> return []+ es@(e1 : rest) -> billToParser IsExpr $ do++ -- Form the raw application for error reporting+ let es2 = List2 hd e1 rest++ -- Build the arguments parser+ p <- buildParsers IsExpr Nothing [ q | Ident q <- es ]+ case p of+ Nothing -> do+ let go :: Expr -> NamedArg Expr+ go (HiddenArg _ e) = hide (defaultArg e)+ go (InstanceArg _ e) = makeInstance (defaultArg e)+ go e = defaultArg (unnamed e)+ return $! map' go es+ Just p -> case argsParser p es of+ [as] -> return $! as+ [] -> typeError $ OperatorInformation (operators p) (operatorScope p)+ $ NoParseForApplication es2+ as : ass -> do+ let f = fullParen . foldl' (App noRange) hd+ typeError $ OperatorInformation (operators p) (operatorScope p)+ $ AmbiguousParseForApplication es2+ $ fmap f (as :| ass)++---------------------------------------------------------------------------+-- * Inserting parenthesis+---------------------------------------------------------------------------++fullParen :: IsExpr e => e -> e+fullParen e = case exprView $ fullParen' e of+ ParenV e -> e+ e' -> unExprView e'++fullParen' :: IsExpr e => e -> e+fullParen' e = case exprView e of+ LocalV _ -> e+ WildV _ -> e+ OtherV _ -> e+ HiddenArgV _ -> e+ InstanceArgV _ -> e+ ParenV _ -> e+ AppV e1 (Arg info e2) -> par $ unExprView $ AppV (fullParen' e1) (Arg info e2')+ where+ e2' = case argInfoHiding info of+ Hidden -> e2+ Instance{} -> e2+ NotHidden -> fullParen' <$> e2+ OpAppV x ns es -> par $ unExprView $ OpAppV x ns $ (fmap . fmap . fmap . fmap . fmap) fullParen' es+ LamV bs e -> par $ unExprView $ LamV bs (fullParen e)+ where+ par = unExprView . ParenV
@@ -1,209 +1,376 @@-{-# LANGUAGE CPP, ScopedTypeVariables #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-} +{-# LANGUAGE DataKinds #-}+ module Agda.Syntax.Concrete.Operators.Parser where +import Control.Applicative ( Alternative((<|>), many) )+import Control.Monad ((<=<))++import Data.Function (on)+import Data.Kind ( Type )+import qualified Data.List as List+import qualified Data.Strict.Maybe as Strict+ import Agda.Syntax.Position+import qualified Agda.Syntax.Abstract.Name as A import Agda.Syntax.Common-import Agda.Syntax.Fixity import Agda.Syntax.Notation import Agda.Syntax.Concrete-import Agda.Syntax.Concrete.Name-import Agda.Utils.ReadP-import Agda.Utils.Monad+import Agda.Syntax.Concrete.Operators.Parser.Monad hiding (parse)+import qualified Agda.Syntax.Concrete.Operators.Parser.Monad as P -#include "../../../undefined.h"+import Agda.Syntax.Common.Pretty+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Set1 ( Set1 )+import Agda.Utils.Singleton+ import Agda.Utils.Impossible +placeholder :: PositionInName -> Parser e (MaybePlaceholder e)+placeholder p =+ doc (text ("_" ++ show p)) $+ sat $ \case+ Placeholder p' | p' == p -> True+ _ -> False++maybePlaceholder ::+ Maybe PositionInName -> Parser e e -> Parser e (MaybePlaceholder e)+maybePlaceholder mp p = case mp of+ Nothing -> p'+ Just h -> placeholder h <|> p'+ where+ p' = noPlaceholder <$> p++satNoPlaceholder :: (e -> Maybe a) -> Parser e a+satNoPlaceholder p = sat' $ \case+ NoPlaceholder _ e -> p e+ Placeholder _ -> Nothing+ data ExprView e- = LocalV Name+ = LocalV QName | WildV e | OtherV e | AppV e (NamedArg e)- | OpAppV Name [OpApp e]- | HiddenArgV (Named String e)- | InstanceArgV (Named String e)- | LamV [LamBinding] e+ | OpAppV QName (Set1 A.Name) (OpAppArgs' e)+ -- ^ The 'QName' is possibly ambiguous, but it must correspond+ -- to one of the names in the set.+ | HiddenArgV (Named_ e)+ | InstanceArgV (Named_ e)+ | LamV (List1 LamBinding) e | ParenV e -- deriving (Show) class HasRange e => IsExpr e where- exprView :: e -> ExprView e- unExprView :: ExprView e -> e+ exprView :: e -> ExprView e+ unExprView :: ExprView e -> e+ patternView :: e -> Maybe Pattern ------------------------------------------------------------------------------- * Parser combinators----------------------------------------------------------------------------+instance IsExpr e => HasRange (ExprView e) where+ getRange = getRange . unExprView --- | Combining a hierarchy of parsers.-recursive :: (ReadP tok a -> [ReadP tok a -> ReadP tok a]) -> ReadP tok a-recursive f = p0+instance IsExpr Expr where+ exprView = \case+ Ident x -> LocalV x+ App _ e1 e2 -> AppV e1 e2+ OpApp _ d ns es -> OpAppV d ns es+ HiddenArg _ e -> HiddenArgV e+ InstanceArg _ e -> InstanceArgV e+ Paren _ e -> ParenV e+ Lam _ bs e -> LamV bs e+ e@Underscore{} -> WildV e+ e -> OtherV e+ unExprView = \case+ LocalV x -> Ident x+ AppV e1 e2 -> App (fuseRange e1 e2) e1 e2+ OpAppV d ns es -> OpApp (fuseRange d es) d ns es+ HiddenArgV e -> HiddenArg (getRange e) e+ InstanceArgV e -> InstanceArg (getRange e) e+ ParenV e -> Paren (getRange e) e+ LamV bs e -> Lam (fuseRange bs e) bs e+ WildV e -> e+ OtherV e -> e++ patternView = isPattern++instance IsExpr Pattern where+ exprView = \case+ IdentP True x -> LocalV x+ IdentP False _ -> __IMPOSSIBLE__+ AppP e1 e2 -> AppV e1 e2+ OpAppP _ d ns es -> OpAppV d ns $ (fmap . fmap . fmap) (noPlaceholder . Ordinary) es+ HiddenP _ e -> HiddenArgV e+ InstanceP _ e -> InstanceArgV e+ ParenP _ e -> ParenV e+ e@WildP{} -> WildV e+ e -> OtherV e+ unExprView = \case+ LocalV x -> IdentP True x+ AppV e1 e2 -> AppP e1 e2+ OpAppV d ns es -> let ess :: List1 (NamedArg Pattern)+ ess = (fmap . fmap . fmap)+ (\case+ Placeholder{} -> __IMPOSSIBLE__+ NoPlaceholder _ x -> fromOrdinary __IMPOSSIBLE__ x)+ es+ in OpAppP (fuseRange d ess) d ns ess+ HiddenArgV e -> HiddenP (getRange e) e+ InstanceArgV e -> InstanceP (getRange e) e+ ParenV e -> ParenP (getRange e) e+ LamV _ _ -> __IMPOSSIBLE__+ WildV e -> e+ OtherV e -> e++ patternView = pure++-- | Should sections be parsed?+data ParseSections = ParseSections | DoNotParseSections+ deriving (Eq, Show)++-- | Runs a parser. If sections should be parsed, then identifiers+-- with at least two name parts are split up into multiple tokens,+-- using 'PositionInName' to record the tokens' original positions+-- within their respective identifiers.++parse :: IsExpr e => (ParseSections, Parser e a) -> [e] -> [a]+parse (DoNotParseSections, p) es = P.parse p (map noPlaceholder es)+parse (ParseSections, p) es = P.parse p (List1.concat $ map splitExpr es)+ where+ splitExpr :: IsExpr e => e -> List1 (MaybePlaceholder e)+ splitExpr e = case exprView e of+ LocalV n -> splitName n+ _ -> noSplit where- fs = f p0- p0 = foldr ( $ ) p0 fs+ noSplit = singleton $ noPlaceholder e --- | Variant of chainr1-chainr1' :: ReadP t a -> ReadP t (a -> a -> ReadP t a) -> ReadP t a-chainr1' p op = scan- where scan = p >>= rest- rest x = do f <- op- y <- scan- f x y- +++ return x+ splitName n = case List1.last ns of+ Name r nis ps@(_ :| _ : _) -> splitParts r nis (List1.init ns) Beginning ps+ _ -> noSplit+ where+ ns = qnameParts n --- | Variant of chainl1-chainl1' :: ReadP t a -> ReadP t (a -> a -> ReadP t a) -> ReadP t a-chainl1' p op = p >>= rest- where rest x = do f <- op- y <- p- fxy <- f x y- rest fxy- +++ return x+ -- Note that the same range is used for every name part. This is+ -- not entirely correct, but will hopefully not lead to any+ -- problems. + -- Note also that the module qualifier, if any, is only applied+ -- to the first name part.++ splitParts _ _ _ _ (Hole :| []) = singleton $ Placeholder End+ splitParts r nis m _ (Id s :| []) = singleton $ part r nis m End s+ splitParts r nis m w (Hole :| p : ps) = Placeholder w <| splitParts r nis m Middle (p :| ps)+ splitParts r nis m w (Id s :| p : ps) = part r nis m w s <| splitParts r nis [] Middle (p :| ps)++ part r nis m w s =+ NoPlaceholder (Strict.Just w)+ (unExprView $ LocalV $+ foldr Qual (QName $ Name r nis $ singleton $ Id s) m)++---------------------------------------------------------------------------+-- * Parser combinators+---------------------------------------------------------------------------+ ---------------------------- -- Specific combinators -- | Parse a specific identifier as a NamePart-partP :: IsExpr e => String -> ReadP e (Range, NamePart)-partP s = do- tok <- get- case isLocal s tok of- Just p -> return p- Nothing -> pfail- where- isLocal x e = case exprView e of- LocalV (Name r [Id y]) | x == y -> Just (r, Id y)- _ -> Nothing+partP :: IsExpr e => [Name] -> RawName -> Parser e Range+partP ms s =+ doc (text (show str)) $+ satNoPlaceholder isLocal+ where+ str = prettyShow $ foldr Qual (QName $ simpleName s) ms+ isLocal e = case exprView e of+ LocalV y | str == prettyShow y -> Just $ getRange y+ _ -> Nothing -binop :: IsExpr e => ReadP e (NewNotation,Range,[e]) -> ReadP e (e -> e -> ReadP a e)-binop middleP = do- (nsyn,r,es) <- middleP- return $ \x y -> rebuild nsyn r (x : es ++ [y])+-- | Parses a split-up, unqualified name consisting of at least two+-- name parts.+--+-- The parser does not check that underscores and other name parts+-- alternate. The range of the resulting name is the range of the+-- first name part that is not an underscore. -preop, postop :: IsExpr e => ReadP e (NewNotation,Range,[e]) -> ReadP e (e -> ReadP a e)-preop middleP = do- (nsyn,r,es) <- middleP- return $ \x -> rebuild nsyn r (es ++ [x])+atLeastTwoParts :: IsExpr e => Parser e Name+atLeastTwoParts =+ (\p1 ps p2 ->+ let all = p1 :| ps ++ [p2] in+ case List1.mapMaybe fst all of+ (r,nis) : _ -> Name r nis (fmap snd all)+ [] -> __IMPOSSIBLE__)+ <$> part Beginning+ <*> many (part Middle)+ <*> part End+ where+ part pos = sat' $ \case+ Placeholder pos' | pos == pos' -> Just ( Nothing+ , Hole+ )+ NoPlaceholder (Strict.Just pos') e | pos == pos' ->+ case exprView e of+ LocalV (QName (Name r nis (Id s :| []))) -> Just (Just (r, nis), Id s)+ _ -> Nothing+ _ -> Nothing -postop middleP = do- (nsyn,r,es) <- middleP- return $ \x -> rebuild nsyn r (x : es)+-- | Parses a potentially pattern-matching binder +patternBinder :: IsExpr e => Parser e Binder+patternBinder = inOnePart <|> mkBinder_ <$> atLeastTwoParts+ where inOnePart = satNoPlaceholder $ isBinderP <=< patternView +-- | Used to define the return type of 'opP'. --- | Parse the "operator part" of the given syntax.--- holes at beginning and end are IGNORED.+type family OperatorType (k :: NotationKind) (e :: Type) :: Type+type instance OperatorType 'InfixNotation e = MaybePlaceholder e -> MaybePlaceholder e -> e+type instance OperatorType 'PrefixNotation e = MaybePlaceholder e -> e+type instance OperatorType 'PostfixNotation e = MaybePlaceholder e -> e+type instance OperatorType 'NonfixNotation e = e --- Note: it would be better to take the decision of "postprocessing" at the same--- place as where the holes are discarded, however that would require a dependently--- typed function (or duplicated code)-opP :: IsExpr e => ReadP e e -> NewNotation -> ReadP e (NewNotation,Range,[e])-opP p nsyn@(_,_,syn) = do- (range,es) <- worker $ removeExternalHoles syn- return (nsyn,range,es)- where worker [IdPart x] = do (r, part) <- partP x; return (r,[])- worker (IdPart x : _ : xs) = do- (r1, part) <- partP x- e <- p- (r2 , es) <- worker xs- return (fuseRanges r1 r2, e : es)- worker x = __IMPOSSIBLE__ -- holes and non-holes must be alternated.+-- | A singleton type for 'NotationKind' (except for the constructor+-- 'NoNotation'). - removeExternalHoles = reverse . removeLeadingHoles . reverse . removeLeadingHoles- where removeLeadingHoles = dropWhile isAHole+data NK (k :: NotationKind) :: Type where+ In :: NK 'InfixNotation+ Pre :: NK 'PrefixNotation+ Post :: NK 'PostfixNotation+ Non :: NK 'NonfixNotation --- | Given a name with a syntax spec, and a list of parsed expressions--- fitting it, rebuild the expression.--- Note that this function must not parse any input (as guaranteed by the type)-rebuild :: forall symbol e. IsExpr e => NewNotation -> Range -> [e] -> ReadP symbol e-rebuild (name,_,syn) r es = do- exprs <- mapM findExprFor [0..lastHole]- return $ unExprView $ OpAppV (setRange r name) exprs- where filledHoles = zip es (filter isAHole syn)- lastHole = maximum [t | Just t <- map holeTarget syn]- findExprFor :: Int -> ReadP a (OpApp e)- findExprFor n = case [e | (e,NormalHole m) <- filledHoles, m == n] of- [] -> fail $ "no expression for hole " ++ show n- [x] -> case [e | (e,BindHole m) <- filledHoles, m == n] of- [] -> return (Ordinary x) -- no variable to bind- vars -> do bs <- mapM rebuildBinding $ map exprView vars- return $ SyntaxBindingLambda (fuseRange bs x) bs x- _ -> fail $ "more than one expression for hole " ++ show n+-- | Parse the \"operator part\" of the given notation.+--+-- Normal holes (but not binders) at the beginning and end are+-- ignored.+--+-- If the notation does not contain any binders, then a section+-- notation is allowed.+opP :: forall e k. IsExpr e+ => ParseSections+ -> Parser e e -> NewNotation -> NK k -> Parser e (OperatorType k e)+opP parseSections p (NewNotation q names _ syn isOp) kind =+ flip fmap (worker (List1.init $ qnameParts q)+ withoutExternalHoles) $ \(range, hs) -> -rebuildBinding :: ExprView e -> ReadP a LamBinding- -- Andreas, 2011-04-07 put just 'Relevant' here, is this correct?-rebuildBinding (LocalV name) = return $ DomainFree NotHidden Relevant (mkBoundName_ name)-rebuildBinding (WildV e) =- return $ DomainFree NotHidden Relevant (mkBoundName_ $ Name noRange [Hole])-rebuildBinding _ = fail "variable name expected"+ let (normal, binders) = partitionEithers' hs+ lastHole = maximum $ ((-1) :) $ mapMaybe' holeTarget syn -($$$) :: (e -> ReadP a e) -> ReadP a e -> ReadP a e-f $$$ x = do- x' <- x- f x'+ app :: ([(MaybePlaceholder e, NamedArg (Ranged Int))] ->+ [(MaybePlaceholder e, NamedArg (Ranged Int))]) -> e+ app f =+ -- If we have an operator and there is exactly one+ -- placeholder for every hole, then we only return+ -- the operator.+ if isOp && noPlaceholders args == lastHole + 1 then+ -- Note that the information in the set "names" is thrown+ -- away here.+ unExprView (LocalV q')+ else+ List1.ifNull args+ {-then-} (unExprView $ LocalV q')+ {-else-} $ unExprView . OpAppV q' names+ where+ args = map (findExprFor (f normal) binders) [0..lastHole]+ q' = setRange range q+ in --- | Parse using the appropriate fixity, given a parser parsing the--- operator part, the name of the operator, and a parser of--- subexpressions.-infixP, infixrP, infixlP, postfixP, prefixP,nonfixP :: IsExpr e => ReadP e (NewNotation,Range,[e]) -> ReadP e e -> ReadP e e-prefixP op p = do- fs <- many (preop op)- e <- p- foldr (($$$)) (return e) fs+ case kind of+ In -> \x y -> app (\es -> (x, leadingHole) : es ++! [(y, trailingHole)])+ Pre -> \ y -> app (\es -> es ++! [(y, trailingHole)])+ Post -> \x -> app (\es -> (x, leadingHole) : es)+ Non -> app (\es -> es) -postfixP op p = do- e <- p- fs <- many (postop op)- foldl (flip ( $$$ )) (return e) fs+ where -infixlP op p = chainl1' p (binop op)-infixrP op p = chainr1' p (binop op)-infixP op p = do- e <- p- restP e- where- restP x = return x +++ do- f <- binop op- e <- p- f x e+ (leadingHoles, syn1) = span isAHole syn+ (withoutExternalHoles, trailingHoles) = spanEnd isAHole syn1 -nonfixP op p = (do- (nsyn,r,es) <- op- rebuild nsyn r es)- +++ p+ leadingHole = case leadingHoles of+ [HolePart _ h] -> h+ _ -> __IMPOSSIBLE__ -appP :: IsExpr e => ReadP e e -> ReadP e e -> ReadP e e-appP top p = do- h <- p- es <- many (nothidden +++ hidden +++ instanceH)- return $ foldl app h es- where+ trailingHole = case trailingHoles of+ [HolePart _ h] -> h+ _ -> __IMPOSSIBLE__ - app e arg = unExprView $ AppV e arg+ worker ::+ [Name] -> Notation ->+ Parser e (Range, [Either (MaybePlaceholder e, NamedArg (Ranged Int))+ (LamBinding, Ranged BoundVariablePosition)])+ worker _ [] = pure (noRange, [])+ worker ms (IdPart x : xs) =+ (\r1 (r2, es) -> (fuseRanges r1 r2, es))+ <$> partP ms (rangedThing x)+ <*> worker [] xs+ -- Only the first part is qualified.+ worker ms (HolePart _ h : xs) =+ (\e (r, es) -> (r, Left (e, h) : es))+ <$> maybePlaceholder+ (if isOp && parseSections == ParseSections+ then Just Middle else Nothing)+ p+ <*> worker ms xs+ worker ms (WildPart h : xs) =+ (\(r, es) -> let anon = mkBinder_ simpleHole+ !e = Right $! mkBinding h anon+ in (r, e : es))+ <$> worker ms xs+ worker ms (VarPart _ h : xs) = do+ (\ b (r, es) ->+ let !e = Right $! mkBinding h b+ in (r, e : es))+ -- Andreas, 2011-04-07 put just 'Relevant' here, is this+ -- correct?+ <$> patternBinder+ <*> worker ms xs - isHidden (HiddenArgV _) = True- isHidden _ = False+ mkBinding h b = ((,) $! DomainFree $ defaultNamedArg b) h - isInstance (InstanceArgV _) = True- isInstance _ = False+ set x arg = fmap (fmap (const x)) arg - nothidden = Arg NotHidden Relevant . unnamed <$> do- e <- p- case exprView e of- HiddenArgV _ -> pfail- InstanceArgV _ -> pfail- _ -> return e+ findExprFor ::+ [(MaybePlaceholder e, NamedArg (Ranged Int))] ->+ [(LamBinding, Ranged BoundVariablePosition)] -> Int ->+ NamedArg (MaybePlaceholder (OpApp e))+ findExprFor normalHoles binders n =+ case [ h | h@(_, m) <- normalHoles, rangedThing (namedArg m) == n ] of+ [(Placeholder p, arg)] -> set (Placeholder p) arg+ [(NoPlaceholder _ e, arg)] ->+ List1.ifNull+ (map' snd $+ List.sortBy (compare `on` fst)+ [ (varNumber (rangedThing m), b)+ | (b, m) <- binders+ , holeNumber (rangedThing m) == n+ ])+ {-then-} (set (noPlaceholder (Ordinary e)) arg) -- no variable to bind+ {-else-} $ \ bs -> set (noPlaceholder (SyntaxBindingLambda (fuseRange bs e) bs e)) arg+ _ -> __IMPOSSIBLE__ - instanceH = do- InstanceArgV e <- exprView <$> satisfy (isInstance . exprView)- return $ Arg Instance Relevant e+ noPlaceholders :: OpAppArgs0 e -> Int+ noPlaceholders = sum . map (isPlaceholder . namedArg)+ where+ isPlaceholder NoPlaceholder{} = 0+ isPlaceholder Placeholder{} = 1 - hidden = do- HiddenArgV e <- exprView <$> satisfy (isHidden . exprView)- return $ Arg Hidden Relevant e+argsP :: IsExpr e => Parser e e -> Parser e [NamedArg e]+argsP p = many (mkArg <$> p)+ where+ mkArg e = case exprView e of+ HiddenArgV e -> hide (defaultArg e)+ InstanceArgV e -> makeInstance (defaultArg e)+ _ -> defaultArg (unnamed e) -atomP :: IsExpr e => (Name -> Bool) -> ReadP e e-atomP p = do- e <- get- case exprView e of- LocalV x | not (p x) -> pfail- _ -> return e+appP :: IsExpr e => Parser e e -> Parser e [NamedArg e] -> Parser e e+appP p pa = List.foldl' app <$> p <*> pa+ where+ app e = unExprView . AppV e++atomP :: IsExpr e => (QName -> Bool) -> Parser e e+atomP p =+ doc "<atom>" $+ satNoPlaceholder $ \e ->+ case exprView e of+ LocalV x | not (p x) -> Nothing+ _ -> Just e
@@ -0,0 +1,132 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE MagicHash #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++------------------------------------------------------------------------+-- | The parser monad used by the operator parser+------------------------------------------------------------------------++{-# LANGUAGE CPP #-}++module Agda.Syntax.Concrete.Operators.Parser.Monad+ ( MemoKey(..), PrecedenceKey+ , Parser+ , parse+ , sat'+ , sat+ , doc+ , memoise+ , memoiseIfPrinting+ , grammar+ , pattern LeftPK+ , pattern RightPK+ ) where++import Data.Hashable+import GHC.Generics (Generic)+#if ! (__GLASGOW_HASKELL__ <= 908)+import GHC.Exts+#endif+import GHC.Word (Word64(..))++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty++import qualified Agda.Utils.Parser.MemoisedCPS as Parser+import Agda.Utils.Hash++-- | Memoisation keys.++data MemoKey = NodeK {-# UNPACK #-} !PrecedenceKey+ | PostLeftsK {-# UNPACK #-} !PrecedenceKey+ | PreRightsK {-# UNPACK #-} !PrecedenceKey+ | TopK+ | AppK+ | NonfixK+ deriving (Eq, Show, Generic)++data PrecedenceKey = PrecKey !Bool !PrecedenceLevel+ deriving (Eq, Show)++pattern RightPK :: PrecedenceLevel -> PrecedenceKey+pattern RightPK l = PrecKey False l++pattern LeftPK :: PrecedenceLevel -> PrecedenceKey+pattern LeftPK l = PrecKey True l++#if __GLASGOW_HASKELL__ <= 908+doubleToWord64 :: Double -> Word64+doubleToWord64 x = fromIntegral $ hash x+#else+doubleToWord64 :: Double -> Word64+doubleToWord64 (D# x) = W64# (castDoubleToWord64# x)+#endif++instance Hashable PrecedenceKey where+ hashWithSalt h (PrecKey b l) = fromIntegral $+ fromIntegral (h + fromEnum b) `combineWord` fromIntegral (doubleToWord64 l)++instance Hashable MemoKey where+ hashWithSalt h = \case+ NodeK pk -> hashWithSalt (h + 1) pk+ PostLeftsK pk -> hashWithSalt (h + 2) pk+ PreRightsK pk -> hashWithSalt (h + 3) pk+ TopK -> combineInt h 4+ AppK -> combineInt h 5+ NonfixK -> combineInt h 6++-- | The parser monad.+type Parser tok a =+#ifdef DEBUG_PARSING+ Parser.ParserWithGrammar+#else+ Parser.Parser+#endif+ MemoKey tok (MaybePlaceholder tok) a++-- | Runs the parser.++parse :: forall tok a. Parser tok a -> [MaybePlaceholder tok] -> [a]+parse = Parser.parse++-- | Parses a token satisfying the given predicate. The computed value+-- is returned.++sat' :: (MaybePlaceholder tok -> Maybe a) -> Parser tok a+sat' = Parser.sat'++-- | Parses a token satisfying the given predicate.++sat :: (MaybePlaceholder tok -> Bool) ->+ Parser tok (MaybePlaceholder tok)+sat = Parser.sat++-- | Uses the given document as the printed representation of the+-- given parser. The document's precedence is taken to be 'atomP'.++doc :: Doc -> Parser tok a -> Parser tok a+doc = Parser.doc++-- | Memoises the given parser.+--+-- Every memoised parser must be annotated with a /unique/ key.+-- (Parametrised parsers must use distinct keys for distinct inputs.)++memoise :: MemoKey -> Parser tok tok -> Parser tok tok+memoise = Parser.memoise++-- | Memoises the given parser, but only if printing, not if parsing.+--+-- Every memoised parser must be annotated with a /unique/ key.+-- (Parametrised parsers must use distinct keys for distinct inputs.)++memoiseIfPrinting :: MemoKey -> Parser tok tok -> Parser tok tok+memoiseIfPrinting = Parser.memoiseIfPrinting++-- | Tries to print the parser, or returns 'empty', depending on the+-- implementation. This function might not terminate.++grammar :: Parser tok a -> Doc+grammar = Parser.grammar
@@ -0,0 +1,391 @@+-- {-# OPTIONS_GHC -Wunused-imports #-} -- no, because of liftA2+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++-- | Tools for patterns in concrete syntax.++module Agda.Syntax.Concrete.Pattern where++import Control.Applicative ( liftA2 )+import Control.Monad ( (>=>) )+import Control.Monad.Identity++import Data.Monoid ( Any(..), Endo(..), Sum(..) )++import Agda.Syntax.Common+import Agda.Syntax.Concrete++import Agda.Utils.AffineHole+import Agda.Utils.Functor+import Agda.Utils.Impossible+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import Agda.Utils.List2 ( List2 )+import Agda.Utils.Maybe+import Agda.Utils.Singleton+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Tuple ( first )+++-- | Check for ellipsis @...@.++class IsEllipsis a where+ isEllipsis :: a -> Bool++-- | Is the pattern just @...@?+instance IsEllipsis Pattern where+ isEllipsis = \case+ EllipsisP{} -> True+ ParenP _ p -> isEllipsis p+ _ -> False++-- | Has the lhs an occurrence of the ellipsis @...@?++class HasEllipsis a where+ hasEllipsis :: a -> Bool++instance HasEllipsis Pattern where+ hasEllipsis p =+ case hasEllipsis' p of+ ZeroHoles _ -> False+ OneHole _ _ -> True+ ManyHoles -> True++-- | Does the lhs contain an ellipsis?+instance HasEllipsis LHS where+ hasEllipsis (LHS p _ _) = hasEllipsis p+ -- clauses that are already expanded don't have an ellipsis++-- | Check for with-pattern @| p@.++class IsWithP p where+ isWithP :: p -> Maybe p++ default isWithP :: (IsWithP q, Decoration f, f q ~ p) => p -> Maybe p+ isWithP = traverseF isWithP++instance IsWithP Pattern where+ isWithP = \case+ WithP _ p -> Just p+ ParenP _ p -> isWithP p+ _ -> Nothing++instance IsWithP p => IsWithP (Arg p) where+instance IsWithP p => IsWithP (Named n p) where+++-- * LHS manipulation (see also ''Agda.Syntax.Abstract.Pattern'')++-- | The next patterns are ...+--+-- (This view discards 'PatInfo'.)+data LHSPatternView+ = LHSAppP (List1 (NamedArg Pattern))+ -- ^ Application patterns (non-empty list).+ | LHSWithP (List1 Pattern)+ -- ^ With patterns (non-empty list).+ -- These patterns are not prefixed with 'WithP'.++-- | Construct the 'LHSPatternView' of the given list (if not empty).+--+-- Return the view and the remaining patterns.++lhsPatternView :: [NamedArg Pattern] -> Maybe (LHSPatternView, [NamedArg Pattern])+lhsPatternView [] = Nothing+lhsPatternView (p0 : ps) =+ case namedArg p0 of+ WithP _i p -> Just (LHSWithP (p :| map namedArg ps1), ps2)+ where+ (ps1, ps2) = spanJust isWithP ps+ -- If the next pattern is an application pattern, collect more of these+ _ -> Just (LHSAppP (p0 :| ps1), ps2)+ where+ (ps1, ps2) = span (isNothing . isWithP) ps++-- | Add applicative patterns (non-projection / non-with patterns) to the right.+lhsCoreApp :: LHSCore -> List1 (NamedArg Pattern) -> LHSCore+lhsCoreApp (LHSEllipsis r core) ps = LHSEllipsis r $ lhsCoreApp core ps+lhsCoreApp core ps = core { lhsPats = lhsPats core ++ List1.toList ps }++-- | Add with-patterns to the right.+lhsCoreWith :: LHSCore -> List1 Pattern -> LHSCore+lhsCoreWith (LHSWith core wps []) wps' = LHSWith core (wps <> wps') []+lhsCoreWith core wps' = LHSWith core wps' []++-- | Append patterns to 'LHSCore', separating with patterns from the rest.+lhsCoreAddSpine :: LHSCore -> [NamedArg Pattern] -> LHSCore+lhsCoreAddSpine core ps0 =+ -- Recurse on lhsPatternView until no patterns left.+ case lhsPatternView ps0 of+ Nothing -> core+ Just (LHSAppP ps , ps') -> lhsCoreApp core ps `lhsCoreAddSpine` ps'+ Just (LHSWithP wps, ps') -> lhsCoreWith core wps `lhsCoreAddSpine` ps'+++-- | Modify the 'Pattern' component in 'LHS'.+mapLhsOriginalPattern :: (Pattern -> Pattern) -> LHS -> LHS+mapLhsOriginalPattern f lhs@LHS{ lhsOriginalPattern = p } =+ lhs { lhsOriginalPattern = f p }++-- | Effectfully modify the 'Pattern' component in 'LHS'.+mapLhsOriginalPatternM :: (Functor m) => (Pattern -> m Pattern) -> LHS -> m LHS+mapLhsOriginalPatternM f lhs@LHS{ lhsOriginalPattern = p } = f p <&> \ p' ->+ lhs { lhsOriginalPattern = p' }++-- | Does the LHS contain projection patterns?+hasCopatterns :: LHSCore -> Bool+hasCopatterns = \case+ LHSHead{} -> False+ LHSProj{} -> True+ LHSWith h _ _ -> hasCopatterns h+ LHSEllipsis{} -> False++-- * Generic fold++-- | Generic pattern traversal.+--+-- See 'Agda.Syntax.Abstract.Pattern.APatternLike'.++class CPatternLike p where++ -- | Fold pattern.+ foldrCPattern+ :: Monoid m+ => (Pattern -> m -> m)+ -- ^ Combine a pattern and the value computed from its subpatterns.+ -> p -> m++ default foldrCPattern+ :: (Monoid m, Foldable f, CPatternLike q, f q ~ p)+ => (Pattern -> m -> m) -> p -> m+ foldrCPattern = foldMap . foldrCPattern++ -- | Traverse pattern with option of post-traversal modification.+ traverseCPatternA :: (Applicative m)+ => (Pattern -> m Pattern -> m Pattern)+ -- ^ Combine a pattern and the its recursively computed version.+ -> p -> m p++ default traverseCPatternA :: (Traversable f, CPatternLike q, f q ~ p, Applicative m)+ => (Pattern -> m Pattern -> m Pattern)+ -> p -> m p+ traverseCPatternA = traverse . traverseCPatternA++ -- | Traverse pattern.+ traverseCPatternM :: Monad m+ => (Pattern -> m Pattern) -- ^ @pre@: Modification before recursion.+ -> (Pattern -> m Pattern) -- ^ @post@: Modification after recursion.+ -> p -> m p++ default traverseCPatternM+ :: (Traversable f, CPatternLike q, f q ~ p, Monad m)+ => (Pattern -> m Pattern)+ -> (Pattern -> m Pattern)+ -> p -> m p+ traverseCPatternM pre post = traverse $ traverseCPatternM pre post++instance CPatternLike Pattern where+ foldrCPattern f p0 = f p0 $+ case p0 of+ -- Recursive cases:+ AppP p ps -> foldrCPattern f (p, ps)+ RawAppP _ ps -> foldrCPattern f ps+ OpAppP _ _ _ ps -> foldrCPattern f ps+ HiddenP _ ps -> foldrCPattern f ps+ InstanceP _ ps -> foldrCPattern f ps+ ParenP _ p -> foldrCPattern f p+ AsP _ _ p -> foldrCPattern f p+ WithP _ p -> foldrCPattern f p+ RecP _ _ ps -> foldrCPattern f ps+ EllipsisP _ mp -> foldrCPattern f mp+ -- Nonrecursive cases:+ IdentP _ _ -> mempty+ WildP _ -> mempty+ DotP _ _ _ _ -> mempty+ AbsurdP _ -> mempty+ LitP _ _ -> mempty+ QuoteP _ -> mempty+ EqualP _ _ -> mempty++ traverseCPatternA f p0 = f p0 $ case p0 of+ -- Recursive cases:+ AppP p ps -> liftA2 AppP (traverseCPatternA f p) (traverseCPatternA f ps)+ RawAppP r ps -> RawAppP r <$> traverseCPatternA f ps+ OpAppP r x xs ps -> OpAppP r x xs <$> traverseCPatternA f ps+ HiddenP r p -> HiddenP r <$> traverseCPatternA f p+ InstanceP r p -> InstanceP r <$> traverseCPatternA f p+ ParenP r p -> ParenP r <$> traverseCPatternA f p+ AsP r x p -> AsP r x <$> traverseCPatternA f p+ WithP r p -> WithP r <$> traverseCPatternA f p+ RecP kwr r ps -> RecP kwr r <$> traverseCPatternA f ps+ EllipsisP r mp -> EllipsisP r <$> traverseCPatternA f mp+ -- Nonrecursive cases:+ IdentP _ _ -> pure p0+ WildP _ -> pure p0+ DotP _ _ _ _ -> pure p0+ AbsurdP _ -> pure p0+ LitP _ _ -> pure p0+ QuoteP _ -> pure p0+ EqualP _ _ -> pure p0++ traverseCPatternM pre post = pre >=> recurse >=> post+ where+ recurse p0 = case p0 of+ -- Recursive cases:+ AppP p ps -> uncurry AppP <$> traverseCPatternM pre post (p, ps)+ RawAppP r ps -> RawAppP r <$> traverseCPatternM pre post ps+ OpAppP r x xs ps -> OpAppP r x xs <$> traverseCPatternM pre post ps+ HiddenP r p -> HiddenP r <$> traverseCPatternM pre post p+ InstanceP r p -> InstanceP r <$> traverseCPatternM pre post p+ ParenP r p -> ParenP r <$> traverseCPatternM pre post p+ AsP r x p -> AsP r x <$> traverseCPatternM pre post p+ WithP r p -> WithP r <$> traverseCPatternM pre post p+ RecP kwr r ps -> RecP kwr r <$> traverseCPatternM pre post ps+ EllipsisP r mp -> EllipsisP r <$> traverseCPatternM pre post mp+ -- Nonrecursive cases:+ IdentP _ _ -> return p0+ WildP _ -> return p0+ DotP _ _ _ _ -> return p0+ AbsurdP _ -> return p0+ LitP _ _ -> return p0+ QuoteP _ -> return p0+ EqualP _ _ -> return p0++instance (CPatternLike a, CPatternLike b) => CPatternLike (a,b) where+ foldrCPattern f (p, p') =+ foldrCPattern f p `mappend` foldrCPattern f p'++ traverseCPatternA f (p, p') =+ liftA2 (,)+ (traverseCPatternA f p)+ (traverseCPatternA f p')++ traverseCPatternM pre post (p, p') =+ liftA2 (,)+ (traverseCPatternM pre post p)+ (traverseCPatternM pre post p')++instance CPatternLike p => CPatternLike (Arg p)+instance CPatternLike p => CPatternLike (Named n p)+instance CPatternLike p => CPatternLike [p]+instance CPatternLike p => CPatternLike (List1 p)+instance CPatternLike p => CPatternLike (List2 p)+instance CPatternLike p => CPatternLike (Maybe p)+instance CPatternLike p => CPatternLike (FieldAssignment' p)++-- | Compute a value from each subpattern and collect all values in a monoid.++foldCPattern :: (CPatternLike p, Monoid m) => (Pattern -> m) -> p -> m+foldCPattern f = foldrCPattern $ \ p m -> f p `mappend` m++-- | Traverse pattern(s) with a modification before the recursive descent.++preTraverseCPatternM+ :: (CPatternLike p, Monad m)+ => (Pattern -> m Pattern) -- ^ @pre@: Modification before recursion.+ -> p -> m p+preTraverseCPatternM pre p = traverseCPatternM pre return p++-- | Traverse pattern(s) with a modification after the recursive descent.++postTraverseCPatternM+ :: (CPatternLike p, Monad m)+ => (Pattern -> m Pattern) -- ^ @post@: Modification after recursion.+ -> p -> m p+postTraverseCPatternM post p = traverseCPatternM return post p++-- | Map pattern(s) with a modification after the recursive descent.++mapCPattern :: CPatternLike p => (Pattern -> Pattern) -> p -> p+mapCPattern f = runIdentity . postTraverseCPatternM (Identity . f)+++-- * Specific folds.++-- | Get all the identifiers in a pattern in left-to-right order.+--+-- Implemented using difference lists.+patternQNames :: CPatternLike p => p -> [QName]+patternQNames p = foldCPattern f p `appEndo` []+ where+ f :: Pattern -> Endo [QName]+ f = \case+ IdentP _ x -> Endo (x :)+ OpAppP _ x _ _ -> Endo (x :)+ AsP _ _x _ -> mempty -- _x must be a bound name, can't be a constructor!+ AppP _ _ -> mempty+ WithP _ _ -> mempty+ RawAppP _ _ -> mempty+ HiddenP _ _ -> mempty+ ParenP _ _ -> mempty+ WildP _ -> mempty+ AbsurdP _ -> mempty+ DotP _ _ _ _ -> mempty+ LitP _ _ -> mempty+ QuoteP _ -> mempty+ InstanceP _ _ -> mempty+ RecP _ _ _ -> mempty+ EqualP _ _ -> mempty+ EllipsisP _ _ -> mempty++-- | Get all the identifiers in a pattern in left-to-right order.+patternNames :: Pattern -> [Name]+patternNames = map unqualify . patternQNames++-- | Does the pattern contain a with-pattern?+-- (Shortcutting.)+hasWithPatterns :: CPatternLike p => p -> Bool+hasWithPatterns = getAny . foldCPattern (Any . isWithPattern)++-- | Is 'WithP'?+isWithPattern :: Pattern -> Bool+isWithPattern = \case+ WithP{} -> True+ _ -> False++-- | Count the number of with-subpatterns in a pattern?+numberOfWithPatterns :: CPatternLike p => p -> Int+numberOfWithPatterns = getSum . foldCPattern (Sum . f)+ where f p = if isWithPattern p then 1 else 0++-- | Compute the context in which the ellipsis occurs, if at all.+-- If there are several occurrences, this is an error.+-- This only counts ellipsis that haven't already been expanded.+hasEllipsis' :: CPatternLike p => p -> AffineHole Pattern p+hasEllipsis' = traverseCPatternA $ \ p mp ->+ case p of+ EllipsisP _ Nothing -> OneHole id p+ _ -> mp++-- | Reconstruct the ellipsis, used in printing (AbstractToConcrete).+reintroduceEllipsis :: ExpandedEllipsis -> Pattern -> Pattern+reintroduceEllipsis (ExpandedEllipsis r k) p | hasWithPatterns p =+ let (args, wargs) = splitEllipsis k $ List1.toList $ patternAppView p+ (hd,args') = fromMaybe __IMPOSSIBLE__ $ uncons args+ core = foldl AppP (namedArg hd) args'+ in foldl AppP (EllipsisP r $ Just $ core) wargs+reintroduceEllipsis _ p = p++splitEllipsis :: (IsWithP p) => Int -> [p] -> ([p],[p])+splitEllipsis _ [] = ([] , [])+splitEllipsis k (p:ps)+ | isJust (isWithP p) = if+ | k == 0 -> ([] , p:ps)+ | otherwise -> first (p:) $ splitEllipsis (k-1) ps+ | otherwise = first (p:) $ splitEllipsis k ps++---------------------------------------------------------------------------+-- * Helpers for pattern and lhs parsing+---------------------------------------------------------------------------++-- | View a pattern @p@ as a list @p0 .. pn@ where @p0@ is the identifier+-- (in most cases a constructor).+--+-- Pattern needs to be parsed already (operators resolved).+patternAppView :: Pattern -> List1 (NamedArg Pattern)+patternAppView = \case+ AppP p arg -> patternAppView p `List1.appendList` [arg]+ OpAppP _ x _ ps -> defaultNamedArg (IdentP True x) <| ps+ ParenP _ p -> patternAppView p+ RawAppP _ _ -> __IMPOSSIBLE__+ p -> singleton $ defaultNamedArg p
@@ -1,467 +1,669 @@-{-# LANGUAGE CPP, FlexibleInstances #-}-{-# OPTIONS -fno-warn-orphans #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-} +{-# OPTIONS_GHC -Wno-orphans #-}+ {-| Pretty printer for the concrete syntax. -}-module Agda.Syntax.Concrete.Pretty where+module Agda.Syntax.Concrete.Pretty+ ( module Agda.Syntax.Concrete.Pretty+ , module Agda.Syntax.Concrete.Glyph+ ) where -import Data.Char+import Prelude hiding ( null ) +import Data.Maybe+import qualified Data.Foldable as Fold+import qualified Data.Strict.Maybe as Strict+ import Agda.Syntax.Common import Agda.Syntax.Concrete-import Agda.Syntax.Fixity-import Agda.Syntax.Literal+import Agda.Syntax.Concrete.Glyph -import Agda.Utils.Pretty-import Agda.Utils.String+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.List1 ( List1, (<|) )+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2+import Agda.Utils.Maybe+import Agda.Utils.Null+import qualified Agda.Syntax.Common.Aspect as Asp+import Agda.Syntax.Common.Pretty+import Agda.Interaction.Options ( HasOptions(pragmaOptions), optPolarity ) -#include "../../undefined.h" import Agda.Utils.Impossible -instance Show Expr where show = show . pretty-instance Show Declaration where show = show . pretty-instance Show Pattern where show = show . pretty-instance Show TypedBindings where show = show . pretty-instance Show LamBinding where show = show . pretty-instance Show ImportDirective where show = show . pretty-instance Show Pragma where show = show . pretty-instance Show RHS where show = show . pretty+deriving instance Show Expr+deriving instance (Show a) => Show (OpApp a)+deriving instance Show Declaration+deriving instance Show Pattern+deriving instance Show a => Show (Binder' a)+deriving instance Show TypedBinding+deriving instance Show LamBinding+deriving instance Show BoundName+deriving instance Show ModuleAssignment+deriving instance Show Pragma+deriving instance Show RHS+deriving instance Show LHS+deriving instance Show LHSCore+deriving instance Show LamClause+deriving instance Show WhereClause+deriving instance Show ModuleApplication+deriving instance Show DoStmt+deriving instance Show Module -braces' d = case render d of- -- Add space to avoid starting a comment- '-':_ -> braces (text " " <> d)- _ -> braces d+-- Lays out a list of documents [d₁, d₂, …] in the following way:+-- @+-- { d₁+-- ; d₂+-- ⋮+-- }+-- @+-- If the list is empty, then the notation @{}@ is used. --- double braces...-dbraces :: Doc -> Doc-dbraces = braces . braces'+bracesAndSemicolons :: Foldable t => t Doc -> Doc+bracesAndSemicolons ts = case Fold.toList ts of+ [] -> "{}"+ (d : ds) -> sep (["{" <+> d] ++ map (";" <+>) ds ++ ["}"]) -arrow = text "\x2192"-lambda = text "\x03bb"-underscore = text "_"+prettyTactic :: BoundName -> Doc -> Doc+prettyTactic = prettyTactic' . bnameTactic -pHidden :: Pretty a => Hiding -> a -> Doc-pHidden Hidden = braces' . pretty-pHidden Instance = dbraces . pretty-pHidden NotHidden = pretty+prettyFiniteness :: BoundName -> Doc -> Doc+prettyFiniteness name+ | bnameIsFinite name = ("@finite" <+>)+ | otherwise = id -pRelevance :: Pretty a => Relevance -> a -> Doc-pRelevance Forced a = pretty a-pRelevance Relevant a = pretty a-pRelevance Irrelevant a =- let d = pretty a- in if render d == "_" then d else text "." <> d-pRelevance NonStrict a =- let d = pretty a- in if render d == "_" then d else text ".." <> d+prettyTactic' :: TacticAttribute -> Doc -> Doc+prettyTactic' t = (pretty t <+>) -{- UNUSED--- | Use for printing non-dependent function types-prettyWithRelevance :: Pretty a => Arg a -> Doc-prettyWithRelevance a = pRelevance (argRelevance a) a--}+qualifier :: Pretty a => Maybe a -> Doc -> Doc+qualifier (Just x) k = pretty x <> dot <> k+qualifier Nothing k = k +instance Pretty a => Pretty (TacticAttribute' a) where+ pretty (TacticAttribute t) =+ ifNull (pretty t) empty \ d -> "@" <> parens (hlKeyword "tactic" <+> d)+ instance Pretty (ThingWithFixity Name) where pretty (ThingWithFixity n _) = pretty n -instance Pretty Name where- pretty = text . show--instance Pretty QName where- pretty = text . show--instance Pretty Literal where- pretty (LitInt _ n) = text $ show n- pretty (LitFloat _ x) = text $ show x- pretty (LitString _ s) = text $ showString' s ""- pretty (LitChar _ c) = text $ "'" ++ showChar' c "" ++ "'"- pretty (LitQName _ x) = text $ show x--showString' :: String -> ShowS-showString' s =- foldr (.) id $ [ showString "\"" ] ++ map showChar' s ++ [ showString "\"" ]--showChar' :: Char -> ShowS-showChar' '"' = showString "\\\""-showChar' c- | escapeMe c = showLitChar c- | otherwise = showString [c]- where- escapeMe c = not (isPrint c) || c == '\\'--instance Pretty Relevance where- pretty Forced = empty- pretty Relevant = empty- pretty Irrelevant = text "."- pretty NonStrict = text ".."--instance Pretty Induction where- pretty Inductive = text "data"- pretty CoInductive = text "codata"+-- | Show the attributes necessary to recover a modality, in long-form+-- (e.g. using at-syntax rather than dots). For the default modality,+-- the result is at-ω (rather than the empty document). Suitable for+-- showing modalities outside of binders.+attributesForModality :: HasOptions m => Modality -> m Doc+attributesForModality mod@(Modality r q c p)+ | mod `elem` [defaultCheckModality, defaultModality] = do+ showPolarity <- optPolarity <$> pragmaOptions+ pure $ text "@ω" <+> if showPolarity then polarity else empty+ | otherwise = pure $ fsep $ catMaybes [relevance, quantity, cohesion, Just polarity]+ where+ relevance = case r of+ Relevant {} -> Nothing+ Irrelevant {} -> Just "@irrelevant"+ ShapeIrrelevant {} -> Just "@shape-irrelevant"+ quantity = case q of+ Quantity0{} -> Just "@0"+ Quantity1{} -> Just "@1"+ Quantityω{} -> Nothing+ cohesion = case c of+ Flat{} -> Just "@♭"+ Continuous{} -> Nothing+ Sharp{} -> Just "@♯"+ Squash{} -> Just "@⊤"+ polarity = case modPolarityAnn p of+ MixedPolarity -> "@mixed"+ Positive -> "@+"+ Negative -> "@-"+ StrictlyPositive -> "@++"+ UnusedPolarity -> "@unused" instance Pretty (OpApp Expr) where pretty (Ordinary e) = pretty e pretty (SyntaxBindingLambda r bs e) = pretty (Lam r bs e) +instance Pretty a => Pretty (MaybePlaceholder a) where+ pretty Placeholder{} = "_"+ pretty (NoPlaceholder _ e) = pretty e+ instance Pretty Expr where- pretty e =- case e of- Ident x -> pretty x- Lit l -> pretty l- QuestionMark _ n -> text "?" <> maybe empty (text . show) n- Underscore _ n -> underscore <> maybe empty (text . show) n- App _ _ _ ->- case appView e of- AppView e1 args ->- fsep $ pretty e1 : map pretty args--- sep [ pretty e1--- , nest 2 $ fsep $ map pretty args--- ]- RawApp _ es -> fsep $ map pretty es- OpApp _ (Name _ xs) es -> fsep $ prOp xs es- where- prOp (Hole : xs) (e : es) = pretty e : prOp xs es- prOp (Hole : _) [] = __IMPOSSIBLE__- prOp (Id x : xs) es = text x : prOp xs es- prOp [] es = map pretty es- OpApp _ (NoName _ _) _ -> __IMPOSSIBLE__+ pretty = \case+ Ident x -> pretty x+ KnownIdent nk x -> annotate nk (pretty x)+ Lit _ l -> pretty l+ QuestionMark _ n -> hlSymbol "?" <> maybe empty (text . show) n+ Underscore _ n -> maybe underscore text n+ e@(App _ _ _) ->+ case appView e of+ AppView e1 args ->+ fsep $ pretty e1 : map pretty args+-- sep [ pretty e1+-- , nest 2 $ fsep $ map pretty args+-- ]+ RawApp _ es -> fsep $ map pretty $ List2.toList es+ OpApp _ q _ es -> fsep $ prettyOpApp empty q es+ KnownOpApp nk _ q _ es -> fsep $ prettyOpApp nk q es - WithApp _ e es -> fsep $- pretty e : map ((text "|" <+>) . pretty) es+ WithApp _ e es -> fsep $+ pretty e <| fmap ((hlSymbol "|" <+>) . pretty) es - HiddenArg _ e -> braces' $ pretty e- InstanceArg _ e -> dbraces $ pretty e- Lam _ bs e ->- sep [ lambda <+> fsep (map pretty bs) <+> arrow- , nest 2 $ pretty e- ]- AbsurdLam _ NotHidden -> lambda <+> text "()"- AbsurdLam _ Instance -> lambda <+> text "{{}}"- AbsurdLam _ Hidden -> lambda <+> text "{}"- ExtendedLam _ pes ->- lambda <+> braces (fsep $ punctuate (text ";") (map (\(x,y,z) -> prettyClause x y z) pes))- where prettyClause lhs rhs wh = sep [ pretty lhs- , nest 2 $ pretty' rhs- ] $$ nest 2 (pretty wh)- pretty' (RHS e) = arrow <+> pretty e- pretty' AbsurdRHS = empty- Fun _ e1 e2 ->- sep [ pretty e1 <+> arrow- , pretty e2- ]- Pi tel e ->- sep [ fsep (map pretty (smashTel tel) ++ [arrow])- , pretty e- ]- Set _ -> text "Set"- Prop _ -> text "Prop"- SetN _ n -> text "Set" <> text (showIndex n)- Let _ ds e ->- sep [ text "let" <+> vcat (map pretty ds)- , text "in" <+> pretty e- ]- Paren _ e -> parens $ pretty e- As _ x e -> pretty x <> text "@" <> pretty e- Dot _ e -> text "." <> pretty e- Absurd _ -> text "()"- Rec _ xs -> sep (- [ text "record {" ] ++- punctuate (text ";") (map recPr xs)) <+> text "}"- RecUpdate _ e xs ->- sep [ text "record" <+> pretty e <+> text "{" ]- <+> sep (punctuate (text ";") (map recPr xs))- <+> text "}"- ETel [] -> text "()"- ETel tel -> fsep $ map pretty tel- QuoteGoal _ x e -> sep [text "quoteGoal" <+> pretty x <+> text "in",- nest 2 $ pretty e]- Quote _ -> text "quote"- QuoteTerm _ -> text "quoteTerm"- Unquote _ -> text "unquote"+ HiddenArg _ e -> braces' $ pretty e+ InstanceArg _ e -> dbraces $ pretty e+ Lam _ bs (AbsurdLam _ h) -> lambda <+> fsep (fmap pretty bs) <+> absurd h+ Lam _ bs e ->+ sep [ lambda <+> fsep (fmap pretty bs) <+> arrow+ , nest 2 $ pretty e+ ]+ AbsurdLam _ h -> lambda <+> absurd h+ ExtendedLam _ e pes ->+ lambda <+>+ prettyErased e (bracesAndSemicolons (fmap pretty pes))+ Fun _ e1 e2 ->+ sep [ pretty (getModality e1) <+> pretty e1 <+> arrow+ , pretty e2+ ]+ Pi tel e ->+ sep [ pretty (Tel $ smashTel $ List1.toList tel) <+> arrow+ , pretty e+ ]+ Let _ ds me ->+ sep [ hlKeyword "let" <+> vcat (fmap pretty ds)+ , maybe empty (\ e -> hlKeyword "in" <+> pretty e) me+ ]+ Paren _ e -> parens $ pretty e+ IdiomBrackets _ q es -> qualifier q case es of+ [] -> emptyIdiomBrkt+ [e] -> leftIdiomBrkt <+> pretty e <+> rightIdiomBrkt+ e:es -> leftIdiomBrkt <+> pretty e <+> fsep (map (("|" <+>) . pretty) es) <+> rightIdiomBrkt+ DoBlock _ q ss -> qualifier q $ hlKeyword "do" <+> vcat (fmap pretty ss)+ As _ x e -> pretty x <> hlSymbol "@" <> pretty e+ Dot _ e -> hlSymbol "." <> pretty e+ DoubleDot _ e -> hlSymbol ".." <> pretty e+ Absurd _ -> hlSymbol "()"+ Rec _ _ xs ->+ sep [hlKeyword "record", bracesAndSemicolons (map pretty xs)]+ RecUpdate _ _ e xs ->+ sep [hlKeyword "record" <+> pretty e, bracesAndSemicolons (map pretty xs)]+ Quote _ -> hlKeyword "quote"+ QuoteTerm _ -> hlKeyword "quoteTerm"+ Unquote _ -> hlKeyword "unquote"+ Tactic _ t -> hlKeyword "tactic" <+> pretty t -- Andreas, 2011-10-03 print irrelevant things as .(e)- DontCare e -> text "." <> parens (pretty e)- where- recPr (x, e) = sep [ pretty x <+> text "=" , nest 2 $ pretty e ]+ DontCare e -> hlSymbol "." <> parens (pretty e)+ Equal _ a b -> pretty a <+> equals <+> pretty b+ Ellipsis _ -> hlSymbol "..."+ Generalized e -> pretty e+ Highlighted a e -> annotate a (pretty e)+ where+ absurd NotHidden = parens mempty+ absurd Instance{} = dbraces mempty+ absurd Hidden = braces mempty +instance (Pretty a, Pretty b) => Pretty (Either a b) where+ pretty = either pretty pretty++instance Pretty a => Pretty (FieldAssignment' a) where+ pretty (FieldAssignment x e) = sep [ pretty x <+> equals, nest 2 $ pretty e ]++instance Pretty ModuleAssignment where+ pretty (ModuleAssignment m es i) = fsep (pretty m : map pretty es) <+> pretty i++instance Pretty LamClause where+ pretty (LamClause ps rhs _) =+ sep [ fsep (map pretty ps)+ , nest 2 $ pretty' rhs+ ]+ where+ pretty' (RHS e) = arrow <+> pretty e+ pretty' AbsurdRHS = empty++-- Andreas, 2024-02-25+-- Q: Can we always ignore the tactic and the finiteness here? instance Pretty BoundName where- pretty = pretty . boundName+ pretty (BName x _fix _tac _fin) = pretty x -instance Pretty LamBinding where- pretty (DomainFree h r x) = pRelevance r $ pHidden h $ pretty x- pretty (DomainFull b) = pretty b+data NamedBinding = NamedBinding+ { withHiding :: Bool+ , namedBinding :: NamedArg Binder+ } -instance Pretty TypedBindings where- pretty (TypedBindings _ (Arg h rel b)) =- pRelevance rel $ bracks $ pretty b- where- bracks = case h of- Hidden -> braces'- Instance -> dbraces- NotHidden -> parens+isLabeled :: NamedArg Binder -> Maybe ArgName+isLabeled x+ | visible x = Nothing -- Ignore labels on visible arguments+ | Just l <- bareNameOf x = boolToMaybe (l /= nameToRawName (boundName $ binderName $ namedArg x)) l+ | otherwise = Nothing +instance Pretty a => Pretty (Binder' a) where+ pretty (Binder mpat UserBinderName n) =+ applyWhenJust mpat (\ pat -> (<+> ("@" <+> parens (pretty pat)))) $ pretty n + pretty (Binder pat InsertedBinderName n) = case pat of+ Just pat -> parens (pretty pat)+ Nothing -> pretty n++instance Pretty NamedBinding where+ pretty (NamedBinding withH+ x@(Arg (ArgInfo h (Modality r q c p) _o _fv (Annotation lock rew))+ (Named _mn xb@(Binder _mp _ (BName _y _fix t _fin))))) =+ applyWhen withH prH $+ applyWhenJust (isLabeled x) (\ l -> (text l <+>) . (equals <+>)) (pretty xb)+ -- isLabeled looks at _mn and _y+ -- pretty xb prints also the pattern _mp+ where+ prH = prettyRelevance r+ . prettyHiding h mparens+ . (coh <+>)+ . (qnt <+>)+ . (pol <+>)+ . (lck <+>)+ . (tac <+>)+ . (rw <+>)+ coh = pretty c+ qnt = pretty q+ pol = pretty p+ tac = pretty t+ lck = pretty lock+ rw = pretty rew+ -- Parentheses are needed when an attribute @... is printed+ mparens = applyUnless (null coh && null qnt && null lck && null tac && null pol) parens++instance Pretty LamBinding where+ pretty (DomainFree x) = pretty (NamedBinding True x)+ pretty (DomainFull b) = pretty b+ instance Pretty TypedBinding where- pretty (TNoBind e) = pretty e- pretty (TBind _ xs e) =- sep [ fsep (map pretty xs)- , text ":" <+> pretty e- ]+ pretty (TLet _ ds) = parens $ hlKeyword "let" <+> vcat (fmap pretty ds)+ pretty (TBind _ xs (Underscore _ Nothing)) =+ fsep (fmap (pretty . NamedBinding True) xs)+ pretty (TBind _ xs e) = fsep+ [ prettyRelevance y+ $ prettyHiding y parens+ $ prettyFiniteness (binderName $ namedArg y)+ $ prettyCohesion y+ $ prettyQuantity y+ $ prettyLock y+ $ prettyPolarity y+ $ prettyTactic (binderName $ namedArg y)+ $ prettyRewriteAnn y $+ sep [ fsep (map (pretty . NamedBinding False) ys)+ , colon <+> pretty e ]+ | ys@(y : _) <- groupBinds $ List1.toList xs ]+ where+ groupBinds [] = []+ groupBinds (x : xs)+ | Just{} <- isLabeled x = [x] : groupBinds xs+ | otherwise = (x : ys) : groupBinds zs+ where (ys, zs) = span (same x) xs+ same x y = getArgInfo x == getArgInfo y && isNothing (isLabeled y) +newtype Tel = Tel Telescope++instance Pretty Tel where+ pretty (Tel tel)+ | any isMeta tel = forallQ <+> fsep (map pretty tel)+ | otherwise = fsep (map pretty tel)+ where+ isMeta (TBind _ _ (Underscore _ Nothing)) = True+ isMeta _ = False+ smashTel :: Telescope -> Telescope-smashTel (TypedBindings r (Arg h rel (TBind r' xs e)) :- TypedBindings _ (Arg h' rel' (TBind _ ys e')) : tel)- | h == h' && rel == rel' && show e == show e' =- smashTel (TypedBindings r (Arg h rel (TBind r' (xs ++ ys) e)) : tel)+smashTel (TBind r xs e :+ TBind _ ys e' : tel)+ | prettyShow e == prettyShow e' = smashTel (TBind r (xs <> ys) e : tel) smashTel (b : tel) = b : smashTel tel smashTel [] = [] instance Pretty RHS where- pretty (RHS e) = text "=" <+> pretty e+ pretty (RHS e) = equals <+> pretty e pretty AbsurdRHS = empty -instance Show WhereClause where show = show . pretty instance Pretty WhereClause where pretty NoWhere = empty- pretty (AnyWhere [Module _ x [] ds]) | isNoName (unqualify x)- = vcat [ text "where", nest 2 (vcat $ map pretty ds) ]- pretty (AnyWhere ds) = vcat [ text "where", nest 2 (vcat $ map pretty ds) ]- pretty (SomeWhere m ds) =- vcat [ hsep [ text "module", pretty m, text "where" ]- , nest 2 (vcat $ map pretty ds)- ]+ pretty (AnyWhere _ [Module _ NotErased{} x [] ds])+ | isNoName (unqualify x)+ = vcat [ hlKeyword "where", nest 2 (vcat $ map pretty ds) ]+ pretty (AnyWhere _ ds) = vcat [ hlKeyword "where", nest 2 (vcat $ map pretty ds) ]+ pretty (SomeWhere _ erased m a ds) =+ vcat [ hsep $ privateWhenUserWritten a+ [ hlKeyword "module", prettyErased erased (pretty m), hlKeyword "where" ]+ , nest 2 (vcat $ map pretty ds)+ ]+ where+ privateWhenUserWritten = \case+ PrivateAccess _ UserWritten -> (hlKeyword "private" :)+ _ -> id -instance Show LHS where show = show . pretty instance Pretty LHS where- pretty lhs = case lhs of- LHS p ps eqs es -> pr (pretty p) ps eqs es- Ellipsis _ ps eqs es -> pr (text "...") ps eqs es- where- pr d ps eqs es =- sep [ d- , nest 2 $ fsep $ map ((text "|" <+>) . pretty) ps- , nest 2 $ pThing "rewrite" eqs- , nest 2 $ pThing "with" es- ]- pThing thing [] = empty- pThing thing (e : es) = fsep $ (text thing <+> pretty e)- : map ((text "|" <+>) . pretty) es+ pretty (LHS p eqs es) = sep+ [ pretty p+ , nest 2 $ if null eqs then empty else fsep $ map pretty eqs+ , nest 2 $ prefixedThings (hlKeyword "with") (map prettyWithd es)+ ] where -instance Pretty [Declaration] where- pretty = vcat . map pretty+ prettyWithd :: WithExpr -> Doc+ prettyWithd (Named nm wh) =+ let e = pretty wh in+ case nm of+ Nothing -> e+ Just n -> pretty n <+> colon <+> e -instance Show ModuleApplication where show = show . pretty+instance Pretty LHSCore where+ pretty (LHSHead f ps) = sep $ pretty f : map (parens . pretty) ps+ pretty (LHSProj d ps lhscore ps') = sep $+ pretty d : map (parens . pretty) ps +++ parens (pretty lhscore) : map (parens . pretty) ps'+ pretty (LHSWith h wps ps) = if null ps then doc else+ sep $ parens doc : map (parens . pretty) ps+ where+ doc = sep $ pretty h <$ fmap ((pipe <+>) . pretty) wps+ pretty (LHSEllipsis _ _) = "..."+ instance Pretty ModuleApplication where- pretty (SectionApp _ bs e) = fsep (map pretty bs) <+> text "=" <+> pretty e- pretty (RecordModuleIFS _ rec) = text "=" <+> pretty rec <+> text "{{...}}"+ pretty (SectionApp _ bs x es) = fsep $ concat+ [ map pretty bs+ , [ equals, pretty x ]+ , map pretty es+ ]+ pretty (RecordModuleInstance _ x) = equals <+> pretty x <+> "{{...}}" +instance Pretty DoStmt where+ pretty (DoBind _ p e cs) =+ ((pretty p <+> fromArrow) <?> pretty e) <?> prCs cs+ where+ prCs [] = empty+ prCs cs = hlKeyword "where" <?> vcat (map pretty cs)+ pretty (DoThen e) = pretty e+ pretty (DoLet _ ds) = hlKeyword "let" <+> vcat (fmap pretty ds)+ instance Pretty Declaration where- pretty d =- case d of- TypeSig rel x e ->- sep [ pRelevance rel $ pretty x <+> text ":"- , nest 2 $ pretty e- ]- Field x (Arg h rel e) ->- sep [ text "field"- , nest 2 $ pRelevance rel $ pHidden h (TypeSig Relevant x e)- ]- FunClause lhs rhs wh ->- sep [ pretty lhs- , nest 2 $ pretty rhs- ] $$ nest 2 (pretty wh)- DataSig _ ind x tel e ->- sep [ hsep [ pretty ind- , pretty x- , fcat (map pretty tel)- ]- , nest 2 $ hsep- [ text ":"- , pretty e- ]- ]- Data _ ind x tel (Just e) cs ->- sep [ hsep [ pretty ind- , pretty x- , fcat (map pretty tel)- ]- , nest 2 $ hsep- [ text ":"- , pretty e- , text "where"- ]- ] $$ nest 2 (vcat $ map pretty cs)- Data _ ind x tel Nothing cs ->- sep [ hsep [ pretty ind- , pretty x- , fcat (map pretty tel)- ]- , nest 2 $ text "where"- ] $$ nest 2 (vcat $ map pretty cs)- RecordSig _ x tel e ->- sep [ hsep [ text "record"- , pretty x- , fcat (map pretty tel)- ]- , nest 2 $ hsep- [ text ":"- , pretty e- ]- ]- Record _ x con tel (Just e) cs ->- sep [ hsep [ text "record"- , pretty x- , fcat (map pretty tel)- ]- , nest 2 $ hsep- [ text ":"- , pretty e- , text "where"- ]- ] $$ nest 2 (vcat $ maybe [] (\c -> [text "constructor" <+> pretty c])- con ++- map pretty cs)- Record _ x con tel Nothing cs ->- sep [ hsep [ text "record"- , pretty x- , fcat (map pretty tel)- ]- , nest 2 $ text "where"- ] $$ nest 2 (vcat $ maybe [] (\c -> [text "constructor" <+> pretty c])- con ++- map pretty cs)+ prettyList = vcat . map pretty+ pretty = \case+ TypeSig i tac x e ->+ sep [ prettyTactic' tac $ prettyRelevance i $ prettyCohesion i $+ prettyQuantity i $ prettyPolarity i $ pretty x <+> colon+ , nest 2 $ pretty e+ ]+ FieldSig inst tac x (Arg i e) ->+ mkInst inst $ mkOverlap i $+ -- We print relevance before hiding, need to clear it before printing the rest of the attributes with TypeSig.+ prettyRelevance i $ prettyHiding i id $+ pretty $ TypeSig (setRelevance relevant i) tac x e+ where+ mkInst (InstanceDef _) d = sep [ hlKeyword "instance", nest 2 d ]+ mkInst NotInstanceDef d = d - Infix f xs ->- pretty f <+> (fsep $ punctuate comma $ map pretty xs)- Syntax n xs -> text "syntax" <+> pretty n <+> text "..."- Mutual _ ds -> namedBlock "mutual" ds- Abstract _ ds -> namedBlock "abstract" ds- Private _ ds -> namedBlock "private" ds- Postulate _ ds -> namedBlock "postulate" ds- Primitive _ ds -> namedBlock "primitive" ds- Module _ x tel ds ->- hsep [ text "module"- , pretty x- , fcat (map pretty tel)- , text "where"- ] $$ nest 2 (vcat $ map pretty ds)- ModuleMacro _ x (SectionApp _ [] e) DoOpen i | isNoName x ->- sep [ pretty DoOpen- , nest 2 $ pretty e- , nest 4 $ pretty i- ]- ModuleMacro _ x (SectionApp _ tel e) open i ->- sep [ pretty open <+> text "module" <+> pretty x <+> fcat (map pretty tel)- , nest 2 $ text "=" <+> pretty e <+> pretty i- ]- ModuleMacro _ x (RecordModuleIFS _ rec) open i ->- sep [ pretty open <+> text "module" <+> pretty x- , nest 2 $ text "=" <+> pretty rec <+> text "{{...}}"- ]- Open _ x i -> hsep [ text "open", pretty x, pretty i ]- Import _ x rn open i ->- hsep [ pretty open, text "import", pretty x, as rn, pretty i ]- where- as Nothing = empty- as (Just x) = text "as" <+> pretty (asName x)- Pragma pr -> sep [ text "{-#" <+> pretty pr, text "#-}" ]- where- namedBlock s ds =- sep [ text s- , nest 2 $ vcat $ map pretty ds- ]+ mkOverlap i d | isYesOverlap i = hlKeyword "overlap" <+> d+ | otherwise = d+ Field _ fs ->+ sep [ hlKeyword "field"+ , nest 2 $ vcat (map pretty fs)+ ]+ FunClause ai lhs rhs wh _ ->+ sep [ pretty (getModality ai)+ , pretty lhs+ , nest 2 $ pretty rhs+ ] $$ nest 2 (pretty wh)+ DataSig _ erased x tel e ->+ sep [ hsep [ hlKeyword "data"+ , prettyErased erased (pretty x)+ , fsep (map pretty tel)+ ]+ , nest 2 $ hsep+ [ colon+ , pretty e+ ]+ ]+ Data _ erased x tel e cs ->+ sep [ hsep [ hlKeyword "data"+ , prettyErased erased (pretty x)+ , fsep (map pretty tel)+ ]+ , nest 2 $ hsep+ [ colon+ , pretty e+ , hlKeyword "where"+ ]+ ] $$ nest 2 (vcat $ map pretty cs)+ DataDef _ x tel cs ->+ sep [ hsep [ hlKeyword "data"+ , pretty x+ , fsep (map pretty tel)+ ]+ , nest 2 $ hlKeyword "where"+ ] $$ nest 2 (vcat $ map pretty cs)+ RecordSig _ erased x tel e ->+ sep [ hsep [ hlKeyword "record"+ , prettyErased erased (pretty x)+ , fsep (map pretty tel)+ ]+ , nest 2 $ hsep+ [ colon+ , pretty e+ ]+ ]+ Record _ erased x dir tel e cs ->+ pRecord erased x dir tel (Just e) cs+ RecordDef _ x dir tel cs ->+ pRecord defaultErased x dir tel Nothing cs+ Infix f xs ->+ pretty f <+> fsep (punctuate comma $ fmap pretty xs)+ Syntax n _xs -> hlKeyword "syntax" <+> pretty n <+> "..."+ PatternSyn _ n as p -> hlKeyword "pattern" <+> pretty n <+> fsep (map pretty as)+ <+> equals <+> pretty p+ Mutual _ ds -> namedBlock "mutual" ds+ InterleavedMutual _ ds -> namedBlock "interleaved mutual" ds+ LoneConstructor _ ds -> namedBlock "data _ where" ds+ Abstract _ ds -> namedBlock "abstract" ds+ Private _ _ ds -> namedBlock "private" ds+ InstanceB _ ds -> namedBlock "instance" ds+ Macro _ ds -> namedBlock "macro" ds+ Postulate _ ds -> namedBlock "postulate" ds+ Primitive _ ds -> namedBlock "primitive" ds+ Generalize _ ds -> namedBlock "variable" ds+ Opaque _ ds -> namedBlock "opaque" ds+ Unfolding _ rs -> hlKeyword "unfolding" <+> braces (fsep (punctuate semi (pretty <$> rs)))+ Module _ erased x tel ds ->+ hsep [ hlKeyword "module"+ , prettyErased erased (pretty x)+ , fsep (map pretty tel)+ , hlKeyword "where"+ ] $$ nest 2 (vcat $ map pretty ds)+ ModuleMacro _ NotErased{} x (SectionApp _ [] y es) doOpen@(DoOpen _kwr) i+ | isNoName x ->+ sep [ pretty doOpen+ , nest 2 $ fsep $ pretty y : map pretty es+ , nest 4 $ pretty i+ ]+ ModuleMacro _ erased x (SectionApp _ tel y es) open i ->+ sep [ pretty open <+> hlKeyword "module" <+>+ prettyErased erased (pretty x) <+> fsep (map pretty tel)+ , nest 2 $ fsep $ concat [ [ equals, pretty y ], map pretty es, [ pretty i ] ]+ ]+ ModuleMacro _ erased x (RecordModuleInstance _ rec) open _i ->+ sep [ pretty open <+> hlKeyword "module" <+> prettyErased erased (pretty x)+ , nest 2 $ equals <+> pretty rec <+> "{{...}}"+ ]+ Open _ x i -> hsep [ hlKeyword "open", pretty x, pretty i ]+ Import open _ x rn i ->+ hsep [ pretty open, hlKeyword "import", pretty x, as rn, pretty i ]+ where+ as (Left x) = hlKeyword "as" <+> pretty (asName x)+ as (Right args) = fsep (map pretty args)+ UnquoteDecl _ xs t ->+ sep [ hlKeyword "unquoteDecl" <+> fsep (map pretty xs) <+> equals, nest 2 $ pretty t ]+ UnquoteDef _ xs t ->+ sep [ hlKeyword "unquoteDef" <+> fsep (map pretty xs) <+> equals, nest 2 $ pretty t ]+ UnquoteData _ x xs t ->+ sep [ hlKeyword "unquoteData" <+> pretty x <+> fsep (map pretty xs) <+> equals, nest 2 $ pretty t ]+ Pragma pr -> sep [ "{-#" <+> pretty pr, "#-}" ]+ where+ namedBlock s ds =+ sep [ hlKeyword (text s)+ , nest 2 $ vcat $ map pretty ds+ ] +pHasEta0 :: HasEta0 -> Doc+pHasEta0 = \case+ YesEta -> hlKeyword "eta-equality"+ NoEta () -> hlKeyword "no-eta-equality"++instance Pretty RecordDirective where+ pretty = pRecordDirective++pRecordDirective :: RecordDirective -> Doc+pRecordDirective = \case+ Induction ind -> pretty (rangedThing ind)+ Constructor n inst -> hsep [ pInst, hlKeyword "constructor", pretty n ] where+ pInst = case inst of+ InstanceDef{} -> hlKeyword "instance"+ NotInstanceDef{} -> empty+ Eta eta -> pHasEta0 (rangedThing eta)+ PatternOrCopattern{} -> hlKeyword "pattern"++pRecord+ :: Erased+ -> Name+ -> [RecordDirective]+ -> Parameters+ -> Maybe Expr+ -> [Declaration]+ -> Doc+pRecord erased x directives tel me ds = vcat+ [ sep+ [ hsep [ hlKeyword "record"+ , prettyErased erased (pretty x)+ , fsep (map pretty tel)+ ]+ , nest 2 $ pType me+ ]+ , nest 2 $ vcat $ concat+ [ map pretty directives+ , map pretty ds+ ]+ ]+ where+ pType (Just e) = hsep [ colon, pretty e, hlKeyword "where" ]+ pType Nothing = hlKeyword "where"+ instance Pretty OpenShortHand where- pretty DoOpen = text "open"- pretty DontOpen = empty+ pretty = \case+ DoOpen _ -> hlKeyword "open"+ DontOpen -> empty instance Pretty Pragma where- pretty (OptionsPragma _ opts) = fsep $ map text $ "OPTIONS" : opts- pretty (BuiltinPragma _ b x) = hsep [ text "BUILTIN", text b, pretty x ]- pretty (CompiledPragma _ x hs) =- hsep [ text "COMPILED", pretty x, text hs ]- pretty (CompiledTypePragma _ x hs) =- hsep [ text "COMPILED_TYPE", pretty x, text hs ]- pretty (CompiledDataPragma _ x hs hcs) =- hsep $ [text "COMPILED_DATA", pretty x] ++ map text (hs : hcs)- pretty (CompiledEpicPragma _ x e) =- hsep [ text "COMPILED_EPIC", pretty x, text e ]- pretty (CompiledJSPragma _ x e) =- hsep [ text "COMPILED_JS", pretty x, text e ]+ pretty (OptionsPragma _ opts) = fsep $ hlKeyword "OPTIONS" : map (hlPragma . text) opts+ pretty (BuiltinPragma _ b x) = hsep [ hlKeyword "BUILTIN", hlPragma (text (rangedThing b)), pretty x ]+ pretty (RewritePragma _ _ xs) =+ hsep [ hlKeyword "REWRITE", hsep $ map pretty xs ]+ pretty (CompilePragma _ b x e) =+ hsep [ hlKeyword "COMPILE", pretty (rangedThing b), pretty x, textNonEmpty e ]+ pretty (ForeignPragma _ b s) =+ vcat $ hsep [ hlKeyword "FOREIGN", pretty (rangedThing b) ] : map text (lines s) pretty (StaticPragma _ i) =- hsep $ [text "STATIC", pretty i]- pretty (ImportPragma _ i) =- hsep $ [text "IMPORT", text i]- pretty (ImpossiblePragma _) =- hsep $ [text "IMPOSSIBLE"]+ hsep $ [hlKeyword "STATIC", pretty i]+ pretty (InjectivePragma _ i) =+ hsep $ [hlKeyword "INJECTIVE", pretty i]+ pretty (InjectiveForInferencePragma _ i) =+ hsep $ [hlKeyword "INJECTIVE_FOR_INFERENCE", pretty i]+ pretty (InlinePragma _ True i) =+ hsep $ [hlKeyword "INLINE", pretty i]+ pretty (NotProjectionLikePragma _ i) =+ hsep $ [hlKeyword "NOT_PROJECTION_LIKE", pretty i]+ pretty (InlinePragma _ False i) =+ hsep $ [hlKeyword "NOINLINE", pretty i]+ pretty (ImpossiblePragma _ strs) =+ hsep $ [hlKeyword "IMPOSSIBLE"] ++ map text strs pretty (EtaPragma _ x) =- hsep $ [text "ETA", pretty x]--instance Pretty Fixity where- pretty (LeftAssoc _ n) = text "infixl" <+> text (show n)- pretty (RightAssoc _ n) = text "infixr" <+> text (show n)- pretty (NonAssoc _ n) = text "infix" <+> text (show n)--instance Pretty e => Pretty (Arg e) where- -- Andreas 2010-09-21: do not print relevance in general, only in function types!- -- Andreas 2010-09-24: and in record fields- pretty (Arg h r e) = -- pRelevance r $- pHidden h e+ hsep $ [hlKeyword "ETA", pretty x]+ pretty (EtaEqualityPragma _) =+ hsep $ [hlKeyword "ETA_EQUALITY"]+ pretty (TerminationCheckPragma _ tc) =+ case tc of+ TerminationCheck -> __IMPOSSIBLE__+ NoTerminationCheck -> hlKeyword "NO_TERMINATION_CHECK"+ NonTerminating -> hlKeyword "NON_TERMINATING"+ Terminating -> hlKeyword "TERMINATING"+ TerminationMeasure _ x -> hsep $ [hlKeyword "MEASURE", pretty x]+ pretty (NoCoverageCheckPragma _) = hlKeyword "NON_COVERING"+ pretty (WarningOnUsage _ nm str) = hsep [ hlKeyword "WARNING_ON_USAGE", pretty nm, hlPragma (text (show str)) ]+ pretty (WarningOnImport _ str) = hsep [ hlKeyword "WARNING_ON_IMPORT", hlPragma (text (show str)) ]+ pretty (CatchallPragma _) = hlKeyword "CATCHALL"+ pretty (DisplayPragma _ lhs rhs) = hlKeyword "DISPLAY" <+> sep [ pretty lhs <+> equals, nest 2 $ pretty rhs ]+ pretty (NoPositivityCheckPragma _) = hlKeyword "NO_POSITIVITY_CHECK"+ pretty (PolarityPragma _ q occs) =+ hsep (hlKeyword "POLARITY" : pretty q : map pretty occs)+ pretty (NoUniverseCheckPragma _) = hlKeyword "NO_UNIVERSE_CHECK"+ pretty (OverlapPragma _ x m) = hsep [pretty m, pretty x] -instance Pretty e => Pretty (Named String e) where- pretty (Named Nothing e) = pretty e- pretty (Named (Just s) e) = sep [ text s <+> text "=", pretty e ]+instance Pretty Pattern where+ prettyList = fsep . map pretty+ pretty = \case+ IdentP _ x -> pretty x+ AppP p1 p2 -> sep [ pretty p1, nest 2 $ pretty p2 ]+ RawAppP _ ps -> fsep $ map pretty $ List2.toList ps+ OpAppP _ q _ ps -> fsep $ prettyOpApp empty q $ fmap (fmap (fmap (NoPlaceholder Strict.Nothing))) ps+ HiddenP _ p -> braces' $ pretty p+ InstanceP _ p -> dbraces $ pretty p+ ParenP _ p -> parens $ pretty p+ WildP _ -> underscore+ AsP _ x p -> pretty x <> hlSymbol "@" <> pretty p+ DotP _ _ _ p -> "." <> pretty p+ AbsurdP _ -> "()"+ LitP _ l -> pretty l+ QuoteP _ -> hlKeyword "quote"+ RecP _ _ fs -> sep [ hlKeyword "record", bracesAndSemicolons (map pretty fs) ]+ EqualP _ es -> sep $ for es \ (e1, e2) -> parens $ sep [pretty e1, equals, pretty e2]+ EllipsisP _ _ -> "..."+ WithP _ p -> "|" <+> pretty p -instance Pretty [Pattern] where- pretty = fsep . map pretty+prettyOpApp :: forall a .+ Pretty a => Asp.Aspects -> QName -> List1 (NamedArg (MaybePlaceholder a)) -> [Doc]+prettyOpApp asp q es = merge [] $ prOp ms xs $ List1.toList es+ where+ -- ms: the module part of the name.+ ms = List1.init (qnameParts q)+ -- xs: the concrete name (alternation of @Id@ and @Hole@)+ xs = case unqualify q of+ Name _ _ xs -> List1.toList xs+ NoName{} -> __IMPOSSIBLE__ -instance Pretty Pattern where- pretty p =- case p of- IdentP x -> pretty x- AppP p1 p2 -> sep [ pretty p1, nest 2 $ pretty p2 ]- RawAppP _ ps -> fsep $ map pretty ps- OpAppP _ (Name _ xs) ps -> fsep $ prOp xs ps- where- prOp (Hole : xs) (e : es) = pretty e : prOp xs es- prOp (Hole : _) [] = __IMPOSSIBLE__- prOp (Id x : xs) es = text x : prOp xs es- prOp [] [] = []- prOp [] es = map pretty es- OpAppP _ (NoName _ _) _ -> __IMPOSSIBLE__- HiddenP _ p -> braces' $ pretty p- InstanceP _ p -> dbraces $ pretty p- ParenP _ p -> parens $ pretty p- WildP _ -> underscore- AsP _ x p -> pretty x <> text "@" <> pretty p- DotP _ p -> text "." <> pretty p- AbsurdP _ -> text "()"- LitP l -> pretty l+ prOp :: [Name] -> [NamePart] -> [NamedArg (MaybePlaceholder a)] -> [(Doc, Maybe PositionInName)]+ prOp ms (Hole : xs) (e : es) =+ case namedArg e of+ Placeholder p -> (qual ms $ pretty e, Just p) : prOp [] xs es+ NoPlaceholder{} -> (pretty e, Nothing) : prOp ms xs es+ -- Module qualifier needs to go on section holes (#3072)+ prOp _ (Hole : _) [] = __IMPOSSIBLE__+ prOp ms (Id x : xs) es = ( qual ms $ annotate asp $ pretty $ simpleName x+ , Nothing+ ) : prOp [] xs es+ -- Qualify the name part with the module.+ -- We then clear @ms@ such that the following name parts will not be qualified. -instance Pretty ImportDirective where- pretty i =- sep [ public (publicOpen i)- , pretty $ usingOrHiding i- , rename $ renaming i- ]- where- public True = text "public"- public False = empty+ prOp _ [] es = map (\e -> (pretty e, Nothing)) es - rename [] = empty- rename xs = hsep [ text "renaming"- , parens $ fsep $ punctuate (text ";") $ map pr xs- ]+ qual ms doc = hcat $ punctuate "." $ map pretty ms ++ [doc] - pr r = hsep [ pretty (renFrom r), text "to", pretty (renTo r) ]+ -- Section underscores should be printed without surrounding+ -- whitespace. This function takes care of that.+ merge :: [Doc] -> [(Doc, Maybe PositionInName)] -> [Doc]+ merge before [] = reverse before+ merge before ((d, Nothing) : after) = merge (d : before) after+ merge before ((d, Just Beginning) : after) = mergeRight before d after+ merge before ((d, Just End) : after) = case mergeLeft d before of+ (d, bs) -> merge (d : bs) after+ merge before ((d, Just Middle) : after) = case mergeLeft d before of+ (d, bs) -> mergeRight bs d after -instance Pretty UsingOrHiding where- pretty (Hiding []) = empty- pretty (Hiding xs) =- text "hiding" <+> parens (fsep $ punctuate (text ";") $ map pretty xs)- pretty (Using xs) =- text "using" <+> parens (fsep $ punctuate (text ";") $ map pretty xs)+ mergeRight before d after =+ reverse before +++ case merge [] after of+ [] -> [d]+ a : as -> (d <> a) : as -instance Pretty ImportedName where- pretty (ImportedName x) = pretty x- pretty (ImportedModule x) = text "module" <+> pretty x+ mergeLeft d before = case before of+ [] -> (d, [])+ b : bs -> (b <> d, bs)
@@ -0,0 +1,156 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}++{-|+ Desugaring for do-notation. Uses whatever `_>>=_` and `_>>_` happen to be+ in scope.++ Example:++ ```+ foo = do+ x ← m₁+ m₂+ just y ← m₃+ where nothing → m₄+ let z = t+ m₅+ ```+ desugars to+ ```+ foo =+ m₁ >>= λ x →+ m₂ >>+ m₃ >>= λ where+ just y → let z = t in m₅+ nothing → m₄+ ```+ -}+module Agda.Syntax.DoNotation (desugarDoNotation) where++import Prelude hiding (null)++import Agda.Syntax.Common+import Agda.Syntax.Position+import Agda.Syntax.Concrete++import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Monad+import Agda.TypeChecking.Monad++import Agda.Utils.List1 ( List1, pattern (:|) )+import qualified Agda.Utils.List1 as List1+import Agda.Syntax.Common.Pretty ( prettyShow )++import Agda.Utils.Null+import Agda.Utils.Singleton++import Agda.Utils.Impossible++desugarDoNotation :: Maybe QName -> List1 DoStmt -> ScopeM Expr+desugarDoNotation mod ss = do+ let+ qBind = maybe QName qualify mod $ simpleBinaryOperator ">>="+ qThen = maybe QName qualify mod $ simpleBinaryOperator ">>"++ isBind DoBind{} = True+ isBind _ = False++ isThen DoThen{} = True+ isThen _ = False++ -- Only check the operation we actually need. One could imagine to fall back+ -- on _>>=_ if _>>_ is not in scope, but if we are desugaring to _>>_ at all+ -- I think we should throw an error rather than silently switching to _>>=_.+ -- / Ulf+ mapM_ ensureInScope $ [qBind | any isBind ss] +++ [qThen | any isThen $ List1.init ss] -- ignore the last 'DoThen'+ desugarDo qBind qThen ss++desugarDo :: QName -> QName -> List1 DoStmt -> ScopeM Expr+desugarDo qBind qThen = \case++ -- The last statement must be a DoThen.+ DoThen e :| [] -> return e++ -- Or an absurd bind.+ DoBind r p e [] :| [] | Just (r', NotHidden) <- isAbsurdP p ->+ return $ appOp (setRange r qBind) e $ AbsurdLam r' NotHidden++ -- Otherwise, sorry.+ _ :| [] -> failure++ -- `DoThen` and `DoLet` are easy.+ DoThen e :| ss -> appOp qThen e <$> desugarDo0 ss+ DoLet r ds :| ss -> Let r ds . Just <$> desugarDo0 ss++ -- `DoBind` requires more work since we want to generate plain lambdas when possible.+ DoBind r p e [] :| ss | Just x <- singleName p -> do+ -- In this case we have a single name in the bind pattern and no where clauses.+ -- It could still be a pattern bind though (for instance, `refl ← pure eq`), so+ -- to figure out which one to use we look up the name in the scope; if it's a+ -- constructor or pattern synonym we desugar to a pattern lambda.+ res <- resolveName (QName x)+ let isMatch = case res of+ ConstructorName{} -> True+ PatternSynResName{} -> True+ _ -> False+ rest <- desugarDo0 ss+ if isMatch then return $ matchingBind qBind r p e rest []+ else return $ nonMatchingBind qBind r x e rest++ -- If there are @where@ clauses we have to desugar to a pattern lambda.+ DoBind r p e cs :| ss -> do+ rest <- desugarDo0 ss+ return $ matchingBind qBind r p e rest cs++ where+ desugarDo0 :: [DoStmt] -> ScopeM Expr+ desugarDo0 ss = List1.ifNull ss failure $ desugarDo qBind qThen++ failure = doNotationError+ "The last statement in a 'do' block must be an expression or an absurd match."++singleName :: Pattern -> Maybe Name+singleName = \case+ IdentP _ (QName x) -> Just x+ _ -> Nothing++matchingBind :: QName -> Range -> Pattern -> Expr -> Expr -> [LamClause] -> Expr+matchingBind qBind r p e body cs =+ appOp (setRange r qBind) e -- Set the range of the lambda to that of the+ $ ExtendedLam (getRange cs) -- where-clauses to make highlighting of overlapping+ defaultErased -- patterns not highlight the rest of the do-block.+ $ fmap addParens (mainClause :| cs)+ where+ mainClause = LamClause { lamLHS = [p]+ , lamRHS = RHS body+ , lamCatchall = empty }++ -- Add parens to left-hand sides.+ addParens c = c { lamLHS = addP (lamLHS c) }+ where+ addP [] = __IMPOSSIBLE__+ addP pps@(p : ps) = [ParenP (getRange pps) $ rawAppP $ p :| ps ]++nonMatchingBind :: QName -> Range -> Name -> Expr -> Expr -> Expr+nonMatchingBind qBind r x e body =+ appOp (setRange r qBind) e $ Lam (getRange (x, body)) (singleton bx) body+ where bx = DomainFree $ defaultNamedArg $ mkBinder_ x++appOp :: QName -> Expr -> Expr -> Expr+appOp q e1 e2 = app (Ident q) [par e1, par e2]+ where+ par e = Paren (getRange e) e -- Add parens to get the right precedence context (#3152)+ app e es = foldl (\ e1 e2 -> App (getRange (e1, e2)) e1 (defaultNamedArg e2)) e es++ensureInScope :: QName -> ScopeM ()+ensureInScope q = do+ r <- resolveName q+ case r of+ UnknownName -> doNotationError $+ prettyShow q ++ " needs to be in scope to desugar 'do' block"+ _ -> return ()++doNotationError :: String -> ScopeM a+doNotationError = typeError . DoNotationError
@@ -1,137 +1,156 @@-{-# LANGUAGE CPP, DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-} -{-| Definitions for fixity and precedence levels.+{-| Definitions for fixity, precedence levels, and declared syntax. -} module Agda.Syntax.Fixity where -import Data.Generics (Typeable, Data)-import Data.Foldable-import Data.Traversable+import Control.DeepSeq +import GHC.Generics (Generic)+ import Agda.Syntax.Position import Agda.Syntax.Common-import Agda.Syntax.Concrete.Name-import Agda.Syntax.Notation --- | The notation is handled as the fixity in the renamer. Hence they--- are grouped together in this type.-data Fixity' = Fixity'- {theFixity :: Fixity,- theNotation :: Notation}- deriving (Typeable, Data, Show, Eq)+import Agda.Syntax.Common.Pretty -data ThingWithFixity x = ThingWithFixity x Fixity' deriving (Functor,Foldable,Traversable,Typeable,Data,Show)--- | All the notation information related to a name.-type NewNotation = (Name, Fixity, Notation)+import Agda.Utils.Impossible --- | If an operator has no specific notation, recover it from its name.-oldToNewNotation :: (Name, Fixity') -> NewNotation-oldToNewNotation (name, Fixity' f []) = (name, f, syntaxOf name)-oldToNewNotation (name, Fixity' f syn) = (name, f, syn)+-- The Fixity data type is now defined in Agda.Syntax.Common.+-- Andreas, 2019-08-16, issue #1346 -syntaxOf :: Name -> Notation-syntaxOf (NoName _ _) = []-syntaxOf (Name _ [_]) = []-syntaxOf (Name _ xs) = mkSyn 0 xs- where mkSyn :: Int -> [NamePart] -> Notation- mkSyn n [] = []- mkSyn n (Hole:xs) = NormalHole n : mkSyn (1+n) xs- mkSyn n (Id x:xs) = IdPart x : mkSyn n xs+-- | Decorating something with @Fixity'@.+data ThingWithFixity x = ThingWithFixity x Fixity'+ deriving (Functor, Foldable, Traversable, Show) +instance LensFixity' (ThingWithFixity a) where+ lensFixity' f (ThingWithFixity a fix') = ThingWithFixity a <$> f fix' -defaultFixity' = Fixity' defaultFixity defaultNotation+instance LensFixity (ThingWithFixity a) where+ lensFixity = lensFixity' . lensFixity -noFixity = NonAssoc noRange (negate 666)+-- | Do we prefer parens around arguments like @λ x → x@ or not?+-- See 'lamBrackets'.+data ParenPreference = PreferParen | PreferParenless+ deriving (Eq, Ord, Show, Generic) --- | Fixity of operators.-data Fixity = LeftAssoc Range Nat- | RightAssoc Range Nat- | NonAssoc Range Nat- deriving (Typeable, Data, Show)+instance NFData ParenPreference -instance Eq Fixity where- LeftAssoc _ n == LeftAssoc _ m = n == m- RightAssoc _ n == RightAssoc _ m = n == m- NonAssoc _ n == NonAssoc _ m = n == m- _ == _ = False+preferParen :: ParenPreference -> Bool+preferParen p = PreferParen == p -fixityLevel :: Fixity -> Nat-fixityLevel (LeftAssoc _ n) = n-fixityLevel (RightAssoc _ n) = n-fixityLevel (NonAssoc _ n) = n+preferParenless :: ParenPreference -> Bool+preferParenless p = PreferParenless == p --- | The default fixity. Currently defined to be @'NonAssoc' 20@.-defaultFixity :: Fixity-defaultFixity = NonAssoc noRange 20+-- * Precendence -- | Precedence is associated with a context. data Precedence = TopCtx | FunctionSpaceDomainCtx- | LeftOperandCtx Fixity | RightOperandCtx Fixity- | FunctionCtx | ArgumentCtx | InsideOperandCtx+ | LeftOperandCtx Fixity | RightOperandCtx Fixity ParenPreference+ | FunctionCtx | ArgumentCtx ParenPreference | InsideOperandCtx | WithFunCtx | WithArgCtx | DotPatternCtx- deriving (Show,Typeable,Data)+ deriving (Show, Eq, Generic) +instance NFData Precedence --- | The precedence corresponding to a possibly hidden argument.-hiddenArgumentCtx :: Hiding -> Precedence-hiddenArgumentCtx NotHidden = ArgumentCtx-hiddenArgumentCtx Hidden = TopCtx-hiddenArgumentCtx Instance = TopCtx+instance Pretty Precedence where+ pretty = text . show +-- | When printing we keep track of a stack of precedences in order to be able+-- to decide whether it's safe to leave out parens around lambdas. An empty+-- stack is equivalent to `TopCtx`. Invariant: `notElem TopCtx`.+type PrecedenceStack = [Precedence]++pushPrecedence :: Precedence -> PrecedenceStack -> PrecedenceStack+pushPrecedence TopCtx _ = []+pushPrecedence p ps = p : ps++headPrecedence :: PrecedenceStack -> Precedence+headPrecedence [] = TopCtx+headPrecedence (p : _) = p++-- | Argument context preferring parens.+argumentCtx_ :: Precedence+argumentCtx_ = ArgumentCtx PreferParen+ -- | Do we need to bracket an operator application of the given fixity -- in a context with the given precedence.-opBrackets :: Fixity -> Precedence -> Bool-opBrackets (LeftAssoc _ n1)- (LeftOperandCtx (LeftAssoc _ n2)) | n1 >= n2 = False-opBrackets (RightAssoc _ n1)- (RightOperandCtx (RightAssoc _ n2)) | n1 >= n2 = False-opBrackets f1- (LeftOperandCtx f2) | fixityLevel f1 > fixityLevel f2 = False-opBrackets f1- (RightOperandCtx f2) | fixityLevel f1 > fixityLevel f2 = False-opBrackets _ TopCtx = False-opBrackets _ FunctionSpaceDomainCtx = False-opBrackets _ InsideOperandCtx = False-opBrackets _ WithArgCtx = False-opBrackets _ WithFunCtx = False-opBrackets _ _ = True+opBrackets :: Fixity -> PrecedenceStack -> Bool+opBrackets = opBrackets' False +-- | Do we need to bracket an operator application of the given fixity+-- in a context with the given precedence.+opBrackets' :: Bool -> -- Is the last argument a parenless lambda?+ Fixity -> PrecedenceStack -> Bool+opBrackets' isLam f ps = brack f (headPrecedence ps)+ where+ false = isLam && lamBrackets ps -- require more parens for `e >>= λ x → e₁` than `e >>= e₁`+ brack (Fixity _ (Related n1) LeftAssoc)+ (LeftOperandCtx (Fixity _ (Related n2) LeftAssoc)) | n1 >= n2 = false+ brack (Fixity _ (Related n1) RightAssoc)+ (RightOperandCtx (Fixity _ (Related n2) RightAssoc) _) | n1 >= n2 = false+ brack f1 (LeftOperandCtx f2) | Related f1 <- fixityLevel f1+ , Related f2 <- fixityLevel f2+ , f1 > f2 = false+ brack f1 (RightOperandCtx f2 _) | Related f1 <- fixityLevel f1+ , Related f2 <- fixityLevel f2+ , f1 > f2 = false+ brack _ TopCtx = false+ brack _ FunctionSpaceDomainCtx = false+ brack _ InsideOperandCtx = false+ brack _ WithArgCtx = false+ brack _ WithFunCtx = false+ brack _ _ = True+ -- | Does a lambda-like thing (lambda, let or pi) need brackets in the -- given context? A peculiar thing with lambdas is that they don't--- need brackets in certain right operand contexts. However, we insert--- brackets anyway, for the following reasons:------ * Clarity.------ * Sometimes brackets are needed. Example: @m₁ >>= (λ x → x) >>= m₂@--- (here @_>>=_@ is left associative).-lamBrackets :: Precedence -> Bool-lamBrackets TopCtx = False-lamBrackets _ = True+-- need brackets in certain right operand contexts. To decide we need to look+-- at the stack of precedences and not just the current precedence.+-- Example: @m₁ >>= (λ x → x) >>= m₂@ (for @_>>=_@ left associative).+lamBrackets :: PrecedenceStack -> Bool+lamBrackets [] = False+lamBrackets (p : ps) = case p of+ TopCtx -> __IMPOSSIBLE__+ ArgumentCtx pref -> preferParen pref || lamBrackets ps+ RightOperandCtx _ pref -> preferParen pref || lamBrackets ps+ FunctionSpaceDomainCtx -> True+ LeftOperandCtx{} -> True+ FunctionCtx -> True+ InsideOperandCtx -> True+ WithFunCtx -> True+ WithArgCtx -> True+ DotPatternCtx -> True -- | Does a function application need brackets?-appBrackets :: Precedence -> Bool-appBrackets ArgumentCtx = True-appBrackets DotPatternCtx = True-appBrackets _ = False+appBrackets :: PrecedenceStack -> Bool+appBrackets = appBrackets' False +-- | Does a function application need brackets?+appBrackets' :: Bool -> -- Is the argument of the application a parenless lambda?+ PrecedenceStack -> Bool+appBrackets' isLam ps = brack (headPrecedence ps)+ where+ brack ArgumentCtx{} = True+ brack DotPatternCtx = True+ brack _ = isLam && lamBrackets ps -- allow e + e₁ λ x → e₂+ -- | Does a with application need brackets?-withAppBrackets :: Precedence -> Bool-withAppBrackets TopCtx = False-withAppBrackets FunctionSpaceDomainCtx = False-withAppBrackets WithFunCtx = False-withAppBrackets _ = True+withAppBrackets :: PrecedenceStack -> Bool+withAppBrackets = brack . headPrecedence+ where+ brack TopCtx = False+ brack FunctionSpaceDomainCtx = False+ brack WithFunCtx = False+ brack _ = True -- | Does a function space need brackets?-piBrackets :: Precedence -> Bool-piBrackets TopCtx = False-piBrackets _ = True+piBrackets :: PrecedenceStack -> Bool+piBrackets [] = False+piBrackets _ = True -roundFixBrackets :: Precedence -> Bool-roundFixBrackets DotPatternCtx = True-roundFixBrackets _ = False+roundFixBrackets :: PrecedenceStack -> Bool+roundFixBrackets ps = DotPatternCtx == headPrecedence ps -instance HasRange Fixity where- getRange (LeftAssoc r _) = r- getRange (RightAssoc r _) = r- getRange (NonAssoc r _) = r+instance KillRange x => KillRange (ThingWithFixity x) where+ killRange (ThingWithFixity c f) = ThingWithFixity (killRange c) f
@@ -0,0 +1,72 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}++module Agda.Syntax.IdiomBrackets (parseIdiomBracketsSeq) where++import Control.Monad++import Agda.Syntax.Common+import Agda.Syntax.Position+import Agda.Syntax.Concrete+import Agda.Syntax.Concrete.Operators+import Agda.Syntax.Concrete.Pretty ( leftIdiomBrkt, rightIdiomBrkt )++import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Monad+import Agda.TypeChecking.Monad++import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import Agda.Syntax.Common.Pretty ( prettyShow )+import Agda.Utils.Singleton++parseIdiomBracketsSeq :: Range -> Maybe QName -> [Expr] -> ScopeM Expr+parseIdiomBracketsSeq r mod es = do+ let qEmpty = maybe QName qualify mod $ simpleName "empty"+ qPlus = maybe QName qualify mod $ simpleBinaryOperator "<|>"+ ePlus a b = App r (App r (Ident qPlus) (defaultNamedArg a)) (defaultNamedArg b)+ case es of+ [] -> ensureInScope qEmpty >> return (Ident qEmpty)+ [e] -> parseIdiomBrackets r mod e+ es@(_:_) -> do+ ensureInScope qPlus+ es' <- mapM (parseIdiomBrackets r mod) es+ return $ foldr1 ePlus es'++parseIdiomBrackets :: Range -> Maybe QName -> Expr -> ScopeM Expr+parseIdiomBrackets r mod e = do+ let qPure = maybe QName qualify mod $ simpleName "pure"+ qAp = maybe QName qualify mod $ simpleBinaryOperator "<*>"+ ePure = App r (Ident qPure) . defaultNamedArg+ eAp a b = App r (App r (Ident qAp) (defaultNamedArg a)) (defaultNamedArg b)+ mapM_ ensureInScope [qPure, qAp]+ case e of+ RawApp _ es -> do+ e :| es <- appViewM =<< parseApplication es+ return $ foldl eAp (ePure e) es+ _ -> return $ ePure e++appViewM :: Expr -> ScopeM (List1 Expr)+appViewM = \case+ e@App{} -> let AppView e' es = appView e in (e' :|) <$> mapM onlyVisible es+ OpApp _ op _ es -> (Ident op <|) <$> mapM (ordinary <=< noPlaceholder <=< onlyVisible) es+ e -> return $ singleton e+ where+ onlyVisible a+ | defaultNamedArg () == fmap (() <$) a = return $ namedArg a+ | otherwise = idiomBracketError "Only regular arguments are allowed in idiom brackets (no implicit or instance arguments)"+ noPlaceholder Placeholder{} = idiomBracketError "Naked sections are not allowed in idiom brackets"+ noPlaceholder (NoPlaceholder _ x) = return x++ ordinary (Ordinary a) = return a+ ordinary _ = idiomBracketError "Binding syntax is not allowed in idiom brackets"++ensureInScope :: QName -> ScopeM ()+ensureInScope q = do+ r <- resolveName q+ case r of+ UnknownName -> idiomBracketError $+ prettyShow q ++ " needs to be in scope to use idiom brackets " ++ prettyShow leftIdiomBrkt ++ " ... " ++ prettyShow rightIdiomBrkt+ _ -> return ()++idiomBracketError :: String -> ScopeM a+idiomBracketError = typeError . IdiomBracketError
@@ -1,15 +1,20 @@-{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving, FlexibleContexts, UndecidableInstances #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+ {-| An info object contains additional information about a piece of abstract syntax that isn't part of the actual syntax. For instance, it might contain- the source code posisiton of an expression or the concrete syntax that+ the source code position of an expression or the concrete syntax that an internal expression originates from. -} module Agda.Syntax.Info where -import Data.Generics (Typeable, Data)-import Text.Show.Functions+import Prelude hiding (null) +import Control.DeepSeq++import GHC.Generics (Generic)+ import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Common import Agda.Syntax.Position@@ -17,158 +22,312 @@ import Agda.Syntax.Fixity import Agda.Syntax.Scope.Base (ScopeInfo) -{--------------------------------------------------------------------------- No information- --------------------------------------------------------------------------}--data Info = Nope+import Agda.Utils.Functor+import Agda.Utils.Null {-------------------------------------------------------------------------- Meta information --------------------------------------------------------------------------} -data MetaInfo =- MetaInfo { metaRange :: Range- , metaScope :: ScopeInfo- , metaNumber :: Maybe Nat- }- deriving (Typeable, Data, Show)+-- | Kind of a meta: the method how to solve it.+--+data MetaKind+ = InstanceMeta -- ^ Meta variable solved by instance search.+ | UnificationMeta -- ^ Meta variable solved by unification (default).+ deriving (Show, Eq, Generic) +instance Null MetaKind where+ empty = UnificationMeta++instance NFData MetaKind++-- | Default meta kind from its 'Hiding' context.+--+hidingToMetaKind :: Hiding -> MetaKind+hidingToMetaKind = \case+ Instance{} -> InstanceMeta+ Hidden -> UnificationMeta+ NotHidden -> UnificationMeta++-- | Name suggestion for meta variable. Empty string means no suggestion.+type MetaNameSuggestion = String++-- | Information associated to a meta variable in the abstract syntax.+--+data MetaInfo = MetaInfo+ { metaRange :: Range+ , metaScope :: ScopeInfo+ , metaNumber :: Maybe MetaId+ , metaNameSuggestion :: MetaNameSuggestion+ , metaKind :: MetaKind+ }+ deriving (Show, Eq, Generic)++emptyMetaInfo :: MetaInfo+emptyMetaInfo = MetaInfo+ { metaRange = noRange+ , metaScope = empty+ , metaNumber = Nothing+ , metaNameSuggestion = ""+ , metaKind = empty+ }++instance Null MetaInfo where+ empty = emptyMetaInfo+ instance HasRange MetaInfo where getRange = metaRange instance KillRange MetaInfo where- killRange m = m { metaRange = killRange $ metaRange m }+ killRange m = m { metaRange = noRange } +instance NFData MetaInfo where+ rnf (MetaInfo _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d+ {-------------------------------------------------------------------------- General expression information --------------------------------------------------------------------------} --- | For a general expression we can either remember just the source code--- position or the entire concrete expression it came from.-data ExprInfo- = ExprRange Range- | ExprSource Range (Precedence -> Expr)- -- ^ Even if we store the original expression we have to know- -- whether to put parenthesis around it.- deriving (Typeable, Data, Show)+newtype ExprInfo = ExprRange Range+ deriving (Show, Eq, Null, NFData) +exprNoRange :: ExprInfo+exprNoRange = ExprRange noRange+ instance HasRange ExprInfo where- getRange (ExprRange r ) = r- getRange (ExprSource r _) = r+ getRange (ExprRange r) = r instance KillRange ExprInfo where- killRange (ExprRange r) = ExprRange (killRange r)- killRange (ExprSource r f) = ExprSource (killRange r) f+ killRange (ExprRange _) = exprNoRange {--------------------------------------------------------------------------- Module information+ Application information --------------------------------------------------------------------------} -data ModuleInfo =- ModuleInfo { minfoRange :: Range- , minfoAsTo :: Range- -- The range of the \"as\" and \"to\" keywords,- -- if any. Retained for highlighting purposes.- , minfoAsName :: Maybe C.Name- -- The \"as\" module name, if any. Retained for- -- highlighting purposes.- , minfoOpenShort :: Maybe OpenShortHand- , minfoDirective :: Maybe ImportDirective- -- Retained for abstractToConcrete of ModuleMacro- }- deriving (Typeable, Data)+-- | Information about application+data AppInfo = AppInfo+ { appRange :: Range+ , appOrigin :: Origin+ , appParens :: ParenPreference -- ^ Do we prefer a lambda argument with or without parens?+ }+ deriving (Show, Eq, Ord, Generic) -deriving instance (Show OpenShortHand, Show ImportDirective) => Show ModuleInfo+-- | Default is system inserted and prefer parens.+defaultAppInfo :: Range -> AppInfo+defaultAppInfo r = AppInfo{ appRange = r, appOrigin = Inserted, appParens = PreferParen } +-- | `AppInfo` with no range information.+defaultAppInfo_ :: AppInfo+defaultAppInfo_ = defaultAppInfo noRange++instance Null AppInfo where+ empty = defaultAppInfo_++instance HasRange AppInfo where+ getRange = appRange++instance KillRange AppInfo where+ killRange (AppInfo r o p) = AppInfo (killRange r) o p++instance LensOrigin AppInfo where+ getOrigin = appOrigin+ mapOrigin f i = i { appOrigin = f (appOrigin i) }++instance NFData AppInfo++{--------------------------------------------------------------------------+ Module information+ --------------------------------------------------------------------------}++data ModuleInfo = ModuleInfo+ { minfoRange :: Range+ , minfoAsTo :: Range+ -- ^ The range of the \"as\" and \"to\" keywords,+ -- if any. Retained for highlighting purposes.+ , minfoAsName :: Maybe C.Name+ -- ^ The \"as\" module name, if any. Retained for highlighting purposes.+ , minfoOpenShort :: OpenShortHand+ , minfoDirective :: Maybe ImportDirective+ -- ^ Retained for @abstractToConcrete@ of 'ModuleMacro'.+ }+ deriving (Eq, Show, Generic)+ instance HasRange ModuleInfo where getRange = minfoRange +instance SetRange ModuleInfo where+ setRange r i = i { minfoRange = r }+ instance KillRange ModuleInfo where- killRange m = m { minfoRange = killRange $ minfoRange m }+ killRange m = m { minfoRange = noRange } +instance NFData ModuleInfo+ --------------------------------------------------------------------------- -- Let info --------------------------------------------------------------------------- newtype LetInfo = LetRange Range- deriving (Typeable, Data, Show)+ deriving (Show, Eq, Null, NFData) instance HasRange LetInfo where getRange (LetRange r) = r instance KillRange LetInfo where- killRange (LetRange r) = LetRange (killRange r)+ killRange (LetRange _) = LetRange noRange {-------------------------------------------------------------------------- Definition information (declarations that actually define something) --------------------------------------------------------------------------} -data DefInfo =- DefInfo { defFixity :: Fixity'- , defAccess :: Access- , defAbstract :: IsAbstract- , defInfo :: DeclInfo- }- deriving (Typeable, Data, Show)+data DefInfo' t = DefInfo+ { defFixity :: Fixity'+ , defAccess :: Access+ , defAbstract :: IsAbstract+ , defOpaque :: IsOpaque+ , defInstance :: IsInstance+ , defMacro :: IsMacro+ , defInfo :: DeclInfo+ , defTactic :: TacticAttribute' t+ }+ deriving (Show, Eq, Generic) -mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo-mkDefInfo x f a ab r = DefInfo f a ab (DeclInfo x r)+mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t+mkDefInfo x f a ab r = mkDefInfoInstance x f a ab NotInstanceDef NotMacroDef r -instance HasRange DefInfo where+-- | Same as @mkDefInfo@ but where we can also give the @IsInstance@+mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo' t+mkDefInfoInstance x f a ab i m r = DefInfo f a ab TransparentDef i m (DeclInfo x r) empty++instance HasRange (DefInfo' t) where getRange = getRange . defInfo -instance KillRange DefInfo where- killRange i = i { defInfo = killRange $ defInfo i }+instance SetRange (DefInfo' t) where+ setRange r i = i { defInfo = setRange r (defInfo i) } +instance KillRange (DefInfo' t) where+ killRange i = i { defInfo = killRange $ defInfo i,+ defTactic = killRange $ defTactic i }++instance LensIsAbstract (DefInfo' t) where+ lensIsAbstract f i = (f $! defAbstract i) <&> \ a -> i { defAbstract = a }++instance LensIsOpaque (DefInfo' t) where+ lensIsOpaque f i = (f $! defOpaque i) <&> \ a -> i { defOpaque = a }++instance AnyIsAbstract (DefInfo' t) where+ anyIsAbstract = defAbstract++instance AllAreOpaque (DefInfo' t) where+ jointOpacity = jointOpacity . defOpaque++instance NFData t => NFData (DefInfo' t)+ {-------------------------------------------------------------------------- General declaration information --------------------------------------------------------------------------} -data DeclInfo =- DeclInfo { declName :: Name- , declRange :: Range- }- deriving (Typeable, Data, Show)+data DeclInfo = DeclInfo+ { declName :: Name+ , declRange :: Range+ }+ deriving (Show, Eq, Generic) instance HasRange DeclInfo where getRange = declRange +instance SetRange DeclInfo where+ setRange r i = i { declRange = r }+ instance KillRange DeclInfo where- killRange i = i { declRange = killRange $ declRange i }+ killRange i = i { declRange = noRange } +instance NFData DeclInfo+ {--------------------------------------------------------------------------+ Mutual block information+ --------------------------------------------------------------------------}++data MutualInfo = MutualInfo+ { mutualTerminationCheck :: TerminationCheck Name+ , mutualCoverageCheck :: CoverageCheck+ , mutualPositivityCheck :: PositivityCheck+ , mutualRange :: Range+ }+ deriving (Show, Eq, Generic)++-- | Default value for 'MutualInfo'.+instance Null MutualInfo where+ empty = MutualInfo TerminationCheck YesCoverageCheck YesPositivityCheck noRange++instance HasRange MutualInfo where+ getRange = mutualRange++instance KillRange MutualInfo where+ killRange i = i { mutualRange = noRange }++instance NFData MutualInfo++{-------------------------------------------------------------------------- Left hand side information --------------------------------------------------------------------------} -newtype LHSInfo = LHSRange Range- deriving (Typeable, Data, Show)+data LHSInfo = LHSInfo+ { lhsRange :: Range+ , lhsEllipsis :: ExpandedEllipsis+ } deriving (Show, Eq, Generic) instance HasRange LHSInfo where- getRange (LHSRange r) = r+ getRange (LHSInfo r _) = r instance KillRange LHSInfo where- killRange (LHSRange r) = LHSRange (killRange r)+ killRange (LHSInfo _ ell) = LHSInfo noRange ell +instance Null LHSInfo where+ null i = null (lhsRange i) && null (lhsEllipsis i)+ empty = LHSInfo empty empty++instance NFData LHSInfo+ {-------------------------------------------------------------------------- Pattern information --------------------------------------------------------------------------} --- TODO: Is it safe to add Typeable/Data here? PatInfo contains a--- function space.+-- | For a general pattern we remember the source code position.+newtype PatInfo+ = PatRange Range+ deriving (Eq, Null, Semigroup, Monoid, Show, SetRange, HasRange,+ KillRange, NFData) -data PatInfo = PatRange Range- | PatSource Range (Precedence -> Pattern)- deriving (Typeable, Data)+-- | Empty range for patterns.+patNoRange :: PatInfo+patNoRange = PatRange noRange -instance Show PatInfo where- show (PatRange r) = "PatRange " ++ show r- show (PatSource r _) = "PatSource " ++ show r+-- | Constructor pattern info.+data ConPatInfo = ConPatInfo+ { conPatOrigin :: ConOrigin+ -- ^ Does this pattern come form the eta-expansion of an implicit pattern?+ --- Or from a user written constructor or record pattern?+ , conPatInfo :: PatInfo+ , conPatLazy :: ConPatLazy+ }+ deriving (Eq, Show, Generic) -instance HasRange PatInfo where- getRange (PatRange r) = r- getRange (PatSource r _) = r+instance HasRange ConPatInfo where+ getRange = getRange . conPatInfo -instance KillRange PatInfo where- killRange (PatRange r) = PatRange $ killRange r- killRange (PatSource r f) = PatSource (killRange r) f+instance KillRange ConPatInfo where+ killRange (ConPatInfo b i l) = ConPatInfo b (killRange i) l++instance SetRange ConPatInfo where+ setRange r (ConPatInfo b _ l) = ConPatInfo b (PatRange r) l++instance NFData ConPatInfo++-- | Has the constructor pattern a dotted (forced) constructor?+data ConPatLazy+ = ConPatLazy -- ^ Dotted constructor.+ | ConPatEager -- ^ Ordinary constructor.+ deriving (Eq, Ord, Show, Bounded, Enum, Generic)++instance NFData ConPatLazy
@@ -1,327 +1,2057 @@-{-# LANGUAGE CPP, DeriveDataTypeable, GeneralizedNewtypeDeriving,- DeriveFunctor, DeriveFoldable, DeriveTraversable #-}--module Agda.Syntax.Internal- ( module Agda.Syntax.Internal- , module Agda.Syntax.Abstract.Name- ) where--import Prelude hiding (foldr)-import Control.Applicative-import Data.Generics (Typeable, Data)-import Data.Foldable-import Data.Traversable-import Data.Function-import qualified Data.List as List--import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Literal-import Agda.Syntax.Abstract.Name--import Agda.Utils.Monad-import Agda.Utils.Size-import Agda.Utils.Permutation--#include "../undefined.h"-import Agda.Utils.Impossible---- | Raw values.------ @Def@ is used for both defined and undefined constants.--- Assume there is a type declaration and a definition for--- every constant, even if the definition is an empty--- list of clauses.----data Term = Var Nat Args- | Lam Hiding (Abs Term) -- ^ terms are beta normal- | Lit Literal- | Def QName Args- | Con QName Args- | Pi (Arg Type) (Abs Type)- | Sort Sort- | Level Level- | MetaV MetaId Args- | DontCare Term -- ^ irrelevant stuff- deriving (Typeable, Data, Show)--data Type = El Sort Term- deriving (Typeable, Data, Show)--data Elim = Apply (Arg Term) | Proj QName -- ^ name of a record projection- deriving (Show)---- | Top sort (Set\omega).-topSort :: Type-topSort = El Inf (Sort Inf)--data Sort = Type Level- | Prop -- ignore me- | Inf- | DLub Sort (Abs Sort)- -- ^ if the free variable occurs in the second sort- -- the whole thing should reduce to Inf, otherwise- -- it's the normal Lub- deriving (Typeable, Data, Show)--newtype Level = Max [PlusLevel]- deriving (Show, Typeable, Data)--data PlusLevel = ClosedLevel Integer- | Plus Integer LevelAtom- deriving (Show, Typeable, Data)--data LevelAtom = MetaLevel MetaId Args- | BlockedLevel MetaId Term- | NeutralLevel Term- | UnreducedLevel Term- deriving (Show, Typeable, Data)---- | Something where a meta variable may block reduction.-data Blocked t = Blocked MetaId t- | NotBlocked t- deriving (Typeable, Data, Eq, Ord, Functor, Foldable, Traversable)--instance Show t => Show (Blocked t) where- showsPrec p (Blocked m x) = showParen (p > 0) $- showString "Blocked " . shows m . showString " " . showsPrec 10 x- showsPrec p (NotBlocked x) = showsPrec p x--instance Applicative Blocked where- pure = notBlocked- Blocked x f <*> e = Blocked x $ f (ignoreBlocking e)- NotBlocked f <*> e = f <$> e--instance Sized Term where- size v = case v of- Var _ vs -> 1 + Prelude.sum (map size vs)- Def _ vs -> 1 + Prelude.sum (map size vs)- Con _ vs -> 1 + Prelude.sum (map size vs)- MetaV _ vs -> 1 + Prelude.sum (map size vs)- Level l -> size l- Lam _ f -> 1 + size f- Lit _ -> 1- Pi a b -> 1 + size a + size b- Sort s -> 1- DontCare mv -> size mv--instance Sized Type where- size = size . unEl--instance Sized Level where- size (Max as) = 1 + Prelude.sum (map size as)--instance Sized PlusLevel where- size (ClosedLevel _) = 1- size (Plus _ a) = size a--instance Sized LevelAtom where- size (MetaLevel _ vs) = 1 + Prelude.sum (map size vs)- size (BlockedLevel _ v) = size v- size (NeutralLevel v) = size v- size (UnreducedLevel v) = size v--instance KillRange Term where- killRange v = case v of- Var i vs -> killRange1 (Var i) vs- Def c vs -> killRange2 Def c vs- Con c vs -> killRange2 Con c vs- MetaV m vs -> killRange1 (MetaV m) vs- Lam h f -> killRange2 Lam h f- Lit l -> killRange1 Lit l- Level l -> killRange1 Level l- Pi a b -> killRange2 Pi a b- Sort s -> killRange1 Sort s- DontCare mv -> killRange1 DontCare mv--instance KillRange Level where- killRange (Max as) = killRange1 Max as--instance KillRange PlusLevel where- killRange l@ClosedLevel{} = l- killRange (Plus n l) = killRange1 (Plus n) l--instance KillRange LevelAtom where- killRange (MetaLevel n as) = killRange1 (MetaLevel n) as- killRange (BlockedLevel m v) = killRange1 (BlockedLevel m) v- killRange (NeutralLevel v) = killRange1 NeutralLevel v- killRange (UnreducedLevel v) = killRange1 UnreducedLevel v--instance KillRange Type where- killRange (El s v) = killRange2 El s v--instance KillRange Sort where- killRange s = case s of- Prop -> Prop- Inf -> Inf- Type a -> killRange1 Type a- DLub s1 s2 -> killRange2 DLub s1 s2--instance KillRange a => KillRange (Tele a) where- killRange = fmap killRange--{---- instance KillRange Telescope where- killRange EmptyTel = EmptyTel- killRange (ExtendTel a tel) = ExtendTel (killRange a) (killRange tel) -- killRange2 ExtendTel a tel--}--instance KillRange a => KillRange (Blocked a) where- killRange = fmap killRange--instance KillRange a => KillRange (Abs a) where- killRange = fmap killRange---- | Type of argument lists.----type Args = [Arg Term]---- | Sequence of types. An argument of the first type is bound in later types--- and so on.-data Tele a = EmptyTel- | ExtendTel a (Abs (Tele a)) -- ^ Abs is never NoAbs.- deriving (Typeable, Data, Show, Functor, Foldable, Traversable)--type Telescope = Tele (Arg Type)--instance Sized (Tele a) where- size EmptyTel = 0- size (ExtendTel _ tel) = 1 + size tel---- | The body has (at least) one free variable.-data Abs a = Abs String a- | NoAbs String a- deriving (Typeable, Data, Functor, Foldable, Traversable)---- | Danger: doesn't shift variables properly-unAbs :: Abs a -> a-unAbs (Abs _ v) = v-unAbs (NoAbs _ v) = v--absName :: Abs a -> String-absName (Abs x _) = x-absName (NoAbs x _) = x--instance Show a => Show (Abs a) where- showsPrec p (Abs x a) = showParen (p > 0) $- showString "Abs " . shows x . showString " " . showsPrec 10 a- showsPrec p (NoAbs x a) = showParen (p > 0) $- showString "NoAbs " . shows x . showString " " . showsPrec 10 a--instance Sized a => Sized (Abs a) where- size = size . unAbs------- Definitions------- | A clause is a list of patterns and the clause body should @Bind@.------ The telescope contains the types of the pattern variables and the--- permutation is how to get from the order the variables occur in--- the patterns to the order they occur in the telescope. The body--- binds the variables in the order they appear in the patterns.------ For the purpose of the permutation and the body dot patterns count--- as variables. TODO: Change this!-data Clause = Clause- { clauseRange :: Range- , clauseTel :: Telescope- , clausePerm :: Permutation- , clausePats :: [Arg Pattern]- , clauseBody :: ClauseBody- }- deriving (Typeable, Data, Show)-data ClauseBody = Body Term- | Bind (Abs ClauseBody)- | NoBody -- ^ for absurd clauses.- deriving (Typeable, Data, Show)--instance HasRange Clause where- getRange = clauseRange---- | Patterns are variables, constructors, or wildcards.--- @QName@ is used in @ConP@ rather than @Name@ since--- a constructor might come from a particular namespace.--- This also meshes well with the fact that values (i.e.--- the arguments we are matching with) use @QName@.----data Pattern = VarP String -- name suggestion- | DotP Term- | ConP QName (Maybe (Arg Type)) [Arg Pattern]- -- ^ The type is @'Just' t@' iff the pattern is a- -- record pattern. The scope used for the type is given- -- by any outer scope plus the clause's telescope- -- ('clauseTel').- | LitP Literal- deriving (Typeable, Data, Show)--newtype MetaId = MetaId Nat- deriving (Eq, Ord, Num, Real, Enum, Integral, Typeable, Data)--instance Show MetaId where- show (MetaId n) = "_" ++ show n---- | Doesn't do any reduction.-arity :: Type -> Nat-arity t = case unEl t of- Pi _ b -> 1 + arity (unAbs b)- _ -> 0---- | Suggest a name for the first argument of a function of the given type.-argName :: Type -> String-argName = argN . unEl- where- argN (Pi _ b) = "." ++ absName b- argN _ = __IMPOSSIBLE__--------------------------------------------------------------------------------- * Smart constructors------------------------------------------------------------------------------blockingMeta :: Blocked t -> Maybe MetaId-blockingMeta (Blocked m _) = Just m-blockingMeta (NotBlocked _) = Nothing--blocked :: MetaId -> a -> Blocked a-blocked x = Blocked x--notBlocked :: a -> Blocked a-notBlocked = NotBlocked--ignoreBlocking :: Blocked a -> a-ignoreBlocking (Blocked _ x) = x-ignoreBlocking (NotBlocked x) = x--set0 = set 0-set n = sort $ mkType n-prop = sort Prop-sort s = El (sSuc s) $ Sort s-varSort n = Type $ Max [Plus 0 $ NeutralLevel $ Var n []]---- | Get the next higher sort.-sSuc :: Sort -> Sort-sSuc Prop = mkType 1-sSuc Inf = Inf-sSuc (DLub a b) = DLub (sSuc a) (fmap sSuc b)-sSuc (Type l) = Type $ levelSuc l--levelSuc (Max []) = Max [ClosedLevel 1]-levelSuc (Max as) = Max $ map inc as- where inc (ClosedLevel n) = ClosedLevel (n + 1)- inc (Plus n l) = Plus (n + 1) l--mkType n = Type $ Max [ClosedLevel n | n > 0]--getSort :: Type -> Sort-getSort (El s _) = s--unEl :: Type -> Term-unEl (El _ t) = t--impossibleTerm :: String -> Int -> Term-impossibleTerm file line = Lit $ LitString noRange $ unlines- [ "An internal error has occurred. Please report this as a bug."- , "Location of the error: " ++ file ++ ":" ++ show line- ]+{-# LANGUAGE CPP #-}+{-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE MagicHash #-}+{-# OPTIONS_GHC -Wunused-imports #-}+-- {-# OPTIONS_GHC -Wunused-matches #-}++module Agda.Syntax.Internal+ ( module Agda.Syntax.Internal+ , module Agda.Syntax.Internal.Blockers+ , module Agda.Syntax.Internal.Elim+ , module Agda.Syntax.Internal.Univ+ , module Agda.Syntax.Abstract.Name+ , MetaId(..), ProblemId(..)+ ) where++import Prelude hiding (null)++import Control.Monad.Identity+import Control.DeepSeq+import GHC.Exts++import qualified Data.List as List+import Data.Maybe+import Data.Semigroup ( Sum(..) )+import System.IO.Unsafe (unsafePerformIO)++import GHC.Generics (Generic)++import Agda.Syntax.Position+import Agda.Syntax.Common+import Agda.Syntax.Literal+import Agda.Syntax.Abstract.Name+import Agda.Syntax.Internal.Blockers+import Agda.Syntax.Internal.Elim+import Agda.Syntax.Internal.Univ+import Agda.Syntax.Common.Pretty++import Agda.Utils.CallStack+ ( CallStack+ , HasCallStack+ , prettyCallSite+ , headCallSite+ , withCallerCallStack+ )++import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1)+import Agda.Utils.Null+import Agda.Utils.Size+import Agda.Utils.ExpandCase+import qualified Agda.Utils.CompactRegion as Compact+import qualified Agda.Utils.MinimalArray.Lifted as AL++import Agda.Utils.Impossible++---------------------------------------------------------------------------+-- * Function type domain+---------------------------------------------------------------------------++data RewDom' t = RewDom+ { rewDomEq :: LocalEquation' t+ -- ^ Elaborated "@rewrite" equation+ , rewDomRew :: Maybe RewriteRule+ -- ^ "@rewrite" equation transformed into a directed rewrite rule.+ --+ -- @Nothing@ iff invalidated by a substitution. If we are checking+ -- against an "@rewrite" domain, this is fine, but if we are inside an "@rewrite"+ -- context, this is probably an internal error.+ } deriving (Show, Generic)++type RewDom = RewDom' Term++data DomInfo t = DomInfo {+ domInfoArgInfo :: ArgInfo+ , domInfoName :: (Maybe NamedName)+ -- ^ e.g. @x@ in @{x = y : A} -> B@.+ , domInfoIsFinite :: Bool+ -- ^ Is this a Π-type (False), or a partial type (True)?+ , domInfoTactic :: (Maybe t)+ -- ^ "@tactic e".+ , domInfoRew :: (Maybe (RewDom' t))+ -- ^ Elaborated "@rewrite" equation+ --+ -- Will only be present if domain annotated with "@rewrite" (@annRewrite@+ -- is @IsRewrite@) AND the type successfully elaborated into a rewrite rule.+ }++instance Show t => Show (DomInfo t) where+ show (DomInfo a b c d e) = show (a,b,c,d,e)++{-# INLINE domInfo #-}+domInfo :: Dom' t e -> ArgInfo+domInfo d = domInfoArgInfo (domDomInfo d)++{-# INLINE dInfo #-}+dInfo :: Lens' (Dom' t e) ArgInfo+dInfo = \f d ->+ f (domInfo d) <&> \x -> d {domDomInfo = (domDomInfo d){domInfoArgInfo = x}}++{-# INLINE domName #-}+domName :: Dom' t e -> Maybe NamedName+domName d = domInfoName (domDomInfo d)++{-# INLINE dName #-}+dName :: Lens' (Dom' t e) (Maybe NamedName)+dName = \f d ->+ f (domName d) <&> \x -> d {domDomInfo = (domDomInfo d){domInfoName = x}}++{-# INLINE domIsFinite #-}+domIsFinite :: Dom' t e -> Bool+domIsFinite d =+ domInfoIsFinite (domDomInfo d)++{-# INLINE dIsFinite #-}+dIsFinite :: Lens' (Dom' t e) Bool+dIsFinite = \f d ->+ f (domIsFinite d) <&> \x -> d {domDomInfo = (domDomInfo d){domInfoIsFinite = x}}++{-# INLINE domTactic #-}+domTactic :: Dom' t e -> Maybe t+domTactic d =+ domInfoTactic (domDomInfo d)++{-# INLINE dTactic #-}+dTactic :: Lens' (Dom' t e) (Maybe t)+dTactic = \f d ->+ f (domTactic d) <&> \x -> d {domDomInfo = (domDomInfo d){domInfoTactic = x}}++{-# INLINE rewDom #-}+rewDom :: Dom' t e -> Maybe (RewDom' t)+rewDom d =+ domInfoRew (domDomInfo d)++{-# INLINE dRew #-}+dRew :: Lens' (Dom' t e) (Maybe (RewDom' t))+dRew = \f d ->+ f (rewDom d) <&> \x -> d {domDomInfo = (domDomInfo d){domInfoRew = x}}++-- | Similar to 'Arg', but we need to distinguish+-- an irrelevance annotation in a function domain+-- (the domain itself is not irrelevant!)+-- from an irrelevant argument.+--+-- @Dom@ is used in 'Pi' of internal syntax, in 'Context' and 'Telescope'.+-- 'Arg' is used for actual arguments ('Var', 'Con', 'Def' etc.)+-- and in 'Abstract' syntax and other situations.+--+-- [ cubical ] When @annFinite (argInfoAnnotation domInfo) = True@ for+-- the domain of a 'Pi' type, the elements should be compared by+-- tabulating the domain type. Only supported in case the domain type+-- is primIsOne, to obtain the correct equality for partial elements.+--+data Dom' t e = Dom'+ { domDomInfo :: !(DomInfo t)+ , unDom :: e+ } deriving (Show, Foldable, Traversable)++pattern Dom :: ArgInfo -> Maybe NamedName -> Bool -> Maybe t -> Maybe (RewDom' t) -> e -> Dom' t e+pattern Dom a b c d e f = Dom' (DomInfo a b c d e) f+{-# INLINE Dom #-}+{-# COMPLETE Dom #-}++instance Functor (Dom' t) where+ {-# INLINE fmap #-}+ fmap fn = \(Dom a b c d e f) -> Dom a b c d e $! fn f++type Dom = Dom' Term++{-# INLINE domEq #-}+domEq :: Dom' t e -> Maybe (LocalEquation' t)+domEq = fmap rewDomEq . rewDom++-- | Is this Dom annotated as a local rewrite rule and if so, has the rewrite+-- been invalidated due to a substitution?+invalidRew :: Dom' t e -> Bool+invalidRew d = case rewDom d of+ Just (RewDom {rewDomRew = Nothing}) -> True+ _ -> False+++instance Decoration (Dom' t) where+ traverseF f (Dom ai x t b r a) = Dom ai x t b r <$> f a++instance HasRange a => HasRange (Dom' t a) where+ getRange = getRange . unDom++instance KillRange t => KillRange (RewDom' t) where+ killRange (RewDom eq rew) = killRangeN RewDom eq rew++instance (KillRange t, KillRange a) => KillRange (Dom' t a) where+ killRange (Dom info x t b r a) = killRangeN Dom info x t b r a++-- | Ignores 'Origin' and 'FreeVariables' and tactic.+instance Eq a => Eq (Dom' t a) where+ Dom (ArgInfo h1 m1 _ _ a1) s1 f1 _ _ x1 == Dom (ArgInfo h2 m2 _ _ a2) s2 f2 _ _ x2 =+ (h1, m1, a1, s1, f1, x1) == (h2, m2, a2, s2, f2, x2)++instance LensNamed (Dom' t e) where+ type NameOf (Dom' t e) = NamedName+ {-# INLINE lensNamed #-}+ lensNamed = \f dom ->+ f (domName dom) <&> \ nm -> dom { domDomInfo = (domDomInfo dom){domInfoName = nm }}++instance LensArgInfo (Dom' t e) where+ getArgInfo = domInfo+ setArgInfo ai dom = dom { domDomInfo = (domDomInfo dom) {domInfoArgInfo = ai} }++instance LensLock (Dom' t e) where+ getLock = getLock . getArgInfo+ setLock = mapArgInfo . setLock++instance LensRewriteAnn (Dom' t e) where+ getRewriteAnn = getRewriteAnn . getArgInfo+ setRewriteAnn = mapRewriteAnn . setRewriteAnn++instance LensLocalEquation (Dom e) where+ getLocalEq = domEq++-- The other lenses are defined through LensArgInfo++instance LensHiding (Dom' t e) where+instance LensModality (Dom' t e) where+instance LensOrigin (Dom' t e) where+instance LensFreeVariables (Dom' t e) where+instance LensAnnotation (Dom' t e) where++-- Since we have LensModality, we get relevance and quantity by default++instance LensRelevance (Dom' t e) where+instance LensQuantity (Dom' t e) where+instance LensCohesion (Dom' t e) where+instance LensModalPolarity (Dom' t e) where++argFromDom :: Dom' t a -> Arg a+argFromDom d = let !i = domInfo d in Arg i (unDom d)++namedArgFromDom :: Dom' t a -> NamedArg a+namedArgFromDom d =+ let !i = domInfo d+ !s = domName d+ in Arg i $ Named s (unDom d)++-- The following functions are less general than they could be:+-- @Dom@ could be replaced by @Dom' t@.+-- However, this causes problems with instance resolution in several places.+-- often for class AddContext.++domFromArgRew :: Maybe RewDom -> Arg a -> Dom a+domFromArgRew rew (Arg i a) = Dom i Nothing False Nothing rew a++domFromArg :: Arg a -> Dom a+domFromArg = domFromArgRew Nothing++domFromNamedArg :: NamedArg a -> Dom a+domFromNamedArg (Arg i a) = Dom i (nameOf a) False Nothing Nothing (namedThing a)++defaultDom :: a -> Dom a+defaultDom = defaultArgDom defaultArgInfo++defaultArgDomRew :: ArgInfo -> Maybe RewDom -> a -> Dom a+defaultArgDomRew info rew x = domFromArgRew rew (Arg info x)++defaultArgDom :: ArgInfo -> a -> Dom a+defaultArgDom info = defaultArgDomRew info Nothing++defaultNamedArgDom :: ArgInfo -> String -> a -> Dom a+defaultNamedArgDom info (unranged -> !s) x =+ set lensNamed (Just $ WithOrigin Inserted s) (defaultArgDom info x)++-- | Type of argument lists.+--+type Args = [Arg Term]+type NamedArgs = [NamedArg Term]+type Args1 = List1 (Arg Term)+type NamedArgs1 = List1 (NamedArg Term)++-- | Store the names of the record fields in the constructor.+-- This allows reduction of projection redexes outside of TCM.+-- For instance, during substitution and application.+data ConHead = ConHead+ { conName :: QName -- ^ The name of the constructor.+ , conDataRecord :: DataOrRecord -- ^ Data or record constructor?+ , conInductive :: Induction -- ^ Record constructors can be coinductive.+ , conIsHIT :: IsHIT -- ^ Is the datatype of this constructor a HIT?+ , conFields :: [Arg QName] -- ^ The name of the record fields.+ -- 'Arg' is stored since the info in the constructor args+ -- might not be accurate because of subtyping (issue #2170).+ } deriving (Show, Generic)++instance Eq ConHead where+ (==) = (==) `on` conName++instance Ord ConHead where+ (<=) = (<=) `on` conName++instance Pretty ConHead where+ pretty = pretty . conName++instance HasRange ConHead where+ getRange = getRange . conName++instance SetRange ConHead where+ setRange r = mapConName (setRange r)++instance CopatternMatchingAllowed ConHead where+ copatternMatchingAllowed = copatternMatchingAllowed . conDataRecord++class LensConName a where+ getConName :: a -> QName+ setConName :: QName -> a -> a+ setConName = mapConName . const+ mapConName :: (QName -> QName) -> a -> a+ mapConName f a = setConName (f (getConName a)) a++instance LensConName ConHead where+ getConName = conName+ setConName c con = con { conName = c }+++-- | Terms used for internal purposes+data DummyTermKind+ = DummyNamed String+ -- ^ Generic dummy term, the 'String' generally describes where the+ -- term was generated (as well as giving a disambiguator).+ --+ -- Should not be used to convey actual information.++ | DummyBrave Term+ -- ^ Collects applications to a 'BraveTerm'.+ deriving Show++instance IsString DummyTermKind where+ fromString = DummyNamed++-- | Raw values.+--+-- @Def@ is used for both defined and undefined constants.+-- Assume there is a type declaration and a definition for+-- every constant, even if the definition is an empty+-- list of clauses.+--+data Term = Var' {-# UNPACK #-} !Int Elims -- ^ @x es@ neutral+ | Lam ArgInfo (Abs Term) -- ^ Terms are beta normal. Relevance is ignored+ | Lit Literal+ | Def QName Elims -- ^ @f es@, possibly a delta/iota-redex+ | Con ConHead ConInfo Elims+ -- ^ @c es@ or @record { fs = es }@+ -- @es@ allows only Apply and IApply eliminations,+ -- and IApply only for data constructors.+ | Pi (Dom Type) (Abs Type) -- ^ dependent or non-dependent function space+ | Sort Sort+ | Level Level+ | MetaV {-# UNPACK #-} !MetaId Elims+ | DontCare Term+ -- ^ Irrelevant stuff in relevant position, but created+ -- in an irrelevant context. Basically, an internal+ -- version of the irrelevance axiom @.irrAx : .A -> A@.+ | Dummy DummyTermKind Elims+ -- ^ A (part of a) term or type which is only used for internal purposes.+ --+ -- The 'DummyTermKind' describes why this dummy was created;+ -- typically, it is a string describing the source location+ -- that created it, but dummy terms are also used when+ -- *leaving* the type checker (through reification) to+ -- convey out-of-band information.+ --+ -- The second field accumulates eliminations in case we+ -- apply a dummy term to more of them. Dummy terms should+ -- never be used in places where they can affect type+ -- checking, so syntactic checks are free to ignore the+ -- eliminators, which are only there to ease debugging when+ -- a dummy term incorrectly leaks into a relevant position.+ deriving Show++-- Caching small variables+--------------------------------------------------------------------------------++{-# NOINLINE varTable #-}+varTable :: AL.Array Term+varTable = unsafePerformIO $ do+ !c <- Compact.new 4096+ let !tbl = AL.fromList [Var' i [] | i <- [0..(varTableSize - 1)]]+ Compact.add c tbl++pattern Var :: Int -> Elims -> Term+pattern Var i es <- Var' i es where+ Var i es = case es of+ [] -> case i < varTableSize of+ True -> AL.unsafeIndex varTable i+ _ -> Var' i es+ _ -> Var' i es+{-# INLINE Var #-}+{-# COMPLETE Var, Lam, Lit, Def, Con, Pi, Sort, Level, MetaV, DontCare, Dummy #-}++{-# INLINE varTableSize #-}+varTableSize :: Int+varTableSize = 128++-- | An unapplied variable.+var :: Nat -> Term+var i | i >= 0 = case i < varTableSize of+ True -> AL.unsafeIndex varTable i+ _ -> Var' i []+ | otherwise = __IMPOSSIBLE__++--------------------------------------------------------------------------------++type ConInfo = ConOrigin++type Elim = Elim' Term+type Elims = [Elim] -- ^ eliminations ordered left-to-right.++-- | Binder.+--+-- 'Abs': The bound variable might appear in the body.+-- 'NoAbs' is pseudo-binder, it does not introduce a fresh variable,+-- similar to the @const@ of Haskell.+--+data Abs a = Abs { absName :: ArgName, unAbs :: a }+ -- ^ The body has (at least) one free variable.+ -- Danger: 'unAbs' doesn't shift variables properly+ | NoAbs { absName :: ArgName, unAbs :: a }+ deriving (Foldable, Traversable, Generic)++instance Functor Abs where+ fmap f = \case+ Abs x y -> Abs x $! f y+ NoAbs x y -> NoAbs x $! f y++instance Decoration Abs where+ traverseF f (Abs x a) = Abs x <$> f a+ traverseF f (NoAbs x a) = NoAbs x <$> f a++-- | Types are terms with a sort annotation.+--+data Type'' t a = El { _getSort :: Sort' t, unEl :: a }+ deriving (Show, Functor, Foldable, Traversable)++type Type' a = Type'' Term a++type Type = Type' Term++instance Decoration (Type'' t) where+ traverseF f (El s a) = El s <$> f a++class LensSort a where+ lensSort :: Lens' a Sort+ getSort :: a -> Sort+ getSort a = a ^. lensSort++instance LensSort Sort where+ lensSort f s = f s <&> \ s' -> s'++instance LensSort (Type' a) where+ lensSort f (El s a) = f s <&> \ s' -> El s' a++-- General instance leads to overlapping instances.+-- instance (Decoration f, LensSort a) => LensSort (f a) where+instance LensSort a => LensSort (Dom a) where+ lensSort = traverseF . lensSort++instance LensSort a => LensSort (Arg a) where+ lensSort = traverseF . lensSort+++-- | Sequence of types. An argument of the first type is bound in later types+-- and so on.+data Tele a = EmptyTel+ | ExtendTel a !(Abs (Tele a)) -- ^ 'Abs' is never 'NoAbs'.+ deriving (Show, Functor, Foldable, Traversable, Generic)++instance ExpandCase (Tele a) where type Result (Tele a) = Tele a++type Telescope = Tele (Dom Type)++data UnivSize+ = USmall -- ^ @Prop/Set/SSet ℓ@.+ | ULarge -- ^ @(Prop/Set/SSet)ωᵢ@.+ deriving stock (Eq, Show)++-- | Blocked dependency (i.e. free zero variable) check, used in 'PiSort'.+--+-- For efficiency, we track whether the codomain sort has actually changed.+-- If it hasn't, we can avoid duplicating work.+data BlockedDepCheck t+ = CodomainSortSame+ -- ^ The codomain sort has not changed, so we can just do the dependency+ -- check on the current codomain sort.+ | CodomainSortOld t+ -- ^ The codomain sort has changed, so we really need to do the dependency+ -- check on the original codomain sort.+ --+ -- E.g. see #5810: @∀ t → Set (ℓ t)@ has codomain sort @Set (lsuc (ℓ t))@+ -- but then after the substitution @ℓ ↦ λ _ → lzero@, the codomain sort+ -- becomes @Set (lsuc lzero)@, which is no longer dependent on @t@.+ -- To avoid a subject reduction problem, we have to remember that the+ -- codomain sort before the substitution was @Set (lsuc (ℓ t))@.+ --+ -- The old codomain sort lives in its original context. In an ideal world,+ -- we would store this context, but this does not appear very feasible+ -- (without a significant refactor).+ deriving (Show, Functor, Foldable, Traversable, Generic)++codomainSortOld :: t -> BlockedDepCheck t -> t+codomainSortOld s (CodomainSortOld s') = s'+codomainSortOld s CodomainSortSame = s++-- | Sorts.+--+data Sort' t+ = Univ Univ (Level' t)+ -- ^ @Prop ℓ@, @Set ℓ@, @SSet ℓ@.+ | Inf Univ !Integer+ -- ^ @Propωᵢ@, @(S)Setωᵢ@.+ | SizeUniv+ -- ^ @SizeUniv@, a sort inhabited by type @Size@.+ | LockUniv+ -- ^ @LockUniv@, a sort for locks.+ | LevelUniv+ -- ^ @LevelUniv@, a sort inhabited by type @Level@.+ -- When --level-universe isn't on, this universe reduces to @Set 0@+ | IntervalUniv+ -- ^ @IntervalUniv@, a sort inhabited by the cubical interval.+ | PiSort' (BlockedDepCheck (Sort' t)) (Dom' t t) (Sort' t) (Abs (Sort' t))+ -- ^ Sort of the pi type @(x : A) → B@.+ -- The components are the blocked dependency problem @c@, the domain @A@+ -- (as a bare term), the sort @s1@ of @A@, and the sort @s2@ of @B@ in+ -- the context extended by @x : A@.+ --+ -- @s2@ is always @Abs@+ --+ -- @c@ stores the original codomain sort to ensure we make coherent+ -- choices w.r.t. whether pi types are level-dependent or not+ -- (see #5810)+ --+ -- The sort denoted by @'PiSort' c A s1 s2@ only depends on @c@, @s1@+ -- and @s2@. The domain @A@ is kept around so that we can rebuild the+ -- type @'El' s1 A@ needed to extend the context when we have to work+ -- under the binder of @s2@; see e.g. 'reduceB'' for sorts or+ -- 'piSortEquals'.+ | FunSort (Sort' t) (Sort' t)+ -- ^ Sort of a (non-dependent) function type.+ | UnivSort (Sort' t)+ -- ^ Sort of another sort ("successor sort").+ | MetaS {-# UNPACK #-} !MetaId [Elim' t]+ -- ^ Sort metavariable.+ | DefS QName [Elim' t]+ -- ^ A postulated sort.+ | DummyS String+ -- ^ A (part of a) term or type which is only used for internal purposes.+ -- Replaces the abuse of @Prop@ for a dummy sort.+ -- The @String@ typically describes the location where we create this dummy,+ -- but can contain other information as well.+ deriving Show++mustBeAbs :: Impossible -> Abs t -> Abs t+mustBeAbs err (Abs x t) = Abs x t+mustBeAbs err NoAbs{} = throwImpossible err++-- | The codomain sort of a 'PiSort' should always be 'Abs'. This pattern+-- synonym defensively checks this.+pattern PiSort ::+ BlockedDepCheck (Sort' t) -> Dom' t t -> Sort' t -> Abs (Sort' t)+ -> Sort' t+pattern PiSort c a s1 s2Abs <- PiSort' c a s1 s2Abs where+ PiSort c a s1 s2Abs = PiSort' c a s1 (mustBeAbs __IMPOSSIBLE__ s2Abs)++{-# COMPLETE+ Univ, Inf,+ SizeUniv, LockUniv, LevelUniv, IntervalUniv,+ PiSort, FunSort, UnivSort, MetaS, DefS, DummyS #-}++pattern Prop, Type, SSet :: Level' t -> Sort' t+pattern Prop l = Univ UProp l+pattern Type l = Univ UType l+pattern SSet l = Univ USSet l++{-# COMPLETE+ Prop, Type, SSet, Inf,+ SizeUniv, LockUniv, LevelUniv, IntervalUniv,+ PiSort, FunSort, UnivSort, MetaS, DefS, DummyS #-}++type Sort = Sort' Term++-- | A level is a maximum expression of a closed level and 0..n+-- 'PlusLevel' expressions each of which is an atom plus a number.+data Level' t = Max !Integer [PlusLevel' t]+ deriving (Show, Functor, Foldable, Traversable)++type Level = Level' Term++data PlusLevel' t = Plus !Integer t+ deriving (Show, Functor, Foldable, Traversable)++type PlusLevel = PlusLevel' Term+type LevelAtom = Term++---------------------------------------------------------------------------+-- * Brave Terms+---------------------------------------------------------------------------++-- | Newtypes for terms that produce a dummy, rather than crash, when+-- applied to incompatible eliminations.+newtype BraveTerm = BraveTerm { unBrave :: Term } deriving Show++---------------------------------------------------------------------------+-- * Blocked Terms+---------------------------------------------------------------------------++type Blocked = Blocked' Term+type NotBlocked = NotBlocked' Term+--+-- | @'Blocked a@ without the @a@.+type Blocked_ = Blocked ()++---------------------------------------------------------------------------+-- * Definitions+---------------------------------------------------------------------------++-- | Named pattern arguments.+type NAPs = [NamedArg DeBruijnPattern]++-- | Does the clause body contain calls to any of the mutually recursive functions?+data ClauseRecursive+ = YesRecursive+ -- ^ Definitely a call to a mutually recursive function.+ | NotRecursive+ -- ^ Definitely no call to a mutually recursive function.+ | MaybeRecursive+ -- ^ Don't know because the analysis has not run yet.+ deriving (Bounded, Enum, Eq, Generic, Show)++couldBeRecursive :: ClauseRecursive -> Bool+couldBeRecursive = \case+ YesRecursive -> True+ NotRecursive -> False+ MaybeRecursive -> True++decideRecursive :: Bool -> ClauseRecursive+decideRecursive = \case+ True -> YesRecursive+ False -> NotRecursive++-- | A clause is a list of patterns and the clause body.+--+-- The telescope contains the types of the pattern variables and the+-- de Bruijn indices say how to get from the order the variables occur in+-- the patterns to the order they occur in the telescope. The body+-- binds the variables in the order they appear in the telescope.+--+-- @clauseTel ~ permute clausePerm (patternVars namedClausePats)@+--+-- Terms in dot patterns are valid in the clause telescope.+--+-- For the purpose of the permutation and the body dot patterns count+-- as variables. TODO: Change this!+data Clause = Clause+ { clauseLHSRange :: Range+ , clauseFullRange :: Range+ , clauseTel :: Telescope+ -- ^ @Δ@: The types of the pattern variables in dependency order.+ , namedClausePats :: NAPs+ -- ^ @Δ ⊢ ps@. The de Bruijn indices refer to @Δ@.+ , clauseBody :: Maybe Term+ -- ^ @Just v@ with @Δ ⊢ v@ for a regular clause, or @Nothing@ for an+ -- absurd one.+ , clauseType :: Maybe (Arg Type)+ -- ^ @Δ ⊢ t@. The type of the rhs under @clauseTel@.+ -- Used, e.g., by @TermCheck@.+ -- Can be 'Irrelevant' if we encountered an irrelevant projection+ -- pattern on the lhs.+ , clauseCatchall :: Catchall+ -- ^ Clause has been labelled as CATCHALL.+ , clauseRecursive :: ClauseRecursive+ -- ^ @clauseBody@ contains recursive calls? Computed by termination checker.+ , clauseUnreachable :: Maybe Bool+ -- ^ Clause has been labelled as unreachable by the coverage checker.+ -- @Nothing@ means coverage checker has not run yet (clause may be unreachable).+ -- @Just False@ means clause is not unreachable.+ -- @Just True@ means clause is unreachable.+ , clauseEllipsis :: ExpandedEllipsis+ -- ^ Was this clause created by expansion of an ellipsis?+ , clauseWhereModule :: Maybe ModuleName+ -- ^ Keeps track of the module name associate with the clause's where clause.+ }+ deriving (Show, Generic)++clausePats :: Clause -> [Arg DeBruijnPattern]+clausePats = map' (fmap namedThing) . namedClausePats++instance HasRange Clause where+ getRange = clauseLHSRange++-- | Pattern variables.+type PatVarName = ArgName++patVarNameToString :: PatVarName -> String+patVarNameToString = argNameToString++nameToPatVarName :: Name -> PatVarName+nameToPatVarName = nameToArgName++data PatternInfo = PatternInfo+ { patOrigin :: PatOrigin+ , patAsNames :: [Name]+ } deriving (Show, Eq, Generic)++instance Null PatternInfo where+ empty = defaultPatternInfo++defaultPatternInfo :: PatternInfo+defaultPatternInfo = PatternInfo PatOSystem []++-- | Origin of the pattern: what did the user write in this position?+data PatOrigin+ = PatOSystem -- ^ Pattern inserted by the system+ | PatOSplit -- ^ Pattern generated by case split+ | PatOSplitArg ArgName -- ^ Argument to pattern generated by case split+ | PatOVar Name -- ^ User wrote a variable pattern+ | PatODot -- ^ User wrote a dot pattern+ | PatOWild -- ^ User wrote a wildcard pattern+ | PatOCon -- ^ User wrote a constructor pattern+ | PatORec -- ^ User wrote a record pattern+ | PatOLit -- ^ User wrote a literal pattern+ | PatOAbsurd -- ^ User wrote an absurd pattern+ deriving (Show, Eq, Generic)++-- | Patterns are variables, constructors, or wildcards.+-- @QName@ is used in @ConP@ rather than @Name@ since+-- a constructor might come from a particular namespace.+-- This also meshes well with the fact that values (i.e.+-- the arguments we are matching with) use @QName@.+--+data Pattern' x+ = VarP PatternInfo x+ -- ^ @x@+ | DotP PatternInfo Term+ -- ^ @.t@+ | ConP ConHead ConPatternInfo [NamedArg (Pattern' x)]+ -- ^ @c ps@+ -- The subpatterns do not contain any projection copatterns.+ | LitP LitPatternInfo Literal+ -- ^ E.g. @5@, @"hello"@.+ | ProjP ProjOrigin QName+ -- ^ Projection copattern. Can only appear by itself.+ | IApplyP PatternInfo Term Term x+ -- ^ Path elimination pattern, like @VarP@ but keeps track of endpoints.+ | DefP PatternInfo QName [NamedArg (Pattern' x)]+ -- ^ Used for HITs, the QName should be the one from primHComp.+ deriving (Show, Functor, Foldable, Traversable, Generic)++type Pattern = Pattern' PatVarName+ -- ^ The @PatVarName@ is a name suggestion.++varP :: a -> Pattern' a+varP = VarP defaultPatternInfo++dotP :: Term -> Pattern' a+dotP = DotP defaultPatternInfo++litP :: Literal -> Pattern' a+litP = LitP empty++-- | Type used when numbering pattern variables.+data DBPatVar = DBPatVar+ { dbPatVarName :: PatVarName+ , dbPatVarIndex :: !Int+ } deriving (Show, Eq, Generic)++type DeBruijnPattern = Pattern' DBPatVar++namedVarP :: PatVarName -> Named_ Pattern+namedVarP x = Named named $ varP x+ where named = if isUnderscore x then Nothing else Just $ WithOrigin Inserted $ unranged x++namedDBVarP :: Int -> PatVarName -> Named_ DeBruijnPattern+namedDBVarP m = (fmap . fmap) (\x -> DBPatVar x m) . namedVarP++-- | Make an absurd pattern with the given de Bruijn index.+absurdP :: Int -> DeBruijnPattern+absurdP = VarP (PatternInfo PatOAbsurd []) . DBPatVar absurdPatternName++-- | For the sake of reducing clauses before they have compiled,+-- we keep a match priority in the constructors (and literals)+-- of patterns that is computed during lhs checking and+-- decides whether a mismatch should be treated as a hard 'No'.+-- Matches that get available earlier have a lower priority.+-- Lower priority wins, meaning that if we combine a+-- 'DontKnow' with a 'No' we take the one with the lower priority.+newtype MatchPrio = MatchPrio { theMatchPrio :: Int }+ deriving (Eq, Ord, Show, Enum, KillRange, NFData)++instance Null MatchPrio where+ empty = MatchPrio 0++instance Semigroup MatchPrio where+ MatchPrio p <> MatchPrio p' = MatchPrio $ min p p'++instance Monoid MatchPrio where+ mempty = empty++-- | Extra information attached to a 'LitP'.+data LitPatternInfo = LitPatternInfo+ { litPInfo :: PatternInfo+ -- ^ Information on the origin of the pattern.+ , litPPrio :: MatchPrio+ -- ^ Time when this pattern was constructed during LHS checking.+ -- This field is used during pattern matching with the non-compiled clauses.+ }+ deriving (Eq, Show, Generic)++instance Null LitPatternInfo where+ empty = LitPatternInfo empty empty++instance KillRange LitPatternInfo where+ killRange (LitPatternInfo a b) = killRangeN LitPatternInfo a b++-- | The @ConPatternInfo@ states whether the constructor belongs to+-- a record type (@True@) or data type (@False@).+-- In the former case, the @PatOrigin@ of the @conPInfo@ says+-- whether the record pattern orginates from the expansion of an+-- implicit pattern.+-- The @Type@ is the type of the whole record pattern.+-- The scope used for the type is given by any outer scope+-- plus the clause's telescope ('clauseTel').+data ConPatternInfo = ConPatternInfo+ { conPInfo :: PatternInfo+ -- ^ Information on the origin of the pattern.+ , conPRecord :: Bool+ -- ^ @False@ if data constructor.+ -- @True@ if record constructor.+ , conPFallThrough :: Bool+ -- ^ Should the match block on non-canonical terms or can it+ -- proceed to the catch-all clause?+ , conPType :: Maybe (Arg Type)+ -- ^ The type of the whole constructor pattern.+ -- Should be present (@Just@) if constructor pattern is+ -- is generated ordinarily by type-checking.+ -- Could be absent (@Nothing@) if pattern comes from some+ -- plugin (like Agsy).+ -- Needed e.g. for with-clause stripping.+ , conPLazy :: Bool+ -- ^ Lazy patterns are generated by the forcing translation in the unifier+ -- ('Agda.TypeChecking.Rules.LHS.Unify.unifyStep') and are dropped by+ -- the clause compiler (TODO: not yet)+ -- ('Agda.TypeChecking.CompiledClause.Compile.compileClauses') when the+ -- variables they bind are unused. The GHC backend compiles lazy matches+ -- to lazy patterns in Haskell (TODO: not yet).+ , conPPrio :: !MatchPrio+ -- ^ Time when this pattern was constructed during LHS checking.+ -- This field is used during pattern matching with the non-compiled clauses.+ }+ deriving (Show, Generic)++noConPatternInfo :: ConPatternInfo+noConPatternInfo = ConPatternInfo defaultPatternInfo False False Nothing False empty++-- | Build partial 'ConPatternInfo' from 'ConInfo'+toConPatternInfo :: ConInfo -> ConPatternInfo+toConPatternInfo ConORec = noConPatternInfo{ conPInfo = PatternInfo PatORec [] , conPRecord = True }+toConPatternInfo _ = noConPatternInfo++-- | Build 'ConInfo' from 'ConPatternInfo'.+fromConPatternInfo :: ConPatternInfo -> ConInfo+fromConPatternInfo i = patToConO $ patOrigin $ conPInfo i+ where+ patToConO :: PatOrigin -> ConOrigin+ patToConO = \case+ PatOSystem -> ConOSystem+ PatOSplit -> ConOSplit+ PatOSplitArg{} -> ConOSystem+ PatOVar{} -> ConOSystem+ PatODot -> ConOSystem+ PatOWild -> ConOSystem+ PatOCon -> ConOCon+ PatORec -> ConORec+ PatOLit -> ConOCon+ PatOAbsurd -> ConOSystem++-- | Extract pattern variables in left-to-right order.+-- A 'DotP' is also treated as variable (see docu for 'Clause').+class PatternVars a where+ type PatternVarOut a+ patternVars :: a -> [Arg (Either (PatternVarOut a) Term)]++instance PatternVars (Arg (Pattern' a)) where+ type PatternVarOut (Arg (Pattern' a)) = a++ -- patternVars :: Arg (Pattern' a) -> [Arg (Either a Term)]+ patternVars (Arg i (VarP _ x) ) = [Arg i $ Left x]+ patternVars (Arg i (DotP _ t) ) = [Arg i $ Right t]+ patternVars (Arg _ (ConP _ _ ps)) = patternVars ps+ patternVars (Arg _ (DefP _ _ ps)) = patternVars ps+ patternVars (Arg _ (LitP _ _) ) = []+ patternVars (Arg _ ProjP{} ) = []+ patternVars (Arg i (IApplyP _ _ _ x)) = [Arg i $ Left x]+++instance PatternVars (NamedArg (Pattern' a)) where+ type PatternVarOut (NamedArg (Pattern' a)) = a++ patternVars = patternVars . fmap namedThing++instance PatternVars a => PatternVars [a] where+ type PatternVarOut [a] = PatternVarOut a++ patternVars = concatMap patternVars++-- | Retrieve the PatternInfo from a pattern+patternInfo :: Pattern' x -> Maybe PatternInfo+patternInfo (VarP i _) = Just i+patternInfo (DotP i _) = Just i+patternInfo (LitP i _) = Just $ litPInfo i+patternInfo (ConP _ ci _) = Just $ conPInfo ci+patternInfo ProjP{} = Nothing+patternInfo (IApplyP i _ _ _) = Just i+patternInfo (DefP i _ _) = Just i++-- | Retrieve the origin of a pattern+patternOrigin :: Pattern' x -> Maybe PatOrigin+patternOrigin = fmap patOrigin . patternInfo++instance IsProjP (Pattern' a) where+ isProjP = \case+ ProjP o d -> Just (o, unambiguous d)+ _ -> Nothing++-----------------------------------------------------------------------------+-- * Explicit substitutions+-----------------------------------------------------------------------------++-- | Substitutions.++data Substitution' a++ = IdS+ -- ^ Identity substitution.+ -- @Γ ⊢ IdS : Γ@++ | EmptyS Impossible+ -- ^ Empty substitution, lifts from the empty context. First argument is @__IMPOSSIBLE__@.+ -- Apply this to closed terms you want to use in a non-empty context.+ -- @Γ ⊢ EmptyS : ()@++ | a :# !(Substitution' a)+ -- ^ Substitution extension, ``cons''.+ -- @+ -- Γ ⊢ u : Aρ Γ ⊢ ρ : Δ+ -- ----------------------+ -- Γ ⊢ u :# ρ : Δ, A+ -- @++ | Strengthen Impossible !Int !(Substitution' a)+ -- ^ Strengthening substitution. First argument is @__IMPOSSIBLE__@.+ -- In @'Strengthen err n ρ@ the number @n@ must be non-negative.+ -- This substitution should only be applied to values @t@ for+ -- which none of the variables @0@ up to @n - 1@ are free in+ -- @t[ρ]@, and in that case @n@ is subtracted from all free de+ -- Bruijn indices in @t[ρ]@.+ -- Γ ⊢ ρ : Δ |Θ| = n+ -- ---------------------------+ -- Γ ⊢ Strengthen n ρ : Δ, Θ+ -- @++ | Wk !Int !(Substitution' a)+ -- ^ Weakening substitution, lifts to an extended context.+ -- @+ -- Γ ⊢ ρ : Δ+ -- -------------------+ -- Γ, Ψ ⊢ Wk |Ψ| ρ : Δ+ -- @+++ | Lift !Int !(Substitution' a)+ -- ^ Lifting substitution. Use this to go under a binder.+ -- @Lift 1 ρ == var 0 :# Wk 1 ρ@.+ -- @+ -- Γ ⊢ ρ : Δ+ -- -------------------------+ -- Γ, Ψρ ⊢ Lift |Ψ| ρ : Δ, Ψ+ -- @++ deriving ( Show+ , Functor+ , Foldable+ , Traversable+ , Generic+ )++type Substitution = Substitution' Term+type PatternSubstitution = Substitution' DeBruijnPattern+type Renaming = Substitution' Nat++infixr 4 :#++instance Null (Substitution' a) where+ empty = IdS+ null IdS = True+ null _ = False++-- | Wrapper for types that do not contain variables (so applying a substitution is the identity).+-- Useful if you have a structure of types that support substitution mixed with types that don't+-- and need to apply a substitution to the full structure.+newtype NoSubst t a = NoSubst { unNoSubst :: a }+ deriving (Generic, NFData, Functor)++---------------------------------------------------------------------------+-- * Views+---------------------------------------------------------------------------++-- | View type as equality type.++data EqualityView+ = EqualityViewType EqualityTypeData+ -- ^ A type of the form @u ≡ v@ decomposed into its parts.+ -- Used as type for the @rewrite@ expression.+ | OtherType Type+ -- ^ A reduced type used as type for a @with@ expression.+ | IdiomType Type+ -- ^ A reduced type used as type for the @with@ inspect idiom.++data EqualityTypeData = EqualityTypeData+ { _eqtRange :: Range -- ^ Range of the @rewrite@ expression, if any.+ , _eqtSort :: Sort -- ^ Sort of this type.+ , _eqtName :: QName -- ^ Builtin EQUALITY.+ , _eqtParams :: Args -- ^ Hidden. Empty or @Level@.+ , _eqtType :: Arg Term -- ^ Hidden.+ , _eqtLhs :: Arg Term -- ^ NotHidden.+ , _eqtRhs :: Arg Term -- ^ NotHidden.+ }++pattern EqualityType ::+ Range+ -> Sort+ -> QName+ -> Args+ -> Arg Term+ -> Arg Term+ -> Arg Term+ -> EqualityView+pattern EqualityType{ eqtRange, eqtSort, eqtName, eqtParams, eqtType, eqtLhs, eqtRhs } =+ EqualityViewType (EqualityTypeData eqtRange eqtSort eqtName eqtParams eqtType eqtLhs eqtRhs)++{-# COMPLETE EqualityType, OtherType, IdiomType #-}++isEqualityType :: EqualityView -> Bool+isEqualityType EqualityType{} = True+isEqualityType OtherType{} = False+isEqualityType IdiomType{} = False++-- | View type as path type.++data PathView+ = PathType+ { pathSort :: Sort -- ^ Sort of this type.+ , pathName :: QName -- ^ Builtin PATH.+ , pathLevel :: Arg Term -- ^ Hidden+ , pathType :: Arg Term -- ^ Hidden+ , pathLhs :: Arg Term -- ^ NotHidden+ , pathRhs :: Arg Term -- ^ NotHidden+ }+ | OType Type -- ^ reduced++isPathType :: PathView -> Bool+isPathType PathType{} = True+isPathType OType{} = False++data IntervalView+ = IZero+ | IOne+ | IMin (Arg Term) (Arg Term)+ | IMax (Arg Term) (Arg Term)+ | INeg (Arg Term)+ | OTerm Term+ deriving Show++isIOne :: IntervalView -> Bool+isIOne IOne = True+isIOne _ = False++---------------------------------------------------------------------------+-- * Absurd Lambda+---------------------------------------------------------------------------++-- | Absurd lambdas are internally represented as identity+-- with variable name "()".+absurdBody :: Abs Term+absurdBody = Abs absurdPatternName $ Var 0 []++isAbsurdBody :: Abs Term -> Bool+isAbsurdBody (Abs x (Var 0 [])) = isAbsurdPatternName x+isAbsurdBody _ = False++absurdPatternName :: PatVarName+absurdPatternName = "()"++isAbsurdPatternName :: PatVarName -> Bool+isAbsurdPatternName x = x == absurdPatternName++---------------------------------------------------------------------------+-- * Smart constructors+---------------------------------------------------------------------------++-- | Add 'DontCare' is it is not already a @DontCare@.+dontCare :: Term -> Term+dontCare v =+ case v of+ DontCare{} -> v+ _ -> DontCare v++-- | Construct a string representing the call-site that created the dummy thing.+dummyLocName :: CallStack -> String+dummyLocName cs = maybe __IMPOSSIBLE__ prettyCallSite (headCallSite cs)++-- | Aux: A dummy term to constitute a dummy term/level/sort/type.+dummyTermWith :: String -> CallStack -> Term+dummyTermWith kind cs = flip Dummy [] . DummyNamed $ concat [kind, ": ", dummyLocName cs]++__DUMMY_TERM_WITH__ :: HasCallStack => String -> Term+__DUMMY_TERM_WITH__ = withCallerCallStack . dummyTermWith++-- | A dummy term created at location.+-- Note: use macro __DUMMY_TERM__ !+dummyTerm :: CallStack -> Term+dummyTerm = dummyTermWith "dummyTerm"++__DUMMY_TERM__ :: HasCallStack => Term+__DUMMY_TERM__ = withCallerCallStack dummyTerm++-- | A dummy level to constitute a level/sort created at location.+-- Note: use macro __DUMMY_LEVEL__ !+dummyLevel :: CallStack -> Level+dummyLevel = atomicLevel . dummyTermWith "dummyLevel"++__DUMMY_LEVEL__ :: HasCallStack => Level+__DUMMY_LEVEL__ = withCallerCallStack dummyLevel++-- | A dummy sort created at location.+-- Note: use macro __DUMMY_SORT__ !+dummySort :: CallStack -> Sort+dummySort = DummyS . dummyLocName++__DUMMY_SORT__ :: HasCallStack => Sort+__DUMMY_SORT__ = withCallerCallStack dummySort++-- | A dummy type created at location.+-- Note: use macro __DUMMY_TYPE__ !+dummyType :: CallStack -> Type+dummyType cs = El (dummySort cs) $ dummyTermWith "dummyType" cs++__DUMMY_TYPE__ :: HasCallStack => Type+__DUMMY_TYPE__ = withCallerCallStack dummyType++-- | Context entries without a type have this dummy type.+-- Note: use macro __DUMMY_DOM__ !+dummyDom :: CallStack -> Dom Type+dummyDom = defaultDom . dummyType++__DUMMY_DOM__ :: HasCallStack => Dom Type+__DUMMY_DOM__ = withCallerCallStack dummyDom++-- | Constant level @n@+pattern ClosedLevel :: Integer -> Level+pattern ClosedLevel n = Max n []++atomicLevel :: t -> Level' t+atomicLevel a = Max 0 [ Plus 0 a ]++varSort :: Int -> Sort+varSort n = Type $ atomicLevel $ var n++tmSort :: Term -> Sort+tmSort t = Type $ atomicLevel t++tmSSort :: Term -> Sort+tmSSort t = SSet $ atomicLevel t++-- | Given a constant @m@ and level @l@, compute @m + l@+levelPlus :: Integer -> Level -> Level+levelPlus m (Max n as) = Max (m + n) $ map' pplus as+ where pplus (Plus n l) = Plus (m + n) l++levelSuc :: Level -> Level+levelSuc = levelPlus 1++mkType :: Integer -> Sort+mkType n = Type $ ClosedLevel n++mkProp :: Integer -> Sort+mkProp n = Prop $ ClosedLevel n++mkSSet :: Integer -> Sort+mkSSet n = SSet $ ClosedLevel n++impossibleTerm :: CallStack -> Term+impossibleTerm = flip Dummy [] . DummyNamed . show . Impossible++---------------------------------------------------------------------------+-- * Sorts.+---------------------------------------------------------------------------++isSort :: Term -> Maybe Sort+isSort = \case+ Sort s -> Just s+ _ -> Nothing++-- | Get the flavor of the universe. 'Nothing' could also mean "don't know".+sortUniv :: Sort' t -> Maybe Univ+sortUniv = \case+ Univ u _ -> Just u+ Inf u _ -> Just u+ _ -> Nothing++-- | Is this a Prop universe? Answers are yes ('True') or maybe ('False').+isProp :: Sort' t -> Bool+isProp = (Just UProp ==) . sortUniv++-- | Is this a strict universe inhabitable by data types?+isStrictDataSort :: Sort' t -> Bool+isStrictDataSort = maybe False ((IsStrict ==) . univFibrancy) . sortUniv++-- | Turn a known 'UProp' sort into a 'UType' sort, leave others unchanged.+propToType :: Sort' t -> Sort' t+propToType = \case+ Univ UProp l -> Univ UType l+ Inf UProp l -> Inf UType l+ s -> s++---------------------------------------------------------------------------+-- * Telescopes.+---------------------------------------------------------------------------++-- | A traversal for the names in a telescope.+mapAbsNamesM :: Applicative m => (ArgName -> m ArgName) -> Tele a -> m (Tele a)+mapAbsNamesM _ EmptyTel = pure EmptyTel+mapAbsNamesM f (ExtendTel a ( Abs x b)) = ExtendTel a <$> ( Abs <$> f x <*> mapAbsNamesM f b)+mapAbsNamesM f (ExtendTel a (NoAbs x b)) = ExtendTel a <$> (NoAbs <$> f x <*> mapAbsNamesM f b)+ -- Ulf, 2013-11-06: Last case is really impossible but I'd rather find out we+ -- violated that invariant somewhere other than here.++mapAbsNames :: (ArgName -> ArgName) -> Tele a -> Tele a+mapAbsNames f = runIdentity . mapAbsNamesM (Identity . f)++-- | Telescope as list.+type ListTel' a = [Dom (a, Type)]+type ListTel = ListTel' ArgName++telFromList' :: (a -> ArgName) -> ListTel' a -> Telescope+telFromList' f = List.foldr extTel EmptyTel+ where+ extTel dom@Dom'{unDom = (x, a)} = ExtendTel (dom{unDom = a}) . Abs (f x)++-- | Convert a list telescope to a telescope.+telFromList :: ListTel -> Telescope+telFromList = telFromList' id++-- | Convert a telescope to its list form.+telToList :: Tele (Dom t) -> [Dom (ArgName,t)]+telToList EmptyTel = []+telToList (ExtendTel arg (Abs x tel)) = (fmap (x,) arg :) $! telToList tel+telToList (ExtendTel _ NoAbs{} ) = __IMPOSSIBLE__++-- | Lens to edit a 'Telescope' as a list.+listTel :: Lens' Telescope ListTel+listTel f = fmap telFromList . f . telToList++-- | Drop the types from a telescope.+class TelToArgs a where+ telToArgs :: a -> [Arg ArgName]++instance TelToArgs ListTel where+ telToArgs = map' \dom -> Arg (domInfo dom) (fst $ unDom dom)++instance TelToArgs Telescope where+ telToArgs = telToArgs . telToList++-- | Constructing a singleton telescope.+class SgTel a where+ sgTel :: a -> Telescope++instance SgTel (ArgName, Dom Type) where+ sgTel (x, !dom) = ExtendTel dom $ Abs x EmptyTel++instance SgTel (Dom (ArgName, Type)) where+ sgTel dom = ExtendTel (snd <$> dom) $ Abs (fst $ unDom dom) EmptyTel++instance SgTel (Dom Type) where+ sgTel dom = sgTel (stringToArgName "_", dom)++---------------------------------------------------------------------------+-- * Simple operations on terms and types.+---------------------------------------------------------------------------++-- | Removing a topmost 'DontCare' constructor.+stripDontCare :: Term -> Term+stripDontCare = \case+ DontCare v -> v+ v -> v++-- | Doesn't do any reduction.+arity :: Type -> Nat+arity t = case unEl t of+ Pi _ b -> 1 + arity (unAbs b)+ _ -> 0++-- | Suggest a name if available (i.e. name is not "_")+class Suggest a where+ suggestName :: a -> Maybe String++instance Suggest String where+ suggestName "_" = Nothing+ suggestName x = Just x++instance Suggest (Abs b) where+ suggestName = suggestName . absName++instance Suggest Name where+ suggestName = suggestName . nameToArgName++instance Suggest Term where+ suggestName (Lam _ v) = suggestName v+ suggestName _ = Nothing++-- Wrapping @forall a. (Suggest a) => a@ into a datatype because+-- GHC doesn't support impredicative polymorphism+data Suggestion = forall a. Suggest a => Suggestion a++suggests :: [Suggestion] -> String+suggests [] = "x"+suggests (Suggestion x : xs) = fromMaybe (suggests xs) $ suggestName x++---------------------------------------------------------------------------+-- * Eliminations.+---------------------------------------------------------------------------++{-+Note: 'unSpine' is computed quite often, so it makes sense to optimize it. The first optimization is+to check with 'hasProj' and skip building a new term if the spine doesn't contain projections. The+second optimization is to use an unboxed sum type to distinguish the three cases for reconstructing+a term with spines ('Var', 'Def' and 'MetaV'), thereby avoiding heap allocation.++Docs on unboxed sums: https://downloads.haskell.org/ghc/9.14.1/docs/users_guide/exts/primitives.html#unboxed-sums+-}++hasProj :: Elims -> Bool+hasProj = \case+ [] -> False+ Proj{}:_ -> True+ _:es -> hasProj es++#if __GLASGOW_HASKELL__ < 906+data SpineHead' = SHVar !Int | SHDef !QName | SHMetaV {-# UNPACK #-} !MetaId+newtype SpineHead = SpineHead SpineHead'+#else+data SpineHead' = SHVar !Int | SHDef !QName | SHMetaV {-# UNPACK #-} !MetaId+data SpineHead = SpineHead {-# UNPACK #-} !SpineHead'+#endif++applySpineHead :: SpineHead -> Elims -> Term+applySpineHead h !es = case h of+ SpineHead (SHVar x ) -> Var x es+ SpineHead (SHDef f ) -> Def f es+ SpineHead (SHMetaV x) -> MetaV x es++unSpineLoop :: SpineHead -> Elims -> Elims -> Term+unSpineLoop !h !res es = case es of+ [] -> applySpineHead h $! reverse res+ Proj _ f : es' -> let !v = defaultArg $! (applySpineHead h $! reverse res) in+ unSpineLoop (SpineHead (SHDef f)) [Apply v] es'+ e : es' -> unSpineLoop h (e : res) es'++-- | Convert top-level postfix projections into prefix projections.+unSpine :: Term -> Term+unSpine t = case t of+ Var i es | hasProj es -> unSpineLoop (SpineHead (SHVar i )) [] es+ Def f es | hasProj es -> unSpineLoop (SpineHead (SHDef f )) [] es+ MetaV x es | hasProj es -> unSpineLoop (SpineHead (SHMetaV x)) [] es+ t -> t++-- | Convert 'Proj' projection eliminations+-- according to their 'ProjOrigin' into+-- 'Def' projection applications.+unSpine' :: (ProjOrigin -> QName -> Bool) -> Term -> Term+unSpine' p v =+ case hasElims v of+ Just (h, es) -> loop h [] es+ Nothing -> v+ where+ loop :: (Elims -> Term) -> Elims -> Elims -> Term+ loop h res es =+ case es of+ [] -> h $! reverse res+ Proj o f : es' | p o f -> let !v = defaultArg $! (h $! reverse res) in+ loop (Def f) [Apply v] es'+ e : es' -> loop h (e : res) es'++{-# INLINE hasElims #-}+-- | A view distinguishing the neutrals @Var@, @Def@, and @MetaV@ which+-- can be projected.+hasElims :: Term -> Maybe (Elims -> Term, Elims)+hasElims v =+ case v of+ Var i es -> Just (Var i, es)+ Def f es -> Just (Def f, es)+ MetaV x es -> Just (MetaV x, es)+ Con{} -> Nothing+ Lit{} -> Nothing+ Lam{} -> Nothing+ Pi{} -> Nothing+ Sort{} -> Nothing+ Level{} -> Nothing+ DontCare{} -> Nothing+ Dummy{} -> Nothing+++---------------------------------------------------------------------------+-- * Type family for type-directed operations.+---------------------------------------------------------------------------++-- @TypeOf a@ contains sufficient type information to do+-- a type-directed traversal of @a@.+type family TypeOf a++type instance TypeOf Term = Type -- Type of the term+type instance TypeOf Elims = (Type, Elims -> Term) -- Head symbol type + constructor+type instance TypeOf (Abs Term) = (Dom Type, Abs Type) -- Domain type + codomain type+type instance TypeOf (Abs Type) = Dom Type -- Domain type+type instance TypeOf (Arg a) = Dom (TypeOf a)+type instance TypeOf (Dom a) = TypeOf a+type instance TypeOf Type = ()+type instance TypeOf Sort = ()+type instance TypeOf Level = ()+type instance TypeOf [PlusLevel] = ()+type instance TypeOf PlusLevel = ()++---------------------------------------------------------------------------+-- * (Local) rewrite rules+---------------------------------------------------------------------------++-- | NLPat might become definitionally singular (after a substitution)+data DefSing+ = NeverSing+ -- ^ Never definitionally singular+ | MaybeSing+ -- ^ Might become definitionally singular after a substitution+ | AlwaysSing+ -- ^ Always definitionally singular (e.g. irrelevant or in |Prop|)+ deriving (Show, Generic, Enum, Bounded)++relToDefSing :: Relevance -> DefSing+relToDefSing r = if isIrrelevant r then AlwaysSing else NeverSing++-- Only approximate if both sides are |NotDefSingIfInj| with non-empty+-- injective constraints+minDefSing :: DefSing -> DefSing -> DefSing+minDefSing s s' = toEnum $ fromEnum s `min` fromEnum s'++maxDefSing :: DefSing -> DefSing -> DefSing+maxDefSing s s' = toEnum $ fromEnum s `max` fromEnum s'++isAlwaysSing :: DefSing -> Bool+isAlwaysSing AlwaysSing = True+isAlwaysSing _ = False++-- | Non-linear (non-constructor) first-order pattern.+data NLPat+ = PVar DefSing !Int [Arg Int]+ -- ^ Matches anything (modulo non-linearity) that only contains bound+ -- variables that occur in the given arguments.+ -- Tracks the definitional singularity of the surrounding pattern (not+ -- the type of the variable itself)+ | PDef QName PElims+ -- ^ Matches @f es@+ | PLam ArgInfo (Abs NLPat)+ -- ^ Matches @λ x → t@+ | PPi (Dom NLPType) (Abs NLPType)+ -- ^ Matches @(x : A) → B@+ | PSort NLPSort+ -- ^ Matches a sort of the given shape.+ | PBoundVar {-# UNPACK #-} !Int PElims+ -- ^ Matches @x es@ where x is a lambda-bound variable+ | PTerm Term+ -- ^ Matches the term modulo β (ideally βη).+ deriving (Show, Generic)+type PElims = [Elim' NLPat]+++type instance TypeOf NLPat = Type+type instance TypeOf [Elim' NLPat] = (Type, Elims -> Term)+++data NLPType = NLPType+ { nlpTypeSort :: NLPSort+ , nlpTypeUnEl :: NLPat+ } deriving (Show, Generic)+++data NLPSort+ = PUniv Univ NLPat+ | PInf Univ Integer+ | PSizeUniv+ | PLockUniv+ | PLevelUniv+ | PIntervalUniv+ deriving (Show, Generic)++pattern PType, PProp, PSSet :: NLPat -> NLPSort+pattern PType p = PUniv UType p+pattern PProp p = PUniv UProp p+pattern PSSet p = PUniv USSet p++{-# COMPLETE+ PType, PSSet, PProp, PInf,+ PSizeUniv, PLockUniv, PLevelUniv, PIntervalUniv #-}++data RewriteHead+ = RewDefHead QName+ | RewVarHead Nat+ -- ^ de Bruijn index of head symbol (excluding rewContext variables)+ deriving (Show, Generic, Eq)++headToPat :: Nat -> RewriteHead -> PElims -> NLPat+headToPat _ (RewDefHead f) = PDef f+headToPat telStart (RewVarHead x) = PBoundVar (x + telStart)++headToTerm :: Nat -> RewriteHead -> Elims -> Term+headToTerm _ (RewDefHead f) = Def f+headToTerm telStart (RewVarHead x) = Var (x + telStart)++-- | Undirected equational constraint ("the LHS and RHS+-- must be convertible in the calling context").+-- Admits arbitrary substitution.+data LocalEquation' t = LocalEquation+ { lEqContext :: !(Tele (Dom' t (Type'' t t)))+ , lEqLHS :: t+ , lEqRHS :: t+ , lEqType :: Type'' t t+ }+ deriving (Show, Generic)++type LocalEquation = LocalEquation' Term++-- | Directed rewrite rules generic over the type of head symbol.+-- Generally unstable under substitution.+data RewriteRule = RewriteRule+ { rewContext :: Telescope+ , rewHead :: RewriteHead+ , rewPats :: PElims -- patterns (including rewContext variables)+ , rewRHS :: Term+ , rewType :: Type+ }+ deriving (Show, Generic)++lrewHasProjectionPattern :: RewriteRule -> Bool+lrewHasProjectionPattern rew = any (isJust . isProjElim) $ rewPats rew++class LensLocalEquation a where+ getLocalEq :: a -> Maybe LocalEquation++---------------------------------------------------------------------------+-- * Null instances.+---------------------------------------------------------------------------++instance Null (Tele a) where+ empty = EmptyTel+ null EmptyTel = True+ null ExtendTel{} = False++instance Null ClauseRecursive where+ empty = MaybeRecursive++-- | A 'null' clause is one with no patterns and no rhs.+-- Should not exist in practice.+instance Null Clause where+ empty = Clause empty empty empty empty empty empty empty empty empty empty empty+ null (Clause _ _ tel pats body _ _ _ _ _ wm)+ = null tel+ && null pats+ && null body+ && null wm+++---------------------------------------------------------------------------+-- * Show instances.+---------------------------------------------------------------------------++instance Show a => Show (Abs a) where+ showsPrec p (Abs x a) = showParen (p > 0) $+ showString "Abs " . shows x . showString " " . showsPrec 10 a+ showsPrec p (NoAbs x a) = showParen (p > 0) $+ showString "NoAbs " . shows x . showString " " . showsPrec 10 a++-- instance Show t => Show (Blocked t) where+-- showsPrec p (Blocked m x) = showParen (p > 0) $+-- showString "Blocked " . shows m . showString " " . showsPrec 10 x+-- showsPrec p (NotBlocked x) = showsPrec p x++---------------------------------------------------------------------------+-- * Sized instances and TermSize.+---------------------------------------------------------------------------++-- | The size of a telescope is its length (as a list).+instance Sized (Tele a) where+ size EmptyTel = 0+ size (ExtendTel _ tel) = 1 + size tel++ natSize EmptyTel = Zero+ natSize (ExtendTel _ tel) = Succ $ natSize tel++instance Sized a => Sized (Abs a) where+ size = size . unAbs+ natSize = natSize . unAbs++-- | The size of a term is roughly the number of nodes in its+-- syntax tree. This number need not be precise for logical+-- correctness of Agda, it is only used for reporting+-- (and maybe decisions regarding performance).+--+-- Not counting towards the term size are:+--+-- * sort and color annotations,+-- * projections.+--+class TermSize a where+ termSize :: a -> Int+ termSize = getSum . tsize++ tsize :: a -> Sum Int++instance {-# OVERLAPPABLE #-} (Foldable t, TermSize a) => TermSize (t a) where+ tsize = foldMap tsize++instance TermSize Term where+ tsize = \case+ Var _ vs -> 1 + tsize vs+ Def _ vs -> 1 + tsize vs+ Con _ _ vs -> 1 + tsize vs+ MetaV _ vs -> 1 + tsize vs+ Level l -> tsize l+ Lam _ f -> 1 + tsize f+ Lit _ -> 1+ Pi a b -> 1 + tsize a + tsize b+ Sort s -> tsize s+ DontCare mv -> tsize mv+ Dummy{} -> 1++instance TermSize Sort where+ tsize = \case+ Univ _ l -> 1 + tsize l+ Inf _ _ -> 1+ SizeUniv -> 1+ LockUniv -> 1+ LevelUniv -> 1+ IntervalUniv -> 1+ PiSort _c a s1 s2 -> 1 + tsize a + tsize s1 + tsize s2+ FunSort s1 s2 -> 1 + tsize s1 + tsize s2+ UnivSort s -> 1 + tsize s+ MetaS _ es -> 1 + tsize es+ DefS _ es -> 1 + tsize es+ DummyS{} -> 1++instance TermSize Level where+ tsize (Max _ as) = 1 + tsize as++instance TermSize PlusLevel where+ tsize (Plus _ a) = tsize a++instance TermSize a => TermSize (Substitution' a) where+ tsize IdS = 1+ tsize (EmptyS _) = 1+ tsize (Wk _ rho) = 1 + tsize rho+ tsize (t :# rho) = 1 + tsize t + tsize rho+ tsize (Strengthen _ _ rho) = 1 + tsize rho+ tsize (Lift _ rho) = 1 + tsize rho++---------------------------------------------------------------------------+-- * KillRange instances.+---------------------------------------------------------------------------++instance KillRange ConHead where+ killRange (ConHead c d i h fs) = killRangeN ConHead c d i h fs++instance KillRange Term where+ killRange = \case+ Var i vs -> killRangeN (Var i) vs+ Def c vs -> killRangeN Def c vs+ Con c ci vs -> killRangeN Con c ci vs+ MetaV m vs -> killRangeN (MetaV m) vs+ Lam i f -> killRangeN Lam i f+ Lit l -> killRangeN Lit l+ Level l -> killRangeN Level l+ Pi a b -> killRangeN Pi a b+ Sort s -> killRangeN Sort s+ DontCare mv -> killRangeN DontCare mv+ v@Dummy{} -> v++instance KillRange a => KillRange (Level' a) where+ killRange (Max n as) = killRangeN (Max n) as++instance KillRange a => KillRange (PlusLevel' a) where+ killRange (Plus n l) = killRangeN (Plus n) l++instance (KillRange a, KillRange b) => KillRange (Type'' a b) where+ killRange (El s v) = killRangeN El s v++instance KillRange a => KillRange (Sort' a) where+ killRange = \case+ Inf u n -> Inf u n+ SizeUniv -> SizeUniv+ LockUniv -> LockUniv+ LevelUniv -> LevelUniv+ IntervalUniv -> IntervalUniv+ Univ u a -> killRangeN (Univ u) a+ PiSort c a s1 s2 -> killRangeN PiSort c a s1 s2+ FunSort s1 s2 -> killRangeN FunSort s1 s2+ UnivSort s -> killRangeN UnivSort s+ MetaS x es -> killRangeN (MetaS x) es+ DefS d es -> killRangeN DefS d es+ s@DummyS{} -> s++instance KillRange Substitution where+ killRange IdS = IdS+ killRange (EmptyS err) = EmptyS err+ killRange (Wk n rho) = killRangeN (Wk n) rho+ killRange (t :# rho) = killRangeN (:#) t rho+ killRange (Strengthen err n rho) = killRangeN (Strengthen err n) rho+ killRange (Lift n rho) = killRangeN (Lift n) rho++instance KillRange PatOrigin where+ killRange = \case+ PatOSystem -> PatOSystem+ PatOSplit -> PatOSplit+ PatOSplitArg n -> killRangeN PatOSplitArg n+ PatOVar n -> killRangeN PatOVar n+ PatODot -> PatODot+ PatOWild -> PatOWild+ PatOCon -> PatOCon+ PatORec -> PatORec+ PatOLit -> PatOLit+ PatOAbsurd -> PatOAbsurd++instance KillRange PatternInfo where+ killRange (PatternInfo o xs) = killRangeN PatternInfo o xs++instance KillRange ConPatternInfo where+ killRange (ConPatternInfo i mr b mt lz prio) = killRangeN (ConPatternInfo i mr b) mt lz prio++instance KillRange DBPatVar where+ killRange (DBPatVar x i) = killRangeN DBPatVar x i++instance KillRange a => KillRange (Pattern' a) where+ killRange p =+ case p of+ VarP o x -> killRangeN VarP o x+ DotP o v -> killRangeN DotP o v+ ConP con info ps -> killRangeN ConP con info ps+ LitP o l -> killRangeN LitP o l+ ProjP o q -> killRangeN (ProjP o) q+ IApplyP o u t x -> killRangeN (IApplyP o) u t x+ DefP o q ps -> killRangeN (DefP o) q ps++instance KillRange ClauseRecursive where+ killRange = id++instance KillRange Clause where+ killRange (Clause rl rf tel ps body t catchall recursive unreachable ell wm) =+ killRangeN Clause rl rf tel ps body t catchall recursive unreachable ell wm+++instance KillRange NLPat where+ killRange (PVar s x y) = killRangeN (PVar s) x y+ killRange (PDef x y) = killRangeN PDef x y+ killRange (PLam x y) = killRangeN PLam x y+ killRange (PPi x y) = killRangeN PPi x y+ killRange (PSort x) = killRangeN PSort x+ killRange (PBoundVar x y) = killRangeN PBoundVar x y+ killRange (PTerm x) = killRangeN PTerm x++instance KillRange NLPType where+ killRange (NLPType s a) = killRangeN NLPType s a++instance KillRange NLPSort where+ killRange (PUniv u l) = killRangeN (PUniv u) l+ killRange s@(PInf _f _n) = s+ killRange PSizeUniv = PSizeUniv+ killRange PLockUniv = PLockUniv+ killRange PLevelUniv = PLevelUniv+ killRange PIntervalUniv = PIntervalUniv++instance KillRange RewriteHead where+ killRange (RewVarHead a) =+ killRangeN RewVarHead a+ killRange (RewDefHead a) =+ killRangeN RewDefHead a++instance KillRange t => KillRange (LocalEquation' t) where+ killRange (LocalEquation a b c d) =+ killRangeN LocalEquation a b c d++instance KillRange RewriteRule where+ killRange (RewriteRule a b c d e) =+ killRangeN RewriteRule a b c d e++instance KillRange a => KillRange (Tele a) where+ killRange = fmap killRange++instance KillRange a => KillRange (Blocked a) where+ killRange = fmap killRange++instance KillRange a => KillRange (Abs a) where+ killRange = fmap killRange++instance KillRange a => KillRange (BlockedDepCheck a) where++-----------------------------------------------------------------------------+-- * Simple pretty printing+-----------------------------------------------------------------------------++instance Pretty a => Pretty (Substitution' a) where+ prettyPrec = pr+ where+ pr p rho = case rho of+ IdS -> "idS"+ EmptyS _err -> "emptyS"+ t :# rho -> mparens (p > 2) $+ sep [ pr 2 rho <> ",", prettyPrec 3 t ]+ Strengthen _ n rho -> mparens (p > 9) $+ text ("strS " ++! show n) <+> pr 10 rho+ Wk n rho -> mparens (p > 9) $+ text ("wkS " ++! show n) <+> pr 10 rho+ Lift n rho -> mparens (p > 9) $+ text ("liftS " ++! show n) <+> pr 10 rho++instance Pretty Term where+ prettyPrec p v =+ case v of+ Var x els -> text ("@" ++! show x) `pApp` els+ Lam ai b ->+ mparens (p > 0) $+ sep [ "λ" <+> prettyHiding ai id (text . absName $ b) <+> "->"+ , nest 2 $ pretty (unAbs b) ]+ Lit l -> pretty l+ Def q els -> pretty q `pApp` els+ Con c _ci vs -> pretty (conName c) `pApp` vs+ Pi a (NoAbs _ b) -> mparens (p > 0) $+ sep [ pretty (getModality a) <+> prettyPrec 1 (unDom a) <+> "->"+ , nest 2 $ pretty b ]+ Pi a b -> mparens (p > 0) $+ sep [ pDom (domInfo a) (pretty (getModality a) <+> text (absName b) <+> ":" <+> pretty (unDom a)) <+> "->"+ , nest 2 $ pretty (unAbs b) ]+ Sort s -> prettyPrec p s+ Level l -> prettyPrec p l+ MetaV x els -> pretty x `pApp` els+ DontCare v -> prettyPrec p v++ Dummy kind es -> case kind of+ DummyNamed s -> parens (text s) `pApp` es+ DummyBrave hd -> pretty hd `pApp` es+ where+ pApp d els = mparens (not (null els) && p > 9) $+ sep [d, nest 2 $ fsep (map' (prettyPrec 10) els)]++instance Pretty t => Pretty (Abs t) where+ pretty (Abs x t) = "Abs" <+> (text x <> ".") <+> pretty t+ pretty (NoAbs x t) = "NoAbs" <+> (text x <> ".") <+> pretty t++instance Pretty t => Pretty (BlockedDepCheck t) where+ pretty (CodomainSortOld s) = "CodomainSortOld" <+> pretty s+ pretty CodomainSortSame = "CodomainSortSame"++instance (Pretty t, Pretty e) => Pretty (Dom' t e) where+ pretty dom = pLock <+> pTac <+> pDom dom (pretty (getModality dom) <+> pretty (unDom dom))+ where+ pTac | Just t <- domTactic dom = "@" <> parens ("tactic" <+> pretty t)+ | otherwise = empty+ pLock | IsLock{} <- getLock dom = "@lock"+ | otherwise = empty++pDom :: LensHiding a => a -> Doc -> Doc+pDom i =+ case getHiding i of+ NotHidden -> parens+ Hidden -> braces+ Instance{} -> braces . braces++instance Pretty ClauseRecursive where+ pretty = \case+ YesRecursive -> "+Rec"+ NotRecursive -> "-Rec"+ MaybeRecursive -> "?Rec"++instance Pretty Clause where+ pretty Clause{clauseTel = tel, namedClausePats = ps, clauseBody = b, clauseType = t} =+ sep [ pretty tel <+> "|-"+ , nest 2 $ sep [ fsep (map' (prettyPrec 10) ps) <+> "="+ , nest 2 $ pBody b t ] ]+ where+ pBody Nothing _ = "(absurd)"+ pBody (Just b) Nothing = pretty b+ pBody (Just b) (Just t) = sep [ pretty b <+> ":", nest 2 $ pretty t ]++instance Pretty a => Pretty (Tele (Dom a)) where+ pretty tel = fsep [ pDom a (text x <+> ":" <+> pretty (unDom a)) | (x, a) <- telToList tel ]+ where+ telToList EmptyTel = []+ telToList (ExtendTel a tel) = (absName tel, a) : telToList (unAbs tel)++prettyPrecLevelSucs :: Int -> Integer -> (Int -> Doc) -> Doc+prettyPrecLevelSucs p 0 d = d p+prettyPrecLevelSucs p n d = mparens (p > 9) $ "lsuc" <+> prettyPrecLevelSucs 10 (n - 1) d++instance Pretty Level where+ prettyPrec p (Max n as) =+ case as of+ [] -> prettyN+ [a] | n == 0 -> prettyPrec p a+ _ -> mparens (p > 9) $ List.foldr1 (\a b -> "lub" <+> a <+> b) $+ [ prettyN | n > 0 ] ++! map' (prettyPrec 10) as+ where+ prettyN = prettyPrecLevelSucs p n (const "lzero")++instance Pretty PlusLevel where+ prettyPrec p (Plus n a) = prettyPrecLevelSucs p n $ \p -> prettyPrec p a++instance Pretty Sort where+ prettyPrec p s =+ case s of+ Univ u (ClosedLevel n) -> text $ suffix n $ showUniv u+ Univ u l -> mparens (p > 9) $ text (showUniv u) <+> prettyPrec 10 l+ Inf u n -> text $ suffix n $ showUniv u ++! "ω"+ SizeUniv -> "SizeUniv"+ LockUniv -> "LockUniv"+ LevelUniv -> "LevelUniv"+ IntervalUniv -> "IntervalUniv"+ PiSort c a s1 s2 -> mparens (p > 9) $+ "piSort" <+> pDom (domInfo a) (text (absName s2) <+> ":" <+> pretty (unDom a) <+> ":" <+> pretty s1)+ <+> parens (pretty (unAbs s2))+ FunSort a b -> mparens (p > 9) $+ "funSort" <+> prettyPrec 10 a <+> prettyPrec 10 b+ UnivSort s -> mparens (p > 9) $ "univSort" <+> prettyPrec 10 s+ MetaS x es -> prettyPrec p $ MetaV x es+ DefS d es -> prettyPrec p $ Def d es+ DummyS s -> parens $ text s+ where+ suffix n = applyWhen (n /= 0) (++! show n)++instance Pretty Type where+ prettyPrec p (El _ a) = prettyPrec p a++instance Pretty DBPatVar where+ prettyPrec _ x = text $ patVarNameToString (dbPatVarName x) ++! "@" ++! show (dbPatVarIndex x)++instance Pretty a => Pretty (Pattern' a) where+ prettyPrec n (VarP _o x) = prettyPrec n x+ prettyPrec _ (DotP _o t) = "." <> prettyPrec 10 t+ prettyPrec n (ConP c i nps)= mparens (n > 0 && not (null nps)) $+ (lazy <> pretty (conName c)) <+> fsep (map' (prettyPrec 10) ps)+ where ps = map' (fmap namedThing) nps+ lazy | conPLazy i = "~"+ | otherwise = empty+ prettyPrec n (DefP _o q nps)= mparens (n > 0 && not (null nps)) $+ pretty q <+> fsep (map' (prettyPrec 10) ps)+ where ps = map' (fmap namedThing) nps+ -- -- Version with printing record type:+ -- prettyPrec _ (ConP c i ps) = (if b then braces else parens) $ prTy $+ -- text (show $ conName c) <+> fsep (map (pretty . namedArg) ps)+ -- where+ -- b = maybe False (== ConOSystem) $ conPRecord i+ -- prTy d = caseMaybe (conPType i) d $ \ t -> d <+> ":" <+> pretty t+ prettyPrec _ (LitP _ l) = pretty l+ prettyPrec _ (ProjP _o q) = text ("." ++! prettyShow q)+ prettyPrec n (IApplyP _o _ _ x) = prettyPrec n x+-- prettyPrec n (IApplyP _o u0 u1 x) = text "@[" <> prettyPrec 0 u0 <> text ", " <> prettyPrec 0 u1 <> text "]" <> prettyPrec n x++instance Pretty a => Pretty (Blocked a) where+ pretty = \case+ NotBlocked ReallyNotBlocked a -> pretty a+ NotBlocked nb a -> pretty a <+> ("[ blocked on" <+> pretty nb <+> "]")+ Blocked b a -> pretty a <+> ("[ stuck on" <+> pretty b <+> "]")++instance Pretty a => Pretty (NoSubst t a) where+ pretty = pretty . unNoSubst++-----------------------------------------------------------------------------+-- * NFData instances+-----------------------------------------------------------------------------++-- Note: only strict in the shape of the terms.++instance NFData Term where+ rnf = \case+ Var _ es -> rnf es+ Lam _ b -> rnf (unAbs b)+ Lit l -> rnf l+ Def _ es -> rnf es+ Con _ _ vs -> rnf vs+ Pi a b -> rnf (unDom a, unAbs b)+ Sort s -> rnf s+ Level l -> rnf l+ MetaV _ es -> rnf es+ DontCare v -> rnf v+ Dummy _ es -> rnf es++instance NFData Type where+ rnf (El s v) = rnf (s, v)++instance NFData Sort where+ rnf = \case+ Univ _ l -> rnf l+ Inf _ _ -> ()+ SizeUniv -> ()+ LockUniv -> ()+ LevelUniv -> ()+ IntervalUniv -> ()+ PiSort a b c d -> rnf (a, b, c, unAbs d)+ FunSort a b -> rnf (a, b)+ UnivSort a -> rnf a+ MetaS _ es -> rnf es+ DefS _ es -> rnf es+ DummyS _ -> ()++instance NFData Level where+ rnf (Max n as) = rnf (n, as)++instance NFData PlusLevel where+ rnf (Plus n l) = rnf (n, l)++instance NFData e => NFData (Dom e) where+ rnf (Dom a c d e f g) = rnf a `seq` rnf c `seq` rnf d `seq` rnf e `seq` rnf f `seq` rnf g++instance NFData a => NFData (DataOrRecord' a)+instance NFData ConHead+instance NFData a => NFData (Abs a)+instance NFData a => NFData (Tele a)+instance NFData IsFibrant+instance NFData ClauseRecursive+instance NFData Clause+instance NFData PatternInfo+instance NFData PatOrigin+instance NFData x => NFData (Pattern' x)+instance NFData DBPatVar+instance NFData ConPatternInfo+instance NFData LitPatternInfo+instance NFData a => NFData (Substitution' a)+instance NFData DefSing+instance NFData NLPat+instance NFData NLPType+instance NFData NLPSort+instance NFData RewriteHead+instance NFData LocalEquation+instance NFData RewriteRule+instance NFData RewDom+instance NFData a => NFData (BlockedDepCheck a)
@@ -0,0 +1,319 @@++module Agda.Syntax.Internal.Blockers where++import Control.DeepSeq++import Data.Set (Set)+import qualified Data.Set as Set++import GHC.Generics (Generic)++import Agda.Syntax.Common+import Agda.Syntax.Abstract.Name (QName)+import Agda.Syntax.Internal.Elim++import Agda.Syntax.Common.Pretty+import Agda.Utils.List+import Agda.Utils.Functor++---------------------------------------------------------------------------+-- * Blocked Terms+---------------------------------------------------------------------------++-- | Even if we are not stuck on a meta during reduction+-- we can fail to reduce a definition by pattern matching+-- for another reason.+data NotBlocked' t+ = StuckOn (Elim' t)+ -- ^ The 'Elim' is neutral and blocks a pattern match.+ | Underapplied+ -- ^ Not enough arguments were supplied to complete the matching.+ | AbsurdMatch+ -- ^ We matched an absurd clause, results in a neutral 'Def'.+ | MissingClauses QName+ -- ^ We ran out of clauses for 'QName', all considered clauses+ -- produced an actual mismatch.+ -- This can happen when try to reduce a function application+ -- but we are still missing some function clauses.+ -- See "Agda.TypeChecking.Patterns.Match".+ | ReallyNotBlocked+ -- ^ Reduction was not blocked, we reached a whnf+ -- which can be anything but a stuck @'Def'@.+ deriving (Show, Generic)++-- | 'ReallyNotBlocked' is the unit.+-- 'MissingClauses' is dominant.+-- @'StuckOn'{}@ should be propagated, if tied, we take the left.+instance Semigroup (NotBlocked' t) where+ ReallyNotBlocked <> b = b+ -- MissingClauses is dominant (absorptive)+ b@MissingClauses{} <> _ = b+ _ <> b@MissingClauses{} = b+ -- StuckOn is second strongest+ b@StuckOn{} <> _ = b+ _ <> b@StuckOn{} = b+ b <> _ = b++instance Monoid (NotBlocked' t) where+ -- ReallyNotBlocked is neutral+ mempty = ReallyNotBlocked+ mappend = (<>)++instance NFData t => NFData (NotBlocked' t)++instance Pretty t => Pretty (NotBlocked' t) where+ pretty = \case+ StuckOn e -> "elimination" <+> pretty e+ Underapplied -> "missing elimination (underapplied)"+ AbsurdMatch -> "absurd match"+ MissingClauses x -> "missing clause for" <+> pretty x+ ReallyNotBlocked -> "(not stuck)"++-- | What is causing the blocking? Or in other words which metas or problems need to be solved to+-- unblock the blocked computation/constraint.+data Blocker = UnblockOnAll !(Set Blocker)+ | UnblockOnAny !(Set Blocker)+ | UnblockOnMeta {-# UNPACK #-} !MetaId -- ^ Unblock if meta is instantiated+ | UnblockOnProblem !ProblemId+ | UnblockOnDef !QName -- ^ Unblock when function is defined+ deriving (Show, Eq, Ord, Generic)++instance NFData Blocker++alwaysUnblock :: Blocker+alwaysUnblock = UnblockOnAll Set.empty++neverUnblock :: Blocker+neverUnblock = UnblockOnAny Set.empty++unblockOnAll :: Set Blocker -> Blocker+unblockOnAll us =+ case allViewS us of+ us | [u] <- Set.toList us -> u+ us -> UnblockOnAll us+ where+ allViewS = Set.unions . map' allView . Set.toList+ allView (UnblockOnAll us) = allViewS us+ allView u = Set.singleton u++unblockOnAny :: Set Blocker -> Blocker+unblockOnAny us =+ case anyViewS us of+ us | [u] <- Set.toList us -> u+ us | Set.member alwaysUnblock us -> alwaysUnblock+ | otherwise -> UnblockOnAny us+ where+ anyViewS = Set.unions . map' anyView . Set.toList+ anyView (UnblockOnAny us) = anyViewS us+ anyView u = Set.singleton u++unblockOnEither :: Blocker -> Blocker -> Blocker+unblockOnEither a b = unblockOnAny $ Set.fromList [a, b]++unblockOnBoth :: Blocker -> Blocker -> Blocker+unblockOnBoth a b = unblockOnAll $ Set.fromList [a, b]++unblockOnMeta :: MetaId -> Blocker+unblockOnMeta = UnblockOnMeta++unblockOnProblem :: ProblemId -> Blocker+unblockOnProblem = UnblockOnProblem++unblockOnDef :: QName -> Blocker+unblockOnDef = UnblockOnDef++unblockOnAllMetas :: Set MetaId -> Blocker+unblockOnAllMetas = unblockOnAll . Set.mapMonotonic unblockOnMeta++unblockOnAnyMeta :: Set MetaId -> Blocker+unblockOnAnyMeta = unblockOnAny . Set.mapMonotonic unblockOnMeta++onBlockingMetasM :: Monad m => (MetaId -> m Blocker) -> Blocker -> m Blocker+onBlockingMetasM f (UnblockOnAll bs) = unblockOnAll . Set.fromList <$> mapM (onBlockingMetasM f) (Set.toList bs)+onBlockingMetasM f (UnblockOnAny bs) = unblockOnAny . Set.fromList <$> mapM (onBlockingMetasM f) (Set.toList bs)+onBlockingMetasM f (UnblockOnMeta x) = f x+onBlockingMetasM f b@UnblockOnProblem{} = pure b+onBlockingMetasM f b@UnblockOnDef{} = pure b++allBlockingMetas :: Blocker -> Set MetaId+allBlockingMetas (UnblockOnAll us) = Set.unions $ map' allBlockingMetas $ Set.toList us+allBlockingMetas (UnblockOnAny us) = Set.unions $ map' allBlockingMetas $ Set.toList us+allBlockingMetas (UnblockOnMeta x) = Set.singleton x+allBlockingMetas UnblockOnProblem{} = Set.empty+allBlockingMetas UnblockOnDef{} = Set.empty++allBlockingProblems :: Blocker -> Set ProblemId+allBlockingProblems (UnblockOnAll us) = Set.unions $ map' allBlockingProblems $ Set.toList us+allBlockingProblems (UnblockOnAny us) = Set.unions $ map' allBlockingProblems $ Set.toList us+allBlockingProblems UnblockOnMeta{} = Set.empty+allBlockingProblems (UnblockOnProblem p) = Set.singleton p+allBlockingProblems UnblockOnDef{} = Set.empty++allBlockingDefs :: Blocker -> Set QName+allBlockingDefs (UnblockOnAll us) = Set.unions $ map' allBlockingDefs $ Set.toList us+allBlockingDefs (UnblockOnAny us) = Set.unions $ map' allBlockingDefs $ Set.toList us+allBlockingDefs UnblockOnMeta{} = Set.empty+allBlockingDefs UnblockOnProblem{} = Set.empty+allBlockingDefs (UnblockOnDef q) = Set.singleton q++{- There are two possible instances of Semigroup, so we don't commit+ to either one.+instance Semigroup Blocker where+ x <> y = unblockOnAll $ Set.fromList [x, y]++instance Monoid Blocker where+ mempty = alwaysUnblock+ mappend = (<>)+-}++instance Pretty Blocker where+ pretty (UnblockOnAll us) = "all" <> parens (fsep $ punctuate "," $ map' pretty $ Set.toList us)+ pretty (UnblockOnAny us) = "any" <> parens (fsep $ punctuate "," $ map' pretty $ Set.toList us)+ pretty (UnblockOnMeta m) = pretty m+ pretty (UnblockOnProblem pid) = "problem" <+> pretty pid+ pretty (UnblockOnDef q) = "definition" <+> pretty q++-- | Something where a meta variable may block reduction. Notably a top-level meta is considered+-- blocking. This did not use to be the case (pre Aug 2020).+data Blocked' t a+ = Blocked { theBlocker :: Blocker, ignoreBlocking :: a }+ | NotBlocked { blockingStatus :: NotBlocked' t, ignoreBlocking :: a }+ deriving (Show, Functor, Foldable, Traversable, Generic)++instance Decoration (Blocked' t) where+ traverseF f (Blocked b x) = Blocked b <$> f x+ traverseF f (NotBlocked nb x) = NotBlocked nb <$> f x++-- | Blocking on _all_ blockers.+instance Applicative (Blocked' t) where+ pure = notBlocked+ f <*> e = ((f $> ()) `mappend` (e $> ())) $> ignoreBlocking f (ignoreBlocking e)++instance Semigroup a => Semigroup (Blocked' t a) where+ Blocked x a <> Blocked y b = Blocked (unblockOnBoth x y) (a <> b)+ b@Blocked{} <> NotBlocked{} = b+ NotBlocked{} <> b@Blocked{} = b+ NotBlocked x a <> NotBlocked y b = NotBlocked (x <> y) (a <> b)++instance (Monoid a) => Monoid (Blocked' t a) where+ mempty = notBlocked mempty+ mappend = (<>)++instance (NFData t, NFData a) => NFData (Blocked' t a)++-- | When trying to reduce @f es@, on match failed on one+-- elimination @e ∈ es@ that came with info @r :: NotBlocked@.+-- @stuckOn e r@ produces the new @NotBlocked@ info.+--+-- 'MissingClauses' must be propagated, as this is blockage+-- that can be lifted in the future (as more clauses are added).+--+-- @'StuckOn' e0@ is also propagated, since it provides more+-- precise information as @StuckOn e@ (as @e0@ is the original+-- reason why reduction got stuck and usually a subterm of @e@).+-- An information like @StuckOn (Apply (Arg info (Var i [])))@+-- (stuck on a variable) could be used by the lhs/coverage checker+-- to trigger a split on that (pattern) variable.+--+-- In the remaining cases for @r@, we are terminally stuck+-- due to @StuckOn e@. Propagating @'AbsurdMatch'@ does not+-- seem useful.+--+-- 'Underapplied' must not be propagated, as this would mean+-- that @f es@ is underapplied, which is not the case (it is stuck).+-- Note that 'Underapplied' can only arise when projection patterns were+-- missing to complete the original match (in @e@).+-- (Missing ordinary pattern would mean the @e@ is of function type,+-- but we cannot match against something of function type.)+stuckOn :: Elim' t -> NotBlocked' t -> NotBlocked' t+stuckOn e = \case+ r@MissingClauses{} -> r+ r@StuckOn{} -> r+ Underapplied -> r'+ AbsurdMatch -> r'+ ReallyNotBlocked -> r'+ where r' = StuckOn e++---------------------------------------------------------------------------+-- * Handling blocked terms.+---------------------------------------------------------------------------++blockedOn :: Blocker -> a -> Blocked' t a+blockedOn b | alwaysUnblock == b = notBlocked+ | otherwise = Blocked b++blocked :: MetaId -> a -> Blocked' t a+blocked = Blocked . unblockOnMeta++notBlocked :: a -> Blocked' t a+notBlocked = NotBlocked ReallyNotBlocked++blocked_ :: MetaId -> Blocked' t ()+blocked_ x = blocked x ()++notBlocked_ :: Blocked' t ()+notBlocked_ = notBlocked ()++getBlocker :: Blocked' t a -> Blocker+getBlocker (Blocked b _) = b+getBlocker NotBlocked{} = neverUnblock++-----------------------------------------------------------------------------+-- * Waking up logic+-----------------------------------------------------------------------------++-- | Should a constraint wake up or not? If not, we might refine the unblocker.+data WakeUp = WakeUp | DontWakeUp (Maybe Blocker)+ deriving (Show, Eq)++wakeUpWhen :: (constr -> Bool) -> (constr -> WakeUp) -> constr -> WakeUp+wakeUpWhen guard wake c | guard c = wake c+ | otherwise = DontWakeUp Nothing++wakeUpWhen_ :: (constr -> Bool) -> constr -> WakeUp+wakeUpWhen_ p = wakeUpWhen p (const WakeUp)++wakeIfBlockedOnProblem :: ProblemId -> Blocker -> WakeUp+wakeIfBlockedOnProblem pid u+ | u' == alwaysUnblock = WakeUp+ | otherwise = DontWakeUp (Just u')+ where+ u' = unblockProblem pid u++wakeIfBlockedOnMeta :: MetaId -> Blocker -> WakeUp+wakeIfBlockedOnMeta x u+ | u' == alwaysUnblock = WakeUp+ | otherwise = DontWakeUp (Just u')+ where+ u' = unblockMeta x u++wakeIfBlockedOnDef :: QName -> Blocker -> WakeUp+wakeIfBlockedOnDef q u+ | u' == alwaysUnblock = WakeUp+ | otherwise = DontWakeUp (Just u')+ where+ u' = unblockDef q u++unblockMeta :: MetaId -> Blocker -> Blocker+unblockMeta x u@(UnblockOnMeta y) | x == y = alwaysUnblock+ | otherwise = u+unblockMeta _ u@UnblockOnProblem{} = u+unblockMeta _ u@UnblockOnDef{} = u+unblockMeta x (UnblockOnAll us) = unblockOnAll $ Set.map (unblockMeta x) us+unblockMeta x (UnblockOnAny us) = unblockOnAny $ Set.map (unblockMeta x) us++unblockProblem :: ProblemId -> Blocker -> Blocker+unblockProblem p u@(UnblockOnProblem q) | p == q = alwaysUnblock+ | otherwise = u+unblockProblem _ u@UnblockOnMeta{} = u+unblockProblem _ u@UnblockOnDef{} = u+unblockProblem p (UnblockOnAll us) = unblockOnAll $ Set.map (unblockProblem p) us+unblockProblem p (UnblockOnAny us) = unblockOnAny $ Set.map (unblockProblem p) us++unblockDef :: QName -> Blocker -> Blocker+unblockDef q u@(UnblockOnDef q') | q == q' = alwaysUnblock+ | otherwise = u+unblockDef q u@UnblockOnMeta{} = u+unblockDef q u@UnblockOnProblem{} = u+unblockDef q (UnblockOnAll us) = unblockOnAll $ Set.map (unblockDef q) us+unblockDef q (UnblockOnAny us) = unblockOnAny $ Set.map (unblockDef q) us
@@ -0,0 +1,140 @@+{-# OPTIONS_GHC -Wunused-imports #-}+-- {-# OPTIONS_GHC -ddump-simpl -dsuppress-all -dno-suppress-type-signatures -ddump-to-file -dno-typeable-binds #-}++-- | Extract used definitions from terms.++module Agda.Syntax.Internal.Defs where++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Utils.ExpandCase+import Agda.Utils.StrictEndo+import Agda.Utils.Impossible++-- | Get list of definitions, throw an error if any metavariable is encountered.+getDefListNoMetas :: Term -> [QName]+getDefListNoMetas a =+ getDefs (\_ -> __IMPOSSIBLE__) (\x -> Endo \xs -> x:xs) a `appEndo` []++-- | Getting the used definitions.+--+-- Note: in contrast to 'Agda.Syntax.Internal.Generic.foldTerm'+-- @getDefs@ also collects from sorts in terms.+-- Thus, this is not an instance of @foldTerm@.+class GetDefs a where++ -- | @getDefs lookup emb a@ extracts all used definitions+ -- (functions, data/record types) from @a@, embedded into a monoid via @emb@.+ -- Instantiations of meta variables are obtained via @lookup@.+ --+ -- Typical monoid instances would be @Endo [QName]@ or @Set QName@. Do not use @[QName]@+ -- because of obvious quadratic slowdown.+ -- Note that @emb@ can also choose to discard a used definition+ -- by mapping to the unit of the monoid.+ getDefs :: (Monoid m, ExpandCase m) => (MetaId -> Maybe Term) -> (QName -> m) -> a -> m++ -- {-# INLINE getDefs #-}+ -- default getDefs ::+ -- (Foldable f, GetDefs b, f b ~ a, Monoid m, ExpandCase m)+ -- => (MetaId -> Maybe Term) -> (QName -> m) -> a -> m+ -- getDefs ms ds = foldMap (getDefs ms ds)++instance GetDefs Clause where+ getDefs ms ds cl =+ expand \ret -> ret $ getDefs ms ds (clauseBody cl)++instance GetDefs Term where+ getDefs ms ds t = expand \ret -> case t of+ Def d vs -> ret $ ds d <> getDefs ms ds vs+ Con _ _ vs -> ret $ getDefs ms ds vs+ Lit l -> ret $ mempty+ Var i vs -> ret $ getDefs ms ds vs+ Lam _ v -> ret $ getDefs ms ds v+ Pi a b -> ret $ getDefs ms ds a <> getDefs ms ds b+ Sort s -> ret $ getDefs ms ds s+ Level l -> ret $ getDefs ms ds l+ MetaV x vs -> ret $ getDefs ms ds x <> getDefs ms ds vs+ DontCare v -> ret $ getDefs ms ds v+ Dummy{} -> ret $ mempty++instance GetDefs MetaId where+ getDefs ms ds x = getDefs ms ds (ms x)++instance GetDefs Type where+ getDefs ms ds a = expand \ret -> case a of+ El s t -> ret $ getDefs ms ds s <> getDefs ms ds t++instance GetDefs Sort where+ getDefs ms ds s = expand \ret -> case s of+ Univ _ l -> ret $ getDefs ms ds l+ Inf _ _ -> ret $ mempty+ SizeUniv -> ret $ mempty+ LockUniv -> ret $ mempty+ LevelUniv -> ret $ mempty+ IntervalUniv -> ret $ mempty+ PiSort c a s1 s2 -> ret $+ getDefs ms ds c <> getDefs ms ds a <> getDefs ms ds s1 <> getDefs ms ds s2+ FunSort s1 s2 -> ret $ getDefs ms ds s1 <> getDefs ms ds s2+ UnivSort s -> ret $ getDefs ms ds s+ MetaS x es -> ret $ getDefs ms ds x <> getDefs ms ds es+ DefS d es -> ret $ ds d <> getDefs ms ds es+ DummyS{} -> ret $ mempty++instance GetDefs a => GetDefs (BlockedDepCheck a) where+ getDefs ms ds c = expand \ret -> case c of+ CodomainSortOld s -> ret $ getDefs ms ds s+ CodomainSortSame -> ret $ mempty++instance GetDefs Level where+ getDefs ms ds l = expand \ret -> case l of Max _ ls -> ret $ getDefs ms ds ls++instance GetDefs PlusLevel where+ getDefs ms ds l = expand \ret -> case l of Plus _ l -> ret $ getDefs ms ds l++-- collection instances+instance GetDefs a => GetDefs (Maybe a) where+ {-# INLINE getDefs #-}+ getDefs ms ds ma = expand \ret -> case ma of+ Nothing -> ret mempty+ Just a -> ret $ getDefs ms ds a++instance GetDefs a => GetDefs [a] where+ {-# INLINE getDefs #-}+ getDefs ms ds = go where+ go as = expand \ret -> case as of+ [] -> ret mempty+ a:as -> ret $ getDefs ms ds a <> go as++instance GetDefs a => GetDefs (Elim' a) where+ {-# INLINE getDefs #-}+ getDefs ms ds e = expand \ret -> case e of+ Apply t -> ret $ getDefs ms ds t+ Proj _ _ -> ret $ mempty+ IApply l r t -> ret $ getDefs ms ds l <> getDefs ms ds r <> getDefs ms ds t++instance GetDefs a => GetDefs (Arg a) where+ {-# INLINE getDefs #-}+ getDefs ms ds a = expand \ret -> case a of+ Arg _ t -> ret $ getDefs ms ds t++instance GetDefs a => GetDefs (Dom a) where+ {-# INLINE getDefs #-}+ getDefs ms ds d = expand \ret -> case d of+ Dom _ _ _ _ _ t -> ret $ getDefs ms ds t++instance GetDefs a => GetDefs (Abs a) where+ {-# INLINE getDefs #-}+ getDefs ms ds a = expand \ret -> case a of+ Abs _ t -> ret $ getDefs ms ds t+ NoAbs _ t -> ret $ getDefs ms ds t++instance (GetDefs a, GetDefs b) => GetDefs (a,b) where+ {-# INLINE getDefs #-}+ getDefs ms ds ab = expand \ret -> case ab of (a,b) -> ret $ getDefs ms ds a <> getDefs ms ds b++instance GetDefs Telescope where+ getDefs ms ds = getDefs ms ds . telToList++-- no defs here+instance {-# OVERLAPPING #-} GetDefs String where+ getDefs _ _ _ = mempty
@@ -0,0 +1,106 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Syntax.Internal.Elim where++import Control.DeepSeq++import Agda.Syntax.Common+import Agda.Syntax.Position+import Agda.Syntax.Abstract.Name++import Agda.Syntax.Common.Pretty+import Agda.Utils.Empty+import Agda.Utils.Maybe+import Agda.Utils.Tuple+import Agda.Utils.Impossible++-- | Eliminations, subsuming applications and projections.+--+data Elim' a+ = Apply {-# UNPACK #-} !(Arg a) -- ^ Application.+ | Proj ProjOrigin QName -- ^ Projection. 'QName' is name of a record projection.+ | IApply a a a -- ^ IApply x y r, x and y are the endpoints+ deriving (Show, Functor, Foldable, Traversable)++-- | This instance cheats on 'Proj', use with care.+-- 'Proj's are always assumed to be 'UserWritten', since they have no 'ArgInfo'.+-- Same for IApply+instance LensOrigin (Elim' a) where+ getOrigin (Apply a) = getOrigin a+ getOrigin Proj{} = UserWritten+ getOrigin IApply{} = UserWritten+ mapOrigin f (Apply a) = Apply $ mapOrigin f a+ mapOrigin f e@Proj{} = e+ mapOrigin f e@IApply{} = e++{-# INLINE isApplyElim #-}+-- | Drop 'Apply' constructor. (Safe)+isApplyElim :: Elim' a -> Maybe (Arg a)+isApplyElim (Apply u) = Just u+isApplyElim Proj{} = Nothing+isApplyElim (IApply _ _ r) = Just $! defaultArg r++{-# INLINE mustApplyElim #-}+-- | Drop 'Apply' constructor, fails with @__IMPOSSIBLE__@ on a projection.+mustApplyElim :: Elim' a -> Arg a+mustApplyElim (Apply u) = u+mustApplyElim Proj{} = __IMPOSSIBLE__+mustApplyElim (IApply _ _ r) = defaultArg r++isApplyElim' :: Empty -> Elim' a -> Arg a+isApplyElim' e = fromMaybe (absurd e) . isApplyElim++-- | Only 'Apply' variant.+isProperApplyElim :: Elim' a -> Bool+isProperApplyElim = \case+ Apply _ -> True+ IApply{} -> False+ Proj{} -> False++-- | Drop 'Apply' constructors. (Safe)+allApplyElims :: [Elim' a] -> Maybe [Arg a]+allApplyElims = mapM isApplyElim++-- | Drop 'Apply' constructors, fails with @__IMPOSSIBLE__@ if there's+-- a non-'Apply' entry.+mustAllApplyElims :: [Elim' a] -> [Arg a]+mustAllApplyElims [] = []+mustAllApplyElims (a:as) = case a of+ Apply a -> (a :) $! mustAllApplyElims as+ Proj{} -> __IMPOSSIBLE__+ IApply _ _ r -> let !a = defaultArg r in (a :) $! mustAllApplyElims as++-- | Split at first non-'Apply'+splitApplyElims :: [Elim' a] -> ([Arg a], [Elim' a])+splitApplyElims (Apply u : es) = first (u :) $! splitApplyElims es+splitApplyElims es = ([], es)++class IsProjElim e where+ isProjElim :: e -> Maybe (ProjOrigin, QName)++instance IsProjElim (Elim' a) where+ isProjElim (Proj o d) = Just (o, d)+ isProjElim Apply{} = Nothing+ isProjElim IApply{} = Nothing++-- | Discards @Proj f@ entries.+argsFromElims :: [Elim' t] -> [Arg t]+argsFromElims = mapMaybe isApplyElim++-- | Drop 'Proj' constructors. (Safe)+allProjElims :: [Elim' t] -> Maybe [(ProjOrigin, QName)]+allProjElims = mapM isProjElim++instance KillRange a => KillRange (Elim' a) where+ killRange = fmap killRange++instance Pretty tm => Pretty (Elim' tm) where+ prettyPrec p (Apply v) = prettyPrec p v+ prettyPrec _ (Proj _o x) = text ("." ++ prettyShow x)+ prettyPrec p (IApply x y r) = prettyPrec p r+-- prettyPrec p (IApply x y r) = text "@[" <> prettyPrec 0 x <> text ", " <> prettyPrec 0 y <> text "]" <> prettyPrec p r++instance NFData a => NFData (Elim' a) where+ rnf (Apply x) = rnf x+ rnf Proj{} = ()+ rnf (IApply x y r) = rnf x `seq` rnf y `seq` rnf r
@@ -1,117 +1,177 @@-{-# LANGUAGE CPP #-} +-- | Tree traversal for internal syntax.+ module Agda.Syntax.Internal.Generic where -import Control.Applicative-import Data.Traversable-import Data.Monoid-import Data.Foldable import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Utils.Functor+import Agda.Utils.List1 (List1) -#include "../../undefined.h"-import Agda.Utils.Impossible+-- | Generic term traversal.+--+-- Note: ignores sorts in terms!+-- (Does not traverse into or collect from them.) class TermLike a where- traverseTerm :: (Term -> Term) -> a -> a- traverseTermM :: (Monad m, Applicative m) => (Term -> m Term) -> a -> m a- foldTerm :: Monoid m => (Term -> m) -> a -> m -instance TermLike a => TermLike (Arg a) where- traverseTerm f = fmap (traverseTerm f)- traverseTermM f = traverse (traverseTermM f)- foldTerm f = foldMap (foldTerm f)+ -- | Generic traversal with post-traversal action.+ -- Ignores sorts.+ traverseTermM :: Monad m => (Term -> m Term) -> a -> m a -instance TermLike a => TermLike [a] where- traverseTerm f = fmap (traverseTerm f)- traverseTermM f = traverse (traverseTermM f)- foldTerm f = foldMap (foldTerm f)+ default traverseTermM :: (Monad m, Traversable f, TermLike b, f b ~ a)+ => (Term -> m Term) -> a -> m a+ traverseTermM = traverse . traverseTermM -instance TermLike a => TermLike (Maybe a) where- traverseTerm f = fmap (traverseTerm f)- traverseTermM f = traverse (traverseTermM f)- foldTerm f = foldMap (foldTerm f)+ -- | Generic fold, ignoring sorts.+ foldTerm :: Monoid m => (Term -> m) -> a -> m + default foldTerm+ :: (Monoid m, Foldable f, TermLike b, f b ~ a) => (Term -> m) -> a -> m+ foldTerm = foldMap . foldTerm++-- Constants++instance TermLike Bool where+ traverseTermM _ = pure+ foldTerm _ = mempty++instance TermLike Int where+ traverseTermM _ = pure+ foldTerm _ = mempty++instance TermLike Integer where+ traverseTermM _ = pure+ foldTerm _ = mempty++instance TermLike Char where+ traverseTermM _ = pure+ foldTerm _ = mempty++instance TermLike QName where+ traverseTermM _ = pure+ foldTerm _ = mempty++-- Functors++instance TermLike a => TermLike (Elim' a) where+instance TermLike a => TermLike (Arg a) where+instance (TermLike a, TermLike b) => TermLike (Dom' a b) where+instance TermLike a => TermLike [a] where+instance TermLike a => TermLike (List1 a) where+instance TermLike a => TermLike (Maybe a) where+instance TermLike a => TermLike (Blocked a) where+instance TermLike a => TermLike (Abs a) where+instance TermLike a => TermLike (Tele a) where+instance TermLike a => TermLike (WithHiding a) where+instance TermLike a => TermLike (BlockedDepCheck a) where++-- Tuples+ instance (TermLike a, TermLike b) => TermLike (a, b) where- traverseTerm f (x, y) = (traverseTerm f x, traverseTerm f y) traverseTermM f (x, y) = (,) <$> traverseTermM f x <*> traverseTermM f y foldTerm f (x, y) = foldTerm f x `mappend` foldTerm f y -instance TermLike a => TermLike (Abs a) where- traverseTerm f = fmap (traverseTerm f)- traverseTermM f = traverse (traverseTermM f)- foldTerm f = foldMap (foldTerm f)+instance (TermLike a, TermLike b, TermLike c) => TermLike (a, b, c) where+ traverseTermM f (x, y, z) = (,,) <$> traverseTermM f x <*> traverseTermM f y <*> traverseTermM f z+ foldTerm f (x, y, z) = mconcat [foldTerm f x, foldTerm f y, foldTerm f z] +instance (TermLike a, TermLike b, TermLike c, TermLike d) => TermLike (a, b, c, d) where+ traverseTermM f (x, y, z, u) = (,,,) <$> traverseTermM f x <*> traverseTermM f y <*> traverseTermM f z <*> traverseTermM f u+ foldTerm f (x, y, z, u) = mconcat [foldTerm f x, foldTerm f y, foldTerm f z, foldTerm f u]++-- Real terms+ instance TermLike Term where- traverseTerm f t = case t of- Var i xs -> f $ Var i $ traverseTerm f xs- Def c xs -> f $ Def c $ traverseTerm f xs- Con c xs -> f $ Con c $ traverseTerm f xs- Lam h b -> f $ Lam h $ traverseTerm f b- Pi a b -> f $ uncurry Pi $ traverseTerm f (a, b)- MetaV m xs -> f $ MetaV m $ traverseTerm f xs- Level l -> f $ Level $ traverseTerm f l- Lit _ -> f t- Sort _ -> f t- DontCare mv -> f $ DontCare $ traverseTerm f mv - traverseTermM f t = case t of+ traverseTermM f = \case Var i xs -> f =<< Var i <$> traverseTermM f xs Def c xs -> f =<< Def c <$> traverseTermM f xs- Con c xs -> f =<< Con c <$> traverseTermM f xs+ Con c ci xs -> f =<< Con c ci <$> traverseTermM f xs Lam h b -> f =<< Lam h <$> traverseTermM f b Pi a b -> f =<< uncurry Pi <$> traverseTermM f (a, b) MetaV m xs -> f =<< MetaV m <$> traverseTermM f xs Level l -> f =<< Level <$> traverseTermM f l- Lit _ -> f t- Sort _ -> f t+ t@Lit{} -> f t+ Sort s -> f =<< Sort <$> traverseTermM f s DontCare mv -> f =<< DontCare <$> traverseTermM f mv+ Dummy s xs -> f =<< Dummy s <$> traverseTermM f xs foldTerm f t = f t `mappend` case t of Var i xs -> foldTerm f xs Def c xs -> foldTerm f xs- Con c xs -> foldTerm f xs+ Con c ci xs -> foldTerm f xs Lam h b -> foldTerm f b Pi a b -> foldTerm f (a, b) MetaV m xs -> foldTerm f xs Level l -> foldTerm f l Lit _ -> mempty- Sort _ -> mempty+ Sort s -> foldTerm f s DontCare mv -> foldTerm f mv+ Dummy _ xs -> foldTerm f xs instance TermLike Level where- traverseTerm f (Max as) = Max $ traverseTerm f as- traverseTermM f (Max as) = Max <$> traverseTermM f as- foldTerm f (Max as) = foldTerm f as+ traverseTermM f (Max n as) = Max n <$> traverseTermM f as+ foldTerm f (Max n as) = foldTerm f as instance TermLike PlusLevel where- traverseTerm f l = case l of- ClosedLevel{} -> l- Plus n l -> Plus n $ traverseTerm f l- traverseTermM f l = case l of- ClosedLevel{} -> return l- Plus n l -> Plus n <$> traverseTermM f l- foldTerm f ClosedLevel{} = mempty- foldTerm f (Plus _ l) = foldTerm f l--instance TermLike LevelAtom where- traverseTerm f l = case l of- MetaLevel m vs -> MetaLevel m $ traverseTerm f vs- NeutralLevel v -> NeutralLevel $ traverseTerm f v- BlockedLevel m v -> BlockedLevel m $ traverseTerm f v- UnreducedLevel v -> UnreducedLevel $ traverseTerm f v- traverseTermM f l = case l of- MetaLevel m vs -> MetaLevel m <$> traverseTermM f vs- NeutralLevel v -> NeutralLevel <$> traverseTermM f v- BlockedLevel m v -> BlockedLevel m <$> traverseTermM f v- UnreducedLevel v -> UnreducedLevel <$> traverseTermM f v- foldTerm f l = case l of- MetaLevel m vs -> foldTerm f vs- NeutralLevel v -> foldTerm f v- BlockedLevel _ v -> foldTerm f v- UnreducedLevel v -> foldTerm f v+ traverseTermM f (Plus n l) = Plus n <$> traverseTermM f l+ foldTerm f (Plus _ l) = foldTerm f l -instance TermLike Type where- traverseTerm f (El s t) = El s $ traverseTerm f t+instance (TermLike b) => TermLike (Type'' a b) where traverseTermM f (El s t) = El s <$> traverseTermM f t foldTerm f (El s t) = foldTerm f t++instance TermLike Sort where+ traverseTermM f = \case+ Univ u l -> Univ u <$> traverseTermM f l+ s@(Inf _ _)-> pure s+ s@SizeUniv -> pure s+ s@LockUniv -> pure s+ s@LevelUniv -> pure s+ s@IntervalUniv -> pure s+ PiSort a b c d -> PiSort <$>+ traverseTermM f a <*> traverseTermM f b <*>+ traverseTermM f c <*> traverseTermM f d+ FunSort a b -> FunSort <$> traverseTermM f a <*> traverseTermM f b+ UnivSort a -> UnivSort <$> traverseTermM f a+ MetaS x es -> MetaS x <$> traverseTermM f es+ DefS q es -> DefS q <$> traverseTermM f es+ s@(DummyS _) -> pure s++ foldTerm f = \case+ Univ _ l -> foldTerm f l+ Inf _ _ -> mempty+ SizeUniv -> mempty+ LockUniv -> mempty+ LevelUniv -> mempty+ IntervalUniv -> mempty+ PiSort a b c d ->+ foldTerm f a <> foldTerm f b <> foldTerm f c <> foldTerm f d+ FunSort a b -> foldTerm f a <> foldTerm f b+ UnivSort a -> foldTerm f a+ MetaS _ es -> foldTerm f es+ DefS _ es -> foldTerm f es+ DummyS _ -> mempty++instance TermLike EqualityView where++ traverseTermM f = \case+ OtherType t -> OtherType+ <$> traverseTermM f t+ IdiomType t -> IdiomType+ <$> traverseTermM f t+ EqualityType r s eq l t a b -> EqualityType r s eq+ <$> traverse (traverseTermM f) l+ <*> traverseTermM f t+ <*> traverseTermM f a+ <*> traverseTermM f b++ foldTerm f = \case+ OtherType t -> foldTerm f t+ IdiomType t -> foldTerm f t+ EqualityType _r _s _eq l t a b -> foldTerm f (l ++ [t, a, b])++-- | Put it in a monad to make it possible to do strictly.+copyTerm :: (TermLike a, Monad m) => a -> m a+copyTerm = traverseTermM return
@@ -0,0 +1,109 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Syntax.Internal.MetaVars where++import Data.Monoid+import qualified Data.Set as Set++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Generic++import Agda.Utils.Singleton++-- | Returns every meta-variable occurrence in the given type, except+-- for those in sort annotations on types.+class AllMetas t where+ allMetas :: Monoid m => (MetaId -> m) -> t -> m++ default allMetas :: (TermLike t, Monoid m) => (MetaId -> m) -> t -> m+ allMetas = allMetas'++-- Default instances+instance AllMetas Term+instance (TermLike a, TermLike b) => AllMetas (Type'' a b)+instance TermLike a => AllMetas (Elim' a)+instance TermLike a => AllMetas (Tele a)++instance (TermLike a, AllMetas a, AllMetas b) => AllMetas (Dom' a b) where+ allMetas f (Dom _ _ _ t r e) = allMetas f t <> allMetas f r <> allMetas f e++-- These types need to be packed up as a Term to get the metas.+instance AllMetas Sort where allMetas f = allMetas f . Sort+instance AllMetas Level where allMetas f = allMetas f . Level+instance AllMetas PlusLevel where allMetas f l = allMetas f (Max 0 [l])++instance (TermLike a, AllMetas a) => AllMetas (RewDom' a) where+ allMetas f (RewDom a b) = allMetas f (a, b)++instance (TermLike a, AllMetas a) => AllMetas (LocalEquation' a) where+ allMetas f (LocalEquation a b c d) = allMetas f (a, b, c, d)++instance AllMetas RewriteRule where+ allMetas f (RewriteRule g _ _ es b) = allMetas f (g, es, b)++instance {-# OVERLAPPING #-} AllMetas String where+ allMetas f _ = mempty++-- Generic instances+instance (AllMetas a, AllMetas b) => AllMetas (a, b) where+ allMetas f (x, y) = allMetas f x <> allMetas f y++instance (AllMetas a, AllMetas b, AllMetas c) => AllMetas (a, b, c) where+ allMetas f (x, y, z) = allMetas f (x, (y, z))++instance (AllMetas a, AllMetas b, AllMetas c, AllMetas d) => AllMetas (a, b, c, d) where+ allMetas f (x, y, z, w) = allMetas f (x, (y, (z, w)))++instance AllMetas a => AllMetas [a] where allMetas f xs = foldMap (allMetas f) xs+instance AllMetas a => AllMetas (Maybe a) where allMetas f xs = foldMap (allMetas f) xs+instance AllMetas a => AllMetas (Arg a) where allMetas f xs = foldMap (allMetas f) xs++allMetas' :: (TermLike a, Monoid m) => (MetaId -> m) -> a -> m+allMetas' singl = foldTerm metas+ where+ metas (MetaV m _) = singl m+ metas (Sort s) = sortMetas s+ metas _ = mempty++ sortMetas Univ{} = mempty+ sortMetas Inf{} = mempty+ sortMetas SizeUniv{} = mempty+ sortMetas LockUniv{} = mempty+ sortMetas LevelUniv = mempty+ sortMetas IntervalUniv{} = mempty+ sortMetas (PiSort c _ s1 s2) =+ -- the domain is a term so is covered by the fold+ foldMap sortMetas c <> sortMetas s1 <> sortMetas (unAbs s2)+ sortMetas (FunSort a b) = sortMetas a <> sortMetas b+ sortMetas (UnivSort s) = sortMetas s+ sortMetas (MetaS x _) = singl x+ sortMetas DefS{} = mempty+ sortMetas DummyS{} = mempty++-- | Returns 'allMetas' in a list.+-- @allMetasList = allMetas (:[])@.+--+-- Note: this resulting list is computed via difference lists.+-- Thus, use this function if you actually need the whole list of metas.+-- Otherwise, use 'allMetas' with a suitable monoid.+allMetasList :: AllMetas a => a -> [MetaId]+allMetasList t = allMetas singleton t `appEndo` []++-- | 'True' if thing contains no metas.+-- @noMetas = null . allMetasList@.+noMetas :: AllMetas a => a -> Bool+noMetas = getAll . allMetas (\ _m -> All False)++-- | Returns the first meta it find in the thing, if any.+-- @firstMeta == listToMaybe . allMetasList@.+firstMeta :: AllMetas a => a -> Maybe MetaId+firstMeta = getFirst . allMetas (First . Just)++-- | A blocker that unblocks if any of the metas in a term are solved.+unblockOnAnyMetaIn :: AllMetas t => t -> Blocker+unblockOnAnyMetaIn t = unblockOnAnyMeta $ allMetas Set.singleton t++-- | A blocker that unblocks if any of the metas in a term are solved.+unblockOnAllMetasIn :: AllMetas t => t -> Blocker+unblockOnAllMetasIn t = unblockOnAllMetas $ allMetas Set.singleton t
@@ -0,0 +1,432 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Extract all names and meta-variables from things.++module Agda.Syntax.Internal.Names where++import Data.HashMap.Strict (HashMap)+import Data.Map (Map)+import Data.Set (Set)++import Agda.Syntax.Common+import Agda.Syntax.Literal+import Agda.Syntax.Internal+import Agda.Syntax.Concrete qualified as C+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Abstract (PatternSynDefn(..))+import Agda.Syntax.Treeless++import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.CompiledClause++import Agda.Utils.List1 (List1)+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Singleton+import Agda.Utils.Impossible++-- | Some or all of the 'QName's that can be found in the given thing.++namesIn :: (NamesIn a, Collection QName m) => a -> m+namesIn = namesIn' singleton++-- | Some or all of the 'QName's that can be found in the given thing.++namesIn' :: (NamesIn a, Monoid m) => (QName -> m) -> a -> m+namesIn' f = namesAndMetasIn' (either f mempty)++-- | Some or all of the meta-variables that can be found in the given+-- thing.++metasIn :: (NamesIn a, Collection MetaId m) => a -> m+metasIn = metasIn' singleton++-- | Some or all of the meta-variables that can be found in the given+-- thing.++-- TODO: Does this function make+-- Agda.Syntax.Internal.MetaVars.allMetas superfluous? Maybe not,+-- allMetas ignores the first argument of PiSort.++metasIn' :: (NamesIn a, Monoid m) => (MetaId -> m) -> a -> m+metasIn' f = namesAndMetasIn' (either mempty f)++-- | Some or all of the names and meta-variables that can be found in+-- the given thing.++namesAndMetasIn ::+ (NamesIn a, Collection QName m1, Collection MetaId m2) =>+ a -> (m1, m2)+namesAndMetasIn =+ namesAndMetasIn'+ (either (\x -> (singleton x, mempty))+ (\m -> (mempty, singleton m)))++class NamesIn a where+ -- | Some or all of the names and meta-variables that can be found+ -- in the given thing.+ namesAndMetasIn' :: Monoid m => (Either QName MetaId -> m) -> a -> m++ default namesAndMetasIn' ::+ (Monoid m, Foldable f, NamesIn b, f b ~ a) =>+ (Either QName MetaId -> m) -> a -> m+ namesAndMetasIn' = foldMap . namesAndMetasIn'++-- Generic collections+instance NamesIn a => NamesIn (Maybe a)+instance NamesIn a => NamesIn (Strict.Maybe a)+instance NamesIn a => NamesIn [a]+instance NamesIn a => NamesIn (List1 a)+instance NamesIn a => NamesIn (Set a)+instance NamesIn a => NamesIn (Map k a)++-- Decorations+instance NamesIn a => NamesIn (Arg a)+instance NamesIn a => NamesIn (Named n a)+instance NamesIn a => NamesIn (Abs a)+instance NamesIn a => NamesIn (WithArity a)+instance NamesIn a => NamesIn (Open a)+instance NamesIn a => NamesIn (C.FieldAssignment' a)+instance NamesIn a => NamesIn (BlockedDepCheck a)++instance (NamesIn a, NamesIn b) => NamesIn (Dom' a b) where+ namesAndMetasIn' sg (Dom _ _ _ t r e) =+ namesAndMetasIn' sg (t, r, e)++-- Specific collections+instance NamesIn a => NamesIn (Tele a)++-- Tuples++instance (NamesIn a, NamesIn b) => NamesIn (a, b) where+ namesAndMetasIn' sg (x, y) =+ namesAndMetasIn' sg x <> namesAndMetasIn' sg y+ {-# INLINE namesAndMetasIn' #-}++instance (NamesIn a, NamesIn b, NamesIn c) => NamesIn (a, b, c) where+ namesAndMetasIn' sg (x, y, z) =+ namesAndMetasIn' sg x <> namesAndMetasIn' sg y <> namesAndMetasIn' sg z+ {-# INLINE namesAndMetasIn' #-}++instance (NamesIn a, NamesIn b, NamesIn c, NamesIn d) => NamesIn (a, b, c, d) where+ namesAndMetasIn' sg (x, y, z, u) =+ namesAndMetasIn' sg x <> namesAndMetasIn' sg y <> namesAndMetasIn' sg z <> namesAndMetasIn' sg u+ {-# INLINE namesAndMetasIn' #-}++instance+ (NamesIn a, NamesIn b, NamesIn c, NamesIn d, NamesIn e) =>+ NamesIn (a, b, c, d, e) where+ namesAndMetasIn' sg (x, y, z, u, v) =+ namesAndMetasIn' sg x <> namesAndMetasIn' sg y <> namesAndMetasIn' sg z <> namesAndMetasIn' sg u+ <> namesAndMetasIn' sg v+ {-# INLINE namesAndMetasIn' #-}++instance+ (NamesIn a, NamesIn b, NamesIn c, NamesIn d, NamesIn e, NamesIn f) =>+ NamesIn (a, b, c, d, e, f) where+ namesAndMetasIn' sg (x, y, z, u, v, w) =+ namesAndMetasIn' sg x <> namesAndMetasIn' sg y <> namesAndMetasIn' sg z <> namesAndMetasIn' sg u+ <> namesAndMetasIn' sg v <> namesAndMetasIn' sg w+ {-# INLINE namesAndMetasIn' #-}++instance NamesIn CompKit where+ namesAndMetasIn' sg (CompKit a b) = namesAndMetasIn' sg (a,b)++-- Base cases++instance NamesIn QName where+ namesAndMetasIn' sg x = sg (Left x) -- interesting case!++instance NamesIn MetaId where+ namesAndMetasIn' sg x = sg (Right x)++instance NamesIn ConHead where+ namesAndMetasIn' sg h = namesAndMetasIn' sg (conName h)++instance NamesIn Bool where+ namesAndMetasIn' _ _ = mempty++instance NamesIn Int where+ namesAndMetasIn' _ _ = mempty++-- Andreas, 2017-07-27+-- In the following clauses, the choice of fields is not obvious+-- to the reader. Please comment on the choices.++instance NamesIn Definition where+ namesAndMetasIn' sg+ (Defn _ _ t _ _ _ disp _ _ _ _ _ _ _ _ _ _ _ def) =+ namesAndMetasIn' sg (t, def, disp)++instance NamesIn Defn where+ namesAndMetasIn' sg = \case+ Axiom _ -> mempty+ DataOrRecSig _ _ -> mempty+ GeneralizableVar _ -> mempty+ PrimitiveSort _ s -> namesAndMetasIn' sg s+ AbstractDefn{} -> __IMPOSSIBLE__+ -- Andreas 2017-07-27, Q: which names can be in @cc@ which are not already in @cl@?+ Function cl cc _ _ _ _ _ prj _ _ el _ _ _+ -- Andreas, 2025-11-18, issue #8037+ -- When copying the record type along with one of its projections in a module application,+ -- we need to make sure the record type has not been deleted as deadcode.+ -> namesAndMetasIn' sg (cl, cc, el, prj)+ Datatype _ _ cl cs s _ _ _ _ trX trD+ -> namesAndMetasIn' sg (cl, cs, s, trX, trD)+ Record _ cl c _ fs recTel _ _ _ _ _ _ _ comp+ -> namesAndMetasIn' sg (cl, c, fs, recTel, comp)+ Constructor _ _ c d _ _ kit fs _ _ _ _+ -> namesAndMetasIn' sg (c, d, kit, fs)+ Primitive _ _ cl _ cc _+ -> namesAndMetasIn' sg (cl, cc)++instance NamesIn Clause where+ namesAndMetasIn' sg (Clause _ _ tel ps b t _ _ _ _ _) =+ namesAndMetasIn' sg (tel, ps, b, t)++instance NamesIn ProjectionLikenessMissing where+ {-# INLINE namesAndMetasIn' #-}+ namesAndMetasIn' _ = mempty++instance NamesIn Projection where+ {-# INLINE namesAndMetasIn' #-}+ namesAndMetasIn' sg p = namesAndMetasIn' sg (projProper p)++instance (NamesIn a, NamesIn b) => NamesIn (Either a b) where+ {-# INLINE namesAndMetasIn' #-}+ namesAndMetasIn' sg = \case+ Left a -> namesAndMetasIn' sg a+ Right b -> namesAndMetasIn' sg b++instance NamesIn CompiledClauses where+ namesAndMetasIn' sg = \case+ Case _ c -> namesAndMetasIn' sg c+ Done _ _ _ v -> namesAndMetasIn' sg v+ Fail _ -> mempty++-- Andreas, 2017-07-27+-- Why ignoring the litBranches?+instance NamesIn a => NamesIn (Case a) where+ namesAndMetasIn' sg (Branches _ bs _ _ c _ _) =+ namesAndMetasIn' sg (bs, c)++instance NamesIn (Pattern' a) where+ namesAndMetasIn' sg = \case+ VarP _ _ -> mempty+ LitP _ l -> namesAndMetasIn' sg l+ DotP _ v -> namesAndMetasIn' sg v+ ConP c cpi args -> namesAndMetasIn' sg (c, cpi, args)+ DefP o q args -> namesAndMetasIn' sg (q, args)+ ProjP _ f -> namesAndMetasIn' sg f+ IApplyP _ t u _ -> namesAndMetasIn' sg (t, u)++instance (NamesIn a, NamesIn b) => NamesIn (Type'' a b) where+ namesAndMetasIn' sg (El s t) = namesAndMetasIn' sg (s, t)++instance NamesIn a => NamesIn (Sort' a) where+ namesAndMetasIn' sg = \case+ Univ _ l -> namesAndMetasIn' sg l+ Inf _ _ -> mempty+ SizeUniv -> mempty+ LockUniv -> mempty+ LevelUniv -> mempty+ IntervalUniv -> mempty+ PiSort a b c d -> namesAndMetasIn' sg (a, b, c, d)+ FunSort a b -> namesAndMetasIn' sg (a, b)+ UnivSort a -> namesAndMetasIn' sg a+ MetaS x es -> namesAndMetasIn' sg (x, es)+ DefS d es -> namesAndMetasIn' sg (d, es)+ DummyS _ -> mempty++instance NamesIn Term where+ namesAndMetasIn' sg = \case+ Var _ args -> namesAndMetasIn' sg args+ Lam _ b -> namesAndMetasIn' sg b+ Lit l -> namesAndMetasIn' sg l+ Def f args -> namesAndMetasIn' sg (f, args)+ Con c _ args -> namesAndMetasIn' sg (c, args)+ Pi a b -> namesAndMetasIn' sg (a, b)+ Sort s -> namesAndMetasIn' sg s+ Level l -> namesAndMetasIn' sg l+ MetaV x args -> namesAndMetasIn' sg (x, args)+ DontCare v -> namesAndMetasIn' sg v+ Dummy _ args -> namesAndMetasIn' sg args++instance NamesIn a => NamesIn (Level' a) where+ namesAndMetasIn' sg (Max _ ls) = namesAndMetasIn' sg ls++instance NamesIn a => NamesIn (PlusLevel' a) where+ namesAndMetasIn' sg (Plus _ l) = namesAndMetasIn' sg l++-- For QName and Meta literals!+instance NamesIn Literal where+ namesAndMetasIn' sg = \case+ LitNat _ -> mempty+ LitWord64 _ -> mempty+ LitString _ -> mempty+ LitChar _ -> mempty+ LitFloat _ -> mempty+ LitQName x -> namesAndMetasIn' sg x+ LitMeta _ m -> namesAndMetasIn' sg m++instance NamesIn a => NamesIn (Elim' a) where+ namesAndMetasIn' sg (Apply arg) = namesAndMetasIn' sg arg+ namesAndMetasIn' sg (Proj _ f) = namesAndMetasIn' sg f+ namesAndMetasIn' sg (IApply x y arg) = namesAndMetasIn' sg (x, y, arg)++instance NamesIn a => NamesIn (Substitution' a) where+ namesAndMetasIn' sg = \case+ IdS -> mempty+ EmptyS _ -> mempty+ t :# s -> namesAndMetasIn' sg (t, s)+ Strengthen _ _ s -> namesAndMetasIn' sg s+ Wk _ s -> namesAndMetasIn' sg s+ Lift _ s -> namesAndMetasIn' sg s++instance NamesIn DisplayForm where+ namesAndMetasIn' sg (Display _ ps v) = namesAndMetasIn' sg (ps, v)++instance NamesIn DisplayTerm where+ namesAndMetasIn' sg = \case+ DWithApp v us es -> namesAndMetasIn' sg (v, us, es)+ DCon c _ vs -> namesAndMetasIn' sg (c, vs)+ DDef f es -> namesAndMetasIn' sg (f, es)+ DDot' v es -> namesAndMetasIn' sg (v, es)+ DTerm' v es -> namesAndMetasIn' sg (v, es)++instance NamesIn a => NamesIn (Builtin a) where+ namesAndMetasIn' sg = \case+ Builtin t -> namesAndMetasIn' sg t+ Prim x -> namesAndMetasIn' sg x+ BuiltinRewriteRelations xs -> namesAndMetasIn' sg xs++-- | Note that the 'primFunImplementation' is skipped.+instance NamesIn PrimFun where+ namesAndMetasIn' sg = \case+ PrimFun x _ _ _ -> namesAndMetasIn' sg x++instance NamesIn Section where+ namesAndMetasIn' sg = \case+ Section tel -> namesAndMetasIn' sg tel++instance NamesIn NLPat where+ namesAndMetasIn' sg = \case+ PVar _ _ _ -> mempty+ PDef a b -> namesAndMetasIn' sg (a, b)+ PLam _ a -> namesAndMetasIn' sg a+ PPi a b -> namesAndMetasIn' sg (a, b)+ PSort a -> namesAndMetasIn' sg a+ PBoundVar _ a -> namesAndMetasIn' sg a+ PTerm a -> namesAndMetasIn' sg a++instance NamesIn NLPType where+ namesAndMetasIn' sg = \case+ NLPType a b -> namesAndMetasIn' sg (a, b)++instance NamesIn NLPSort where+ namesAndMetasIn' sg = \case+ PUniv _ a -> namesAndMetasIn' sg a+ PInf _ _ -> mempty+ PSizeUniv -> mempty+ PLockUniv -> mempty+ PLevelUniv -> mempty+ PIntervalUniv -> mempty++instance NamesIn GlobalRewriteRule where+ namesAndMetasIn' sg = \case+ GlobalRewriteRule a b c d e f _ _ ->+ namesAndMetasIn' sg (a, b, c, d, e, f)++instance NamesIn a => NamesIn (LocalEquation' a) where+ namesAndMetasIn' sg (LocalEquation a b c d) = namesAndMetasIn' sg (a, b, c, d)++instance NamesIn RewriteHead where+ namesAndMetasIn' sg (RewVarHead a) = namesAndMetasIn' sg a+ namesAndMetasIn' sg (RewDefHead a) = namesAndMetasIn' sg a++instance NamesIn RewriteRule where+ namesAndMetasIn' sg (RewriteRule a b c d e) =+ namesAndMetasIn' sg (a, b, c, d, e)++instance NamesIn a => NamesIn (RewDom' a) where+ namesAndMetasIn' sg (RewDom a b) =+ namesAndMetasIn' sg (a, b)++instance (NamesIn b) => NamesIn (HashMap a b) where+ namesAndMetasIn' sg map = foldMap (namesAndMetasIn' sg) map++instance NamesIn System where+ namesAndMetasIn' sg (System tel cs) = namesAndMetasIn' sg (tel, cs)++instance NamesIn ExtLamInfo where+ namesAndMetasIn' sg (ExtLamInfo _ _ s) = namesAndMetasIn' sg s++instance NamesIn a => NamesIn (FunctionInverse' a) where+ namesAndMetasIn' sg = \case+ NotInjective -> mempty+ Inverse m -> namesAndMetasIn' sg m++instance NamesIn TTerm where+ namesAndMetasIn' sg = \case+ TVar _ -> mempty+ TPrim _ -> mempty+ TDef x -> namesAndMetasIn' sg x+ TApp t xs -> namesAndMetasIn' sg (t, xs)+ TLam t -> namesAndMetasIn' sg t+ TLit l -> namesAndMetasIn' sg l+ TCon x -> namesAndMetasIn' sg x+ TLet _ t1 t2 -> namesAndMetasIn' sg (t1, t2)+ TCase _ c t ts -> namesAndMetasIn' sg (c, t, ts)+ TUnit -> mempty+ TSort -> mempty+ TErased -> mempty+ TCoerce t -> namesAndMetasIn' sg t+ TError _ -> mempty++instance NamesIn TAlt where+ namesAndMetasIn' sg = \case+ TACon x _ t -> namesAndMetasIn' sg (x, t)+ TAGuard t1 t2 -> namesAndMetasIn' sg (t1, t2)+ TALit l t -> namesAndMetasIn' sg (l, t)++instance NamesIn CaseType where+ namesAndMetasIn' sg = \case+ CTData x -> namesAndMetasIn' sg x+ CTNat -> mempty+ CTInt -> mempty+ CTChar -> mempty+ CTString -> mempty+ CTFloat -> mempty+ CTQName -> mempty++instance NamesIn CaseInfo where+ namesAndMetasIn' sg (CaseInfo _ _ _ t) = namesAndMetasIn' sg t++instance NamesIn Compiled where+ namesAndMetasIn' sg (Compiled t _) = namesAndMetasIn' sg t++-- Pattern synonym stuff --++instance NamesIn PatternSynDefn where+ namesAndMetasIn' sg (PatternSynDefn _args p) = namesAndMetasIn' sg p++instance NamesIn ConPatternInfo where+ namesAndMetasIn' sg (ConPatternInfo _ _ _ ty _ _) = namesAndMetasIn' sg ty++instance NamesIn (A.Pattern' a) where+ namesAndMetasIn' sg = \case+ A.VarP _ -> mempty+ A.ConP _ c args -> namesAndMetasIn' sg (c, args)+ A.ProjP _ _ d -> namesAndMetasIn' sg d+ A.DefP _ f args -> namesAndMetasIn' sg (f, args)+ A.WildP _ -> mempty+ A.AsP _ _ p -> namesAndMetasIn' sg p+ A.AbsurdP _ -> mempty+ A.LitP _ l -> namesAndMetasIn' sg l+ A.PatternSynP _ c args -> namesAndMetasIn' sg (c, args)+ A.RecP _ _ fs -> namesAndMetasIn' sg fs+ A.DotP{} -> __IMPOSSIBLE__ -- Dot patterns are not allowed in pattern synonyms+ A.EqualP{} -> __IMPOSSIBLE__ -- Andrea: should we allow these in pattern synonyms?+ A.WithP _ p -> namesAndMetasIn' sg p++instance NamesIn AmbiguousQName where+ namesAndMetasIn' sg = namesAndMetasIn' sg . getAmbiguous
@@ -1,42 +1,370 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Syntax.Internal.Pattern where +import Control.Monad ( (>=>), forM )+import Control.Monad.State ( MonadState(..), State, evalState )++import Data.Maybe+import Data.Monoid+import qualified Data.List as List+ import Agda.Syntax.Common import Agda.Syntax.Internal-import Agda.Utils.Tuple -data OneHolePatterns = OHPats [Arg Pattern] (Arg OneHolePattern) [Arg Pattern]- deriving (Show)-data OneHolePattern = Hole- | OHCon QName (Maybe (Arg Type)) OneHolePatterns- -- ^ The type serves the same role as the type- -- argument to 'ConP'.- --- -- TODO: If a hole is plugged this type may- -- have to be updated in some way.- deriving (Show)+import Agda.Utils.List+import Agda.Utils.Permutation+import Agda.Utils.Size (size)+import Agda.Utils.Tuple ( second ) -plugHole :: Pattern -> OneHolePatterns -> [Arg Pattern]-plugHole p (OHPats ps hole qs) = ps ++ [fmap (plug p) hole] ++ qs+import Agda.Utils.Impossible++-- * Tools for clauses++-- | Translate the clause patterns to terms with free variables bound by the+-- clause telescope.+--+-- Precondition: no projection patterns.+clauseArgs :: Clause -> Args+clauseArgs cl = mustAllApplyElims $ clauseElims cl++-- | Translate the clause patterns to an elimination spine+-- with free variables bound by the clause telescope.+clauseElims :: Clause -> Elims+clauseElims cl = patternsToElims $ namedClausePats cl++-- | Arity of a function, computed from clauses.+class FunArity a where+ funArity :: a -> Int++-- | Get the number of initial 'Apply' patterns.++instance {-# OVERLAPPABLE #-} IsProjP p => FunArity [p] where+ funArity = length . takeWhile (isNothing . isProjP)++-- | Get the number of initial 'Apply' patterns in a clause.+instance FunArity Clause where+ funArity = funArity . namedClausePats++-- | Get the number of common initial 'Apply' patterns in a list of clauses.+instance {-# OVERLAPPING #-} FunArity [Clause] where+ funArity [] = 0+ funArity cls = minimum $ map' funArity cls++-- * Tools for patterns++-- | Label the pattern variables from left to right+-- using one label for each variable pattern and one for each dot pattern.+class LabelPatVars a b where+ type PatVarLabel b+ labelPatVars :: a -> State [PatVarLabel b] b+ unlabelPatVars :: b -> a+ -- ^ Intended, but unpractical due to the absence of type-level lambda, is:+ -- @labelPatVars :: f (Pattern' x) -> State [i] (f (Pattern' (i,x)))@++ default labelPatVars+ :: (Traversable f+ , LabelPatVars a' b'+ , PatVarLabel b ~ PatVarLabel b'+ , f a' ~ a, f b' ~ b)+ => a -> State [PatVarLabel b] b+ labelPatVars = traverse labelPatVars++ default unlabelPatVars+ :: (Traversable f, LabelPatVars a' b', f a' ~ a, f b' ~ b)+ => b -> a+ unlabelPatVars = fmap unlabelPatVars++instance LabelPatVars a b => LabelPatVars (Arg a) (Arg b) where+ type PatVarLabel (Arg b) = PatVarLabel b++instance LabelPatVars a b => LabelPatVars (Named x a) (Named x b) where+ type PatVarLabel (Named x b) = PatVarLabel b++instance LabelPatVars a b => LabelPatVars [a] [b] where+ type PatVarLabel [b] = PatVarLabel b++instance LabelPatVars Pattern DeBruijnPattern where+ type PatVarLabel DeBruijnPattern = Int++ labelPatVars = \case+ VarP o x -> VarP o . DBPatVar x <$> next+ DotP o t -> DotP o t <$ next+ ConP c mt ps -> ConP c mt <$> labelPatVars ps+ DefP o q ps -> DefP o q <$> labelPatVars ps+ LitP o l -> return $ LitP o l+ ProjP o q -> return $ ProjP o q+ IApplyP o u t x -> IApplyP o u t . DBPatVar x <$> next+ where+ next = caseListM get __IMPOSSIBLE__ $ \x xs -> do+ put xs+ return x+ unlabelPatVars = fmap dbPatVarName++-- | Augment pattern variables with their de Bruijn index.+{-# SPECIALIZE numberPatVars :: Int -> Permutation -> [NamedArg Pattern] -> [NamedArg DeBruijnPattern] #-}+--+-- Example:+-- @+-- f : (A : Set) (n : Nat) (v : Vec A n) -> ...+-- f A .(suc n) (cons n x xs)+--+-- clauseTel = (A : Set) (n : Nat) (x : A) (xs : Vec A n)+-- perm = Perm 5 [0,2,3,4]+-- invertP __IMPOSSIBLE__ perm = Perm 4 [0,__IMPOSSIBLE__,1,2,3]+-- flipP ... = Perm 4 [3,__IMPOSSIBLE__,2,1,0]+-- pats = A .(suc 2) (cons n x xs)+-- dBpats = 3 .(suc 2) (cons 2 1 0 )+-- @+--+numberPatVars :: (LabelPatVars a b, PatVarLabel b ~ Int) => Int -> Permutation -> a -> b+numberPatVars err perm ps = evalState (labelPatVars ps) $+ permPicks $ flipP $ invertP err perm++unnumberPatVars :: LabelPatVars a b => b -> a+unnumberPatVars = unlabelPatVars++dbPatPerm :: [NamedArg DeBruijnPattern] -> Maybe Permutation+dbPatPerm = dbPatPerm' True++-- | Computes the permutation from the clause telescope+-- to the pattern variables.+--+-- Use as @fromMaybe __IMPOSSIBLE__ . dbPatPerm@ to crash+-- in a controlled way if a de Bruijn index is out of scope here.+--+-- The first argument controls whether dot patterns counts as variables or+-- not.+dbPatPerm' :: Bool -> [NamedArg DeBruijnPattern] -> Maybe Permutation+dbPatPerm' countDots ps = Perm (size ixs) <$> picks where- plug p Hole = p- plug p (OHCon c mt h) = ConP c mt $ plugHole p h+ ixs = concatMap (getIndices . namedThing . unArg) ps+ n = size $ catMaybes ixs+ picks = forM (downFrom n) $ \ i -> List.elemIndex (Just i) ixs -allHoles :: [Arg Pattern] -> [OneHolePatterns]-allHoles = map snd . allHolesWithContents+ getIndices :: DeBruijnPattern -> [Maybe Int]+ getIndices (VarP _ x) = [Just $ dbPatVarIndex x]+ getIndices (ConP c _ ps) = concatMap (getIndices . namedThing . unArg) ps+ getIndices (DefP _ _ ps) = concatMap (getIndices . namedThing . unArg) ps+ getIndices (DotP _ _) = [Nothing | countDots]+ getIndices (LitP _ _) = []+ getIndices ProjP{} = []+ getIndices (IApplyP _ _ _ x) = [Just $ dbPatVarIndex x] -allHolesWithContents :: [Arg Pattern] -> [(Pattern, OneHolePatterns)]-allHolesWithContents [] = []-allHolesWithContents (p : ps) = map left phs ++ map (right p) (allHolesWithContents ps)+-- | Computes the permutation from the clause telescope+-- to the pattern variables.+--+-- Use as @fromMaybe __IMPOSSIBLE__ . clausePerm@ to crash+-- in a controlled way if a de Bruijn index is out of scope here.+clausePerm :: Clause -> Maybe Permutation+clausePerm = dbPatPerm . namedClausePats++-- | Turn a pattern into a term.+-- Projection patterns are turned into projection eliminations,+-- other patterns into apply elimination.+patternToElim :: Arg DeBruijnPattern -> Elim+patternToElim (Arg ai (VarP o x)) = Apply $ Arg ai $ var $ dbPatVarIndex x+patternToElim (Arg ai (ConP c cpi ps)) = Apply $ Arg ai $ Con c ci $+ map' (patternToElim . fmap namedThing) ps+ where ci = fromConPatternInfo cpi+patternToElim (Arg ai (DefP o q ps)) = Apply $ Arg ai $ Def q $+ map' (patternToElim . fmap namedThing) ps+patternToElim (Arg ai (DotP o t) ) = Apply $ Arg ai t+patternToElim (Arg ai (LitP o l) ) = Apply $ Arg ai $ Lit l+patternToElim (Arg ai (ProjP o dest)) = Proj o dest+patternToElim (Arg ai (IApplyP o t u x)) = IApply t u $ var $ dbPatVarIndex x++patternsToElims :: [NamedArg DeBruijnPattern] -> [Elim]+patternsToElims ps = map' build ps where- phs :: [(Pattern, Arg OneHolePattern)]- phs = map (id -*- Arg (argHiding p) Relevant) (holes $ unArg p)+ build :: NamedArg DeBruijnPattern -> Elim+ build = patternToElim . fmap namedThing - holes :: Pattern -> [(Pattern, OneHolePattern)]- holes p@(VarP _) = [(p, Hole)]- holes p@(DotP _) = [(p, Hole)]- holes (ConP c mt qs) = map (id -*- OHCon c mt) $ allHolesWithContents qs- holes _ = []+patternToTerm :: DeBruijnPattern -> Term+patternToTerm p = case patternToElim (defaultArg p) of+ Apply x -> unArg x+ Proj{} -> __IMPOSSIBLE__+ IApply _ _ x -> x - left (p, ph) = (p, OHPats [] ph ps)- right q (p, OHPats ps h qs) = (p, OHPats (q : ps) h qs)++class MapNamedArgPattern a p where+ mapNamedArgPattern :: (NamedArg (Pattern' a) -> NamedArg (Pattern' a)) -> p -> p++ default mapNamedArgPattern+ :: (Functor f, MapNamedArgPattern a p', p ~ f p')+ => (NamedArg (Pattern' a) -> NamedArg (Pattern' a)) -> p -> p+ mapNamedArgPattern = fmap . mapNamedArgPattern++-- | Modify the content of @VarP@, and the closest surrounding @NamedArg@.+--+-- Note: the @mapNamedArg@ for @Pattern'@ is not expressible simply+-- by @fmap@ or @traverse@ etc., since @ConP@ has @NamedArg@ subpatterns,+-- which are taken into account by @mapNamedArg@.++instance MapNamedArgPattern a (NamedArg (Pattern' a)) where+ mapNamedArgPattern f np =+ case namedArg np of+ VarP o x -> f np+ DotP o t -> f np+ LitP o l -> f np+ ProjP o q -> f np+ ConP c i ps -> f $ setNamedArg np $ ConP c i $ mapNamedArgPattern f ps+ DefP o q ps -> f $ setNamedArg np $ DefP o q $ mapNamedArgPattern f ps+ IApplyP o u t x -> f np++instance MapNamedArgPattern a p => MapNamedArgPattern a [p] where+++-- | Generic pattern traversal.+--+-- Pre-applies a pattern modification, recurses, and post-applies another one.++class PatternLike a b where++ -- | Fold pattern.+ foldrPattern+ :: Monoid m+ => (Pattern' a -> m -> m)+ -- ^ Combine a pattern and the value computed from its subpatterns.+ -> b -> m++ {-# INLINE foldrPattern #-}+ default foldrPattern+ :: (Monoid m, Foldable f, PatternLike a p, f p ~ b)+ => (Pattern' a -> m -> m) -> b -> m+ foldrPattern = foldMap . foldrPattern++ -- | Traverse pattern.+ traversePatternM+ :: Monad m+ => (Pattern' a -> m (Pattern' a)) -- ^ @pre@: Modification before recursion.+ -> (Pattern' a -> m (Pattern' a)) -- ^ @post@: Modification after recursion.+ -> b -> m b++ default traversePatternM+ :: (Traversable f, PatternLike a p, f p ~ b, Monad m)+ => (Pattern' a -> m (Pattern' a))+ -> (Pattern' a -> m (Pattern' a))+ -> b -> m b++ traversePatternM pre post = traverse $ traversePatternM pre post++-- | Compute from each subpattern a value and collect them all in a monoid.++foldPattern :: (PatternLike a b, Monoid m) => (Pattern' a -> m) -> b -> m+foldPattern f = foldrPattern $ \ p m -> f p `mappend` m++-- | Traverse pattern(s) with a modification before the recursive descent.++preTraversePatternM+ :: (PatternLike a b, Monad m)+ => (Pattern' a -> m (Pattern' a)) -- ^ @pre@: Modification before recursion.+ -> b -> m b+preTraversePatternM pre = traversePatternM pre return++-- | Traverse pattern(s) with a modification after the recursive descent.++postTraversePatternM :: (PatternLike a b, Monad m)+ => (Pattern' a -> m (Pattern' a)) -- ^ @post@: Modification after recursion.+ -> b -> m b+postTraversePatternM = traversePatternM return++-- This is where the action is:++instance PatternLike a (Pattern' a) where++ foldrPattern f p = f p $ case p of+ ConP _ _ ps -> foldrPattern f ps+ DefP _ _ ps -> foldrPattern f ps+ VarP _ _ -> mempty+ LitP _ _ -> mempty+ DotP _ _ -> mempty+ ProjP _ _ -> mempty+ IApplyP{} -> mempty++ traversePatternM pre post = pre >=> recurse >=> post+ where+ recurse p = case p of+ ConP c ci ps -> ConP c ci <$> traversePatternM pre post ps+ DefP o q ps -> DefP o q <$> traversePatternM pre post ps+ VarP _ _ -> return p+ LitP _ _ -> return p+ DotP _ _ -> return p+ ProjP _ _ -> return p+ IApplyP{} -> return p++-- Boilerplate instances:++instance PatternLike a b => PatternLike a [b] where+instance PatternLike a b => PatternLike a (Arg b) where+instance PatternLike a b => PatternLike a (Named x b) where++-- Counting pattern variables ---------------------------------------------++class CountPatternVars a where+ countPatternVars :: a -> Int++ default countPatternVars :: (Foldable f, CountPatternVars b, f b ~ a) =>+ a -> Int+ countPatternVars = getSum . foldMap (Sum . countPatternVars)++instance CountPatternVars a => CountPatternVars [a] where+instance CountPatternVars a => CountPatternVars (Arg a) where+instance CountPatternVars a => CountPatternVars (Named x a) where++instance CountPatternVars (Pattern' x) where+ countPatternVars p =+ case p of+ VarP{} -> 1+ LitP{} -> 0+ ProjP{} -> 0+ ConP _ _ ps -> countPatternVars ps+ DotP{} -> 1 -- dot patterns are treated as variables in the clauses+ -- Andreas, 2026-05-01, issue #7629, need to also count interval variables:+ IApplyP{} -> 1+ DefP _ _ ps -> countPatternVars ps++-- Computing modalities of pattern variables ------------------------------++class PatternVarModalities p where+ type PatVar p+ -- | Get the list of pattern variables annotated with modalities.+ patternVarModalities :: p -> [(PatVar p, Modality)]++instance PatternVarModalities a => PatternVarModalities [a] where+ type PatVar [a] = PatVar a+ patternVarModalities = foldMap patternVarModalities++instance PatternVarModalities a => PatternVarModalities (Named s a) where+ type PatVar (Named s a) = PatVar a+ patternVarModalities = foldMap patternVarModalities++instance PatternVarModalities a => PatternVarModalities (Arg a) where+ type PatVar (Arg a) = PatVar a+ patternVarModalities arg = map' (second (composeModality m)) (patternVarModalities $ unArg arg)+ where m = getModality arg++-- UNUSED:+-- instance PatternVarModalities a x => PatternVarModalities (Elim' a) x where+-- patternVarModalities (Apply x) = patternVarModalities x -- Note: x :: Arg a+-- patternVarModalities (IApply x y p) = patternVarModalities [x, y, p]+-- patternVarModalities Proj{} = []++instance PatternVarModalities (Pattern' x) where+ type PatVar (Pattern' x) = x+ patternVarModalities p =+ case p of+ VarP _ x -> [(x, defaultModality)]+ ConP _ _ ps -> patternVarModalities ps+ DefP _ _ ps -> patternVarModalities ps+ DotP{} -> []+ LitP{} -> []+ ProjP{} -> []+ IApplyP _ _ _ x -> [(x, defaultModality)]+++hasDefP :: [NamedArg DeBruijnPattern] -> Bool+hasDefP ps = getAny $ flip foldPattern ps $ \ (x :: DeBruijnPattern) ->+ case x of+ DefP{} -> Any True+ _ -> Any False
@@ -0,0 +1,79 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Sanity checking for internal syntax. Mostly checking variable scoping.+module Agda.Syntax.Internal.SanityCheck where++import Control.Monad++import Agda.Syntax.Internal+import Agda.TypeChecking.Free+import Agda.TypeChecking.Monad++import Agda.Utils.List ( dropEnd, initWithDefault )+import Agda.Syntax.Common.Pretty+import Agda.Utils.Size+import Agda.Utils.Impossible+import qualified Agda.Utils.VarSet as VarSet+++sanityCheckVars :: (Pretty a, Free a) => Telescope -> a -> TCM ()+sanityCheckVars tel v =+ case filter bad (VarSet.toAscList $ freeVarSet v) of+ [] -> return ()+ xs -> do+ alwaysReportSDoc "impossible" 1 . return $+ sep [ hang "Sanity check failed for" 2+ (hang (pretty tel <+> "|-") 2 (pretty v))+ , text $ "out of scope: " ++ show xs ]+ __IMPOSSIBLE__+ where+ n = size tel+ bad x = x < 0 || x >= n++-- | Check that @Γ ⊢ ρ : Δ@.+sanityCheckSubst :: (Pretty a, Free a) => Telescope -> Substitution' a -> Telescope -> TCM ()+sanityCheckSubst gamma rho delta = go gamma rho delta+ where+ go gamma rho delta =+ case rho of++ IdS -> do+ unless (size gamma == size delta) $ err $+ "idS:" <+> hang (pretty gamma <+> "/=") 2 (pretty delta)++ EmptyS _ -> do+ unless (null delta) $ err $+ "emptyS:" <+> pretty delta <+> "is not empty"++ v :# rho -> do+ when (null delta) $ err $ "consS: empty target"+ sanityCheckVars gamma v+ sanityCheckSubst gamma rho (dropLast delta)++ Strengthen _ n rho -> do+ unless (natSize delta >= toEnum n) $ err $ "strS: empty target"+ sanityCheckSubst gamma rho (dropLastN n delta)++ Wk n rho -> do+ unless (natSize gamma >= toEnum n) $ err $+ "wkS:" <+> sep [ "|" <> pretty gamma <> "|" , text $ "< " ++ show n ]+ sanityCheckSubst (dropLastN n gamma) rho delta++ Lift n rho -> do+ unless (natSize gamma >= toEnum n) $ err $+ "liftS: source" <+> sep [ "|" <> pretty gamma <> "|" , text $ "< " ++ show n ]+ unless (natSize delta >= toEnum n) $ err $+ "liftS: target" <+> sep [ "|" <> pretty delta <> "|" , text $ "< " ++ show n ]+ sanityCheckSubst (dropLastN n gamma) rho (dropLastN n delta)++ dropLast = telFromList . initWithDefault __IMPOSSIBLE__ . telToList+ dropLastN n = telFromList . dropEnd n . telToList++ err reason = do+ alwaysReportSDoc "impossible" 1 . return $+ sep [ hang "Sanity check failed for" 2 $+ hang (pretty gamma <+> "|-") 2 $+ hang (pretty rho <+> ":") 2 $+ pretty delta+ , reason ]+ __IMPOSSIBLE__
@@ -0,0 +1,103 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE DeriveAnyClass #-}++-- | Kinds of standard universes: @Prop@, @Type@, @SSet@.++module Agda.Syntax.Internal.Univ where++import Control.DeepSeq ( NFData )+import GHC.Generics ( Generic )++import Agda.Utils.Boolean++-- * Types+---------------------------------------------------------------------------++-- | Flavor of standard universe (@Prop < Type < SSet@,).+data Univ+ = UProp -- ^ Fibrant universe of propositions.+ | UType -- ^ Fibrant universe.+ | USSet -- ^ Non-fibrant universe.+ deriving stock (Eq, Ord, Show, Bounded, Enum, Generic)+ deriving anyclass NFData+ -- NB: for deriving Ord, keep ordering UProp < UType < USSet!++-- | We have @IsFibrant < IsStrict@.+data IsFibrant+ = IsFibrant -- ^ Fibrant universe.+ | IsStrict -- ^ Non-fibrant universe.+ deriving (Show, Eq, Ord, Generic)+ -- NB: for deriving Ord, keep ordering IsFibrant < IsStrict!++instance Boolean IsFibrant where+ fromBool = \case+ True -> IsFibrant+ False -> IsStrict++instance IsBool IsFibrant where+ toBool = \case+ IsFibrant -> True+ IsStrict -> False++-- * Universe kind arithmetic+---------------------------------------------------------------------------++-- | The successor universe type of a universe.+univUniv :: Univ -> Univ+univUniv = \case+ UProp -> UType+ UType -> UType+ USSet -> USSet++-- | Compute the universe type of a function space from the universe types of domain and codomain.+funUniv :: Univ -> Univ -> Univ+funUniv = curry $ \case+ (USSet, _) -> USSet+ (_, USSet) -> USSet+ (_, u) -> u++-- ** Inverting 'funUniv'++-- | Conclude @u1@ from @funUniv u1 u2@ and @u2@.++domainUniv ::+ Bool -- ^ Have 'UProp'?+ -> Univ -- ^ 'Univ' kind of the 'funSort'.+ -> Univ -- ^ 'Univ' kind of the codomain.+ -> Maybe Univ -- ^ 'Univ' kind of the domain, if unique.+domainUniv propEnabled u = \case+ USSet -> Nothing+ _ | u == USSet -> Just USSet+ | propEnabled -> Nothing+ | otherwise -> Just UType++-- | Conclude @u2@ from @funUniv u1 u2@ and @u1@.++codomainUniv ::+ Univ -- ^ 'Univ' kind of the 'funSort'.+ -> Univ -- ^ 'Univ' kind of the domain.+ -> Maybe Univ -- ^ 'Univ' kind of the codomain, if uniquely exists.+codomainUniv u = \case+ USSet -> Nothing+ _ -> Just u++-- * Fibrancy++-- | Fibrancy of standard universes.++univFibrancy :: Univ -> IsFibrant+univFibrancy = \case+ UProp -> IsFibrant+ UType -> IsFibrant+ USSet -> IsStrict++-- * Printing++-- | Hacky showing of standard universes, does not take actual names into account.++showUniv :: Univ -> String+showUniv = \case+ UProp -> "Prop"+ UType -> "Set"+ USSet -> "SSet"
@@ -1,56 +1,108 @@-{-# LANGUAGE DeriveDataTypeable #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}+ module Agda.Syntax.Literal where -import Data.Generics (Typeable, Data)+import Control.DeepSeq+import Data.Char+import Data.Word++import Data.Text (Text)+import qualified Data.Text as T+ import Agda.Syntax.Position-import Agda.Syntax.Abstract.Name+import Agda.Syntax.Common ( Ranged, MetaId )+import Agda.Syntax.Abstract.Name ( QName )+import Agda.Syntax.TopLevelModuleName.Boot ( TopLevelModuleName' )+import Agda.Utils.Float ( doubleDenotEq, doubleDenotOrd )+import Agda.Syntax.Common.Pretty -data Literal = LitInt Range Integer- | LitFloat Range Double- | LitString Range String- | LitChar Range Char- | LitQName Range QName- deriving (Typeable, Data, Show)+type RLiteral = Ranged Literal+data Literal+ = LitNat !Integer+ | LitWord64 !Word64+ | LitFloat !Double+ | LitString !Text+ | LitChar !Char+ | LitQName !QName+ | LitMeta !(TopLevelModuleName' Range) !MetaId+ deriving Show +instance Pretty Literal where+ pretty (LitNat n) = hlNumber $ pretty n+ pretty (LitWord64 n) = hlNumber $ pretty n+ pretty (LitFloat d) = hlNumber $ pretty d+ pretty (LitString s) = hlString . text $ showText s ""+ pretty (LitChar c) = hlString . text $ "'" ++ showChar' c "'"+ pretty (LitQName x) = pretty x+ pretty (LitMeta _ x) = pretty x++showText :: Text -> ShowS+showText s = showString "\""+ . T.foldr (\ c -> (showChar' c .)) id s+ . showString "\""++showChar' :: Char -> ShowS+showChar' '"' = showString "\\\""+showChar' c+ | escapeMe c = showLitChar c+ | otherwise = showString [c]+ where+ escapeMe c = not (isPrint c) || c == '\\'+ instance Eq Literal where- LitInt _ n == LitInt _ m = n == m- LitFloat _ x == LitFloat _ y = x == y- LitString _ s == LitString _ t = s == t- LitChar _ c == LitChar _ d = c == d- LitQName _ x == LitQName _ y = x == y- _ == _ = False+ LitNat n == LitNat m = n == m+ -- ASR (2016-09-29). We use bitwise equality for comparing Double+ -- because Haskell's Eq, which equates 0.0 and -0.0, allows to prove+ -- a contradiction (see Issue #2169).+ LitWord64 n == LitWord64 m = n == m+ LitFloat x == LitFloat y = doubleDenotEq x y+ LitString s == LitString t = s == t+ LitChar c == LitChar d = c == d+ LitQName x == LitQName y = x == y+ LitMeta f x == LitMeta g y = (f, x) == (g, y)+ _ == _ = False instance Ord Literal where- LitInt _ n `compare` LitInt _ m = n `compare` m- LitFloat _ x `compare` LitFloat _ y = x `compare` y- LitString _ s `compare` LitString _ t = s `compare` t- LitChar _ c `compare` LitChar _ d = c `compare` d- compare LitInt{} _ = LT- compare _ LitInt{} = GT+ LitNat n `compare` LitNat m = n `compare` m+ LitWord64 n `compare` LitWord64 m = n `compare` m+ LitFloat x `compare` LitFloat y = doubleDenotOrd x y+ LitString s `compare` LitString t = s `compare` t+ LitChar c `compare` LitChar d = c `compare` d+ LitQName x `compare` LitQName y = x `compare` y+ LitMeta f x `compare` LitMeta g y = (f, x) `compare` (g, y)+ compare LitNat{} _ = LT+ compare _ LitNat{} = GT+ compare LitWord64{} _ = LT+ compare _ LitWord64{} = GT compare LitFloat{} _ = LT- compare _ LitFloat{} = GT+ compare _ LitFloat{} = GT compare LitString{} _ = LT compare _ LitString{} = GT+ compare LitChar{} _ = LT+ compare _ LitChar{} = GT compare LitQName{} _ = LT compare _ LitQName{} = GT+ -- compare LitMeta{} _ = LT+ -- compare _ LitMeta{} = GT -instance HasRange Literal where- getRange (LitInt r _) = r- getRange (LitFloat r _) = r- getRange (LitString r _) = r- getRange (LitChar r _) = r- getRange (LitQName r _) = r+instance KillRange Literal where+ killRange (LitNat x) = LitNat x+ killRange (LitWord64 x) = LitWord64 x+ killRange (LitFloat x) = LitFloat x+ killRange (LitString x) = LitString x+ killRange (LitChar x) = LitChar x+ killRange (LitQName x) = killRangeN LitQName x+ killRange (LitMeta m x) = LitMeta (killRange m) x -instance SetRange Literal where- setRange r (LitInt _ x) = LitInt r x- setRange r (LitFloat _ x) = LitFloat r x- setRange r (LitString _ x) = LitString r x- setRange r (LitChar _ x) = LitChar r x- setRange r (LitQName _ x) = LitQName r x+-- | Ranges are not forced. -instance KillRange Literal where- killRange (LitInt r x) = LitInt (killRange r) x- killRange (LitFloat r x) = LitFloat (killRange r) x- killRange (LitString r x) = LitString (killRange r) x- killRange (LitChar r x) = LitChar (killRange r) x- killRange (LitQName r x) = LitQName (killRange r) x+instance NFData Literal where+ rnf (LitNat _ ) = ()+ rnf (LitWord64 _ ) = ()+ rnf (LitFloat _ ) = ()+ rnf (LitString _ ) = ()+ rnf (LitChar _ ) = ()+ rnf (LitQName a ) = rnf a+ rnf (LitMeta m _ ) = rnf m
@@ -1,100 +1,443 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-} +{-| As a concrete name, a notation is a non-empty list of alternating 'IdPart's and holes.+ In contrast to concrete names, holes can be binders. -module Agda.Syntax.Notation where+ Example:+ @+ syntax fmap (λ x → e) xs = for x ∈ xs return e+ @ -import Control.Applicative-import Control.Monad (when)-import Control.Monad.Error (throwError)-import Data.List-import Data.Maybe-import Data.Generics (Typeable, Data)+ The declared notation for @fmap@ is @for_∈_return_@ where the first hole is a binder.+-} -import System.FilePath+module Agda.Syntax.Notation where -import Test.QuickCheck+import Prelude hiding ( null, zip, zipWith ) -import Agda.Syntax.Common-import Agda.Syntax.Position-import Agda.Utils.FileName-import Agda.Utils.Pretty+import Control.DeepSeq+import Control.Monad+import Control.Monad.Except -#include "../undefined.h"-import Agda.Utils.Impossible+import qualified Data.List as List -{-| A name is a non-empty list of alternating 'Id's and 'Hole's. A normal name- is represented by a singleton list, and operators are represented by a list- with 'Hole's where the arguments should go. For instance: @[Hole,Id "+",Hole]@- is infix addition.+import GHC.Generics (Generic) - Equality and ordering on @Name@s are defined to ignore range so same names- in different locations are equal.--}+import qualified Agda.Syntax.Abstract.Name as A+import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete.Name+import Agda.Syntax.Position --- | Data type constructed in the Happy parser; converted to 'GenPart'--- before it leaves the Happy code.-data HoleName = LambdaHole String String -- ^ (\x -> y) ; 1st argument is the bound name (unused for now)- | ExprHole String -- ^ simple named hole+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.ListInf ( pattern (:<) )+import qualified Agda.Utils.ListInf as ListInf+import Agda.Utils.Set1 ( Set1 )+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.Zip --- | Target of a hole-holeName (LambdaHole _ n) = n-holeName (ExprHole n) = n+import Agda.Utils.Impossible -type Notation = [GenPart]+-- | Data type constructed in the Happy parser; converted to+-- 'NotationPart' before it leaves the Happy code.+data HoleName+ = LambdaHole { _bindHoleNames :: List1 RString+ , holeName :: RString+ }+ -- ^ @λ x₁ … xₙ → y@: The first argument contains the bound names.+ | ExprHole { holeName :: RString }+ -- ^ Simple named hole with hiding. --- | Part of a Notation-data GenPart = BindHole Int -- ^ Argument is the position of the hole (with binding) where the binding should occur.- | NormalHole Int -- ^ Argument is where the expression should go- | IdPart String- deriving (Data, Typeable, Show, Eq)+-- | Is the hole a binder?+isLambdaHole :: HoleName -> Bool+isLambdaHole (LambdaHole _ _) = True+isLambdaHole _ = False -- | Get a flat list of identifier parts of a notation. stringParts :: Notation -> [String]-stringParts gs = [ x | IdPart x <- gs ]+stringParts gs = [ rangedThing x | IdPart x <- gs ] --- | Target argument position of a part (Nothing if it is not a hole)-holeTarget (BindHole n) = Just n-holeTarget (NormalHole n) = Just n-holeTarget (IdPart _) = Nothing+-- | Target argument position of a part (Nothing if it is not a hole).+holeTarget :: NotationPart -> Maybe Int+holeTarget (VarPart _ n) = Just $ holeNumber $ rangedThing n+holeTarget (WildPart n) = Just $ holeNumber $ rangedThing n+holeTarget (HolePart _ n) = Just $ rangedThing $ namedArg n+holeTarget IdPart{} = Nothing -- | Is the part a hole?-isAHole :: GenPart -> Bool-isAHole = isJust . holeTarget+isAHole :: NotationPart -> Bool+isAHole HolePart{} = True+isAHole VarPart{} = False+isAHole WildPart{} = False+isAHole IdPart{} = False -isBindingHole (BindHole _) = True-isBindingHole _ = False+-- | Is the part a binder?+isBinder :: NotationPart -> Bool+isBinder HolePart{} = False+isBinder VarPart{} = True+isBinder WildPart{} = True+isBinder IdPart{} = False -isLambdaHole (LambdaHole _ _) = True-isLambdaHole _ = False+-- | Classification of notations. +data NotationKind+ = InfixNotation -- ^ Ex: @_bla_blub_@.+ | PrefixNotation -- ^ Ex: @_bla_blub@.+ | PostfixNotation -- ^ Ex: @bla_blub_@.+ | NonfixNotation -- ^ Ex: @bla_blub@.+ | NoNotation+ deriving (Eq, Show, Generic) +-- | Classify a notation by presence of leading and/or trailing+-- /normal/ holes.+notationKind :: Notation -> NotationKind+notationKind [] = NoNotation+notationKind (h:syn) =+ case (isAHole h, isAHole $ last1 h syn) of+ (True , True ) -> InfixNotation+ (True , False) -> PostfixNotation+ (False, True ) -> PrefixNotation+ (False, False) -> NonfixNotation++-- | Analogue of 'isPrePostOrInfixOperator': prefix, infix, or postfix.+isPrePostOrInfixNotation :: Notation -> Bool+isPrePostOrInfixNotation n = case notationKind n of+ InfixNotation -> True+ PrefixNotation -> True+ PostfixNotation -> True+ NonfixNotation -> False+ NoNotation -> False+ -- | From notation with names to notation with indices.-mkNotation :: [HoleName] -> [String] -> Either String Notation+--+-- An example (with some parts of the code omitted):+-- The lists+-- @["for", "x", "∈", "xs", "return", "e"]@+-- and+-- @['LambdaHole' ("x" :| []) "e", 'ExprHole' "xs"]@+-- are mapped to the following notation:+-- @+-- [ 'IdPart' "for" , 'VarPart' ('BoundVariablePosition' 0 0)+-- , 'IdPart' "∈" , 'HolePart' 1+-- , 'IdPart' "return" , 'HolePart' 0+-- ]+-- @+mkNotation :: [NamedArg HoleName] -> [RString] -> Either String Notation mkNotation _ [] = throwError "empty notation is disallowed" mkNotation holes ids = do- xs <- mapM mkPart ids- when (not (isAlternating xs)) $ throwError "syntax must alternate holes and non-holes"- when (not (isExprLinear xs)) $ throwError "syntax must use holes exactly once"- when (not (isLambdaLinear xs)) $ throwError "syntax must use binding holes exactly once"- return xs- where mkPart ident =- case (findIndices (\x -> ident == holeName x) holes,- findIndices (\x -> case x of LambdaHole ident' _ -> ident == ident';_ -> False) holes) of- ([],[x]) -> return $ BindHole x- ([x], []) -> return $ NormalHole x- ([], []) -> return $ IdPart ident- _ -> throwError "hole names must be unique"+ unless uniqueHoleNames $ throwError "syntax must use unique argument names"+ let xs :: Notation = map mkPart ids+ unless (isExprLinear xs) $ throwError "syntax must use holes exactly once"+ unless (isLambdaLinear xs) $ throwError "syntax must use binding holes exactly once"+ unless (noAdjacentHoles xs) $ throwError $ concat+ [ "syntax must not contain adjacent holes ("+ , prettyHoles+ , ")"+ ]+ -- Andreas, 2018-10-18, issue #3285:+ -- syntax that is just a single hole is ill-formed and crashes the operator parser+ when (isSingleHole xs) $ throwError "syntax cannot be a single hole"+ return $ insertWildParts xs+ where+ holeNames :: [RString]+ holeNames = map namedArg holes >>= \case+ LambdaHole _ y -> [y]+ ExprHole y -> [y] - isExprLinear xs = sort [ x | NormalHole x <- xs] == [ i | (i,h) <- zip [0..] holes ]- isLambdaLinear xs = sort [ x | BindHole x <- xs] == [ i | (i,h) <- zip [0..] holes, isLambdaHole h ]+ prettyHoles :: String+ prettyHoles = List.unwords $ map (rawNameToString . rangedThing) holeNames + mkPart ident = maybe (IdPart ident) (`withRangeOf` ident) $ lookup ident holeMap - isAlternating :: [GenPart] -> Bool- isAlternating [] = __IMPOSSIBLE__- isAlternating [x] = True- isAlternating (x:y:xs) = isAHole x /= isAHole y && isAlternating (y:xs)+ holeNumbers = [0 .. length holes - 1] + numberedHoles :: [(Int, NamedArg HoleName)]+ numberedHoles = zip holeNumbers holes --- | No notation by default-defaultNotation = []-noNotation = []+ -- The WildParts don't correspond to anything in the right-hand side so+ -- we add them next to their corresponding body. Slightly subtle: due to+ -- the way the operator parsing works they can't be added first or last.+ insertWildParts :: [NotationPart] -> [NotationPart]+ insertWildParts xs = foldr ins xs wilds+ where+ wilds = [ i | (_, WildPart i) <- holeMap ]++ ins w (HolePart r h : hs)+ | namedArg h == fmap holeNumber w =+ HolePart r h : WildPart w : hs+ ins w (h : hs) = h : insBefore w hs+ ins _ [] = __IMPOSSIBLE__++ insBefore w (HolePart r h : hs)+ | namedArg h == fmap holeNumber w =+ WildPart w : HolePart r h : hs+ insBefore w (h : hs) = h : insBefore w hs+ insBefore _ [] = __IMPOSSIBLE__++ -- A map (association list) from hole names to notation parts. A+ -- @LambdaHole@ contributes one or more entries, one @HolePart@+ -- and zero or more @VarPart@s or @WildParts@, all mapped to the+ -- same number.+ holeMap :: [(RString, NotationPart)]+ holeMap = do+ (i, h) <- numberedHoles+ let ri x = Ranged (getRange x) i+ rp x n = Ranged (getRange x) $+ BoundVariablePosition+ { holeNumber = i+ , varNumber = n+ }+ hole y = HolePart noRange $ fmap (ri y <$) h+ -- This range is filled in by mkPart.+ case namedArg h of+ ExprHole y -> [(y, hole y)]+ LambdaHole xs y -> [(y, hole y)] +++ zipWith+ (\ n x -> case rangedThing x of+ "_" -> (x, WildPart (rp x n))+ _ -> (x, VarPart noRange (rp x n)))+ -- Filled in by mkPart.+ [0..]+ (List1.toList xs)++ -- Check whether all hole names are distinct.+ -- The hole names are the keys of the @holeMap@.+ uniqueHoleNames = distinct [ x | (x, _) <- holeMap, rangedThing x /= "_" ]++ isExprLinear xs =+ List.sort [ i | x <- xs, isAHole x, let Just i = holeTarget x ]+ ==+ holeNumbers++ isLambdaLinear xs =+ List.sort [ rangedThing x | VarPart _ x <- xs ]+ ==+ [ BoundVariablePosition { holeNumber = i, varNumber = v }+ | (i, h) <- numberedHoles+ , LambdaHole vs _ <- [namedArg h]+ , (v, x) <- zip [0..] $ map rangedThing $ List1.toList vs+ , x /= "_"+ ]++ noAdjacentHoles :: [NotationPart] -> Bool+ noAdjacentHoles =+ noAdj .+ filter (\h -> case h of+ HolePart{} -> True+ IdPart{} -> True+ _ -> False)+ where+ noAdj [] = __IMPOSSIBLE__+ noAdj [_] = True+ noAdj (x:y:xs) =+ not (isAHole x && isAHole y) &&+ noAdj (y:xs)++ isSingleHole :: [NotationPart] -> Bool+ isSingleHole = \case+ [ IdPart{} ] -> False+ [ _hole ] -> True+ _ -> False++-- | All the notation information related to a name.+data NewNotation = NewNotation+ { notaName :: QName+ , notaNames :: Set1 A.Name+ -- ^ The names the syntax and/or fixity belong to.+ --+ -- Invariant: Every name in the list matches 'notaName'.+ , notaFixity :: Fixity+ -- ^ Associativity and precedence (fixity) of the names.+ , notation :: Notation+ -- ^ Syntax associated with the names.+ , notaIsOperator :: Bool+ -- ^ True if the notation comes from an operator (rather than a+ -- syntax declaration).+ } deriving (Show, Generic)++instance LensFixity NewNotation where+ lensFixity f nota = f (notaFixity nota) <&> \ fx -> nota { notaFixity = fx }++-- | If an operator has no specific notation, then it is computed from+-- its name.+namesToNotation :: QName -> A.Name -> NewNotation+namesToNotation q n = NewNotation+ { notaName = q+ , notaNames = singleton n+ , notaFixity = f+ , notation = if null syn then syntaxOf (unqualify q) else syn+ , notaIsOperator = null syn+ }+ where Fixity' f syn _ = A.nameFixity n++-- | Replace 'noFixity' by 'defaultFixity'.+useDefaultFixity :: NewNotation -> NewNotation+useDefaultFixity n+ | notaFixity n == noFixity = n { notaFixity = defaultFixity }+ | otherwise = n++-- | Return the 'IdPart's of a notation, the first part qualified,+-- the other parts unqualified.+-- This allows for qualified use of operators, e.g.,+-- @M.for x ∈ xs return e@, or @x ℕ.+ y@.+notationNames :: NewNotation -> [QName]+notationNames (NewNotation q _ _ parts _) =+ zipWith ($) (reQualify :< ListInf.repeat QName) [ simpleName $ rangedThing x | IdPart x <- parts ]+ where+ -- The qualification of @q@.+ modules = List1.init (qnameParts q)+ -- Putting the qualification onto @x@.+ reQualify x = List.foldr Qual (QName x) modules++-- | Create a 'Notation' (without binders) from a concrete 'Name'.+-- Does the obvious thing:+-- 'Hole's become 'HolePart's, 'Id's become 'IdParts'.+-- If 'Name' has no 'Hole's, it returns 'noNotation'.+syntaxOf :: Name -> Notation+syntaxOf y+ | isOperator y = mkSyn 0 $ List1.toList $ nameNameParts y+ | otherwise = noNotation+ where+ -- Turn a concrete name into a Notation,+ -- numbering the holes from left to right.+ -- Result will have no 'BindingHole's.+ mkSyn :: Int -> [NamePart] -> Notation+ mkSyn _ [] = []+ mkSyn n (Hole : xs) = HolePart noRange (defaultNamedArg $ unranged n) : mkSyn (1 + n) xs+ mkSyn n (Id x : xs) = IdPart (unranged x) : mkSyn n xs++-- | Merges 'NewNotation's that have the same precedence level and+-- notation, with two exceptions:+--+-- * Operators and notations coming from syntax declarations are kept+-- separate.+--+-- * If /all/ instances of a given 'NewNotation' have the same+-- precedence level or are \"unrelated\", then they are merged. They+-- get the given precedence level, if any, and otherwise they become+-- unrelated (but related to each other).+--+-- If 'NewNotation's that are merged have distinct associativities,+-- then they get 'NonAssoc' as their associativity.+--+-- Precondition: No 'A.Name' may occur in more than one list element.+-- Every 'NewNotation' must have the same 'notaName'.+--+-- Postcondition: No 'A.Name' occurs in more than one list element.+mergeNotations :: List1 NewNotation -> List1 NewNotation+mergeNotations ns@(_ :| []) = ns+mergeNotations ns =+ fmap merge+ . List1.concatMap1 groupIfLevelsMatch+ . List1.groupOn1 (notation &&& notaIsOperator)+ $ ns+ where+ groupIfLevelsMatch :: List1 NewNotation -> List1 (List1 NewNotation)+ groupIfLevelsMatch ns =+ if allEqual (map fixityLevel related)+ then singleton $ sameAssoc $ sameLevel ns+ else fmap singleton ns+ where+ -- Fixities of operators whose precedence level is not Unrelated.+ related = List1.mapMaybe (maybeRelated . notaFixity) ns+ where+ maybeRelated f =+ case fixityLevel f of+ Unrelated -> Nothing+ Related {} -> Just f++ -- Precondition: All related operators have the same precedence+ -- level.+ --+ -- Gives all unrelated operators the same level.+ sameLevel = fmap (set (_notaFixity . _fixityLevel) level)+ where+ level = case related of+ f : _ -> fixityLevel f+ [] -> Unrelated++ -- If all related operators have the same associativity, then the+ -- unrelated operators get the same associativity, and otherwise+ -- all operators get the associativity NonAssoc.+ sameAssoc = fmap (set (_notaFixity . _fixityAssoc) assoc)+ where+ assoc = case related of+ f : _ | allEqual (map fixityAssoc related) -> fixityAssoc f+ _ -> NonAssoc++ merge :: List1 NewNotation -> NewNotation+ merge ns@(n :| _) = n { notaNames = Set1.unions $ fmap notaNames ns }++-- | Check if a notation contains any lambdas (in which case it cannot be used in a pattern).+isLambdaNotation :: NewNotation -> Bool+isLambdaNotation n = any isBinder (notation n)+ where+ isBinder VarPart{} = True+ isBinder WildPart{} = True+ isBinder IdPart{} = False+ isBinder HolePart{} = False++-- | Lens for 'Fixity' in 'NewNotation'.++_notaFixity :: Lens' NewNotation Fixity+_notaFixity f r = f (notaFixity r) <&> \x -> r { notaFixity = x }++-- * Sections++-- | Sections, as well as non-sectioned operators.++data NotationSection = NotationSection+ { sectNotation :: NewNotation+ , sectKind :: NotationKind+ -- ^ For non-sectioned operators this should match the notation's+ -- 'notationKind'.+ , sectLevel :: Maybe FixityLevel+ -- ^ Effective precedence level. 'Nothing' for closed notations.+ , sectIsSection :: Bool+ -- ^ 'False' for non-sectioned operators.+ }+ deriving (Show, Generic)++-- | Converts a notation to a (non-)section.++noSection :: NewNotation -> NotationSection+noSection n = NotationSection+ { sectNotation = n+ , sectKind = notationKind (notation n)+ , sectLevel = Just (fixityLevel (notaFixity n))+ , sectIsSection = False+ }+++-- * Pretty printing++instance Pretty NewNotation where+ pretty (NewNotation x _xs fx nota isOp) = hsepWith "=" px pn+ where+ px = fsep [ if isOp then empty else "syntax" , pretty fx , pretty x ]+ pn = if isOp then empty else pretty nota++instance Pretty NotationKind where pretty = pshow++instance Pretty NotationSection where+ pretty (NotationSection nota kind mlevel isSection)+ | isSection = fsep+ [ "section"+ , pretty kind+ , maybe empty pretty mlevel+ , pretty nota+ ]+ | otherwise = pretty nota++-- NFData instances++instance NFData NotationKind+instance NFData NewNotation+instance NFData NotationSection
@@ -3,102 +3,276 @@ ( -- * Types Parser -- * Parse functions- , Agda.Syntax.Parser.parse- , Agda.Syntax.Parser.parseLiterate- , Agda.Syntax.Parser.parsePosString- , parseFile'+ , parse+ , parsePosString+ , parseRangeString+ , parseFile -- * Parsers , moduleParser+ , moduleNameParser+ , agdaFileExtensions , exprParser+ , exprWhereParser+ , holeContentParser , tokensParser+ -- * Reading files.+ , readFilePM -- * Parse errors , ParseError(..)+ , ParseWarning(..)+ , PM(..)+ , runPMIO ) where import Control.Exception-import Data.List-import System.Directory+import Control.Monad ( forM_ )+import Control.Monad.Except+import Control.Monad.State+import Control.Monad.IO.Class ( MonadIO(..) ) +import Data.Bifunctor+import qualified Data.List as List+import Data.Text.Lazy (Text)++import Agda.Syntax.Common import Agda.Syntax.Position-import Agda.Syntax.Parser.Monad as M hiding (Parser, parseFlags)+import Agda.Syntax.Parser.Monad+ ( ParseError(..), ParseWarning(..), ParseResult(..), ParseFlags, LexState+ , ParseState (parseWarnings, parseAttributes), defaultParseFlags, parseKeepComments+ ) import qualified Agda.Syntax.Parser.Monad as M import qualified Agda.Syntax.Parser.Parser as P import Agda.Syntax.Parser.Lexer-import Agda.Syntax.Strict+import Agda.Syntax.Parser.Literate import Agda.Syntax.Concrete+import Agda.Syntax.Concrete.Attribute import Agda.Syntax.Parser.Tokens import Agda.Utils.FileName+import Agda.Utils.IO.UTF8 (readTextFile)+import Agda.Utils.Maybe (forMaybe, fromMaybe)+import qualified Agda.Utils.Maybe.Strict as Strict ------------------------------------------------------------------------ -- Wrapping parse results -wrap :: Strict a => ParseResult a -> a-wrap (ParseOk _ x) = x-wrap (ParseFailed err) = throw err+-- | A monad for handling parse errors and warnings. -wrapM:: (Strict a, Monad m) => m (ParseResult a) -> m a-wrapM m =- do r <- m- case r of- ParseOk _ x -> return x- ParseFailed err -> throw err+newtype PM a = PM { unPM :: ExceptT ParseError (StateT [ParseWarning] IO) a }+ deriving ( Functor, Applicative, Monad, MonadIO+ , MonadError ParseError, MonadState [ParseWarning]+ ) +-- | Run a 'PM' computation, returning a list of warnings in first-to-last order+-- and either a parse error or the parsed thing.++runPMIO :: (MonadIO m) => PM a -> m (Either ParseError a, [ParseWarning])+runPMIO = liftIO . fmap (second reverse) . flip runStateT [] . runExceptT . unPM++-- | Add a 'ParseWarning'.++warning :: ParseWarning -> PM ()+warning w = PM (modify (w:))++-- | Embed a 'ParseResult' as 'PM' computation.++wrap :: ParseResult a -> PM (a, Attributes)+wrap (ParseFailed err) = throwError err+wrap (ParseOk s x) = do+ modify' (parseWarnings s ++)+ return (x, parseAttributes s)++wrapM :: IO (ParseResult a) -> PM (a, Attributes)+wrapM m = liftIO m >>= wrap++-- | Returns the contents of the given file.++readFilePM :: RangeFile -> PM Text+readFilePM file =+ wrapIOM (ReadFileError file) $+ readTextFile (filePath $ rangeFilePath file)++wrapIOM :: (MonadError e m, MonadIO m) => (IOError -> e) -> IO a -> m a+wrapIOM f m = do+ a <- liftIO $ (Right <$> m) `catch` (\ err -> return $ Left (err :: IOError))+ case a of+ Right x -> return x+ Left err -> throwError (f err)+ ------------------------------------------------------------------------ -- Parse functions -- | Wrapped Parser type. data Parser a = Parser- { parser :: M.Parser a- , parseFlags :: ParseFlags+ { parser :: M.Parser a+ , parseFlags :: ParseFlags+ , parseLiterate :: LiterateParser a } -parse :: Strict a => Parser a -> String -> IO a-parse p = wrapM . return . M.parse (parseFlags p) [normal] (parser p)+type LiterateParser a =+ Parser a -> SrcFile -> [Layer] -> PM (a, Attributes) -parseFile :: Strict a => Parser a -> AbsolutePath -> IO a-parseFile p = wrapM . M.parseFile (parseFlags p) [normal] (parser p)+-- | Initial state for lexing. -parseLiterate :: Strict a => Parser a -> String -> IO a-parseLiterate p =- wrapM . return . M.parse (parseFlags p) [literate, code] (parser p)+normalLexState :: [LexState]+normalLexState = [normal] -parseLiterateFile :: Strict a => Parser a -> AbsolutePath -> IO a-parseLiterateFile p =- wrapM . M.parseFile (parseFlags p) [literate, code] (parser p)+-- | Initial state for lexing with top-level layout. -parsePosString :: Strict a => Parser a -> Position -> String -> IO a-parsePosString p pos =- wrapM . return . M.parsePosString pos (parseFlags p) [normal] (parser p)+layoutLexState :: [LexState]+layoutLexState = [layout, normal] -parseFile' :: Strict a => Parser a -> AbsolutePath -> IO a-parseFile' p file =- if "lagda" `isSuffixOf` filePath file then- Agda.Syntax.Parser.parseLiterateFile p file- else- Agda.Syntax.Parser.parseFile p file+-- | Parse without top-level layout. +parse :: Parser a -> String -> PM (a, Attributes)+parse p = wrapM . return . M.parse (parseFlags p) normalLexState (parser p)++-- | Parse with top-level layout.++parseFileFromString+ :: SrcFile -- ^ Name of source file.+ -> Parser a -- ^ Parser to use.+ -> String -- ^ Contents of source file.+ -> PM (a, Attributes)+parseFileFromString src p = wrapM . return . M.parseFromSrc (parseFlags p) layoutLexState (parser p) src++-- | Parse with top-level layout.++parseLiterateWithoutComments :: LiterateParser a+parseLiterateWithoutComments p f layers = parseFileFromString f p $ illiterate layers++-- | Parse with top-level layout.++parseLiterateWithComments :: LiterateParser [Token]+parseLiterateWithComments p f layers = do+ (code, coh) <- parseLiterateWithoutComments p f layers+ let literate = filter (not . isCodeLayer) layers+ let (terms, overlaps) = interleaveRanges (map Left code) (map Right literate)++ forM_ (map fst overlaps) $ \c ->+ warning $ OverlappingTokensWarning { warnRange = f <$ getRangeWithoutFile c }++ return . (,coh) . forMaybe terms $ \case+ Left t -> Just t+ Right (Layer Comment interval s) -> Just $ TokTeX (f <$ interval, s)+ Right (Layer Markup interval s) -> Just $ TokMarkup (f <$ interval, s)+ Right (Layer Code _ _) -> Nothing+++parseLiterateFile+ :: Processor+ -> Parser a+ -> RangeFile+ -- ^ The file.+ -> String+ -- ^ The file contents. Note that the file is /not/ read from+ -- disk.+ -> PM (a, Attributes)+parseLiterateFile po p path = parseLiterate p p (pure path) . po (startPos' ())++parsePosString :: Parser a -> Position -> String -> PM (a, Attributes)+parsePosString p pos = wrapM . return . M.parsePosString pos (parseFlags p) normalLexState (parser p)++-- | Calls 'parsePosString' with 'Position' extracted from the Range.+parseRangeString :: Parser a -> Range -> String -> PM (a, Attributes)+parseRangeString p = parsePosString p . fromMaybe (startPos Nothing) . rStart++-- | Extensions supported by `parseFile`.++agdaFileExtensions :: [String]+agdaFileExtensions = ".agda" : literateExts++-- | Parse a file.+--+-- The 'Bool' parameter controls whether only @```agda@ blocks+-- are treated as Agda code in Markdown/Typst files.+-- When @True@, only blocks marked @```agda@ are considered code.+-- When @False@, both @```@ and @```agda@ blocks are code (default).++parseFile ::+ Bool+ -- ^ When @True@, only treat @```agda@ blocks as code in Markdown/Typst.+ -> Parser a+ -> RangeFile+ -- ^ The file.+ -> String+ -- ^ The file contents. Note that the file is /not/ read from+ -- disk.+ -> PM ((a, Attributes), FileType)+parseFile onlyAgdaBlocks p file input =+ if ".agda" `List.isSuffixOf` path then+ (, AgdaFileType) <$> parseFileFromString (Strict.Just file) p input+ else+ go (literateProcessors onlyAgdaBlocks)+ where+ path = filePath (rangeFilePath file)++ go [] = throwError InvalidExtensionError+ { errPath = file+ , errValidExts = agdaFileExtensions+ }+ go ((ext, (po, ft)) : pos)+ | ext `List.isSuffixOf` path =+ (, ft) <$> parseLiterateFile po p file input+ | otherwise = go pos+ ------------------------------------------------------------------------ -- Specific parsers -- | Parses a module. moduleParser :: Parser Module-moduleParser = Parser { parser = P.moduleParser- , parseFlags = withoutComments }+moduleParser = Parser+ { parser = P.moduleParser+ , parseFlags = withoutComments+ , parseLiterate = parseLiterateWithoutComments+ } +-- | Parses a module name.++moduleNameParser :: Parser QName+moduleNameParser = Parser+ { parser = P.moduleNameParser+ , parseFlags = withoutComments+ , parseLiterate = parseLiterateWithoutComments+ }+ -- | Parses an expression. exprParser :: Parser Expr-exprParser = Parser { parser = P.exprParser- , parseFlags = withoutComments }+exprParser = Parser+ { parser = P.exprParser+ , parseFlags = withoutComments+ , parseLiterate = parseLiterateWithoutComments+ } +-- | Parses an expression followed by a where clause.++exprWhereParser :: Parser ExprWhere+exprWhereParser = Parser+ { parser = P.exprWhereParser+ , parseFlags = withoutComments+ , parseLiterate = parseLiterateWithoutComments+ }++-- | Parses an expression or some other content of an interaction hole.++holeContentParser :: Parser HoleContent+holeContentParser = Parser+ { parser = P.holeContentParser+ , parseFlags = withoutComments+ , parseLiterate = parseLiterateWithoutComments+ }+ -- | Gives the parsed token stream (including comments). tokensParser :: Parser [Token]-tokensParser = Parser { parser = P.tokensParser- , parseFlags = withComments }+tokensParser = Parser+ { parser = P.tokensParser+ , parseFlags = withComments+ , parseLiterate = parseLiterateWithComments+ } -- | Keep comments in the token stream generated by the lexer.
@@ -1,3 +1,4 @@+{-# OPTIONS_GHC -Wunused-imports #-} {-| This module defines the things required by Alex and some other Alex related things.@@ -5,10 +6,11 @@ module Agda.Syntax.Parser.Alex ( -- * Alex requirements AlexInput(..)+ , lensLexInput , alexInputPrevChar , alexGetChar, alexGetByte -- * Lex actions- , LexAction, LexPredicate+ , LexAction(..), LexPredicate , (.&&.), (.||.), not' , PreviousInput, CurrentInput, TokenLength -- * Monad operations@@ -16,69 +18,99 @@ ) where -import Control.Arrow import Control.Monad.State+import Data.Char import Data.Word+import GHC.Exts (oneShot) import Agda.Syntax.Position import Agda.Syntax.Parser.Monad -import Agda.Utils.Monad+import Agda.Utils.Lens+import Agda.Utils.Tuple -- | This is what the lexer manipulates. data AlexInput = AlexInput- { lexPos :: !Position -- ^ current position- , lexInput :: String -- ^ current input- , lexPrevChar :: !Char -- ^ previously read character- }+ { lexSrcFile :: !SrcFile -- ^ File.+ , lexPos :: !PositionWithoutFile -- ^ Current position.+ , lexInput :: !String -- ^ Current input.+ , lexPrevChar :: !Char -- ^ Previously read character.+ } +-- | A lens for 'lexInput'.+lensLexInput :: Lens' AlexInput String+lensLexInput f r = f (lexInput r) <&> \ s -> r { lexInput = s }+ -- | Get the previously lexed character. Same as 'lexPrevChar'. Alex needs this -- to be defined to handle \"patterns with a left-context\". alexInputPrevChar :: AlexInput -> Char alexInputPrevChar = lexPrevChar --- | Lex a character. No surprises.+-- | Returns the next character, and updates the 'AlexInput' value. ----- This function is used by Alex 2.+-- This function is not suitable for use by Alex 2, because it can+-- return non-ASCII characters. alexGetChar :: AlexInput -> Maybe (Char, AlexInput)-alexGetChar (AlexInput { lexInput = [] }) = Nothing-alexGetChar (AlexInput { lexInput = c:s, lexPos = p }) =+alexGetChar (AlexInput { lexInput = [] }) = Nothing+alexGetChar inp@(AlexInput { lexInput = c:s, lexPos = p }) = Just (c, AlexInput- { lexInput = s- , lexPos = movePos p c- , lexPrevChar = c- }- )+ { lexSrcFile = lexSrcFile inp+ , lexInput = s+ , lexPos = movePos p c+ , lexPrevChar = c+ }+ ) --- | A variant of 'alexGetChar'.+-- | Returns the next byte, and updates the 'AlexInput' value. ----- This function is used by Alex 3.+-- A trick is used to handle the fact that there are more than 256+-- Unicode code points. The function translates characters to bytes in+-- the following way:+--+-- * Whitespace characters other than \'\\t\' and \'\\n\' are+-- translated to \' \'.+-- * Non-ASCII alphabetical characters are translated to \'z\'.+-- * Other non-ASCII printable characters are translated to \'+\'.+-- * Everything else is translated to \'\\1\'.+--+-- Note that it is important that there are no keywords containing+-- \'z\', \'+\', \' \' or \'\\1\'.+--+-- This function is used by Alex (version 3).+ alexGetByte :: AlexInput -> Maybe (Word8, AlexInput) alexGetByte ai =- -- Note that we ensure that every character presented to Alex fits- -- in seven bits.- (fromIntegral . fromEnum *** id) <$> alexGetChar ai+ first (fromIntegral . fromEnum . toASCII) <$> alexGetChar ai+ where+ toASCII c+ | isSpace c && c /= '\t' && c /= '\n' = ' '+ | isAscii c = c+ | isPrint c = if isAlpha c then 'z'+ else '+'+ | otherwise = '\1' {-------------------------------------------------------------------------- Monad operations --------------------------------------------------------------------------} getLexInput :: Parser AlexInput-getLexInput = getInp <$> get+getLexInput = gets getInp where- getInp s = AlexInput- { lexPos = parsePos s- , lexInput = parseInp s- , lexPrevChar = parsePrevChar s- }+ getInp s = AlexInput+ { lexSrcFile = parseSrcFile s+ , lexPos = parsePos s+ , lexInput = parseInp s+ , lexPrevChar = parsePrevChar s+ } setLexInput :: AlexInput -> Parser () setLexInput inp = modify upd where- upd s = s { parsePos = lexPos inp- , parseInp = lexInput inp- , parsePrevChar = lexPrevChar inp- }+ upd s = s { parseSrcFile = lexSrcFile inp+ , parsePos = lexPos inp+ , parseInp = lexInput inp+ , parsePrevChar = lexPrevChar inp+ } {-------------------------------------------------------------------------- Lex actions@@ -88,9 +120,30 @@ type CurrentInput = AlexInput type TokenLength = Int --- | In the lexer, regular expressions are associated with lex actions who's--- task it is to construct the tokens.-type LexAction r = PreviousInput -> CurrentInput -> TokenLength -> Parser r+-- | In the lexer, regular expressions are associated with lex actions whose+-- task is to construct the tokens.+newtype LexAction r+ = LexAction { runLexAction :: PreviousInput -> CurrentInput -> TokenLength -> Parser r }+ deriving (Functor)++instance Applicative LexAction where+ {-# INLINE pure #-}+ pure r = LexAction (oneShot \ _ _ _ -> pure r)+ {-# INLINE (<*>) #-}+ mf <*> mr = LexAction (oneShot \ a b c -> runLexAction mf a b c <*> runLexAction mr a b c)++instance Monad LexAction where+ return = pure+ {-# INLINE (>>=) #-}+ m >>= k = LexAction (oneShot \ a b c -> do+ r <- runLexAction m a b c+ runLexAction (k r) a b c)++instance MonadState ParseState LexAction where+ {-# INLINE get #-}+ get = LexAction (oneShot (\ _ _ _ -> get))+ {-# INLINE put #-}+ put s = LexAction (oneShot (\ _ _ _ -> put s)) -- | Sometimes regular expressions aren't enough. Alex provides a way to do -- arbitrary computations to see if the input matches. This is done with a
@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} {-| This module defines the lex action to lex nested comments. As is well-known this cannot be done by regular expressions (which, incidently, is probably@@ -10,7 +10,7 @@ module Agda.Syntax.Parser.Comments where -import Data.List+import qualified Data.List as List import {-# SOURCE #-} Agda.Syntax.Parser.LexActions import Agda.Syntax.Parser.Monad@@ -19,11 +19,6 @@ import Agda.Syntax.Parser.LookAhead import Agda.Syntax.Position -import Agda.Utils.Monad--#include "../../undefined.h"-import Agda.Utils.Impossible- -- | Should comment tokens be output? keepComments :: LexPredicate@@ -38,43 +33,46 @@ -- In the end the comment is discarded and 'lexToken' is called to lex a real -- token. nestedComment :: LexAction Token-nestedComment inp inp' _ =- do setLexInput inp'- runLookAhead err $ skipBlock "{-" "-}"+nestedComment = LexAction $ \ inp inp' _ ->+ do setLexInput inp'+ let err :: forall a. String -> LookAhead a+ err _ = liftP $ parseErrorAt (lexPos inp) "Unterminated '{-'"+ runLookAhead err $ skipBlock "{-" "-}" keep <- keepCommentsM if keep then do inp'' <- getLexInput let p1 = lexPos inp; p2 = lexPos inp''- i = Interval p1 p2+ i = posToInterval (lexSrcFile inp) p1 p2 s = case (p1, p2) of- (Pn { posPos = p1 }, Pn { posPos = p2 }) ->- genericTake (p2 - p1) $ lexInput inp+ (Pn' { posPos = p1 }, Pn' { posPos = p2 }) ->+ List.genericTake (p2 - p1) $ lexInput inp return $ TokComment (i, s) else- lexToken- where- err _ = liftP $ parseErrorAt (lexPos inp) "Unterminated '{-'"+ lexToken + -- | Lex a hole (@{! ... !}@). Holes can be nested. -- Returns @'TokSymbol' 'SymQuestionMark'@. hole :: LexAction Token-hole inp inp' _ =- do setLexInput inp'- runLookAhead err $ skipBlock "{!" "!}"- p <- lexPos <$> getLexInput- return $ TokSymbol SymQuestionMark (Interval (lexPos inp) p)- where- err _ = liftP $ parseErrorAt (lexPos inp) "Unterminated '{!'"+hole = LexAction $ \ inp inp' _ ->+ do setLexInput inp'+ let err :: forall a. String -> LookAhead a+ err _ = liftP $ parseErrorAt (lexPos inp) "Unterminated '{!'"+ runLookAhead err $ skipBlock "{!" "!}"+ p <- lexPos <$> getLexInput+ return $+ TokSymbol SymQuestionMark $+ posToInterval (lexSrcFile inp) (lexPos inp) p -- | Skip a block of text enclosed by the given open and close strings. Assumes -- the first open string has been consumed. Open-close pairs may be nested. skipBlock :: String -> String -> LookAhead () skipBlock open close = scan 1 where- scan 0 = sync- scan n = match [ open ==> scan (n + 1)- , close ==> scan (n - 1)- ] `other` scan n- where- (==>) = (,)- other = ($)+ scan 0 = sync+ scan n = match [ open ==> scan (n + 1)+ , close ==> scan (n - 1)+ ] `other` scan n+ where+ (==>) = (,)+ other = ($)
@@ -0,0 +1,835 @@+-- | Utility functions used in the Happy parser.++{-# OPTIONS_GHC -Wunused-matches #-}++module Agda.Syntax.Parser.Helpers where++import Prelude hiding (null)++import Control.Applicative ( (<|>) )+import Control.Monad.State ( modify' )++import Data.Bifunctor (first, second)+import Data.Char+import qualified Data.List as List+import Data.Maybe+import Data.Semigroup ( sconcat )+import Data.Text (Text)+import qualified Data.Text as T++import Agda.Syntax.Position+import Agda.Syntax.Parser.Monad+import Agda.Syntax.Parser.Lexer+import Agda.Syntax.Parser.Tokens+import Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Attribute as CA+import Agda.Syntax.Concrete.Pattern+import Agda.Syntax.Common+import Agda.Syntax.Notation+import Agda.Syntax.Literal++import Agda.TypeChecking.Positivity.Occurrence++import Agda.Utils.Either+import Agda.Utils.Functor+import Agda.Utils.Hash+import Agda.Utils.List ( spanJust, chopWhen, initLast )+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton+import qualified Agda.Utils.Maybe.Strict as Strict+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2++import Agda.Utils.Impossible+import Data.List (partition)++-- | Insert a top-level module if there is none.+-- Also fix-up for the case the declarations in the top-level module+-- are not indented (this is allowed as a special case).+figureOutTopLevelModule :: [Declaration] -> Module+figureOutTopLevelModule ds00 = Mod moduleName optionPragmas decls+ where+ -- First, we grab the leading OPTIONS pragmas.+ (optionPragmas, ds) = (`spanJust` ds00) \case+ Pragma p@OptionsPragma{} -> Just p+ _ -> Nothing++ -- Then, we look for a top-level module and insert one if we cannot find one.+ (moduleName, decls) = case break isModule ds of++ -- Andreas, 2026-02-19, issue #7988:+ -- Case 1: If the first module is a qualified one, this must be the top-level module.+ (ds0, Module r erased m@Qual{} tel ds1 : ds2) ->+ (m, ds0 ++ Module r erased m tel ds1' : ds2')+ where (ds1', ds2') = rectifyNonIndentedDecls ds1 ds2++ -- Otherwise, we check what happens after the declarations that are allowed+ -- before the top-level module.+ _ -> case spanAllowedBeforeModule ds of++ -- Andreas 2016-02-01, issue #1388.+ -- We need to distinguish two additional cases.++ -- Case 2: Regular file layout: imports followed by one module.+ -- The declarations in the module may not be indented.+ -- This is allowed for the top level module, and thus rectified here.+ (ds0, Module r erased m tel ds1 : ds2) ->+ (m, ds0 ++ Module r erased m tel ds1' : ds2')+ where (ds1', ds2') = rectifyNonIndentedDecls ds1 ds2++ -- Case 3: a top-level module declaration is missing.+ -- Andreas, 2017-01-01, issue #2229:+ -- Put everything (except OPTIONS pragmas) into an anonymous module.+ _ -> (m, [Module r defaultErased m [] ds])+ where+ m = QName $ noName r+ -- Andreas, 2017-05-17, issue #2574.+ -- Since the module noName will act as jump target, it needs a range.+ -- We use the beginning of the file as beginning of the top level module.+ r = beginningOfFile $ getRange ds++ -- Helper to move unindented declarations into the top-level module.+ -- This is when an empty first module @null ds1@ is followed by (unindented) declarations @ds2@.+ -- If both ds1 and ds2 are non-empty, this will be an error in the scope checker;+ -- we can let it through here.+ rectifyNonIndentedDecls ds1 ds2 = if null ds1 then (ds2, []) else (ds1, ds2)++-- | Is the given declaration a module definition?+isModule :: Declaration -> Bool+isModule = \case+ Module{} -> True+ _ -> False++-- | Create a name from a string. The boolean indicates whether a part+-- of the name can be token 'constructor'.+mkName' :: Bool -> (Interval, String) -> Parser Name+mkName' constructor (i, s) =+ either parseError return $ mkValidName constructor (getRange i) s++-- | Create a name from a string. The boolean indicates whether a part+-- of the name can be token 'constructor'.+mkValidName :: Bool -> Range -> String -> Either String Name+mkValidName constructor' r s = do+ let+ xs = C.stringNameParts s++ -- The keyword constructor can appear as the only NamePart in the+ -- last segment of a qualified name --- Foo.constructor refers to+ -- the constructor of the record Foo.+ constructor = case xs of+ _ :| [] -> constructor'+ _ -> False+ -- The constructor' argument to mkName' determines whether this+ -- is the last segment of a QName, the local variable constructor+ -- additionally takes whether it's the only NamePart into+ -- consideration.++ mapM_ (isValidId constructor) xs+ unless (alternating xs) $ parseError $ "a name cannot contain two consecutive underscores"+ return $ Name r InScope xs+ where+ parseError = Left+ isValidId _ Hole = return ()+ isValidId con (Id y) = do+ let x = rawNameToString y+ err = "in the name " ++ s ++ ", the part " ++ x ++ " is not valid"+ case parse defaultParseFlags [0] (lexer return) (x <> " ") of+ ParseOk _ TokId{} -> return ()+ ParseFailed{} -> parseError err+ ParseOk _ TokEOF{} -> parseError err+ ParseOk _ (TokKeyword KwConstructor _) | con -> pure ()+ ParseOk _ t -> parseError . ((err ++ " because it is ") ++) $ case t of+ TokQId{} -> "qualified"+ TokQual q _ _ -> case q of+ QualDo -> "a qualified do-block"+ QualOpenIdiom{} -> "a qualified idiom bracket"+ QualEmptyIdiom{} -> "a qualified empty idiom bracket"+ TokKeyword{} -> "a keyword"+ TokLiteral{} -> "a literal"+ TokSymbol s _ -> case s of+ SymDot -> __IMPOSSIBLE__ -- "reserved"+ SymSemi -> "used to separate declarations"+ SymVirtualSemi -> __IMPOSSIBLE__+ SymBar -> "used for with-arguments"+ SymColon -> "part of declaration syntax"+ SymArrow -> "the function arrow"+ SymEqual -> "part of declaration syntax"+ SymLambda -> "used for lambda-abstraction"+ SymUnderscore -> "used for anonymous identifiers"+ SymQuestionMark -> "a meta variable"+ SymAs -> "used for as-patterns"+ SymOpenParen -> "used to parenthesize expressions"+ SymCloseParen -> "used to parenthesize expressions"+ SymOpenIdiomBracket{} -> "an idiom bracket"+ SymCloseIdiomBracket{} -> "an idiom bracket"+ SymEmptyIdiomBracket -> "an empty idiom bracket"+ SymDoubleOpenBrace{} -> "used for instance arguments"+ SymDoubleCloseBrace{} -> "used for instance arguments"+ SymOpenBrace -> "used for hidden arguments"+ SymCloseBrace -> "used for hidden arguments"+ SymOpenVirtualBrace -> __IMPOSSIBLE__+ SymCloseVirtualBrace -> __IMPOSSIBLE__+ SymOpenPragma -> "used for pragmas"+ SymClosePragma -> "used for pragmas"+ SymEllipsis -> "used for function clauses"+ SymDotDot -> "a modality"+ SymEndComment -> "the end-of-comment brace"+ TokString{} -> __IMPOSSIBLE__+ TokTeX{} -> __IMPOSSIBLE__ -- used by the LaTeX backend only+ TokMarkup{} -> __IMPOSSIBLE__ -- ditto+ TokComment{} -> __IMPOSSIBLE__+ TokDummy{} -> __IMPOSSIBLE__++ -- we know that there are no two Ids in a row+ alternating (Hole :| Hole : _) = False+ alternating (_ :| x : xs) = alternating $ x :| xs+ alternating (_ :| []) = True++-- | Create a name from a string+mkName :: (Interval, String) -> Parser Name+mkName = mkName' False++-- | Create a qualified name from a list of strings+mkQName :: [(Interval, String)] -> Parser QName+mkQName ss | Just (ss0, ss1) <- initLast ss = do+ xs0 <- mapM mkName ss0+ xs1 <- mkName' True ss1+ return $ foldr Qual (QName xs1) xs0+mkQName _ = __IMPOSSIBLE__ -- The lexer never gives us an empty list of parts++mkDomainFree_ :: (NamedArg Binder -> NamedArg Binder) -> Maybe Pattern -> Name -> NamedArg Binder+mkDomainFree_ f p n = f $ defaultNamedArg $ Binder p UserBinderName $ mkBoundName_ n++mkRString :: (Interval, String) -> RString+mkRString (i, s) = Ranged (getRange i) s++mkRText :: (Interval, String) -> Ranged Text+mkRText (i, s) = Ranged (getRange i) $ T.pack s++-- | Create a qualified name from a string (used in pragmas).+-- Range of each name component is range of whole string.+-- TODO: precise ranges!++pragmaQName :: (Interval, String) -> Parser QName+pragmaQName (r, s) = do+ let ss = chopWhen (== '.') s+ mkQName $ map (r,) ss++mkNamedArg :: Maybe QName -> Either QName Range -> Parser (NamedArg BoundName)+mkNamedArg x y = do+ lbl <- case x of+ Nothing -> return $ Just $ WithOrigin UserWritten $ unranged "_"+ Just (QName x) -> return $ Just $ WithOrigin UserWritten $ Ranged (getRange x) $ prettyShow x+ _ -> parseError "expected unqualified variable name"+ var <- case y of+ Left (QName y) -> return $ mkBoundName y noFixity'+ Right r -> return $ mkBoundName (noName r) noFixity'+ _ -> parseError "expected unqualified variable name"+ return $ defaultArg $ Named lbl var++-- | Polarity parser.+--+--- Unknown polarities are replaced with the default polarity.++parsePolarity :: (Interval, String) -> Parser (Ranged Occurrence)+parsePolarity (i, s) =+ case s of+ "_" -> ret Unused+ "++" -> ret StrictPos+ "+" -> ret JustPos+ "-" -> ret JustNeg+ "*" -> ret Mixed+ _ -> do+ parseWarning (UnknownPolarity r s)+ ret Mixed+ where+ r = getRange i+ ret = return . Ranged r++recoverLayout :: [(Interval, String)] -> String+recoverLayout [] = ""+recoverLayout xs@((i, _) : _) = go (iStart i) xs+ where+ c0 = posCol (iStart i)++ go _cur [] = ""+ go cur ((i, s) : xs) = padding cur (iStart i) ++ s ++ go (iEnd i) xs++ padding (Pn _ _ l1 c1) (Pn _ _ l2 c2)+ | l1 < l2 = List.genericReplicate (l2 - l1) '\n' ++ List.genericReplicate (max 0 (c2 - c0)) ' '+ | l1 == l2 = List.genericReplicate (c2 - c1) ' '+ | otherwise = __IMPOSSIBLE__++ensureUnqual :: QName -> Parser Name+ensureUnqual (QName x) = return x+ensureUnqual q@Qual{} = parseError' (rStart' $ getRange q) "Qualified name not allowed here"++------------------------------------------------------------------------+-- Lambinds++-- | Result of parsing @LamBinds@.+data LamBinds' a = LamBinds+ { lamBindings :: a -- ^ A number of domain-free or typed bindings or record patterns.+ , absurdBinding :: Maybe Hiding -- ^ Followed by possibly a final absurd pattern.+ } deriving (Functor)++type LamBinds = LamBinds' [LamBinding]++mkAbsurdBinding :: Hiding -> LamBinds+mkAbsurdBinding = LamBinds [] . Just++mkLamBinds :: a -> LamBinds' a+mkLamBinds bs = LamBinds bs Nothing++-- | Build a forall pi (forall x y z -> ...)+forallPi :: List1 LamBinding -> Expr -> Expr+forallPi bs e = Pi (fmap addType bs) e++-- | Converts lambda bindings to typed bindings.+addType :: LamBinding -> TypedBinding+addType (DomainFull b) = b+addType (DomainFree x) = TBind r (singleton x) $ Underscore r Nothing+ where r = getRange x++-- | Returns the value of the first erasure attribute, if any, or else+-- the default value of type 'Erased'.+--+-- Raises warnings for all attributes except for erasure attributes,+-- and for multiple erasure attributes.++onlyErased+ :: [Attr] -- ^ The attributes, in reverse order.+ -> Parser Erased+onlyErased as = do+ es <- catMaybes <$> mapM onlyErased' (reverse as)+ case es of+ [] -> return defaultErased+ [e] -> return e+ e : es -> do+ parseWarning $ MultipleAttributes (getRange es) (Just "erasure")+ return e+ where+ onlyErased' a = case theAttr a of+ RelevanceAttribute{} -> unsup "Relevance"+ CohesionAttribute{} -> unsup "Cohesion"+ LockAttribute{} -> unsup "Lock"+ RewriteAttribute{} -> unsup "Rewrite"+ CA.TacticAttribute{} -> unsup "Tactic"+ PolarityAttribute{} -> unsup "Polarity"+ QuantityAttribute q -> maybe (unsup "Linearity") (return . Just) $ erasedFromQuantity q+ where+ unsup s = do+ parseWarning $ UnsupportedAttribute (attrRange a) (Just s)+ return Nothing++-- | Constructs extended lambdas.++extLam+ :: Range -- ^ The range of the lambda symbol and @where@ or+ -- the braces.+ -> [Attr] -- ^ The attributes in reverse order.+ -> List1 LamClause -- ^ The clauses in reverse order.+ -> Parser Expr+extLam symbolRange attrs cs = do+ e <- onlyErased attrs+ let cs' = List1.reverse cs+ return $ ExtendedLam (getRange (symbolRange, e, cs')) e cs'++-- | Constructs extended or absurd lambdas.++extOrAbsLam+ :: Range -- ^ The range of the lambda symbol.+ -> [Attr] -- ^ The attributes, in reverse order.+ -> Either ([LamBinding], Hiding) (List1 Expr)+ -> Parser Expr+extOrAbsLam lambdaRange attrs cs = case cs of+ Right es -> do+ -- It is of the form @\ { p1 ... () }@.+ e <- onlyErased attrs+ cl <- mkAbsurdLamClause empty es+ return $ ExtendedLam (getRange (lambdaRange, e, es)) e $ singleton cl+ Left (bs, h) -> do+ mapM_ (\a -> parseWarning $+ UnsupportedAttribute (attrRange a) Nothing)+ (reverse attrs)+ List1.ifNull bs+ {-then-} (return $ AbsurdLam r h)+ {-else-} $ \ bs -> return $ Lam r bs (AbsurdLam r h)+ where+ r = fuseRange lambdaRange bs++-- | Interpret an expression as a list of names and (not parsed yet) as-patterns++exprAsNamesAndPatterns :: Expr -> Maybe (List1 (Name, Maybe Expr))+exprAsNamesAndPatterns = mapM exprAsNameAndPattern . exprAsTele+ where+ exprAsTele :: Expr -> List1 Expr+ exprAsTele (RawApp _ es) = List2.toList1 es+ exprAsTele e = singleton e++exprAsNameAndPattern :: Expr -> Maybe (Name, Maybe Expr)+exprAsNameAndPattern (Ident (QName x)) = Just (x, Nothing)+exprAsNameAndPattern (Underscore r _) = Just (setRange r simpleHole, Nothing)+exprAsNameAndPattern (As _ n e) = Just (n, Just e)+exprAsNameAndPattern (Paren r e) = Just (setRange r simpleHole, Just e)+exprAsNameAndPattern _ = Nothing++-- interpret an expression as name or list of hidden / instance names+exprAsNameOrHiddenNames :: Expr -> Maybe (List1 (NamedArg (Name, Maybe Expr)))+exprAsNameOrHiddenNames = \case+ HiddenArg _ (Named Nothing e) ->+ fmap (hide . defaultNamedArg) <$> exprAsNamesAndPatterns e+ InstanceArg _ (Named Nothing e) ->+ fmap (makeInstance . defaultNamedArg) <$> exprAsNamesAndPatterns e+ e ->+ singleton . defaultNamedArg <$> exprAsNameAndPattern e++boundNamesOrAbsurd :: List1 Expr -> Parser (Either (List1 (NamedArg Binder)) (List1 Expr))+boundNamesOrAbsurd es+ | any isAbsurd es = return $ Right es+ | otherwise =+ case mapM exprAsNameAndPattern es of+ Nothing -> parseError $ "expected sequence of bound identifiers"+ Just good -> fmap Left $ forM good $ \ (n, me) -> do+ p <- traverse exprToPattern me+ return (defaultNamedArg (Binder p UserBinderName (mkBoundName_ n)))++ where++ isAbsurd :: Expr -> Bool+ isAbsurd (Absurd _) = True+ isAbsurd (HiddenArg _ (Named _ e)) = isAbsurd e+ isAbsurd (InstanceArg _ (Named _ e)) = isAbsurd e+ isAbsurd (Paren _ e) = isAbsurd e+ isAbsurd (As _ _ e) = isAbsurd e+ isAbsurd (RawApp _ es) = any isAbsurd es+ isAbsurd _ = False++-- | Match a pattern-matching "assignment" statement @p <- e@+exprToAssignment :: Expr -> Parser (Maybe (Pattern, Range, Expr))+exprToAssignment e@(RawApp _r es)+ | (es1, arr : es2) <- List2.break isLeftArrow es =+ case filter isLeftArrow es2 of+ arr : _ -> parseError' (rStart' $ getRange arr) $ "Unexpected " ++ prettyShow arr+ [] ->+ -- Andreas, 2021-05-06, issue #5365+ -- Handle pathological cases like @do <-@ and @do x <-@.+ case (es1, es2) of+ (e1:rest1, e2:rest2) -> do+ p <- exprToPattern $ rawApp $ e1 :| rest1+ pure $ Just (p, getRange arr, rawApp (e2 :| rest2))+ _ -> parseError' (rStart' $ getRange e) $ "Incomplete binding " ++ prettyShow e+ where+ isLeftArrow (Ident (QName (Name _ _ (Id arr :| [])))) =+ arr `elem` ["<-", "\x2190"] -- \leftarrow [issue #5465, unicode might crash happy]+ isLeftArrow _ = False+exprToAssignment _ = pure Nothing++-- | Build a with-block+buildWithBlock ::+ [Either RewriteEqn (List1 (Named Name Expr))] ->+ Parser ([RewriteEqn], [Named Name Expr])+buildWithBlock rees = case groupByEither rees of+ (Left rs : rest) -> (List1.toList rs,) <$> finalWith rest+ rest -> ([],) <$> finalWith rest++ where++ finalWith :: (HasRange a, HasRange b) =>+ [Either (List1 a) (List1 (List1 b))] -> Parser [b]+ finalWith [] = pure $ []+ finalWith [Right ees] = pure $ List1.toList $ sconcat ees+ finalWith (Right{} : tl) = parseError' (rStart' $ getRange tl)+ "Cannot use rewrite / pattern-matching with after a with-abstraction."+ finalWith (Left{} : _) = __IMPOSSIBLE__++-- | Build a with-statement+buildWithStmt :: List1 (Named Name Expr) ->+ Parser [Either RewriteEqn (List1 (Named Name Expr))]+buildWithStmt nes = do+ ws <- mapM buildSingleWithStmt (List1.toList nes)+ let rws = groupByEither ws+ pure $ map (first (Invert ())) rws++buildUsingStmt :: List1 Expr -> Parser RewriteEqn+buildUsingStmt es = do+ mpatexprs <- mapM exprToAssignment es+ case mapM (fmap $ \(pat, _, expr) -> (pat, expr)) mpatexprs of+ Nothing -> parseError' (rStart' $ getRange es) "Expected assignments"+ Just assignments -> pure $ LeftLet assignments++buildSingleWithStmt ::+ Named Name Expr ->+ Parser (Either (Named Name (Pattern, Expr)) (Named Name Expr))+buildSingleWithStmt e = do+ mpatexpr <- exprToAssignment (namedThing e)+ pure $ case mpatexpr of+ Just (pat, _, expr) -> Left ((pat, expr) <$ e)+ Nothing -> Right e++-- | Build a do-statement+defaultBuildDoStmt :: Expr -> [LamClause] -> Parser DoStmt+defaultBuildDoStmt e (_ : _) = parseError' (rStart' $ getRange e) "Only pattern matching do-statements can have where clauses."+defaultBuildDoStmt e [] = pure $ DoThen e++buildDoStmt :: Expr -> [LamClause] -> Parser DoStmt+buildDoStmt (Let r ds Nothing) [] = return $ DoLet r ds+buildDoStmt e@(RawApp _ _) cs = do+ mpatexpr <- exprToAssignment e+ case mpatexpr of+ Just (pat, r, expr) -> pure $ DoBind r pat expr cs+ Nothing -> defaultBuildDoStmt e cs+buildDoStmt e cs = defaultBuildDoStmt e cs+++{--------------------------------------------------------------------------+ Patterns+ --------------------------------------------------------------------------}++-- | Turn an expression into a left hand side.+exprToLHS :: Expr -> Parser ([RewriteEqn] -> [WithExpr] -> LHS)+exprToLHS e = LHS <$> exprToPattern e++-- | Turn an expression into a pattern. Fails if the expression is not a+-- valid pattern.+exprToPattern :: Expr -> Parser Pattern+exprToPattern e = case C.isPattern e of+ Nothing -> parseErrorRange e $ "Not a valid pattern: " ++ prettyShow e+ Just p -> pure p++-- | Turn an expression into a name. Fails if the expression is not a+-- valid identifier.+exprToName :: Expr -> Parser Name+exprToName (Ident (QName x)) = return x+exprToName e = parseErrorRange e $ "Not a valid identifier: " ++ prettyShow e++-- | When given expression is @e1 = e2@, turn it into a named expression.+-- Call this inside an implicit argument @{e}@ or @{{e}}@, where+-- an equality must be a named argument (rather than a cubical partial match).+maybeNamed :: Expr -> Parser (Named_ Expr)+maybeNamed e =+ case e of+ Equal _ e1 e2 -> do+ let succeed x = return $ named (WithOrigin UserWritten $ Ranged (getRange e1) x) e2+ case e1 of+ Ident (QName x) -> succeed $ nameToRawName x+ -- We could have the following, but names of arguments cannot be _.+ -- Underscore{} -> succeed $ "_"+ _ -> parseErrorRange e $ "Not a valid named argument: " ++ prettyShow e+ _ -> return $ unnamed e++-- Andreas, 2024-02-20, issue #7136:+-- The following function has been rewritten to a defensive pattern matching style+-- to be robust against future parser changes.+patternSynArgs :: [NamedArg Binder] -> Parser [WithHiding Name]+patternSynArgs = mapM \ x -> do+ let+ abort s = parseError $+ "Illegal pattern synonym argument " ++ prettyShow x ++ "\n" +++ "(" ++ s ++ ".)"+ noAnn s = s ++ " annotations not allowed in pattern synonym arguments"++ case x of++ -- Invariant: fixity is not used here, and neither finiteness+ Arg _ (Named _ (Binder _ _ (BName _ fix _ fin)))+ | not $ null fix -> __IMPOSSIBLE__+ | fin -> __IMPOSSIBLE__++ -- Error cases:+ Arg _ (Named _ (Binder (Just _) _ _)) ->+ abort "Arguments to pattern synonyms cannot be patterns themselves"+ Arg _ (Named _ (Binder _ _ (BName _ _ tac _))) | not (null tac) ->+ abort $ noAnn "Tactic"++ -- Benign case:+ Arg ai (Named mn (Binder Nothing _ (BName n _ _ _)))+ -- allow {n = n} for backwards compat with Agda 2.6+ | maybe True ((C.nameToRawName n ==) . rangedThing . woThing) mn ->+ case ai of++ -- Benign case:+ ArgInfo h (Modality Relevant{} (Quantityω _) Continuous (PolarityModality { modPolarityAnn = MixedPolarity })) UserWritten UnknownFVs (Annotation IsNotLock IsNotRewrite) ->+ return $ WithHiding h n++ -- Error cases:+ ArgInfo _ _ _ _ (Annotation (IsLock _) _) ->+ abort $ noAnn "Lock"++ ArgInfo _ _ _ _ (Annotation _ (IsRewrite _)) ->+ abort $ noAnn "Rewrite"++ ArgInfo _ (Modality r q c p) _ _ _+ | not (isRelevant r) ->+ abort "Arguments to pattern synonyms must be relevant"+ | not (isQuantityω q) ->+ abort $ noAnn "Quantity"+ | modPolarityAnn p /= MixedPolarity ->+ abort $ noAnn "Polarity"+ | c /= Continuous ->+ abort $ noAnn "Cohesion"++ -- Invariant: origin and fvs not used.+ ArgInfo _ _ _ (KnownFVs _) _ -> __IMPOSSIBLE__+ ArgInfo _ _ o _ _ | o /= UserWritten -> __IMPOSSIBLE__++ ArgInfo _ _ _ _ _ -> __IMPOSSIBLE__++ -- Error case: other named args are unsupported (issue #7136)+ | otherwise ->+ abort "Arguments to pattern synonyms cannot be named"++mkLamClause+ :: Catchall+ -> [Expr] -- ^ Possibly empty list of patterns.+ -> RHS+ -> Parser LamClause+mkLamClause catchall es rhs = mapM exprToPattern es <&> \ ps ->+ LamClause{ lamLHS = ps, lamRHS = rhs, lamCatchall = catchall }++mkAbsurdLamClause :: Catchall -> List1 Expr -> Parser LamClause+mkAbsurdLamClause catchall es = mkLamClause catchall (List1.toList es) AbsurdRHS++{- RHS or type signature -}++data RHSOrTypeSigs+ = JustRHS RHS+ | TypeSigsRHS Expr+ deriving Show++patternToNames :: Pattern -> Parser (List1 (Arg Name))+patternToNames = \case+ IdentP _ (QName i) -> return $ singleton $ defaultArg i+ WildP r -> return $ singleton $ defaultArg $ C.noName r+ DotP kwr _ _ (Ident (QName i)) -> return $ singleton $ makeIrrelevant kwr $ defaultArg i+ RawAppP _ ps -> sconcat . List2.toList1 <$> mapM patternToNames ps+ p -> parseError $+ "Illegal name in type signature: " ++ prettyShow p++-- | Interpret leading dot as irrelevance++patternToArgPattern :: Pattern -> Arg Pattern+patternToArgPattern = \case+ DotP kwr _ _ (Ident x) -> makeIrrelevant kwr $ defaultArg $ IdentP True x+ DotP kwr _ _ (Underscore r _) -> makeIrrelevant kwr $ defaultArg $ WildP r+ p -> defaultArg p+++funClauseOrTypeSigs :: [Attr] -> ([RewriteEqn] -> [WithExpr] -> LHS)+ -> [Either RewriteEqn (List1 (Named Name Expr))]+ -> RHSOrTypeSigs+ -> WhereClause -> Parser (List1 Declaration)+funClauseOrTypeSigs attrs lhs' with mrhs wh = do+ (rs , es) <- buildWithBlock with+ let lhs = lhs' rs (map (fmap observeModifiers) es)+ -- traceShowM lhs+ case mrhs of+ JustRHS rhs -> do+ whenJust (haveTacticAttr attrs) \ re ->+ parseWarning $ MisplacedAttributes (getRange re) $+ "Ignoring tactic attribute, illegal in function clauses"+ whenJust (haveRewAttr attrs) \ re ->+ parseWarning $ MisplacedAttributes (getRange re) $+ "Ignoring local rewrite attribute, illegal in function clauses"+ -- Andreas, 2025-07-09, issue #7989: extract irrelevance info from lhs pattern+ let (Arg info p) = patternToArgPattern $ lhsOriginalPattern lhs+ -- Andreas, 2025-07-10, issue #7988: allow attributes in function clause+ info <- applyAttrs attrs info+ return $ singleton $ FunClause info lhs{ lhsOriginalPattern = p } rhs wh empty+ TypeSigsRHS e -> case wh of+ NoWhere -> case lhs of+ LHS p _ _ | hasEllipsis p -> parseError "The ellipsis ... cannot have a type signature"+ LHS _ _ (_:_) -> parseError "Illegal: with in type signature"+ LHS _ (_:_) _ -> parseError "Illegal: rewrite in type signature"+ LHS p _ _ | hasWithPatterns p -> parseError "Illegal: with patterns in type signature"+ LHS p [] [] -> forMM (patternToNames p) $ \ (Arg info x) -> do+ info <- applyAttrs attrs info+ return $ typeSig info (getTacticAttr attrs) x e+ _ -> parseError "A type signature cannot have a where clause"++typeSig :: ArgInfo -> TacticAttribute -> Name -> Expr -> Declaration+typeSig i tac n e = TypeSig i tac n (Generalized e)++------------------------------------------------------------------------+-- * Relevance++makeIrrelevant :: (HasRange a, LensRelevance b) => a -> b -> b+makeIrrelevant = setRelevance . Irrelevant . OIrrDot . getRange++makeShapeIrrelevant :: (HasRange a, LensRelevance b) => a -> b -> b+makeShapeIrrelevant = setRelevance . ShapeIrrelevant . OShIrrDotDot . getRange++defaultIrrelevantArg :: HasRange a => a -> b -> Arg b+defaultIrrelevantArg a = makeIrrelevant a . defaultArg++defaultShapeIrrelevantArg :: HasRange a => a -> b -> Arg b+defaultShapeIrrelevantArg a = makeShapeIrrelevant a . defaultArg++makeIrrelevantM :: (HasRange a, LensRelevance b) => a -> b -> Parser b+makeIrrelevantM r x = do+ assertPristineRelevance r x+ return $ makeIrrelevant r x++makeShapeIrrelevantM :: (HasRange a, LensRelevance b) => a -> b -> Parser b+makeShapeIrrelevantM r x = do+ assertPristineRelevance r x+ return $ makeShapeIrrelevant r x++assertPristineRelevance :: (HasRange a, LensRelevance b) => a -> b -> Parser ()+assertPristineRelevance r x = unless (null $ getRelevance x) $+ parseErrorRange r $ "Conflicting relevance information"++------------------------------------------------------------------------+-- * Attributes++-- | Parse an attribute.+toAttribute :: Range -> Expr -> Parser (Maybe Attr)+toAttribute r e = do+ case exprToAttribute r e of+ Nothing -> Nothing <$ parseWarning (UnknownAttribute r s)+ Just a -> fmap Just $ theAttribute $ Attr r s a+ where+ s = prettyShow e++-- | Updates 'parseAttributes' and returns an @rewrite attribute+rewAttribute :: Range -> Parser (Maybe Attr)+rewAttribute r = fmap Just $ theAttribute $+ Attr r "rewrite" (RewriteAttribute $ IsRewrite r)++-- | Updates 'parseAttributes' and returns the attribute+theAttribute :: Attr -> Parser Attr+theAttribute attr = do+ modify' \ st -> st{ parseAttributes = attr : parseAttributes st }+ return attr++-- | Apply an attribute to thing (usually `Arg`).+-- This will fail if one of the attributes is already set+-- in the thing to something else than the default value.+applyAttr :: (LensAttribute a) => Attr -> a -> Parser a+applyAttr attr@(Attr _ _ a) = maybe failure return . setPristineAttribute a+ where+ failure = errorConflictingAttribute attr++-- | Apply attributes to thing (usually `Arg`).+-- Expects a reversed list of attributes.+-- This will fail if one of the attributes is already set+-- in the thing to something else than the default value.+applyAttrsDropTactic :: LensAttribute a => [Attr] -> a -> Parser a+applyAttrsDropTactic rattrs arg = do+ let (tactics, attrs) = partition isTactic rattrs+ unlessNull tactics \ ts ->+ parseWarning $ MisplacedAttributes (getRange ts) $+ "Ignoring misplaced @(tactic ...) attribute"+ applyAttrs attrs arg+ where+ isTactic :: Attr -> Bool+ isTactic = isJust . C.theTacticAttribute . isTacticAttribute . theAttr++-- | Apply attributes to thing (usually `Arg`).+-- Expects a reversed list of attributes.+-- This will fail if one of the attributes is already set+-- in the thing to something else than the default value.+applyAttrs :: LensAttribute a => [Attr] -> a -> Parser a+applyAttrs rattrs arg = do+ let attrs = reverse rattrs+ checkForUniqueAttribute (isJust . isQuantityAttribute ) attrs+ checkForUniqueAttribute (isJust . isRelevanceAttribute) attrs+ checkForUniqueAttribute (not . null . isTacticAttribute) attrs+ foldM (flip applyAttr) arg attrs++applyAttrs1 :: LensAttribute a => List1 Attr -> a -> Parser a+applyAttrs1 = applyAttrs . List1.toList++-- | Set the tactic attribute of a binder+setTacticAttr :: [Attr] -> NamedArg Binder -> NamedArg Binder+setTacticAttr [] = id+setTacticAttr as = updateNamedArg $ fmap $ \ b ->+ case getTacticAttr as of+ t | null t -> b+ | otherwise -> b { bnameTactic = t }++-- | Get the tactic attribute if present.+getTacticAttr :: [Attr] -> TacticAttribute+getTacticAttr = C.TacticAttribute . haveTacticAttr++-- | Check if tactic attribute is present.+haveTacticAttr :: [Attr] -> Maybe (Ranged Expr)+haveTacticAttr as =+ case tacticAttributes [ a | Attr _ _ a <- as ] of+ [CA.TacticAttribute e] -> Just e+ [] -> Nothing+ _ -> __IMPOSSIBLE__++haveRewAttr :: [Attr] -> Maybe RewriteAnn+haveRewAttr as =+ case rewAttributes $ theAttr <$> as of+ [CA.RewriteAttribute r] -> Just r+ [] -> Nothing+ _ -> __IMPOSSIBLE__++-- | Report a parse error if two attributes in the list are of the same kind,+-- thus, present conflicting information.+checkForUniqueAttribute :: (Attribute -> Bool) -> [Attr] -> Parser ()+checkForUniqueAttribute p attrs = do+ let pAttrs = filter (p . theAttr) attrs+ when (length pAttrs >= 2) $+ errorConflictingAttributes pAttrs++-- | Report an attribute as conflicting (e.g., with an already set value).+errorConflictingAttribute :: Attr -> Parser a+errorConflictingAttribute a = parseErrorRange a $+ "Conflicting attribute: " ++ prettyAttr a++-- | Report attributes as conflicting (e.g., with each other).+-- Precondition: List not emtpy.+errorConflictingAttributes :: [Attr] -> Parser a+errorConflictingAttributes [a] = errorConflictingAttribute a+errorConflictingAttributes as = parseErrorRange as $+ "Conflicting attributes: " ++ unwords (map prettyAttr as)++prettyAttr :: Attr -> String+prettyAttr = ("@" ++) . attrName++-- | Apply some attributes to some binders.+applyAttributes :: Functor f+ => [Attr]+ -- ^ Can contain @tactic@ attribute.+ -> ArgInfo+ -- ^ If the attributes to be set are not at default value here, crash.+ -> f (NamedArg Binder)+ -- ^ Binders to apply attributes to.+ -> Parser (f (NamedArg Binder))+ -- ^ Binders with attributes applied.+applyAttributes attrs ai bs = do+ applyAttrs attrs ai <&> \ ai' ->+ fmap (setTacticAttr attrs . setArgInfo ai') bs++------------------------------------------------------------------------+-- * Brackets++-- | Turn a 'QualifiedToken' into a properly qualified name, and the+-- range of its keyword.+-- If the qualified token is an opening bracket, this also calls+-- 'openBracket'.+unqualifyToken :: QualifiedToken -> Parser (QName, Range)+unqualifyToken (QualifiedToken tok iss kw) = (,) <$> mkQName iss <*> case tok of+ QualOpenIdiom tok -> openBracket $ TokSymbol (SymOpenIdiomBracket tok) kw+ _ -> pure (getRange kw)++-- | Close a double brace from a pair of single closing braces.+--+-- This implements the rule described in the grammar that the braces+-- must be adjacent, and additionally acts as 'closeBracket', generating+-- the proper error if the opening braces were Unicode.+closeTwoBraces :: Interval -> Interval -> Parser Range+closeTwoBraces i1 i2 =+ let ivl = getIntervalFile i1 <$ fuseIntervals (void i1) (void i2) in+ if posPos (iEnd i2) - posPos (iStart i1) > 2+ then parseErrorRange i2 "Expecting '}}', found separated '}'s."+ -- We just call closeBracket with a fake token so as to not+ -- duplicate the hairy code below.+ else closeBracket (TokSymbol (SymDoubleCloseBrace False) ivl)
@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} {-| This module contains the lex actions that handle the layout rules. The way it works is that the 'Parser' monad keeps track of a stack of@@ -7,26 +7,110 @@ > f x = x' > where- > x' = case x of { True -> False; False -> ...+ > x' = do y <- foo x; bar ... At the @...@ the layout context would be - > [NoLayout, Layout 4, Layout 0]+ > [Layout 12, Layout 4, Layout 0] - The closest layout block is the one containing the @case@ branches. This- block starts with an open brace (@\'{\'@) and so doesn't use layout. The- second closest block is the @where@ clause. Here, there is no open brace- so the block is started by the @x'@ token which has indentation 4. Finally- there is a top-level layout block with indentation 0.+ The closest layout block is the one following @do@ which is+ started by token @y@ at column 12. The second closest block is the+ @where@ clause started by the @x'@ token which has indentation 4.+ Finally, there is a top-level layout block with indentation 0.++ In April 2021 we changed layout handling in the lexer to allow+ stacking of layout keywords on the same line, e.g.:++ > private module M where+ > postulate A : Set+ > private+ > B : Set++ The layout columns in the layout context (stack of layout blocks) can+ have 'LayoutStatus' either 'Tentative' or 'Confirmed'. New layout+ columns following a layout keyword are tentative until we see a new+ line. E.g.++ - The first @private@ block (column 8) is 'Tentative' when we+ encounter the layout keyword @where@.++ - The @postulate@ block (column 12) is 'Tentative' until the newline+ after @A : Set@.++ In contrast,++ - The @module@ block (column 2) is 'Confirmed' from the beginning+ since the first token (@postulate@) after the layout keyword @where@+ is on a new line.++ - The second @private@ block (column 14) is also 'Confirmed' from the+ beginning (for the same reason).++ A new layout column has to be strictly above the last __confirmed__+ column only. E.g., when encountering @postulate@ at column 2 after+ @where@, the confirmed column is still 0, so this is a valid start of+ the block following @where@.++ The column 8 of the @private@ block never enters the 'Confirmed' status+ but remains 'Tentative'. Also, this block can never get more than the+ one declaration it has (@module...@), because when the @module@ block+ closes due to a column \< 2, it closes as well. One could say that+ tentative blocks buried under confirmed blocks are passive, the only+ wait for their closing.++ To implement the process of block confirmation (function+ 'confirmLayout'), the lexer has to act on newline characters (except for+ those in a block comment).++ - In ordinary mode, when encountering a newline, we confirm the top+ unconfirmed blocks. Example: The newline after @A : Set@ confirms+ the column 12 after @postulate@. Function: 'confirmLayoutAtNewLine',+ state @bol@.++ - In the @layout@ state following a layout keyword, a newline does not+ confirm any block, but announces that the next block should be+ confirmed from the start. Function: 'confirmedLayoutComing'.++ In order to implement 'confirmedLayoutComing' we have a 'LayoutStatus'+ flag in the parse state (field 'stateLayStatus'). By default, for a new+ layout block, the status is 'Tentative' (unless we saw a newline).++ New layout blocks are created as follows. When a layout keyword is+ encountered, we enter lexer state 'layout' via function 'withLayout'.+ When we exit the 'layout' state via 'newLayoutBlock' with a token that+ marks the new layout column, we push a new 'LayoutBlock' onto the+ 'LayoutContext' using the given column and the current 'parseLayStatus'+ which is then reset to 'Tentative'.++ The new block is actually only pushed if the column is above the last+ confirmed layout column ('confirmedLayoutColumn'). If this check fails,+ we instead enter the 'empty_layout' state. This state produces the+ closing brace and is immediately left for 'bol' (beginning of line).++ (Remark: In 'bol' we might confirm some tentative top blocks, but this+ is irrelevant, since they will be closed immediately, given that the+ current token is left of the confirmed column, and tentative columns+ above it must be to the right of this column.)++ The 'offsideRule' (state 'bol') is unchanged. It checks how the first+ token on a new line relates to the top layout column, be it tentative or+ confirmed. (Since we are on a new line, 'Tentative' can only happen when+ we popped some 'Confirmed' columns and continue popping the top+ 'Tentative' columns here.) While the token is to the left of the layout+ column, we keep closing blocks.+ -} module Agda.Syntax.Parser.Layout- ( openBrace, closeBrace- , withLayout+ ( withLayout , offsideRule- , newLayoutContext+ , newLayoutBlock , emptyLayout+ , confirmLayout ) where +import Control.Monad ( when )+import Control.Monad.State ( gets, modify )+ import Agda.Syntax.Parser.Lexer import Agda.Syntax.Parser.Alex import Agda.Syntax.Parser.Monad@@ -34,85 +118,63 @@ import Agda.Syntax.Parser.LexActions import Agda.Syntax.Position ---- | Executed upon lexing an open brace (@\'{\'@). Enters the 'NoLayout'--- context.-openBrace :: LexAction Token-openBrace = token $ \_ ->- do pushContext NoLayout- i <- getParseInterval- return (TokSymbol SymOpenBrace i)---{-| Executed upon lexing a close brace (@\'}\'@). Exits the current layout- context. This might look a bit funny--the lexer will happily use a close- brace to close a context open by a virtual brace. This is not a problem- since the parser will make sure the braces are appropriately matched.--}-closeBrace :: LexAction Token-closeBrace = token $ \_ ->- do popContext- i <- getParseInterval- return (TokSymbol SymCloseBrace i)+import Agda.Utils.Functor ((<&>)) +{-| Executed for the first token in each line (see 'Agda.Syntax.Parser.Lexer.bol'),+ except when the last token was a layout keyword. -{-| Executed for the first token in each line (see 'Agda.Syntax.Parser.Lexer.bol'). Checks the position of the token relative to the current layout context. If the token is - /to the left/ :- Exit the current context and a return virtual close brace (stay in the- 'Agda.Syntax.Parser.Lexer.bol' state).+ Exit the current block and a return virtual close brace (stay in the+ 'Agda.Syntax.Parser.Lexer.bol' state). - /same column/ :- Exit the 'Agda.Syntax.Parser.Lexer.bol' state and return a virtual semi- colon.+ Exit the 'Agda.Syntax.Parser.Lexer.bol' state and return a virtual semi+ colon. - /to the right/ :- Exit the 'Agda.Syntax.Parser.Lexer.bol' state and continue lexing.+ Exit the 'Agda.Syntax.Parser.Lexer.bol' state and continue lexing. - If the current block doesn't use layout (i.e. it was started by- 'openBrace') all positions are considered to be /to the right/. -} offsideRule :: LexAction Token-offsideRule inp _ _ =- do offs <- getOffside p- case offs of- LT -> do popContext- return (TokSymbol SymCloseVirtualBrace (Interval p p))- EQ -> do popLexState- return (TokSymbol SymVirtualSemi (Interval p p))- GT -> do popLexState- lexToken- where- p = lexPos inp+offsideRule = LexAction $ \ inp _ _ -> do+ let p = lexPos inp+ i = posToInterval (lexSrcFile inp) p p+ getOffside p >>= \case+ LT -> do popBlock+ return (TokSymbol SymCloseVirtualBrace i)+ EQ -> do popLexState+ return (TokSymbol SymVirtualSemi i)+ GT -> do popLexState+ lexToken {-| This action is only executed from the 'Agda.Syntax.Parser.Lexer.empty_layout' state. It will exit this state, enter the 'Agda.Syntax.Parser.Lexer.bol' state, and return a virtual close brace (closing the empty layout block started- by 'newLayoutContext').+ by 'newLayoutBlock'). -} emptyLayout :: LexAction Token-emptyLayout inp _ _ =- do popLexState- pushLexState bol- return (TokSymbol SymCloseVirtualBrace (Interval p p))- where- p = lexPos inp+emptyLayout = LexAction $ \ inp _ _ -> do+ let p = lexPos inp+ i = posToInterval (lexSrcFile inp) p p+ popLexState+ pushLexState bol+ return (TokSymbol SymCloseVirtualBrace i) -{-| Start a new layout context. This is one of two ways to get out of the- 'Agda.Syntax.Parser.Lexer.layout' state (the other is 'openBrace'). There are+{-| Start a new layout block. This is how to get out of the+ 'Agda.Syntax.Parser.Lexer.layout' state. There are two possibilities: - - The current token is to the right of the current layout context (or we're- in a no layout context).+ - The current token is to the right of the confirmed layout column. - - The current token is to the left of or in the same column as the current- context.+ - The current token is to the left of or in the same column as the confirmed+ layout column. - In the first case everything is fine and we enter a new layout context at+ In the first case everything is fine and we enter a new layout block at the column of the current token. In the second case we have an empty layout block so we enter the 'Agda.Syntax.Parser.Lexer.empty_layout' state. In both cases we return a virtual open brace without consuming any input.@@ -123,26 +185,71 @@ then enter a state in which the only thing you can do is generate the second one. -}-newLayoutContext :: LexAction Token-newLayoutContext inp _ _ =- do let offset = posCol p- ctx <- topContext- case ctx of- Layout prevOffs | prevOffs >= offset ->- do pushLexState empty_layout- return (TokSymbol SymOpenVirtualBrace (Interval p p))- _ ->- do pushContext (Layout offset)- return (TokSymbol SymOpenVirtualBrace (Interval p p))- where- p = lexPos inp+newLayoutBlock :: LexAction Token+newLayoutBlock = LexAction $ \ inp _ _ -> do+ let p = lexPos inp+ i = posToInterval (lexSrcFile inp) p p+ offset = posCol p+ status <- popPendingLayout+ kw <- gets parseLayKw+ prevOffs <- confirmedLayoutColumn <$> getContext+ if prevOffs >= offset+ then pushLexState empty_layout+ else do+ when (status == Confirmed) $+ modifyContext $ confirmTentativeBlocks $ Just offset+ pushBlock $ Layout kw status offset+ return $ TokSymbol SymOpenVirtualBrace i+ where + -- Get and reset the status of the coming layout block.+ popPendingLayout :: Parser LayoutStatus+ popPendingLayout = do+ status <- gets parseLayStatus+ resetLayoutStatus+ return status + -- The confirmed layout column, or 0 if there is none.+ confirmedLayoutColumn :: LayoutContext -> Column+ confirmedLayoutColumn = \case+ Layout _ Confirmed c : _ -> c+ Layout _ Tentative _ : cxt -> confirmedLayoutColumn cxt+ [] -> 0 -- should only happen when looking at the first token (top-level layout)+ -- | Compute the relative position of a location to the -- current layout context.-getOffside :: Position -> Parser Ordering+getOffside :: Position' a -> Parser Ordering getOffside loc =- do ctx <- topContext- return $ case ctx of- Layout n -> compare (posCol loc) n- _ -> GT+ getContext <&> \case+ Layout _ _ n : _ -> compare (posCol loc) n+ _ -> GT++-- | At a new line, we confirm either existing tentative layout+-- columns, or, if the last token was a layout keyword, the expected+-- new layout column.+confirmLayout :: Parser ()+confirmLayout = getLexState >>= \ case+ s : _ | s == layout -> confirmedLayoutComing+ _ -> confirmLayoutAtNewLine+ where++ -- Mark the pending layout block as 'Confirmed'.+ confirmedLayoutComing :: Parser ()+ confirmedLayoutComing = modify $ \ s -> s { parseLayStatus = Confirmed }++ -- Encountering a newline outside of a 'layout' state we confirm top+ -- tentative layout columns.+ confirmLayoutAtNewLine :: Parser ()+ confirmLayoutAtNewLine = modifyContext $ confirmTentativeBlocks Nothing++-- | Confirm all top 'Tentative' layout columns.+-- If a column is given, only those below the given column.+--+-- The code ensures that the newly created 'Definitive' columns+-- are strictly decreasing.+--+confirmTentativeBlocks :: Maybe Column -> LayoutContext -> LayoutContext+confirmTentativeBlocks mcol = \case+ Layout kw Tentative col : cxt | maybe True (col <) mcol+ -> Layout kw Confirmed col : confirmTentativeBlocks (Just col) cxt+ cxt -> cxt
@@ -1,8 +1,15 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ module Agda.Syntax.Parser.Layout where -import Agda.Syntax.Parser.Alex-import Agda.Syntax.Parser.Tokens+import Agda.Syntax.Parser.Alex (LexAction)+import Agda.Syntax.Parser.Monad (Parser)+import Agda.Syntax.Parser.Tokens (Token) offsideRule :: LexAction Token-newLayoutContext :: LexAction Token+newLayoutBlock :: LexAction Token emptyLayout :: LexAction Token++confirmLayout :: Parser ()+-- confirmLayoutAtNewLine :: Parser ()+-- confirmedLayoutComing :: Parser ()
@@ -1,5 +1,7 @@ {-# LANGUAGE CPP #-} +{-# OPTIONS_GHC -Wunused-imports #-}+ {-| This module contains the building blocks used to construct the lexer. -} module Agda.Syntax.Parser.LexActions@@ -10,31 +12,37 @@ , token , withInterval, withInterval', withInterval_ , withLayout- , begin, end, endWith+ , andThen, skip+ , begin, end, beginWith, endWith , begin_, end_ , lexError -- ** Specialized actions- , keyword, symbol, identifier, literal+ , keyword, symbol, qualifiedToken, literal, literal', integer -- * Lex predicates , followedBy, eof, inState ) where +import Control.Monad.State (modify)++import Data.Bifunctor import Data.Char-import Control.Arrow+#if !MIN_VERSION_base(4,20,0)+import Data.Foldable (foldl')+#endif+import Data.Maybe +import Agda.Syntax.Common (pattern Ranged) import Agda.Syntax.Parser.Lexer import Agda.Syntax.Parser.Alex import Agda.Syntax.Parser.Monad import Agda.Syntax.Parser.Tokens import Agda.Syntax.Position import Agda.Syntax.Literal-import Agda.Syntax.Concrete.Name import Agda.Utils.List-import Agda.Utils.Tuple-import Agda.Utils.Unicode+import Agda.Utils.List1 (String1, toList)+import qualified Agda.Utils.List1 as List1 -#include "../../undefined.h" import Agda.Utils.Impossible {--------------------------------------------------------------------------@@ -43,14 +51,23 @@ -- | Called at the end of a file. Returns 'TokEOF'. returnEOF :: AlexInput -> Parser Token-returnEOF inp =- do setLastPos $ lexPos inp- setPrevToken "<EOF>"- return TokEOF+returnEOF AlexInput{ lexSrcFile, lexPos } = do+ -- Andreas, 2018-12-30, issue #3480+ -- The following setLastPos leads to parse error reporting+ -- far away from the interesting position, in particular+ -- if there is a long comment before the EOF.+ -- (Such a long comment is frequent in interactive programming, as+ -- commenting out until the end of the file is a common habit.)+ -- -- setLastPos lexPos+ -- Without it, we get much more useful error locations.+ setPrevToken "<EOF>"+ return $ TokEOF $ posToInterval lexSrcFile lexPos lexPos -- | Set the current input and lex a new token (calls 'lexToken'). skipTo :: AlexInput -> Parser Token-skipTo inp = setLexInput inp >> lexToken+skipTo inp = do+ setLexInput inp+ lexToken {-| Scan the input to find the next token. Calls 'Agda.Syntax.Parser.Lexer.alexScanUser'. This is the main lexing function@@ -59,173 +76,234 @@ -} lexToken :: Parser Token lexToken =- do inp <- getLexInput- lss@(ls:_) <- getLexState+ do inp <- getLexInput+ lss <- getLexState flags <- getParseFlags- case alexScanUser (lss, flags) (foolAlex inp) ls of- AlexEOF -> returnEOF inp- AlexSkip inp' len -> skipTo (newInput inp inp' len)- AlexToken inp' len action -> fmap postToken $ action inp (newInput inp inp' len) len- AlexError i -> parseError $ "Lexical error" ++- (case lexInput i of- '\t' : _ -> " (you may want to replace tabs with spaces)"- _ -> "") ++- ":"+ case alexScanUser (lss, flags) inp (headWithDefault __IMPOSSIBLE__ lss) of+ AlexEOF -> returnEOF inp+ AlexSkip inp' len -> skipTo inp'+ AlexToken inp' len action -> postToken <$> runLexAction action inp inp' len+ AlexError i -> parseError $ concat+ [ "Lexical error"+ , case listToMaybe $ lexInput i of+ Just '\t' -> " (you may want to replace tabs with spaces)"+ Just c | not (isPrint c) -> " (unprintable character)"+ _ -> ""+ , ":"+ ] +isSub :: Char -> Bool+isSub c = '\x2080' <= c && c <= '\x2089'++readSubscript :: [Char] -> Integer+readSubscript = read . map (\c -> toEnum (fromEnum c - 0x2080 + fromEnum '0'))+ postToken :: Token -> Token postToken (TokId (r, "\x03bb")) = TokSymbol SymLambda r+postToken (TokId (r, "\x2026")) = TokSymbol SymEllipsis r postToken (TokId (r, "\x2192")) = TokSymbol SymArrow r-postToken (TokId (r, "\x2983")) = TokSymbol SymDoubleOpenBrace r-postToken (TokId (r, "\x2984")) = TokSymbol SymDoubleCloseBrace r+postToken (TokId (r, "\x2983")) = TokSymbol (SymDoubleOpenBrace True) r+postToken (TokId (r, "\x2984")) = TokSymbol (SymDoubleCloseBrace True) r+postToken (TokId (r, "\x2987")) = TokSymbol (SymOpenIdiomBracket True) r+postToken (TokId (r, "\x2988")) = TokSymbol (SymCloseIdiomBracket True) r+postToken (TokId (r, "\x2987\x2988")) = TokSymbol SymEmptyIdiomBracket r postToken (TokId (r, "\x2200")) = TokKeyword KwForall r-postToken (TokId (r, s))- | set == "Set" && all isSub n = TokSetN (r, readSubscript n)- where- (set, n) = splitAt 3 s- isSub c = c `elem` ['\x2080'..'\x2089']- readSubscript = read . map (\c -> toEnum (fromEnum c - 0x2080 + fromEnum '0')) postToken t = t --- | Use the input string from the previous input (with the appropriate--- number of characters dropped) instead of the fake input string that--- was given to Alex (with unicode characters removed).-newInput :: PreviousInput -> CurrentInput -> TokenLength -> CurrentInput-newInput inp inp' len =- case drop (len - 1) (lexInput inp) of- c:s' -> inp' { lexInput = s'- , lexPrevChar = c- }- [] -> inp' { lexInput = [] } -- we do get empty tokens moving between states---- | Alex 2 can't handle unicode characters. To solve this we--- translate all Unicode (non-ASCII) identifiers to @z@, all Unicode--- operator characters to @+@, and all whitespace characters (except--- for @\t@ and @\n@) to ' '. It is important that there aren't any--- keywords containing @z@, @+@ or @ @.-foolAlex :: AlexInput -> AlexInput-foolAlex inp = inp { lexInput = map fool $ lexInput inp }- where- fool c- | isSpace c && not (c `elem` "\t\n") = ' '- | isUnicodeId c = if isAlpha c then 'z' else '+'- | otherwise = c- {-------------------------------------------------------------------------- Lex actions --------------------------------------------------------------------------} -- | The most general way of parsing a token. token :: (String -> Parser tok) -> LexAction tok-token action inp inp' len =+token action = LexAction $ \ inp inp' len -> do setLexInput inp'- setPrevToken t- setLastPos $ lexPos inp- action t- where- t = take len $ lexInput inp+ let t = take len $ lexInput inp+ setPrevToken t+ setLastPos $ lexPos inp+ action t -- | Parse a token from an 'Interval' and the lexed string. withInterval :: ((Interval, String) -> tok) -> LexAction tok withInterval f = token $ \s -> do r <- getParseInterval- return $ f (r,s)+ return $ f (r,s) -- | Like 'withInterval', but applies a function to the string. withInterval' :: (String -> a) -> ((Interval, a) -> tok) -> LexAction tok-withInterval' f t = withInterval (t . (id -*- f))+withInterval' f t = withInterval (t . second f) -- | Return a token without looking at the lexed string. withInterval_ :: (Interval -> r) -> LexAction r withInterval_ f = withInterval (f . fst) +-- | Enter the layout state for the given keyword.+enterLayout :: Keyword -> Parser ()+enterLayout kw = do+ pushLexState layout+ modify \st -> st { parseLayKw = kw } -- | Executed for layout keywords. Enters the 'Agda.Syntax.Parser.Lexer.layout' -- state and performs the given action.-withLayout :: LexAction r -> LexAction r-withLayout a i1 i2 n =- do pushLexState layout- a i1 i2 n+withLayout :: Keyword -> LexAction r -> LexAction r+withLayout kw a = enterLayout kw `andThen` a +infixr 1 `andThen` +-- | Prepend some parser manipulation to an action.+andThen :: Parser () -> LexAction r -> LexAction r+andThen cmd a = LexAction $ \ inp inp' n -> do+ cmd+ runLexAction a inp inp' n++-- | Visit the current lexeme again.+revisit :: LexAction Token+revisit = LexAction $ \ _ _ _ -> lexToken++-- | Throw away the current lexeme.+skip :: LexAction Token+skip = LexAction $ \ _ inp' _ -> skipTo inp'+ -- | Enter a new state without consuming any input. begin :: LexState -> LexAction Token-begin code _ _ _ =- do pushLexState code- lexToken+begin code = beginWith code revisit +-- | Exit the current state without consuming any input.+end :: LexAction Token+end = endWith revisit -- | Enter a new state throwing away the current lexeme. begin_ :: LexState -> LexAction Token-begin_ code _ inp' _ =- do pushLexState code- skipTo inp'-+begin_ code = beginWith code skip -- | Exit the current state throwing away the current lexeme. end_ :: LexAction Token-end_ _ inp' _ =- do popLexState- skipTo inp'+end_ = endWith skip +-- | Enter a new state and perform the given action.+beginWith :: LexState -> LexAction a -> LexAction a+beginWith code a = pushLexState code `andThen` a -- | Exit the current state and perform the given action. endWith :: LexAction a -> LexAction a-endWith a inp inp' n =- do popLexState- a inp inp' n+endWith a = popLexState `andThen` a --- | Exit the current state without consuming any input-end :: LexAction Token-end _ _ _ =- do popLexState- lexToken- -- | Parse a 'Keyword' token, triggers layout for 'layoutKeywords'. keyword :: Keyword -> LexAction Token-keyword k = layout $ withInterval_ (TokKeyword k)+keyword k =+ case k of++ -- Unconditional layout keyword.+ _ | k `elem` layoutKeywords ->+ withLayout k cont++ -- Andreas, 2021-05-06, issue #5356:+ -- @constructor@ is not a layout keyword after all, replaced by @data _ where@.+ -- -- @constructor@ is not a layout keyword in @record ... where@ blocks,+ -- -- only in @interleaved mutual@ blocks.+ -- KwConstructor -> do+ -- cxt <- getContext+ -- if inMutualAndNotInWhereBlock cxt+ -- then withLayout k cont+ -- else cont++ _ -> cont where- layout | elem k layoutKeywords = withLayout- | otherwise = id+ cont = withInterval_ (TokKeyword k) + -- Andreas, 2021-05-06, issue #5356:+ -- @constructor@ is not a layout keyword after all, replaced by @data _ where@.+ -- -- Most recent block decides ...+ -- inMutualAndNotInWhereBlock = \case+ -- Layout KwMutual _ _ : _ -> True+ -- Layout KwWhere _ _ : _ -> False+ -- _ : bs -> inMutualAndNotInWhereBlock bs+ -- [] -> True -- For better errors on stray @constructor@ decls. + -- | Parse a 'Symbol' token. symbol :: Symbol -> LexAction Token symbol s = withInterval_ (TokSymbol s) +-- | Parse a number.++number :: String -> Integer+number str = case str of+ '0' : 'x' : num -> parseNumber 16 num+ '0' : 'b' : num -> parseNumber 2 num+ num -> parseNumber 10 num+ where+ parseNumber :: Integer -> String -> Integer+ parseNumber radix = foldl' (addDigit radix) 0++ -- We rely on Agda.Syntax.Parser.Lexer to enforce that the digits are+ -- in the correct range (so e.g. the digit 'E' cannot appear in a+ -- binary number).+ addDigit :: Integer -> Integer -> Char -> Integer+ addDigit radix n '_' = n+ addDigit radix n c = n * radix + fromIntegral (digitToInt c)++integer :: String -> Integer+integer = \case+ '-' : str -> - (number str)+ str -> number str+ -- | Parse a literal.-literal :: Read a => (Range -> a -> Literal) -> LexAction Token-literal lit =- withInterval' read (TokLiteral . uncurry lit . (getRange *** id))+literal' :: (String -> a) -> (a -> Literal) -> LexAction Token+literal' read lit = withInterval' read $ \ (r, a) ->+ TokLiteral $ Ranged (getRange r) $ lit a --- | Parse an identifier. Identifiers can be qualified (see 'Name').--- Example: @Foo.Bar.f@-identifier :: LexAction Token-identifier = qualified (either TokId TokQId)+literal :: Read a => (a -> Literal) -> LexAction Token+literal = literal' read +-- | Parse a potentially-qualified token. This action is responsible for+-- lexing both identifiers (which do not always have a qualifier, in+-- which case a 'TokId' is returned) *and* "qualified keywords", like+-- qualified @do@.+--+-- This action may thus modify the layout state of the parser, since+-- qualified @do@ is a layout "keyword".+--+-- Examples: @Foo.Bar.f@, @Foo.do@.+qualifiedToken :: LexAction Token+qualifiedToken = qualified $ either (pure . TokId . second toList) (qid . map (second toList)) where+ qid :: [(Interval, String)] -> Parser Token+ qid parts = case initLast parts of+ -- For qualified 'do', we have to pretend to be a layout keyword+ Just (initp, (i, "do")) ->+ TokQual QualDo initp i <$ enterLayout KwDo + Just (initp, (i, "(|)")) -> pure $ TokQual QualEmptyIdiom initp i+ Just (initp, (i, "\x2987\x2988")) -> pure $ TokQual QualEmptyIdiom initp i++ Just (initp, (i, "(|")) -> pure $ TokQual (QualOpenIdiom False) initp i+ Just (initp, (i, "\x2987")) -> pure $ TokQual (QualOpenIdiom True) initp i++ _ -> pure $ TokQId parts+ -- | Parse a possibly qualified name.-qualified :: (Either (Interval, String) [(Interval, String)] -> a) -> LexAction a+qualified :: (Either (Interval, String1) [(Interval, String1)] -> Parser a) -> LexAction a qualified tok = token $ \s -> do i <- getParseInterval- case mkName i $ wordsBy (=='.') s of- [] -> lexError "lex error on .."- [x] -> return $ tok $ Left x- xs -> return $ tok $ Right xs+ case mkName i $ List1.wordsBy (== '.') s of+ [] -> lexError "lex error on .."+ [x] -> tok $ Left x+ xs -> tok $ Right xs where- -- Compute the ranges for the substrings (separated by '.') of a name.- mkName :: Interval -> [String] -> [(Interval, String)]- mkName _ [] = []- mkName i [x] = [(i, x)]- mkName i (x:xs) = (i0, x) : mkName i1 xs- where- p0 = iStart i- p1 = iEnd i- p' = movePosByString p0 x- i0 = Interval p0 p'- i1 = Interval (movePos p' '.') p1+ -- Compute the ranges for the substrings (separated by '.') of+ -- a name. Dots are included: the intervals generated for+ -- "A.B.x" correspond to "A.", "B." and "x".+ mkName :: Interval -> [String1] -> [(Interval, String1)]+ mkName _ [] = []+ mkName i [x] = [(i, x)]+ mkName (Interval f p0 p1) (x:xs) = (i0, x) : mkName i1 xs+ where+ p' = movePos (movePosByString p0 x) '.'+ i0 = Interval f p0 p'+ i1 = Interval f p' p1 {--------------------------------------------------------------------------@@ -236,8 +314,8 @@ followedBy :: Char -> LexPredicate followedBy c' _ _ _ inp = case lexInput inp of- [] -> False- c:_ -> c == c'+ [] -> False+ c:_ -> c == c' -- | True if we are at the end of the file. eof :: LexPredicate
@@ -1,3 +1,5 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ module Agda.Syntax.Parser.LexActions where import Agda.Syntax.Literal@@ -12,17 +14,23 @@ withInterval :: ((Interval, String) -> tok) -> LexAction tok withInterval' :: (String -> a) -> ((Interval, a) -> tok) -> LexAction tok-withLayout :: LexAction r -> LexAction r+withLayout :: Keyword -> LexAction r -> LexAction r -begin :: LexState -> LexAction Token-endWith :: LexAction a -> LexAction a-begin_ :: LexState -> LexAction Token-end_ :: LexAction Token+andThen :: Parser () -> LexAction r -> LexAction r+skip :: LexAction Token -keyword :: Keyword -> LexAction Token-symbol :: Symbol -> LexAction Token-identifier :: LexAction Token-literal :: Read a => (Range -> a -> Literal) -> LexAction Token+begin :: LexState -> LexAction Token+beginWith :: LexState -> LexAction a -> LexAction a+endWith :: LexAction a -> LexAction a+begin_ :: LexState -> LexAction Token+end_ :: LexAction Token++keyword :: Keyword -> LexAction Token+symbol :: Symbol -> LexAction Token+qualifiedToken :: LexAction Token+literal :: Read a => (a -> Literal) -> LexAction Token+literal' :: (String -> a) -> (a -> Literal) -> LexAction Token+integer :: String -> Integer followedBy :: Char -> LexPredicate eof :: LexPredicate
@@ -1,6 +1,9 @@ {-{-# OPTIONS_GHC -fno-warn-deprecated-flags #-}-{-# LANGUAGE BangPatterns #-}+{-# OPTIONS_GHC -Wno-error=deprecated-flags #-}+{-# OPTIONS_GHC -Wno-error=missing-signatures #-}+{-# OPTIONS_GHC -Wno-error=tabs #-}+{-# OPTIONS_GHC -Wno-error=unused-imports #-}+ {-| The lexer is generated by Alex (<http://www.haskell.org/alex>) and is an adaptation of GHC's lexer. The main lexing function 'lexer' is called by the "Agda.Syntax.Parser.Parser" to get the next token from the input.@@ -9,14 +12,12 @@ ( -- * The main function lexer -- * Lex states- , normal, literate, code+ , normal, code , layout, empty_layout, bol, imp_dir -- * Alex generated functions , AlexReturn(..), alexScanUser ) where -import Data.List- import Agda.Syntax.Parser.Alex import Agda.Syntax.Parser.Comments #ifndef __HADDOCK__@@ -30,21 +31,28 @@ } -$digit = 0-9+-- Note that the regular expressions should not use non-ASCII+-- characters, see Agda.Syntax.Parser.Alex.alexGetByte.++$digit = 0-9 $hexdigit = [ $digit a-f A-F ]-$alpha = [ A-Z a-z _ ]-$op = [ \- \! \# \$ \% \& \* \+ \/ \< \= \> \^ \| \~ \? \` \[ \] \, \: ]+$binarydigit = 0-1+$alpha = [ A-Z a-z _ ]+$op = [ \- \! \# \$ \% \& \* \+ \/ \< \= \> \^ \| \~ \? \` \[ \] \, \: ] $idstart = [ $digit $alpha $op ]-$idchar = [ $idstart ' \\ ]-$endcomment = ~ [ $idchar ]+$idchar = [ $idstart ' \\ ] $nonalpha = $idchar # $alpha-$nonalphanum = $nonalpha # $digit $white_notab = $white # \t $white_nonl = $white_notab # \n -@number = $digit+ | "0x" $hexdigit+-@exponent = [eE] [\-\+]? @number-@float = @number \. @number @exponent? | @number @exponent+@prettynumber = $digit+ ([_] $digit+)*+ | "0x" $hexdigit+ ([_] $hexdigit+)*+ | "0b" $binarydigit+ ([_] $binarydigit+)*+@integer = [\-]? @prettynumber+@decimal = $digit++@exponent = [eE] [\-\+]? @decimal+@float = [\-]? @decimal \. @decimal @exponent?+ | [\-]? @decimal @exponent -- A name can't start with \x (to allow \x -> x). -- Bug in alex: [ _ op ]+ doesn't seem to work!@@ -56,162 +64,204 @@ tokens :- --- Lexing literate files-<tex> $white_nonl* \\ "begin{code}" $white_nonl* $ { end_ }-<tex> .+ / { keepComments } { withInterval TokTeX }-<tex> .+ ;-<tex> \n ;-<tex> () / { eof } { end_ }-<bol_,layout_>- \\ "end{code}" / { inState code } { begin_ tex }- -- \end{code} should only be recognized if the bottom of the stack is <code>- -- White space <0,code,bol_,layout_,empty_layout_,imp_dir_> $white_nonl+ ; -<pragma_> $white_notab ;+<pragma_,fpragma_> $white_notab ; -- Pragmas-<0,code> "{-#" { begin pragma }-<pragma_> "{-#" { symbol SymOpenPragma }-<pragma_> "#-}" { endWith $ symbol SymClosePragma }-<pragma_> "OPTIONS" { keyword KwOPTIONS }-<pragma_> "BUILTIN" { keyword KwBUILTIN }-<pragma_> "COMPILED_DATA" { keyword KwCOMPILED_DATA }-<pragma_> "COMPILED_TYPE" { keyword KwCOMPILED_TYPE }-<pragma_> "COMPILED" { keyword KwCOMPILED }-<pragma_> "COMPILED_EPIC" { keyword KwCOMPILED_EPIC }-<pragma_> "COMPILED_JS" { keyword KwCOMPILED_JS }-<pragma_> "STATIC" { keyword KwSTATIC }-<pragma_> "IMPORT" { keyword KwIMPORT }-<pragma_> "IMPOSSIBLE" { keyword KwIMPOSSIBLE }-<pragma_> "ETA" { keyword KwETA }-<pragma_> "LINE" { keyword KwLINE }-<pragma_> . # [ $white ] + { withInterval $ TokString }+<0,code,pragma_> "{-#" { beginWith pragma $ symbol SymOpenPragma }+<fpragma_> "{-#" { beginWith fpragma $ symbol SymOpenPragma }+<pragma_,fpragma_> "#-}" { endWith $ symbol SymClosePragma }+<pragma_> "BUILTIN" { keyword KwBUILTIN }+<pragma_> "CATCHALL" { keyword KwCATCHALL }+<pragma_> "COMPILE" { endWith $ beginWith fpragma $ keyword KwCOMPILE }+<pragma_> "FOREIGN" { endWith $ beginWith fpragma $ keyword KwFOREIGN }+<pragma_> "DISPLAY" { keyword KwDISPLAY }+<pragma_> "ETA" { keyword KwETA }+<pragma_> "ETA_EQUALITY" { keyword KwETA_EQUALITY }+<pragma_> "IMPOSSIBLE" { keyword KwIMPOSSIBLE }+<pragma_> "INJECTIVE" { keyword KwINJECTIVE }+<pragma_> "INJECTIVE_FOR_INFERENCE" { keyword KwINJECTIVE_FOR_INFERENCE }+<pragma_> "INLINE" { keyword KwINLINE }+<pragma_> "INCOHERENT" { keyword KwINCOHERENT }+<pragma_> "NOINLINE" { keyword KwNOINLINE }+<pragma_> "NOT_PROJECTION_LIKE" { keyword KwNOT_PROJECTION_LIKE }+<pragma_> "LINE" { keyword KwLINE }+<pragma_> "MEASURE" { keyword KwMEASURE }+<pragma_> "NO_POSITIVITY_CHECK" { keyword KwNO_POSITIVITY_CHECK }+<pragma_> "NO_TERMINATION_CHECK" { keyword KwNO_TERMINATION_CHECK }+<pragma_> "NO_UNIVERSE_CHECK" { keyword KwNO_UNIVERSE_CHECK }+<pragma_> "NON_COVERING" { keyword KwNON_COVERING }+<pragma_> "NON_TERMINATING" { keyword KwNON_TERMINATING }+<pragma_> "OPTIONS" { keyword KwOPTIONS }+<pragma_> "POLARITY" { keyword KwPOLARITY }+<pragma_> "OVERLAPPABLE" { keyword KwOVERLAPPABLE }+<pragma_> "OVERLAPPING" { keyword KwOVERLAPPING }+<pragma_> "OVERLAPS" { keyword KwOVERLAPS }+<pragma_> "REWRITE" { keyword KwREWRITE }+<pragma_> "STATIC" { keyword KwSTATIC }+<pragma_> "TERMINATING" { keyword KwTERMINATING }+<pragma_> "WARNING_ON_USAGE" { keyword KwWARNING_ON_USAGE }+<pragma_> "WARNING_ON_IMPORT" { keyword KwWARNING_ON_IMPORT }+<pragma_> . # [ $white \" ] + { withInterval $ TokString } -- we recognise string literals in pragmas+<fpragma_> . # [ $white ] + { withInterval $ TokString } -- Comments+<0,code,bol_,layout_,empty_layout_,imp_dir_>+ "--" .* / { keepComments .&&. (followedBy '\n' .||. eof) }+ { confirmLayout `andThen` withInterval TokComment }+<0,code,bol_,layout_,empty_layout_,imp_dir_>+ "--" .* / { followedBy '\n' .||. eof }+ { confirmLayout `andThen` skip }+ -- We need to rule out pragmas here. Usually longest match would take -- precedence, but in some states pragmas aren't valid but comments are. <0,code,bol_,layout_,empty_layout_,imp_dir_> "{-" / { not' (followedBy '#') } { nestedComment }-+ -- A misplaced end-comment, like in @f {x-} = x-@ gives a parse error.+ "-}" { symbol SymEndComment }+ @ident "-}" { symbol SymEndComment } --- Dashes followed by a name symbol should be parsed as a name.-<0,code,bol_,layout_,empty_layout_,imp_dir_>- "--" .* / { keepComments .&&. (followedBy '\n' .||. eof) }- { withInterval TokComment }-<0,code,bol_,layout_,empty_layout_,imp_dir_>- "--" .* / { followedBy '\n' .||. eof } ;+-- Note: we need to confirm tentative layout columns whenever we meet+-- a newline character ('\n').+-- The exception is the newline after a layout keyword. -- We need to check the offside rule for the first token on each line. We -- should not check the offside rule for the end of file token or an -- '\end{code}'-<0,code,imp_dir_> \n { begin bol_ }+<0,code,imp_dir_> \n { begin bol_ } -- Note that @begin@ revisits '\n' in the new state! <bol_> {- \n ;--- ^ \\ "end{code}" { end }- () / { not' eof } { offsideRule }+ \n { confirmLayout `andThen` skip }+-- ^ \\ "end{code}" { end }+ () / { not' eof } { offsideRule } } --- After a layout keyword there is either an open brace (no layout) or the+-- After a layout keyword the -- indentation of the first token decides the column of the layout block. <layout_>- { \n ;--- \{ { endWith openBrace }- () { endWith newLayoutContext }+ { \n { confirmLayout `andThen` skip}+ () { endWith newLayoutBlock } } -- The only rule for the empty_layout state. Generates a close brace.-<empty_layout_> () { emptyLayout }+<empty_layout_> () { emptyLayout } -- Keywords-<0,code> let { keyword KwLet }-<0,code> in { keyword KwIn }-<0,code> where { keyword KwWhere }-<0,code> field { keyword KwField }-<0,code> with { keyword KwWith }-<0,code> rewrite { keyword KwRewrite }-<0,code> postulate { keyword KwPostulate }-<0,code> primitive { keyword KwPrimitive }-<0,code> open { keyword KwOpen }-<0,code> import { keyword KwImport }-<0,code> module { keyword KwModule }-<0,code> data { keyword KwData }-<0,code> codata { keyword KwCoData }-<0,code> record { keyword KwRecord }-<0,code> constructor { keyword KwConstructor }-<0,code> infix { keyword KwInfix }-<0,code> infixl { keyword KwInfixL }-<0,code> infixr { keyword KwInfixR }-<0,code> mutual { keyword KwMutual }-<0,code> abstract { keyword KwAbstract }-<0,code> private { keyword KwPrivate }-<0,code> Set { keyword KwSet }-<0,code> Prop { keyword KwProp }-<0,code> forall { keyword KwForall }-<0,code> Set @number { withInterval' (read . drop 3) TokSetN }-<0,code> quoteGoal { keyword KwQuoteGoal }-<0,code> quote { keyword KwQuote }-<0,code> quoteTerm { keyword KwQuoteTerm }-<0,code> unquote { keyword KwUnquote }-<0,code> syntax { keyword KwSyntax }+-- Wrapping all our keywords which are also Haskell keywords in quotes+-- allows this file to basically syntax highlight as Haskell correctly+<0,code> abstract { keyword KwAbstract }+<0,code> codata { keyword KwCoData }+<0,code> coinductive { keyword KwCoInductive }+<0,code> constructor { keyword KwConstructor }+<0,code> data { keyword KwData }+<0,code> "do" { keyword KwDo }+<0,code> "eta-equality" { keyword KwEta }+<0,code> field { keyword KwField }+<0,code> forall { keyword KwForall }+<0,code> import { keyword KwImport }+<0,code> "in" { keyword KwIn }+<0,code> inductive { keyword KwInductive }+<0,code> infix { keyword KwInfix }+<0,code> infixl { keyword KwInfixL }+<0,code> infixr { keyword KwInfixR }+<0,code> instance { keyword KwInstance }+<0,code> interleaved { keyword KwInterleaved }+<0,code> "let" { keyword KwLet }+<0,code> macro { keyword KwMacro }+<0,code> "module" { keyword KwModule }+<0,code> mutual { keyword KwMutual }+<0,code> "no-eta-equality" { keyword KwNoEta }+<0,code> open { keyword KwOpen }+<0,code> overlap { keyword KwOverlap }+<0,code> pattern { keyword KwPatternSyn }+<0,code> postulate { keyword KwPostulate }+<0,code> primitive { keyword KwPrimitive }+<0,code> private { keyword KwPrivate }+<0,code> quote { keyword KwQuote }+<0,code> quoteTerm { keyword KwQuoteTerm }+<0,code> record { keyword KwRecord }+<0,code> rewrite { keyword KwRewrite }+<0,code> syntax { keyword KwSyntax }+<0,code> tactic { keyword KwTactic }+<0,code> unquote { keyword KwUnquote }+<0,code> unquoteDecl { keyword KwUnquoteDecl }+<0,code> unquoteDef { keyword KwUnquoteDef }+<0,code> variable { keyword KwVariable }+<0,code> "where" { keyword KwWhere }+<0,code> with { keyword KwWith }+<0,code> opaque { keyword KwOpaque }+<0,code> unfolding { keyword KwUnfolding } -- The parser is responsible to put the lexer in the imp_dir_ state when it -- expects an import directive keyword. This means that if you run the -- tokensParser you will never see these keywords.-<0,code> using { keyword KwUsing }-<0,code> hiding { keyword KwHiding }+<0,code> using { keyword KwUsing }+<0,code> hiding { keyword KwHiding } <0,code> renaming { keyword KwRenaming }-<imp_dir_> to { endWith $ keyword KwTo }-<0,code> public { keyword KwPublic }+<imp_dir_> to { endWith $ keyword KwTo }+<0,code> public { keyword KwPublic } -- Holes-<0,code> "{!" { hole }+<0,code> "{!" { hole } -- Special symbols-<0,code> "..." { symbol SymEllipsis }-<0,code> ".." { symbol SymDotDot }-<0,code> "." { symbol SymDot }-<0,code> ";" { symbol SymSemi }-<0,code> ":" { symbol SymColon }-<0,code> "=" { symbol SymEqual }-<0,code> "_" { symbol SymUnderscore }-<0,code> "?" { symbol SymQuestionMark }-<0,code> "|" { symbol SymBar }-<0,code> "(" { symbol SymOpenParen }-<0,code> ")" { symbol SymCloseParen }-<0,code> "->" { symbol SymArrow }-<0,code> "\" { symbol SymLambda }-<0,code> "@" { symbol SymAs }-<0,code> "{{" /[^!] { symbol SymDoubleOpenBrace }+<0,code> "..." { symbol SymEllipsis }+<0,code> ".." { symbol SymDotDot }+<0,code> "." { symbol SymDot }+<0,code> ";" { symbol SymSemi }+<0,code> ":" { symbol SymColon }+<0,code> "=" { symbol SymEqual }+<0,code> "_" { symbol SymUnderscore }+<0,code> "?" { symbol SymQuestionMark }+<0,code> "|" { symbol SymBar }+<0,code> "(|" /[$white] { symbol (SymOpenIdiomBracket False) }+<0,code> "|)" { symbol (SymCloseIdiomBracket False) }+<0,code> "(|)" { symbol SymEmptyIdiomBracket }+<0,code> "(" { symbol SymOpenParen }+<0,code> ")" { symbol SymCloseParen }+<0,code> "->" { symbol SymArrow }+<0,code> "\" { symbol SymLambda } -- "+<0,code> "@" { symbol SymAs }+<0,code> "{{" /[^[!\-]] { symbol (SymDoubleOpenBrace False) }+-- Andreas, 2019-08-08, issue #3962, don't lex '{{' if followed by '-'+-- since this will be confused with '{-' (start of comment) by Emacs.+ -- We don't lex '}}' into a SymDoubleCloseBrace. Instead, we lex it as -- two SymCloseBrace's. When the parser is looking for a double -- closing brace, it will also accept two SymCloseBrace's, after -- verifying that they are immediately next to each other. -- This trick allows us to keep "record { a = record {}}" working -- properly.--- <0,code> "}}" { symbol SymDoubleCloseBrace }-<0,code> "{" { symbol SymOpenBrace } -- you can't use braces for layout-<0,code> "}" { symbol SymCloseBrace }+-- <0,code> "}}" { symbol SymDoubleCloseBrace } +<0,code> "{" { symbol SymOpenBrace } -- you can't use braces for layout+<0,code> "}" { symbol SymCloseBrace }+ -- Literals-<0,code> \' { litChar }-<0,code> \" { litString }-<0,code> @number { literal LitInt }-<0,code> @float { literal LitFloat }+<0,code> \' { litChar }+<0,code,pragma_> \" { litString }+-- " -- ← this silly incantation lets the rest of this file correctly+-- syntax highlight as Haskell (otherwise it's all a string literal) --- Identifiers-<0,code> @q_ident { identifier }+<0,code> @integer { literal' integer LitNat }+<0,code> @float { literal LitFloat } -{+-- Qualified tokens, like identifiers, qualified @do@, and qualified+-- idiom brackets, are all handled by the same 'qualifiedToken' action.+<0,code> @namespace "(|" /[$white] { qualifiedToken }+<0,code> @namespace "(|)" { qualifiedToken } --- | This is the initial state for parsing a literate file. Code blocks--- should be enclosed in @\\begin{code}@ @\\end{code}@ pairs.-literate :: LexState-literate = tex+<0,code,imp_dir_> @q_ident { qualifiedToken }+-- Andreas, 2013-02-21, added identifiers to the 'imp_dir_' state.+-- This is to fix issue 782: 'toz' should not be lexed as 'to'+-- (followed by 'z' after leaving imp_dir_).+-- With identifiers in state imp_dir_, 'toz' should be lexed as+-- identifier 'toz' in imp_dir_ state, leading to a parse error later. +{ -- | This is the initial state for parsing a regular, non-literate file. normal :: LexState@@ -219,10 +269,7 @@ {-| The layout state. Entered when we see a layout keyword ('withLayout') and- exited either when seeing an open brace ('openBrace') or at the next token- ('newLayoutContext').-- Update: we don't use braces for layout anymore.+ exited at the next token ('newLayoutBlock'). -} layout :: LexState layout = layout_@@ -233,7 +280,12 @@ pragma :: LexState pragma = pragma_ -{-| We enter this state from 'newLayoutContext' when the token following a+-- | The state inside a FOREIGN pragma. This needs to be different so that we don't+-- lex further strings as pragma keywords.+fpragma :: LexState+fpragma = fpragma_++{-| We enter this state from 'newLayoutBlock' when the token following a layout keyword is to the left of (or at the same column as) the current layout context. Example: @@ -244,7 +296,7 @@ same indentation as the @data@ definition. What we have to do is insert an empty layout block @{}@ after the @where@. The only thing that can happen in this state is that 'emptyLayout' is executed, generating the closing- brace. The open brace is generated when entering by 'newLayoutContext'.+ brace. The open brace is generated when entering by 'newLayoutBlock'. -} empty_layout :: LexState empty_layout = empty_layout_
@@ -0,0 +1,347 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Preprocessors for literate code formats.++module Agda.Syntax.Parser.Literate+ ( literateProcessors+ , literateExts+ , literateTeX+ , literateRsT+ , literateMd+ , literateOrg+ , illiterate+ , atomizeLayers+ , Processor+ , Layers+ , Layer(..)+ , LayerRole(..)+ , isCode+ , isCodeLayer+ )+ where++import Control.Monad ((<=<))+import Data.Char (isSpace)+import Data.List (isPrefixOf)+import Text.Regex.TDFA+ ( Regex, getAllTextSubmatches, match, matchM+ , makeRegexOpts, blankCompOpt, blankExecOpt, newSyntax, caseSensitive+ )++import Agda.Syntax.Common+import Agda.Syntax.Position++import Agda.Utils.List+import qualified Agda.Utils.List1 as List1++import Agda.Utils.Impossible++-- | Role of a character in the file.++data LayerRole = Markup | Comment | Code+ deriving (Show, Eq)++-- | A sequence of characters in a file playing the same role.++data Layer = Layer+ { layerRole :: LayerRole+ , interval :: IntervalWithoutFile+ , layerContent :: String+ } deriving Show++-- | A list of contiguous layers.++type Layers = [Layer]++instance HasRangeWithoutFile Layer where+ getRangeWithoutFile = getRangeWithoutFile . interval++-- | Annotates a tokenized string with position information.++mkLayers :: PositionWithoutFile -> [(LayerRole, String)] -> Layers+mkLayers pos [] = emptyLiterate pos+mkLayers pos ((_,"") : xs) = mkLayers pos xs+ -- Empty layers are ignored.+mkLayers pos ((ty,s) : xs) =+ Layer ty (Interval () pos next) s : mkLayers next xs+ where+ next = movePosByString pos s++unMkLayers :: Layers -> [(LayerRole, String)]+unMkLayers = map ((,) <$> layerRole <*> layerContent)++atomizeLayers :: Layers -> [(LayerRole, Char)]+atomizeLayers = (fmap <$> ((,) . fst) <*> snd) <=< unMkLayers++-- | Type of a literate preprocessor:+-- Invariants:+--+-- > f : Processor+--+-- proposition> f pos s /= []+--+-- proposition> f pos s >>= layerContent == s++type Processor = PositionWithoutFile -> String -> [Layer]++-- | List of valid extensions for literate Agda files, and their+-- corresponding preprocessors.+--+-- If you add new extensions, remember to update test/Utils.hs so+-- that test cases ending in the new extensions are found.+--+-- The 'Bool' parameter controls whether only @```agda@ blocks+-- are treated as Agda code in Markdown/Typst files.+-- When @True@, only blocks marked @```agda@ are considered code.+-- When @False@, both @```@ and @```agda@ blocks are code (default).++literateProcessors :: Bool -> [(String, (Processor, FileType))]+literateProcessors onlyAgdaBlocks =+ ((,) <$> (".lagda" ++) . fst <*> snd) <$>+ [ ("" , (literateTeX, TexFileType))+ , (".rst", (literateRsT, RstFileType))+ , (".tex", (literateTeX, TexFileType))+ , (".md", (literateMd onlyAgdaBlocks, MdFileType ))+ , (".org", (literateOrg, OrgFileType))+ , (".tree", (literateTree, TreeFileType))+ -- For now, treat typst as markdown because they use the same+ -- syntax for code blocks.+ , (".typ", (literateMd onlyAgdaBlocks, TypstFileType))+ ]++-- | List of valid literate file extensions.+literateExts :: [String]+literateExts = fst <$> literateProcessors False++-- | Returns @True@ if the role corresponds to Agda code.++isCode :: LayerRole -> Bool+isCode Code = True+isCode Markup = False+isCode Comment = False++-- | Returns @True@ if the layer contains Agda code.++isCodeLayer :: Layer -> Bool+isCodeLayer = isCode . layerRole++-- | Blanks the non-code parts of a given file, preserving positions of+-- characters corresponding to code. This way, there is a direct+-- correspondence between source positions and positions in the+-- processed result.++illiterate :: [Layer] -> String+illiterate xs = concat+ [ (if isCode layerRole then id else bleach) layerContent+ | Layer{layerRole, layerContent} <- xs+ ]++-- | Replaces non-space characters in a string with spaces.++bleach :: String -> String+bleach = map $ \ c -> if isSpace c && c /= '\t' then c else ' '++-- | Check if a character is a blank character.++isBlank :: Char -> Bool+isBlank = (&&) <$> isSpace <*> (/= '\n')++-- | Returns a tuple consisting of the first line of the input, and the rest+-- of the input.++caseLine :: a -> (String -> String -> a) -> String -> a+caseLine a k = \case+ [] -> a+ x:xs -> k (List1.toList line) rest+ where+ (line, rest) = breakAfter1 (== '\n') x xs++-- | Canonical decomposition of an empty literate file.++emptyLiterate :: PositionWithoutFile -> [Layer]+emptyLiterate pos = [Layer Markup (Interval () pos pos) ""]++-- | Create a regular expression that:+-- - Must match the whole string+-- - Works across line boundaries++rex :: String -> Regex+rex s =+ makeRegexOpts blankCompOpt{newSyntax = True} blankExecOpt $+ "\\`" ++ s ++ "\\'"++-- | Preprocessor for literate TeX.++literateTeX :: Processor+literateTeX pos s = mkLayers pos (tex s)+ where+ tex :: String -> [(LayerRole, String)]+ tex = caseLine [] $ \ line rest ->+ case r_begin `matchM` line of+ Just (getAllTextSubmatches -> [_, pre, _, markup, whitespace]) ->+ (Comment, pre) : (Markup, markup) :+ (Code, whitespace) : code rest+ Just _ -> __IMPOSSIBLE__+ Nothing -> (Comment, line) : tex rest++ r_begin = rex "(([^\\%]|\\\\.)*)(\\\\begin\\{code\\}[^\n]*)(\n)?"++ code :: String -> [(LayerRole, String)]+ code = caseLine [] $ \ line rest ->+ case r_end `matchM` line of+ Just (getAllTextSubmatches -> [_, code, markup, post]) ->+ (Code, code) : (Markup, markup) : (Comment, post) : tex rest+ Just _ -> __IMPOSSIBLE__+ Nothing -> (Code, line) : code rest++ r_end = rex "([[:blank:]]*)(\\\\end\\{code\\})(.*)"++-- | Preprocessor for Markdown.+--+-- The 'Bool' parameter controls whether only @```agda@ blocks+-- are treated as Agda code.+-- When @True@, only blocks explicitly marked @```agda@ are considered code.+-- When @False@, both unmarked @```@ and @```agda@ blocks are code (default).++literateMd :: Bool -> Processor+literateMd onlyAgdaBlocks pos s = mkLayers pos $ md s+ where+ md :: String -> [(LayerRole, String)]+ md = caseLine [] $ \ line rest ->+ case md_begin `matchM` line of+ Just (getAllTextSubmatches -> [_, pre, markup, tag]) ->+ -- When onlyAgdaBlocks is True, only treat blocks with "agda" tag as code+ if onlyAgdaBlocks && null tag+ then (Comment, pre) : (Comment, markup) : code_other rest+ else (Comment, pre) : (Markup, markup) : code rest+ Just _ -> __IMPOSSIBLE__+ Nothing ->+ (Comment, line) :+ if md_begin_other `match` line+ then code_other rest+ else md rest++ md_begin = rex "(.*)([[:space:]]*```(agda)?[[:space:]]*)"+ md_begin_other = rex "[[:space:]]*```[a-zA-Z0-9-]*[[:space:]]*"++ code :: String -> [(LayerRole, String)]+ code = caseLine [] $ \ line rest ->+ case md_end `matchM` line of+ Just (getAllTextSubmatches -> [_, markup]) ->+ (Markup, markup) : md rest+ Just _ -> __IMPOSSIBLE__+ Nothing -> (Code, line) : code rest++ -- A non-Agda code block.+ code_other :: String -> [(LayerRole, String)]+ code_other = caseLine [] $ \ line rest ->+ (Comment, line) :+ if md_end `match` line+ then md rest+ else code_other rest++ md_end = rex "([[:space:]]*```[[:space:]]*)"++-- | Preprocessor for reStructuredText.++literateRsT :: Processor+literateRsT pos s = mkLayers pos $ rst s+ where+ rst :: String -> [(LayerRole, String)]+ rst = caseLine [] maybe_code++ maybe_code line rest =+ if r_comment `match` line then+ not_code+ else case r_code `match` line of+ [] -> not_code+ [[_, before, "::", after]] ->+ -- Code starts+ if maybe True isBlank $ lastMaybe before then+ (Markup, line) : code rest+ else+ (Comment, before ++ ":") : (Markup, ":" ++ after) : code rest+ _ -> __IMPOSSIBLE__+ where+ not_code = (Comment, line) : rst rest++ -- Finds the next indented block in the input.+ code :: String -> [(LayerRole, String)]+ code = caseLine [] $ \ line rest ->+ if all isSpace line then+ (Markup, line) : code rest+ else+ let xs = takeWhile isBlank line in+ if null xs+ then maybe_code line rest+ else (Code, line) : indented xs rest++ -- Process an indented block.+ indented :: String -> String -> [(LayerRole, String)]+ indented ind = caseLine [] $ \ line rest ->+ if all isSpace line || (ind `isPrefixOf` line)+ then (Code, line) : indented ind rest+ else maybe_code line rest++ -- Beginning of a code block.+ r_code = rex "(.*)(::)([[:space:]]*)"++ -- Beginning of a comment block.+ r_comment = rex "[[:space:]]*\\.\\.([[:space:]].*)?"++-- | Preprocessor for Org mode documents.++literateOrg :: Processor+literateOrg pos s = mkLayers pos $ org s+ where+ org :: String -> [(LayerRole, String)]+ org = caseLine [] $ \ line rest ->+ if org_begin `match` line then+ (Markup, line) : code rest+ else+ (Comment, line) : org rest++ -- Valid: #+begin_src agda2 :tangle yes+ -- Valid: #+begin_src agda2+ -- Invalid: #+begin_src adga2-foo+ org_begin = rex' "\\`(.*)([[:space:]]*\\#\\+begin_src agda2[[:space:]]+)"++ code :: String -> [(LayerRole, String)]+ code = caseLine [] $ \ line rest ->+ if org_end `match` line then+ (Markup, line) : org rest+ else+ (Code, line) : code rest++ org_end = rex' "\\`([[:space:]]*\\#\\+end_src[[:space:]]*)(.*)"++ -- Explicit type annotation required to disambiguate source.+ rex' :: String -> Regex+ -- Source blocks start with `#+begin_src` but the casing does not matter.+ rex' = makeRegexOpts blankCompOpt{newSyntax = True, caseSensitive = False} blankExecOpt++-- | Preprocessor for Forester documents++literateTree :: Processor+literateTree pos s = mkLayers pos (tree s)+ where+ tree :: String -> [(LayerRole, String)]+ tree = caseLine [] $ \ line rest ->+ case tree_begin `matchM` line of+ Just (getAllTextSubmatches -> [_, pre, _, markup, whitespace]) ->+ (Comment, pre) : (Markup, markup) :+ (Code, whitespace) : code rest+ Just _ -> __IMPOSSIBLE__+ Nothing -> (Comment, line) : tree rest++ tree_begin = rex "(([^\\%]|\\\\.)*)(\\\\agda\\{[^\n]*)(\n)?"++ code :: String -> [(LayerRole, String)]+ code = caseLine [] $ \ line rest ->+ case tree_end `matchM` line of+ Just (getAllTextSubmatches -> [_, code, markup, post]) ->+ (Code, code) : (Markup, markup) : (Comment, post) : tree rest+ Just _ -> __IMPOSSIBLE__+ Nothing -> (Code, line) : code rest++ tree_end = rex "([[:blank:]]*)(\\})(.*)"
@@ -1,5 +1,5 @@-{-# LANGUAGE Rank2Types #-}-{-| When lexing by hands (for instance string literals) we need to do some++{-| When lexing by hand (for instance string literals) we need to do some looking ahead. The 'LookAhead' monad keeps track of the position we are currently looking at, and provides facilities to synchronise the look-ahead position with the actual position of the 'Parser' monad (see 'sync' and@@ -10,6 +10,7 @@ LookAhead , runLookAhead -- * Operations+ , lookAheadError , getInput, setInput, liftP , nextChar, eatNextChar , sync, rollback@@ -23,6 +24,9 @@ import Agda.Syntax.Parser.Alex import Agda.Syntax.Parser.Monad +import Agda.Utils.Null (ifNull)+import Agda.Utils.Maybe (fromMaybeM)+ {-------------------------------------------------------------------------- The look-ahead monad --------------------------------------------------------------------------}@@ -31,23 +35,19 @@ 'AlexInput', wrapped around the 'Parser' monad. -} newtype LookAhead a =- LookAhead { unLookAhead :: ReaderT ErrorFunction- (StateT AlexInput Parser) a- }+ LookAhead { _unLookAhead :: ReaderT ErrorFunction+ (StateT AlexInput Parser) a+ }+ deriving (Functor, Applicative, Monad) newtype ErrorFunction = ErrorFun { throwError :: forall a. String -> LookAhead a } -{--------------------------------------------------------------------------- Monad instances- --------------------------------------------------------------------------}--instance Monad LookAhead where- return = LookAhead . return- m >>= k = LookAhead $ unLookAhead m >>= unLookAhead . k- fail s =- do err <- LookAhead ask- throwError err s+-- | Throw an error message according to the supplied method.+lookAheadError :: String -> LookAhead a+-- ASR (2021-02-07). The eta-expansion @\e -> throwError e@ is+-- required GHC >= 9.0.1 ((see Issue #4955).+lookAheadError s = ($ s) =<< do LookAhead $ asks (\e -> throwError e) {-------------------------------------------------------------------------- Operations@@ -70,35 +70,39 @@ -- | Look at the next character. Fails if there are no more characters. nextChar :: LookAhead Char-nextChar =- do inp <- getInput- case alexGetChar inp of- Nothing -> fail "unexpected end of file"- Just (c,inp') ->- do setInput inp'- return c+nextChar = fromMaybeM (lookAheadError "unexpected end of file") nextCharMaybe +-- | Look at the next character. Return 'Nothing' if there are no more characters.+nextCharMaybe :: LookAhead (Maybe Char)+nextCharMaybe =+ do inp <- getInput+ case alexGetChar inp of+ Nothing -> return Nothing+ Just (c,inp') ->+ do setInput inp'+ return $ Just c + -- | Consume all the characters up to the current look-ahead position. sync :: LookAhead () sync =- do inp <- getInput- liftP $ setLexInput inp+ do inp <- getInput+ liftP $ setLexInput inp -- | Undo look-ahead. Restores the input from the 'ParseState'. rollback :: LookAhead () rollback =- do inp <- liftP getLexInput- setInput inp+ do inp <- liftP getLexInput+ setInput inp -- | Consume the next character. Does 'nextChar' followed by 'sync'. eatNextChar :: LookAhead Char eatNextChar =- do c <- nextChar- sync- return c+ do c <- nextChar+ sync+ return c {-| Do a case on the current input string. If any of the given strings match we@@ -108,28 +112,53 @@ -} match :: [(String, LookAhead a)] -> LookAhead a -> LookAhead a match xs def =- do c <- nextChar- match' c xs def+ do c <- nextChar+ match' c xs def {-| Same as 'match' but takes the initial character from the first argument instead of reading it from the input. Consequently, in the default case the input is not advanced. -} match' :: Char -> [(String, LookAhead a)] -> LookAhead a -> LookAhead a-match' c xs def =- do inp <- getInput- match'' inp xs c- where- match'' inp bs c =- case bs' of- [] -> setInput inp >> def- [("",p)] -> p- _ -> match'' inp bs' =<< nextChar- where- bs' = [ (s, p) | (c':s, p) <- bs, c == c' ]+match' c xs def = do + -- Set the error continuation to the default @def@, but make sure we reset+ -- the input to where we started speculative matching.+ inp <- getInput+ let fallback = setInput inp >> def++ -- Find the longest match from the table.+ match'' fallback xs c++ where+ match'' fallback bs c =++ -- Match the first character, dropping entries that do not match.+ ifNull [ (s, p) | (c':s, p) <- bs, c == c' ]++ -- If no alternatives are left, fall back to the failure continuation.+ {-then-} fallback++ -- Otherwise:+ {-else-} $ \ bs' -> do++ -- If we have a successful match, store it in the failure continuation.+ fallback' <- do+ case lookup "" bs' of++ -- No match yet.+ Nothing -> pure fallback++ -- Match found! Remember it, and the state of the input where we found it.+ Just p -> do+ inp <- getInput+ pure $ setInput inp >> p++ -- Keep trying to find a (longer) match.+ maybe fallback' (match'' fallback' bs') =<< nextCharMaybe+ -- | Run a 'LookAhead' computation. The first argument is the error function. runLookAhead :: (forall b. String -> LookAhead b) -> LookAhead a -> Parser a runLookAhead err (LookAhead m) =- do inp <- getLexInput- evalStateT (runReaderT m (ErrorFun err)) inp+ do inp <- getLexInput+ evalStateT (runReaderT m (ErrorFun err)) inp
@@ -1,184 +1,445 @@-{-# LANGUAGE MultiParamTypeClasses, DeriveDataTypeable #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE UnboxedSums #-}+ module Agda.Syntax.Parser.Monad ( -- * The parser monad Parser , ParseResult(..) , ParseState(..)- , ParseError(..)+ , ParseError(..), ParseWarning(..) , LexState- , LayoutContext(..)+ , OpenBracket(..)+ , LayoutBlock(..), LayoutContext, LayoutStatus(..)+ , Column , ParseFlags (..) -- * Running the parser , initState , defaultParseFlags , parse , parsePosString- , parseFile+ , parseFromSrc -- * Manipulating the state , setParsePos, setLastPos, getParseInterval , setPrevToken , getParseFlags , getLexState, pushLexState, popLexState -- ** Layout- , topContext, popContext, pushContext- , pushCurrentContext+ , topBlock, popBlock, pushBlock+ , getContext, setContext, modifyContext+ , resetLayoutStatus+ -- ** Brackets+ , openBracket, closeBracket -- ** Errors- , parseError, parseErrorAt+ , parseWarning, parseWarningName+ , parseError, parseErrorAt, parseError', parseErrorRange , lexError ) where -import Control.Exception-import Data.Char-import Data.Int-import Data.Typeable+import Prelude hiding ( null ) -import Control.Monad.State-import Control.Monad.Error-import Control.Applicative+import Control.DeepSeq+import Control.Exception ( displayException )+import Control.Monad.Except (MonadError(..))+import Control.Monad.State (MonadState(..), modify', modify, gets)+import Control.Monad +import Data.Maybe ( listToMaybe, fromMaybe )+import Data.Word ( Word32 )+import Data.List ( uncons )++import GHC.Exts (oneShot)++import Agda.Interaction.Options.Warnings++import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete.Attribute import Agda.Syntax.Position+import Agda.Syntax.Parser.Tokens ( Keyword( KwMutual ), Token(..), Symbol(..), QualifiableToken (QualOpenIdiom) ) -import Agda.Utils.FileName-import qualified Agda.Utils.IO.UTF8 as UTF8-import Agda.Utils.Monad+import Agda.TypeChecking.Positivity.Occurrence ( pattern Mixed ) +import Agda.Utils.Function ( applyUnless )+import Agda.Utils.Functor ( (<&>) )+import Agda.Utils.IO ( showIOException )+import Agda.Utils.List ( tailWithDefault )+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Null+import Agda.Utils.Word (packW64, splitW64)++import Agda.Utils.Impossible+ {-------------------------------------------------------------------------- The parse monad --------------------------------------------------------------------------} --- | The parse monad. Equivalent to @StateT 'ParseState' (Either 'ParseError')@--- except for the definition of @fail@, which builds a suitable 'ParseError'--- object.-newtype Parser a = P { unP :: ParseState -> ParseResult a }+type ParseRes a = (# ParseError | (# a , ParseState #) #)+pattern PErr :: ParseError -> ParseRes a+pattern PErr e <- (# e | #) where PErr !e = (# e | #)+pattern POk :: a -> ParseState -> ParseRes a+pattern POk a s <- (# | (# a, s #) #) where POk !a !s = (# | (# a, s #) #)+{-# INLINE PErr #-}+{-# INLINE POk #-}+{-# COMPLETE PErr, POk #-} +newtype Parser a = Parser {_runP :: ParseState -> ParseRes a}++instance Functor Parser where+ {-# INLINE fmap #-}+ fmap f (Parser g) = Parser (oneShot \s -> case g s of+ POk a s -> POk (f a) s+ PErr e -> PErr e)++instance Applicative Parser where+ {-# INLINE pure #-}+ pure a = Parser (\s -> POk a s)+ {-# INLINE (<*>) #-}+ (<*>) (Parser pf) (Parser pa) = Parser (oneShot \s -> case pf s of+ POk f s -> case pa s of+ POk a s -> POk (f a) s+ PErr e -> PErr e+ PErr e -> PErr e)++instance Monad Parser where+ return = pure+ {-# INLINE (>>=) #-}+ Parser pa >>= f = Parser (oneShot \s -> case pa s of+ POk a s -> _runP (f a) s+ PErr e -> PErr e)++instance MonadState ParseState Parser where+ {-# INLINE get #-}+ get = Parser (oneShot \s -> POk s s)+ {-# INLINE put #-}+ put s = Parser (oneShot \_ -> POk () s)++instance MonadError ParseError Parser where+ {-# INLINE throwError #-}+ throwError e = Parser \_ -> PErr e+ {-# INLINE catchError #-}+ catchError (Parser pa) f = Parser (oneShot \s -> case pa s of+ POk a s -> POk a s+ PErr e -> _runP (f e) s)+ -- | The parser state. Contains everything the parser and the lexer could ever -- need. data ParseState = PState- { parsePos :: !Position -- ^ position at current input location- , parseLastPos :: !Position -- ^ position of last token- , parseInp :: String -- ^ the current input- , parsePrevChar :: !Char -- ^ the character before the input- , parsePrevToken:: String -- ^ the previous token- , parseLayout :: [LayoutContext] -- ^ the stack of layout contexts- , parseLexState :: [LexState] -- ^ the state of the lexer- -- (states can be nested so we need a stack)- , parseFlags :: ParseFlags -- ^ currently there are no flags+ { parseSrcFile :: !SrcFile+ , parsePos :: !PositionWithoutFile -- ^ position at current input location+ , parseLastPos :: !PositionWithoutFile -- ^ position of last token+ , parseInp :: !String -- ^ the current input+ , parsePrevChar :: !Char -- ^ the character before the input+ , parsePrevToken :: !String -- ^ the previous token+ , parseLayout :: !LayoutContext -- ^ the stack of layout blocks+ , parseLayStatus :: !LayoutStatus -- ^ the status of the coming layout block+ , parseLayKw :: !Keyword -- ^ the keyword for the coming layout block+ , parseLexState :: ![LexState] -- ^ the state of the lexer+ -- (states can be nested so we need a stack)+ , parseFlags :: !ParseFlags -- ^ parametrization of the parser+ , parseWarnings :: ![ParseWarning] -- ^ In reverse order.+ , parseBrackets :: ![OpenBracket] -- ^ stack of open unicode/ASCII brackets+ , parseAttributes :: !Attributes -- ^ Every encountered attribute. } deriving Show -{-| To do context sensitive lexing alex provides what is called /start codes/- in the Alex documentation. It is really an integer representing the state+{-| For context sensitive lexing alex provides what is called /start codes/+ in the Alex documentation. It is really an integer representing the state of the lexer, so we call it @LexState@ instead. -} type LexState = Int +-- | The stack of layout blocks.+--+-- When we encounter a layout keyword, we push a 'Tentative' block+-- with 'noColumn'. This is replaced by aproper column once we+-- reach the next token.+type LayoutContext = [LayoutBlock]+ -- | We need to keep track of the context to do layout. The context--- specifies the indentation (if any) of a layout block. See+-- specifies the indentation columns of the open layout blocks. See -- "Agda.Syntax.Parser.Layout" for more informaton.-data LayoutContext = NoLayout -- ^ no layout- | Layout Int32 -- ^ layout at specified column+data LayoutBlock+ = Layout Keyword LayoutStatus Column+ -- ^ Layout at specified 'Column', introduced by 'Keyword'. deriving Show --- | There aren't any parser flags at the moment.-data ParseFlags = ParseFlags- { parseKeepComments :: Bool+-- | A (layout) column.+type Column = Word32++-- | Status of a layout column (see #1145).+-- A layout column is 'Tentative' until we encounter a new line.+-- This allows stacking of layout keywords.+--+-- Inside a @LayoutContext@ the sequence of 'Confirmed' columns+-- needs to be strictly increasing.+-- 'Tentative columns between 'Confirmed' columns need to be+-- strictly increasing as well.+data LayoutStatus+ = Tentative -- ^ The token defining the layout column was on the same line+ -- as the layout keyword and we have not seen a new line yet.+ | Confirmed -- ^ We have seen a new line since the layout keyword+ -- and the layout column has not been superseded by+ -- a smaller column.+ deriving (Eq, Show)++-- | Information about an opening unicode-able bracket necessary for+-- correctly parsing its closing delimiter.+data OpenBracket+ -- | An opening idiom bracket.+ = OpenIdiomBracket+ { openBracketUnicode :: Bool -- ^ 'True' if the user wrote @⦇@.+ , openBracketInterval :: Interval -- ^ Position of the opening bracket.+ }+ -- | An opening double brace.+ | OpenDoubleBrace+ { openBracketUnicode :: Bool -- ^ 'True' if the user wrote @⦃@.+ , openBracketInterval :: Interval -- ^ Position of the opening bracket.+ }+ deriving (Eq, Show)++instance NFData OpenBracket where+ rnf (OpenIdiomBracket x _) = rnf x+ rnf (OpenDoubleBrace x _) = rnf x++-- | Parser flags.+data ParseFlags = ParseFlags+ { parseKeepComments :: !Bool -- ^ Should comment tokens be returned by the lexer? } deriving Show --- | What you get if parsing fails.-data ParseError = ParseError- { errPos :: Position -- ^ where the error occured- , errInput :: String -- ^ the remaining input- , errPrevToken :: String -- ^ the previous token- , errMsg :: String -- ^ hopefully an explanation- -- of what happened- }- deriving (Typeable)+-- | Parse errors: what you get if parsing fails.+data ParseError -instance Exception ParseError+ -- | Errors that arise at a specific position in the file+ = ParseError+ { errPos :: !Position+ -- ^ Where the error occurred.+ , errInput :: !String+ -- ^ The remaining input.+ , errPrevToken :: !String+ -- ^ The previous token.+ , errMsg :: !String+ -- ^ Hopefully an explanation of what happened.+ } + -- | Parse errors that concern a range in a file.+ | OverlappingTokensError+ { errRange :: !Range+ -- ^ The range of the bigger overlapping token+ }++ -- | Parse errors that concern a whole file.+ | InvalidExtensionError+ { errPath :: !RangeFile+ -- ^ The file which the error concerns.+ , errValidExts :: ![String]+ }+ | ReadFileError+ { errPath :: !RangeFile+ , errIOError :: !IOError+ }+ deriving Show++instance KillRange ParseError where+ killRange = \case+ ParseError _ inp tok msg -> ParseError empty inp tok msg+ OverlappingTokensError _ -> OverlappingTokensError empty+ InvalidExtensionError _ exts -> InvalidExtensionError empty exts+ ReadFileError _ err -> ReadFileError empty err++instance NFData ParseError where+ rnf = \case+ ParseError _r inp tok msg -> rnf inp `seq` rnf tok `seq` rnf msg+ OverlappingTokensError _r -> ()+ InvalidExtensionError _r exts -> rnf exts+ ReadFileError _r _err -> ()++-- | Warnings for parsing.+data ParseWarning+ -- | Parse errors that concern a range in a file.+ = OverlappingTokensWarning+ { warnRange :: !(Range' SrcFile)+ -- ^ The range of the bigger overlapping token.+ }+ | MisplacedAttributes Range !String+ -- ^ The 'String' is the error message.+ | UnknownPolarity Range !String+ -- ^ Unknown polarity, ignored.+ | UnknownAttribute Range !String+ -- ^ Unknown attribute, ignored.+ -- The 'Range' includes the "@", the 'String' not.+ | UnsupportedAttribute Range !(Maybe String)+ -- ^ Unsupported attribute.+ | MultipleAttributes Range !(Maybe String)+ -- ^ Multiple attributes.+ | MismatchedBrackets Range !OpenBracket+ -- ^ The closing bracket (at the 'Range') was closed with a+ -- unicode-ness that doesn't match that of the 'OpenBracket'.+ deriving Show++instance NFData ParseWarning where+ rnf (OverlappingTokensWarning _) = ()+ rnf (MisplacedAttributes _ s) = rnf s+ rnf (UnknownPolarity _ s) = rnf s+ rnf (UnknownAttribute _ s) = rnf s+ rnf (UnsupportedAttribute _ s) = rnf s+ rnf (MultipleAttributes _ s) = rnf s+ rnf (MismatchedBrackets _ s) = rnf s++parseWarningName :: ParseWarning -> WarningName+parseWarningName = \case+ OverlappingTokensWarning{} -> OverlappingTokensWarning_+ MisplacedAttributes{} -> MisplacedAttributes_+ UnknownPolarity{} -> UnknownPolarity_+ UnknownAttribute{} -> UnknownAttribute_+ UnsupportedAttribute{} -> UnsupportedAttribute_+ MultipleAttributes{} -> MultipleAttributes_+ MismatchedBrackets{} -> MismatchedBrackets_+ -- | The result of parsing something.-data ParseResult a = ParseOk ParseState a- | ParseFailed ParseError+data ParseResult a+ = ParseOk ParseState a+ | ParseFailed ParseError+ deriving Show +-- | Old interface to parser.+unP :: Parser a -> ParseState -> ParseResult a+unP (Parser m) s = case m s of+ PErr e -> ParseFailed e+ POk a s -> ParseOk s a++-- | Throw a parse error at the current position.+parseError :: String -> Parser a+parseError msg = do+ s <- get+ throwError $ ParseError+ { errPos = parseLastPos s <&> const (parseSrcFile s)+ , errInput = parseInp s+ , errPrevToken = parsePrevToken s+ , errMsg = msg+ }++-- | Records a warning.++parseWarning :: ParseWarning -> Parser ()+parseWarning w =+ modify' $ \s -> s { parseWarnings = w : parseWarnings s }+ {-------------------------------------------------------------------------- Instances --------------------------------------------------------------------------} -instance Monad Parser where- return x = P $ \s -> ParseOk s x- P m >>= f = P $ \s -> case m s of- ParseFailed e -> ParseFailed e- ParseOk s' x -> unP (f x) s'- fail msg = P $ \s -> ParseFailed $- ParseError { errPos = parseLastPos s- , errInput = parseInp s- , errPrevToken = parsePrevToken s- , errMsg = msg- }+instance Pretty ParseError where+ pretty ParseError{ errPos, errMsg, errPrevToken, errInput } = vcat+ [ applyUnless (null errPos) ((pretty errPos <> colon) <+>) "error: [ParseError]"+ , if not $ null errMsg then text errMsg else sep+ -- Happy errors have no message, so we print the context instead+ [ text $ errPrevToken ++ "<ERROR>"+ , text $ take 30 errInput ++ "..."+ ]+ ]+ pretty OverlappingTokensError{errRange} = vcat+ [ applyUnless (null errRange) ((pretty errRange <> colon) <+>) "error: [OverlappingTokensError]"+ , "Multi-line comment spans one or more literate text blocks."+ ]+ pretty InvalidExtensionError{errPath,errValidExts} = vcat+ [ applyUnless (null errPath) ((pretty errPath <> colon) <+>) "error: [InvalidExtensionError]"+ , "Unsupported extension."+ , "Supported extensions are:" <+> prettyList_ errValidExts+ ]+ pretty ReadFileError{errPath,errIOError} = vcat $ concat+ [ [ "Cannot read file" <+> pretty errPath | not (null errPath) ]+ , [ "Error:" <+> text (showIOException errIOError) ]+ ] -instance Functor Parser where- fmap = liftM+instance HasRange ParseError where+ getRange err = case err of+ ParseError{ errPos = p } -> posToRange p p+ OverlappingTokensError{ errRange } -> errRange+ InvalidExtensionError{} -> errPathRange+ ReadFileError{} -> errPathRange+ where+ errPathRange = posToRange p p+ where p = startPos $ Just $ errPath err -instance Applicative Parser where- pure = return- (<*>) = ap+-- | Does not include printing of the range.+--+instance Pretty ParseWarning where+ pretty = \case -instance MonadError ParseError Parser where- throwError e = P $ \_ -> ParseFailed e- P m `catchError` h = P $ \s -> case m s of- ParseFailed err -> unP (h err) s- m' -> m'+ OverlappingTokensWarning _r ->+ "Multi-line comment spans one or more literate text blocks." -instance MonadState ParseState Parser where- get = P $ \s -> ParseOk s s- put s = P $ \_ -> ParseOk s ()+ MisplacedAttributes _r s -> text s -instance Show ParseError where- show err =- unlines- [ pos ++ ": " ++ errMsg err- --, replicate (length pos + 2) ' ' ++ "on '" ++ errPrevToken err ++ "'"- , errPrevToken err ++ "<ERROR>\n" ++ take 30 (errInput err) ++ "..."- ]- where- pos = show (errPos err)+ UnknownPolarity _r s ->+ "Replacing unknown polarity" <+> text s <+> "by" <+> pretty Mixed --- showInp "" = "at end of file"--- showInp t = "on input " ++ elide 5 t------ elide 3 s--- | length (take 4 s) < 4 = s--- | otherwise = "..."--- elide n (c:s) = c : elide (n - 1) s--- elide _ "" = ""+ UnknownAttribute _r s ->+ "Ignoring unknown attribute:" <+> ("@" <> text s) -instance HasRange ParseError where- getRange err = posToRange (errPos err) (errPos err)+ UnsupportedAttribute _r ms -> hsep+ [ case ms of+ Nothing -> "Attributes"+ Just s -> text s <+> "attributes"+ , "are not supported here."+ ] + MismatchedBrackets _r brk ->+ let+ (nm, op, cl) = case brk of+ OpenIdiomBracket True _ -> ("Idiom brackets", "\x2987", "\x2988")+ OpenIdiomBracket False _ -> ("Idiom brackets", "(|", "|)")+ OpenDoubleBrace True _ -> ("Double braces", "\x2983", "\x2984")+ OpenDoubleBrace False _ -> ("Double braces", "{{", "}}")+ in nm <> " opened with `" <> op <> "` must be closed with `" <> cl <> "`."++ MultipleAttributes _r ms -> hsep+ [ "Multiple", pretty ms, "attributes (ignored)." ]+++instance HasRange ParseWarning where+ getRange OverlappingTokensWarning{warnRange} = warnRange+ getRange (MisplacedAttributes r _) = r+ getRange (UnknownPolarity r _) = r+ getRange (UnknownAttribute r _) = r+ getRange (UnsupportedAttribute r _) = r+ getRange (MultipleAttributes r _) = r+ getRange (MismatchedBrackets r _) = r+ {-------------------------------------------------------------------------- Running the parser --------------------------------------------------------------------------} initStatePos :: Position -> ParseFlags -> String -> [LexState] -> ParseState initStatePos pos flags inp st =- PState { parsePos = pos- , parseLastPos = pos- , parseInp = inp- , parsePrevChar = '\n'- , parsePrevToken = ""- , parseLexState = st- , parseLayout = [NoLayout]- , parseFlags = flags- }+ PState { parseSrcFile = srcFile pos+ , parsePos = pos'+ , parseLastPos = pos'+ , parseInp = inp+ , parsePrevChar = '\n'+ , parsePrevToken = ""+ , parseLexState = st+ , parseLayout = [] -- the first block will be from the top-level layout+ , parseLayStatus = Confirmed -- for the to-be-determined column of the top-level layout+ , parseLayKw = KwMutual -- Layout keyword for the top-level layout.+ -- Does not mean that the top-level block is a mutual block.+ -- Just for better errors on stray @constructor@ decls.+ , parseFlags = flags+ , parseWarnings = []+ , parseAttributes = []+ , parseBrackets = []+ }+ where+ pos' = pos { srcFile = () } -- | Constructs the initial state of the parser. The string argument -- is the input string, the file path is only there because it's part -- of a position.-initState :: Maybe AbsolutePath -> ParseFlags -> String -> [LexState]- -> ParseState+initState ::+ Maybe RangeFile -> ParseFlags -> String -> [LexState] -> ParseState initState file = initStatePos (startPos file) -- | The default flags.@@ -189,127 +450,163 @@ -- more specialised functions that supply the 'ParseFlags' and the -- 'LexState'. parse :: ParseFlags -> [LexState] -> Parser a -> String -> ParseResult a-parse flags st p input = unP p (initState Nothing flags input st)+parse flags st p input = parseFromSrc flags st p Strict.Nothing input -- | The even more general way of parsing a string. parsePosString :: Position -> ParseFlags -> [LexState] -> Parser a -> String -> ParseResult a parsePosString pos flags st p input = unP p (initStatePos pos flags input st) --- | The most general way of parsing a file. The "Agda.Syntax.Parser" will define--- more specialised functions that supply the 'ParseFlags' and the--- 'LexState'.------ Note that Agda source files always use the UTF-8 character--- encoding.-parseFile :: ParseFlags -> [LexState] -> Parser a -> AbsolutePath- -> IO (ParseResult a)-parseFile flags st p file =- do input <- liftIO $ UTF8.readTextFile $ filePath file- return $ unP p (initState (Just file) flags input st)+-- | Calls 'parsePosString' with 'Position' extracted from the Range.+parseRangeString :: Range -> ParseFlags -> [LexState] -> Parser a -> String ->+ ParseResult a+parseRangeString = parsePosString . fromMaybe (startPos Nothing) . rStart +-- | Parses a string as if it were the contents of the given file+-- Useful for integrating preprocessors.+parseFromSrc :: ParseFlags -> [LexState] -> Parser a -> SrcFile -> String+ -> ParseResult a+parseFromSrc flags st p src input = unP p (initState (Strict.toLazy src) flags input st)++ {-------------------------------------------------------------------------- Manipulating the state --------------------------------------------------------------------------} -setParsePos :: Position -> Parser ()-setParsePos p = modify $ \s -> s { parsePos = p }+setParsePos :: PositionWithoutFile -> Parser ()+setParsePos p = modify' $ \s -> s { parsePos = p } -setLastPos :: Position -> Parser ()-setLastPos p = modify $ \s -> s { parseLastPos = p }+setLastPos :: PositionWithoutFile -> Parser ()+setLastPos p = modify' $ \s -> s { parseLastPos = p } setPrevToken :: String -> Parser ()-setPrevToken t = modify $ \s -> s { parsePrevToken = t }+setPrevToken t = modify' $ \s -> s { parsePrevToken = t } -getLastPos :: Parser Position-getLastPos = get >>= return . parseLastPos+getLastPos :: Parser PositionWithoutFile+getLastPos = gets parseLastPos -- | The parse interval is between the last position and the current position. getParseInterval :: Parser Interval-getParseInterval =- do s <- get- return $ Interval (parseLastPos s) (parsePos s)+getParseInterval = do+ s <- get+ return $ posToInterval (parseSrcFile s) (parseLastPos s) (parsePos s) getLexState :: Parser [LexState]-getLexState = parseLexState <$> get+getLexState = gets parseLexState -setLexState :: [LexState] -> Parser ()-setLexState ls =- do s <- get- put $ s { parseLexState = ls }+-- UNUSED Liang-Ting Chen 2019-07-16+--setLexState :: [LexState] -> Parser ()+--setLexState ls = modify' $ \ s -> s { parseLexState = ls } +modifyLexState :: ([LexState] -> [LexState]) -> Parser ()+modifyLexState f = modify' $ \ s -> s { parseLexState = f (parseLexState s) }+ pushLexState :: LexState -> Parser ()-pushLexState l = do s <- getLexState- setLexState (l:s)+pushLexState l = modifyLexState (l:) popLexState :: Parser ()-popLexState = do _:ls <- getLexState- setLexState ls+popLexState = modifyLexState $ tailWithDefault __IMPOSSIBLE__ getParseFlags :: Parser ParseFlags-getParseFlags = parseFlags <$> get----- | @parseError = fail@-parseError :: String -> Parser a-parseError = fail+getParseFlags = gets parseFlags -- | Fake a parse error at the specified position. Used, for instance, when -- lexing nested comments, which when failing will always fail at the end -- of the file. A more informative position is the beginning of the failing -- comment.-parseErrorAt :: Position -> String -> Parser a+parseErrorAt :: PositionWithoutFile -> String -> Parser a parseErrorAt p msg =- do setLastPos p- parseError msg+ do setLastPos p+ parseError msg +-- | Use 'parseErrorAt' or 'parseError' as appropriate.+parseError' :: Maybe PositionWithoutFile -> String -> Parser a+parseError' = maybe parseError parseErrorAt +-- | Report a parse error at the beginning of the given 'Range'.+parseErrorRange :: HasRange r => r -> String -> Parser a+parseErrorRange = parseError' . rStart' . getRange++ -- | For lexical errors we want to report the current position as the site of -- the error, whereas for parse errors the previous position is the one -- we're interested in (since this will be the position of the token we just -- lexed). This function does 'parseErrorAt' the current position. lexError :: String -> Parser a lexError msg =- do p <- parsePos <$> get- parseErrorAt p msg+ do p <- gets parsePos+ parseErrorAt p msg {-------------------------------------------------------------------------- Layout --------------------------------------------------------------------------} -getContext :: Parser [LayoutContext]-getContext = parseLayout <$> get+getContext :: MonadState ParseState m => m LayoutContext+getContext = gets parseLayout -setContext :: [LayoutContext] -> Parser ()-setContext ctx =- do s <- get- put $ s { parseLayout = ctx }+setContext :: LayoutContext -> Parser ()+setContext = modifyContext . const --- | Return the current layout context.-topContext :: Parser LayoutContext-topContext =- do ctx <- getContext- case ctx of- [] -> parseError "No layout context in scope"- l:_ -> return l+modifyContext :: (LayoutContext -> LayoutContext) -> Parser ()+modifyContext f = modify' $ \ s -> s { parseLayout = f (parseLayout s) } -popContext :: Parser ()-popContext =- do ctx <- getContext- case ctx of- [] -> parseError "There is no layout block to close at this point."- _:ctx -> setContext ctx+-- | Return the current layout block.+topBlock :: Parser (Maybe LayoutBlock)+topBlock = listToMaybe <$> getContext -pushContext :: LayoutContext -> Parser ()-pushContext l =- do ctx <- getContext- setContext (l : ctx)+popBlock :: Parser ()+popBlock =+ do ctx <- getContext+ case ctx of+ [] -> parseError "There is no layout block to close at this point."+ _:ctx -> setContext ctx --- | Should only be used at the beginning of a file. When we start parsing--- we should be in layout mode. Instead of forcing zero indentation we use--- the indentation of the first token.-pushCurrentContext :: Parser ()-pushCurrentContext =- do p <- getLastPos- pushContext (Layout (posCol p))+pushBlock :: LayoutBlock -> Parser ()+pushBlock l = modifyContext (l :)++-- | When we see a layout keyword, by default we expect a 'Tentative' block.+resetLayoutStatus :: Parser ()+resetLayoutStatus = modify' $ \ s -> s { parseLayStatus = Tentative }++------------------------------------------------------------------------+-- * Brackets++-- | Push the 'OpenBracket' state corresponding to an opening token.+openBracket :: Token -> Parser Range+openBracket tok =+ case tok of+ TokSymbol (SymOpenIdiomBracket u) r -> push r $ OpenIdiomBracket u+ TokSymbol (SymDoubleOpenBrace u) r -> push r $ OpenDoubleBrace u+ TokQual (QualOpenIdiom u) _ r -> push r $ OpenIdiomBracket u++ -- These are the only tokens we call this for.+ _ -> __IMPOSSIBLE__+ where push rng k = getRange rng <$ modify' \s -> s { parseBrackets = k rng:parseBrackets s}++-- | Pop an 'OpenBracket' from the parser state, and generate the+-- 'MismatchedBrackets' warning if the given 'Token' does not match what+-- was expected.+closeBracket :: Token -> Parser Range+closeBracket (TokSymbol sym ivl) = do+ let+ rng = getRange ivl+ match a b xs = rng <$ do+ unless (openBracketUnicode a == b) $ parseWarning $ MismatchedBrackets rng a+ modify' \s -> s { parseBrackets = xs }++ -- Since Happy won't call the action if the rule doesn't match, and we+ -- call this function from the *parser*, this function is guaranteed+ -- to only run if the parser is expecting a closing delimiter of the+ -- right type.+ gets parseBrackets >>= \case+ open@OpenIdiomBracket{}:xs+ | SymCloseIdiomBracket uC <- sym -> match open uC xs+ | otherwise -> __IMPOSSIBLE__+ open@OpenDoubleBrace{}:xs+ | SymDoubleCloseBrace uC <- sym -> match open uC xs+ | otherwise -> __IMPOSSIBLE__+ [] -> __IMPOSSIBLE__++-- Only symbols can be closing delimiters.+closeBracket _ = __IMPOSSIBLE__
@@ -1,1410 +1,1951 @@ {-{-# OPTIONS_GHC -fno-warn-incomplete-patterns- -fno-warn-deprecated-flags #-}-{-# LANGUAGE BangPatterns #-}-{-| The parser is generated by Happy (<http://www.haskell.org/happy>).--}-module Agda.Syntax.Parser.Parser (- moduleParser- , exprParser- , tokensParser- , tests- ) where--import Control.Arrow-import Control.Monad-import Control.Monad.State-import Data.Char-import Data.List-import Data.Maybe-import qualified Data.Traversable as T--import Agda.Syntax.Position hiding (tests)-import Agda.Syntax.Parser.Monad-import Agda.Syntax.Parser.Lexer-import Agda.Syntax.Parser.Tokens-import Agda.Syntax.Concrete-import Agda.Syntax.Concrete.Name-import Agda.Syntax.Concrete.Pretty-import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Literal--import Agda.Utils.Monad-import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers-}--%name tokensParser Tokens-%name exprParser Expr-%name moduleParser File-%tokentype { Token }-%monad { Parser }-%lexer { lexer } { TokEOF }---- This is a trick to get rid of shift/reduce conflicts arising because we want--- to parse things like "m >>= \x -> k x". See the Expr rule for more--- information.-%nonassoc LOWEST-%nonassoc '->'--%token- 'let' { TokKeyword KwLet $$ }- 'in' { TokKeyword KwIn $$ }- 'where' { TokKeyword KwWhere $$ }- 'with' { TokKeyword KwWith $$ }- 'rewrite' { TokKeyword KwRewrite $$ }- 'postulate' { TokKeyword KwPostulate $$ }- 'primitive' { TokKeyword KwPrimitive $$ }- 'open' { TokKeyword KwOpen $$ }- 'import' { TokKeyword KwImport $$ }- 'using' { TokKeyword KwUsing $$ }- 'hiding' { TokKeyword KwHiding $$ }- 'renaming' { TokKeyword KwRenaming $$ }- 'to' { TokKeyword KwTo $$ }- 'public' { TokKeyword KwPublic $$ }- 'module' { TokKeyword KwModule $$ }- 'data' { TokKeyword KwData $$ }- 'codata' { TokKeyword KwCoData $$ }- 'record' { TokKeyword KwRecord $$ }- 'constructor' { TokKeyword KwConstructor $$ }- 'field' { TokKeyword KwField $$ }- 'infix' { TokKeyword KwInfix $$ }- 'infixl' { TokKeyword KwInfixL $$ }- 'infixr' { TokKeyword KwInfixR $$ }- 'mutual' { TokKeyword KwMutual $$ }- 'abstract' { TokKeyword KwAbstract $$ }- 'private' { TokKeyword KwPrivate $$ }- 'Prop' { TokKeyword KwProp $$ }- 'Set' { TokKeyword KwSet $$ }- 'forall' { TokKeyword KwForall $$ }- 'syntax' { TokKeyword KwSyntax $$ }- 'OPTIONS' { TokKeyword KwOPTIONS $$ }- 'BUILTIN' { TokKeyword KwBUILTIN $$ }- 'IMPORT' { TokKeyword KwIMPORT $$ }- 'IMPOSSIBLE' { TokKeyword KwIMPOSSIBLE $$ }- 'ETA' { TokKeyword KwETA $$ }- 'COMPILED' { TokKeyword KwCOMPILED $$ }- 'COMPILED_DATA' { TokKeyword KwCOMPILED_DATA $$ }- 'COMPILED_TYPE' { TokKeyword KwCOMPILED_TYPE $$ }- 'COMPILED_EPIC' { TokKeyword KwCOMPILED_EPIC $$ }- 'COMPILED_JS' { TokKeyword KwCOMPILED_JS $$ }- 'STATIC' { TokKeyword KwSTATIC $$ }- 'quoteGoal' { TokKeyword KwQuoteGoal $$ }- 'quote' { TokKeyword KwQuote $$ }- 'quoteTerm' { TokKeyword KwQuoteTerm $$ }- 'unquote' { TokKeyword KwUnquote $$ }-- setN { TokSetN $$ }- tex { TokTeX $$ }- comment { TokComment $$ }-- '...' { TokSymbol SymEllipsis $$ }- '..' { TokSymbol SymDotDot $$ }- '.' { TokSymbol SymDot $$ }- ';' { TokSymbol SymSemi $$ }- ':' { TokSymbol SymColon $$ }- '=' { TokSymbol SymEqual $$ }- '_' { TokSymbol SymUnderscore $$ }- '?' { TokSymbol SymQuestionMark $$ }- '->' { TokSymbol SymArrow $$ }- '\\' { TokSymbol SymLambda $$ }- '@' { TokSymbol SymAs $$ }- '|' { TokSymbol SymBar $$ }- '(' { TokSymbol SymOpenParen $$ }- ')' { TokSymbol SymCloseParen $$ }- '{{' { TokSymbol SymDoubleOpenBrace $$ }- '}}' { TokSymbol SymDoubleCloseBrace $$ }- '{' { TokSymbol SymOpenBrace $$ }- '}' { TokSymbol SymCloseBrace $$ }- vopen { TokSymbol SymOpenVirtualBrace $$ }- vclose { TokSymbol SymCloseVirtualBrace $$ }- vsemi { TokSymbol SymVirtualSemi $$ }- '{-#' { TokSymbol SymOpenPragma $$ }- '#-}' { TokSymbol SymClosePragma $$ }-- id { TokId $$ }- q_id { TokQId $$ }-- string { TokString $$ }- literal { TokLiteral $$ }--%%--{--------------------------------------------------------------------------- Parsing the token stream. Used by the TeX compiler.- --------------------------------------------------------------------------}---- Parse a list of tokens.-Tokens :: { [Token] }-Tokens : TokensR { reverse $1 }---- Happy is much better at parsing left recursive grammars (constant--- stack size vs. linear stack size for right recursive).-TokensR :: { [Token] }-TokensR : TokensR Token { $2 : $1 }- | { [] }---- Parse single token.-Token :: { Token }-Token- : 'let' { TokKeyword KwLet $1 }- | 'in' { TokKeyword KwIn $1 }- | 'where' { TokKeyword KwWhere $1 }- | 'with' { TokKeyword KwWith $1 }- | 'rewrite' { TokKeyword KwRewrite $1 }- | 'postulate' { TokKeyword KwPostulate $1 }- | 'primitive' { TokKeyword KwPrimitive $1 }- | 'open' { TokKeyword KwOpen $1 }- | 'import' { TokKeyword KwImport $1 }- | 'using' { TokKeyword KwUsing $1 }- | 'hiding' { TokKeyword KwHiding $1 }- | 'renaming' { TokKeyword KwRenaming $1 }- | 'to' { TokKeyword KwTo $1 }- | 'public' { TokKeyword KwPublic $1 }- | 'module' { TokKeyword KwModule $1 }- | 'data' { TokKeyword KwData $1 }- | 'codata' { TokKeyword KwCoData $1 }- | 'record' { TokKeyword KwRecord $1 }- | 'constructor' { TokKeyword KwConstructor $1 }- | 'field' { TokKeyword KwField $1 }- | 'infix' { TokKeyword KwInfix $1 }- | 'infixl' { TokKeyword KwInfixL $1 }- | 'infixr' { TokKeyword KwInfixR $1 }- | 'mutual' { TokKeyword KwMutual $1 }- | 'abstract' { TokKeyword KwAbstract $1 }- | 'private' { TokKeyword KwPrivate $1 }- | 'Prop' { TokKeyword KwProp $1 }- | 'Set' { TokKeyword KwSet $1 }- | 'forall' { TokKeyword KwForall $1 }- | 'syntax' { TokKeyword KwSyntax $1 }- | 'OPTIONS' { TokKeyword KwOPTIONS $1 }- | 'BUILTIN' { TokKeyword KwBUILTIN $1 }- | 'IMPORT' { TokKeyword KwIMPORT $1 }- | 'COMPILED' { TokKeyword KwCOMPILED $1 }- | 'COMPILED_DATA'{ TokKeyword KwCOMPILED_DATA $1 }- | 'COMPILED_TYPE'{ TokKeyword KwCOMPILED_TYPE $1 }- | 'COMPILED_EPIC'{ TokKeyword KwCOMPILED_EPIC $1 }- | 'COMPILED_JS' { TokKeyword KwCOMPILED_JS $1 }- | 'STATIC' { TokKeyword KwSTATIC $1 }- | 'IMPOSSIBLE' { TokKeyword KwIMPOSSIBLE $1 }- | 'ETA' { TokKeyword KwETA $1 }- | 'quoteGoal' { TokKeyword KwQuoteGoal $1 }- | 'quote' { TokKeyword KwQuote $1 }- | 'quoteTerm' { TokKeyword KwQuoteTerm $1 }- | 'unquote' { TokKeyword KwUnquote $1 }-- | setN { TokSetN $1 }- | tex { TokTeX $1 }- | comment { TokComment $1 }-- | '...' { TokSymbol SymEllipsis $1 }- | '..' { TokSymbol SymDotDot $1 }- | '.' { TokSymbol SymDot $1 }- | ';' { TokSymbol SymSemi $1 }- | ':' { TokSymbol SymColon $1 }- | '=' { TokSymbol SymEqual $1 }- | '_' { TokSymbol SymUnderscore $1 }- | '?' { TokSymbol SymQuestionMark $1 }- | '->' { TokSymbol SymArrow $1 }- | '\\' { TokSymbol SymLambda $1 }- | '@' { TokSymbol SymAs $1 }- | '|' { TokSymbol SymBar $1 }- | '(' { TokSymbol SymOpenParen $1 }- | ')' { TokSymbol SymCloseParen $1 }- | '{{' { TokSymbol SymDoubleOpenBrace $1 }- | '}}' { TokSymbol SymDoubleCloseBrace $1 }- | '{' { TokSymbol SymOpenBrace $1 }- | '}' { TokSymbol SymCloseBrace $1 }- | vopen { TokSymbol SymOpenVirtualBrace $1 }- | vclose { TokSymbol SymCloseVirtualBrace $1 }- | vsemi { TokSymbol SymVirtualSemi $1 }- | '{-#' { TokSymbol SymOpenPragma $1 }- | '#-}' { TokSymbol SymClosePragma $1 }-- | id { TokId $1 }- | q_id { TokQId $1 }- | string { TokString $1 }-- | literal { TokLiteral $1 }--{--------------------------------------------------------------------------- Top level- --------------------------------------------------------------------------}--File :: { ([Pragma], [Declaration]) }-File : File1 { $1 }--File1 : TopLevel { ([], $1) }- | TopLevelPragma File1 { let (ps,m) = $2 in ($1 : ps, m) }---{--------------------------------------------------------------------------- Meta rules- --------------------------------------------------------------------------}---- The first token in a file decides the indentation of the top-level layout--- block. Or not. It will if we allow the top-level module to be omitted.--- topen : {- empty -} {% pushCurrentContext }---{- A layout block might have to be closed by a parse error. Example:- let x = e in e'- Here the 'let' starts a layout block which should end before the 'in'. The- problem is that the lexer doesn't know this, so there is no virtual close- brace. However when the parser sees the 'in' there will be a parse error.- This is our cue to close the layout block.--}-close : vclose { () }- | error {% popContext }----- You can use concrete semi colons in a layout block started with a virtual--- brace, so we don't have to distinguish between the two semi colons. You can't--- use a virtual semi colon in a block started by a concrete brace, but this is--- simply because the lexer will not generate virtual semis in this case.-semi : ';' { $1 }- | vsemi { $1 }----- Enter the 'imp_dir' lex state, where we can parse the keywords 'using',--- 'hiding', 'renaming' and 'to'.-beginImpDir :: { () }-beginImpDir : {- empty -} {% pushLexState imp_dir }--{--------------------------------------------------------------------------- Helper rules- --------------------------------------------------------------------------}---- An integer. Used in fixity declarations.-Int :: { Integer }-Int : literal {% case $1 of {- LitInt _ n -> return n;- _ -> fail $ "Expected integer"- }- }---{--------------------------------------------------------------------------- Names- --------------------------------------------------------------------------}---- A name is really a sequence of parts, but the lexer just sees it as a--- string, so we have to do the translation here.-Id :: { Name }-Id : id {% mkName $1 }---- Space separated list of one or more identifiers.-SpaceIds :: { [Name] }-SpaceIds- : Id SpaceIds { $1 : $2 }- | Id { [$1] }---- When looking for a double closed brace, we accept either a single token '}}'--- (which is what the unicode character "RIGHT WHITE CURLY BRACKET" is--- postprocessed into in LexActions.hs), but also two consecutive tokens '}'--- (which a string '}}' is lexed to). This small hack allows us to keep--- "record { a = record { }}" working. In the second case, we check that the two--- tokens '}' are immediately consecutive.-DoubleCloseBrace :: { Range }-DoubleCloseBrace- : '}}' { getRange $1 }- | '}' '}' {%- if posPos (fromJust (rEnd (getRange $2))) -- posPos (fromJust (rStart (getRange $1))) > 2- then parseErrorAt (fromJust (rStart (getRange $2)))- "Expecting '}}', found separated '}'s."- else return $ fuseRange (getRange $1) (getRange ($2))- }--{- UNUSED--- Space separated list of one or more identifiers, some of which may--- be surrounded by braces.-HiddenIds :: { [Arg Name] }-HiddenIds- : Id HiddenIds { defaultArg $1 : $2 }- | Id { [defaultArg $1] }- | '{{' SpaceIds DoubleCloseBrace HiddenIds { map (Arg Instance Relevant) $2 ++ $4 }- | '{{' SpaceIds DoubleCloseBrace { map (Arg Instance Relevant) $2 }- | '{' SpaceIds '}' HiddenIds { map (Arg Hidden Relevant) $2 ++ $4 }- | '{' SpaceIds '}' { map (Arg Hidden Relevant) $2 }--}---- A possibly dotted identifier.-MaybeDottedId :: { Arg Name }-MaybeDottedId- : '.' Id { Arg NotHidden Irrelevant $2 }- | Id { defaultArg $1 }---- Space separated list of one or more possibly dotted identifiers.-MaybeDottedIds :: { [Arg Name] }-MaybeDottedIds- : MaybeDottedId MaybeDottedIds { $1 : $2 }- | MaybeDottedId { [$1] }---- Space separated list of one or more identifiers, some of which may--- be surrounded by braces or dotted.-ArgIds :: { [Arg Name] }-ArgIds- : MaybeDottedId ArgIds { $1 : $2 }- | MaybeDottedId { [$1] }- | '{{' MaybeDottedIds DoubleCloseBrace ArgIds { map makeInstance $2 ++ $4 }- | '{{' MaybeDottedIds DoubleCloseBrace { map makeInstance $2 }- | '{' MaybeDottedIds '}' ArgIds { map hide $2 ++ $4 }- | '{' MaybeDottedIds '}' { map hide $2 }- | '.' '{' SpaceIds '}' ArgIds { map (Arg Hidden Irrelevant) $3 ++ $5 }- | '.' '{' SpaceIds '}' { map (Arg Hidden Irrelevant) $3 }- | '.' '{{' SpaceIds DoubleCloseBrace ArgIds { map (Arg Instance Irrelevant) $3 ++ $5 }- | '.' '{{' SpaceIds DoubleCloseBrace { map (Arg Instance Irrelevant) $3 }- | '..' '{' SpaceIds '}' ArgIds { map (Arg Hidden NonStrict) $3 ++ $5 }- | '..' '{' SpaceIds '}' { map (Arg Hidden NonStrict) $3 }- | '..' '{{' SpaceIds DoubleCloseBrace ArgIds { map (Arg Instance NonStrict) $3 ++ $5 }- | '..' '{{' SpaceIds DoubleCloseBrace { map (Arg Instance NonStrict) $3 }--QId :: { QName }-QId : q_id {% mkQName $1 }- | Id { QName $1 }----- A module name is just a qualified name-ModuleName :: { QName }-ModuleName : QId { $1 }----- A binding variable. Can be '_'-BId :: { Name }-BId : Id { $1 }- | '_' { Name (getRange $1) [Hole] }--{- UNUSED--- A binding variable. Can be '_'-MaybeDottedBId :: { (Relevance, Name) }-MaybeDottedBId- : BId { (Relevant , $1) }- | '.' BId { (Irrelevant, $2) }- | '..' BId { (NonStrict, $2) }--}----- Space separated list of binding identifiers. Used in fixity--- declarations infixl 100 + --SpaceBIds :: { [Name] }-SpaceBIds- : BId SpaceBIds { $1 : $2 }- | BId { [$1] }--{- DOES PRODUCE REDUCE/REDUCE CONFLICTS!--- Space-separated list of binding identifiers. Used in dependent--- function spaces: (x y z : Nat) -> ...--- (Used to be comma-separated; hence the name)--- QUESTION: Should this be replaced by SpaceBIds above?---CommaBIds :: { [(Relevance,Name)] }-CommaBIds :: { [Name] }-CommaBIds- : CommaBIds BId { $1 ++ [$2] } -- SWITCHING DOES NOT HELP- | BId { [$1] }--}---- Space-separated list of binding identifiers. Used in dependent--- function spaces: (x y z : Nat) -> ...--- (Used to be comma-separated; hence the name)--- QUESTION: Should this be replaced by SpaceBIds above?--- Andreas, 2011-04-07 the trick avoids reduce/reduce conflicts--- when parsing (x y z : A) -> B--- at point (x y it is not clear whether x y is an application or--- a variable list. We could be parsing (x y z) -> B--- with ((x y) z) being a type.-CommaBIds :: { [Name] }-CommaBIds : CommaBIdAndAbsurds {- case $1 of- Left ns -> ns- Right _ -> fail $ "expected sequence of bound identifiers, not absurd pattern"- }-{-- let getName (Ident (QName x)) = Just x- getName (Underscore r _) = Just (Name r [Hole])- getName _ = Nothing- in- case partition isJust $ map getName $1 of- (good, []) -> return $ map fromJust good- _ -> fail $ "expected sequence of bound identifiers"--}--CommaBIdAndAbsurds :: { Either [Name] [Expr] }-CommaBIdAndAbsurds : Application {%- let getName (Ident (QName x)) = Just x- getName (Underscore r _) = Just (Name r [Hole])- getName _ = Nothing-- containsAbsurd (Absurd _) = True- containsAbsurd (HiddenArg _ (Named _ e)) = containsAbsurd e- containsAbsurd (InstanceArg _ (Named _ e)) = containsAbsurd e- containsAbsurd (Paren _ expr) = containsAbsurd expr- containsAbsurd (RawApp _ exprs) = any containsAbsurd exprs- containsAbsurd _ = False- in- if isJust $ find containsAbsurd $1 then return $ Right $1 else- case partition isJust $ map getName $1 of- (good, []) -> return $ Left $ map fromJust good- _ -> fail $ "expected sequence of bound identifiers"- }----- Space separated list of strings in a pragma.-PragmaStrings :: { [String] }-PragmaStrings- : {- empty -} { [] }- | string PragmaStrings { snd $1 : $2 }--PragmaName :: { QName }-PragmaName : string {% fmap QName (mkName $1) }--{--------------------------------------------------------------------------- Expressions (terms and types)- --------------------------------------------------------------------------}--{- Expressions. You might expect lambdas and lets to appear in the first- expression category (lowest precedence). The reason they don't is that we- want to parse things like-- m >>= \x -> k x-- This will leads to a conflict in the following case-- m >>= \x -> k x >>= \y -> k' y-- At the second '>>=' we can either shift or reduce. We solve this problem- using Happy's precedence directives. The rule 'Expr -> Expr1' (which is the- rule you shouldn't use to reduce when seeing '>>=') is given LOWEST- precedence. The terminals '->' and op (which is what you should shift)- is given higher precedence.--}---- Top level: Function types.-Expr :: { Expr }-Expr- : TeleArrow Expr { Pi $1 $2 }- | 'forall' ForallBindings Expr { forallPi $2 $3 }- | Application3 '->' Expr { Fun (fuseRange $1 $3) (RawApp (getRange $1) $1) $3 }- | Expr1 %prec LOWEST { $1 }---- Level 1: Application-Expr1 : WithExprs {% case $1 of- { [e] -> return e- ; e : es -> return $ WithApp (fuseRange e es) e es- ; [] -> fail "impossible: empty with expressions"- }- }--WithExprs :: { [Expr] }-WithExprs- : Application3 '|' WithExprs { RawApp (getRange $1) $1 : $3 }- | Application { [RawApp (getRange $1) $1] }--Application :: { [Expr] }-Application- : Expr2 { [$1] }- | Expr3 Application { $1 : $2 }---- Level 2: Lambdas and lets-Expr2- : '\\' LamBindings Expr { Lam (fuseRange $1 $3) $2 $3 }- | '\\' '{' LamClauses '}' { ExtendedLam (fuseRange $1 (fuseRange $2 $4)) (reverse $3) }- | '\\' AbsurdLamBindings {% case $2 of- Left (bs, h) -> if null bs then return $ AbsurdLam r h else- return $ Lam r bs (AbsurdLam r h)- where r = fuseRange $1 bs- Right es -> do -- it is of the form @\ { p1 ... () }@- p <- exprToLHS (RawApp (getRange es) es);- return $ ExtendedLam (fuseRange $1 es)- [(p [] [], AbsurdRHS, NoWhere)]- }- | 'let' Declarations 'in' Expr { Let (fuseRange $1 $4) $2 $4 }- | Expr3 { $1 }- | 'quoteGoal' Id 'in' Expr { QuoteGoal (getRange ($1,$4)) $2 $4}--Application3 :: { [Expr] }-Application3- : Expr3 { [$1] }- | Expr3 Application3 { $1 : $2 }---- Level 3: Atoms-Expr3Curly- : '{' Expr '}' { HiddenArg (fuseRange $1 $3) (unnamed $2) }- | '{' Id '=' Expr '}' { HiddenArg (fuseRange $1 $5) (named (show $2) $4) }- | '{' '}' { let r = fuseRange $1 $2 in HiddenArg r $ unnamed $ Absurd r }--Expr3NoCurly- : QId { Ident $1 }- | literal { Lit $1 }- | '?' { QuestionMark (getRange $1) Nothing }- | '_' { Underscore (getRange $1) Nothing }- | 'Prop' { Prop (getRange $1) }- | 'Set' { Set (getRange $1) }- | 'quote' { Quote (getRange $1) }- | 'quoteTerm' { QuoteTerm (getRange $1) }- | 'unquote' { Unquote (getRange $1) }- | setN { SetN (getRange (fst $1)) (snd $1) }- | '{{' Expr DoubleCloseBrace { InstanceArg (fuseRange $1 $3) (unnamed $2) }- | '{{' Id '=' Expr DoubleCloseBrace { InstanceArg (fuseRange $1 $5) (named (show $2) $4) }- | '(' Expr ')' { Paren (fuseRange $1 $3) $2 }- | '(' ')' { Absurd (fuseRange $1 $2) }- | '{{' DoubleCloseBrace { let r = fuseRange $1 $2 in InstanceArg r $ unnamed $ Absurd r }- | Id '@' Expr3 { As (fuseRange $1 $3) $1 $3 }- | '.' Expr3 { Dot (fuseRange $1 $2) $2 }- | 'record' '{' FieldAssignments '}' { Rec (getRange ($1,$4)) $3 }- | 'record' Expr3NoCurly '{' FieldAssignments '}' { RecUpdate (getRange ($1,$5)) $2 $4 }--Expr3- : Expr3Curly { $1 }- | Expr3NoCurly { $1 }--FieldAssignments :: { [(Name, Expr)] }-FieldAssignments- : {- empty -} { [] }- | FieldAssignments1 { $1 }--FieldAssignments1 :: { [(Name, Expr)] }-FieldAssignments1- : FieldAssignment { [$1] }- | FieldAssignment ';' FieldAssignments1 { $1 : $3 }--FieldAssignment :: { (Name, Expr) }-FieldAssignment- : Id '=' Expr { ($1, $3) }--{--------------------------------------------------------------------------- Bindings- --------------------------------------------------------------------------}---- "Delta ->" to avoid conflict between Delta -> Gamma and Delta -> A.-TeleArrow : Telescope1 '->' { $1 }--Telescope1- : TypedBindingss { {-TeleBind-} $1 }--TypedBindingss :: { [TypedBindings] }-TypedBindingss- : TypedBindings TypedBindingss { $1 : $2 }- | TypedBindings { [$1] }----- A typed binding is either (x1 .. xn : A) or {y1 .. ym : B}--- Andreas, 2011-04-07: or .(x1 .. xn : A) or .{y1 .. ym : B}--- Andreas, 2011-04-27: or ..(x1 .. xn : A) or ..{y1 .. ym : B}-TypedBindings :: { TypedBindings }-TypedBindings- : '.' '(' TBind ')' { TypedBindings (fuseRange $2 $4) (Arg NotHidden Irrelevant $3) }- | '.' '{' TBind '}' { TypedBindings (fuseRange $2 $4) (Arg Hidden Irrelevant $3) }- | '.' '{{' TBind DoubleCloseBrace { TypedBindings (fuseRange $1 $3) (Arg Instance Irrelevant $3) }- | '..' '(' TBind ')' { TypedBindings (fuseRange $2 $4) (Arg NotHidden NonStrict $3) }- | '..' '{' TBind '}' { TypedBindings (fuseRange $2 $4) (Arg Hidden NonStrict $3) }- | '..' '{{' TBind DoubleCloseBrace { TypedBindings (fuseRange $1 $3) (Arg Instance NonStrict $3) }- | '(' TBind ')' { TypedBindings (fuseRange $1 $3) (Arg NotHidden Relevant $2) }- | '{{' TBind DoubleCloseBrace { TypedBindings (fuseRange $1 $3) (Arg Instance Relevant $2) }- | '{' TBind '}' { TypedBindings (fuseRange $1 $3) (Arg Hidden Relevant $2) }----- x1 .. xn:A-TBind :: { TypedBinding }-TBind : CommaBIds ':' Expr { TBind (fuseRange $1 $3) (map mkBoundName_ $1) $3 }----- A non-empty sequence of lambda bindings.-LamBindings :: { [LamBinding] }-LamBindings- : LamBinds '->' {%- case reverse $1 of- Left _ : _ -> parseError "Absurd lambda cannot have a body."- _ : _ -> return [ b | Right b <- $1 ]- [] -> parsePanic "Empty LamBinds"- }--AbsurdLamBindings :: { Either ([LamBinding], Hiding) [Expr] }-AbsurdLamBindings- : LamBindsAbsurd {%- case $1 of- Left lb -> case reverse lb of- Right _ : _ -> parseError "Missing body for lambda"- Left h : _ -> return $ Left ([ b | Right b <- init lb], h)- _ -> parsePanic "Empty LamBindsAbsurd"- Right es -> return $ Right es- }---- absurd lambda is represented by Left hiding-LamBinds :: { [Either Hiding LamBinding] }-LamBinds- : DomainFreeBinding LamBinds { map Right $1 ++ $2 }- | TypedBindings LamBinds { Right (DomainFull $1) : $2 }- | DomainFreeBinding { map Right $1 }- | TypedBindings { [Right $ DomainFull $1] }- | '(' ')' { [Left NotHidden] }- | '{' '}' { [Left Hidden] }- | '{{' DoubleCloseBrace { [Left Instance] }---- Like LamBinds, but could also parse an absurd LHS of an extended lambda @{ p1 ... () }@-LamBindsAbsurd :: { Either [Either Hiding LamBinding] [Expr] }-LamBindsAbsurd- : DomainFreeBinding LamBinds { Left $ map Right $1 ++ $2 }- | TypedBindings LamBinds { Left $ Right (DomainFull $1) : $2 }- | DomainFreeBindingAbsurd { case $1 of- Left lb -> Left $ map Right lb- Right es -> Right es }- | TypedBindings { Left [Right $ DomainFull $1] }- | '(' ')' { Left [Left NotHidden] }- | '{' '}' { Left [Left Hidden] }- | '{{' DoubleCloseBrace { Left [Left Instance] }---- FNF, 2011-05-05: No where clauses in extended lambdas for now-NonAbsurdLamClause :: { (LHS,RHS,WhereClause) }-NonAbsurdLamClause- : Application3 '->' Expr {% do- p <- exprToLHS (RawApp (getRange $1) $1) ;- return (p [] [], RHS $3, NoWhere)- }--AbsurdLamClause :: { (LHS,RHS,WhereClause) }-AbsurdLamClause--- FNF, 2011-05-09: By being more liberal here, we avoid shift/reduce and reduce/reduce errors.--- Later stages such as scope checking will complain if we let something through which we should not- : Application {% do- p <- exprToLHS (RawApp (getRange $1) $1);- return (p [] [], AbsurdRHS, NoWhere)- }--LamClause :: { (LHS,RHS,WhereClause) }-LamClause- : NonAbsurdLamClause { $1 }- | AbsurdLamClause { $1 }---- Parses all extended lambda clauses except for a single absurd clause, which is taken care of--- in AbsurdLambda-LamClauses :: { [(LHS,RHS,WhereClause)] }-LamClauses- : LamClauses semi LamClause { $3 : $1 }- | AbsurdLamClause semi LamClause { [$3, $1] }- | NonAbsurdLamClause { [$1] }--- | {- empty -} { [] }---ForallBindings :: { [LamBinding] }-ForallBindings- : TypedUntypedBindings1 '->' { $1 }---- A non-empty sequence of possibly untyped bindings.-TypedUntypedBindings1 :: { [LamBinding] }-TypedUntypedBindings1- : DomainFreeBinding TypedUntypedBindings1 { $1 ++ $2 }- | TypedBindings TypedUntypedBindings1 { DomainFull $1 : $2 }- | DomainFreeBinding { $1 }- | TypedBindings { [DomainFull $1] }---- A possibly empty sequence of possibly untyped bindings.--- This is used as telescope in data and record decls.-TypedUntypedBindings :: { [LamBinding] }-TypedUntypedBindings- : DomainFreeBinding TypedUntypedBindings { $1 ++ $2 }- | TypedBindings TypedUntypedBindings { DomainFull $1 : $2 }- | { [] }---- A domain free binding is either x or {x1 .. xn}-DomainFreeBinding :: { [LamBinding] }-DomainFreeBinding- : DomainFreeBindingAbsurd { case $1 of- Left lbs -> lbs- Right _ -> fail "expected sequence of bound identifiers, not absurd pattern"- }-{- : BId { [DomainFree NotHidden Relevant $ mkBoundName_ $1] }- | '.' BId { [DomainFree NotHidden Irrelevant $ mkBoundName_ $2] }- | '..' BId { [DomainFree NotHidden NonStrict $ mkBoundName_ $2] }- | '{' CommaBIds '}' { map (DomainFree Hidden Relevant . mkBoundName_) $2 }- | '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance Relevant . mkBoundName_) $2 }- | '.' '{' CommaBIds '}' { map (DomainFree Hidden Irrelevant . mkBoundName_) $3 }- | '.' '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance Irrelevant . mkBoundName_) $3 }- | '..' '{' CommaBIds '}' { map (DomainFree Hidden NonStrict . mkBoundName_) $3 }- | '..' '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance NonStrict . mkBoundName_) $3 }- | '..' '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance NonStrict . mkBoundName_) $3 }- -}---- A domain free binding is either x or {x1 .. xn}-DomainFreeBindingAbsurd :: { Either [LamBinding] [Expr]}-DomainFreeBindingAbsurd- : BId { Left [DomainFree NotHidden Relevant $ mkBoundName_ $1] }- | '.' BId { Left [DomainFree NotHidden Irrelevant $ mkBoundName_ $2] }- | '..' BId { Left [DomainFree NotHidden NonStrict $ mkBoundName_ $2] }- | '{' CommaBIdAndAbsurds '}'- { either (Left . map (DomainFree Hidden Relevant . mkBoundName_)) Right $2 }- | '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree Instance Relevant . mkBoundName_) $2 }- | '.' '{' CommaBIds '}' { Left $ map (DomainFree Hidden Irrelevant . mkBoundName_) $3 }- | '.' '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree Instance Irrelevant . mkBoundName_) $3 }- | '..' '{' CommaBIds '}' { Left $ map (DomainFree Hidden NonStrict . mkBoundName_) $3 }- | '..' '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree Instance NonStrict . mkBoundName_) $3 }---{--------------------------------------------------------------------------- Modules and imports- --------------------------------------------------------------------------}---- You can rename imports-ImportImportDirective :: { (Maybe AsName, ImportDirective) }-ImportImportDirective- : ImportDirective { (Nothing, $1) }- | id Id ImportDirective {% isName "as" $1 >>- return (Just (AsName $2 (getRange (fst $1))), $3) }---- Import directives-ImportDirective :: { ImportDirective }-ImportDirective : ImportDirective1 {% verifyImportDirective $1 }---- Can contain public-ImportDirective1 :: { ImportDirective }-ImportDirective1- : 'public' ImportDirective2 { $2 { publicOpen = True } }- | ImportDirective2 { $1 }--ImportDirective2 :: { ImportDirective }-ImportDirective2- : UsingOrHiding RenamingDir { ImportDirective (fuseRange (snd $1) (snd $2)) (fst $1) (fst $2) False }- | RenamingDir { ImportDirective (getRange (snd $1)) (Hiding []) (fst $1) False }- | UsingOrHiding { ImportDirective (getRange (snd $1)) (fst $1) [] False }- | {- empty -} { ImportDirective noRange (Hiding []) [] False }--UsingOrHiding :: { (UsingOrHiding , Range) }-UsingOrHiding- : 'using' '(' CommaImportNames ')' { (Using $3 , fuseRange $1 $4) }- -- only using can have an empty list- | 'hiding' '(' CommaImportNames1 ')' { (Hiding $3 , fuseRange $1 $4) }--RenamingDir :: { ([Renaming] , Range) }-RenamingDir- : 'renaming' '(' Renamings ')' { ($3 , fuseRange $1 $4) }---- Renamings of the form 'x to y'-Renamings :: { [Renaming] }-Renamings- : Renaming ';' Renamings { $1 : $3 }- | Renaming { [$1] }--Renaming :: { Renaming }-Renaming- : ImportName_ 'to' Id { Renaming $1 $3 (getRange $2) }---- We need a special imported name here, since we have to trigger--- the imp_dir state exactly one token before the 'to'-ImportName_ :: { ImportedName }-ImportName_- : beginImpDir Id { ImportedName $2 }- | 'module' beginImpDir Id { ImportedModule $3 }--ImportName :: { ImportedName }-ImportName : Id { ImportedName $1 }- | 'module' Id { ImportedModule $2 }---- Actually semi-colon separated-CommaImportNames :: { [ImportedName] }-CommaImportNames- : {- empty -} { [] }- | CommaImportNames1 { $1 }--CommaImportNames1- : ImportName { [$1] }- | ImportName ';' CommaImportNames1 { $1 : $3 }--{--------------------------------------------------------------------------- Function clauses- --------------------------------------------------------------------------}---- A left hand side of a function clause. We parse it as an expression, and--- then check that it is a valid left hand side.-LHS :: { LHS }-LHS : Expr1 RewriteEquations WithExpressions- {% exprToLHS $1 >>= \p -> return (p $2 $3) }- | '...' WithPats RewriteEquations WithExpressions- { Ellipsis (fuseRange $1 $3) $2 $3 $4 }--WithPats :: { [Pattern] }-WithPats : {- empty -} { [] }- | '|' Application3 WithPats- {% exprToPattern (RawApp (getRange $2) $2) >>= \p ->- return (p : $3)- }--WithExpressions :: { [Expr] }-WithExpressions- : {- empty -} { [] }- | 'with' Expr- { case $2 of { WithApp _ e es -> e : es; e -> [e] } }--RewriteEquations :: { [Expr] }-RewriteEquations- : {- empty -} { [] }- | 'rewrite' Expr- { case $2 of { WithApp _ e es -> e : es; e -> [e] } }---- Where clauses are optional.-WhereClause :: { WhereClause }-WhereClause- : {- empty -} { NoWhere }- | 'where' Declarations { AnyWhere $2 }- | 'module' Id 'where' Declarations { SomeWhere $2 $4 }---{--------------------------------------------------------------------------- Different kinds of declarations- --------------------------------------------------------------------------}---- Top-level definitions.-Declaration :: { [Declaration] }-Declaration- : RelTypeSig { [$1] } -- Possibly dotted type signature.- | Fields { $1 }- | FunClause { [$1] }- | Data { [$1] }- | DataSig { [$1] } -- lone data type signature in mutual block- | Record { [$1] }- | RecordSig { [$1] } -- lone record signature in mutual block- | Infix { [$1] }- | Mutual { [$1] }- | Abstract { [$1] }- | Private { [$1] }- | Postulate { [$1] }- | Primitive { [$1] }- | Open { [$1] }- | Import { [$1] }- | ModuleMacro { [$1] }- | Module { [$1] }- | Pragma { [$1] }- | Syntax { [$1] }---{--------------------------------------------------------------------------- Individual declarations- --------------------------------------------------------------------------}---- Type signatures of the form "n1 n2 n3 ... : Type", with at least--- one bound name.-TypeSigs :: { [Declaration] }-TypeSigs : SpaceIds ':' Expr { map (flip (TypeSig Relevant) $3) $1 }---- Some declaration can include relevance information (axioms, functions)-RelTypeSig :: { Declaration }-RelTypeSig- : '.' Id ':' Expr { TypeSig Irrelevant $2 $4 }- | Id ':' Expr { TypeSig Relevant $1 $3 }--RelTypeSigs :: { [Declaration] }-RelTypeSigs : MaybeDottedIds ':' Expr { map (\ (Arg _ rel x) -> TypeSig rel x $3) $1 }---- A variant of TypeSigs where any sub-sequence of names can be marked--- as hidden or irrelevant using braces and dots:--- {n1 .n2} n3 .n4 {n5} .{n6 n7} ... : Type.-ArgTypeSigs :: { [Arg Declaration] }-ArgTypeSigs : ArgIds ':' Expr { map (fmap (flip (TypeSig Relevant) $3)) $1 }---- Function declarations. The left hand side is parsed as an expression to allow--- declarations like 'x::xs ++ ys = e', when '::' has higher precedence than '++'.-FunClause :: { Declaration }-FunClause : LHS RHS WhereClause { FunClause $1 $2 $3 }--RHS :: { RHS }-RHS : '=' Expr { RHS $2 }- | {- empty -} { AbsurdRHS }---- Data declaration. Can be local.-Data :: { Declaration }-Data : 'data' Id TypedUntypedBindings ':' Expr 'where'- Constructors { Data (getRange ($1, $6, $7)) Inductive $2 $3 (Just $5) $7 }- | 'codata' Id TypedUntypedBindings ':' Expr 'where'- Constructors { Data (getRange ($1, $6, $7)) CoInductive $2 $3 (Just $5) $7 }-- -- New cases when we already had a DataSig. Then one can omit the sort.- | 'data' Id TypedUntypedBindings 'where'- Constructors { Data (getRange ($1, $4, $5)) Inductive $2 $3 Nothing $5 }- | 'codata' Id TypedUntypedBindings 'where'- Constructors { Data (getRange ($1, $4, $5)) CoInductive $2 $3 Nothing $5 }---- Data type signature. Found in mutual blocks.-DataSig :: { Declaration }-DataSig : 'data' Id TypedUntypedBindings ':' Expr- { DataSig (fuseRange $1 $5) Inductive $2 $3 $5 }---- Record declarations.-Record :: { Declaration }-Record : 'record' Id TypedUntypedBindings ':' Expr 'where'- RecordDeclarations- { Record (getRange ($1, $6, $7)) $2 (fst $7) $3 (Just $5) (snd $7) }- | 'record' Id TypedUntypedBindings 'where'- RecordDeclarations- { Record (getRange ($1, $4, $5)) $2 (fst $5) $3 Nothing (snd $5) }---- Record type signature. In mutual blocks.-RecordSig :: { Declaration }-RecordSig : 'record' Id TypedUntypedBindings ':' Expr- { RecordSig (fuseRange $1 $5) $2 $3 $5 }---- Declaration of record constructor name.-RecordConstructorName :: { Name }-RecordConstructorName : 'constructor' Id { $2 }---- Fixity declarations.-Infix :: { Declaration }-Infix : 'infix' Int SpaceBIds { Infix (NonAssoc (fuseRange $1 $3) $2) $3 }- | 'infixl' Int SpaceBIds { Infix (LeftAssoc (fuseRange $1 $3) $2) $3 }- | 'infixr' Int SpaceBIds { Infix (RightAssoc (fuseRange $1 $3) $2) $3 }---- Field declarations.-Fields :: { [Declaration] }-Fields : 'field' ArgTypeSignatures- { let toField (Arg h rel (TypeSig _ x t)) = Field x (Arg h rel t) in map toField $2 }---REM { let toField (h, TypeSig x t) = Field h x t in map toField $2 }---- Mutually recursive declarations.-Mutual :: { Declaration }-Mutual : 'mutual' Declarations { Mutual (fuseRange $1 $2) $2 }----- Abstract declarations.-Abstract :: { Declaration }-Abstract : 'abstract' Declarations { Abstract (fuseRange $1 $2) $2 }----- Private can only appear on the top-level (or rather the module level).-Private :: { Declaration }-Private : 'private' Declarations { Private (fuseRange $1 $2) $2 }----- Postulates. Can only contain type signatures. TODO: relax this.-Postulate :: { Declaration }-Postulate : 'postulate' RelTypeSignatures { Postulate (fuseRange $1 $2) $2 }---- Primitives. Can only contain type signatures.-Primitive :: { Declaration }-Primitive : 'primitive' TypeSignatures { Primitive (fuseRange $1 $2) $2 }---- Syntax declaration (To declare eg. mixfix binders)-Syntax :: { Declaration }-Syntax : 'syntax' Id HoleNames '=' SimpleIds {%- case $2 of- Name _ [_] -> case mkNotation $3 $5 of- Left err -> parseError $ "malformed syntax declaration: " ++ err- Right n -> return $ Syntax $2 n- _ -> parseError "syntax declarations are allowed only for simple names (without holes)"-}--SimpleIds :: { [String] }-SimpleIds : SimpleId { [$1] }- | SimpleIds SimpleId {$1 ++ [$2]}--HoleNames :: { [HoleName] }-HoleNames : HoleName { [$1] }- | HoleNames HoleName {$1 ++ [$2]}--HoleName :: { HoleName }-HoleName : SimpleId { ExprHole $1}- | '(' '\\' SimpleId '->' SimpleId ')' { LambdaHole $3 $5 }--- Variable name hole to be implemented later.---- Discard the interval.-SimpleId :: { String }-SimpleId : id { snd $1 }----- Open-Open :: { Declaration }-Open : 'open' ModuleName OpenArgs ImportDirective {- let- { m = $2- ; es = $3- ; dir = $4- ; r = getRange ($1, m, es, dir)- } in- case es of- { [] -> Open r m dir- ; _ -> Private r [ ModuleMacro r (noName $ beginningOf $ getRange $2)- (SectionApp (getRange (m , es)) [] (RawApp (fuseRange m es) (Ident m : es)))- DoOpen dir- ]- }- }- | 'open' ModuleName '{{' '...' DoubleCloseBrace ImportDirective {- let r = getRange ($1, $2, $3, $4) in- Private r [ ModuleMacro r (noName $ beginningOf $ getRange $2)- (RecordModuleIFS r $2) DoOpen $6- ]- }--OpenArgs :: { [Expr] }-OpenArgs : {- empty -} { [] }- | Expr3 OpenArgs { $1 : $2 }--ModuleApplication :: { [TypedBindings] -> Parser ModuleApplication }-ModuleApplication : ModuleName '{{' '...' DoubleCloseBrace { (\ts ->- if null ts then return $ RecordModuleIFS (getRange ($1, $4)) $1- else parseError "No bindings allowed for record module with non-canonical implicits" )- }- | ModuleName OpenArgs {- (\ts -> return $ SectionApp (getRange ($1, $2)) ts (RawApp (fuseRange $1 $2) (Ident $1 : $2)) ) }----- Module instantiation-ModuleMacro :: { Declaration }-ModuleMacro : 'module' Id TypedUntypedBindings '=' ModuleApplication ImportDirective- {% do {ma <- $5 (map addType $3); return $ ModuleMacro (getRange ($1, ma, $6)) $2 ma DontOpen $6 } }- | 'open' 'module' Id TypedUntypedBindings '=' ModuleApplication ImportDirective- {% do {ma <- $6 (map addType $4); return $ ModuleMacro (getRange ($1, ma, $7)) $3 ma DoOpen $7 } }---- Import-Import :: { Declaration }-Import : 'import' ModuleName ImportImportDirective- { Import (getRange ($1,$2,snd $3)) $2 (fst $3) DontOpen (snd $3) }- | 'open' 'import' ModuleName ImportImportDirective- { Import (getRange ($1,$3,snd $4)) $3 (fst $4) DoOpen (snd $4) }---- Module-Module :: { Declaration }-Module : 'module' Id TypedUntypedBindings 'where' Declarations0- { Module (getRange ($1,$4,$5)) (QName $2) (map addType $3) $5 }---- The top-level consist of a bunch of import and open followed by a top-level module.-TopLevel :: { [Declaration] }-TopLevel : TopModule { [$1] }- | Import TopLevel { $1 : $2 }- | Open TopLevel { $1 : $2 }---- The top-level module can have a qualified name.-TopModule :: { Declaration }-TopModule : 'module' ModuleName TypedUntypedBindings 'where' Declarations0- { Module (getRange ($1,$4,$5)) $2 (map addType $3) $5 }--Pragma :: { Declaration }-Pragma : DeclarationPragma { Pragma $1 }--TopLevelPragma :: { Pragma }-TopLevelPragma- : OptionsPragma { $1 }--DeclarationPragma :: { Pragma }-DeclarationPragma- : BuiltinPragma { $1 }- | CompiledPragma { $1 }- | CompiledDataPragma { $1 }- | CompiledTypePragma { $1 }- | CompiledEpicPragma { $1 }- | CompiledJSPragma { $1 }- | StaticPragma { $1 }- | ImportPragma { $1 }- | ImpossiblePragma { $1 }- | RecordEtaPragma { $1 }--OptionsPragma :: { Pragma }-OptionsPragma : '{-#' 'OPTIONS' PragmaStrings '#-}' { OptionsPragma (fuseRange $1 $4) $3 }--BuiltinPragma :: { Pragma }-BuiltinPragma- : '{-#' 'BUILTIN' string PragmaName '#-}'- { BuiltinPragma (fuseRange $1 $5) (snd $3) (Ident $4) }--CompiledPragma :: { Pragma }-CompiledPragma- : '{-#' 'COMPILED' PragmaName PragmaStrings '#-}'- { CompiledPragma (fuseRange $1 $5) $3 (unwords $4) }--CompiledTypePragma :: { Pragma }-CompiledTypePragma- : '{-#' 'COMPILED_TYPE' PragmaName PragmaStrings '#-}'- { CompiledTypePragma (fuseRange $1 $5) $3 (unwords $4) }--CompiledDataPragma :: { Pragma }-CompiledDataPragma- : '{-#' 'COMPILED_DATA' PragmaName string PragmaStrings '#-}'- { CompiledDataPragma (fuseRange $1 $6) $3 (snd $4) $5 }--CompiledEpicPragma :: { Pragma }-CompiledEpicPragma- : '{-#' 'COMPILED_EPIC' PragmaName PragmaStrings '#-}'- { CompiledEpicPragma (fuseRange $1 $5) $3 (unwords $4) }--CompiledJSPragma :: { Pragma }-CompiledJSPragma- : '{-#' 'COMPILED_JS' PragmaName PragmaStrings '#-}'- { CompiledJSPragma (fuseRange $1 $5) $3 (unwords $4) }--StaticPragma :: { Pragma }-StaticPragma- : '{-#' 'STATIC' PragmaName '#-}'- { StaticPragma (fuseRange $1 $4) $3 }--RecordEtaPragma :: { Pragma }-RecordEtaPragma- : '{-#' 'ETA' PragmaName '#-}'- { EtaPragma (fuseRange $1 $4) $3 }--ImportPragma :: { Pragma }-ImportPragma- : '{-#' 'IMPORT' string '#-}'- {% let s = snd $3 in- if validHaskellModuleName s- then return $ ImportPragma (fuseRange $1 $4) s- else parseError $ "Malformed module name: " ++ s ++ "."- }--ImpossiblePragma :: { Pragma }- : '{-#' 'IMPOSSIBLE' '#-}' { ImpossiblePragma (fuseRange $1 $3) }--{--------------------------------------------------------------------------- Sequences of declarations- --------------------------------------------------------------------------}---- Non-empty list of type signatures, with several identifiers allowed--- for every signature.-TypeSignatures :: { [TypeSignature] }-TypeSignatures- : vopen TypeSignatures1 close { reverse $2 }---- Inside the layout block.-TypeSignatures1 :: { [TypeSignature] }-TypeSignatures1- : TypeSignatures1 semi TypeSigs { reverse $3 ++ $1 }- | TypeSigs { reverse $1 }---- A variant of TypeSignatures which allows the irrelevance annotation (dot).-RelTypeSignatures :: { [TypeSignature] }-RelTypeSignatures- : vopen RelTypeSignatures1 close { reverse $2 }---- Inside the layout block.-RelTypeSignatures1 :: { [TypeSignature] }-RelTypeSignatures1- : RelTypeSignatures1 semi RelTypeSigs { reverse $3 ++ $1 }- | RelTypeSigs { reverse $1 }---- A variant of TypeSignatures which uses ArgTypeSigs instead of--- TypeSigs.-ArgTypeSignatures :: { [Arg TypeSignature] }-ArgTypeSignatures- : vopen ArgTypeSignatures1 close { reverse $2 }---- Inside the layout block.-ArgTypeSignatures1 :: { [Arg TypeSignature] }-ArgTypeSignatures1- : ArgTypeSignatures1 semi ArgTypeSigs { reverse $3 ++ $1 }- | ArgTypeSigs { reverse $1 }---- Constructors are type signatures. But constructor lists can be empty.-Constructors :: { [Constructor] }-Constructors- : vopen close { [] }- | TypeSignatures { $1 }---- Record declarations, including an optional record constructor name.-RecordDeclarations :: { (Maybe Name, [Declaration]) }-RecordDeclarations- : vopen close { (Nothing, []) }- | vopen RecordConstructorName close { (Just $2, []) }- | vopen RecordConstructorName semi Declarations1 close { (Just $2, reverse $4) }- | vopen Declarations1 close { (Nothing, reverse $2) }---- Arbitrary declarations-Declarations :: { [Declaration] }-Declarations- : vopen Declarations1 close { reverse $2 }---- Arbitrary declarations-Declarations0 :: { [Declaration] }-Declarations0- : vopen close { [] }- | Declarations { $1 }--Declarations1 :: { [Declaration] }-Declarations1- : Declarations1 semi Declaration { reverse $3 ++ $1 }- | Declaration { reverse $1 }---{--{--------------------------------------------------------------------------- Parsers- --------------------------------------------------------------------------}---- | Parse the token stream. Used by the TeX compiler.-tokensParser :: Parser [Token]---- | Parse an expression. Could be used in interactions.-exprParser :: Parser Expr---- | Parse a module.-moduleParser :: Parser Module---{--------------------------------------------------------------------------- Happy stuff- --------------------------------------------------------------------------}---- | Required by Happy.-happyError :: Parser a-happyError = parseError "Parse error"---{--------------------------------------------------------------------------- Utility functions- --------------------------------------------------------------------------}---- | Create a name from a string.--mkName :: (Interval, String) -> Parser Name-mkName (i, s) = do- let xs = parts s- mapM_ isValidId xs- unless (alternating xs) $ fail $ "a name cannot contain two consecutive underscores"- return $ Name (getRange i) xs- where- parts :: String -> [NamePart]- parts "" = []- parts ('_' : s) = Hole : parts s- parts s = Id x : parts s'- where (x, s') = break (== '_') s-- isValidId Hole = return ()- isValidId (Id x) = case parse defaultParseFlags [0] (lexer return) x of- ParseOk _ (TokId _) -> return ()- _ -> fail $ "in the name " ++ s ++ ", the part " ++ x ++ " is not valid"-- -- we know that there are no two Ids in a row- alternating (Hole : Hole : _) = False- alternating (_ : xs) = alternating xs- alternating [] = True---- | Create a qualified name from a list of strings-mkQName :: [(Interval, String)] -> Parser QName-mkQName ss = do- xs <- mapM mkName ss- return $ foldr Qual (QName $ last xs) (init xs)---- | Match a particular name.-isName :: String -> (Interval, String) -> Parser ()-isName s (_,s')- | s == s' = return ()- | otherwise = fail $ "expected " ++ s ++ ", found " ++ s'---- | Build a forall pi (forall x y z -> ...)-forallPi :: [LamBinding] -> Expr -> Expr-forallPi bs e = Pi (map addType bs) e---- | Converts lambda bindings to typed bindings.-addType :: LamBinding -> TypedBindings-addType (DomainFull b) = b-addType (DomainFree h rel x) = TypedBindings r $ Arg h rel $ TBind r [x] $ Underscore r Nothing- where r = getRange x---- | Check that an import directive doesn't contain repeated names-verifyImportDirective :: ImportDirective -> Parser ImportDirective-verifyImportDirective i =- case filter ((>1) . length)- $ group- $ sort xs- of- [] -> return i- yss -> let Just pos = rStart $ getRange $ head $ concat yss in- parseErrorAt pos $- "repeated name" ++ s ++ " in import directive: " ++- concat (intersperse ", " $ map (show . head) yss)- where- s = case yss of- [_] -> ""- _ -> "s"- where- xs = names (usingOrHiding i) ++ map renFrom (renaming i)- names (Using xs) = xs- names (Hiding xs) = xs---- | Breaks up a string into substrings. Returns every maximal--- subsequence of zero or more characters distinct from @'.'@.------ > splitOnDots "" == [""]--- > splitOnDots "foo.bar" == ["foo", "bar"]--- > splitOnDots ".foo.bar" == ["", "foo", "bar"]--- > splitOnDots "foo.bar." == ["foo", "bar", ""]--- > splitOnDots "foo..bar" == ["foo", "", "bar"]-splitOnDots :: String -> [String]-splitOnDots "" = [""]-splitOnDots ('.' : s) = [] : splitOnDots s-splitOnDots (c : s) = case splitOnDots s of- p : ps -> (c : p) : ps--prop_splitOnDots = and- [ splitOnDots "" == [""]- , splitOnDots "foo.bar" == ["foo", "bar"]- , splitOnDots ".foo.bar" == ["", "foo", "bar"]- , splitOnDots "foo.bar." == ["foo", "bar", ""]- , splitOnDots "foo..bar" == ["foo", "", "bar"]- ]---- | Returns 'True' iff the name is a valid Haskell (hierarchical)--- module name.-validHaskellModuleName :: String -> Bool-validHaskellModuleName = all ok . splitOnDots- where- -- Checks if a dot-less module name is well-formed.- ok :: String -> Bool- ok [] = False- ok (c : s) =- isUpper c &&- all (\c -> isLower c || c == '_' ||- isUpper c ||- generalCategory c == DecimalNumber ||- c == '\'')- s--{--------------------------------------------------------------------------- Patterns- --------------------------------------------------------------------------}---- | Turn an expression into a left hand side.-exprToLHS :: Expr -> Parser ([Expr] -> [Expr] -> LHS)-exprToLHS e = case e of- WithApp r e es -> LHS <$> exprToPattern e <*> mapM exprToPattern es- _ -> LHS <$> exprToPattern e <*> return []---- | Turn an expression into a pattern. Fails if the expression is not a--- valid pattern.-exprToPattern :: Expr -> Parser Pattern-exprToPattern e =- case e of- Ident x -> return $ IdentP x- App _ e1 e2 -> AppP <$> exprToPattern e1- <*> T.mapM (T.mapM exprToPattern) e2- Paren r e -> ParenP r- <$> exprToPattern e- Underscore r _ -> return $ WildP r- Absurd r -> return $ AbsurdP r- As r x e -> AsP r x <$> exprToPattern e- Dot r (HiddenArg _ e) -> return $ HiddenP r $ fmap (DotP r) e- Dot r e -> return $ DotP r e- Lit l -> return $ LitP l- HiddenArg r e -> HiddenP r <$> T.mapM exprToPattern e- InstanceArg r e -> InstanceP r <$> T.mapM exprToPattern e- RawApp r es -> RawAppP r <$> mapM exprToPattern es- OpApp r x es -> OpAppP r x <$> mapM opAppExprToPattern es- _ ->- let Just pos = rStart $ getRange e in- parseErrorAt pos $ "Not a valid pattern: " ++ show e--opAppExprToPattern :: OpApp Expr -> Parser Pattern-opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "syntax binding lambda cannot appear in a pattern"-opAppExprToPattern (Ordinary e) = exprToPattern e--parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug."--{--------------------------------------------------------------------------- Tests- --------------------------------------------------------------------------}---- | Test suite.-tests :: IO Bool-tests = runTests "Agda.Syntax.Parser.Parser"- [ quickCheck' prop_splitOnDots- ]+#if __GLASGOW_HASKELL__ > 800+{-# OPTIONS_GHC -Wno-error=missing-signatures #-}+#endif+{-# LANGUAGE PatternGuards #-}++{-| The parser is generated by Happy (<http://www.haskell.org/happy>).+ -+ - Ideally, ranges should be as precise as possible, to get messages that+ - emphasize precisely the faulting term(s) upon error.+ -+ - However, interactive highlighting is only applied at the end of each+ - mutual block, keywords are only highlighted once (see+ - `TypeChecking.Rules.Decl'). So if the ranges of two declarations+ - interleave, one must ensure that keyword ranges are not included in+ - the intersection. (Otherwise they are uncolored by the interactive+ - highlighting.)+ -+ -}+module Agda.Syntax.Parser.Parser (+ moduleParser+ , moduleNameParser+ , exprParser+ , exprWhereParser+ , tokensParser+ , holeContentParser+ ) where++import Prelude hiding ( null )+import qualified Prelude++import Control.Applicative ( (<|>) )+import Control.Monad+import Control.Monad.State++import Data.Bifunctor (first, second)+import Data.Char+import Data.DList (DList)+import qualified Data.DList as DL+import qualified Data.List as List+import Data.Maybe+import Data.Semigroup ((<>), sconcat)+import qualified Data.Traversable as T++import Agda.Syntax.Position hiding (tests)+import Agda.Syntax.Parser.Helpers+import Agda.Syntax.Parser.Monad+import Agda.Syntax.Parser.Lexer+import Agda.Syntax.Parser.Tokens+import Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Attribute+import Agda.Syntax.Concrete.Pattern+import Agda.Syntax.Common+import Agda.Syntax.Notation+import Agda.Syntax.Literal++import Agda.TypeChecking.Positivity.Occurrence hiding (tests)++import Agda.Utils.Either hiding (tests)+import Agda.Utils.Functor+import Agda.Utils.Hash+import Agda.Utils.List ( spanJust, chopWhen )+import Agda.Utils.List1 ( List1, pattern (:|), (<|) )+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty hiding ((<>))+import Agda.Utils.Singleton+import qualified Agda.Utils.Maybe.Strict as Strict+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2++import Agda.Utils.Impossible++}++%name tokensParser Tokens+%name exprParser Expr+%name exprWhereParser ExprWhere+%name moduleParser File+%name moduleNameParser ModuleName+%name funclauseParser FunClause+%name holeContentParser HoleContent++%tokentype { Token }+%monad { Parser }+%lexer { lexer } { TokEOF{} }++%expect 8+-- * shift/reduce for \ x y z -> foo = bar+-- shifting means it'll parse as \ x y z -> (foo = bar) rather than+-- (\ x y z -> foo) = bar+--+-- * Telescope let and do-notation let.+-- Expr2 -> 'let' Declarations . LetBody+-- TypedBinding -> '(' 'let' Declarations . ')'+-- ')' shift, and enter state 486+-- (reduce using rule 189)+-- A do-block cannot end in a 'let' so committing to TypedBinding with a+-- shift is the right thing to do here.+--+-- * Named implicits in TypedBinding {x = y}. When encountering the '=' shift+-- treats this as a named implicit and reducing would fail later.++-- This is a trick to get rid of shift/reduce conflicts arising because we want+-- to parse things like "m >>= \x -> k x". See the Expr rule for more+-- information.+%nonassoc LOWEST+%nonassoc '->'++%token+ 'abstract' { TokKeyword KwAbstract $$ }+ 'codata' { TokKeyword KwCoData $$ }+ 'coinductive' { TokKeyword KwCoInductive $$ }+ 'constructor' { TokKeyword KwConstructor $$ }+ 'data' { TokKeyword KwData $$ }+ 'eta-equality' { TokKeyword KwEta $$ }+ 'field' { TokKeyword KwField $$ }+ 'forall' { TokKeyword KwForall $$ }+ 'variable' { TokKeyword KwVariable $$ }+ 'hiding' { TokKeyword KwHiding $$ }+ 'import' { TokKeyword KwImport $$ }+ 'in' { TokKeyword KwIn $$ }+ 'inductive' { TokKeyword KwInductive $$ }+ 'infix' { TokKeyword KwInfix $$ }+ 'infixl' { TokKeyword KwInfixL $$ }+ 'infixr' { TokKeyword KwInfixR $$ }+ 'instance' { TokKeyword KwInstance $$ }+ 'overlap' { TokKeyword KwOverlap $$ }+ 'let' { TokKeyword KwLet $$ }+ 'macro' { TokKeyword KwMacro $$ }+ 'module' { TokKeyword KwModule $$ }+ 'interleaved' { TokKeyword KwInterleaved $$ }+ 'mutual' { TokKeyword KwMutual $$ }+ 'no-eta-equality' { TokKeyword KwNoEta $$ }+ 'open' { TokKeyword KwOpen $$ }+ 'pattern' { TokKeyword KwPatternSyn $$ }+ 'postulate' { TokKeyword KwPostulate $$ }+ 'primitive' { TokKeyword KwPrimitive $$ }+ 'private' { TokKeyword KwPrivate $$ }+ 'public' { TokKeyword KwPublic $$ }+ 'quote' { TokKeyword KwQuote $$ }+ 'quoteTerm' { TokKeyword KwQuoteTerm $$ }+ 'record' { TokKeyword KwRecord $$ }+ 'renaming' { TokKeyword KwRenaming $$ }+ 'rewrite' { TokKeyword KwRewrite $$ }+ 'syntax' { TokKeyword KwSyntax $$ }+ 'tactic' { TokKeyword KwTactic $$ }+ 'to' { TokKeyword KwTo $$ }+ 'unquote' { TokKeyword KwUnquote $$ }+ 'unquoteDecl' { TokKeyword KwUnquoteDecl $$ }+ 'unquoteDef' { TokKeyword KwUnquoteDef $$ }+ 'using' { TokKeyword KwUsing $$ }+ 'where' { TokKeyword KwWhere $$ }+ 'do' { TokKeyword KwDo $$ }+ 'with' { TokKeyword KwWith $$ }+ 'opaque' { TokKeyword KwOpaque $$ }+ 'unfolding' { TokKeyword KwUnfolding $$ }++ 'BUILTIN' { TokKeyword KwBUILTIN $$ }+ 'CATCHALL' { TokKeyword KwCATCHALL $$ }+ 'DISPLAY' { TokKeyword KwDISPLAY $$ }+ 'ETA' { TokKeyword KwETA $$ }+ 'ETA_EQUALITY' { TokKeyword KwETA_EQUALITY $$ }+ 'FOREIGN' { TokKeyword KwFOREIGN $$ }+ 'COMPILE' { TokKeyword KwCOMPILE $$ }+ 'IMPOSSIBLE' { TokKeyword KwIMPOSSIBLE $$ }+ 'INCOHERENT' { TokKeyword KwINCOHERENT $$ }+ 'INJECTIVE' { TokKeyword KwINJECTIVE $$ }+ 'INJECTIVE_FOR_INFERENCE' { TokKeyword KwINJECTIVE_FOR_INFERENCE $$ }+ 'INLINE' { TokKeyword KwINLINE $$ }+ 'NOINLINE' { TokKeyword KwNOINLINE $$ }+ 'MEASURE' { TokKeyword KwMEASURE $$ }+ 'NO_TERMINATION_CHECK' { TokKeyword KwNO_TERMINATION_CHECK $$ }+ 'NO_POSITIVITY_CHECK' { TokKeyword KwNO_POSITIVITY_CHECK $$ }+ 'NO_UNIVERSE_CHECK' { TokKeyword KwNO_UNIVERSE_CHECK $$ }+ 'NON_TERMINATING' { TokKeyword KwNON_TERMINATING $$ }+ 'NON_COVERING' { TokKeyword KwNON_COVERING $$ }+ 'NOT_PROJECTION_LIKE' { TokKeyword KwNOT_PROJECTION_LIKE $$ }+ 'OPTIONS' { TokKeyword KwOPTIONS $$ }+ 'POLARITY' { TokKeyword KwPOLARITY $$ }+ 'OVERLAPPABLE' { TokKeyword KwOVERLAPPABLE $$ }+ 'OVERLAPPING' { TokKeyword KwOVERLAPPING $$ }+ 'OVERLAPS' { TokKeyword KwOVERLAPS $$ }+ 'WARNING_ON_USAGE' { TokKeyword KwWARNING_ON_USAGE $$ }+ 'WARNING_ON_IMPORT' { TokKeyword KwWARNING_ON_IMPORT $$ }+ 'REWRITE' { TokKeyword KwREWRITE $$ }+ 'STATIC' { TokKeyword KwSTATIC $$ }+ 'TERMINATING' { TokKeyword KwTERMINATING $$ }++ tex { TokTeX $$ }+ comment { TokComment $$ }++ '...' { TokSymbol SymEllipsis $$ }+ '..' { TokSymbol SymDotDot $$ }+ '.' { TokSymbol SymDot $$ }+ ';' { TokSymbol SymSemi $$ }+ ':' { TokSymbol SymColon $$ }+ '=' { TokSymbol SymEqual $$ }+ '_' { TokSymbol SymUnderscore $$ }+ '?' { TokSymbol SymQuestionMark $$ }+ '->' { TokSymbol SymArrow $$ }+ '\\' { TokSymbol SymLambda $$ }+ '@' { TokSymbol SymAs $$ }+ '|' { TokSymbol SymBar $$ }+ '(' { TokSymbol SymOpenParen $$ }+ ')' { TokSymbol SymCloseParen $$ }++ -- Handling of Unicode brackets: the actual terminals produced by+ -- the lexer get the "i_" prefix, for internal.+ --+ -- These should not be used anywhere other than the Token+ -- production!!! Other non-terminals that need these delimiters+ -- should use the unprefixed versions, e.g. "{{". Those will+ -- automatically handle generating the MismatchedBrackets warnings+ -- when appropriate.+ --+ -- Note that the "}}" nonterminal also handles the special case for+ -- closing a "{{" with a pair of consecutive '}' '}'.+ "i_(|" { $$@(TokSymbol SymOpenIdiomBracket{} _) }+ "i_|)" { $$@(TokSymbol SymCloseIdiomBracket{} _) }+ "i_{{" { $$@(TokSymbol SymDoubleOpenBrace{} _) }+ "i_}}" { $$@(TokSymbol SymDoubleCloseBrace{} _) }++ "(|)" { TokSymbol SymEmptyIdiomBracket $$ }+ '{' { TokSymbol SymOpenBrace $$ }+ '}' { TokSymbol SymCloseBrace $$ }+-- ':{' { TokSymbol SymColonBrace $$ }+ vopen { TokSymbol SymOpenVirtualBrace $$ }+ vclose { TokSymbol SymCloseVirtualBrace $$ }+ vsemi { TokSymbol SymVirtualSemi $$ }+ '{-#' { TokSymbol SymOpenPragma $$ }+ '#-}' { TokSymbol SymClosePragma $$ }++ id { TokId $$ }+ q_id { TokQId $$ }+ q_do { TokQual_ $$@(QualifiedToken QualDo _ _) }++ q_idiom { TokQual_ $$@(QualifiedToken QualOpenIdiom{} _ _) }+ q_idiomE { TokQual_ $$@(QualifiedToken QualEmptyIdiom _ _) }++ string { TokString $$ }+ literal { TokLiteral $$ }++%%++{--------------------------------------------------------------------------+ Parsing the token stream. Used by the TeX compiler.+ --------------------------------------------------------------------------}++-- Parse a list of tokens.+Tokens :: { [Token] }+Tokens : TokensR { reverse $1 }++-- Happy is much better at parsing left recursive grammars (constant+-- stack size vs. linear stack size for right recursive).+TokensR :: { [Token] }+TokensR : TokensR Token { $2 : $1 }+ | { [] }++-- Parse single token.+Token :: { Token }+Token+ -- Please keep these keywords in alphabetical order!+ : 'abstract' { TokKeyword KwAbstract $1 }+ | 'codata' { TokKeyword KwCoData $1 }+ | 'coinductive' { TokKeyword KwCoInductive $1 }+ | 'constructor' { TokKeyword KwConstructor $1 }+ | 'data' { TokKeyword KwData $1 }+ | 'do' { TokKeyword KwDo $1 }+ | 'eta-equality' { TokKeyword KwEta $1 }+ | 'field' { TokKeyword KwField $1 }+ | 'forall' { TokKeyword KwForall $1 }+ | 'hiding' { TokKeyword KwHiding $1 }+ | 'import' { TokKeyword KwImport $1 }+ | 'in' { TokKeyword KwIn $1 }+ | 'inductive' { TokKeyword KwInductive $1 }+ | 'infix' { TokKeyword KwInfix $1 }+ | 'infixl' { TokKeyword KwInfixL $1 }+ | 'infixr' { TokKeyword KwInfixR $1 }+ | 'instance' { TokKeyword KwInstance $1 }+ | 'let' { TokKeyword KwLet $1 }+ | 'macro' { TokKeyword KwMacro $1 }+ | 'module' { TokKeyword KwModule $1 }+ | 'interleaved' { TokKeyword KwInterleaved $1 }+ | 'mutual' { TokKeyword KwMutual $1 }+ | 'no-eta-equality' { TokKeyword KwNoEta $1 }+ | 'opaque' { TokKeyword KwOpaque $1 }+ | 'open' { TokKeyword KwOpen $1 }+ | 'overlap' { TokKeyword KwOverlap $1 }+ | 'pattern' { TokKeyword KwPatternSyn $1 }+ | 'postulate' { TokKeyword KwPostulate $1 }+ | 'primitive' { TokKeyword KwPrimitive $1 }+ | 'private' { TokKeyword KwPrivate $1 }+ | 'public' { TokKeyword KwPublic $1 }+ | 'quote' { TokKeyword KwQuote $1 }+ | 'quoteTerm' { TokKeyword KwQuoteTerm $1 }+ | 'record' { TokKeyword KwRecord $1 }+ | 'renaming' { TokKeyword KwRenaming $1 }+ | 'rewrite' { TokKeyword KwRewrite $1 }+ | 'syntax' { TokKeyword KwSyntax $1 }+ | 'tactic' { TokKeyword KwTactic $1 }+ | 'to' { TokKeyword KwTo $1 }+ | 'unfolding' { TokKeyword KwUnfolding $1 }+ | 'unquote' { TokKeyword KwUnquote $1 }+ | 'unquoteDecl' { TokKeyword KwUnquoteDecl $1 }+ | 'unquoteDef' { TokKeyword KwUnquoteDef $1 }+ | 'using' { TokKeyword KwUsing $1 }+ | 'variable' { TokKeyword KwVariable $1 }+ | 'where' { TokKeyword KwWhere $1 }+ | 'with' { TokKeyword KwWith $1 }++ -- Please keep these pragmas in alphabetical order!+ | 'BUILTIN' { TokKeyword KwBUILTIN $1 }+ | 'CATCHALL' { TokKeyword KwCATCHALL $1 }+ | 'COMPILE' { TokKeyword KwCOMPILE $1 }+ | 'DISPLAY' { TokKeyword KwDISPLAY $1 }+ | 'ETA' { TokKeyword KwETA $1 }+ | 'ETA_EQUALITY' { TokKeyword KwETA_EQUALITY $1 }+ | 'FOREIGN' { TokKeyword KwFOREIGN $1 }+ | 'IMPOSSIBLE' { TokKeyword KwIMPOSSIBLE $1 }+ | 'INCOHERENT' { TokKeyword KwINCOHERENT $1 }+ | 'INJECTIVE' { TokKeyword KwINJECTIVE $1 }+ | 'INJECTIVE_FOR_INFERENCE' { TokKeyword KwINJECTIVE_FOR_INFERENCE $1 }+ | 'INLINE' { TokKeyword KwINLINE $1 }+ | 'MEASURE' { TokKeyword KwMEASURE $1 }+ | 'NOINLINE' { TokKeyword KwNOINLINE $1 }+ | 'NO_POSITIVITY_CHECK' { TokKeyword KwNO_POSITIVITY_CHECK $1 }+ | 'NO_TERMINATION_CHECK' { TokKeyword KwNO_TERMINATION_CHECK $1 }+ | 'NO_UNIVERSE_CHECK' { TokKeyword KwNO_UNIVERSE_CHECK $1 }+ | 'NON_TERMINATING' { TokKeyword KwNON_TERMINATING $1 }+ | 'NON_COVERING' { TokKeyword KwNON_COVERING $1 }+ | 'NOT_PROJECTION_LIKE' { TokKeyword KwNOT_PROJECTION_LIKE $1 }+ | 'OPTIONS' { TokKeyword KwOPTIONS $1 }+ | 'OVERLAPPABLE' { TokKeyword KwOVERLAPPABLE $1 }+ | 'OVERLAPPING' { TokKeyword KwOVERLAPPING $1 }+ | 'OVERLAPS' { TokKeyword KwOVERLAPS $1 }+ | 'POLARITY' { TokKeyword KwPOLARITY $1 }+ | 'REWRITE' { TokKeyword KwREWRITE $1 }+ | 'STATIC' { TokKeyword KwSTATIC $1 }+ | 'TERMINATING' { TokKeyword KwTERMINATING $1 }+ | 'WARNING_ON_IMPORT' { TokKeyword KwWARNING_ON_IMPORT $1 }+ | 'WARNING_ON_USAGE' { TokKeyword KwWARNING_ON_USAGE $1 }++ | tex { TokTeX $1 }+ | comment { TokComment $1 }++ | '...' { TokSymbol SymEllipsis $1 }+ | '..' { TokSymbol SymDotDot $1 }+ | '.' { TokSymbol SymDot $1 }+ | ';' { TokSymbol SymSemi $1 }+ | ':' { TokSymbol SymColon $1 }+ | '=' { TokSymbol SymEqual $1 }+ | '_' { TokSymbol SymUnderscore $1 }+ | '?' { TokSymbol SymQuestionMark $1 }+ | '->' { TokSymbol SymArrow $1 }+ | '\\' { TokSymbol SymLambda $1 }+ | '@' { TokSymbol SymAs $1 }+ | '|' { TokSymbol SymBar $1 }+ | '(' { TokSymbol SymOpenParen $1 }+ | ')' { TokSymbol SymCloseParen $1 }+ | "i_(|" { $1 }+ | "i_|)" { $1 }+ | "i_{{" { $1 }+ | "i_}}" { $1 }+ | "(|)" { TokSymbol SymEmptyIdiomBracket $1 }+ | '{' { TokSymbol SymOpenBrace $1 }+ | '}' { TokSymbol SymCloseBrace $1 }+ | vopen { TokSymbol SymOpenVirtualBrace $1 }+ | vclose { TokSymbol SymCloseVirtualBrace $1 }+ | vsemi { TokSymbol SymVirtualSemi $1 }+ | '{-#' { TokSymbol SymOpenPragma $1 }+ | '#-}' { TokSymbol SymClosePragma $1 }++ | id { TokId $1 }+ | q_id { TokQId $1 }+ | q_do { TokQual_ $1 }+ | q_idiom { TokQual_ $1 }+ | q_idiomE { TokQual_ $1 }+ | string { TokString $1 }++ | literal { TokLiteral $1 }++{--------------------------------------------------------------------------+ Top level+ --------------------------------------------------------------------------}++File :: { Module }+File : vopen TopDeclarations maybe_vclose { figureOutTopLevelModule $2 }++maybe_vclose :: { () }+maybe_vclose : {- empty -} { () }+ | vclose { () }++{--------------------------------------------------------------------------+ Meta rules+ --------------------------------------------------------------------------}++{- A layout block might have to be closed by a parse error. Example:+ let x = e in e'+ Here the 'let' starts a layout block which should end before the 'in'. The+ problem is that the lexer doesn't know this, so there is no virtual close+ brace. However when the parser sees the 'in' there will be a parse error.+ This is our cue to close the layout block.+-}+close :: { () }+close : vclose { () }+ | error {% popBlock }+++-- You can use concrete semi colons in a layout block started with a virtual+-- brace, so we don't have to distinguish between the two semi colons. You can't+-- use a virtual semi colon in a block started by a concrete brace, but this is+-- simply because the lexer will not generate virtual semis in this case.+semi :: { Interval }+semi : ';' { $1 }+ | vsemi { $1 }+++-- Enter the 'imp_dir' lex state, where we can parse the keyword 'to'.+beginImpDir :: { () }+beginImpDir : {- empty -} {% pushLexState imp_dir }++{--------------------------------------------------------------------------+ Helper rules+ --------------------------------------------------------------------------}++-- A float. Used in fixity declarations.+Float :: { Ranged Double }+Float : literal {% forM $1 $ \case+ { LitNat i -> return $ fromInteger i+ ; LitFloat d -> return d+ ; _ -> parseError $ "Expected floating point number"+ }+ }++-- See "Handling of Unicode brackets" above.+"(|" :: { Range } : "i_(|" {% openBracket $1 }+"|)" :: { Range } : "i_|)" {% closeBracket $1 }+"{{" :: { Range } : "i_{{" {% openBracket $1 }+"}}" :: { Range }+ : "i_}}" {% closeBracket $1 }++ -- To support closing nested records without whitespace between the+ -- closing braces, as in+ --+ -- record {a = record{}}+ --+ -- the lexer will always turn "}" into '}' tokens, regardless of how+ -- many there are in a row. When looking for a closing brace, we+ -- handle the Unicode version (lexed as a single token, above), or+ -- *two* of the ASCII closing tokens.+ -- The closeTwoBraces helper makes sure that the closing tokens are+ -- next to eachother in the source file.+ | '}' '}' {% closeTwoBraces $1 $2 }++-- Parse a 'QualifiedToken'-valued terminal into the qualifying module+-- name and the range of the actual keyword/symbol.+Q_(p) :: { (QName, Range) } : p {% unqualifyToken $1 }++{--------------------------------------------------------------------------+ Names+ --------------------------------------------------------------------------}++-- A name is really a sequence of parts, but the lexer just sees it as a+-- string, so we have to do the translation here.+Id :: { Name }+Id : id {% mkName $1 }++-- Space separated list of one or more identifiers.+SpaceIds :: { List1 Name }+SpaceIds+ : Id SpaceIds { $1 <| $2 }+ | Id { singleton $1 }++-- A possibly dotted identifier.+MaybeDottedId :: { Arg Name }+MaybeDottedId+ : '..' Id { defaultShapeIrrelevantArg $1 $2 }+ | '.' Id { defaultIrrelevantArg $1 $2 }+ | Id { defaultArg $1 }++-- Space separated list of one or more possibly dotted identifiers.+MaybeDottedIds :: { List1 (Arg Name) }+MaybeDottedIds+ : MaybeDottedId MaybeDottedIds { $1 <| $2 }+ | MaybeDottedId { singleton $1 }++-- Space separated list of one or more identifiers, some of which may+-- be surrounded by braces or dotted.+ArgIds :: { List1 (Arg Name) }+ArgIds+ : MaybeDottedId ArgIds { $1 <| $2 }+ | MaybeDottedId { singleton $1 }+ | "{{" MaybeDottedIds "}}" ArgIds { fmap makeInstance $2 <> $4 }+ | "{{" MaybeDottedIds "}}" { fmap makeInstance $2 }+ | '{' MaybeDottedIds '}' ArgIds { fmap hide $2 <> $4 }+ | '{' MaybeDottedIds '}' { fmap hide $2 }+ | '.' '{' SpaceIds '}' ArgIds { fmap (hide . defaultIrrelevantArg $1) $3 <> $5 }+ | '.' '{' SpaceIds '}' { fmap (hide . defaultIrrelevantArg $1) $3 }+ | '.' "{{" SpaceIds "}}" ArgIds { fmap (makeInstance . defaultIrrelevantArg $1) $3 <> $5 }+ | '.' "{{" SpaceIds "}}" { fmap (makeInstance . defaultIrrelevantArg $1) $3 }+ | '..' '{' SpaceIds '}' ArgIds { fmap (hide . defaultShapeIrrelevantArg $1) $3 <> $5 }+ | '..' '{' SpaceIds '}' { fmap (hide . defaultShapeIrrelevantArg $1) $3 }+ | '..' "{{" SpaceIds "}}" ArgIds { fmap (makeInstance . defaultShapeIrrelevantArg $1) $3 <> $5 }+ | '..' "{{" SpaceIds "}}" { fmap (makeInstance . defaultShapeIrrelevantArg $1) $3 }++-- Modalities preceding identifiers++ModalArgIds :: { (TacticAttribute, List1 (Arg Name)) }+ModalArgIds : Attributes ArgIds {% (getTacticAttr $1,) `fmap` mapM (applyAttrs $1) $2 }++-- Attributes are parsed as '@' followed by an atomic expression.+-- Unknown attributes cast a warning and are ignored.++Attribute :: { Maybe Attr }+Attribute+ : '@' 'rewrite' {% rewAttribute (getRange ($1,$2)) }+ -- ^ 'rewrite' is a keyword so does not get parsed as an identifier in ExprOrAttr+ | '@' ExprOrAttr {% toAttribute (getRange ($1,$2)) $2 }++-- Parse a reverse list of modalities++Attributes :: { [Attr] }+Attributes : {- empty -} { [] }+ | Attributes Attribute { maybe $1 (: $1) $2 }++Attributes1 :: { [Attr] }+Attributes1 : Attribute { maybeToList $1 }+ | Attributes1 Attribute { maybe $1 (: $1) $2 }++QId :: { QName }+QId : q_id {% mkQName $1 }+ | Id { QName $1 }+++-- A module name is just a qualified name+ModuleName :: { QName }+ModuleName : QId { $1 }+++-- A binding variable. Can be '_'+BId :: { Name }+BId : Id { $1 }+ | '_' { setRange (getRange $1) simpleHole }++{- UNUSED+-- A binding variable. Can be '_'+MaybeDottedBId :: { (Relevance, Name) }+MaybeDottedBId+ : BId { (Relevant empty , $1) }+ | '.' BId { (Irrelevant (OIrrDot $ getRange $1), $2) }+ | '..' BId { (ShapeIrrelevant (OShIrrDotDot $ getRange $1), $2) }+-}+++-- Space separated list of binding identifiers. Used in fixity+-- declarations infixl 100 + -+SpaceBIds :: { List1 Name }+SpaceBIds+ : BId SpaceBIds { $1 <| $2 }+ | BId { singleton $1 }++-- Space-separated list of binding identifiers. Used in dependent+-- function spaces: (x y z : Nat) -> ...+-- (Used to be comma-separated; hence the name)+-- QUESTION: Should this be replaced by SpaceBIds above?+-- Andreas, 2011-04-07 the trick avoids reduce/reduce conflicts+-- when parsing (x y z : A) -> B+-- at point (x y it is not clear whether x y is an application or+-- a variable list. We could be parsing (x y z) -> B+-- with ((x y) z) being a type.+CommaBIds :: { List1 (NamedArg Binder) }+CommaBIds : CommaBIdAndAbsurds {%+ case $1 of+ Left ns -> return ns+ Right _ -> parseError $ "expected sequence of bound identifiers, not absurd pattern"+ }++CommaBIdAndAbsurds :: { Either (List1 (NamedArg Binder)) (List1 Expr) }+CommaBIdAndAbsurds+ : Application {% boundNamesOrAbsurd $1 }+ | QId '=' QId {% (Left . singleton . updateNamedArg mkBinder) `fmap` mkNamedArg (Just $1) (Left $3) }+ | '_' '=' QId {% (Left . singleton . updateNamedArg mkBinder) `fmap` mkNamedArg Nothing (Left $3) }+ | QId '=' '_' {% (Left . singleton . updateNamedArg mkBinder) `fmap` mkNamedArg (Just $1) (Right $ getRange $3) }+ | '_' '=' '_' {% (Left . singleton . updateNamedArg mkBinder) `fmap` mkNamedArg Nothing (Right $ getRange $3) }++-- Parse a sequence of identifiers, including hiding info.+-- Does not include instance arguments.+-- E.g. x {y z} _ {v}+-- To be used in typed bindings, like (x {y z} _ {v} : Nat).+BIdsWithHiding :: { List1 (NamedArg Binder) }+BIdsWithHiding : Application {%+ -- interpret an expression as a name and maybe a pattern+ case mapM exprAsNameOrHiddenNames $1 of+ Nothing -> parseError "Expected sequence of possibly hidden bound identifiers"+ Just good -> forM (sconcat good) $ updateNamedArgA $ \ (n, me) -> do+ p <- traverse exprToPattern me+ pure $ Binder p UserBinderName (mkBoundName_ n)+ }+++-- Space separated list of strings in a pragma.+PragmaStrings :: { [(Interval, String)] }+PragmaStrings+ : {- empty -} { [] }+ | string PragmaStrings { $1 : $2 }+{- Unused+PragmaString :: { String }+PragmaString+ : string { snd $1 }+-}+Strings :: { [(Interval, String)] }+Strings : {- empty -} { [] }+ | string Strings { $1 : $2 }++ForeignCode :: { DList (Interval, String) }+ForeignCode+ : {- empty -} { mempty }+ | string ForeignCode { $1 `DL.cons` $2 }+ | '{-#' ForeignCode '#-}' ForeignCode+ { (($1, "{-#") `DL.cons` $2) <> (($3, "#-}") `DL.cons` $4) }++PragmaName :: { Name }+PragmaName : string {% mkName $1 }++PragmaQName :: { QName }+PragmaQName : string {% pragmaQName $1 } -- Issue 2125. WAS: string {% fmap QName (mkName $1) }++PragmaQNames :: { [QName] }+PragmaQNames : Strings {% mapM pragmaQName $1 }++PragmaQNames1 :: { [QName] }+PragmaQNames1 : PragmaQName PragmaQNames { $1:$2 }++{--------------------------------------------------------------------------+ Expressions (terms and types)+ --------------------------------------------------------------------------}++{- Expressions. You might expect lambdas and lets to appear in the first+ expression category (lowest precedence). The reason they don't is that we+ want to parse things like++ m >>= \x -> k x++ This will leads to a conflict in the following case++ m >>= \x -> k x >>= \y -> k' y++ At the second '>>=' we can either shift or reduce. We solve this problem+ using Happy's precedence directives. The rule 'Expr -> Expr1' (which is the+ rule you shouldn't use to reduce when seeing '>>=') is given LOWEST+ precedence. The terminals '->' and op (which is what you should shift)+ is given higher precedence.+-}++-- Top level: Function types.+Expr :: { Expr }+Expr+ : TeleArrow Expr { Pi $1 $2 }+ | Application3 '->' Expr { Fun (getRange ($1,$2,$3))+ (defaultArg $ rawApp $1)+ $3 }+ | Attributes1 Application3 '->' Expr {% applyAttrsDropTactic $1 (defaultArg $ rawApp $2) <&> \ dom ->+ Fun (getRange ($1,$2,$3,$4)) dom $4 }+ | Expr1 %prec LOWEST { $1 }++-- Level 1: Application+Expr1 :: { Expr }+Expr1+ : UnnamedWithExprs+ {% case $1 of+ { e :| [] -> return e+ ; e :| e1 : es -> return $ WithApp (getRange (e, e1, es)) e (e1 :| es)+ }+ }++WithExprs :: { List1 (Named Name Expr) }+WithExprs+ : Application3 'in' Id '|' WithExprs { named $3 (rawApp $1) <| $5 }+ | Application3 {- empty -} '|' WithExprs { unnamed (rawApp $1) <| $3 }+ | Application3 'in' Id { singleton (named $3 (rawApp $1)) }+ | Application3 {- empty -} { singleton (unnamed (rawApp $1)) }++UnnamedWithExprs :: { List1 Expr }+UnnamedWithExprs+ : Application3 '|' UnnamedWithExprs { (rawApp $1) <| $3 }+ | {- empty -} Application { singleton (rawApp $1) }++Application :: { List1 Expr }+Application+ : Expr2 { singleton $1 }+ | Expr3 Application { $1 <| $2 }++-- Level 2: Lambdas and lets+Expr2 :: { Expr }+Expr2+ : '\\' LamBindings Expr { Lam (getRange ($1,$2,$3)) $2 $3 }+ | ExtendedOrAbsurdLam { $1 }+ | 'forall' ForallBindings Expr { forallPi $2 $3 }+ | 'let' Declarations LetBody { Let (getRange ($1,$2,$3)) $2 $3 }+ | Expr3 { $1 }+ | 'tactic' Application3 { Tactic (getRange ($1, $2)) (rawApp $2) }++ | 'do' vopen DoStmts close { DoBlock (kwRange $1) Nothing $3 }+ | Q_(q_do) vopen DoStmts close { DoBlock (kwRange (snd $1)) (Just (fst $1)) $3 }++LetBody :: { Maybe Expr }+LetBody : 'in' Expr { Just $2 }+ | {- empty -} { Nothing }++ExtendedOrAbsurdLam :: { Expr }+ExtendedOrAbsurdLam+ : '\\' '{' LamClauses '}' {% extLam (getRange ($1, $2, $4)) [] $3 }+ | '\\' Attributes1 '{' LamClauses '}' {% extLam (getRange ($1, $3, $5)) $2 $4 }+ | '\\' 'where' vopen LamWhereClauses close {% extLam (getRange ($1, $2, $3, $5)) [] $4 }+ | '\\' Attributes1 'where' vopen LamWhereClauses close {% extLam (getRange ($1, $3, $4, $6)) $2 $5 }+ | '\\' AbsurdLamBindings {% extOrAbsLam (getRange $1) [] $2 }+ | '\\' Attributes1 AbsurdLamBindings {% extOrAbsLam (getRange $1) $2 $3 }++Application3 :: { List1 Expr }+Application3+ : Expr3 { singleton $1 }+ | Expr3 Application3 { $1 <| $2 }++-- Christian Sattler, 2017-08-04, issue #2671+-- We allow empty lists of expressions for the LHS of extended lambda clauses.+-- I am not sure what Application3 is otherwise used for, so I keep the+-- original type and create this copy solely for extended lambda clauses.+Application3PossiblyEmpty :: { [Expr] }+Application3PossiblyEmpty+ : {- empty -} { [] }+ | Expr3 Application3PossiblyEmpty { $1 : $2 }++-- Level 3: Atoms+Expr3Curly :: { Expr }+Expr3Curly+ : '{' Expr4 '}' {% HiddenArg (getRange ($1,$2,$3)) `fmap` maybeNamed $2 }+ | '{' '}' { let r = fuseRange $1 $2 in HiddenArg r $ unnamed $ Absurd r }+ | "{{" Expr4 "}}" {% InstanceArg (getRange ($1,$2,$3)) `fmap` maybeNamed $2 }+ | "{{" "}}" { let r = fuseRange $1 $2 in InstanceArg r $ unnamed $ Absurd r }++Expr3NoCurly :: { Expr }+Expr3NoCurly+ : '?' { QuestionMark (getRange $1) Nothing }+ | '_' { Underscore (getRange $1) Nothing }+ | 'quote' { Quote (getRange $1) }+ | 'quoteTerm' { QuoteTerm (getRange $1) }+ | 'unquote' { Unquote (getRange $1) }++ | IdiomBrackets { $1 }++ | '(' ')' { Absurd (fuseRange $1 $2) }+ | Id '@' Expr3 { As (getRange ($1,$2,$3)) $1 $3 }+ | '.' Expr3 { Dot (kwRange $1) $2 }+ | '..' Expr3 { DoubleDot (kwRange $1) $2 }++ | 'record' '{' RecordAssignments '}'+ { Rec (kwRange $1) (getRange ($1,$2,$3,$4)) $3 }+ | 'record' Expr3NoCurly '{' FieldAssignments '}'+ { RecUpdate (kwRange $1) (getRange ($1,$2,$3,$4,$5)) $2 $4 }++ | '...' { Ellipsis (getRange $1) }+ | ExprOrAttr { $1 }++IdiomBrackets :: { Expr }+ : "(|" UnnamedWithExprs "|)" { IdiomBrackets (getRange ($1,$2,$3)) Nothing (List1.toList $2) }+ | "(|)" { IdiomBrackets (getRange $1) Nothing [] }++ | Q_(q_idiom) UnnamedWithExprs "|)"+ { IdiomBrackets (getRange (snd $1,$2,$3)) (Just (fst $1)) (List1.toList $2) }+ | Q_(q_idiomE)+ { IdiomBrackets (getRange $1) (Just (fst $1)) [] }++-- Level 4: Maybe named, or cubical faces+Expr4 :: { Expr }+Expr4 : Expr1 '=' Expr { Equal (getRange ($1, $2, $3)) $1 $3 }+ | Expr { $1 }++ExprOrAttr :: { Expr }+ExprOrAttr+ : QId { Ident $1 }+ | literal { Lit (getRange $1) (rangedThing $1) }+ | '(' Expr4 ')' { Paren (getRange ($1,$2,$3)) $2 }+ -- ^ this is needed for cubical stuff++Expr3 :: { Expr }+Expr3+ : Expr3Curly { $1 }+ | Expr3NoCurly { $1 }++RecordAssignments :: { RecordAssignments }+RecordAssignments+ : {- empty -} { [] }+ | RecordAssignments1 { List1.toList $1 }++RecordAssignments1 :: { List1 RecordAssignment }+RecordAssignments1+ : RecordAssignment { singleton $1 }+ | RecordAssignment ';' RecordAssignments1 { $1 <| $3 }++RecordAssignment :: { RecordAssignment }+RecordAssignment+ : FieldAssignment { Left $1 }+ | ModuleAssignment { Right $1 }++ModuleAssignment :: { ModuleAssignment }+ModuleAssignment+ : ModuleName OpenArgs ImportDirective { ModuleAssignment $1 $2 $3 }++FieldAssignments :: { [FieldAssignment] }+FieldAssignments+ : {- empty -} { [] }+ | FieldAssignments1 { List1.toList $1 }++FieldAssignments1 :: { List1 FieldAssignment }+FieldAssignments1+ : FieldAssignment { singleton $1 }+ | FieldAssignment ';' FieldAssignments1 { $1 <| $3 }++FieldAssignment :: { FieldAssignment }+FieldAssignment+ : Id '=' Expr { FieldAssignment $1 $3 }++{--------------------------------------------------------------------------+ Bindings+ --------------------------------------------------------------------------}++-- "Delta ->" to avoid conflict between Delta -> Gamma and Delta -> A.+TeleArrow :: { Telescope1 }+TeleArrow : Telescope1 '->' { $1 }++Telescope1 :: { Telescope1 }+Telescope1 : TypedBindings { $1 }++TypedBindings :: { List1 TypedBinding }+TypedBindings+ : TypedBinding TypedBindings { $1 <| $2 }+ | TypedBinding { singleton $1 }+++-- A typed binding is either (x1 .. xn : A) or {y1 .. ym : B}+-- Andreas, 2011-04-07: or .(x1 .. xn : A) or .{y1 .. ym : B}+-- Andreas, 2011-04-27: or ..(x1 .. xn : A) or ..{y1 .. ym : B}+TypedBinding :: { TypedBinding }+TypedBinding+ : '(' Open ')' { TLet (getRange ($1,$3)) (singleton $2) }+ | '(' 'let' Declarations ')' { TLet (getRange ($1,$4)) $3 }++-- relevant+ | '(' TBindWithHiding ')' { setRange (getRange ($1,$2,$3)) $ $2 }+ | '{' TBind '}' { setRange (getRange ($1,$2,$3)) $ hide $2 }+ | "{{" TBind "}}" { setRange (getRange ($1,$2,$3)) $ makeInstance $2 }++-- irrelevant+ | '.' '(' TBindWithHiding ')' { setRange (getRange ($2,$3,$4)) $ makeIrrelevant $1 $3 }+ | '.' '{' TBind '}' { setRange (getRange ($2,$3,$4)) $ hide $ makeIrrelevant $1 $3 }+ | '.' "{{" TBind "}}" { setRange (getRange ($2,$3,$4)) $ makeInstance $ makeIrrelevant $1 $3 }++-- shape-irrelevant+ | '..' '(' TBindWithHiding ')' { setRange (getRange ($2,$3,$4)) $ makeShapeIrrelevant $1 $3 }+ | '..' '{' TBind '}' { setRange (getRange ($2,$3,$4)) $ hide $ makeShapeIrrelevant $1 $3 }+ | '..' "{{" TBind "}}" { setRange (getRange ($2,$3,$4)) $ makeInstance $ makeShapeIrrelevant $1 $3 }++-- attributes, relevant+ | '(' ModalTBindWithHiding ')' { setRange (getRange ($1,$2,$3)) $ $2 }+ | "{{" ModalTBind "}}" { setRange (getRange ($1,$2,$3)) $ makeInstance $2 }+ | '{' ModalTBind '}' { setRange (getRange ($1,$2,$3)) $ hide $2 }++-- attributes, irrelevant+ | '.' '(' ModalTBindWithHiding ')' {% setRange (getRange ($2,$3,$4)) <\$> makeIrrelevantM $1 $3 }+ | '.' '{' ModalTBind '}' {% setRange (getRange ($2,$3,$4)) . hide <\$> makeIrrelevantM $1 $3 }+ | '.' "{{" ModalTBind "}}" {% setRange (getRange ($2,$3,$4)) . makeInstance <\$> makeIrrelevantM $1 $3 }+-- attributes, shape-irrelevant+ | '..' '(' ModalTBindWithHiding ')' {% setRange (getRange ($2,$3,$4)) <\$> makeShapeIrrelevantM $1 $3 }+ | '..' '{' ModalTBind '}' {% setRange (getRange ($2,$3,$4)) . hide <\$> makeShapeIrrelevantM $1 $3 }+ | '..' "{{" ModalTBind "}}" {% setRange (getRange ($2,$3,$4)) . makeInstance <\$> makeShapeIrrelevantM $1 $3 }+++-- x1 .. xn : A+-- x1 .. xn :{i1 i2 ..} A+TBind :: { TypedBinding }+TBind : CommaBIds ':' Expr {+ let r = getRange ($1,$2,$3) -- the range is approximate only for TypedBindings+ in TBind r $1 $3+ }++ModalTBind :: { TypedBinding }+ModalTBind : Attributes1 CommaBIds ':' Expr {% do+ let r = getRange ($1,$2,$3,$4) -- the range is approximate only for TypedBindings+ xs <- mapM (applyAttrs $1 . setTacticAttr $1) $2+ return $ TBind r xs $4+ }++-- x {y z} _ {v} : A+TBindWithHiding :: { TypedBinding }+TBindWithHiding : BIdsWithHiding ':' Expr {+ let r = getRange ($1,$2,$3) -- the range is approximate only for TypedBindings+ in TBind r $1 $3+ }++ModalTBindWithHiding :: { TypedBinding }+ModalTBindWithHiding : Attributes1 BIdsWithHiding ':' Expr {% do+ let r = getRange ($1,$2,$3,$4) -- the range is approximate only for TypedBindings+ xs <- mapM (applyAttrs $1 . setTacticAttr $1) $2+ return $ TBind r xs $4+ }++-- A non-empty sequence of lambda bindings.+LamBindings :: { List1 LamBinding }+LamBindings+ : LamBinds '->' {%+ case absurdBinding $1 of+ Just{} -> parseError "Absurd lambda cannot have a body."+ Nothing -> return $ List1.fromListSafe __IMPOSSIBLE__ $ lamBindings $1+ }++AbsurdLamBindings :: { Either ([LamBinding], Hiding) (List1 Expr) }+AbsurdLamBindings+ : LamBindsAbsurd {%+ case $1 of+ Left lb -> case absurdBinding lb of+ Nothing -> parseError "Missing body for lambda"+ Just h -> return $ Left (lamBindings lb, h)+ Right es -> return $ Right es+ }++-- absurd lambda is represented by @Left hiding@+LamBinds :: { LamBinds }+LamBinds+ : DomainFreeBinding LamBinds { fmap (map DomainFree (List1.toList $1) ++) $2 }+ | TypedBinding LamBinds { fmap (DomainFull $1 :) $2 }+ | DomainFreeBinding { mkLamBinds $ map DomainFree $ List1.toList $1 }+ | TypedBinding { mkLamBinds [DomainFull $1] }+ | '(' ')' { mkAbsurdBinding NotHidden }+ | '{' '}' { mkAbsurdBinding Hidden }+ | "{{" "}}" { mkAbsurdBinding (Instance NoOverlap) }++-- Like LamBinds, but could also parse an absurd LHS of an extended lambda @{ p1 ... () }@+LamBindsAbsurd :: { Either LamBinds (List1 Expr) }+LamBindsAbsurd+ : DomainFreeBinding LamBinds { Left $ fmap (map DomainFree (List1.toList $1) ++) $2 }+ | TypedBinding LamBinds { Left $ fmap (DomainFull $1 :) $2 }+ | TypedBinding { Left $ mkLamBinds [DomainFull $1] }+ | '(' ')' { Left $ mkAbsurdBinding NotHidden }+ | '{' '}' { Left $ mkAbsurdBinding Hidden }+ | "{{" "}}" { Left $ mkAbsurdBinding (Instance NoOverlap) }+ | DomainFreeBindingAbsurd {+ case $1 of+ Left lb -> Left $ mkLamBinds (map DomainFree $ List1.toList lb)+ Right es -> Right es+ }++-- FNF, 2011-05-05: No where-clauses in extended lambdas for now.+-- Andreas, 2020-03-28: And also not in sight either nine years later.+NonAbsurdLamClause :: { LamClause }+NonAbsurdLamClause+ : Application3PossiblyEmpty '->' Expr {% mkLamClause empty $1 (RHS $3) }+ | CatchallPragma+ Application3PossiblyEmpty '->' Expr {% mkLamClause (YesCatchall (getRange $1)) $2 (RHS $4) }++AbsurdLamClause :: { LamClause }+AbsurdLamClause+-- FNF, 2011-05-09: By being more liberal here, we avoid shift/reduce and reduce/reduce errors.+-- Later stages such as scope checking will complain if we let something through which we should not+ : Application {% mkAbsurdLamClause empty $1 }+ | CatchallPragma Application {% mkAbsurdLamClause (YesCatchall (getRange $1)) $2 }++LamClause :: { LamClause }+LamClause+ : NonAbsurdLamClause { $1 }+ | AbsurdLamClause { $1 }++-- Parses all extended lambda clauses except for a single absurd clause, which is taken care of+-- in AbsurdLambda+LamClauses :: { List1 LamClause }+LamClauses+ : LamClauses semi LamClause { $3 <| $1 }+ | AbsurdLamClause semi LamClause { $3 <| singleton $1 }+ | NonAbsurdLamClause { singleton $1 }++-- Parses all extended lambda clauses including a single absurd clause.+-- For lambda-where this is not[sic!, now?] taken care of in AbsurdLambda.+LamWhereClauses :: { List1 LamClause }+LamWhereClauses+ : LamWhereClauses semi LamClause { $3 <| $1 }+ | LamClause { singleton $1 }++ForallBindings :: { List1 LamBinding }+ForallBindings+ : TypedUntypedBindings1 '->' { $1 }++-- A non-empty sequence of possibly untyped bindings.+TypedUntypedBindings1 :: { List1 LamBinding }+TypedUntypedBindings1+ : DomainFreeBinding TypedUntypedBindings1 { fmap DomainFree $1 <> $2 }+ | TypedBinding TypedUntypedBindings1 { DomainFull $1 <| $2 }+ | DomainFreeBinding { fmap DomainFree $1 }+ | TypedBinding { singleton $ DomainFull $1 }++-- A possibly empty sequence of possibly untyped bindings.+-- This is used as telescope in data and record decls.+TypedUntypedBindings :: { [LamBinding] }+TypedUntypedBindings+ : DomainFreeBinding TypedUntypedBindings { map DomainFree (List1.toList $1) ++ $2 }+ | TypedBinding TypedUntypedBindings { DomainFull $1 : $2 }+ | { [] }++DomainFreeBindings :: { [NamedArg Binder] }+DomainFreeBindings+ : {- empty -} { [] }+ | DomainFreeBinding DomainFreeBindings { List1.toList $1 ++ $2 }++-- A domain free binding is either x or {x1 .. xn}+DomainFreeBinding :: { List1 (NamedArg Binder) }+DomainFreeBinding+ : DomainFreeBindingAbsurd {% case $1 of+ Left lbs -> return lbs+ Right _ -> parseError "expected sequence of bound identifiers, not absurd pattern"+ }++MaybeAsPattern :: { Maybe Pattern }+MaybeAsPattern+ : '@' Expr3 {% fmap Just (exprToPattern $2) }+ | {- empty -} { Nothing }++-- A domain free binding is either x or {x1 .. xn}+DomainFreeBindingAbsurd :: { Either (List1 (NamedArg Binder)) (List1 Expr)}+DomainFreeBindingAbsurd+-- no parentheses+ : BId MaybeAsPattern { Left . singleton $ mkDomainFree_ id $2 $1 }+ | '.' BId MaybeAsPattern { Left . singleton $ mkDomainFree_ (makeIrrelevant $1) $3 $2 }+ | '..' BId MaybeAsPattern { Left . singleton $ mkDomainFree_ (makeShapeIrrelevant $1) $3 $2 }++-- just parentheses+ | '(' Application ')' {% exprToPattern (rawApp $2) >>= \ p ->+ pure . Left . singleton $ mkDomainFree_ id (Just p) $ simpleHole }+ | '{' CommaBIdAndAbsurds '}' { first (fmap hide) $2 }+ | "{{" CommaBIds "}}" { Left $ fmap makeInstance $2 }++-- additonal attributes, e.g. @tactic+ | '(' Attributes1 CommaBIdAndAbsurds ')'+ {% applyAttrs $2 defaultArgInfo <&> \ ai ->+ first (fmap (setTacticAttr $2 . setArgInfo ai)) $3 }+ | '{' Attributes1 CommaBIdAndAbsurds '}'+ {% applyAttrs $2 defaultArgInfo <&> \ ai ->+ first (fmap (hide . setTacticAttr $2 . setArgInfo ai)) $3 }+ | "{{" Attributes1 CommaBIds "}}"+ {% Left <\$> applyAttributes $2 (makeInstance defaultArgInfo) $3 }++-- additional irrelevance+ | '.' '(' CommaBIds ')' { Left $ fmap (makeIrrelevant $1) $3 }+ | '.' '{' CommaBIds '}' { Left $ fmap (hide . makeIrrelevant $1) $3 }+ | '.' "{{" CommaBIds "}}" { Left $ fmap (makeInstance . makeIrrelevant $1) $3 }++-- additional shape-irrelevance+ | '..' '(' CommaBIds ')' { Left $ fmap (makeShapeIrrelevant $1) $3 }+ | '..' '{' CommaBIds '}' { Left $ fmap (hide . makeShapeIrrelevant $1) $3 }+ | '..' "{{" CommaBIds "}}" { Left $ fmap (makeInstance . makeShapeIrrelevant $1) $3 }++-- additional irrelevance and attributes+ | '.' '(' Attributes1 CommaBIds ')'+ {% Left <\$> applyAttributes $3 (makeIrrelevant $1 defaultArgInfo) $4 }+ | '.' '{' Attributes1 CommaBIds '}'+ {% Left <\$> applyAttributes $3 (makeIrrelevant $1 $ hide defaultArgInfo) $4 }+ | '.' "{{" Attributes1 CommaBIds "}}"+ {% Left <\$> applyAttributes $3 (makeIrrelevant $1 $ makeInstance defaultArgInfo) $4 }++-- additional shape-irrelevance and attributes+ | '..' '(' Attributes1 CommaBIds ')'+ {% Left <\$> applyAttributes $3 (makeShapeIrrelevant $1 defaultArgInfo) $4 }+ | '..' '{' Attributes1 CommaBIds '}'+ {% Left <\$> applyAttributes $3 (makeShapeIrrelevant $1 $ hide defaultArgInfo) $4 }+ | '..' "{{" Attributes1 CommaBIds "}}"+ {% Left <\$> applyAttributes $3 (makeShapeIrrelevant $1 $ makeInstance defaultArgInfo) $4 }+++{--------------------------------------------------------------------------+ Do-notation+ --------------------------------------------------------------------------}++DoStmts :: { List1 DoStmt }+DoStmts : DoStmt { singleton $1 }+ | DoStmt vsemi { singleton $1 } -- #3046+ | DoStmt semi DoStmts { $1 <| $3 }++DoStmt :: { DoStmt }+DoStmt : Expr DoWhere {% buildDoStmt $1 $2 }++DoWhere :: { [LamClause] }+DoWhere+ : {- empty -} { [] }+ | 'where' vopen LamWhereClauses close { reverse (List1.toList $3) }++{--------------------------------------------------------------------------+ Modules and imports+ --------------------------------------------------------------------------}++-- Import directives+ImportDirective :: { ImportDirective }+ImportDirective+ : ImportDirective1 ImportDirective { $1 <> $2 }+ | {- empty -} { mempty }++ImportDirective1 :: { ImportDirective }+ : 'public' { defaultImportDir { importDirRange = getRange $1, publicOpen = Just (kwRange $1) } }+ | Using { defaultImportDir { importDirRange = snd $1, using = fst $1 } }+ | Hiding { defaultImportDir { importDirRange = snd $1, hiding = fst $1 } }+ | RenamingDir { defaultImportDir { importDirRange = snd $1, impRenaming = fst $1 } }++Using :: { (Using, Range) }+Using+ : 'using' '(' CommaImportNames ')' { (Using $3 , getRange ($1,$2,$3,$4)) }+ -- using can have an empty list++Hiding :: { ([ImportedName], Range) }+Hiding+ : 'hiding' '(' CommaImportNames ')' { ($3 , getRange ($1,$2,$3,$4)) }+ -- if you want to hide nothing that's fine, isn't it?++RenamingDir :: { ([Renaming] , Range) }+RenamingDir+ : 'renaming' '(' Renamings ')' { ($3 , getRange ($1,$2,$3,$4)) }+ | 'renaming' '(' ')' { ([] , getRange ($1,$2,$3)) }++-- Renamings of the form 'x to y'+Renamings :: { [Renaming] }+Renamings+ : Renaming ';' Renamings { $1 : $3 }+ | Renaming { [$1] }++Renaming :: { Renaming }+Renaming+ : ImportName_ 'to' RenamingTarget { Renaming $1 (setImportedName $1 (snd $3)) (fst $3) (getRange $2) }++RenamingTarget :: { (Maybe Fixity, Name) }+RenamingTarget+ : Id { (Nothing, $1) }+ | 'infix' Float Id { (Just (Fixity (getRange ($1,$2)) (Related $ rangedThing $2) NonAssoc) , $3) }+ | 'infixl' Float Id { (Just (Fixity (getRange ($1,$2)) (Related $ rangedThing $2) LeftAssoc) , $3) }+ | 'infixr' Float Id { (Just (Fixity (getRange ($1,$2)) (Related $ rangedThing $2) RightAssoc), $3) }++-- We need a special imported name here, since we have to trigger+-- the imp_dir state exactly one token before the 'to'+ImportName_ :: { ImportedName }+ImportName_+ : beginImpDir Id { ImportedName $2 }+ | 'module' beginImpDir Id { ImportedModule $3 }++ImportName :: { ImportedName }+ImportName : Id { ImportedName $1 }+ | 'module' Id { ImportedModule $2 }++-- Actually semi-colon separated, possibly empty list of ImportName.+CommaImportNames :: { [ImportedName] }+CommaImportNames+ : {- empty -} { [] }+ | CommaImportNames1 { List1.toList $1 }++CommaImportNames1 :: { List1 ImportedName }+CommaImportNames1+ : ImportName { singleton $1 }+ | ImportName ';' CommaImportNames1 { $1 <| $3 }++{--------------------------------------------------------------------------+ Function clauses+ --------------------------------------------------------------------------}++-- A left hand side of a function clause. We parse it as an expression, and+-- then check that it is a valid left hand side.+LHS :: { [RewriteEqn] -> [WithExpr] -> LHS }+LHS : Expr1 {% exprToLHS $1 }++-- Parsing either an expression @e@ or a @(rewrite | with p <-) e1 | ... | en@.+HoleContent :: { HoleContent }+HoleContent+ : Expr { HoleContentExpr $1 }+ | WHS+ {% fmap HoleContentRewrite $ forM $1 $ \case+ Left r -> pure r+ Right{} -> parseError "Cannot declare a 'with' abstraction from inside a hole."+ }++-- Where clauses are optional.+WhereClause :: { WhereClause }+WhereClause+ : {- empty -} { NoWhere }+ | 'where' Declarations0+ { AnyWhere (getRange $1) $2 }+ | 'module' Attributes Id 'where' Declarations0+ {% onlyErased $2 >>= \erased ->+ return $ SomeWhere (getRange ($1,$4)) erased+ $3 PublicAccess $5 }+ | 'module' Attributes Underscore 'where' Declarations0+ {% onlyErased $2 >>= \erased ->+ return $ SomeWhere (getRange ($1,$4)) erased+ $3 PublicAccess $5 }+ -- Note: The access modifier is a dummy, it is computed in the nicifier.++ExprWhere :: { ExprWhere }+ExprWhere : Expr WhereClause { ExprWhere $1 $2 }++{--------------------------------------------------------------------------+ Different kinds of declarations+ --------------------------------------------------------------------------}++-- Top-level definitions.+Declaration :: { List1 Declaration }+Declaration+ : Fields { singleton $1 }+ | FunClause { $1 } -- includes type signatures+ | Data { singleton $1 }+ | DataSig { singleton $1 } -- lone data type signature in mutual block+ | Record { singleton $1 }+ | RecordSig { singleton $1 } -- lone record signature in mutual block+ | Infix { singleton $1 }+ | Generalize { singleton $1 }+ | Mutual { singleton $1 }+ | Abstract { singleton $1 }+ | Private { singleton $1 }+ | Instance { singleton $1 }+ | Macro { singleton $1 }+ | Postulate { singleton $1 }+ | Primitive { singleton $1 }+ | Import { singleton $1 }+ | Open { singleton $1 }+ | ModuleMacro { singleton $1 }+ | Module { singleton $1 }+ | Pragma { singleton $1 }+ | Syntax { singleton $1 }+ | PatternSyn { singleton $1 }+ | UnquoteDecl { singleton $1 }+ | Constructor { singleton $1 }+ | Opaque { singleton $1 }+ | Unfolding { singleton $1 }++{--------------------------------------------------------------------------+ Individual declarations+ --------------------------------------------------------------------------}++-- A variant of TypeSigs where any sub-sequence of names can be marked+-- as hidden or irrelevant using braces and dots:+-- {n1 .n2} n3 .n4 {n5} .{n6 n7} ... : Type.+ArgTypeSigs :: { List1 (Arg Declaration) }+ArgTypeSigs+ : ModalArgIds ':' Expr { let (tac, xs) = $1 in+ fmap (fmap (\ x -> typeSig defaultArgInfo tac x $3)) xs }+ | 'overlap' ModalArgIds ':' Expr {%+ let (tac, xs) = $2+ setOverlap x =+ case getHiding x of+ Instance _ -> return $ makeInstance' YesOverlap x+ _ -> parseErrorRange $1+ "The 'overlap' keyword only applies to instance fields (fields marked with {{ }})"+ in T.traverse (setOverlap . fmap (\ x -> typeSig defaultArgInfo tac x $4)) xs }+ | 'instance' ArgTypeSignatures {+ let+ setInstance (TypeSig info tac x t) = TypeSig (makeInstance info) tac x t+ setInstance _ = __IMPOSSIBLE__ in+ fmap (fmap setInstance) $2 }++ModalArgTypeSigs :: { List1 Declaration }+ModalArgTypeSigs+ : ModalArgIds ':' Expr { let (tac, xs) = $1 in+ fmap (\ (Arg ai x) -> typeSig ai tac x $3) xs }++-- Function declarations. The left hand side is parsed as an expression to allow+-- declarations like 'x::xs ++ ys = e', when '::' has higher precedence than '++'.+-- FunClause also handle possibly dotted type signatures.+FunClause :: { List1 Declaration }+FunClause+ : {- emptyb -} LHS WHS RHS WhereClause {% funClauseOrTypeSigs [] $1 $2 $3 $4 }+ | Attributes1 LHS WHS RHS WhereClause {% funClauseOrTypeSigs $1 $2 $3 $4 $5 }++-- "With Hand Side", in between the Left & the Right hand ones+WHS :: { [Either RewriteEqn (List1 (Named Name Expr))] }+WHS+ : {- empty -} { [] }+ | 'with' WithExprs WHS {% fmap (++ $3) (buildWithStmt $2) }+ | 'rewrite' UnnamedWithExprs WHS { Left (Rewrite $ fmap ((),) $2) : $3 }+ | 'using' UnnamedWithExprs WHS {% do+ eqn <- buildUsingStmt $2+ pure $ Left eqn : $3 }++RHS :: { RHSOrTypeSigs }+RHS+ : {- empty -} { JustRHS AbsurdRHS }+ | '=' Expr { JustRHS (RHS $2) }+ | ':' Expr { TypeSigsRHS $2 }++-- Data declaration. Can be local.+Data :: { Declaration }+Data : 'data' Id TypedUntypedBindings ':' Expr 'where'+ Declarations0+ { Data (getRange ($1,$2,$3,$4,$5,$6,$7))+ defaultErased $2 $3 $5 $7 }+ | 'data' Attributes1 Id TypedUntypedBindings ':' Expr 'where'+ Declarations0+ {% onlyErased $2 >>= \e ->+ return $ Data (getRange (($1,$2,$3,$4),($5,$6,$7,$8)))+ e $3 $4 $6 $8 }++ -- New cases when we already had a DataSig. Then one can omit the sort.+ | 'data' Id TypedUntypedBindings 'where'+ Declarations0 { DataDef (getRange ($1,$2,$3,$4,$5)) $2 $3 $5 }++-- Data type signature. Found in mutual blocks.+DataSig :: { Declaration }+DataSig+ : 'data' Id TypedUntypedBindings ':' Expr+ { DataSig (getRange ($1,$2,$3,$4,$5)) defaultErased $2 $3 $5 }+ | 'data' Attributes1 Id TypedUntypedBindings ':' Expr+ {% onlyErased $2 >>= \e ->+ return $ DataSig (getRange ($1,$2,$3,$4,$5,$6)) e $3 $4 $6 }++-- Andreas, 2012-03-16: The Expr3NoCurly instead of Id in everything+-- following 'record' is to remove the (harmless) shift/reduce conflict+-- introduced by record update expressions.++-- Record declarations.+Record :: { Declaration }+Record : 'record' Expr3NoCurly TypedUntypedBindings ':' Expr 'where'+ RecordDeclarations+ {% exprToName $2 >>= \ n -> let (dir, ds) = $7 in+ return $ Record (getRange ($1,$2,$3,$4,$5,$6,$7))+ defaultErased n dir $3 $5 ds }+ | 'record' Attributes1 Expr3NoCurly TypedUntypedBindings ':' Expr+ 'where'+ RecordDeclarations+ {% onlyErased $2 >>= \e ->+ exprToName $3 >>= \n ->+ let (dir, ds) = $8 in+ return $ Record (getRange (($1,$2,$3,$4),($5,$6,$7,$8)))+ e n dir $4 $6 ds }+ | 'record' Expr3NoCurly TypedUntypedBindings 'where'+ RecordDeclarations+ {% exprToName $2 >>= \ n -> let (dir, ds) = $5 in return $ RecordDef (getRange ($1,$2,$3,$4,$5)) n dir $3 ds }++-- Record type signature. In mutual blocks.+RecordSig :: { Declaration }+RecordSig+ : 'record' Expr3NoCurly TypedUntypedBindings ':' Expr+ {% exprToName $2 >>= \n ->+ return $ RecordSig (getRange ($1,$2,$3,$4,$5))+ defaultErased n $3 $5 }+ | 'record' Attributes1 Expr3NoCurly TypedUntypedBindings ':' Expr+ {% onlyErased $2 >>= \e ->+ exprToName $3 >>= \n ->+ return $ RecordSig (getRange ($1,$2,$3,$4,$5,$6)) e n $4 $6 }++Constructor :: { Declaration }+Constructor : 'data' '_' 'where' Declarations0+ { LoneConstructor (kwRange ($1,$2,$3)) $4 }++-- Declaration of record constructor name.+RecordConstructorName :: { (Name, IsInstance) }+RecordConstructorName : 'constructor' Id { ($2, NotInstanceDef) }+ | 'instance' vopen 'constructor' Id close { ($4, InstanceDef (kwRange $1)) }+++-- Fixity declarations.+Infix :: { Declaration }+Infix : 'infix' Float SpaceBIds { Infix (Fixity (getRange ($1,$2,$3)) (Related $ rangedThing $2) NonAssoc) $3 }+ | 'infixl' Float SpaceBIds { Infix (Fixity (getRange ($1,$2,$3)) (Related $ rangedThing $2) LeftAssoc) $3 }+ | 'infixr' Float SpaceBIds { Infix (Fixity (getRange ($1,$2,$3)) (Related $ rangedThing $2) RightAssoc) $3 }++-- Field declarations.+Fields :: { Declaration }+Fields : 'field' ArgTypeSignaturesOrEmpty+ { let+ inst i = case getHiding i of+ Instance _ -> InstanceDef empty -- no @instance@ keyword here+ _ -> NotInstanceDef+ toField (Arg info (TypeSig info' tac x t)) = FieldSig (inst info') tac x (Arg info t)+ in Field (kwRange $1) $ map toField $2 }++-- Variable declarations for automatic generalization+Generalize :: { Declaration }+Generalize : 'variable' Block0(ModalArgTypeSigs)+ { Generalize (kwRange $1) (List1.concat $2) }++-- Mutually recursive declarations.+Mutual :: { Declaration }+Mutual : 'mutual' Declarations0 { Mutual (kwRange $1) $2 }+ | 'interleaved' 'mutual' Declarations0 { InterleavedMutual (kwRange ($1,$2)) $3 }++-- Abstract declarations.+Abstract :: { Declaration }+Abstract : 'abstract' Declarations0 { Abstract (kwRange $1) $2 }+++-- Private can only appear on the top-level (or rather the module level).+Private :: { Declaration }+Private : 'private' Declarations0 { Private (kwRange $1) UserWritten $2 }+++-- Instance declarations.+Instance :: { Declaration }+Instance : 'instance' Declarations0 { InstanceB (kwRange $1) $2 }+++-- Macro declarations.+Macro :: { Declaration }+Macro : 'macro' Declarations0 { Macro (kwRange $1) $2 }++-- Postulates.+--+-- Checked in nicifier:+-- Can only contain type signatures, possibly in instance and private blocks.+Postulate :: { Declaration }+Postulate : 'postulate' Declarations0 { Postulate (kwRange $1) $2 }++-- Primitives.+--+-- Checked in nicifier:+-- Can only contain type signatures, possibly in instance and private blocks.+Primitive :: { Declaration }+Primitive : 'primitive' Declarations0 { Primitive (kwRange $1) $2 }++-- Unquoting declarations.+UnquoteDecl :: { Declaration }+UnquoteDecl+ : 'unquoteDecl' '=' Expr { UnquoteDecl (fuseRange $1 $3) [] $3 }+ | 'unquoteDecl' 'data' Id '=' Expr { UnquoteData (getRange($1, $2, $5)) $3 [] $5 }+ | 'unquoteDecl' 'data' Id 'constructor' SpaceIds '=' Expr { UnquoteData (getRange($1, $2, $4, $7)) $3 (List1.toList $5) $7 }+ | 'unquoteDecl' SpaceIds '=' Expr { UnquoteDecl (fuseRange $1 $4) (List1.toList $2) $4 }+ | 'unquoteDef' SpaceIds '=' Expr { UnquoteDef (fuseRange $1 $4) (List1.toList $2) $4 }++-- Syntax declaration (To declare eg. mixfix binders)+Syntax :: { Declaration }+Syntax : 'syntax' Id HoleNames '=' SimpleIds {%+ case $2 of+ Name _ _ (_ :| []) -> case mkNotation (DL.toList $3) (reverse $5) of+ Left err -> parseError $ "Malformed syntax declaration: " ++ err+ Right n -> return $ Syntax $2 n+ _ -> parseError "Syntax declarations are allowed only for simple names (without holes)"+}++-- Pattern synonyms.+PatternSyn :: { Declaration }+PatternSyn : 'pattern' Id PatternSynArgs '=' Expr {% do+ p <- exprToPattern $5+ return (PatternSyn (getRange ($1,$2,$3,$4,$5)) $2 $3 p)+ }++PatternSynArgs :: { [WithHiding Name] }+PatternSynArgs : DomainFreeBindings {% patternSynArgs $1 }++-- The list should be reversed.++SimpleIds :: { [RString] }+SimpleIds : SimpleId { [$1] }+ | SimpleIds SimpleId { $2 : $1 }++-- The list should be reversed.++SimpleIdsOrWildcards :: { List1 RString }+SimpleIdsOrWildcards+ : SimpleIdOrWildcard { List1.singleton $1 }+ | SimpleIdsOrWildcards SimpleIdOrWildcard { $2 <| $1 }++HoleNames :: { DList (NamedArg HoleName) }+HoleNames : { mempty }+ | HoleNames HoleName { $1 `DL.snoc` $2 }++HoleName :: { NamedArg HoleName }+HoleName+ : SimpleTopHole { defaultNamedArg $1 }+ | '{' SimpleHole '}' { hide $ defaultNamedArg $2 }+ | "{{" SimpleHole "}}" { makeInstance $ defaultNamedArg $2 }+ | '{' SimpleId '=' SimpleHole '}' { hide $ defaultArg $ userNamed $2 $4 }+ | "{{" SimpleId '=' SimpleHole "}}" { makeInstance $ defaultArg $ userNamed $2 $4 }++SimpleTopHole :: { HoleName }+SimpleTopHole+ : SimpleId { ExprHole $1 }+ | '(' '\\' SimpleIdsOrWildcards '->' SimpleId ')'+ { LambdaHole (List1.reverse $3) $5 }++SimpleHole :: { HoleName }+SimpleHole+ : SimpleId { ExprHole $1 }+ | '\\' SimpleIdsOrWildcards '->' SimpleId+ { LambdaHole (List1.reverse $2) $4 }++-- Discard the interval.+SimpleId :: { RString }+SimpleId : id { Ranged (getRange $ fst $1) (stringToRawName $ snd $1) }++SimpleIdOrWildcard :: { RString }+SimpleIdOrWildcard+ : SimpleId { $1 }+ | '_' { Ranged (getRange $1) "_" }++MaybeOpen :: { OpenShortHand }+MaybeOpen : 'open' { DoOpen (kwRange $1) }+ | {- empty -} { DontOpen }++-- Import with possible opening.+Import :: { Declaration }+Import+ : MaybeOpen 'import' ModuleName OpenArgs ImportDirective+ { Import $1 (kwRange $2) $3 (Right $4) $5 }++-- Open without import.+Open :: { Declaration }+Open+ : 'open' ModuleName OpenArgs ImportDirective {+ let+ { m = $2+ ; es = $3+ ; dir = $4+ ; r = getRange ($1, m, es, dir)+ } in+ case es of+ { [] -> Open (kwRange $1) m dir+ ; _ -> Private empty Inserted+ [ ModuleMacro r defaultErased+ (noName $ beginningOf $ getRange m)+ (SectionApp (getRange (m , es)) [] m es)+ (DoOpen (kwRange $1)) dir+ ]+ }+ }+ | 'open' ModuleName "{{" '...' "}}" ImportDirective {+ let r = getRange $2 in+ Private empty Inserted+ [ ModuleMacro r defaultErased (noName $ beginningOf r)+ (RecordModuleInstance r $2) (DoOpen (kwRange $1)) $6+ ]+ }++OpenArgs :: { [Expr] }+OpenArgs : {- empty -} { [] }+ | Expr3 OpenArgs { $1 : $2 }++ModuleApplication :: { Telescope -> Parser ModuleApplication }+ModuleApplication : ModuleName "{{" '...' "}}" { (\ts ->+ if null ts then return $ RecordModuleInstance (getRange ($1,$2,$3,$4)) $1+ else parseError "No bindings allowed for record module with non-canonical implicits" )+ }+ | ModuleName OpenArgs {+ (\ts -> return $ SectionApp (getRange ($1, $2)) ts $1 $2) }+++-- Module instantiation+ModuleMacro :: { Declaration }+ModuleMacro+ : 'module' Attributes ModuleName TypedUntypedBindings '='+ ModuleApplication ImportDirective+ {% do { ma <- $6 (map addType $4)+ ; erased <- onlyErased $2+ ; name <- ensureUnqual $3+ ; return $ ModuleMacro (getRange ($1, $2, $3, ma, $7))+ erased name ma DontOpen $7+ }+ }+ | 'open' 'module' Attributes Id TypedUntypedBindings '='+ ModuleApplication ImportDirective+ {% do { ma <- $7 (map addType $5)+ ; erased <- onlyErased $3+ ; return $ ModuleMacro (getRange ($1, $2, $3, $4, ma, $8))+ erased $4 ma (DoOpen (kwRange $1)) $8+ } }++-- Module+Module :: { Declaration }+Module+ : 'module' Attributes ModuleName TypedUntypedBindings 'where'+ Declarations0+ {% onlyErased $2 >>= \erased ->+ return $ Module (getRange ($1,$2,$3,$4,$5,$6)) erased+ $3 (map addType $4) $6 }+ | 'module' Attributes Underscore TypedUntypedBindings 'where'+ Declarations0+ {% onlyErased $2 >>= \erased ->+ return $ Module (getRange ($1,$2,$3,$4,$5,$6)) erased+ (QName $3) (map addType $4) $6 }++Underscore :: { Name }+Underscore : '_' { noName (getRange $1) }++Pragma :: { Declaration }+Pragma : DeclarationPragma { Pragma $1 }++DeclarationPragma :: { Pragma }+DeclarationPragma+ : BuiltinPragma { $1 }+ | RewritePragma { $1 }+ | CompilePragma { $1 }+ | ForeignPragma { $1 }+ | StaticPragma { $1 }+ | InjectivePragma { $1 }+ | InjectiveForInferencePragma { $1 }+ | InlinePragma { $1 }+ | NoInlinePragma { $1 }+ | ImpossiblePragma { $1 }+ | TerminatingPragma { $1 }+ | NonTerminatingPragma { $1 }+ | NoTerminationCheckPragma { $1 }+ | NonCoveringPragma { $1 }+ | NotProjectionLikePragma { $1 }+ | WarningOnUsagePragma { $1 }+ | WarningOnImportPragma { $1 }+ | MeasurePragma { $1 }+ | CatchallPragma { $1 }+ | DisplayPragma { $1 }+ | EtaPragma { $1 }+ | EtaEqualityPragma { $1 }+ | NoPositivityCheckPragma { $1 }+ | NoUniverseCheckPragma { $1 }+ | PolarityPragma { $1 }+ | OverlapPragma { $1 }+ | OptionsPragma { $1 }+ -- Andreas, 2014-03-06+ -- OPTIONS pragma not allowed everywhere, but don't give parse error.+ -- Give better error during type checking instead.++OptionsPragma :: { Pragma }+OptionsPragma :+ '{-#' 'OPTIONS' PragmaStrings '#-}'+ { OptionsPragma (getRange ($1, $2, map fst $3, $4)) (map snd $3) }++BuiltinPragma :: { Pragma }+BuiltinPragma+ : '{-#' 'BUILTIN' string PragmaQName '#-}'+ { BuiltinPragma (getRange ($1,$2,fst $3,$4,$5)) (mkRString $3) $4 }+ -- Extra rule to accept keyword REWRITE also as built-in:+ | '{-#' 'BUILTIN' 'REWRITE' PragmaQName '#-}'+ { BuiltinPragma (getRange ($1,$2,$3,$4,$5)) (Ranged (getRange $3) "REWRITE") $4 }++RewritePragma :: { Pragma }+RewritePragma+ : '{-#' 'REWRITE' PragmaQNames '#-}'+ { RewritePragma (getRange ($1,$2,$3,$4)) (getRange $2) $3 }++ForeignPragma :: { Pragma }+ForeignPragma+ : '{-#' 'FOREIGN' string ForeignCode '#-}'+ { ForeignPragma (getRange ($1, $2, fst $3, $5))+ (mkRText $3) (recoverLayout (DL.toList $4)) }++CompilePragma :: { Pragma }+CompilePragma+ : '{-#' 'COMPILE' string PragmaQName PragmaStrings '#-}'+ { CompilePragma (getRange ($1, $2, fst $3, $4, map fst $5, $6))+ (mkRText $3) $4 (unwords (map snd $5)) }++StaticPragma :: { Pragma }+StaticPragma+ : '{-#' 'STATIC' PragmaQName '#-}'+ { StaticPragma (getRange ($1,$2,$3,$4)) $3 }++InlinePragma :: { Pragma }+InlinePragma+ : '{-#' 'INLINE' PragmaQName '#-}'+ { InlinePragma (getRange ($1,$2,$3,$4)) True $3 }++NoInlinePragma :: { Pragma }+NoInlinePragma+ : '{-#' 'NOINLINE' PragmaQName '#-}'+ { InlinePragma (getRange ($1,$2,$3,$4)) False $3 }++NotProjectionLikePragma :: { Pragma }+NotProjectionLikePragma+ : '{-#' 'NOT_PROJECTION_LIKE' PragmaQName '#-}'+ { NotProjectionLikePragma (getRange ($1,$2,$3,$4)) $3 }++OverlapPragma :: { Pragma }+OverlapPragma+ : '{-#' 'OVERLAPPABLE' PragmaQNames1 '#-}' { OverlapPragma (getRange ($1,$2,$3,$4)) $3 Overlappable }+ | '{-#' 'OVERLAPPING' PragmaQNames1 '#-}' { OverlapPragma (getRange ($1,$2,$3,$4)) $3 Overlapping }+ | '{-#' 'OVERLAPS' PragmaQNames1 '#-}' { OverlapPragma (getRange ($1,$2,$3,$4)) $3 Overlaps }+ | '{-#' 'INCOHERENT' PragmaQNames1 '#-}' { OverlapPragma (getRange ($1,$2,$3,$4)) $3 Incoherent }++InjectivePragma :: { Pragma }+InjectivePragma+ : '{-#' 'INJECTIVE' PragmaQName '#-}'+ { InjectivePragma (getRange ($1,$2,$3,$4)) $3 }++InjectiveForInferencePragma :: { Pragma }+InjectiveForInferencePragma+ : '{-#' 'INJECTIVE_FOR_INFERENCE' PragmaQName '#-}'+ { InjectiveForInferencePragma (getRange ($1,$2,$3,$4)) $3 }++DisplayPragma :: { Pragma }+DisplayPragma+ : '{-#' 'DISPLAY' string PragmaStrings '#-}'+ {% let (r, s) = $3 in+ parseDisplayPragma (getRange ($1, $2, r, map fst $4, $5))+ (iStart r) (unwords (s : map snd $4)) }++EtaPragma :: { Pragma }+EtaPragma+ : '{-#' 'ETA' PragmaQName '#-}'+ { EtaPragma (getRange ($1,$2,$3,$4)) $3 }++EtaEqualityPragma :: { Pragma }+EtaEqualityPragma+ : '{-#' 'ETA_EQUALITY' '#-}'+ { EtaEqualityPragma (getRange ($1,$2,$3)) }++NoTerminationCheckPragma :: { Pragma }+NoTerminationCheckPragma+ : '{-#' 'NO_TERMINATION_CHECK' '#-}'+ { TerminationCheckPragma (getRange ($1,$2,$3)) NoTerminationCheck }++NonTerminatingPragma :: { Pragma }+NonTerminatingPragma+ : '{-#' 'NON_TERMINATING' '#-}'+ { TerminationCheckPragma (getRange ($1,$2,$3)) NonTerminating }++TerminatingPragma :: { Pragma }+TerminatingPragma+ : '{-#' 'TERMINATING' '#-}'+ { TerminationCheckPragma (getRange ($1,$2,$3)) Terminating }++NonCoveringPragma :: { Pragma }+NonCoveringPragma+ : '{-#' 'NON_COVERING' '#-}'+ { NoCoverageCheckPragma (getRange ($1,$2,$3)) }++MeasurePragma :: { Pragma }+MeasurePragma+ : '{-#' 'MEASURE' PragmaName '#-}'+ { let r = getRange ($1, $2, $3, $4) in+ TerminationCheckPragma r (TerminationMeasure r $3) }++CatchallPragma :: { Pragma }+CatchallPragma+ : '{-#' 'CATCHALL' '#-}'+ { CatchallPragma (getRange ($1,$2,$3)) }++ImpossiblePragma :: { Pragma }+ImpossiblePragma+ : '{-#' 'IMPOSSIBLE' PragmaStrings '#-}'+ { ImpossiblePragma (getRange ($1, $2, map fst $3, $4))+ (map snd $3) }++NoPositivityCheckPragma :: { Pragma }+NoPositivityCheckPragma+ : '{-#' 'NO_POSITIVITY_CHECK' '#-}'+ { NoPositivityCheckPragma (getRange ($1,$2,$3)) }++NoUniverseCheckPragma :: { Pragma }+NoUniverseCheckPragma+ : '{-#' 'NO_UNIVERSE_CHECK' '#-}'+ { NoUniverseCheckPragma (getRange ($1,$2,$3)) }++PolarityPragma :: { Pragma }+PolarityPragma+ : '{-#' 'POLARITY' PragmaName Polarities '#-}'+ { let occs = reverse $4 in+ PolarityPragma (getRange ($1,$2,$3,occs,$5)) $3 occs }++WarningOnUsagePragma :: { Pragma }+WarningOnUsagePragma+ : '{-#' 'WARNING_ON_USAGE' PragmaQName literal '#-}'+ {% case $4 of+ { Ranged r (LitString str) -> return $ WarningOnUsage (getRange ($1,$2,$3,r,$5)) $3 str+ ; _ -> parseError "Expected string literal"+ }+ }++WarningOnImportPragma :: { Pragma }+WarningOnImportPragma+ : '{-#' 'WARNING_ON_IMPORT' literal '#-}'+ {% case $3 of+ { Ranged r (LitString str) -> return $ WarningOnImport (getRange ($1,$2,r,$4)) str+ ; _ -> parseError "Expected string literal"+ }+ }++-- Possibly empty list of polarities. Reversed.+Polarities :: { [Ranged Occurrence] }+Polarities : {- empty -} { [] }+ | Polarities Polarity { $2 : $1 }++Polarity :: { Ranged Occurrence }+Polarity : string {% parsePolarity $1 }++{--------------------------------------------------------------------------+ Sequences of declarations+ --------------------------------------------------------------------------}++-- A nonempty block of things.+Block1(p) -- :: List1 p+ : vopen Block1i(p) close { List1.reverse $2 }++-- Inside the layout block.+Block1i(p) -- :: List1 p+ : Block1i(p) semi p { $3 <| $1 }+ | p { singleton $1 }++-- A possibly empty block of things+Block0(p) -- :: [p]+ : vopen Block0i(p) close { reverse $2 }++-- Inside the layout block.+Block0i(p)+ : Block0i(p) semi p { $3 : $1 }+ | p { [ $1 ] }+ | {- empty -} { [] }++-- A variant of TypeSignatures which uses ArgTypeSigs instead of+-- TypeSigs.+ArgTypeSignatures :: { List1 (Arg TypeSignature) }+ArgTypeSignatures+ : vopen ArgTypeSignatures1 close { List1.reverse $2 }++-- Inside the layout block.+ArgTypeSignatures1 :: { List1 (Arg TypeSignature) }+ArgTypeSignatures1+ : ArgTypeSignatures1 semi ArgTypeSigs { List1.reverse $3 <> $1 }+ | ArgTypeSigs { List1.reverse $1 }++-- A variant of TypeSignatures which uses ArgTypeSigs instead of+-- TypeSigs.+ArgTypeSignaturesOrEmpty :: { [Arg TypeSignature] }+ArgTypeSignaturesOrEmpty+ : vopen ArgTypeSignatures0 close { reverse $2 }++-- Inside the layout block.+ArgTypeSignatures0 :: { [Arg TypeSignature] }+ArgTypeSignatures0+ : ArgTypeSignatures0 semi ArgTypeSigs { reverse (List1.toList $3) ++ $1 }+ | ArgTypeSigs { reverse (List1.toList $1) }+ | {- empty -} { [] }++-- Record declarations, including an optional record constructor name.+RecordDeclarations :: { ([RecordDirective], [Declaration]) }+RecordDeclarations+ : vopen RecordDirectives close { (reverse $2, []) }+ | vopen RecordDirectives semi Declarations1 close { (reverse $2, List1.toList $4) }+ | vopen Declarations1 close { ([], List1.toList $2) }++RecordDirectives :: { [RecordDirective] }+RecordDirectives+ : {- empty -} { [] }+ | RecordDirectives semi RecordDirective { $3 : $1 }+ | RecordDirective { [$1] }++RecordDirective :: { RecordDirective }+RecordDirective+ : RecordConstructorName { uncurry Constructor $1 }+ | RecordInduction { Induction $1 }+ | RecordEta { Eta $1 }+ | RecordPatternMatching { PatternOrCopattern $1 }++RecordEta :: { Ranged HasEta0 }+RecordEta+ : 'eta-equality' { Ranged (getRange $1) YesEta }+ | 'no-eta-equality' { Ranged (getRange $1) (NoEta ()) }++-- Directive 'pattern' if a decision between matching on constructor/record pattern+-- or copattern matching is needed.+-- Such decision is only needed for 'no-eta-equality' records.+-- But eta could be turned off automatically, thus, we do not bundle this+-- with the 'no-eta-equality' declaration.+-- Nor with the 'constructor' declaration, since it applies also to+-- the record pattern.+RecordPatternMatching :: { Range }+RecordPatternMatching+ : 'pattern' { getRange $1 }++-- Declaration of record as 'inductive' or 'coinductive'.+RecordInduction :: { Ranged Induction }+RecordInduction+ : 'inductive' { Ranged (getRange $1) Inductive }+ | 'coinductive' { Ranged (getRange $1) CoInductive }++Opaque :: { Declaration }+ : 'opaque' Declarations0 { Opaque (kwRange $1) $2 }++Unfolding :: { Declaration }+ : 'unfolding' UnfoldingNames { Unfolding (kwRange $1) $2 }++UnfoldingNames :: { [QName] }+UnfoldingNames+ : QId UnfoldingNames { $1:$2 }+ | {- empty -} { [] }++-- Arbitrary declarations+Declarations :: { List1 Declaration }+Declarations+ : vopen Declarations1 close { $2 }++-- Arbitrary declarations (possibly empty)+Declarations0 :: { [Declaration] }+Declarations0+ : vopen close { [] }+ | Declarations { List1.toList $1 }++Declarations1 :: { List1 Declaration }+Declarations1+ : Declaration semi Declarations1 { $1 <> $3 }+ | Declaration vsemi { $1 } -- #3046+ | Declaration { $1 }++TopDeclarations :: { [Declaration] }+TopDeclarations+ : {- empty -} { [] }+ | Declarations1 { List1.toList $1 }++{++{--------------------------------------------------------------------------+ Parsers+ --------------------------------------------------------------------------}++-- | Parse the token stream. Used by the TeX compiler.+tokensParser :: Parser [Token]++-- | Parse an expression. Could be used in interactions.+exprParser :: Parser Expr++-- | Parse an expression followed by a where clause. Could be used in interactions.+exprWhereParser :: Parser ExprWhere++-- | Parse a module.+moduleParser :: Parser Module++-- | Parse a display pragma.+parseDisplayPragma ::+ Range -- ^ Range of the whole DISPLAY pragma.+ -> Position -- ^ Start of the name the thing we want to display.+ -> String -- ^ The DISPLAY pragma content.+ -> Parser Pragma+parseDisplayPragma r pos s =+ case parsePosString pos defaultParseFlags [normal] funclauseParser s of+ ParseOk s (FunClause defaultArgInfo (LHS lhs [] []) (RHS rhs) NoWhere ca :| []) | null (parseInp s) ->+ return $ DisplayPragma r lhs rhs+ _ -> parseError "Invalid DISPLAY pragma. Should have form {-# DISPLAY LHS = RHS #-}."++{--------------------------------------------------------------------------+ Happy stuff+ --------------------------------------------------------------------------}++-- | Required by Happy.+happyError :: Parser a+happyError = parseError ""+++{--------------------------------------------------------------------------+ Utility functions+ --------------------------------------------------------------------------}++-- Utilites have been moved to Agda.Syntax.Parser.Helpers.+--+-- Add Haskell functions used in the parser there, not here. }
@@ -1,3 +1,4 @@+{-# OPTIONS_GHC -Wunused-imports #-} {-| The code to lex string and character literals. Basically the same code as in GHC.@@ -6,9 +7,11 @@ ( litString, litChar ) where -import Control.Monad.State+import Data.Bifunctor import Data.Char+import qualified Data.Text as T +import Agda.Syntax.Common (pattern Ranged) import Agda.Syntax.Parser.Alex import Agda.Syntax.Parser.Monad import Agda.Syntax.Parser.Tokens@@ -16,17 +19,14 @@ import Agda.Syntax.Position import Agda.Syntax.Literal -import Agda.Utils.Char ( decDigit, hexDigit, octDigit )-import Agda.Utils.Tuple ( (-*-) )- {-------------------------------------------------------------------------- Exported actions --------------------------------------------------------------------------} -- | Lex a string literal. Assumes that a double quote has been lexed. litString :: LexAction Token-litString = stringToken '"' (\i s ->- return $ TokLiteral $ LitString (getRange i) s)+litString = stringToken '"' $ \ i s ->+ return $ TokLiteral $ Ranged (getRange i) $ LitString $ T.pack s {-| Lex a character literal. Assumes that a single quote has been lexed. A character literal is lexed in exactly the same way as a string literal.@@ -35,11 +35,9 @@ the other hand it will only be inefficient if there is a lexical error. -} litChar :: LexAction Token-litChar = stringToken '\'' $ \i s ->- do case s of- [c] -> return $ TokLiteral $ LitChar (getRange i) c- _ -> lexError- "character literal must contain a single character"+litChar = stringToken '\'' $ \ i -> \case+ [c] -> return $ TokLiteral $ Ranged (getRange i) $ LitChar c+ _ -> lexError "character literal must contain a single character" {--------------------------------------------------------------------------@@ -49,9 +47,9 @@ -- | Custom error function. litError :: String -> LookAhead a litError msg =- do sync- liftP $ lexError $- "Lexical error in string or character literal: " ++ msg+ do sync+ liftP $ lexError $+ "Lexical error in string or character literal: " ++ msg {--------------------------------------------------------------------------@@ -62,14 +60,14 @@ -- character argument is the delimiter (@\"@ for strings and @\'@ for -- characters). stringToken :: Char -> (Interval -> String -> Parser tok) -> LexAction tok-stringToken del mkTok inp inp' n =- do setLastPos (backupPos $ lexPos inp')+stringToken del mkTok = LexAction $ \ inp inp' n ->+ do setLastPos (backupPos $ lexPos inp') setLexInput inp' -- TODO: Should setPrevToken be run here? Compare with -- Agda.Syntax.Parser.LexActions.token.- tok <- runLookAhead litError $ lexString del ""- i <- getParseInterval- mkTok i tok+ tok <- runLookAhead litError $ lexString del ""+ i <- getParseInterval+ mkTok i tok -- | This is where the work happens. The string argument is an accumulating@@ -77,90 +75,90 @@ lexString :: Char -> String -> LookAhead String lexString del s = - do c <- nextChar- case c of+ do c <- nextChar+ case c of - c | c == del -> sync >> return (reverse s)+ c | c == del -> sync >> return (reverse s) - '\\' ->- do c' <- nextChar- case c' of- '&' -> sync >> lexString del s- c | isSpace c -> sync >> lexStringGap del s- _ -> normalChar+ '\\' ->+ do c' <- nextChar+ case c' of+ '&' -> sync >> lexString del s+ c | isSpace c -> sync >> lexStringGap del s+ _ -> normalChar - _ -> normalChar+ _ -> normalChar where- normalChar =- do rollback- c <- lexChar- lexString del (c:s)+ normalChar =+ do rollback+ c <- lexChar+ lexString del (c:s) -- | A string gap consists of whitespace (possibly including line breaks) -- enclosed in backslashes. The gap is not part of the resulting string. lexStringGap :: Char -> String -> LookAhead String lexStringGap del s =- do c <- eatNextChar- case c of- '\\' -> lexString del s- c | isSpace c -> lexStringGap del s- _ -> fail "non-space in string gap"+ do c <- eatNextChar+ case c of+ '\\' -> lexString del s+ c | isSpace c -> lexStringGap del s+ _ -> lookAheadError "non-space in string gap" -- | Lex a single character. lexChar :: LookAhead Char lexChar =- do c <- eatNextChar- case c of- '\\' -> lexEscape- _ -> return c+ do c <- eatNextChar+ case c of+ '\\' -> lexEscape+ _ -> return c -- | Lex an escaped character. Assumes the backslash has been lexed. lexEscape :: LookAhead Char lexEscape =- do c <- eatNextChar- case c of- '^' -> do c <- eatNextChar- if c >= '@' && c <= '_'- then return (chr (ord c - ord '@'))- else fail "invalid control character"+ do c <- eatNextChar+ case c of+ '^' -> do c <- eatNextChar+ if c >= '@' && c <= '_'+ then return (chr (ord c - ord '@'))+ else lookAheadError "invalid control character" - 'x' -> readNum isHexDigit 16 hexDigit- 'o' -> readNum isOctDigit 8 octDigit- x | isDigit x- -> readNumAcc isDigit 10 decDigit (decDigit x)+ 'x' -> readNum isHexDigit 16 digitToInt+ 'o' -> readNum isOctDigit 8 digitToInt+ x | isDigit x+ -> readNumAcc isDigit 10 digitToInt (digitToInt x) - c ->- -- Try to match the input (starting with c) against the- -- silly escape codes.- do esc <- match' c (map (id -*- return) sillyEscapeChars)- (fail "bad escape code")- sync- return esc+ c ->+ -- Try to match the input (starting with c) against the+ -- silly escape codes.+ do esc <- match' c (map (second return) sillyEscapeChars)+ (lookAheadError "bad escape code")+ sync+ return esc -- | Read a number in the specified base. readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> LookAhead Char readNum isDigit base conv =- do c <- eatNextChar- if isDigit c- then readNumAcc isDigit base conv (conv c)- else fail "non-digit in numeral"+ do c <- eatNextChar+ if isDigit c+ then readNumAcc isDigit base conv (conv c)+ else lookAheadError "non-digit in numeral" -- | Same as 'readNum' but with an accumulating parameter. readNumAcc :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> LookAhead Char readNumAcc isDigit base conv i = scan i where- scan i =- do inp <- getInput- c <- nextChar- case c of- c | isDigit c -> scan (i*base + conv c)- _ ->- do setInput inp- sync- if i >= ord minBound && i <= ord maxBound- then return (chr i)- else fail "character literal out of bounds"+ scan i =+ do inp <- getInput+ c <- nextChar+ case c of+ c | isDigit c -> scan (i*base + conv c)+ _ ->+ do setInput inp+ sync+ if i >= ord minBound && i <= ord maxBound+ then return (chr i)+ else lookAheadError "character literal out of bounds" -- | The escape codes. sillyEscapeChars :: [(String, Char)]
@@ -1,72 +1,166 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.Syntax.Parser.Tokens- ( Token(..)+ ( Token(.., TokQual)+ , QualifiableToken(..), QualifiedToken(..) , Keyword(..) , layoutKeywords , Symbol(..) ) where -import Agda.Syntax.Literal (Literal)-import Agda.Syntax.Concrete.Name (Name, QName)+import Data.Functor (void)++import Agda.Syntax.Literal (RLiteral) import Agda.Syntax.Position data Keyword- = KwLet | KwIn | KwWhere | KwData | KwCoData- | KwPostulate | KwMutual | KwAbstract | KwPrivate- | KwOpen | KwImport | KwModule | KwPrimitive- | KwInfix | KwInfixL | KwInfixR | KwWith | KwRewrite- | KwSet | KwProp | KwForall | KwRecord | KwConstructor | KwField- | KwHiding | KwUsing | KwRenaming | KwTo | KwPublic- | KwOPTIONS | KwBUILTIN | KwLINE- | KwCOMPILED_DATA | KwCOMPILED_TYPE | KwCOMPILED | KwCOMPILED_EPIC | KwCOMPILED_JS- | KwIMPORT | KwIMPOSSIBLE | KwETA | KwSTATIC- | KwQuoteGoal | KwQuote | KwQuoteTerm | KwUnquote | KwSyntax+ = KwLet | KwIn | KwWhere | KwData | KwCoData | KwDo+ | KwPostulate | KwAbstract | KwPrivate | KwInstance+ | KwInterleaved | KwMutual+ | KwOverlap+ | KwOpen | KwImport | KwModule | KwPrimitive | KwMacro+ | KwInfix | KwInfixL | KwInfixR | KwWith | KwRewrite+ | KwForall | KwRecord | KwConstructor | KwField+ | KwInductive | KwCoInductive+ | KwEta | KwNoEta+ | KwHiding | KwUsing | KwRenaming | KwTo | KwPublic+ | KwOpaque | KwUnfolding+ | KwOPTIONS | KwBUILTIN | KwLINE+ | KwFOREIGN | KwCOMPILE+ | KwIMPOSSIBLE | KwSTATIC | KwINJECTIVE | KwINJECTIVE_FOR_INFERENCE | KwINLINE | KwNOINLINE+ | KwETA+ | KwETA_EQUALITY+ | KwNO_TERMINATION_CHECK | KwTERMINATING | KwNON_TERMINATING+ | KwNOT_PROJECTION_LIKE+ | KwNON_COVERING+ | KwWARNING_ON_USAGE | KwWARNING_ON_IMPORT+ | KwMEASURE | KwDISPLAY+ | KwREWRITE+ | KwOVERLAPPABLE | KwOVERLAPPING | KwOVERLAPS | KwINCOHERENT+ | KwQuote | KwQuoteTerm+ | KwUnquote | KwUnquoteDecl | KwUnquoteDef+ | KwSyntax+ | KwPatternSyn | KwTactic | KwCATCHALL+ | KwVariable+ | KwNO_POSITIVITY_CHECK | KwPOLARITY+ | KwNO_UNIVERSE_CHECK deriving (Eq, Show) +-- | Unconditional layout keywords.+--+-- Some keywords introduce layout only in certain circumstances,+-- these are not included here.+-- layoutKeywords :: [Keyword] layoutKeywords =- [ KwLet, KwWhere, KwPostulate, KwMutual, KwAbstract, KwPrivate, KwPrimitive, KwField ]+ [ KwAbstract+ , KwDo+ , KwField+ , KwInstance+ , KwLet+ , KwMacro+ , KwMutual+ , KwPostulate+ , KwPrimitive+ , KwPrivate+ , KwVariable+ , KwWhere+ , KwOpaque+ ] data Symbol- = SymDot | SymSemi | SymVirtualSemi | SymBar- | SymColon | SymArrow | SymEqual | SymLambda- | SymUnderscore | SymQuestionMark | SymAs- | SymOpenParen | SymCloseParen- | SymDoubleOpenBrace | SymDoubleCloseBrace- | SymOpenBrace | SymCloseBrace- | SymOpenVirtualBrace | SymCloseVirtualBrace- | SymOpenPragma | SymClosePragma | SymEllipsis | SymDotDot- deriving (Eq, Show)+ = SymDot -- ^ @.@+ | SymSemi -- ^ @;@+ | SymVirtualSemi -- ^ layout-implied @;@+ | SymBar -- ^ @|@+ | SymColon -- ^ @:@+ | SymArrow -- ^ @->@ or @→@+ | SymEqual -- ^ @=@+ | SymLambda -- ^ @\@ or @λ@+ | SymUnderscore -- ^ @_@+ | SymQuestionMark -- ^ @?@+ | SymAs -- ^ @@@+ | SymOpenParen -- ^ @(@+ | SymCloseParen -- ^ @)@ + | SymEmptyIdiomBracket -- ^ @(|)@ or @⦇⦈@+ | SymOpenIdiomBracket Bool -- ^ @(|@ or @⦇@, 'True' if unicode+ | SymCloseIdiomBracket Bool -- ^ @|)@ or @⦈@, 'True' if unicode++ | SymDoubleOpenBrace Bool -- ^ @{{@ or @⦃@, 'True' if unicode+ | SymDoubleCloseBrace Bool -- ^ @{{@ or @⦄@, 'True' if unicode+ | SymOpenBrace -- ^ @{@+ | SymCloseBrace -- ^ @}@+ | SymOpenVirtualBrace -- ^ layout-implied @{@+ | SymCloseVirtualBrace -- ^ layout-implied @}@+ | SymOpenPragma -- ^ @{-#@+ | SymClosePragma -- ^ @#-}@+ | SymEllipsis -- ^ @...@ or @…@+ | SymDotDot -- ^ @..@+ | SymEndComment -- ^ A misplaced end-comment "-}".+ deriving (Eq, Show)++-- | "Tokens" which may appear qualified.+data QualifiableToken+ = QualDo -- ^ qualified @do@+ | QualEmptyIdiom -- ^ qualified @(|)@ or @⦇⦈@+ | QualOpenIdiom Bool -- ^ qualified @(|@ or @⦇@, 'True' if unicode+ deriving (Eq, Show)++-- | A "qualified token", i.e. a sequence of (module) names followed by+-- one of the allowed ('QualifiableToken') keywords/symbols.+data QualifiedToken+ = QualifiedToken+ QualifiableToken -- ^ The token itself.+ [(Interval, String)] -- ^ Parts for the qualifying identifier, together with their ranges.+ Interval -- ^ Range of the token being qualified.+ deriving (Eq, Show)+ data Token- -- Keywords- = TokKeyword Keyword Interval- -- Identifiers and operators- | TokId (Interval, String)- | TokQId [(Interval, String)] -- non empty namespace- -- Literals- | TokLiteral Literal- -- Special symbols- | TokSymbol Symbol Interval- -- Other tokens- | TokString (Interval, String) -- arbitrary string, used in pragmas- | TokSetN (Interval, Integer)- | TokTeX (Interval, String)+ -- Keywords+ = TokKeyword Keyword Interval+ -- Identifiers and operators+ | TokId (Interval, String)+ | TokQId [(Interval, String)]+ -- Non-empty namespace. The intervals for+ -- "A.B.x" correspond to "A.", "B." and "x".+ | TokQual_ QualifiedToken+ -- Literals+ | TokLiteral RLiteral+ -- Special symbols+ | TokSymbol Symbol Interval+ -- Other tokens+ | TokString (Interval, String)+ -- ^ Arbitrary string (not enclosed in double quotes), used in pragmas.+ | TokTeX (Interval, String)+ | TokMarkup (Interval, String) | TokComment (Interval, String)- | TokDummy -- Dummy token to make Happy not complain- -- about overlapping cases.- | TokEOF+ | TokDummy -- Dummy token to make Happy not complain+ -- about overlapping cases.+ | TokEOF Interval deriving (Eq, Show) +pattern TokQual :: QualifiableToken -> [(Interval, String)] -> Interval -> Token+pattern TokQual clz iss j = TokQual_ (QualifiedToken clz iss j)++{-# COMPLETE TokKeyword, TokId, TokQId, TokQual, TokLiteral, TokSymbol, TokString, TokTeX, TokMarkup, TokComment, TokDummy, TokEOF #-}++instance HasRange QualifiedToken where+ getRange (QualifiedToken _ iss j) = getRange (map fst iss, j)+ instance HasRange Token where getRange (TokKeyword _ i) = getRange i getRange (TokId (i, _)) = getRange i- getRange (TokQId iss) = Range $ map fst iss+ getRange (TokQId iss) = getRange (map fst iss)+ getRange (TokQual_ q) = getRange q getRange (TokLiteral lit) = getRange lit getRange (TokSymbol _ i) = getRange i getRange (TokString (i, _)) = getRange i- getRange (TokSetN (i, _)) = getRange i getRange (TokTeX (i, _)) = getRange i+ getRange (TokMarkup (i, _)) = getRange i getRange (TokComment (i, _)) = getRange i getRange TokDummy = noRange- getRange TokEOF = noRange+ getRange (TokEOF i) = getRange i++instance HasRangeWithoutFile Token where+ getRangeWithoutFile = void . getRange
@@ -1,472 +1,902 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}--{-| Position information for syntax. Crucial for giving good error messages.--}--module Agda.Syntax.Position- ( -- * Positions- Position(..)- , positionInvariant- , startPos- , movePos- , movePosByString- , backupPos-- -- * Intervals- , Interval(..)- , intervalInvariant- , takeI- , dropI-- -- * Ranges- , Range(..)- , rangeInvariant- , noRange- , posToRange- , rStart- , rEnd- , rangeToInterval- , continuous- , continuousPerLine- , HasRange(..)- , SetRange(..)- , KillRange(..)- , killRange1, killRange2, killRange3, killRange4, killRange5, killRange6, killRange7- , withRangeOf- , fuseRange- , fuseRanges- , beginningOf- , beginningOfFile-- -- * Tests- , tests- ) where--import Data.Generics (Typeable, Data)-import Data.List-import Data.Function-import Data.Set (Set, (\\))-import qualified Data.Set as Set-import Data.Int-import Agda.Utils.QuickCheck-import Control.Applicative-import Control.Monad-import Agda.Utils.FileName hiding (tests)-import Agda.Utils.TestHelpers--#include "../undefined.h"-import Agda.Utils.Impossible--{--------------------------------------------------------------------------- Types and classes- --------------------------------------------------------------------------}---- | Represents a point in the input.------ If two positions have the same 'srcFile' and 'posPos' components,--- then the final two components should be the same as well, but since--- this can be hard to enforce the program should not rely too much on--- the last two components; they are mainly there to improve error--- messages for the user.------ Note the invariant which positions have to satisfy: 'positionInvariant'.-data Position = Pn { srcFile :: Maybe AbsolutePath- -- ^ File.- , posPos :: !Int32- -- ^ Position.- , posLine :: !Int32- -- ^ Line number, counting from 1.- , posCol :: !Int32- -- ^ Column number, counting from 1.- }- deriving (Typeable, Data)--positionInvariant :: Position -> Bool-positionInvariant p =- posPos p > 0 && posLine p > 0 && posCol p > 0--importantPart p = (srcFile p, posPos p)--instance Eq Position where- (==) = (==) `on` importantPart--instance Ord Position where- compare = compare `on` importantPart---- | An interval. The @iEnd@ position is not included in the interval.------ Note the invariant which intervals have to satisfy: 'intervalInvariant'.-data Interval = Interval { iStart, iEnd :: !Position }- deriving (Typeable, Data, Eq, Ord)--intervalInvariant :: Interval -> Bool-intervalInvariant i =- all positionInvariant [iStart i, iEnd i] &&- iStart i <= iEnd i---- | The length of an interval, assuming that the start and end--- positions are in the same file.-iLength :: Interval -> Int32-iLength i = posPos (iEnd i) - posPos (iStart i)---- | A range is a list of intervals. The intervals should be--- consecutive and separated.------ Note the invariant which ranges have to satisfy: 'rangeInvariant'.-newtype Range = Range [Interval]- deriving (Typeable, Data, Eq, Ord)--rangeInvariant :: Range -> Bool-rangeInvariant (Range []) = True-rangeInvariant (Range is) =- all intervalInvariant is &&- and (zipWith (<) (map iEnd $ init is) (map iStart $ tail is))---- | Things that have a range are instances of this class.-class HasRange t where- getRange :: t -> Range--instance HasRange Interval where- getRange i = Range [i]--instance HasRange Range where- getRange = id--instance HasRange a => HasRange [a] where- getRange = foldr fuseRange noRange--instance (HasRange a, HasRange b) => HasRange (a,b) where- getRange = uncurry fuseRange--instance (HasRange a, HasRange b, HasRange c) => HasRange (a,b,c) where- getRange (x,y,z) = getRange (x,(y,z))--instance (HasRange a, HasRange b, HasRange c, HasRange d) => HasRange (a,b,c,d) where- getRange (x,y,z,w) = getRange (x,(y,(z, w)))--instance HasRange a => HasRange (Maybe a) where- getRange Nothing = noRange- getRange (Just a) = getRange a---- | If it is also possible to set the range, this is the class.------ Instances should satisfy @'getRange' ('setRange' r x) == r@.-class HasRange t => SetRange t where- setRange :: Range -> t -> t--instance SetRange Range where- setRange = const---- | Killing the range of an object sets all range information to 'noRange'.-class KillRange a where- killRange :: a -> a--killRange1 f a = f (killRange a)-killRange2 f a = killRange1 (f $ killRange a)-killRange3 f a = killRange2 (f $ killRange a)-killRange4 f a = killRange3 (f $ killRange a)-killRange5 f a = killRange4 (f $ killRange a)-killRange6 f a = killRange5 (f $ killRange a)-killRange7 f a = killRange6 (f $ killRange a)--instance KillRange Range where- killRange _ = noRange--instance KillRange a => KillRange [a] where- killRange = map killRange--instance (KillRange a, KillRange b) => KillRange (a, b) where- killRange (x, y) = (killRange x, killRange y)--instance KillRange a => KillRange (Maybe a) where- killRange = fmap killRange--instance (KillRange a, KillRange b) => KillRange (Either a b) where- killRange (Left x) = Left $ killRange x- killRange (Right x) = Right $ killRange x--{--------------------------------------------------------------------------- Pretty printing- --------------------------------------------------------------------------}--instance Show Position where- show (Pn Nothing _ l c) = show l ++ "," ++ show c- show (Pn (Just f) _ l c) = filePath f ++ ":" ++ show l ++ "," ++ show c--instance Show Interval where- show (Interval s e) = file ++ start ++ "-" ++ end- where- f = srcFile s- sl = posLine s- el = posLine e- sc = posCol s- ec = posCol e- file = case f of- Nothing -> ""- Just f -> filePath f ++ ":"- start = show sl ++ "," ++ show sc- end- | sl == el = show ec- | otherwise = show el ++ "," ++ show ec--instance Show Range where- show r = case rangeToInterval r of- Nothing -> ""- Just i -> show i--{--------------------------------------------------------------------------- Functions on postitions and ranges- --------------------------------------------------------------------------}---- | The first position in a file: position 1, line 1, column 1.-startPos :: Maybe AbsolutePath -> Position-startPos f = Pn { srcFile = f, posPos = 1, posLine = 1, posCol = 1 }---- | Ranges between two unknown positions-noRange :: Range-noRange = Range []---- | Advance the position by one character.--- A newline character (@'\n'@) moves the position to the first--- character in the next line. Any other character moves the--- position to the next column.-movePos :: Position -> Char -> Position-movePos (Pn f p l c) '\n' = Pn f (p + 1) (l + 1) 1-movePos (Pn f p l c) _ = Pn f (p + 1) l (c + 1)---- | Advance the position by a string.------ > movePosByString = foldl' movePos-movePosByString :: Position -> String -> Position-movePosByString = foldl' movePos---- | Backup the position by one character.------ Precondition: The character must not be @'\n'@.-backupPos :: Position -> Position-backupPos (Pn f p l c) = Pn f (p - 1) l (c - 1)---- | Extracts the interval corresponding to the given string, assuming--- that the string starts at the beginning of the given interval.------ Precondition: The string must not be too long for the interval.-takeI :: String -> Interval -> Interval-takeI s i | genericLength s > iLength i = __IMPOSSIBLE__- | otherwise = i { iEnd = movePosByString (iStart i) s }---- | Removes the interval corresponding to the given string from the--- given interval, assuming that the string starts at the beginning of--- the interval.------ Precondition: The string must not be too long for the interval.-dropI :: String -> Interval -> Interval-dropI s i | genericLength s > iLength i = __IMPOSSIBLE__- | otherwise = i { iStart = movePosByString (iStart i) s }---- | Converts two positions to a range.-posToRange :: Position -> Position -> Range-posToRange p1 p2 | p1 < p2 = Range [Interval p1 p2]- | otherwise = Range [Interval p2 p1]---- | Converts a range to an interval, if possible.-rangeToInterval :: Range -> Maybe Interval-rangeToInterval (Range []) = Nothing-rangeToInterval (Range is) = Just $ Interval { iStart = iStart (head is)- , iEnd = iEnd (last is)- }---- | Returns the shortest continuous range containing the given one.-continuous :: Range -> Range-continuous r = case rangeToInterval r of- Nothing -> Range []- Just i -> Range [i]---- | Removes gaps between intervals on the same line.-continuousPerLine :: Range -> Range-continuousPerLine (Range []) = Range []-continuousPerLine (Range (i:is)) = Range $ fuse i $ sortBy (compare `on` iStart) is- where- fuse i [] = [i]- fuse i (j:is)- | sameLine i j = fuse (fuseIntervals i j) is- | otherwise = i : fuse j is- sameLine i j = posLine (iEnd i) == posLine (iStart j)---- | The initial position in the range, if any.-rStart :: Range -> Maybe Position-rStart r = iStart <$> rangeToInterval r---- | The position after the final position in the range, if any.-rEnd :: Range -> Maybe Position-rEnd r = iEnd <$> rangeToInterval r---- | Finds the least interval which covers the arguments.-fuseIntervals :: Interval -> Interval -> Interval-fuseIntervals x y = Interval { iStart = head ps, iEnd = last ps }- where ps = sort [iStart x, iStart y, iEnd x, iEnd y]---- | @fuseRanges r r'@ unions the ranges @r@ and @r'@.------ Meaning it finds the least range @r0@ that covers @r@ and @r'@.-fuseRanges :: Range -> Range -> Range-fuseRanges (Range is) (Range js) = Range (helper is js)- where- helper [] js = js- helper is [] = is- helper (i:is) (j:js)- | iEnd i < iStart j = i : helper is (j:js)- | iEnd j < iStart i = j : helper (i:is) js- | iEnd i < iEnd j = helper is (fuseIntervals i j : js)- | otherwise = helper (fuseIntervals i j : is) js--fuseRange :: (HasRange u, HasRange t) => u -> t -> Range-fuseRange x y = fuseRanges (getRange x) (getRange y)---- | @beginningOf r@ is an empty range (a single, empty interval)--- positioned at the beginning of @r@. If @r@ does not have a--- beginning, then 'noRange' is returned.-beginningOf :: Range -> Range-beginningOf r = case rStart r of- Nothing -> noRange- Just pos -> posToRange pos pos---- | @beginningOfFile r@ is an empty range (a single, empty interval)--- at the beginning of @r@'s starting position's file. If there is no--- such position, then an empty range is returned.-beginningOfFile :: Range -> Range-beginningOfFile r = case rStart r of- Nothing -> noRange- Just (Pn { srcFile = f }) -> posToRange p p- where p = startPos f---- | @x `withRangeOf` y@ sets the range of @x@ to the range of @y@.-withRangeOf :: (SetRange t, HasRange u) => t -> u -> t-x `withRangeOf` y = setRange (getRange y) x----------------------------------------------------------------------------- Test suite---- | The positions corresponding to the interval, /including/ the--- end-point. This function assumes that the two end points belong to--- the same file. Note that the 'Arbitrary' instance for 'Position's--- uses a single, hard-wired file name.-iPositions :: Interval -> Set Int32-iPositions i = Set.fromList [posPos (iStart i) .. posPos (iEnd i)]---- | The positions corresponding to the range, including the--- end-points. All ranges are assumed to belong to a single file.-rPositions :: Range -> Set Int32-rPositions (Range is) = Set.unions (map iPositions is)---- | Constructs the least interval containing all the elements in the--- set.-makeInterval :: Set Int32 -> Set Int32-makeInterval s- | Set.null s = Set.empty- | otherwise = Set.fromList [Set.findMin s .. Set.findMax s]--prop_iLength i = iLength i >= 0--prop_startPos = positionInvariant . startPos--prop_noRange = rangeInvariant noRange--prop_takeI_dropI i =- forAll (choose (0, toInteger $ iLength i)) $ \n ->- let s = genericReplicate n ' '- t = takeI s i- d = dropI s i- in- intervalInvariant t &&- intervalInvariant d &&- fuseIntervals t d == i--prop_rangeToInterval (Range []) = True-prop_rangeToInterval r =- intervalInvariant i &&- iPositions i == makeInterval (rPositions r)- where Just i = rangeToInterval r--prop_continuous r =- rangeInvariant cr &&- rPositions cr == makeInterval (rPositions r)- where cr = continuous r--prop_fuseIntervals i1 =- forAll (intervalInSameFileAs i1) $ \i2 ->- let i = fuseIntervals i1 i2 in- intervalInvariant i &&- iPositions i ==- makeInterval (Set.union (iPositions i1) (iPositions i2))--prop_fuseRanges :: Range -> Range -> Bool-prop_fuseRanges r1 r2 =- rangeInvariant r &&- rPositions r == Set.union (rPositions r1) (rPositions r2)- where r = fuseRanges r1 r2--prop_beginningOf r = rangeInvariant (beginningOf r)--prop_beginningOfFile r = rangeInvariant (beginningOfFile r)--instance Arbitrary Position where- arbitrary = do- srcFile <- arbitrary- NonZero (NonNegative pos') <- arbitrary- let pos = fromInteger pos'- line = pred pos `div` 10 + 1- col = pred pos `mod` 10 + 1- return (Pn {srcFile = srcFile, posPos = pos,- posLine = line, posCol = col })---- | Sets the 'srcFile' components of the interval.--setFile :: Maybe AbsolutePath -> Interval -> Interval-setFile f (Interval p1 p2) =- Interval (p1 { srcFile = f }) (p2 { srcFile = f })---- | Generates an interval located in the same file as the given--- interval.--intervalInSameFileAs i = setFile (srcFile $ iStart i) <$> arbitrary--prop_intervalInSameFileAs i =- forAll (intervalInSameFileAs i) $ \i' ->- intervalInvariant i' &&- srcFile (iStart i) == srcFile (iStart i')--instance Arbitrary Interval where- arbitrary = do- (p1, p2) <- liftM2 (,) arbitrary arbitrary- let [p1', p2'] = sort [p1, p2 { srcFile = srcFile p1 }]- return (Interval p1' p2')--instance Arbitrary Range where- arbitrary = Range . fuse . sort . fixFiles <$> arbitrary- where- fixFiles [] = []- fixFiles (i : is) = i : map (setFile $ srcFile $ iStart i) is-- fuse (i1 : i2 : is)- | iEnd i1 >= iStart i2 = fuse (fuseIntervals i1 i2 : is)- | otherwise = i1 : fuse (i2 : is)- fuse is = is---- | Test suite.-tests :: IO Bool-tests = runTests "Agda.Syntax.Position"- [ quickCheck' positionInvariant- , quickCheck' intervalInvariant- , quickCheck' rangeInvariant- , quickCheck' prop_iLength- , quickCheck' prop_startPos- , quickCheck' prop_noRange- , quickCheck' prop_takeI_dropI- , quickCheck' prop_rangeToInterval- , quickCheck' prop_continuous- , quickCheck' prop_fuseIntervals- , quickCheck' prop_fuseRanges- , quickCheck' prop_beginningOf- , quickCheck' prop_beginningOfFile- , quickCheck' prop_intervalInSameFileAs- ]+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE UndecidableInstances #-} -- Due to KILLRANGE vararg typeclass++{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}++{-| Position information for syntax. Crucial for giving good error messages.+-}++module Agda.Syntax.Position+ ( -- * Positions+ Position+ , PositionWithoutFile+ , Position'(..)+ , pattern Pn+ , posLine+ , posCol+ , SrcFile+ , RangeFile(..)+ , mkRangeFile+ , positionInvariant+ , startPos+ , startPos'+ , movePos+ , movePosByString+ , backupPos++ -- * Intervals+ , Interval+ , IntervalWithoutFile+ , IntervalWithoutFile'+ , pattern PackIWF+ , unpackIWF+ , Interval'(Interval, iStart', iEnd')+ , intervalInvariant+ , iStart+ , iEnd+ , posToInterval+ , getIntervalFile+ , iLength+ , fuseIntervals++ -- * Ranges+ , Range+ , RangeWithoutFile+ , Range'(..)+ , rangeInvariant+ , consecutiveAndSeparated+ , intervalsToRange+ , intervalToRange+ , rangeFromAbsolutePath+ , rangeIntervals+ , rangeFile+ , rangeModule'+ , rangeModule+ , rightMargin+ , noRange+ , posToRange, posToRange'+ , rStart, rStart'+ , rEnd, rEnd'+ , rangeToInterval+ , rangeToIntervalWithFile+ , continuous+ , continuousPerLine+ , PrintRange(..)+ , HasRange(..)+ , HasRangeWithoutFile(..)+ , SetRange(..)+ , KillRange(..)+ , KillRangeT+ , killRangeMap+ , KILLRANGE(..)+ , withRangeOf+ , fuseRange+ , fuseRanges+ , beginningOf+ , beginningOfFile+ , interleaveRanges+ ) where++import Prelude hiding ( null )++import Control.DeepSeq+import Control.Monad+import Control.Monad.Writer (runWriter, tell)++import qualified Data.Foldable as Fold+import Data.Function (on)+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Sequence (Seq)+import qualified Data.Sequence as Seq+import Data.Void+import Data.Word (Word32, Word64)++import GHC.Generics (Generic)++import Agda.Syntax.TopLevelModuleName.Boot (TopLevelModuleName'(..))++import Agda.Utils.FileName+import Agda.Utils.List+import Agda.Utils.List1 (List1)+import Agda.Utils.List2 (List2)+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Map1 (Map1)+import Agda.Utils.Null+import Agda.Utils.Permutation+import Agda.Utils.Set1 (Set1)+import Agda.Utils.Set1 qualified as Set1+import Agda.Utils.TypeLevel (IsBase, All, Domains)+import Agda.Utils.Tuple (sortPair)+import Agda.Utils.Word (packW64, splitW64)+import Agda.Utils.Hash (combineWord)++import Agda.Utils.Impossible+import Data.Hashable (Hashable(..))+++{--------------------------------------------------------------------------+ Types and classes+ --------------------------------------------------------------------------}++-- | Represents a point in the input.+--+-- If two positions have the same 'srcFile' and 'posPos' components,+-- then the final two components should be the same as well, but since+-- this can be hard to enforce the program should not rely too much on+-- the last two components; they are mainly there to improve error+-- messages for the user.+--+-- Note the invariant which positions have to satisfy: 'positionInvariant'.+data Position' a = Pn'+ { srcFile :: !a+ -- ^ File.+ , posPos :: !Word32+ -- ^ Position, counting from 1.+ , posLineCol :: !Word64 -- ^ Line and position numbers as Word32, both counting from 1.+ }+ deriving (Functor, Foldable, Traversable, Generic)++instance Show a => Show (Position' a) where+ showsPrec :: Int -> Position' a -> ShowS+ showsPrec i (Pn a p l c) = showParen (i > 10) $+ showString "Pn " .+ showsPrec 11 a . showChar ' ' .+ showsPrec 11 p . showChar ' ' .+ showsPrec 11 l . showChar ' ' .+ showsPrec 11 c++pattern Pn :: a -> Word32 -> Word32 -> Word32 -> Position' a+pattern Pn a p l c <- Pn' a p (splitW64 -> (l, c)) where+ Pn a p l c = Pn' a p (packW64 l c)+{-# COMPLETE Pn #-}+{-# INLINE Pn #-}++posLine :: Position' a -> Word32+posLine (Pn' _ _ lc) = case splitW64 lc of (x, _) -> x++posCol :: Position' a -> Word32+posCol (Pn' _ _ lc) = case splitW64 lc of (_, x) -> x++positionInvariant :: Position' a -> Bool+positionInvariant p =+ posPos p > 0 && posLine p > 0 && posCol p > 0++importantPart :: Position' a -> (a, Word32)+importantPart p = (srcFile p, posPos p)++instance Eq a => Eq (Position' a) where+ (==) = (==) `on` importantPart++instance Ord a => Ord (Position' a) where+ compare = compare `on` importantPart++instance Null a => Null (Position' a) where+ null (Pn' f p lc) = null f && null p && null lc+ empty = Pn' empty 0 0++type SrcFile = Strict.Maybe RangeFile++-- | File information used in the 'Position', 'Interval' and 'Range'+-- types.+data RangeFile = RangeFile+ { rangeFilePath :: !AbsolutePath+ -- ^ The file's path.+ , rangeFileName :: !(Maybe (TopLevelModuleName' Range))+ -- ^ The file's top-level module name (if applicable).+ --+ -- This field is optional, but some things may break if the field+ -- is not instantiated with an actual top-level module name. For+ -- instance, the 'Eq' and 'Ord' instances only make use of this+ -- field.+ --+ -- The field uses 'Maybe' rather than 'Strict.Maybe' because it+ -- should be possible to instantiate it with something that is not+ -- yet defined (see 'Agda.Interaction.Imports.parseSource').+ --+ -- This '(TopLevelModuleName' Range)' should not contain a range.+ }+ deriving (Show, Generic)++-- | A smart constructor for 'RangeFile'.++mkRangeFile :: AbsolutePath -> Maybe (TopLevelModuleName' Range) -> RangeFile+mkRangeFile f top = RangeFile+ { rangeFilePath = f+ , rangeFileName = killRange top+ }++-- | Only the 'rangeFileName' component is compared.++instance Eq RangeFile where+ (==) = (==) `on` rangeFileName++-- | Only the 'rangeFileName' component is compared.++instance Ord RangeFile where+ compare = compare `on` rangeFileName++instance Null RangeFile where+ null (RangeFile file n) = null file && null n+ empty = RangeFile empty empty++instance NFData RangeFile where+ rnf (RangeFile _ n) = rnf n++type Position = Position' SrcFile+type PositionWithoutFile = Position' ()++instance NFData Position where+ rnf = (`seq` ())++instance NFData PositionWithoutFile where+ rnf = (`seq` ())++-- | An interval. The @iEnd@ position is not included in the interval.+--+-- Note the invariant which intervals have to satisfy: 'intervalInvariant'.+data Interval' a = Interval+ { getIntervalFile :: a+ , iStart' :: !PositionWithoutFile+ , iEnd' :: !PositionWithoutFile+ }+ deriving (Show, Eq, Ord, Functor, Foldable, Traversable, Generic)++type Interval = Interval' SrcFile+type IntervalWithoutFile = Interval' ()++instance NFData Interval where+ rnf = (`seq` ())++instance NFData IntervalWithoutFile where+ rnf = (`seq` ())++intervalInvariant :: Ord a => Interval' a -> Bool+intervalInvariant i = and+ [ positionInvariant $ iStart i+ , positionInvariant $ iEnd i+ , iStart i <= iEnd i+ ]++iStart :: Interval' a -> Position' a+iStart (Interval f s _) = f <$ s++iEnd :: Interval' a -> Position' a+iEnd (Interval f _ e) = f <$ e++-- | Converts a file name and two positions to an interval.+-- Sort the positions ascendingly.+posToInterval ::+ a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a+posToInterval f p1 p2 = uncurry (Interval f) $ sortPair (p1, p2)++-- | The length of an interval.+iLength :: Interval' a -> Word32+iLength i = posPos (iEnd i) - posPos (iStart i)++-- | Tolerably efficient representation of 'IntervalWithoutFile'+data IntervalWithoutFile' = IWF !Word64 !Word64 !Word64+ deriving (Eq)++instance NFData IntervalWithoutFile' where+ rnf x = seq x ()++instance Hashable IntervalWithoutFile' where+ hashWithSalt h (IWF a b c) = fromIntegral $+ fromIntegral h `combineWord` fromIntegral a+ `combineWord` fromIntegral b+ `combineWord` fromIntegral c++pattern PackIWF :: IntervalWithoutFile -> IntervalWithoutFile'+pattern PackIWF x <- ((\(IWF ps lc0 lc1) -> case splitW64 ps of+ (p0, p1) -> Interval () (Pn' () p0 lc0) (Pn' () p1 lc1)) -> x) where+ PackIWF (Interval _ (Pn' _ p0 lc0) (Pn' _ p1 lc1)) = IWF (packW64 p0 p1) lc0 lc1+{-# INLINE PackIWF #-}+{-# COMPLETE PackIWF #-}++unpackIWF :: IntervalWithoutFile' -> IntervalWithoutFile+unpackIWF (PackIWF x) = x++instance Ord IntervalWithoutFile' where+ compare (PackIWF x) (PackIWF y) = compare x y++instance Show IntervalWithoutFile' where+ showsPrec i (PackIWF x) = showsPrec i x++-- | A range is a file name, plus a sequence of intervals, assumed to+-- point to the given file. The intervals should be consecutive and+-- separated.+--+-- Note the invariant which ranges have to satisfy: 'rangeInvariant'.+data Range' a+ = NoRange+ | Range !a (Seq IntervalWithoutFile')+ deriving+ (Show, Eq, Ord, Functor, Foldable, Traversable, Generic)++-- TODO: custom Eq, Ord, Hashable using better Seq functions++type Range = Range' SrcFile+type RangeWithoutFile = Range' ()++instance NFData a => NFData (Range' a)++instance Null (Range' a) where+ null NoRange = True+ null Range{} = False++ empty = NoRange++instance Eq a => Semigroup (Range' a) where+ NoRange <> r = r+ r <> NoRange = r+ Range f is <> Range f' is'+ | f /= f' = __IMPOSSIBLE__+ | otherwise = Range f (is <> is')++instance Eq a => Monoid (Range' a) where+ mempty = empty+ mappend = (<>)++-- TODO: efficient Seq function++-- | The intervals that make up the range. The intervals are+-- consecutive and separated ('consecutiveAndSeparated').+rangeIntervals' :: Range' a -> [IntervalWithoutFile']+rangeIntervals' NoRange = []+rangeIntervals' (Range _ is) = Fold.toList is++-- | The intervals that make up the range. The intervals are+-- consecutive and separated ('consecutiveAndSeparated').+rangeIntervals :: Range' a -> [IntervalWithoutFile]+rangeIntervals NoRange = []+rangeIntervals (Range _ is) = map unpackIWF $ Fold.toList is++-- | Turns a file name plus a list of intervals into a range.+--+-- Precondition: 'consecutiveAndSeparated'.+intervalsToRange :: a -> [IntervalWithoutFile] -> Range' a+intervalsToRange _ [] = NoRange+intervalsToRange f is = Range f (Seq.fromList $ map PackIWF is)++-- | Are the intervals consecutive and separated, do they all point to+-- the same file, and do they satisfy the interval invariant?+consecutiveAndSeparated :: Ord a => [Interval' a] -> Bool+consecutiveAndSeparated is =+ all intervalInvariant is+ &&+ allEqual (map (srcFile . iStart) is)+ &&+ allConsecutive (\ i j -> iEnd i < iStart j) is++-- | Range invariant.+rangeInvariant :: Range' a -> Bool+rangeInvariant r =+ consecutiveAndSeparated (rangeIntervals r)+ &&+ case r of+ Range _ is -> not (null is)+ NoRange -> True++-- | The file the range is pointing to.+rangeFile :: Range -> SrcFile+rangeFile NoRange = Strict.Nothing+rangeFile (Range f _) = f++-- | The range's top-level module name, if any.+--+-- If there is no range, then 'Nothing' is returned. If there is a+-- range without a module name, then @'Just' 'Nothing'@ is returned.+rangeModule' :: Range -> Maybe (Maybe (TopLevelModuleName' Range))+rangeModule' NoRange = Nothing+rangeModule' (Range f _) = Just $ case f of+ Strict.Nothing -> Nothing+ Strict.Just f -> rangeFileName f++-- | The range's top-level module name, if any.+rangeModule :: Range -> Maybe (TopLevelModuleName' Range)+rangeModule = join . rangeModule'++-- | Conflate a range to its right margin.+rightMargin :: Range -> Range+rightMargin r@NoRange = r+rightMargin (Range f is) = case Seq.viewr is of+ Seq.EmptyR -> __IMPOSSIBLE__+ _ Seq.:> PackIWF (Interval () _s e) -> intervalToRange f (Interval () e e)++-- | Wrapper to indicate that range should be printed.+newtype PrintRange a = PrintRange a+ deriving (Eq, Ord, HasRange, SetRange, KillRange)++-- | Things that have a range are instances of this class.+class HasRange a where+ getRange :: a -> Range++ default getRange :: (Foldable t, HasRange b, t b ~ a) => a -> Range+ getRange = Fold.foldr fuseRange noRange+ {-# INLINABLE getRange #-}++instance HasRange Interval where+ getRange (Interval f p1 p2) = intervalToRange f (Interval () p1 p2)++instance HasRange Range where+ getRange = id++instance HasRange () where+ getRange _ = noRange++instance HasRange Bool where+ getRange _ = noRange++instance HasRange (TopLevelModuleName' Range) where+ getRange = moduleNameRange++instance SetRange (TopLevelModuleName' Range) where+ setRange r (TopLevelModuleName _ h x z) = TopLevelModuleName r h x z++instance KillRange (TopLevelModuleName' Range) where+ killRange (TopLevelModuleName _ h x z) = TopLevelModuleName noRange h x z++-- | Precondition: The ranges of the list elements must point to the+-- same file (or be empty).+instance HasRange a => HasRange [a]++-- | Precondition: The ranges of the list elements must point to the+-- same file (or be empty).+instance HasRange a => HasRange (List1 a)+instance HasRange a => HasRange (List2 a)+instance HasRange a => HasRange (Maybe a)+instance HasRange a => HasRange (Set1 a)++-- | Precondition: The ranges of the tuple elements must point to the+-- same file (or be empty).+instance (HasRange a, HasRange b) => HasRange (a,b) where+ getRange = uncurry fuseRange++-- | Precondition: The ranges of the tuple elements must point to the+-- same file (or be empty).+instance (HasRange a, HasRange b, HasRange c) => HasRange (a,b,c) where+ getRange (x,y,z) = getRange (x,(y,z))++-- | Precondition: The ranges of the tuple elements must point to the+-- same file (or be empty).+instance (HasRange a, HasRange b, HasRange c, HasRange d) => HasRange (a,b,c,d) where+ getRange (x,y,z,w) = getRange (x,(y,(z,w)))++-- | Precondition: The ranges of the tuple elements must point to the+-- same file (or be empty).+instance (HasRange a, HasRange b, HasRange c, HasRange d, HasRange e) => HasRange (a,b,c,d,e) where+ getRange (x,y,z,w,v) = getRange (x,(y,(z,(w,v))))++-- | Precondition: The ranges of the tuple elements must point to the+-- same file (or be empty).+instance (HasRange a, HasRange b, HasRange c, HasRange d, HasRange e, HasRange f) => HasRange (a,b,c,d,e,f) where+ getRange (x,y,z,w,v,u) = getRange (x,(y,(z,(w,(v,u)))))++-- | Precondition: The ranges of the tuple elements must point to the+-- same file (or be empty).+instance (HasRange a, HasRange b, HasRange c, HasRange d, HasRange e, HasRange f, HasRange g) => HasRange (a,b,c,d,e,f,g) where+ getRange (x,y,z,w,v,u,t) = getRange (x,(y,(z,(w,(v,(u,t))))))++instance (HasRange a, HasRange b) => HasRange (Either a b) where+ getRange = either getRange getRange++-- | Things that have a 'RangeWithoutFile' are instances of this class.++class HasRangeWithoutFile a where+ getRangeWithoutFile :: a -> RangeWithoutFile++ default getRangeWithoutFile :: (Foldable t, HasRangeWithoutFile b, t b ~ a) => a -> RangeWithoutFile+ getRangeWithoutFile = Fold.foldr fuseRangeWithoutFile noRange+ {-# INLINABLE getRangeWithoutFile #-}++instance HasRangeWithoutFile IntervalWithoutFile where+ getRangeWithoutFile = intervalToRange ()++instance HasRangeWithoutFile RangeWithoutFile where+ getRangeWithoutFile = id++instance HasRangeWithoutFile Range where+ getRangeWithoutFile = void . getRange++instance HasRangeWithoutFile () where+ getRangeWithoutFile _ = noRange++instance HasRangeWithoutFile Bool where+ getRangeWithoutFile _ = noRange++-- UNUSED:+-- instance HasRangeWithoutFile (TopLevelModuleName' RangeWithoutFile) where+-- getRangeWithoutFile = moduleNameRange++instance HasRangeWithoutFile a => HasRangeWithoutFile [a]+instance HasRangeWithoutFile a => HasRangeWithoutFile (List1 a)+instance HasRangeWithoutFile a => HasRangeWithoutFile (List2 a)+instance HasRangeWithoutFile a => HasRangeWithoutFile (Maybe a)+instance HasRangeWithoutFile a => HasRangeWithoutFile (Set1 a)++instance (HasRangeWithoutFile a, HasRangeWithoutFile b) => HasRangeWithoutFile (a,b) where+ getRangeWithoutFile = uncurry fuseRangeWithoutFile++instance (HasRangeWithoutFile a, HasRangeWithoutFile b, HasRangeWithoutFile c) => HasRangeWithoutFile (a,b,c) where+ getRangeWithoutFile (x,y,z) = getRangeWithoutFile (x,(y,z))++instance (HasRangeWithoutFile a, HasRangeWithoutFile b, HasRangeWithoutFile c, HasRangeWithoutFile d) => HasRangeWithoutFile (a,b,c,d) where+ getRangeWithoutFile (x,y,z,w) = getRangeWithoutFile (x,(y,(z,w)))++instance (HasRangeWithoutFile a, HasRangeWithoutFile b, HasRangeWithoutFile c, HasRangeWithoutFile d, HasRangeWithoutFile e) => HasRangeWithoutFile (a,b,c,d,e) where+ getRangeWithoutFile (x,y,z,w,v) = getRangeWithoutFile (x,(y,(z,(w,v))))++instance (HasRangeWithoutFile a, HasRangeWithoutFile b, HasRangeWithoutFile c, HasRangeWithoutFile d, HasRangeWithoutFile e, HasRangeWithoutFile f) => HasRangeWithoutFile (a,b,c,d,e,f) where+ getRangeWithoutFile (x,y,z,w,v,u) = getRangeWithoutFile (x,(y,(z,(w,(v,u)))))++instance (HasRangeWithoutFile a, HasRangeWithoutFile b, HasRangeWithoutFile c, HasRangeWithoutFile d, HasRangeWithoutFile e, HasRangeWithoutFile f, HasRangeWithoutFile g) => HasRangeWithoutFile (a,b,c,d,e,f,g) where+ getRangeWithoutFile (x,y,z,w,v,u,t) = getRangeWithoutFile (x,(y,(z,(w,(v,(u,t))))))++instance (HasRangeWithoutFile a, HasRangeWithoutFile b) => HasRangeWithoutFile (Either a b) where+ getRangeWithoutFile = either getRangeWithoutFile getRangeWithoutFile++-- | If it is also possible to set the range, this is the class.+--+-- Instances should satisfy @'getRange' ('setRange' r x) == r@.+class HasRange a => SetRange a where+ setRange :: Range -> a -> a++ default setRange :: (Functor f, SetRange b, f b ~ a) => Range -> a -> a+ setRange = fmap . setRange++instance SetRange Range where+ setRange = const++instance SetRange a => SetRange [a]+instance SetRange a => SetRange (Maybe a)++-- | Killing the range of an object sets all range information to 'noRange'.+class KillRange a where+ killRange :: KillRangeT a++ default killRange :: (Functor f, KillRange b, f b ~ a) => KillRangeT a+ killRange = fmap killRange++type KillRangeT a = a -> a++class KILLRANGE t b where+ killRangeN :: IsBase t ~ b => All KillRange (Domains t) =>+ t -> t++instance IsBase t ~ 'True => KILLRANGE t 'True where+ {-# INLINE killRangeN #-}+ killRangeN v = v++instance KILLRANGE t (IsBase t) => KILLRANGE (a -> t) 'False where+ {-# INLINE killRangeN #-}+ killRangeN f a = killRangeN (f (killRange a))++-- | Remove ranges in keys and values of a map.+killRangeMap :: (KillRange k, KillRange v) => KillRangeT (Map k v)+killRangeMap = Map.mapKeysMonotonic killRange . Map.map killRange++instance KillRange Range where+ killRange _ = noRange++instance KillRange Void where+ killRange = id++instance KillRange () where+ killRange = id++instance KillRange Bool where+ killRange = id++instance KillRange Int where+ killRange = id++instance KillRange Integer where+ killRange = id++instance KillRange Permutation where+ killRange = id++-- | Overlaps with @KillRange [a]@.+instance {-# OVERLAPPING #-} KillRange String where+ killRange = id++instance {-# OVERLAPPABLE #-} KillRange a => KillRange [a]+instance {-# OVERLAPPABLE #-} KillRange a => KillRange (Map k a)+instance {-# OVERLAPPABLE #-} KillRange a => KillRange (Map1 k a)++instance KillRange a => KillRange (Drop a)+instance KillRange a => KillRange (List1 a)+instance KillRange a => KillRange (List2 a)+instance KillRange a => KillRange (Maybe a)+instance KillRange a => KillRange (Strict.Maybe a)++instance {-# OVERLAPPABLE #-} (Ord a, KillRange a) => KillRange (Set a) where+ killRange = Set.map killRange++instance (Ord a, KillRange a) => KillRange (Set1 a) where+ killRange = Set1.map killRange++instance (KillRange a, KillRange b) => KillRange (a, b) where+ killRange (x, y) = (killRange x, killRange y)++instance (KillRange a, KillRange b, KillRange c) =>+ KillRange (a, b, c) where+ killRange (x, y, z) = killRangeN (,,) x y z++instance (KillRange a, KillRange b, KillRange c, KillRange d) =>+ KillRange (a, b, c, d) where+ killRange (x, y, z, u) = killRangeN (,,,) x y z u++instance (KillRange a, KillRange b) => KillRange (Either a b) where+ killRange (Left x) = Left $ killRange x+ killRange (Right x) = Right $ killRange x++{--------------------------------------------------------------------------+ Functions on positions and ranges+ --------------------------------------------------------------------------}++-- | The first position in a file: position 1, line 1, column 1.+startPos' :: a -> Position' a+startPos' f = Pn f 1 1 1++-- | The first position in a file: position 1, line 1, column 1.+startPos :: Maybe RangeFile -> Position+startPos = startPos' . Strict.toStrict++-- | Range pointing to the first position in the given file.+rangeFromAbsolutePath :: AbsolutePath -> Range+rangeFromAbsolutePath f = posToRange' src p0 p0+ where+ src = Strict.Just $ mkRangeFile f Nothing+ p0 = startPos' ()++-- | Ranges between two unknown positions+noRange :: Range' a+noRange = NoRange++-- | Advance the position by one character.+-- A newline character (@'\n'@) moves the position to the first+-- character in the next line. Any other character moves the+-- position to the next column.+movePos :: Position' a -> Char -> Position' a+movePos (Pn f p l _) '\n' = Pn f (p + 1) (l + 1) 1+movePos (Pn f p l c) _ = Pn f (p + 1) l (c + 1)++-- | Advance the position by a string.+--+-- > movePosByString = foldl' movePos+movePosByString :: Foldable t => Position' a -> t Char -> Position' a+movePosByString = Fold.foldl' movePos++-- | Backup the position by one character.+--+-- Precondition: The character must not be @'\n'@.+backupPos :: Position' a -> Position' a+backupPos (Pn f p l c) = Pn f (p - 1) l (c - 1)++-- | Converts a file name and two positions to a range.+posToRange' ::+ a -> PositionWithoutFile -> PositionWithoutFile -> Range' a+posToRange' f p1 p2 = intervalToRange f (posToInterval () p1 p2)++-- | Converts two positions to a range.+--+-- Precondition: The positions have to point to the same file.+posToRange :: Position' a -> Position' b -> Range' a+posToRange p1 p2 =+ posToRange' (srcFile p1) (p1 { srcFile = () }) (p2 { srcFile = () })++-- | Converts a file name and an interval to a range.+intervalToRange :: a -> IntervalWithoutFile -> Range' a+intervalToRange f i = Range f (Seq.singleton (PackIWF i))++-- | Converts a range to an interval, if possible.+rangeToIntervalWithFile :: Range' a -> Maybe (Interval' a)+rangeToIntervalWithFile NoRange = Nothing+rangeToIntervalWithFile (Range f is) =+ case (Seq.viewl is, Seq.viewr is) of+ (PackIWF head Seq.:< _, _ Seq.:> PackIWF last) -> Just $ Interval f (iStart head) (iEnd last)+ _ -> __IMPOSSIBLE__++-- | Converts a range to an interval, if possible.+-- Note that the information about the source file is lost.+rangeToInterval :: Range' a -> Maybe IntervalWithoutFile+rangeToInterval = rangeToIntervalWithFile . void++-- | Returns the shortest continuous range containing the given one.+continuous :: Range' a -> Range' a+continuous NoRange = NoRange+continuous r@(Range f _) =+ maybe __IMPOSSIBLE__ (intervalToRange f) $ rangeToInterval r++-- | Removes gaps between intervals on the same line.+continuousPerLine :: Range' a -> Range' a+continuousPerLine r@NoRange = r+continuousPerLine r@(Range f _) =+ Range f (Seq.unfoldr step (rangeIntervals' r))+ where+ step :: [IntervalWithoutFile'] -> Maybe (IntervalWithoutFile', [IntervalWithoutFile'])+ step [] = Nothing+ step [i] = Just (i, [])+ step (pi@(PackIWF i) : is@(PackIWF j : js))+ | sameLine = let !ij = PackIWF (fuseIntervals i j) in step (ij : js)+ | otherwise = Just (pi, is)+ where+ sameLine = posLine (iEnd i) == posLine (iStart j)++-- | The initial position in the range, if any.+rStart' :: Range' a -> Maybe PositionWithoutFile+rStart' r = iStart <$> rangeToInterval r++-- | The initial position in the range, if any.+rStart :: Range' a -> Maybe (Position' a)+rStart NoRange = Nothing+rStart r@(Range f _) = (\p -> p { srcFile = f }) <$> rStart' r++-- | The position after the final position in the range, if any.+rEnd' :: Range' a -> Maybe PositionWithoutFile+rEnd' r = iEnd <$> rangeToInterval r++-- | The position after the final position in the range, if any.+rEnd :: Range' a -> Maybe (Position' a)+rEnd NoRange = Nothing+rEnd r@(Range f _) = (\p -> p { srcFile = f }) <$> rEnd' r++-- | Finds the least interval which covers the arguments.+--+fuseIntervals :: IntervalWithoutFile -> IntervalWithoutFile -> IntervalWithoutFile+fuseIntervals (Interval () s1 e1) (Interval () s2 e2) = Interval () (min s1 s2) (max e1 e2)++-- | @fuseRanges r r'@ unions the ranges @r@ and @r'@.+--+-- Meaning it finds the least range @r0@ that covers @r@ and @r'@.+--+-- Precondition: The ranges must point to the same file (or be empty).+fuseRanges :: Range' a -> Range' a -> Range' a+fuseRanges NoRange is2 = is2+fuseRanges is1 NoRange = is1+fuseRanges (Range f is1) (Range _ is2) = Range f (fuse is1 is2)+ where+ fuse :: Seq IntervalWithoutFile' -> Seq IntervalWithoutFile' -> Seq IntervalWithoutFile'+ fuse is1 is2 = case (Seq.viewl is1, Seq.viewr is1,+ Seq.viewl is2, Seq.viewr is2) of+ (Seq.EmptyL, _, _, _) -> is2+ (_, _, Seq.EmptyL, _) -> is1+ (PackIWF s1 Seq.:< r1, l1 Seq.:> PackIWF e1, PackIWF s2 Seq.:< r2, l2 Seq.:> PackIWF e2)+ -- Special cases.+ | iEnd e1 < iStart s2 -> is1 Seq.>< is2+ | iEnd e2 < iStart s1 -> is2 Seq.>< is1+ | iEnd e1 == iStart s2 -> mergeTouching l1 e1 s2 r2+ | iEnd e2 == iStart s1 -> mergeTouching l2 e2 s1 r1+ -- General cases.+ | iEnd s1 < iStart s2 -> outputLeftPrefix s1 r1 s2 is2+ | iEnd s2 < iStart s1 -> outputLeftPrefix s2 r2 s1 is1+ | iEnd s1 < iEnd s2 -> fuseSome s1 r1 s2 r2+ | otherwise -> fuseSome s2 r2 s1 r1+ _ -> __IMPOSSIBLE__++ mergeTouching l e s r = l Seq.>< i Seq.<| r+ where+ !i = PackIWF (Interval () (iStart e) (iEnd s))++ -- The following two functions could use binary search instead of+ -- linear.+ outputLeftPrefix :: IntervalWithoutFile -> Seq IntervalWithoutFile' -> IntervalWithoutFile -> Seq IntervalWithoutFile'+ -> Seq IntervalWithoutFile'+ outputLeftPrefix s1 r1 s2 is2 = s1' Seq.<| r1' Seq.>< fuse r1'' is2+ where+ !s1' = PackIWF s1+ (!r1', !r1'') = Seq.spanl (\(PackIWF s) -> iEnd s < iStart s2) r1++ fuseSome :: IntervalWithoutFile -> Seq IntervalWithoutFile' -> IntervalWithoutFile -> Seq IntervalWithoutFile'+ -> Seq IntervalWithoutFile'+ fuseSome s1 r1 s2 r2 = fuse r1' (s12 Seq.<| r2)+ where+ !s12 = PackIWF (fuseIntervals s1 s2)+ !r1' = Seq.dropWhileL (\(PackIWF s) -> iEnd s <= iEnd s2) r1++{-# INLINE fuseRange #-}+-- | Precondition: The ranges must point to the same file (or be+-- empty).+fuseRange :: (HasRange u, HasRange t) => u -> t -> Range+fuseRange x y = fuseRanges (getRange x) (getRange y)++{-# INLINE fuseRangeWithoutFile #-}+-- | Precondition: The ranges must point to the same file (or be+-- empty).+fuseRangeWithoutFile :: (HasRangeWithoutFile u, HasRangeWithoutFile t) => u -> t -> RangeWithoutFile+fuseRangeWithoutFile x y = fuseRanges (getRangeWithoutFile x) (getRangeWithoutFile y)++-- | @beginningOf r@ is an empty range (a single, empty interval)+-- positioned at the beginning of @r@. If @r@ does not have a+-- beginning, then 'noRange' is returned.+beginningOf :: Range -> Range+beginningOf NoRange = NoRange+beginningOf r@(Range f _) = case rStart' r of+ Nothing -> __IMPOSSIBLE__+ Just pos -> posToRange' f pos pos++class BeginningOfFile a where+ -- | Return an empty range (a single, empty interval) at the beginning of the file.+ beginningOfFile :: a -> Range++instance BeginningOfFile SrcFile where+ beginningOfFile f = posToRange' f p p+ where p = startPos' ()++instance BeginningOfFile RangeFile where+ beginningOfFile = beginningOfFile . Strict.Just++instance BeginningOfFile AbsolutePath where+ beginningOfFile f = beginningOfFile $ mkRangeFile f Nothing++-- | @beginningOfFile r@ is an empty range (a single, empty interval)+-- at the beginning of @r@'s starting position's file. If there is no+-- such position, then an empty range is returned.+instance BeginningOfFile Range where+ beginningOfFile :: Range -> Range+ beginningOfFile NoRange = NoRange+ beginningOfFile (Range f _) = posToRange' f p p+ where p = startPos' ()++-- | @x \`withRangeOf\` y@ sets the range of @x@ to the range of @y@.+withRangeOf :: (SetRange t, HasRange u) => t -> u -> t+x `withRangeOf` y = setRange (getRange y) x++-- | Interleaves two streams of ranged elements+--+-- It will report the conflicts as a list of conflicting pairs.+-- In case of conflict, the element with the earliest start position+-- is placed first. In case of a tie, the element with the earliest+-- ending position is placed first. If both tie, the element from the+-- first list is placed first.+interleaveRanges :: forall a. (HasRangeWithoutFile a) => [a] -> [a] -> ([a], [(a,a)])+interleaveRanges as bs = runWriter $ go as bs+ where+ go [] as = return as+ go as [] = return as+ go as@(a:as') bs@(b:bs') =+ let ra = getRangeWithoutFile a+ rb = getRangeWithoutFile b++ ra0 = rStart ra+ rb0 = rStart rb++ ra1 = rEnd ra+ rb1 = rEnd rb+ in+ if ra1 <= rb0 then+ (a:) <$> go as' bs+ else if rb1 <= ra0 then+ (b:) <$> go as bs'+ else do+ tell [(a,b)]+ if ra0 < rb0 || (ra0 == rb0 && ra1 <= rb1) then+ (a:) <$> go as' bs+ else+ (b:) <$> go as bs'++-- Hashable instances++instance Hashable RangeFile where+ {-# INLINE hashWithSalt #-}+ hashWithSalt h (RangeFile x y) = h `hashWithSalt` x `hashWithSalt` y++instance Hashable a => Hashable (Position' a) where+ {-# INLINE hashWithSalt #-}+ hashWithSalt h (Pn' a b c) =+ fromIntegral (fromIntegral (hashWithSalt h a) `combineWord` fromIntegral b `combineWord` fromIntegral c)++instance Hashable a => Hashable (Interval' a) where+ {-# INLINE hashWithSalt #-}+ hashWithSalt h (Interval a b c) = h `hashWithSalt` a `hashWithSalt` b `hashWithSalt` c++instance Hashable a => Hashable (Range' a) where+ {-# INLINE hashWithSalt #-}+ hashWithSalt h = \case+ NoRange -> h + 1+ Range a b -> h + 2 `hashWithSalt` a `hashWithSalt` b
@@ -0,0 +1,3 @@+module Agda.Syntax.Position where++class KillRange a
@@ -0,0 +1,77 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}+{-# OPTIONS_GHC -Wunused-binds #-}++module Agda.Syntax.Reflected where++import Data.Text (Text)++import Agda.Syntax.Common+import Agda.Syntax.Literal+import Agda.Syntax.Abstract.Name+import Agda.Syntax.Internal (Dom)++import Agda.Utils.List1 (List1)++type Args = [Arg Term]++data Elim' a = Apply (Arg a) -- no record projections for now+ deriving (Show)+type Elim = Elim' Term+type Elims = [Elim]++argsToElims :: Args -> Elims+argsToElims = map Apply++data Abs a = Abs String a+ deriving (Show)++data Term = Var Int Elims+ | Con QName Elims+ | Def QName Elims+ | Meta MetaId Elims+ | Lam Hiding (Abs Term)+ | ExtLam (List1 Clause) Elims+ | Pi (Dom Type) (Abs Type)+ | Sort Sort+ | Lit Literal+ | Unknown+ deriving (Show)++type Type = Term++data Sort = SetS Term+ | LitS Integer+ | PropS Term+ | PropLitS Integer+ | InfS Integer+ | UnknownS+ deriving (Show)++data Pattern = ConP QName [Arg Pattern]+ | DotP Term+ | VarP Int+ | LitP Literal+ | AbsurdP Int+ | ProjP QName+ deriving (Show)++data Clause+ = Clause+ { clauseTel :: [(Text, Arg Type)]+ , clausePats :: [Arg Pattern]+ , clauseRHS :: Term+ }+ | AbsurdClause+ { clauseTel :: [(Text, Arg Type)]+ , clausePats :: [Arg Pattern]+ }+ deriving (Show)++data Definition = FunDef Type [Clause]+ | DataDef -- nothing for now+ | RecordDef -- nothing for now+ | DataConstructor+ | Axiom+ | Primitive+ deriving (Show)
@@ -1,608 +1,1743 @@-{-# LANGUAGE CPP, DeriveDataTypeable, GADTs, ScopedTypeVariables, TupleSections #-}--{-| This module defines the notion of a scope and operations on scopes.--}-module Agda.Syntax.Scope.Base where--import Control.Arrow ((***), (&&&))-import Control.Applicative-import Data.Generics (Typeable, Data)-import Data.List-import Data.Map (Map)-import qualified Data.Map as Map-import Data.Function--import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Abstract.Name as A-import Agda.Syntax.Concrete.Name as C-import Agda.Syntax.Concrete- (ImportDirective(..), UsingOrHiding(..), ImportedName(..), Renaming(..))-import qualified Agda.Utils.Map as Map-import Agda.Utils.Tuple-import Agda.Utils.List--#include "../../undefined.h"-import Agda.Utils.Impossible---- * Scope representation---- | A scope is a named collection of names partitioned into public and private--- names.-data Scope = Scope- { scopeName :: A.ModuleName- , scopeParents :: [A.ModuleName]- , scopeNameSpaces :: [(NameSpaceId, NameSpace)]- , scopeImports :: Map C.QName A.ModuleName- }- deriving (Typeable, Data)--data NameSpaceId = PrivateNS | PublicNS | ImportedNS | OnlyQualifiedNS- deriving (Typeable, Data, Eq, Bounded, Enum)--localNameSpace :: Access -> NameSpaceId-localNameSpace PublicAccess = PublicNS-localNameSpace PrivateAccess = PrivateNS-localNameSpace OnlyQualified = OnlyQualifiedNS--nameSpaceAccess :: NameSpaceId -> Access-nameSpaceAccess PrivateNS = PrivateAccess-nameSpaceAccess _ = PublicAccess--scopeNameSpace :: NameSpaceId -> Scope -> NameSpace-scopeNameSpace ns s = maybe __IMPOSSIBLE__ id $ lookup ns $ scopeNameSpaces s---- | The complete information about the scope at a particular program point--- includes the scope stack, the local variables, and the context precedence.-data ScopeInfo = ScopeInfo- { scopeCurrent :: A.ModuleName- , scopeModules :: Map A.ModuleName Scope- , scopeLocals :: LocalVars- , scopePrecedence :: Precedence- }- deriving (Typeable, Data)---- | Local variables-type LocalVars = [(C.Name, A.Name)]---- | A @NameSpace@ contains the mappings from concrete names that the user can--- write to the abstract fully qualified names that the type checker wants to--- read.-data NameSpace = NameSpace- { nsNames :: NamesInScope- , nsModules :: ModulesInScope- }- deriving (Typeable, Data)--type ThingsInScope a = Map C.Name [a]-type NamesInScope = ThingsInScope AbstractName-type ModulesInScope = ThingsInScope AbstractModule--data InScopeTag a where- NameTag :: InScopeTag AbstractName- ModuleTag :: InScopeTag AbstractModule--class Eq a => InScope a where- inScopeTag :: InScopeTag a--inNameSpace :: forall a. InScope a => NameSpace -> ThingsInScope a-inNameSpace = case inScopeTag :: InScopeTag a of- NameTag -> nsNames- ModuleTag -> nsModules--instance KillRange ScopeInfo where- killRange m = m--instance InScope AbstractName where- inScopeTag = NameTag--instance InScope AbstractModule where- inScopeTag = ModuleTag---- | We distinguish constructor names from other names.-data KindOfName = ConName | DefName- deriving (Eq, Show, Typeable, Data)---- | Apart from the name, we also record whether it's a constructor or not and--- what the fixity is.-data AbstractName = AbsName- { anameName :: A.QName- , anameKind :: KindOfName- }- deriving (Typeable, Data)---- | For modules we record the arity. I'm not sure that it's every used anywhere.-data AbstractModule = AbsModule- { amodName :: A.ModuleName- }- deriving (Typeable, Data)--instance Eq AbstractName where- (==) = (==) `on` anameName--instance Ord AbstractName where- compare = compare `on` anameName--instance Eq AbstractModule where- (==) = (==) `on` amodName--instance Ord AbstractModule where- compare = compare `on` amodName--instance Show ScopeInfo where- show (ScopeInfo this mods locals ctx) =- unlines $- [ "ScopeInfo"- , " current = " ++ show this- ] ++- (if null locals then [] else [ " locals = " ++ show locals ]) ++- [ " context = " ++ show ctx- , " modules"- ] ++ map (" "++) (relines . map show $ Map.elems mods)- where- relines = filter (not . null) . lines . unlines--blockOfLines :: String -> [String] -> [String]-blockOfLines _ [] = []-blockOfLines hd ss = hd : map (" "++) ss--instance Show Scope where- show (scope @ Scope { scopeName = name, scopeParents = parents, scopeImports = imps }) =- unlines $- [ "* scope " ++ show name ] ++ ind (- concat [ blockOfLines (show nsid) (lines $ show $ scopeNameSpace nsid scope)- | nsid <- [minBound..maxBound] ]- ++ blockOfLines "imports" (case Map.keys imps of- [] -> []- ks -> [ show ks ]- )- )- where ind = map (" " ++)--instance Show NameSpaceId where- show nsid = case nsid of- PublicNS -> "public"- PrivateNS -> "private"- ImportedNS -> "imported"- OnlyQualifiedNS -> "only-qualified"--instance Show NameSpace where- show (NameSpace names mods) =- unlines $- blockOfLines "names" (map pr $ Map.toList names) ++- blockOfLines "modules" (map pr $ Map.toList mods)- where- pr :: (Show a, Show b) => (a,b) -> String- pr (x, y) = show x ++ " --> " ++ show y--instance Show AbstractName where- show = show . anameName--instance Show AbstractModule where- show = show . amodName---- * Operations on names--instance HasRange AbstractName where- getRange = getRange . anameName--instance SetRange AbstractName where- setRange r x = x { anameName = setRange r $ anameName x }---- * Operations on name and module maps.--mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a-mergeNames = Map.unionWith union---- * Operations on name spaces---- | The empty name space.-emptyNameSpace :: NameSpace-emptyNameSpace = NameSpace Map.empty Map.empty----- | Map functions over the names and modules in a name space.-mapNameSpace :: (NamesInScope -> NamesInScope ) ->- (ModulesInScope -> ModulesInScope) ->- NameSpace -> NameSpace-mapNameSpace fd fm ns =- ns { nsNames = fd $ nsNames ns- , nsModules = fm $ nsModules ns- }---- | Zip together two name spaces.-zipNameSpace :: (NamesInScope -> NamesInScope -> NamesInScope ) ->- (ModulesInScope -> ModulesInScope -> ModulesInScope) ->- NameSpace -> NameSpace -> NameSpace-zipNameSpace fd fm ns1 ns2 =- ns1 { nsNames = nsNames ns1 `fd` nsNames ns2- , nsModules = nsModules ns1 `fm` nsModules ns2- }---- | Map monadic function over a namespace.-mapNameSpaceM :: Monad m =>- (NamesInScope -> m NamesInScope ) ->- (ModulesInScope -> m ModulesInScope) ->- NameSpace -> m NameSpace-mapNameSpaceM fd fm ns = do- ds <- fd $ nsNames ns- ms <- fm $ nsModules ns- return $ ns { nsNames = ds, nsModules = ms }---- * General operations on scopes---- | The empty scope.-emptyScope :: Scope-emptyScope = Scope { scopeName = noModuleName- , scopeParents = []- , scopeNameSpaces = [ (nsid, emptyNameSpace) | nsid <- [minBound..maxBound] ]- , scopeImports = Map.empty- }---- | The empty scope info.-emptyScopeInfo :: ScopeInfo-emptyScopeInfo = ScopeInfo- { scopeCurrent = noModuleName- , scopeModules = Map.singleton noModuleName emptyScope- , scopeLocals = []- , scopePrecedence = TopCtx- }---- | Map functions over the names and modules in a scope.-mapScope :: (NameSpaceId -> NamesInScope -> NamesInScope ) ->- (NameSpaceId -> ModulesInScope -> ModulesInScope) ->- Scope -> Scope-mapScope fd fm s =- s { scopeNameSpaces = [ (nsid, mapNS nsid ns) | (nsid, ns) <- scopeNameSpaces s ] }- where- mapNS acc = mapNameSpace (fd acc) (fm acc)---- | Same as 'mapScope' but applies the same function to all name spaces.-mapScope_ :: (NamesInScope -> NamesInScope ) ->- (ModulesInScope -> ModulesInScope) ->- Scope -> Scope-mapScope_ fd fm = mapScope (const fd) (const fm)---- | Map monadic functions over the names and modules in a scope.-mapScopeM :: (Functor m, Monad m) =>- (NameSpaceId -> NamesInScope -> m NamesInScope ) ->- (NameSpaceId -> ModulesInScope -> m ModulesInScope) ->- Scope -> m Scope-mapScopeM fd fm s = do- nss <- sequence [ (,) nsid <$> mapNS nsid ns | (nsid, ns) <- scopeNameSpaces s ]- return $ s { scopeNameSpaces = nss }- where- mapNS acc = mapNameSpaceM (fd acc) (fm acc)---- | Same as 'mapScopeM' but applies the same function to both the public and--- private name spaces.-mapScopeM_ :: (Functor m, Monad m) =>- (NamesInScope -> m NamesInScope ) ->- (ModulesInScope -> m ModulesInScope) ->- Scope -> m Scope-mapScopeM_ fd fm = mapScopeM (const fd) (const fm)---- | Zip together two scopes. The resulting scope has the same name as the--- first scope.-zipScope :: (NameSpaceId -> NamesInScope -> NamesInScope -> NamesInScope ) ->- (NameSpaceId -> ModulesInScope -> ModulesInScope -> ModulesInScope) ->- Scope -> Scope -> Scope-zipScope fd fm s1 s2 =- s1 { scopeNameSpaces = [ (nsid, zipNS nsid ns1 ns2)- | ((nsid, ns1), (nsid', ns2)) <- zipWith' (,) (scopeNameSpaces s1) (scopeNameSpaces s2)- , assert (nsid == nsid')- ]- , scopeImports = Map.union (scopeImports s1) (scopeImports s2)- }- where- assert True = True- assert False = __IMPOSSIBLE__- zipNS acc = zipNameSpace (fd acc) (fm acc)---- | Same as 'zipScope' but applies the same function to both the public and--- private name spaces.-zipScope_ :: (NamesInScope -> NamesInScope -> NamesInScope ) ->- (ModulesInScope -> ModulesInScope -> ModulesInScope) ->- Scope -> Scope -> Scope-zipScope_ fd fm = zipScope (const fd) (const fm)---- | Filter a scope keeping only concrete names matching the predicates.--- The first predicate is applied to the names and the second to the modules.-filterScope :: (C.Name -> Bool) -> (C.Name -> Bool) -> Scope -> Scope-filterScope pd pm = mapScope_ (Map.filterKeys pd) (Map.filterKeys pm)---- | Return all names in a scope.-allNamesInScope :: InScope a => Scope -> ThingsInScope a-allNamesInScope = namesInScope [minBound..maxBound]--allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access)-allNamesInScope' s =- foldr1 mergeNames [ map (, nameSpaceAccess ns) <$> namesInScope [ns] s- | ns <- [minBound..maxBound] ]---- | Returns the scope's non-private names.-exportedNamesInScope :: InScope a => Scope -> ThingsInScope a-exportedNamesInScope = namesInScope [PublicNS, ImportedNS, OnlyQualifiedNS]--namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a-namesInScope ids s =- foldr1 mergeNames [ inNameSpace (scopeNameSpace nsid s) | nsid <- ids ]--allThingsInScope :: Scope -> NameSpace-allThingsInScope = thingsInScope [minBound..maxBound]--thingsInScope :: [NameSpaceId] -> Scope -> NameSpace-thingsInScope fs s =- NameSpace { nsNames = namesInScope fs s- , nsModules = namesInScope fs s- }---- | Merge two scopes. The result has the name of the first scope.-mergeScope :: Scope -> Scope -> Scope-mergeScope = zipScope_ mergeNames mergeNames---- | Merge a non-empty list of scopes. The result has the name of the first--- scope in the list.-mergeScopes :: [Scope] -> Scope-mergeScopes [] = __IMPOSSIBLE__-mergeScopes ss = foldr1 mergeScope ss---- * Specific operations on scopes---- | Move all names in a scope to the given name space (except never move from--- Imported to Public).-setScopeAccess :: NameSpaceId -> Scope -> Scope-setScopeAccess a s = s { scopeNameSpaces = [ (nsid, ns nsid) | (nsid, _) <- scopeNameSpaces s ]- }- where- zero = emptyNameSpace- one = allThingsInScope s- imp = thingsInScope [ImportedNS] s- noimp = thingsInScope [PublicNS, PrivateNS, OnlyQualifiedNS] s-- ns b = case (a, b) of- (PublicNS, PublicNS) -> noimp- (PublicNS, ImportedNS) -> imp- _ | a == b -> one- | otherwise -> zero--setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope-setNameSpace nsid ns s =- s { scopeNameSpaces = [ (nsid', if nsid == nsid' then ns else ns')- | (nsid', ns') <- scopeNameSpaces s ] }---- | Add names to a scope.-addNamesToScope :: NameSpaceId -> C.Name -> [AbstractName] -> Scope -> Scope-addNamesToScope acc x ys s = mergeScope s s1- where- s1 = setScopeAccess acc $ setNameSpace PublicNS ns emptyScope- ns = emptyNameSpace { nsNames = Map.singleton x ys }---- | Add a name to a scope.-addNameToScope :: NameSpaceId -> C.Name -> AbstractName -> Scope -> Scope-addNameToScope acc x y s = addNamesToScope acc x [y] s---- | Add a module to a scope.-addModuleToScope :: NameSpaceId -> C.Name -> AbstractModule -> Scope -> Scope-addModuleToScope acc x m s = mergeScope s s1- where- s1 = setScopeAccess acc $ setNameSpace PublicNS ns emptyScope- ns = emptyNameSpace { nsModules = Map.singleton x [m] }---- | Apply an 'ImportDirective' to a scope.-applyImportDirective :: ImportDirective -> Scope -> Scope-applyImportDirective dir s = mergeScope usedOrHidden renamed- where- usedOrHidden = useOrHide (hideLHS (renaming dir) $ usingOrHiding dir) s- renamed = rename (renaming dir) $ useOrHide useRenamedThings s-- useRenamedThings = Using $ map renFrom $ renaming dir-- hideLHS :: [Renaming] -> UsingOrHiding -> UsingOrHiding- hideLHS _ i@(Using _) = i- hideLHS ren (Hiding xs) = Hiding $ xs ++ map renFrom ren-- useOrHide :: UsingOrHiding -> Scope -> Scope- useOrHide (Hiding xs) s = filterNames notElem notElem xs s- useOrHide (Using xs) s = filterNames elem elem xs s-- filterNames :: (C.Name -> [C.Name] -> Bool) -> (C.Name -> [C.Name] -> Bool) ->- [ImportedName] -> Scope -> Scope- filterNames pd pm xs = filterScope' (flip pd ds) (flip pm ms)- where- ds = [ x | ImportedName x <- xs ]- ms = [ m | ImportedModule m <- xs ]-- filterScope' pd pm = filterScope pd pm-- -- Renaming- rename :: [Renaming] -> Scope -> Scope- rename rho = mapScope_ (Map.mapKeys $ ren drho)- (Map.mapKeys $ ren mrho)- where- mrho = [ (x, y) | Renaming { renFrom = ImportedModule x, renTo = y } <- rho ]- drho = [ (x, y) | Renaming { renFrom = ImportedName x, renTo = y } <- rho ]-- ren r x = maybe x id $ lookup x r---- | Rename the abstract names in a scope.-renameCanonicalNames :: Map A.QName A.QName -> Map A.ModuleName A.ModuleName ->- Scope -> Scope-renameCanonicalNames renD renM = mapScope_ renameD renameM- where- renameD = Map.map (map $ onName rD)- renameM = Map.map (map $ onMName rM)-- onName f x = x { anameName = f $ anameName x }- onMName f x = x { amodName = f $ amodName x }-- rD x = maybe x id $ Map.lookup x renD- rM x = maybe x id $ Map.lookup x renM---- | Restrict the private name space of a scope-restrictPrivate :: Scope -> Scope-restrictPrivate s = setNameSpace PrivateNS emptyNameSpace $ s { scopeImports = Map.empty }---- | Remove names that can only be used qualified (when opening a scope)-removeOnlyQualified :: Scope -> Scope-removeOnlyQualified s = setNameSpace OnlyQualifiedNS emptyNameSpace s---- | Get the public parts of the public modules of a scope-publicModules :: ScopeInfo -> Map A.ModuleName Scope-publicModules scope = Map.filterWithKey (\m _ -> reachable m) allMods- where- allMods = Map.map restrictPrivate $ scopeModules scope- root = scopeCurrent scope- modules s = map amodName $ concat $ Map.elems $ allNamesInScope s-- chase m = m : case Map.lookup m allMods of- Just s -> concatMap chase $ modules s- Nothing -> __IMPOSSIBLE__-- reachable = (`elem` chase root)--everythingInScope :: ScopeInfo -> NameSpace-everythingInScope scope =- allThingsInScope- $ mergeScopes- [ s | (m, s) <- Map.toList (scopeModules scope), m `elem` current ]- where- this = scopeCurrent scope- parents = case Map.lookup this (scopeModules scope) of- Just s -> scopeParents s- Nothing -> __IMPOSSIBLE__- current = this : parents---- | Look up a name in the scope-scopeLookup :: InScope a => C.QName -> ScopeInfo -> [a]-scopeLookup q scope = map fst $ scopeLookup' q scope--scopeLookup' :: forall a. InScope a => C.QName -> ScopeInfo -> [(a, Access)]-scopeLookup' q scope = nubBy ((==) `on` fst) $ findName q root ++ imports- where- this :: A.ModuleName- this = scopeCurrent scope-- current :: Scope- current = moduleScope this-- root :: Scope- root = mergeScopes $ current : map moduleScope (scopeParents current)-- tag = inScopeTag :: InScopeTag a-- splitName :: C.QName -> [(C.QName, C.QName)]- splitName (C.QName x) = []- splitName (C.Qual x q) = (C.QName x, q) : do- (m, r) <- splitName q- return (C.Qual x m, r)-- imported :: C.QName -> [(A.ModuleName, Access)]- imported q = maybe [] ((:[]) . (, PublicAccess)) $ Map.lookup q $ scopeImports root-- topImports :: [(a, Access)]- topImports = case tag of- NameTag -> []- ModuleTag -> map (AbsModule *** id) (imported q)-- imports :: [(a, Access)]- imports = topImports ++ do- (m, x) <- splitName q- m <- fst <$> imported m- findName x (restrictPrivate $ moduleScope m)-- moduleScope :: A.ModuleName -> Scope- moduleScope name = case Map.lookup name (scopeModules scope) of- Nothing -> __IMPOSSIBLE__- Just s -> s-- lookupName :: forall a. InScope a => C.Name -> Scope -> [(a, Access)]- lookupName x s = maybe [] id $ Map.lookup x (allNamesInScope' s)-- findName :: forall a. InScope a => C.QName -> Scope -> [(a, Access)]- findName (C.QName x) s = lookupName x s- findName (C.Qual x q) s = do- m <- nub $ mods ++ defs -- record types will appear bot as a mod and a def- Just s' <- return $ Map.lookup m (scopeModules scope)- findName q (restrictPrivate s')- where- mods, defs :: [ModuleName]- mods = amodName . fst <$> lookupName x s- -- Qualified constructors are qualified by their datatype rather than a module- defs = mnameFromList . qnameToList . anameName . fst <$> lookupName x s---- * Inverse look-up---- | Find the shortest concrete name that maps (uniquely) to a given abstract--- name.-inverseScopeLookup :: Either A.ModuleName A.QName -> ScopeInfo -> Maybe C.QName-inverseScopeLookup name scope = case name of- Left m -> best $ filter unambiguousModule $ findModule m- Right q -> best $ filter unambiguousName $ findName nameMap q- where- this = scopeCurrent scope- current = this : scopeParents (moduleScope this)- scopes = [ (m, restrict m s) | (m, s) <- Map.toList (scopeModules scope) ]-- moduleScope name = case Map.lookup name (scopeModules scope) of- Nothing -> __IMPOSSIBLE__- Just s -> s-- restrict m s | m `elem` current = s- | otherwise = restrictPrivate s-- len :: C.QName -> Int- len (C.QName _) = 1- len (C.Qual _ x) = 1 + len x-- best xs = case sortBy (compare `on` len) xs of- [] -> Nothing- x : _ -> Just x-- unique :: forall a . [a] -> Bool- unique [] = __IMPOSSIBLE__- unique [_] = True- unique (_:_:_) = False-- unambiguousModule q = unique (scopeLookup q scope :: [AbstractModule])- unambiguousName q = unique xs || all ((ConName ==) . anameKind) xs- where xs = scopeLookup q scope-- findName :: Ord a => Map a [(A.ModuleName, C.Name)] -> a -> [C.QName]- findName table q = do- (m, x) <- maybe [] id $ Map.lookup q table- if m `elem` current- then return (C.QName x)- else do- y <- findModule m- return $ C.qualify y x-- findModule :: A.ModuleName -> [C.QName]- findModule q = findName moduleMap q ++- maybe [] id (Map.lookup q importMap)-- importMap = Map.unionsWith (++) $ do- (m, s) <- scopes- (x, y) <- Map.toList $ scopeImports s- return $ Map.singleton y [x]-- moduleMap = Map.unionsWith (++) $ do- (m, s) <- scopes- (x, ms) <- Map.toList (allNamesInScope s)- q <- amodName <$> ms- return $ Map.singleton q [(m, x)]-- nameMap = Map.unionsWith (++) $ do- (m, s) <- scopes- (x, ms) <- Map.toList (allNamesInScope s)- q <- anameName <$> ms- return $ Map.singleton q [(m, x)]---- | Takes the first component of 'inverseScopeLookup'.-inverseScopeLookupName :: A.QName -> ScopeInfo -> Maybe C.QName-inverseScopeLookupName x = inverseScopeLookup (Right x)---- | Takes the second component of 'inverseScopeLookup'.-inverseScopeLookupModule :: A.ModuleName -> ScopeInfo -> Maybe C.QName-inverseScopeLookupModule x = inverseScopeLookup (Left x)++{-| This module defines the notion of a scope and operations on scopes.+-}+module Agda.Syntax.Scope.Base where++import Prelude hiding ( null, length )++import Control.DeepSeq+import Control.Monad++import Data.Either ( partitionEithers )+import Data.Foldable ( length, toList, foldl' )+import Data.Function ( on )+import Data.HashMap.Strict ( HashMap )+import Data.HashMap.Strict qualified as HMap+import Data.Hashable ( Hashable, hashWithSalt )+import Data.IntMap ( IntMap )+import Data.List qualified as List+import Data.Map.Strict ( Map )+import Data.Map.Strict qualified as Map+import Data.Maybe+import Data.Ord ( Down(..) )++import GHC.Generics (Generic)++import Agda.Benchmarking++import Agda.Syntax.Abstract.Name as A+import Agda.Syntax.Common+import Agda.Syntax.Concrete qualified as C+import Agda.Syntax.Concrete.Fixity as C+import Agda.Syntax.Concrete.Name as C+import Agda.Syntax.Fixity+import Agda.Syntax.Position++import Agda.Syntax.Common.Pretty+import Agda.Utils.AssocList ( AssocList )+import Agda.Utils.AssocList qualified as AssocList+import Agda.Utils.Function ( applyWhen, applyUnless )+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|) )+import Agda.Utils.List1 qualified as List1+import Agda.Utils.List2 ( List2 )+import Agda.Utils.List2 qualified as List2+import Agda.Utils.Map qualified as Map+import Agda.Utils.Maybe ( predicateToMaybe )+import Agda.Utils.Null+import Agda.Utils.Set ( Set )+import Agda.Utils.Set qualified as Set+import Agda.Utils.Set1 ( Set1 )+import Agda.Utils.Singleton+import Agda.Utils.StrictState2 qualified as St2+import Agda.Utils.Tuple ( first, second )+import Agda.Utils.Tuple.Strict ( (&!&) )++import Agda.Utils.Impossible++-- * Scope representation++-- | A scope is a named collection of names partitioned into public and private+-- names.+data Scope = Scope+ { scopeName :: A.ModuleName+ , scopeParents :: [A.ModuleName]+ , scopeNameSpaces :: ScopeNameSpaces+ , scopeImports :: Map C.QName A.ModuleName+ , scopeDatatypeModule :: Maybe DataOrRecordModule+ }+ deriving (Eq, Show, Generic)++data DataOrRecordModule+ = IsDataModule+ | IsRecordModule+ deriving (Show, Eq, Enum, Bounded, Generic)++-- | See 'Agda.Syntax.Common.Access'.+data NameSpaceId+ = PrivateNS -- ^ Things not exported by this module.+ | PublicNS -- ^ Things defined and exported by this module.+ | ImportedNS -- ^ Things from open public, exported by this module.+ deriving (Eq, Bounded, Enum, Show, Generic)++allNameSpaces :: [NameSpaceId]+allNameSpaces = [minBound..maxBound]++type ScopeNameSpaces = [(NameSpaceId, NameSpace)]++localNameSpace :: Access -> NameSpaceId+localNameSpace PublicAccess = PublicNS+localNameSpace PrivateAccess{} = PrivateNS++nameSpaceAccess :: NameSpaceId -> Access+nameSpaceAccess PrivateNS = privateAccessInserted+nameSpaceAccess _ = PublicAccess++-- | Get a 'NameSpace' from 'Scope'.+scopeNameSpace :: NameSpaceId -> Scope -> NameSpace+scopeNameSpace ns = fromMaybe __IMPOSSIBLE__ . lookup ns . scopeNameSpaces++-- | A lens for 'scopeNameSpaces'+updateScopeNameSpaces :: (ScopeNameSpaces -> ScopeNameSpaces) -> Scope -> Scope+updateScopeNameSpaces f s = s { scopeNameSpaces = f (scopeNameSpaces s) }++-- | ``Monadic'' lens (Functor sufficient).+updateScopeNameSpacesM ::+ (Functor m) => (ScopeNameSpaces -> m ScopeNameSpaces) -> Scope -> m Scope+updateScopeNameSpacesM f s = for (f $ scopeNameSpaces s) $ \ x ->+ s { scopeNameSpaces = x }++-- | The complete information about the scope at a particular program point+-- includes the scope stack, the local variables, and the context precedence.+data ScopeInfo = ScopeInfo+ { _scopeCurrent :: A.ModuleName+ , _scopeModules :: Map A.ModuleName Scope+ , _scopeVarsToBind :: LocalVars -- ^ The variables that will be bound at the end+ -- of the current block of variables (i.e. clause).+ -- We collect them here instead of binding them+ -- immediately so we can avoid shadowing between+ -- variables in the same variable block.+ , _scopeLocals :: LocalVars+ , _scopePrecedence :: !PrecedenceStack+ , _scopeInverseName :: NameMap+ , _scopeInverseModule :: ModuleMap+ , _scopeInScope :: InScopeSet+ , _scopeFixities :: C.Fixities -- ^ Maps concrete names C.Name to fixities+ , _scopePolarities :: C.Polarities -- ^ Maps concrete names C.Name to polarities+ }+ deriving (Show, Generic)++-- | For the sake of highlighting, the '_scopeInverseName' map also stores+-- the 'KindOfName' of an @A.QName@.+data NameMapEntry = NameMapEntry+ { qnameKind :: !KindOfName -- ^ The 'anameKind'.+ , qnameConcrete :: !(List1 C.QName) -- ^ Possible renderings of the abstract name.+ }+ deriving (Show, Generic)++-- | Invariant: the 'KindOfName' components should be equal+-- whenever we have two concrete renderings of an abstract name.+instance Semigroup NameMapEntry where+ NameMapEntry k xs <> NameMapEntry _ ys = NameMapEntry k (xs <> ys)++type NameMap = HashMap NameId NameMapEntry+type ModuleMap = HashMap A.ModuleName [C.QName]++instance Eq ScopeInfo where+ ScopeInfo c1 m1 v1 l1 p1 _ _ _ _ _ == ScopeInfo c2 m2 v2 l2 p2 _ _ _ _ _ =+ c1 == c2 && m1 == m2 && v1 == v2 && l1 == l2 && p1 == p2++-- | Local variables.+type LocalVars = AssocList C.Name LocalVar++-- | For each bound variable, we want to know whether it was bound by a+-- λ, Π, module telescope, pattern, or @let@.+data BindingSource+ = LambdaBound+ -- ^ @λ@ (currently also used for @Π@ and module parameters)+ | PatternBound Hiding+ -- ^ @f ... =@.+ -- Remember 'Hiding' for pattern variables @{x}@ and @{{x}}@.+ -- This information is only used for checking pattern synonyms.+ -- It is not serialized.+ | LetBound+ -- ^ @let ... in@+ | WithBound+ -- ^ @| ... in q@+ | MacroBound+ -- ^ Binding added to scope by one of context-manipulating reflection primitives+ deriving (Show, Eq, Generic)++instance Pretty BindingSource where+ pretty = \case+ LambdaBound -> "local"+ PatternBound _ -> "pattern"+ LetBound -> "let-bound"+ WithBound -> "with-bound"+ MacroBound -> "macro-bound"+-- | A local variable can be shadowed by an import.+-- In case of reference to a shadowed variable, we want to report+-- a scope error.+data LocalVar = LocalVar+ { localVar :: A.Name+ -- ^ Unique ID of local variable.+ , localBindingSource :: BindingSource+ -- ^ Kind of binder used to introduce the variable (@λ@, @let@, ...).+ , localShadowedBy :: [AbstractName]+ -- ^ If this list is not empty, the local variable is+ -- shadowed by one or more imports.+ }+ deriving (Show, Generic)++instance Eq LocalVar where+ (==) = (==) `on` localVar++instance Ord LocalVar where+ compare = compare `on` localVar++-- | We show shadowed variables as prefixed by a ".", as not in scope.+instance Pretty LocalVar where+ pretty (LocalVar x _ []) = pretty x+ pretty (LocalVar x _ xs) = "." <> pretty x++-- | Shadow a local name by a non-empty list of imports.+shadowLocal :: List1 AbstractName -> LocalVar -> LocalVar+shadowLocal ys (LocalVar x b zs) = LocalVar x b (List1.toList ys ++! zs)++-- | Treat patternBound variable as a module parameter+patternToModuleBound :: LocalVar -> LocalVar+patternToModuleBound x+ | PatternBound _ <- localBindingSource x =+ x { localBindingSource = LambdaBound }+ | otherwise = x++-- | Project name of unshadowed local variable.+notShadowedLocal :: LocalVar -> Maybe A.Name+notShadowedLocal (LocalVar x _ []) = Just x+notShadowedLocal _ = Nothing++-- | Get all locals that are not shadowed __by imports__.+notShadowedLocals :: LocalVars -> AssocList C.Name A.Name+notShadowedLocals = mapMaybe $ \ (c,x) -> (c,) <$> notShadowedLocal x++-- | Lenses for ScopeInfo components+scopeCurrent :: Lens' ScopeInfo A.ModuleName+scopeCurrent f s =+ f (_scopeCurrent s) <&>+ \x -> s { _scopeCurrent = x }++scopeModules :: Lens' ScopeInfo (Map A.ModuleName Scope)+scopeModules f s =+ f (_scopeModules s) <&>+ \x -> s { _scopeModules = x }++scopeVarsToBind :: Lens' ScopeInfo LocalVars+scopeVarsToBind f s =+ f (_scopeVarsToBind s) <&>+ \x -> s { _scopeVarsToBind = x }++scopeLocals :: Lens' ScopeInfo LocalVars+scopeLocals f s =+ f (_scopeLocals s) <&>+ \x -> s { _scopeLocals = x }++scopePrecedence :: Lens' ScopeInfo PrecedenceStack+scopePrecedence f s =+ f (_scopePrecedence s) <&>+ \x -> s { _scopePrecedence = x }++scopeInverseName :: Lens' ScopeInfo NameMap+scopeInverseName f s =+ f (_scopeInverseName s) <&>+ \x -> s { _scopeInverseName = x }++scopeInverseModule :: Lens' ScopeInfo ModuleMap+scopeInverseModule f s =+ f (_scopeInverseModule s) <&>+ \x -> s { _scopeInverseModule = x }++scopeInScope :: Lens' ScopeInfo InScopeSet+scopeInScope f s =+ f (_scopeInScope s) <&>+ \x -> s { _scopeInScope = x }++scopeFixities :: Lens' ScopeInfo C.Fixities+scopeFixities f s =+ f (_scopeFixities s) <&>+ \x -> s { _scopeFixities = x }++scopePolarities :: Lens' ScopeInfo C.Polarities+scopePolarities f s =+ f (_scopePolarities s) <&>+ \x -> s { _scopePolarities = x }++scopeFixitiesAndPolarities :: Lens' ScopeInfo (C.Fixities, C.Polarities)+scopeFixitiesAndPolarities f s =+ f' (_scopeFixities s) (_scopePolarities s) <&>+ \ (fixs, pols) -> s { _scopeFixities = fixs, _scopePolarities = pols }+ where+ -- Andreas, 2019-08-18: strict matching avoids space leak, see #1829.+ f' !fixs !pols = f (fixs, pols)+ -- Andrea comments on https://github.com/agda/agda/issues/1829#issuecomment-522312084+ -- on a naive version without the bang patterns:+ --+ -- useScope (because of useR) forces the result of projecting the+ -- lens, this usually prevents retaining the whole structure when we+ -- only need a field. However your combined lens adds an extra layer+ -- of laziness with the pairs, so the actual projections remain+ -- unforced.+ --+ -- I guess scopeFixitiesAndPolarities could add some strictness when building the pair?++-- | Lens for 'scopeVarsToBind'.+updateVarsToBind :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo+updateVarsToBind = over scopeVarsToBind++setVarsToBind :: LocalVars -> ScopeInfo -> ScopeInfo+setVarsToBind = set scopeVarsToBind++-- | Lens for 'scopeLocals'.+updateScopeLocals :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo+updateScopeLocals = over scopeLocals++setScopeLocals :: LocalVars -> ScopeInfo -> ScopeInfo+setScopeLocals = set scopeLocals++------------------------------------------------------------------------+-- * Name spaces+--+-- Map concrete names to lists of abstract names.+------------------------------------------------------------------------++-- | A @NameSpace@ contains the mappings from concrete names that the user can+-- write to the abstract fully qualified names that the type checker wants to+-- read.+data NameSpace = NameSpace+ { nsNames :: NamesInScope+ -- ^ Maps concrete names to a list of abstract names.+ -- If this is part of a scope produced by an 'ImportDirective',+ -- the concrete names should (where possible) match those of the directive.+ -- E.g., if the directive mentions @using (x)@, then the concrete @x@+ -- in the map should be this @x@ rather then the @x@ from the original+ -- scope that is restricted by the import directive.+ -- This is important for the highlighting of the 'UnusedImports' warning.+ , nsNameParts :: NamePartsInScope+ -- ^ Maps name parts to a list of abstract names in which the name+ -- part occurs.+ , nsModules :: ModulesInScope+ -- ^ Maps concrete module names to a list of abstract module names.+ , nsInScope :: InScopeSet+ -- ^ All abstract names targeted by a concrete name in scope.+ -- Computed by 'recomputeInScopeSets'.+ }+ deriving (Eq, Show, Generic)++type ThingsInScope a = Map C.Name (List1 a)+type NamesInScope = ThingsInScope AbstractName+type NamePartsInScope = Map RawName NamesInScope+type ModulesInScope = ThingsInScope AbstractModule+type InScopeSet = Set A.QName++-- | Set of types consisting of exactly 'AbstractName' and 'AbstractModule'.+--+-- A GADT just for some dependent-types trickery.+data InScopeTag a where+ NameTag :: InScopeTag AbstractName+ ModuleTag :: InScopeTag AbstractModule++-- | Type class for some dependent-types trickery.+class Ord a => InScope a where+ inScopeTag :: InScopeTag a++instance InScope AbstractName where+ inScopeTag = NameTag++instance InScope AbstractModule where+ inScopeTag = ModuleTag++-- | @inNameSpace@ selects either the name map or the module name map from+-- a 'NameSpace'. What is selected is determined by result type+-- (using the dependent-type trickery).+inNameSpace :: forall a. InScope a => NameSpace -> ThingsInScope a+inNameSpace = case inScopeTag :: InScopeTag a of+ NameTag -> nsNames+ ModuleTag -> nsModules++-- | Non-dependent tag for name or module.+data NameOrModule = NameNotModule | ModuleNotName+ deriving (Eq, Ord, Show, Enum, Bounded, Generic)++------------------------------------------------------------------------+-- * Operator parsing+------------------------------------------------------------------------++-- | Names that are relevant to operator parsing.+data OperatorScope = OpScope {+ osHasOps :: !Bool -- ^ Are there any operators or notations in scope?+ , osScope :: (Map C.QName (List1 AbstractName)) -- ^ All relevant names in global scope.+ , osLocals :: !(AssocList C.Name A.Name) -- ^ Relevant names in local scope.+ } deriving (Eq, Show, Generic)++instance Null OperatorScope where+ empty = OpScope empty empty empty++instance Pretty OperatorScope where+ prettyPrec x (OpScope _ scope locals) = prettyPrec x (scope, locals)++instance NFData OperatorScope++------------------------------------------------------------------------+-- * Live names and copy trimming+------------------------------------------------------------------------++-- | A set of module and definition names that were explicitly referred+-- to during scope checking.+data LiveNames =+ -- | We encountered these names during scope-checking, so they should+ -- be preserved.+ SomeLiveNames+ { liveModules :: !(Set ModuleName)+ , liveNames :: !(Set A.QName)+ }+ -- | An interaction point can see this copy, so we should preserve+ -- every name.+ | AllLiveNames+ deriving (Eq)++instance Semigroup LiveNames where+ SomeLiveNames a b <> SomeLiveNames a' b' = SomeLiveNames (a <> a') (b <> b')+ SomeLiveNames{} <> AllLiveNames = AllLiveNames+ AllLiveNames <> _ = AllLiveNames++instance Monoid LiveNames where+ mempty = SomeLiveNames mempty mempty++instance Pretty LiveNames where+ pretty AllLiveNames = "*"+ pretty (SomeLiveNames mod name) = braces $ vcat+ [ "mods: " <+> pretty mod+ , "names:" <+> pretty name+ ]++-- | Is the given name alive in this set?+--+-- Note: a qualified name can be kept alive by liveness of any of the+-- modules it belongs to.+isNameAlive :: A.QName -> LiveNames -> Bool+isNameAlive _ AllLiveNames = True+isNameAlive qn@(A.QName mod _) live@(SomeLiveNames mods names)+ | qn `Set.member` names = True+ | otherwise = isModuleAlive mod live++-- | Is the given module (or one of its parents) a member of the set?+isModuleAlive :: A.ModuleName -> LiveNames -> Bool+isModuleAlive _ AllLiveNames = True+isModuleAlive (A.MName mod) (SomeLiveNames mods _) =+ any ((`Set.member` mods) . A.MName) (List.inits mod)++------------------------------------------------------------------------+-- * Unused imports+------------------------------------------------------------------------++-- | Information gathered during scope checking for the unused-imports warning+-- when a module is opened.+data OpenedModule = OpenedModule+ { openedRange :: KwRange+ -- ^ 'Range' of the @open@ keyword.+ , openedModule :: A.ModuleName+ -- ^ Module we opened.+ , openedParent :: A.ModuleName+ -- ^ Parent module into which we merged the opened module.+ , openedHasDir :: Bool+ -- ^ Whether the @open@ statement comes with @using@ or @renaming@.+ , openedNameScope :: NamesInScope+ -- ^ The names imported by the @open@ statement.+ -- The keys ('C.Name') of this map should be the concrete names of+ -- the opening directive, if such was given.+ , openedModuleScope :: ModulesInScope+ -- ^ The modules imported by the @open@ statement.+ -- The keys ('C.Name') of this map should be the concrete names of+ -- the opening directive, if such was given.+ , openedCompanions :: Set C.Name+ -- ^ Modules among 'openedModuleScope' that accompany a name+ -- in 'openedNameScope' (e.g. the module of a data type or record type)+ -- and are not mentioned explicitly in the opening directive.+ -- These are not reported individually when unused.+ } deriving (Generic)++instance Null OpenedModule where+ empty = OpenedModule empty empty empty empty empty empty empty+ null (OpenedModule _ _ _ _ s ms _) = null s && null ms++-- | Information gathered during scope checking for the unused-imports warning.+data UnusedImportsState = UnusedImportsState+ { unambiguousLookups :: ![AbstractName]+ -- ^ Names that were unambiguously resolved from a concrete name in the source.+ , ambiguousLookups :: !(IntMap (List2 AbstractName))+ -- ^ Names that were ambiguously resolved from a concrete name in the source.+ -- They are stored with their position in the file+ -- that is matched with disambiguation information produced by the type checker.+ , moduleLookups :: ![AbstractModule]+ -- ^ Modules that were resolved from a concrete name in the source,+ -- either directly or as the qualifier of a qualified name.+ , openedModules :: !(IntMap OpenedModule)+ -- ^ Log of module @open@s with the names they brought into scope.+ } deriving (Generic)++instance Null UnusedImportsState where+ empty = UnusedImportsState empty empty empty empty+ null (UnusedImportsState u a m o) = null u && null a && null m && null o++lensUnambiguousLookups :: Lens' UnusedImportsState [AbstractName]+lensUnambiguousLookups f s = f (unambiguousLookups s) <&> \ !x -> s { unambiguousLookups = x }++lensAmbiguousLookups :: Lens' UnusedImportsState (IntMap (List2 AbstractName))+lensAmbiguousLookups f s = f (ambiguousLookups s) <&> \ !x -> s { ambiguousLookups = x }++lensModuleLookups :: Lens' UnusedImportsState [AbstractModule]+lensModuleLookups f s = f (moduleLookups s) <&> \ !x -> s { moduleLookups = x }++lensOpenedModules :: Lens' UnusedImportsState (IntMap OpenedModule)+lensOpenedModules f s = f (openedModules s) <&> \ !x -> s { openedModules = x }++------------------------------------------------------------------------+-- * Decorated names+--+-- - What kind of name? (defined, constructor...)+-- - Where does the name come from? (to explain to user)+------------------------------------------------------------------------++-- Agda.Syntax.Abstract.Name.KindOfName++-- | All kinds of regular definitions.+defNameKinds :: [KindOfName]+defNameKinds = [DataName .. OtherDefName]++isDefName :: KindOfName -> Bool+isDefName = (>= DataName)++-- | Constructor and pattern synonyms.+conLikeNameKinds :: [KindOfName]+conLikeNameKinds = [ConName, CoConName, PatternSynName]++isConName :: KindOfName -> Maybe Induction+isConName = \case+ ConName -> Just Inductive+ CoConName -> Just CoInductive+ _ -> Nothing++conKindOfName :: Induction -> KindOfName+conKindOfName = \case+ Inductive -> ConName+ CoInductive -> CoConName++-- | For ambiguous constructors, we might have both alternatives of 'Induction'.+-- In this case, we default to 'ConName'.+conKindOfName' :: Foldable t => t Induction -> KindOfName+conKindOfName' = conKindOfName . approxConInduction++-- | For ambiguous constructors, we might have both alternatives of 'Induction'.+-- In this case, we default to 'Inductive'.+approxConInduction :: Foldable t => t Induction -> Induction+approxConInduction = fromMaybe Inductive . exactConInduction++exactConInduction :: Foldable t => t Induction -> Maybe Induction+exactConInduction is = case toList is of+ [CoInductive] -> Just CoInductive+ [Inductive] -> Just Inductive+ _ -> Nothing++-- | Only return @[Co]ConName@ if no ambiguity.+exactConName :: Foldable t => t Induction -> Maybe KindOfName+exactConName = fmap conKindOfName . exactConInduction++-- | A set of 'KindOfName', for the sake of 'elemKindsOfNames'.+data KindsOfNames+ = AllKindsOfNames+ | SomeKindsOfNames (Set KindOfName) -- ^ Only these kinds.+ | ExceptKindsOfNames (Set KindOfName) -- ^ All but these Kinds.++elemKindsOfNames :: KindOfName -> KindsOfNames -> Bool+elemKindsOfNames k = \case+ AllKindsOfNames -> True+ SomeKindsOfNames ks -> k `Set.member` ks+ ExceptKindsOfNames ks -> k `Set.notMember` ks++allKindsOfNames :: KindsOfNames+allKindsOfNames = AllKindsOfNames++someKindsOfNames :: [KindOfName] -> KindsOfNames+someKindsOfNames = SomeKindsOfNames . Set.fromList++exceptKindsOfNames :: [KindOfName] -> KindsOfNames+exceptKindsOfNames = ExceptKindsOfNames . Set.fromList++-- | Decorate something with 'KindOfName'++data WithKind a = WithKind+ { theKind :: KindOfName+ , kindedThing :: a+ } deriving (Show, Eq, Ord, Functor, Foldable, Traversable)+++data ResolvedName+ = -- | Local variable bound by λ, Π, module telescope, pattern, @let@.+ VarName+ { resolvedVar :: A.Name+ , resolvedBindingSource :: BindingSource -- ^ What kind of binder?+ }++ | -- | Function, data/record type, postulate.+ DefinedName Access AbstractName A.Suffix -- ^ 'anameKind' can be 'DefName', 'MacroName', 'QuotableName'.++ | -- | Record field name. Needs to be distinguished to parse copatterns.+ FieldName (List1 AbstractName) -- ^ @('FldName' ==) . 'anameKind'@ for all names.++ | -- | Data or record constructor name.+ ConstructorName+ (Set1 Induction) -- ^ 'Inductive' or 'CoInductive' or both.+ (List1 AbstractName) -- ^ @isJust . 'isConName' . 'anameKind'@ for all names.++ | -- | Name of pattern synonym.+ PatternSynResName (List1 AbstractName) -- ^ @('PatternSynName' ==) . 'anameKind'@ for all names.++ | -- | Unbound name.+ UnknownName+ deriving (Show, Eq, Generic)++instance Pretty ResolvedName where+ pretty = \case+ VarName x b -> pretty b <+> "variable" <+> pretty x+ DefinedName a x s -> pretty a <+> (pretty x <> pretty s)+ FieldName xs -> "field" <+> pretty xs+ ConstructorName _ xs -> "constructor" <+> pretty xs+ PatternSynResName x -> "pattern" <+> pretty x+ UnknownName -> "<unknown name>"++-- | Why is a resolved name ambiguous? What did it resolve to?+--+-- Invariant (statically enforced): At least two resolvents in total.+data AmbiguousNameReason+ = AmbiguousLocalVar LocalVar (List1 AbstractName)+ -- ^ The name resolves both to a local variable and some declared names.+ | AmbiguousDeclName (List2 AbstractName)+ -- ^ The name resolves to at least 2 declared names.+ deriving (Show, Generic)++-- | A failure in name resolution, indicating the reason that a name+-- which /is/ in scope could not be returned from @tryResolveName@.+data NameResolutionError+ = IllegalAmbiguity AmbiguousNameReason+ -- ^ Ambiguous names are not supported in this situation.+ | ConstrOfNonRecord C.QName ResolvedName+ -- ^ The name was @Foo.constructor@, and @Foo@ is in scope, but it is+ -- not a record.+ deriving (Show, Generic)++-- | The flat list of ambiguous names in 'AmbiguousNameReason'.+ambiguousNamesInReason :: AmbiguousNameReason -> List2 (A.QName)+ambiguousNamesInReason = \case+ AmbiguousLocalVar (LocalVar y _ _) xs -> List2.cons (A.qualify_ y) $ fmap anameName xs+ AmbiguousDeclName xs -> fmap anameName xs++data WhyInScopeData+ = WhyInScopeData+ C.QName+ -- ^ The name @x@ this explanation is about.+ FilePath+ -- ^ The directory in which the current module resides.+ (Maybe LocalVar)+ -- ^ The local variable that @x@ could denote, if any.+ [AbstractName]+ -- ^ The defined names that @x@ could denote.+ [AbstractModule]+ -- ^ The modules that @x@ could denote.++whyInScopeDataFromAmbiguousQName :: C.QName -> AmbiguousQName -> Maybe WhyInScopeData+whyInScopeDataFromAmbiguousQName q x = case ambAbstractNames x of+ [] -> Nothing+ xs -> Just $ WhyInScopeData q empty Nothing xs empty++whyInScopeDataFromAbstractName :: C.QName -> AbstractName -> WhyInScopeData+whyInScopeDataFromAbstractName q x = WhyInScopeData q empty Nothing [x] empty++whyInScopeDataFromAmbiguousNameReason :: C.QName -> AmbiguousNameReason -> WhyInScopeData+whyInScopeDataFromAmbiguousNameReason q = \case+ AmbiguousLocalVar x ys -> WhyInScopeData q empty (Just x) (toList ys) empty+ AmbiguousDeclName ys -> WhyInScopeData q empty Nothing (toList ys) empty++-- * Operations on name and module maps.++mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a+mergeNames = Map.unionWith List1.union++mergeNamesMany :: Eq a => [ThingsInScope a] -> ThingsInScope a+mergeNamesMany = Map.unionsWith List1.union++------------------------------------------------------------------------+-- * Operations on name spaces+------------------------------------------------------------------------++-- | The empty name space.+emptyNameSpace :: NameSpace+emptyNameSpace = NameSpace Map.empty Map.empty Map.empty Set.empty+++-- | Map functions over the names and modules in a name space.+mapNameSpace :: (NamesInScope -> NamesInScope ) ->+ (ModulesInScope -> ModulesInScope) ->+ (InScopeSet -> InScopeSet ) ->+ NameSpace -> NameSpace+mapNameSpace fd fm fs ns =+ ns { nsNames = fd $ nsNames ns+ , nsModules = fm $ nsModules ns+ , nsInScope = fs $ nsInScope ns+ }++-- | Zip together two name spaces.+zipNameSpace :: (NamesInScope -> NamesInScope -> NamesInScope ) ->+ (NamePartsInScope -> NamePartsInScope -> NamePartsInScope) ->+ (ModulesInScope -> ModulesInScope -> ModulesInScope ) ->+ (InScopeSet -> InScopeSet -> InScopeSet ) ->+ NameSpace -> NameSpace -> NameSpace+zipNameSpace fd fnps fm fs ns1 ns2 =+ ns1 { nsNames = nsNames ns1 `fd` nsNames ns2+ , nsNameParts = nsNameParts ns1 `fnps` nsNameParts ns2+ , nsModules = nsModules ns1 `fm` nsModules ns2+ , nsInScope = nsInScope ns1 `fs` nsInScope ns2+ }++-- | Map monadic function over a namespace.+mapNameSpaceM :: Applicative m =>+ (NamesInScope -> m NamesInScope ) ->+ (ModulesInScope -> m ModulesInScope) ->+ (InScopeSet -> m InScopeSet ) ->+ NameSpace -> m NameSpace+mapNameSpaceM fd fm fs ns = update ns <$> fd (nsNames ns) <*> fm (nsModules ns) <*> fs (nsInScope ns)+ where+ update ns ds ms is = ns { nsNames = ds, nsModules = ms, nsInScope = is }++------------------------------------------------------------------------+-- * General operations on scopes+------------------------------------------------------------------------++instance Null Scope where+ empty = emptyScope+ -- -- Use default implementation of null+ -- null Scope{ scopeName, scopeParents, scopeNameSpaces, scopeImports, scopeDatatypeModule } = and+ -- [ null scopeName+ -- , null scopeParents+ -- , null scopeNameSpaces || all (null . snd) scopeNameSpaces+ -- , null scopeImports+ -- , null scopeDatatypeModule+ -- ]++instance Null ScopeInfo where+ empty = emptyScopeInfo+ -- -- Use default implementation of null+ -- null ScopeInfo+ -- { _scopeCurrent+ -- , _scopeModules+ -- , _scopeVarsToBind+ -- , _scopeLocals+ -- , _scopePrecendence+ -- , _scopeInverseName+ -- , _scopeInverseModule+ -- , _scopeInScope+ -- , _scopeFixities+ -- , _scopePolarities+ -- } = and+ -- [ null _scopeCurrent+ -- , null _scopeModules || all null (Map.values _scopeModules)+ -- , null _scopeVarsToBind+ -- , null _scopeLocals+ -- , null _scopePrecendence+ -- , null _scopeInverseName+ -- , null _scopeInverseModule+ -- , null _scopeInScope+ -- , null _scopeFixities+ -- , null _scopePolarities+ -- ]++-- | The empty scope.+emptyScope :: Scope+emptyScope = Scope+ { scopeName = noModuleName+ , scopeParents = []+ , scopeNameSpaces = [ (nsid, emptyNameSpace) | nsid <- allNameSpaces ]+ -- Note (Andreas, 2019-08-19): Cannot have [] here because+ -- zipScope assumes all NameSpaces to be present and in the same order.+ , scopeImports = Map.empty+ , scopeDatatypeModule = Nothing+ }++-- | The empty scope info.+emptyScopeInfo :: ScopeInfo+emptyScopeInfo = ScopeInfo+ { _scopeCurrent = noModuleName+ , _scopeModules = Map.singleton noModuleName emptyScope+ , _scopeVarsToBind = []+ , _scopeLocals = []+ , _scopePrecedence = []+ , _scopeInverseName = HMap.empty+ , _scopeInverseModule = HMap.empty+ , _scopeInScope = Set.empty+ , _scopeFixities = Map.empty+ , _scopePolarities = Map.empty+ }++-- | Map functions over the names and modules in a scope.+mapScope :: (NameSpaceId -> NamesInScope -> NamesInScope ) ->+ (NameSpaceId -> ModulesInScope -> ModulesInScope) ->+ (NameSpaceId -> InScopeSet -> InScopeSet ) ->+ Scope -> Scope+mapScope fd fm fs = updateScopeNameSpaces $ AssocList.mapWithKey mapNS+ where+ mapNS acc = mapNameSpace (fd acc) (fm acc) (fs acc)++-- | Same as 'mapScope' but applies the same function to all name spaces.+mapScope_ :: (NamesInScope -> NamesInScope ) ->+ (ModulesInScope -> ModulesInScope) ->+ (InScopeSet -> InScopeSet ) ->+ Scope -> Scope+mapScope_ fd fm fs = mapScope (const fd) (const fm) (const fs)++-- | Same as 'mapScope' but applies the function only on the given name space.+mapScopeNS :: NameSpaceId+ -> (NamesInScope -> NamesInScope )+ -> (ModulesInScope -> ModulesInScope)+ -> (InScopeSet -> InScopeSet )+ -> Scope -> Scope+mapScopeNS nsid fd fm fs = modifyNameSpace nsid $ mapNameSpace fd fm fs++-- | Map monadic functions over the names and modules in a scope.+mapScopeM :: Applicative m =>+ (NameSpaceId -> NamesInScope -> m NamesInScope ) ->+ (NameSpaceId -> ModulesInScope -> m ModulesInScope) ->+ (NameSpaceId -> InScopeSet -> m InScopeSet ) ->+ Scope -> m Scope+mapScopeM fd fm fs = updateScopeNameSpacesM $ AssocList.mapWithKeyM mapNS+ where+ mapNS acc = mapNameSpaceM (fd acc) (fm acc) (fs acc)++-- | Same as 'mapScopeM' but applies the same function to both the public and+-- private name spaces.+mapScopeM_ :: Applicative m =>+ (NamesInScope -> m NamesInScope ) ->+ (ModulesInScope -> m ModulesInScope) ->+ (InScopeSet -> m InScopeSet ) ->+ Scope -> m Scope+mapScopeM_ fd fm fs = mapScopeM (const fd) (const fm) (const fs)++-- | Zip together two scopes. The resulting scope has the same name as the+-- first scope.+zipScope :: (NameSpaceId -> NamesInScope -> NamesInScope -> NamesInScope ) ->+ (NameSpaceId -> NamePartsInScope -> NamePartsInScope -> NamePartsInScope) ->+ (NameSpaceId -> ModulesInScope -> ModulesInScope -> ModulesInScope ) ->+ (NameSpaceId -> InScopeSet -> InScopeSet -> InScopeSet ) ->+ Scope -> Scope -> Scope+zipScope fd fnps fm fs s1 s2 =+ s1 { scopeNameSpaces =+ [ (nsid, zipNS nsid ns1 ns2)+ | ((nsid, ns1), (nsid', ns2)) <- zipWith' (,) (scopeNameSpaces s1) (scopeNameSpaces s2)+ , assert (nsid == nsid')+ ]+ , scopeImports = (Map.union `on` scopeImports) s1 s2+ }+ where+ assert True = True+ assert False = __IMPOSSIBLE__+ zipNS acc = zipNameSpace (fd acc) (fnps acc) (fm acc) (fs acc)++-- | Same as 'zipScope' but applies the same function to both the public and+-- private name spaces.+zipScope_ :: (NamesInScope -> NamesInScope -> NamesInScope ) ->+ (NamePartsInScope -> NamePartsInScope -> NamePartsInScope) ->+ (ModulesInScope -> ModulesInScope -> ModulesInScope ) ->+ (InScopeSet -> InScopeSet -> InScopeSet ) ->+ Scope -> Scope -> Scope+zipScope_ fd fnps fm fs = zipScope (const fd) (const fnps) (const fm) (const fs)++-- | Recompute the inScope sets of a scope.+recomputeInScopeSets :: Scope -> Scope+recomputeInScopeSets = updateScopeNameSpaces (map' (second recomputeInScope))+ where+ recomputeInScope ns = ns { nsInScope = billToPure [Scoping, InverseInScopeRecompute] (allANames $ nsNames ns) }+ allANames :: NamesInScope -> InScopeSet+ allANames = foldl' (\acc -> foldl' (\acc n -> Set.insert (anameName n) acc) acc) mempty++-- | Filter a scope keeping only concrete names matching the predicates.+-- The first predicate is applied to the names and the second to the modules.+filterScope :: (C.Name -> Bool) -> (C.Name -> Bool) -> Scope -> Scope+filterScope pd pm = recomputeInScopeSets . mapScope_ (Map.filterKeys pd) (Map.filterKeys pm) id+ -- We don't have enough information in the in scope set to do an+ -- incremental update here, so just recompute it from the name map.++-- | Filter a scope keeping only concrete names matching the predicates.+-- The first predicate is applied to the names and the second to the modules.+mapScopeMaybe :: (C.Name -> Maybe C.Name) -> (C.Name -> Maybe C.Name) -> Scope -> Scope+mapScopeMaybe pd pm = recomputeInScopeSets . mapScope_ (Map.mapKeysMaybe pd) (Map.mapKeysMaybe pm) id+ -- We don't have enough information in the in scope set to do an+ -- incremental update here, so just recompute it from the name map.++-- allNamePartsInScope :: Scope -> NamePartsInScope+-- allNamePartsInScope =+-- Map.unionsWith (<>) . map (nsNameParts . snd) . scopeNameSpaces++-- | Return all names in a scope.+allNamesInScope :: InScope a => Scope -> ThingsInScope a+allNamesInScope = mergeNamesMany . map' (inNameSpace . snd) . scopeNameSpaces++allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access)+allNamesInScope' s =+ mergeNamesMany $+ map' (\(nsId, ns) -> let !acc = nameSpaceAccess nsId in fmap (,acc) <$> inNameSpace ns)+ (scopeNameSpaces s)++-- | Look up a single name in the current scope.+--+-- This is equivalent to @Map.lookup n . allNamesInScope'@, but more efficient+-- when only a single name needs to be looked up.+findNameInScope :: InScope a => C.Name -> Scope -> [(a, Access)]+findNameInScope n s =+ [ (name, nameSpaceAccess nsId)+ | (nsId, ns) <- scopeNameSpaces s+ , name <- List1.toList' $ Map.lookup n $ inNameSpace ns+ ]++-- | Returns the scope's non-private names.+exportedNamesInScope :: InScope a => Scope -> ThingsInScope a+exportedNamesInScope = namesInScope [PublicNS, ImportedNS]++-- namePartsInScope :: [NameSpaceId] -> Scope -> NamePartsInScope+-- namePartsInScope ids s =+-- Map.unionsWith (<>)+-- [nsNameParts ns | (nsid, ns) <- scopeNameSpaces s, elem nsid ids]++namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a+namesInScope ids s =+ mergeNamesMany $ map' (\nsid -> inNameSpace (scopeNameSpace nsid s)) ids++allThingsInScope :: Scope -> NameSpace+allThingsInScope s =+ NameSpace { nsNames = allNamesInScope s+ , nsNameParts = mempty+ , nsModules = allNamesInScope s+ , nsInScope = Set.unions $ map' (nsInScope . snd) $ scopeNameSpaces s+ }++thingsInScope :: [NameSpaceId] -> Scope -> NameSpace+thingsInScope fs s =+ NameSpace { nsNames = namesInScope fs s+ , nsNameParts = mempty+ , nsModules = namesInScope fs s+ , nsInScope = Set.unions [ nsInScope $ scopeNameSpace nsid s | nsid <- fs ]+ }++-- | Merge two scopes. The result has the name of the first scope.+mergeScope :: Scope -> Scope -> Scope+mergeScope = zipScope_ mergeNames go mergeNames Set.union where+ go m m' = (Map.unionWith (<>) m m')++-- | Merge a non-empty list of scopes. The result has the name of the first+-- scope in the list.+mergeScopes :: [Scope] -> Scope+mergeScopes [] = __IMPOSSIBLE__+mergeScopes ss = foldr1 mergeScope ss++-- * Specific operations on scopes++-- | Move all names in a scope to the given name space (except never move from+-- Imported to Public).+setScopeAccess :: NameSpaceId -> Scope -> Scope+setScopeAccess a s = updateScopeNameSpaces (AssocList.mapWithKey (const . ns)) s+ where+ zero = emptyNameSpace+ one = allThingsInScope s+ imp = thingsInScope [ImportedNS] s+ noimp = thingsInScope [PublicNS, PrivateNS] s++ ns b = case (a, b) of+ (PublicNS, PublicNS) -> noimp+ (PublicNS, ImportedNS) -> imp+ _ | a == b -> one+ | otherwise -> zero++-- | Update a particular name space.+setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope+setNameSpace nsid ns = modifyNameSpace nsid $ const ns++-- | Modify a particular name space.+modifyNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> Scope -> Scope+modifyNameSpace nsid f = updateScopeNameSpaces $ AssocList.updateAt nsid f++addNameToNameParts :: C.Name -> AbstractName -> NamePartsInScope -> NamePartsInScope+addNameToNameParts x y nps =++ -- operator parts in the the name+ let nameOpParts = case nameParts x of+ parts -> case any (== Hole) parts of+ False -> [] -- name has no holes, so it's not an operator+ True -> [s | Id s <- List1.toList parts] in++ -- name parts in the associated notation, if there's any+ let notation = theNotation (nameFixity (qnameName (anameName y))) in+ let notationParts = [rangedThing s | IdPart s <- notation] in++ let allParts = if null notationParts then nameOpParts+ else nameOpParts ++! notationParts in++ foldl'+ (\acc part -> Map.insertWith+ (\_ old -> Map.insertWith (flip List1.union) x (List1.singleton y) old)+ part+ (Map.singleton x (List1.singleton y))+ acc)+ nps+ allParts++-- | Add all associated name parts of a name (operator parts, notation parts) to the scope.+addNamePartsToScope :: NameSpaceId -> C.Name -> AbstractName -> Scope -> Scope+addNamePartsToScope nsid x y s =+ let updNameSpace ns = ns {nsNameParts = addNameToNameParts x y (nsNameParts ns)} in+ let nameSpaces = AssocList.updateAt nsid updNameSpace (scopeNameSpaces s) in+ s {scopeNameSpaces = nameSpaces}++-- | Recompute name parts in the namespaces.+recomputeNameParts :: Scope -> Scope+recomputeNameParts s = s {scopeNameSpaces = map (fmap goNS) (scopeNameSpaces s)} where++ goNS :: NameSpace -> NameSpace+ goNS ns = ns {nsNameParts = nameParts} where++ go :: NamePartsInScope -> C.Name -> List1 AbstractName -> NamePartsInScope+ go acc x anames = foldl' (\acc y -> addNameToNameParts x y acc) acc anames++ nameParts :: NamePartsInScope+ nameParts = Map.foldlWithKey' go mempty (nsNames ns)+++-- | Add a name to a scope.+addNameToScope :: NameSpaceId -> C.Name -> AbstractName -> Scope -> Scope+addNameToScope nsid x y =+ addNamePartsToScope nsid x y .+ mapScopeNS nsid+ (Map.insertWith (flip List1.union) x $ singleton y) -- bind name x ↦ y+ id -- no change to modules+ (Set.insert $ anameName y) -- y is in scope now++-- | Remove a name from a scope. Caution: does not update the nsInScope set.+-- This is only used by rebindName and in that case we add the name right+-- back (but with a different kind).+removeNameFromScope :: NameSpaceId -> C.Name -> Scope -> Scope+removeNameFromScope nsid x = mapScopeNS nsid (Map.delete x) id id++-- | Add a module to a scope.+addModuleToScope :: NameSpaceId -> C.Name -> AbstractModule -> Scope -> Scope+addModuleToScope nsid x m = mapScopeNS nsid id addM id+ where addM = Map.insertWith (flip List1.union) x (singleton m)++-- | When we get here we cannot have both @using@ and @hiding@.+data UsingOrHiding+ = UsingOnly [C.ImportedName]+ | HidingOnly [C.ImportedName]++usingOrHiding :: C.ImportDirective -> UsingOrHiding+usingOrHiding i =+ case (using i, hiding i) of+ (UseEverything, ys) -> HidingOnly ys+ (Using xs , []) -> UsingOnly xs+ _ -> __IMPOSSIBLE__++-- | Apply an 'ImportDirective' to a scope:+--+-- 1. rename keys (C.Name) according to @renaming@;+--+-- 2. for untouched keys, either of+--+-- a) remove keys according to @hiding@, or+-- b) filter keys according to @using@.+--+-- Both steps could be done in one pass, by first preparing key-filtering+-- functions @C.Name -> Maybe C.Name@ for defined names and module names.+-- However, the penalty of doing it in two passes should not be too high.+-- (Doubling the run time.)+applyImportDirective :: C.ImportDirective -> Scope -> Scope+applyImportDirective dir = fst . applyImportDirective_ dir++-- | Version of 'applyImportDirective' that also returns sets of name+-- and module name clashes introduced by @renaming@ to identifiers+-- that are already imported by @using@ or lack of @hiding@.+applyImportDirective_+ :: C.ImportDirective+ -> Scope+ -> (Scope, (Set C.Name, Set C.Name)) -- ^ Merged scope, clashing names, clashing module names.+applyImportDirective_ dir@(ImportDirective{ impRenaming }) s+ | null dir = (s, (empty, empty))+ -- Since each run of applyImportDirective rebuilds the scope+ -- with cost O(n log n) time, it makes sense to test for the identity.+ | otherwise = (recomputeInScopeSets $ mergeScope sUse sRen, (nameClashes, moduleClashes))+ where+ -- Names kept via using/hiding.+ sUse :: Scope+ sUse = useOrHide (usingOrHiding dir) s++ -- Things kept (under a different name) via renaming.+ sRen :: Scope+ sRen = rename impRenaming s++ -- Which names are considered to be defined by a module?+ -- The ones actually defined there publicly ('publicNS')+ -- and the ones imported publicly ('ImportedNS')?+ exportedNSs = [PublicNS, ImportedNS]++ -- Name clashes introduced by the @renaming@ clause.+ nameClashes :: Set C.Name+ nameClashes = Map.keysSet rNames `Set.intersection` Map.keysSet uNames+ -- NB: `intersection` returns a subset of the first argument.+ -- To get the correct error location, i.e., in the @renaming@ clause+ -- rather than at the definition location, we neet to return+ -- names from the @renaming@ clause. (Issue #4154.)+ where+ uNames, rNames :: NamesInScope+ uNames = namesInScope exportedNSs sUse+ rNames = namesInScope exportedNSs sRen++ -- Module name clashes introduced by the @renaming@ clause.++ -- Note: need to cut and paste because of 'InScope' dependent types trickery.+ moduleClashes :: Set C.Name+ moduleClashes = Map.keysSet uModules `Set.intersection` Map.keysSet rModules+ where+ uModules, rModules :: ModulesInScope+ uModules = namesInScope exportedNSs sUse+ rModules = namesInScope exportedNSs sRen+++ -- Restrict scope by directive.+ useOrHide :: UsingOrHiding -> Scope -> Scope+ useOrHide (UsingOnly xs) = filterNames (flip Set.lookupKey) xs+ -- Filter scope, keeping only xs.+ useOrHide (HidingOnly xs) = filterNames (predicateToMaybe . flip Set.notMember) $ map' renFrom impRenaming ++! xs+ -- Filter out xs and the to be renamed names from scope.++ -- Filter scope by (rel xs).+ -- O(n * log (length xs)).+ filterNames :: (Set C.Name -> C.Name -> Maybe C.Name) -> [C.ImportedName] ->+ Scope -> Scope+ filterNames rel xs = mapScopeMaybe (rel $ Set.fromList ds) (rel $ Set.fromList ms)+ where+ (ds, ms) = partitionEithers $ for xs $ \case+ ImportedName x -> Left x+ ImportedModule m -> Right m++ -- Apply a renaming to a scope.+ -- O(n * (log n + log (length rho))).+ rename :: [C.Renaming] -> Scope -> Scope+ rename rho = mapScope_ (updateFxs .+ updateThingsInScope (AssocList.apply drho))+ (updateThingsInScope (AssocList.apply mrho))+ id+ where+ (drho, mrho) = partitionEithers $ for rho $ \case+ Renaming (ImportedName x) (ImportedName y) _fx _ -> Left (x, y)+ Renaming (ImportedModule x) (ImportedModule y) _fx _ -> Right (x, y)+ _ -> __IMPOSSIBLE__++ fixities :: AssocList C.Name Fixity+ fixities = (`mapMaybe` rho) $ \case+ Renaming _ (ImportedName y) (Just fx) _ -> Just (y, fx)+ _ -> Nothing++ -- Update fixities of abstract names targeted by renamed imported identifies.+ updateFxs :: NamesInScope -> NamesInScope+ updateFxs m = foldl upd m fixities+ where+ -- Update fixity of all abstract names targeted by concrete name y.+ upd m (y, fx) = Map.adjust (fmap $ set lensFixity fx) y m++ updateThingsInScope+ :: forall a. SetBindingSite a+ => (C.Name -> Maybe C.Name)+ -> ThingsInScope a -> ThingsInScope a+ updateThingsInScope f = Map.fromListWith __IMPOSSIBLE__ . mapMaybe upd . Map.toAscList+ where+ upd :: (C.Name, List1 a) -> Maybe (C.Name, List1 a)+ upd (x, ys) = f x <&> \ x' -> (x', setBindingSite (getRange x') ys)++-- | Rename the abstract names in a scope.+renameCanonicalNames :: Map A.QName A.QName -> Map A.ModuleName A.ModuleName ->+ Scope -> Scope+renameCanonicalNames renD renM = mapScope_ renameD renameM (Set.map newName)+ where+ newName x = Map.findWithDefault x x renD+ newMod x = Map.findWithDefault x x renM++ renameD = Map.map $ fmap $ over lensAnameName newName+ renameM = Map.map $ fmap $ over lensAmodName newMod++-- | Remove private name space of a scope.+--+-- Should be a right identity for 'exportedNamesInScope'.+-- @exportedNamesInScope . restrictPrivate == exportedNamesInScope@.+restrictPrivate :: Scope -> Scope+restrictPrivate s = setNameSpace PrivateNS emptyNameSpace+ $ s { scopeImports = Map.empty }++-- | Remove private things from the given module from a scope.+restrictLocalPrivate :: ModuleName -> Scope -> Scope+restrictLocalPrivate m scope =+ recomputeNameParts $+ mapScopeNS PrivateNS+ (Map.mapMaybe rName)+ (Map.mapMaybe rMod)+ (Set.filter (not . (`isInModule` m)))+ scope+ where+ rName as = List1.nonEmpty $ List1.filter (not . (`isInModule` m) . anameName) as+ rMod as = List1.nonEmpty $ List1.filter (not . (`isLtChildModuleOf` m) . amodName) as++-- | Filter privates out of a `ScopeInfo`+withoutPrivates :: ScopeInfo -> ScopeInfo+withoutPrivates scope = over scopeModules (fmap $ restrictLocalPrivate m) scope+ where+ m = scope ^. scopeCurrent++-- | Disallow using generalized variables from the scope+disallowGeneralizedVars :: Scope -> Scope+disallowGeneralizedVars = mapScope_ ((fmap . fmap) disallow) id id+ where+ disallow a = a { anameKind = disallowGen (anameKind a) }+ disallowGen GeneralizeName = DisallowedGeneralizeName+ disallowGen k = k++-- | Add an explanation to why things are in scope.+inScopeBecause :: (WhyInScope -> WhyInScope) -> Scope -> Scope+inScopeBecause f = mapScope_ mapName mapMod id+ where+ mapName = fmap . fmap $ \a -> a { anameLineage = f $ anameLineage a }+ mapMod = fmap . fmap $ \a -> a { amodLineage = f $ amodLineage a }++-- | Get the public parts of the public modules of a scope+publicModules :: ScopeInfo -> Map A.ModuleName Scope+publicModules scope = Map.filterWithKey (\ m _ -> reachable m) allMods+ where+ -- Get all modules in the ScopeInfo.+ allMods = Map.map restrictPrivate $ scope ^. scopeModules+ root = scope ^. scopeCurrent++ modules s = map amodName $ List1.concat $ Map.elems $ allNamesInScope s++ chase m = m : concatMap chase ms+ where ms = maybe __IMPOSSIBLE__ modules $ Map.lookup m allMods++ reachable = (`elem` chase root)++publicNames :: ScopeInfo -> Set AbstractName+publicNames scope =+ Set.fromList $ List1.concat $ Map.elems $+ exportedNamesInScope $ mergeScopes $ Map.elems $ publicModules scope++publicNamesOfModules :: Map A.ModuleName Scope -> [AbstractName]+publicNamesOfModules = List1.concat . Map.elems . exportedNamesInScope . mergeScopes . Map.elems++everythingInScope :: ScopeInfo -> NameSpace+everythingInScope scope = allThingsInScope $ mergeScopes $+ (s0 :) $ map look $ scopeParents s0+ where+ look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules+ s0 = look $ scope ^. scopeCurrent++-- | Get all concrete names in scope. Includes bound variables.+concreteNamesInScope :: ScopeInfo -> Set C.QName+concreteNamesInScope scope =+ Set.unions [ build id allNamesInScope root, imported, locals ]+ where+ current = moduleScope $ scope ^. scopeCurrent+ root = mergeScopes $ current : map moduleScope (scopeParents current)++ locals = Set.fromList [ C.QName x | (x, _) <- scope ^. scopeLocals ]++ imported = Set.unions+ [ build (qual c) exportedNamesInScope $ moduleScope a+ | (c, a) <- Map.toList $ scopeImports root+ ]+ where+ qual (C.QName x) = C.Qual x+ qual (C.Qual m x) = C.Qual m . qual x++ build :: (C.QName -> C.QName) -> (forall a. InScope a => Scope -> ThingsInScope a) -> Scope -> Set C.QName+ build qual getNames s = Set.unions $+ Set.mapMonotonic (qual . C.QName) (Map.keysSet (getNames s :: ThingsInScope AbstractName))+ :+ [ build (qual . C.Qual x) exportedNamesInScope $ moduleScope m+ | (x, mods) <- Map.toList (getNames s)+ , not $ isNoName x+ , AbsModule m _ <- List1.toList mods+ ]++ moduleScope :: A.ModuleName -> Scope+ moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules++-- | Look up a name in the scope+scopeLookup :: InScope a => C.QName -> ScopeInfo -> [a]+scopeLookup q scope = map fst $ scopeLookup' q scope++{-# SPECIALIZE scopeLookup' :: C.QName -> ScopeInfo -> [(AbstractName, Access)] #-}+{-# SPECIALIZE scopeLookup' :: C.QName -> ScopeInfo -> [(AbstractModule, Access)] #-}+scopeLookup' :: forall a. InScope a => C.QName -> ScopeInfo -> [(a, Access)]+scopeLookup' q scope = nubOn fst $ inAllScopes ++! topImports ++! imports+ where+ -- 1. Finding a name in the current scope and its parents.+ inAllScopes :: [(a, Access)]+ inAllScopes = concatMap' (findName q) allScopes++ -- 2. Finding a name in the top imports.+ topImports :: [(a, Access)]+ topImports = case (inScopeTag :: InScopeTag a) of+ NameTag -> []+ ModuleTag -> map' (first (`AbsModule` Defined)) (imported q)++ -- 3. Finding a name in the imports belonging to an initial part of the qualifier.+ imports :: [(a, Access)]+ imports = do+ let -- return all possible splittings, e.g.+ -- splitName X.Y.Z = [(X, Y.Z), (X.Y, Z)]+ splitName :: C.QName -> [(C.QName, C.QName)]+ splitName (C.QName x) = []+ splitName (C.Qual x q) =+ ((C.QName x, q) :) $! map' (\(m, r) -> (C.Qual x m, r)) (splitName q)++ (m, x) <- splitName q+ (m, _) <- imported m+ findName x $ restrictPrivate $ moduleScope m++ --------------------------------------------------------------------------------++ allScopes :: [Scope]+ allScopes = scopeAndParents scope++ imported :: C.QName -> [(A.ModuleName, Access)]+ imported q = do+ s <- allScopes+ m <- maybeToList $ Map.lookup q $ scopeImports s+ return (m, PublicAccess)++ findName :: forall a. InScope a => C.QName -> Scope -> [(a, Access)]+ findName = findQNameInScope scope++ moduleScope :: A.ModuleName -> Scope+ moduleScope = scopeOfModule scope++-- | The scope of the given module.+scopeOfModule :: ScopeInfo -> A.ModuleName -> Scope+scopeOfModule scope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules++-- | The current scope and the scopes of its parents.+scopeAndParents :: ScopeInfo -> [Scope]+scopeAndParents scope = (current :) $! map' (scopeOfModule scope) (scopeParents current)+ where+ current = scopeOfModule scope $ scope ^. scopeCurrent++{-# SPECIALIZE findQNameInScope :: ScopeInfo -> C.QName -> Scope -> [(AbstractName, Access)] #-}+{-# SPECIALIZE findQNameInScope :: ScopeInfo -> C.QName -> Scope -> [(AbstractModule, Access)] #-}+-- | Find a concrete, possibly qualified name in scope @s@.+-- The qualifiers are resolved to modules whose public scopes are searched.+findQNameInScope :: forall a. InScope a => ScopeInfo -> C.QName -> Scope -> [(a, Access)]+findQNameInScope scope q0 s = case q0 of+ C.QName x -> findNameInScope x s+ C.Qual x q -> do+ (_, s') <- qualifierScopes scope x s+ findQNameInScope scope q s'++-- | Resolve a qualifier @x@ in scope @s@ to the modules named @x@+-- and their public scopes.+qualifierScopes :: ScopeInfo -> C.Name -> Scope -> [(AbstractModule, Scope)]+qualifierScopes scope x s = do+ -- Andreas, 2013-05-01: Issue 836 complains about the feature+ -- that constructors can also be qualified by their datatype+ -- and projections by their record type. This feature is off+ -- if we just consider the modules (and not also the definitions named @x@).+ (m, _) <- findNameInScope x s+ -- Get the scope of module m, if any, and remove its private definitions.+ s' <- maybeToList $ Map.lookup (amodName m) $ scope ^. scopeModules+ return (m, restrictPrivate s')++-- | For a qualified name @x.q@ resolving to one of the given things @ys@,+-- find the modules @x@ in the current scope (or its parents)+-- through which @q@ resolves to some of @ys@.+--+-- Used to mark the qualifier @x@ as used for the unused-imports analysis.+scopeLookupQualifier :: InScope a => C.QName -> [a] -> ScopeInfo -> [AbstractModule]+scopeLookupQualifier q ys scope = case q of+ C.QName _ -> []+ C.Qual x q -> List.nub $ do+ (m, s) <- qualifierScopes scope x =<< scopeAndParents scope+ let zs = map fst $ findQNameInScope scope q s+ if any (`elem` ys) zs then [m] else []++-- * Inverse look-up++data AllowAmbiguousNames+ = AmbiguousAnything+ -- ^ Used for instance arguments to check whether a name is in scope,+ -- but we do not care whether is is ambiguous+ | AmbiguousConProjs+ -- ^ Ambiguous constructors, projections, or pattern synonyms.+ | AmbiguousNothing+ deriving (Eq, Show)++isNameInScope :: A.QName -> ScopeInfo -> Bool+isNameInScope q scope =+ billToPure [ Scoping, InverseInScope ] $+ Set.member q (scope ^. scopeInScope)++isNameInScopeUnqualified :: A.QName -> ScopeInfo -> Bool+isNameInScopeUnqualified q scope =+ case inverseScopeLookupName' AmbiguousNothing q scope of+ C.QName{} : _ -> True -- NOTE: inverseScopeLookupName' puts unqualified names first+ _ -> False++-- | Find the concrete names that map (uniquely) to a given abstract qualified name.+-- Sort by number of modules in the qualified name, unqualified names first.+inverseScopeLookupName :: A.QName -> ScopeInfo -> [C.QName]+inverseScopeLookupName = inverseScopeLookupName' AmbiguousConProjs++inverseScopeLookupName' :: AllowAmbiguousNames -> A.QName -> ScopeInfo -> [C.QName]+inverseScopeLookupName' amb q scope =+ maybe [] (List1.toList . qnameConcrete) $ inverseScopeLookupName'' amb q scope++-- | A version of 'inverseScopeLookupName' that also delivers the 'KindOfName'.+-- Used in highlighting.+inverseScopeLookupName'' :: AllowAmbiguousNames -> A.QName -> ScopeInfo -> Maybe NameMapEntry+inverseScopeLookupName'' amb q scope = billToPure [ Scoping , InverseNameLookup ] $ do++ NameMapEntry k xs <- HMap.lookup (A.nameId q) (scope ^. scopeInverseName)++ -- try to get an unqualified concrete name, that's probably given+ -- by the user.+ let getUserGivenName :: C.QName -> Maybe NameParts+ getUserGivenName = \case+ C.QName x -> case x of+ C.NoName{} -> Nothing+ C.Name NoRange _ _ -> Nothing+ C.Name _ _ parts -> Just parts+ C.Qual _ x -> getUserGivenName x++ -- unqualified original concrete name+ let !userGiven = getUserGivenName (C.QName $ nameConcrete $ qnameName q)++ !xs <- List1.nonEmpty $ List.sortOn snd do+ -- List comprehension written in monadic form+ q :: C.QName <- nubOn id $ List1.toList xs+ let y:ys = scopeLookup' q scope+ let !k = anameKind $ fst y++ let unambiguous :: Bool+ unambiguous =+ (amb == AmbiguousAnything)+ || (null ys)+ || ( (amb == AmbiguousConProjs)+ && ( all (isJust . isConName . anameKind . fst) (y:ys)+ || ( (k == FldName || k == PatternSynName)+ && all ((k ==) . anameKind . fst) ys)))++ guard unambiguous++ -- Computing priority for name printing.+ --+ -- The rules are currently, in lexicographic order:+ -- 1. Less qualified names are preferred+ -- 2. Names whose unqualified name part is the same as what the user originally wrote, are+ -- preferred.+ -- 3. Names introduced later are preferred, by source position.+ -- If a single module opening introduces multiple possible printable names,+ -- we recursively prefer the names that were introduced later within the module.+ --+ -- Caveat: rule 3 only fires within the current source file. Currently we can't use it across+ -- files because we don't store ranges in interfaces. Currently we happen to pick the+ -- alphabetically greater names in those cases.+ let lineageRanges = go (anameLineage $ fst y) where+ go Defined = let !r = Down $! getRange q in [r]+ go (Opened x why) = let !r = getRange x; !rs = go why in Down r:rs+ go (Applied x why) = let !r = getRange x; !rs = go why in Down r:rs++ let sortingWeight = let !qualifiers = length (C.qnameParts q)+ !preferUserGiven = case (userGiven, getUserGivenName q) of+ (Just x, Just x') | x == x' -> Down True+ _ -> Down False+ in (+ qualifiers+ , preferUserGiven+ , lineageRanges+ )++ pure (q, sortingWeight)++ !xs <- pure (List1.map' fst xs)+ pure $ NameMapEntry k xs++-- | Find the concrete names that map (uniquely) to a given abstract module name.+-- Sort by length, shortest first.+inverseScopeLookupModule :: A.ModuleName -> ScopeInfo -> [C.QName]+inverseScopeLookupModule = inverseScopeLookupModule' AmbiguousNothing++inverseScopeLookupModule' :: AllowAmbiguousNames -> A.ModuleName -> ScopeInfo -> [C.QName]+inverseScopeLookupModule' amb m scope = billToPure [ Scoping , InverseModuleLookup ] $+ best $ filter unambiguousModule $ findModule m+ where+ findModule m = fromMaybe [] $ HMap.lookup m (scope ^. scopeInverseModule)++ best :: [C.QName] -> [C.QName]+ best = List.sortOn $ length . C.qnameParts++ unique :: forall a . [a] -> Bool+ unique [] = __IMPOSSIBLE__+ unique [_] = True+ unique (_:_:_) = False++ unambiguousModule q = amb == AmbiguousAnything || unique (scopeLookup q scope :: [AbstractModule])++recomputeInScopeSet :: ScopeInfo -> Set A.QName+recomputeInScopeSet scope = fst $ St2.execState goCurrent (Set.empty, Set.empty) where+ !mods = scope ^. scopeModules+ !s0 = scope ^. scopeCurrent+ look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m mods+ goCurrent = go True s0 *> forM_ (scopeParents (look s0)) (go True)++ go :: Bool -> ModuleName -> St2.State (Set A.QName) (Set ModuleName) ()+ go !isCurrent !m = do+ seen <- St2.get2+ if Set.member m seen then+ pure ()+ else do+ St2.modify2 (Set.insert m)+ let !s = look m+ -- names and submodules+ forM_ (scopeNameSpaces s) \(nsid, NameSpace _ _ mods inscope) -> do+ when (isCurrent || nsid /= PrivateNS) do+ St2.modify1 (<> inscope)+ Map.forWithKey_ mods \k ms -> do+ when (isInScope k == InScope) do+ forM_ ms \m -> do+ go False (amodName m)+ -- imports+ when isCurrent do+ Map.forWithKey_ (scopeImports s) \_ m -> do+ go False m++recomputeInverseNamesAndModules :: ScopeInfo -> (NameMap, ModuleMap)+recomputeInverseNamesAndModules scope = St2.execState goCurrent (mempty, mempty) where+ look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m mods+ !mods = scope ^. scopeModules+ !s0 = look (scope ^. scopeCurrent)++ -- we traverse outer scopes first, because this causes inner names+ -- to appear first in name lists, and we prefer printing inner names+ goCurrent = goParents (scopeParents s0) *> go [] s0++ updQuals (C.QName x) quals = x:quals+ updQuals (C.Qual x n) quals = updQuals n (x:quals)+ applyQuals !x quals = foldl' (flip C.Qual) x quals++ internalName :: C.QName -> Bool+ internalName C.QName{} = False+ internalName (C.Qual m n) = intern m || internalName n+ where+ -- Recognize fresh names created by Parser.y+ intern (C.Name _ _ (C.Id ('.' : '#' : _) :| [])) = True+ intern _ = False++ -- The pseudo-name @constructor@ bound in a record module (see+ -- 'Agda.Syntax.Scope.Monad.bindRecordConstructorPseudoName') is a keyword,+ -- so it cannot be parsed unqualified. Thus, it must not be offered as an+ -- unqualified rendering of the record constructor (which could happen after+ -- @open R@). Qualified renderings like @R.constructor@ are fine.+ unqualifiedKeyword :: C.QName -> Bool+ unqualifiedKeyword (C.QName (C.Name _ _ (C.Id "constructor" :| []))) = True+ unqualifiedKeyword _ = False++ updModules qualx m =+ St2.modify2 $ HMap.insertWith (\_ acc -> qualx:acc) m [qualx]++ updNames qualx nid entry = do+ let upd _ (NameMapEntry k xs) = NameMapEntry k $! qualx List1.<| xs+ St2.modify1 $ HMap.insertWith upd nid entry++ goParents :: [ModuleName] -> St2.State NameMap ModuleMap ()+ goParents = \case+ [] -> pure ()+ s:ss -> goParents ss *> go [] (look s)++ go :: [C.Name] -> Scope -> St2.State NameMap ModuleMap ()+ go !quals s = do+ -- names and submodules+ forM_ (scopeNameSpaces s) \(nsid, NameSpace names _ mods _) -> do+ when (null quals || nsid /= PrivateNS) do++ -- names+ Map.forWithKey_ names \x ys -> do+ let !qualx = applyQuals (C.QName x) quals+ when (not (internalName qualx || unqualifiedKeyword qualx)) do+ forM_ ys \y -> do+ let nid = A.nameId y+ let entry = NameMapEntry (anameKind y) (qualx :| [])+ updNames qualx nid entry++ -- submodules+ Map.forWithKey_ mods \x ms -> do+ when (isInScope x == InScope) do+ let !qualx = applyQuals (C.QName x) quals+ when (not (internalName qualx)) do+ forM_ ms \m -> do+ let !name = amodName m+ updModules qualx name+ go (x:quals) (look name)++ -- imports+ when (null quals) do+ Map.forWithKey_ (scopeImports s) \x m -> do+ let !qualx = applyQuals x quals+ when (not (internalName qualx)) do+ updModules qualx m+ go (updQuals x quals) (look m)+++recomputeInverseScope' :: ScopeInfo -> ScopeInfo+recomputeInverseScope' scope =+ let (names, modules) = billToPure [Scoping, InverseNameModuleRecompute]+ (recomputeInverseNamesAndModules scope)+ inScope = billToPure [Scoping, InverseInScopeRecompute] (recomputeInScopeSet scope)+ in scope {+ _scopeInverseName = names+ , _scopeInverseModule = modules+ , _scopeInScope = inScope+ }++------------------------------------------------------------------------+-- * Update binding site+------------------------------------------------------------------------++-- | Set the 'nameBindingSite' in an abstract name.+class SetBindingSite a where+ setBindingSite :: Range -> a -> a++ default setBindingSite+ :: (SetBindingSite b, Functor t, t b ~ a)+ => Range -> a -> a+ setBindingSite = fmap . setBindingSite++instance SetBindingSite a => SetBindingSite [a]+instance SetBindingSite a => SetBindingSite (List1 a)++instance SetBindingSite A.Name where+ setBindingSite r x = x { _nameBindingSite = r }++instance SetBindingSite A.QName where+ setBindingSite r x = x { qnameName = setBindingSite r $ qnameName x }++-- | Sets the binding site of all names in the path.+instance SetBindingSite A.ModuleName where+ setBindingSite r (MName x) = MName $ setBindingSite r x++instance SetBindingSite AbstractName where+ setBindingSite r x = x { anameName = setBindingSite r $ anameName x }++instance SetBindingSite AbstractModule where+ setBindingSite r x = x { amodName = setBindingSite r $ amodName x }+++------------------------------------------------------------------------+-- * (Debug) printing+------------------------------------------------------------------------++instance Pretty NameSpaceId where+ pretty = text . \case+ PublicNS -> "public"+ PrivateNS -> "private"+ ImportedNS -> "imported"++instance Pretty NameSpace where+ pretty = vcat . prettyNameSpace++prettyNameSpace :: NameSpace -> [Doc]+prettyNameSpace (NameSpace names nameParts mods _) =+ blockOfLines "names" (map pr' $ Map.toList names) +++ blockOfLines "name parts" (map pr $ Map.toList nameParts) +++ blockOfLines "modules" (map pr $ Map.toList mods)+ where+ pr :: (Pretty a, Pretty b) => (a,b) -> Doc+ pr (x, y) = pretty x <+> "-->" <+> pretty y+ -- pr' :: (Pretty a, IsInstanceDef b, Pretty b) => (a, List1 b) -> Doc+ pr' :: (C.Name, List1 AbstractName) -> Doc+ pr' (x, ys) = pretty x <+> "-->" <+> prettyList (map augment $ List1.toList ys)+ where+ -- Extra information for names; comment out line to remove a particular augmentation+ augment = id+ . PrettyWithInstance+ -- . PrettyWithBindingSite++newtype PrettyWithInstance a = PrettyWithInstance a+instance (IsInstanceDef a, Pretty a) => Pretty (PrettyWithInstance a) where+ pretty (PrettyWithInstance x) =+ applyWhen (isJust $ isInstanceDef x) ("instance" <+>) $ pretty x++newtype PrettyWithBindingSite a = PrettyWithBindingSite a+ deriving (IsInstanceDef)+instance (HasNameBindingSite a, Pretty a) => Pretty (PrettyWithBindingSite a) where+ pretty (PrettyWithBindingSite x) = do+ let r = nameBindingSite x+ applyUnless (null r) (<+> ("bound at" <+> pretty r)) $ pretty x++instance Pretty Scope where+ pretty scope@Scope{ scopeName = name, scopeParents = parents, scopeImports = imps } =+ vcat $ concat+ [ [ "scope" <+> pretty name ]+ , scopeNameSpaces scope >>= \ (nsid, ns) -> do+ block (pretty nsid) $ prettyNameSpace ns+ , ifNull (Map.keys imps) [] {-else-} $ \ ks ->+ block "imports" [ prettyList ks ]+ ]+ where+ block :: Doc -> [Doc] -> [Doc]+ block hd = map (nest 2) . blockOfLines hd++-- | Add first string only if list is non-empty.+blockOfLines :: Doc -> [Doc] -> [Doc]+blockOfLines _ [] = []+blockOfLines hd ss = hd : map (nest 2) ss++instance Pretty ScopeInfo where+ pretty (ScopeInfo this mods toBind locals ctx _ _ _ fixs _) = vcat $ concat+ [ [ "ScopeInfo"+ , nest 2 $ "current =" <+> pretty this+ ]+ , [ nest 2 $ "toBind =" <+> pretty toBind | not (null toBind) ]+ , [ nest 2 $ "locals =" <+> pretty locals | not (null locals) ]+ , [ nest 2 $ "fixities=" <+> pretty fixs | not (null fixs ) ]+ , [ nest 2 $ "context =" <+> pretty ctx+ , nest 2 $ "modules"+ ]+ , map (nest 4 . pretty) $ Map.elems mods+ ]++------------------------------------------------------------------------+-- * Boring instances+------------------------------------------------------------------------++instance KillRange ScopeInfo where+ killRange = id++instance NFData AmbiguousNameReason+instance NFData BindingSource+instance NFData DataOrRecordModule+instance NFData LocalVar+instance NFData NameMapEntry+instance NFData NameOrModule+instance NFData NameSpace+instance NFData NameSpaceId+instance NFData ResolvedName+instance NFData Scope+instance NFData ScopeInfo
@@ -1,438 +1,1192 @@-{-# LANGUAGE CPP #-}--{-| The scope monad with operations.--}--module Agda.Syntax.Scope.Monad where--import Prelude hiding (mapM)-import Control.Applicative-import Control.Monad hiding (mapM)-import Control.Monad.Writer hiding (mapM)-import Control.Monad.State hiding (mapM)-import Data.Map (Map)-import Data.Traversable-import Data.List-import qualified Data.Map as Map--import Agda.Syntax.Common-import Agda.Syntax.Position-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Abstract.Name as A-import Agda.Syntax.Concrete as C-import Agda.Syntax.Scope.Base--import Agda.TypeChecking.Monad.Base-import Agda.TypeChecking.Monad.State-import Agda.TypeChecking.Monad.Options--import Agda.Utils.Tuple-import Agda.Utils.Fresh-import Agda.Utils.Size-import Agda.Utils.List--#include "../../undefined.h"-import Agda.Utils.Impossible---- * The scope checking monad---- | To simplify interaction between scope checking and type checking (in--- particular when chasing imports), we use the same monad.-type ScopeM = TCM---- * Errors--notInScope :: C.QName -> ScopeM a-notInScope x = typeError $ NotInScope [x]---- * General operations--getCurrentModule :: ScopeM A.ModuleName-getCurrentModule = setRange noRange . scopeCurrent <$> getScope--setCurrentModule :: A.ModuleName -> ScopeM ()-setCurrentModule m = modifyScopeInfo $ \s -> s { scopeCurrent = m }--withCurrentModule :: A.ModuleName -> ScopeM a -> ScopeM a-withCurrentModule new action = do- old <- getCurrentModule- setCurrentModule new- x <- action- setCurrentModule old- return x--withCurrentModule' :: (MonadTrans t, Monad (t ScopeM)) => A.ModuleName -> t ScopeM a -> t ScopeM a-withCurrentModule' new action = do- old <- lift getCurrentModule- lift $ setCurrentModule new- x <- action- lift $ setCurrentModule old- return x--getNamedScope :: A.ModuleName -> ScopeM Scope-getNamedScope m = do- scope <- getScope- case Map.lookup m (scopeModules scope) of- Just s -> return s- Nothing -> do- reportSLn "" 0 $ "ERROR: In scope\n" ++ show scope ++ "\nNO SUCH SCOPE " ++ show m- __IMPOSSIBLE__--getCurrentScope :: ScopeM Scope-getCurrentScope = getNamedScope =<< getCurrentModule---- | Create a new module with an empty scope-createModule :: A.ModuleName -> ScopeM ()-createModule m = do- s <- getCurrentScope- let parents = scopeName s : scopeParents s- modifyScopes $ Map.insert m emptyScope { scopeName = m, scopeParents = parents }---- | Apply a function to the scope info.-modifyScopeInfo :: (ScopeInfo -> ScopeInfo) -> ScopeM ()-modifyScopeInfo f = do- scope <- getScope- setScope $ f scope---- | Apply a function to the scope map.-modifyScopes :: (Map A.ModuleName Scope -> Map A.ModuleName Scope) -> ScopeM ()-modifyScopes f = modifyScopeInfo $ \s -> s { scopeModules = f $ scopeModules s }---- | Apply a function to the given scope.-modifyNamedScope :: A.ModuleName -> (Scope -> Scope) -> ScopeM ()-modifyNamedScope m f = modifyScopes $ Map.mapWithKey f'- where- f' m' s | m' == m = f s- | otherwise = s---- | Apply a function to the current scope.-modifyCurrentScope :: (Scope -> Scope) -> ScopeM ()-modifyCurrentScope f = do- m <- getCurrentModule- modifyNamedScope m f---- | Apply a monadic function to the top scope.-modifyNamedScopeM :: A.ModuleName -> (Scope -> ScopeM Scope) -> ScopeM ()-modifyNamedScopeM m f = do- s <- getNamedScope m- s' <- f s- modifyNamedScope m (const s')--modifyCurrentScopeM :: (Scope -> ScopeM Scope) -> ScopeM ()-modifyCurrentScopeM f = do- m <- getCurrentModule- modifyNamedScopeM m f---- | Apply a function to the public or private name space.-modifyCurrentNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> ScopeM ()-modifyCurrentNameSpace acc f = modifyCurrentScope action- where- action s = s { scopeNameSpaces = [ (nsid, f' nsid ns) | (nsid, ns) <- scopeNameSpaces s ] }-- f' a | a == acc = f- | otherwise = id--setContextPrecedence :: Precedence -> ScopeM ()-setContextPrecedence p = modifyScopeInfo $ \s -> s { scopePrecedence = p }--getContextPrecedence :: ScopeM Precedence-getContextPrecedence = scopePrecedence <$> getScope--withContextPrecedence :: Precedence -> ScopeM a -> ScopeM a-withContextPrecedence p m = do- p' <- getContextPrecedence- setContextPrecedence p- x <- m- setContextPrecedence p'- return x--getLocalVars :: ScopeM LocalVars-getLocalVars = scopeLocals <$> getScope--setLocalVars :: LocalVars -> ScopeM ()-setLocalVars vars = modifyScope $ \s -> s { scopeLocals = vars }---- | Run a computation without changing the local variables.-withLocalVars :: ScopeM a -> ScopeM a-withLocalVars m = do- vars <- getLocalVars- x <- m- setLocalVars vars- return x---- * Names---- | Create a fresh abstract name from a concrete name.-freshAbstractName :: Fixity' -> C.Name -> ScopeM A.Name-freshAbstractName fx x = do- i <- fresh- return $ A.Name i x (getRange x) fx---- | @freshAbstractName_ = freshAbstractName defaultFixity@-freshAbstractName_ :: C.Name -> ScopeM A.Name-freshAbstractName_ = freshAbstractName defaultFixity'---- | Create a fresh abstract qualified name.-freshAbstractQName :: Fixity' -> C.Name -> ScopeM A.QName-freshAbstractQName fx x = do- y <- freshAbstractName fx x- m <- getCurrentModule- return $ A.qualify m y---- * Resolving names--data ResolvedName = VarName A.Name- | DefinedName Access AbstractName- | ConstructorName [AbstractName]- | UnknownName- deriving (Show)---- | Look up the abstract name referred to by a given concrete name.-resolveName :: C.QName -> ScopeM ResolvedName-resolveName x = do- scope <- getScope- let vars = map (C.QName -*- id) $ scopeLocals scope- case lookup x vars of- Just y -> return $ VarName $ y { nameConcrete = unqualify x }- Nothing -> case scopeLookup' x scope of- [] -> return UnknownName- ds | all ((==ConName) . anameKind . fst) ds ->- return $ ConstructorName- $ map (\ (d, _) -> updateConcreteName d $ unqualify x) ds- [(d, a)] -> return $ DefinedName a $ updateConcreteName d (unqualify x)- ds -> typeError $ AmbiguousName x (map (anameName . fst) ds)- where- updateConcreteName :: AbstractName -> C.Name -> AbstractName- updateConcreteName d@(AbsName { anameName = an@(A.QName { qnameName = qn }) }) x =- d { anameName = an { qnameName = qn { nameConcrete = x } } }---- | Look up a module in the scope.-resolveModule :: C.QName -> ScopeM AbstractModule-resolveModule x = do- ms <- scopeLookup x <$> getScope- case ms of- [AbsModule m] -> return $ AbsModule (m `withRangesOfQ` x)- [] -> typeError $ NoSuchModule x- ms -> typeError $ AmbiguousModule x (map amodName ms)---- | Get the fixity of a name. The name is assumed to be in scope.-getFixity :: C.QName -> ScopeM Fixity'-getFixity x = do- r <- resolveName x- case r of- VarName y -> return $ nameFixity y- DefinedName _ d -> return $ nameFixity $ qnameName $ anameName d- ConstructorName ds- | null fs -> __IMPOSSIBLE__- | allEqual fs -> return $ head fs- | otherwise -> return defaultFixity'- where- fs = map (nameFixity . qnameName . anameName) ds- UnknownName -> __IMPOSSIBLE__---- * Binding names---- | Bind a variable. The abstract name is supplied as the second argument.-bindVariable :: C.Name -> A.Name -> ScopeM ()-bindVariable x y = do- scope <- getScope- setScope scope { scopeLocals = (x, y) : scopeLocals scope }---- | Bind a defined name. Must not shadow anything.-bindName :: Access -> KindOfName -> C.Name -> A.QName -> ScopeM ()-bindName acc kind x y = do- r <- resolveName (C.QName x)- ys <- case r of- DefinedName _ d -> typeError $ ClashingDefinition (C.QName x) $ anameName d- VarName z -> typeError $ ClashingDefinition (C.QName x) $ A.qualify (mnameFromList []) z- ConstructorName [] -> __IMPOSSIBLE__- ConstructorName ds- | kind == ConName && all ((==ConName) . anameKind) ds -> return [ AbsName y kind ]- | otherwise -> typeError $ ClashingDefinition (C.QName x) $ anameName (head' ds)- UnknownName -> return [AbsName y kind]- modifyCurrentScope $ addNamesToScope (localNameSpace acc) x ys- where- head' [] = {- ' -} __IMPOSSIBLE__- head' (x:_) = x---- | Bind a module name.-bindModule :: Access -> C.Name -> A.ModuleName -> ScopeM ()-bindModule acc x m = modifyCurrentScope $- addModuleToScope (localNameSpace acc) x (AbsModule m)---- | Bind a qualified module name. Adds it to the imports field of the scope.-bindQModule :: Access -> C.QName -> A.ModuleName -> ScopeM ()-bindQModule acc q m = modifyCurrentScope $ \s ->- s { scopeImports = Map.insert q m (scopeImports s) }---- * Module manipulation operations---- | Clear the scope of any no names.-stripNoNames :: ScopeM ()-stripNoNames = modifyScopes $ Map.map strip- where- strip = mapScope (\_ -> stripN) (\_ -> stripN)- stripN m = Map.filterWithKey (const . notNoName) m- notNoName = not . isNoName--type Ren a = Map a a-type Out = (Ren A.ModuleName, Ren A.QName)-type WSM = StateT Out ScopeM---- | Create a new scope with the given name from an old scope. Renames--- public names in the old scope to match the new name and returns the--- renamings.-copyScope :: A.ModuleName -> Scope -> ScopeM (Scope, (Ren A.ModuleName, Ren A.QName))-copyScope new s = runStateT (copy new s) (Map.empty, Map.empty)- where- copy new s = do- s0 <- lift $ getNamedScope new- s' <- mapScopeM copyD copyM s- return $ s' { scopeName = scopeName s0- , scopeParents = scopeParents s0- }-- new' = killRange new- old = scopeName s-- copyM :: NameSpaceId -> ModulesInScope -> WSM ModulesInScope- copyM ImportedNS ms = return ms- copyM PrivateNS _ = return Map.empty- copyM PublicNS ms = traverse (mapM $ onMod renMod) ms- copyM OnlyQualifiedNS ms = traverse (mapM $ onMod renMod) ms-- copyD :: NameSpaceId -> NamesInScope -> WSM NamesInScope- copyD ImportedNS ds = return ds- copyD PrivateNS _ = return Map.empty- copyD PublicNS ds = traverse (mapM $ onName renName) ds- copyD OnlyQualifiedNS ds = traverse (mapM $ onName renName) ds-- onMod f m = do- x <- f $ amodName m- return m { amodName = x }-- onName f d = do- x <- f $ anameName d- return d { anameName = x }-- addName x y = addNames (Map.singleton x y)- addMod x y = addMods (Map.singleton x y)-- addNames rd' = modify $ \(rm, rd) -> (rm, Map.union rd rd')- addMods rm' = modify $ \(rm, rd) -> (Map.union rm rm', rd)-- findName x = Map.lookup x <$> gets snd- findMod x = Map.lookup x <$> gets fst-- -- Change a binding M.x -> old.M'.y to M.x -> new.M'.y- renName :: A.QName -> WSM A.QName- renName x = do- -- Check if we've seen it already- my <- findName x- case my of- Just y -> return y- Nothing -> do- -- First time, generate a fresh name for it- i <- lift fresh- let y = qualifyQ new' . dequalify- $ x { qnameName = (qnameName x) { nameId = i } }- addName x y- return y- where- dequalify = A.qnameFromList . drop (size old) . A.qnameToList-- -- Change a binding M.x -> old.M'.y to M.x -> new.M'.y- renMod :: A.ModuleName -> WSM A.ModuleName- renMod x = do- -- Check if we've seen it already- my <- findMod x- case my of- Just y -> return y- Nothing -> do- -- Create the name of the new module- let y = qualifyM new' $ dequalify x- addMod x y-- -- We need to copy the contents of included modules recursively- s0 <- lift $ createModule y >> getNamedScope x- s <- withCurrentModule' y $ copy y s0- lift $ modifyNamedScope y (const s)- return y- where- dequalify = A.mnameFromList . drop (size old) . A.mnameToList---- | Apply an importdirective and check that all the names mentioned actually--- exist.-applyImportDirectiveM :: C.QName -> ImportDirective -> Scope -> ScopeM Scope-applyImportDirectiveM m dir scope = do- xs <- filterM doesntExist names- reportSLn "scope.import.apply" 20 $ "non existing names: " ++ show xs- case xs of- [] -> case targetNames \\ nub targetNames of- [] -> return $ applyImportDirective dir scope- dup -> typeError $ DuplicateImports m dup- _ -> typeError $ ModuleDoesntExport m xs- where- names :: [ImportedName]- names = map renFrom (renaming dir) ++ case usingOrHiding dir of- Using xs -> xs- Hiding xs -> xs-- targetNames :: [ImportedName]- targetNames = map renName (renaming dir) ++ case usingOrHiding dir of- Using xs -> xs- Hiding{} -> []- where- renName r = (renFrom r) { importedName = renTo r }-- doesntExist (ImportedName x) =- case Map.lookup x (allNamesInScope scope :: ThingsInScope AbstractName) of- Just _ -> return False- Nothing -> return True- doesntExist (ImportedModule x) =- case Map.lookup x (allNamesInScope scope :: ThingsInScope AbstractModule) of- Just _ -> return False- Nothing -> return True---- | Open a module.-openModule_ :: C.QName -> ImportDirective -> ScopeM ()-openModule_ cm dir = do- current <- getCurrentModule- m <- amodName <$> resolveModule cm- let ns = namespace current m- s <- setScopeAccess ns <$>- (applyImportDirectiveM cm dir . removeOnlyQualified . restrictPrivate =<< getNamedScope m)- checkForClashes (scopeNameSpace ns s)- modifyCurrentScope (`mergeScope` s)- where- namespace m0 m1- | not (publicOpen dir) = PrivateNS- | m1 `isSubModuleOf` m0 = PublicNS- | otherwise = ImportedNS-- -- Only checks for clashes that would lead to the same- -- name being exported twice from the module.- checkForClashes new- | not (publicOpen dir) = return ()- | otherwise = do-- old <- allThingsInScope . restrictPrivate <$> (getNamedScope =<< getCurrentModule)-- let defClashes = Map.toList $ Map.intersectionWith (,) (nsNames new) (nsNames old)- modClashes = Map.toList $ Map.intersectionWith (,) (nsModules new) (nsModules old)-- realClash (_, ([x],[y])) = x /= y- realClash _ = True-- defClash (_, (qs0, qs1)) =- any ((/= ConName) . anameKind) (qs0 ++ qs1)-- (f & g) x = f x && g x-- case filter (realClash & defClash) defClashes of- (x, (_, q:_)):_ -> typeError $ ClashingDefinition (C.QName x) (anameName q)- _ -> return ()- case filter realClash modClashes of- (_, (m0:_, m1:_)):_ -> typeError $ ClashingModule (amodName m0) (amodName m1)- _ -> return ()+{-# LANGUAGE NondecreasingIndentation #-}++{-| The scope monad with operations.+-}++module Agda.Syntax.Scope.Monad (module Agda.Syntax.Scope.Monad, module Agda.Syntax.Scope.State) where++import Prelude hiding (null)++import Control.Monad.Except ( MonadError, throwError, runExceptT )+import Control.Monad.State ( StateT, runStateT, gets, modify )+import Control.Monad.Trans ( MonadTrans, lift )+import Control.Monad.IO.Class++import Data.Either ( partitionEithers )+import Data.Foldable (all, traverse_)+import qualified Data.List as List+import Data.Map (Map)+import qualified Data.HashMap.Strict as HMap+import qualified Data.HashSet as HSet+import qualified Data.Map as Map+import Data.IORef+import Data.Maybe+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Traversable hiding (for)++import Agda.Interaction.Options+import Agda.Interaction.Options.Warnings++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Position+import Agda.Syntax.Fixity+import Agda.Syntax.Notation+import Agda.Syntax.Abstract.Name as A+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Abstract (ScopeCopyInfo(..))+import Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Fixity+import Agda.Syntax.Concrete.Definitions ( DeclarationWarning(..) ,DeclarationWarning'(..) )+ -- TODO: move the relevant warnings out of there+import Agda.Syntax.Scope.Base as A+import Agda.Syntax.Scope.State+import Agda.Syntax.Scope.UnusedImports (lookedupModule, registerModuleOpening)++import Agda.TypeChecking.Monad.Base as I+import Agda.TypeChecking.Monad.Builtin+ ( HasBuiltins, getBuiltinName'+ , builtinProp, builtinSet, builtinStrictSet, builtinPropOmega, builtinSetOmega, builtinSSetOmega )+import Agda.TypeChecking.Monad.Debug+import Agda.TypeChecking.Monad.State+import Agda.TypeChecking.Monad.Trace+import Agda.TypeChecking.Positivity.Occurrence ( PragmaPolarities, Occurrence )+import Agda.TypeChecking.Warnings ( warning, warning' )++import qualified Agda.Utils.AssocList as AssocList+import Agda.Utils.CallStack ( CallStack, HasCallStack, withCallerCallStack )+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|), nonEmpty, toList)+import Agda.Utils.List2 (List2(List2), toList)+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.List2 as List2+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Set1 ( Set1 )+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Singleton+import Agda.Utils.Suffix as C+import Agda.Utils.Tuple ((***), pattern Pair)++import Agda.Utils.Impossible++-- Debugging++printLocals :: Int -> String -> ScopeM ()+printLocals v s = verboseS "scope.top" v $ do+ locals <- getLocalVars+ reportSLn "scope.top" v $ s ++ " " ++ prettyShow locals++scopeWarning' :: CallStack -> DeclarationWarning' -> ScopeM ()+scopeWarning' loc = warning' loc . NicifierIssue . DeclarationWarning loc++scopeWarning :: HasCallStack => DeclarationWarning' -> ScopeM ()+scopeWarning = withCallerCallStack scopeWarning'++---------------------------------------------------------------------------+-- * General operations+---------------------------------------------------------------------------++isDatatypeModule :: ReadTCState m => A.ModuleName -> m (Maybe DataOrRecordModule)+isDatatypeModule m = do+ scopeDatatypeModule . Map.findWithDefault __IMPOSSIBLE__ m <$> useScope scopeModules++getNamedScope :: A.ModuleName -> ScopeM Scope+getNamedScope m = do+ scope <- getScope+ case Map.lookup m (scope ^. scopeModules) of+ Just s -> return s+ Nothing -> do+ reportSLn "" 0 $ "ERROR: In scope\n" ++ prettyShow scope ++ "\nNO SUCH SCOPE " ++ prettyShow m+ __IMPOSSIBLE__++getCurrentScope :: ScopeM Scope+getCurrentScope = getNamedScope =<< getCurrentModule++-- | Create a new module with an empty scope.+-- If the module is not new (e.g. duplicate @import@),+-- don't erase its contents.+-- (@Just@ if it is a datatype or record module.)+createModule :: Maybe DataOrRecordModule -> A.ModuleName -> ScopeM ()+createModule b m = do+ reportSLn "scope.createModule" 30 $ "createModule " ++ prettyShow m+ s <- getCurrentScope+ let parents = scopeName s : scopeParents s+ sm = emptyScope { scopeName = m+ , scopeParents = parents+ , scopeDatatypeModule = b }+ -- Andreas, 2015-07-02: internal error if module is not new.+ -- Ulf, 2016-02-15: It's not new if multiple imports (#1770).+ -- Andreas, 2020-05-18, issue #3933:+ -- If it is not new (but apparently did not clash),+ -- we do not erase its contents for reasons of monotonicity.+ modifyScopes $ Map.insertWith mergeScope m sm+ -- András, 2025-08-30: TODO: only inverse modules need to be recomputed+ recomputeInverseScope++-- | Apply a function to the scope map.+modifyScopes :: (Map A.ModuleName Scope -> Map A.ModuleName Scope) -> ScopeM ()+modifyScopes = modifyScope . over scopeModules++-- | Apply a function to the given scope.+modifyNamedScope :: A.ModuleName -> (Scope -> Scope) -> ScopeM ()+modifyNamedScope m f = modifyScopes $ Map.adjust f m++-- | Apply a function to the current scope.+modifyCurrentScope :: (Scope -> Scope) -> ScopeM ()+modifyCurrentScope f = getCurrentModule >>= (`modifyNamedScope` f)++setContextPrecedence :: PrecedenceStack -> ScopeM ()+setContextPrecedence = modifyScope . set scopePrecedence++withContextPrecedence :: ReadTCState m => Precedence -> m a -> m a+withContextPrecedence p =+ locallyTCState (stScope . scopePrecedence) $ pushPrecedence p++getLocalVars :: ReadTCState m => m LocalVars+getLocalVars = useScope scopeLocals++modifyLocalVars :: (LocalVars -> LocalVars) -> ScopeM ()+modifyLocalVars = modifyScope . updateScopeLocals++setLocalVars :: LocalVars -> ScopeM ()+setLocalVars vars = modifyLocalVars $ const vars++-- | Run a computation without changing the local variables.+withLocalVars :: ScopeM a -> ScopeM a+withLocalVars = bracket_ getLocalVars setLocalVars++-- | Run a computation outside some number of local variables and add them back afterwards. This+-- lets you bind variables in the middle of the context and is used when binding generalizable+-- variables (#3735).+outsideLocalVars :: Int -> ScopeM a -> ScopeM a+outsideLocalVars n m = do+ inner <- take n <$> getLocalVars+ modifyLocalVars (drop n)+ x <- m+ modifyLocalVars (inner ++)+ return x++-- | Check that the newly added variable have unique names.++withCheckNoShadowing :: ScopeM a -> ScopeM a+withCheckNoShadowing = bracket_ getLocalVars $ \ lvarsOld ->+ checkNoShadowing lvarsOld =<< getLocalVars++checkNoShadowing :: LocalVars -- ^ Old local scope+ -> LocalVars -- ^ New local scope+ -> ScopeM ()+checkNoShadowing old new = do+ opts <- pragmaOptions+ when (ShadowingInTelescope_ `Set.member`+ (optWarningMode opts ^. warningSet)) $ do+ -- LocalVars is currnently an AssocList so the difference between+ -- two local scope is the left part of the new one.+ let diff = dropEnd (length old) new+ -- Filter out the underscores.+ let newNames = filter (not . isNoName) $ AssocList.keys diff+ -- Associate each name to its occurrences.+ let nameOccs1 :: [(C.Name, List1 Range)]+ nameOccs1 = Map.toList $ Map.fromListWith (<>) $ map pairWithRange newNames+ -- Warn if we have two or more occurrences of the same name.+ let nameOccs2 :: [(C.Name, List2 Range)]+ nameOccs2 = mapMaybe (traverseF List2.fromList1Maybe) nameOccs1+ caseList nameOccs2 (return ()) $ \ c conflicts -> do+ scopeWarning $ ShadowingInTelescope $ c :| conflicts+ where+ pairWithRange :: C.Name -> (C.Name, List1 Range)+ pairWithRange n = (n, singleton $ getRange n)++getVarsToBind :: ScopeM LocalVars+getVarsToBind = useScope scopeVarsToBind++addVarToBind :: C.Name -> LocalVar -> ScopeM ()+addVarToBind x y = modifyScope $ updateVarsToBind $ AssocList.insert x y++-- | After collecting some variable names in the scopeVarsToBind,+-- bind them all simultaneously.+bindVarsToBind :: ScopeM ()+bindVarsToBind = do+ vars <- getVarsToBind+ modifyLocalVars (vars ++)+ printLocals 30 "bound variables:"+ modifyScope $ setVarsToBind []++annotateDecls :: ReadTCState m => m [A.Declaration] -> m (Maybe A.Declaration)+annotateDecls m = do+ forMM (List1.nonEmpty <$> m) \ ds1 -> do+ getScope <&> (`A.ScopedDecl` ds1)++annotateExpr :: ReadTCState m => m A.Expr -> m A.Expr+annotateExpr m = do+ e <- m+ s <- getScope+ return $ A.ScopedExpr s e++---------------------------------------------------------------------------+-- * Names+---------------------------------------------------------------------------++-- | Create a fresh abstract name from a concrete name.+--+-- This function is used when we translate a concrete name+-- in a binder. The 'Range' of the concrete name is+-- saved as the 'nameBindingSite' of the abstract name.+freshAbstractName :: Fixity' -> C.Name -> ScopeM A.Name+freshAbstractName fx x = do+ i <- fresh+ return $ A.Name+ { _nameId = i+ , nameConcrete = x+ , nameCanonical = x+ , _nameBindingSite = getRange x+ , nameFixity = fx+ , nameIsRecordName = False+ }++-- | @freshAbstractName_ = freshAbstractName noFixity'@+freshAbstractName_ :: C.Name -> ScopeM A.Name+freshAbstractName_ = freshAbstractName noFixity'++-- | Create a fresh abstract qualified name.+freshAbstractQName :: Fixity' -> C.Name -> ScopeM A.QName+freshAbstractQName fx x = do+ y <- freshAbstractName fx x+ m <- getCurrentModule+ return $ A.qualify m y++freshAbstractQName' :: C.Name -> ScopeM A.QName+freshAbstractQName' x = do+ fx <- getConcreteFixity x+ freshAbstractQName fx x++-- | Create a concrete name that is not yet in scope.+-- | NOTE: See @chooseName@ in @Agda.Syntax.Translation.AbstractToConcrete@ for similar logic.+-- | NOTE: See @withName@ in @Agda.Syntax.Translation.ReflectedToAbstract@ for similar logic.+freshConcreteName :: Range -> Int -> String -> ScopeM C.Name+freshConcreteName r i s = do+ let cname = C.Name r C.NotInScope $ singleton $ Id $ stringToRawName $ s ++ show i+ resolveName (C.QName cname) >>= \case+ UnknownName -> return cname+ _ -> freshConcreteName r (i + 1) s++---------------------------------------------------------------------------+-- * Resolving names+---------------------------------------------------------------------------++-- | Look up the abstract name referred to by a given concrete name.+resolveName :: C.QName -> ScopeM ResolvedName+resolveName = resolveName' allKindsOfNames Nothing++-- | Look up the abstract name corresponding to a concrete name of+-- a certain kind and/or from a given set of names.+-- Sometimes we know already that we are dealing with a constructor+-- or pattern synonym (e.g. when we have parsed a pattern).+-- Then, we can ignore conflicting definitions of that name+-- of a different kind. (See issue 822.)+resolveName' ::+ KindsOfNames -> Maybe (Set1 A.Name) -> C.QName -> ScopeM ResolvedName+resolveName' kinds names x = runExceptT (tryResolveName kinds names x) >>= \case+ Left (IllegalAmbiguity reason) -> do+ reportS "scope.resolve" 60 $ unlines $+ "resolveName': ambiguous name" :+ map (show . qnameName) (toList $ ambiguousNamesInReason reason)+ setCurrentRange x $ typeError $ AmbiguousName x reason++ Left (ConstrOfNonRecord q r) -> case r of+ UnknownName -> setCurrentRange x $ typeError $ I.NotInScope q+ _ -> setCurrentRange x $ typeError $ ConstructorNameOfNonRecord r++ Right x' -> pure x'++tryResolveName :: forall m. (ReadTCState m, HasBuiltins m, MonadError NameResolutionError m)+ => KindsOfNames+ -- ^ Restrict search to these kinds of names.+ -> Maybe (Set1 A.Name)+ -- ^ Unless 'Nothing', restrict search to match any of these names.+ -> C.QName+ -- ^ Name to be resolved+ -> m ResolvedName+ -- ^ If illegally ambiguous, throw error with the ambiguous name.+tryResolveName kinds names x = do+ scope <- getScope+ let+ vars = AssocList.mapKeysMonotonic C.QName $ scope ^. scopeLocals+ throwAmb = throwError . IllegalAmbiguity++ case lookup x vars of++ -- Case: we have a local variable x, but is (perhaps) shadowed by some imports ys.+ Just var@(LocalVar y b ys) ->+ -- We may ignore the imports filtered out by the @names@ filter.+ case nonEmpty $ filterNames id ys of+ Nothing -> return $ VarName y{ nameConcrete = unqualify x } b+ Just ys' -> throwAmb $ AmbiguousLocalVar var ys'++ -- Case: we do not have a local variable x.+ Nothing -> do+ -- Consider only names that are in the given set of names and+ -- are of one of the given kinds+ let filtKind = filter $ (`elemKindsOfNames` kinds) . anameKind . fst+ possibleNames z = filtKind $ filterNames fst $ scopeLookup' z scope+ -- If the name has a suffix, also consider the possibility that+ -- the base name is in scope (e.g. the builtin sorts `Set` and `Prop`).+ canHaveSuffix <- canHaveSuffixTest+ let (xsuffix, xbase) = (C.lensQNameName . nameSuffix) (,Nothing) x+ possibleBaseNames = filter (canHaveSuffix . anameName . fst) $ possibleNames xbase+ suffixedNames = (,) <$> fromConcreteSuffix xsuffix <*> nonEmpty possibleBaseNames+ case (nonEmpty $ possibleNames x) of+ Just ds | Just ks <- traverse (isConName . anameKind . fst) ds+ -- all names resolve to a constructor name+ , isNothing suffixedNames ->+ return $ ConstructorName (Set1.fromList ks) $ fmap (upd . fst) ds++ Just ds | all ((FldName ==) . anameKind . fst) ds , isNothing suffixedNames ->+ return $ FieldName $ fmap (upd . fst) ds++ Just ds | all ((PatternSynName ==) . anameKind . fst) ds , isNothing suffixedNames ->+ return $ PatternSynResName $ fmap (upd . fst) ds++ Just ((d, a) :| ds) -> case (suffixedNames, ds) of+ (Nothing, []) ->+ return $ DefinedName a (upd d) A.NoSuffix+ (Nothing, (d',_) : ds') ->+ throwAmb $ AmbiguousDeclName $ List2 d d' $ map fst ds'+ (Just (_, ss), _) ->+ throwAmb $ AmbiguousDeclName $ List2.append (d :| map fst ds) (fmap fst ss)++ Nothing -> case suffixedNames of+ -- Name is of the form R.constructor but did not resolve.+ -- Since the record constructor is bound as @constructor@ in the+ -- scope of the record module R (see 'bindRecordConstructorPseudoName'),+ -- this means that R is not (the module of) a record type.+ -- Produce a more informative error than "not in scope".+ Nothing | Just r <- isRecordConstructor x -> do+ -- We resolve the record name r with no filter, that way we+ -- can know when printing an error message whether r is not in+ -- scope, or whether it's some other type of name, etc.+ tryResolveName AllKindsOfNames Nothing r >>= \case+ -- If R does resolve to a record type, its constructor is+ -- simply not in scope here; report the plain not-in-scope error.+ DefinedName _ d _ | anameKind d == RecName -> return UnknownName+ -- If R is not a name but a module (e.g. a copy of a record module),+ -- report R.constructor rather than R as not in scope.+ UnknownName | not $ null (scopeLookup r scope :: [AbstractModule]) ->+ return UnknownName+ recd -> throwError $ ConstrOfNonRecord r recd++ Nothing -> return UnknownName+ Just (suffix , (d, a) :| []) -> return $ DefinedName a (upd d) suffix+ Just (suffix , (d1,_) :| (d2,_) : sds) ->+ throwAmb $ AmbiguousDeclName $ List2 d1 d2 $ map fst sds++ where+ -- @names@ intended semantics: a filter on names.+ -- @Nothing@: don't filter out anything.+ -- @Just ns@: filter by membership in @ns@.+ filterNames :: forall a. (a -> AbstractName) -> [a] -> [a]+ filterNames = case names of+ Nothing -> \ f -> id+ Just ns -> \ f -> filter $ (`Set1.member` ns) . A.qnameName . anameName . f+ -- lambda-dropped style by intention+ upd d = updateConcreteName d $ unqualify x+ updateConcreteName :: AbstractName -> C.Name -> AbstractName+ updateConcreteName d@(AbsName { anameName = A.QName qm qn }) x =+ d { anameName = A.QName (setRange (getRange x) qm) (qn { nameConcrete = x }) }+ fromConcreteSuffix = \case+ Nothing -> Nothing+ Just C.Prime{} -> Nothing+ Just (C.Index i) -> Just $ A.Suffix i+ Just (C.Subscript i) -> Just $ A.Suffix i++-- | Test if a given abstract name can appear with a suffix. Currently+-- only true for the names of builtin sorts.+canHaveSuffixTest :: HasBuiltins m => m (A.QName -> Bool)+canHaveSuffixTest = do+ builtinProp <- getBuiltinName' builtinProp+ builtinSet <- getBuiltinName' builtinSet+ builtinSSet <- getBuiltinName' builtinStrictSet+ builtinPropOmega <- getBuiltinName' builtinPropOmega+ builtinSetOmega <- getBuiltinName' builtinSetOmega+ builtinSSetOmega <- getBuiltinName' builtinSSetOmega+ return $ \x -> Just x `elem` [builtinProp, builtinSet, builtinSSet, builtinPropOmega, builtinSetOmega, builtinSSetOmega]++-- | Look up a module in the scope.+-- Marks the module as used for the unused-imports analysis.+resolveModule :: C.QName -> ScopeM AbstractModule+resolveModule x = do+ ms <- scopeLookup x <$> getScope+ caseMaybe (nonEmpty ms) (typeError $ NoSuchModule x) $ \ case+ AbsModule m why :| [] -> do+ let am = AbsModule (m `withRangeOf` x) why+ am <$ lookedupModule x am+ ms -> typeError $ AmbiguousModule x (fmap amodName ms)++-- | Get the fixity of a not yet bound name.+getConcreteFixity :: C.Name -> ScopeM Fixity'+getConcreteFixity x = Map.findWithDefault noFixity' x <$> useScope scopeFixities++-- | Get the polarities of a not yet bound name.+getConcretePolarity :: C.Name -> ScopeM (Maybe PragmaPolarities)+getConcretePolarity x = Map.lookup x <$> useScope scopePolarities++instance MonadFixityError ScopeM where+ throwMultipleFixityDecls xs = case xs of+ (_, Pair _ f2) :| _ -> setCurrentRange (theNameRange f2) $ typeError $ MultipleFixityDecls xs+ throwMultiplePolarityPragmas xs = case xs of+ x :| _ -> setCurrentRange (getRange x) $ typeError $ MultiplePolarityPragmas xs+ warnUnknownNamesInFixityDecl = scopeWarning . UnknownNamesInFixityDecl+ warnUnknownNamesInPolarityPragmas = scopeWarning . UnknownNamesInPolarityPragmas+ warnUnknownFixityInMixfixDecl = scopeWarning . UnknownFixityInMixfixDecl+ warnPolarityPragmasButNotPostulates = scopeWarning . PolarityPragmasButNotPostulates+ warnEmptyPolarityPragma = scopeWarning . EmptyPolarityPragma+ warnFixityDeclarationForNonOperator r x = scopeWarning $ FixityDeclarationForNonOperator r x++-- | Collect the fixity/syntax declarations and polarity pragmas from the list+-- of declarations and store them in the scope.+computeFixitiesAndPolarities :: DoWarn -> [C.Declaration] -> ScopeM a -> ScopeM a+computeFixitiesAndPolarities warn ds cont = do+ !fp <- fixitiesAndPolarities warn ds+ -- Andreas, 2019-08-16:+ -- Since changing fixities and polarities does not affect the name sets,+ -- we do not need to invoke @modifyScope@ here+ -- (which does @recomputeInverseScopeMaps@).+ -- A simple @locallyScope@ is sufficient.+ locallyScope scopeFixitiesAndPolarities (const fp) cont++-- | Get the notation of a name. The name is assumed to be in scope.+getNotation+ :: C.QName+ -> Set1 A.Name+ -- ^ The name must correspond to one of the names in this set.+ -> ScopeM NewNotation+getNotation x ns = do+ r <- resolveName' allKindsOfNames (Just ns) x+ case r of+ VarName y _ -> return $ namesToNotation x y+ DefinedName _ d _ -> return $ notation d+ FieldName ds -> return $ oneNotation ds+ ConstructorName _ ds-> return $ oneNotation ds+ PatternSynResName n -> return $ oneNotation n+ UnknownName -> __IMPOSSIBLE__+ where+ notation = namesToNotation x . qnameName . anameName+ oneNotation = List1.head . mergeNotations . fmap notation++---------------------------------------------------------------------------+-- * Binding names+---------------------------------------------------------------------------++-- | Bind a variable.+bindVariable+ :: A.BindingSource -- ^ @λ@, @Π@, @let@, ...?+ -> C.Name -- ^ Concrete name.+ -> A.Name -- ^ Abstract name.+ -> ScopeM ()+bindVariable b x y = modifyLocalVars $ AssocList.insert x $ LocalVar y b []++-- | Temporarily unbind a variable. Used for non-recursive lets.+unbindVariable :: C.Name -> ScopeM a -> ScopeM a+unbindVariable x = bracket_ (getLocalVars <* modifyLocalVars (AssocList.delete x)) (modifyLocalVars . const)++-- | Bind a defined name. Must not shadow anything.+bindName :: Access -> KindOfName -> C.Name -> A.QName -> ScopeM ()+bindName acc kind x y = bindName' acc kind noMetadata x y++bindName' :: Access -> KindOfName -> NameMetadata -> C.Name -> A.QName -> ScopeM ()+bindName' acc kind meta x y = whenJustM (bindName'' acc kind meta x y) typeError++addNameToInverseScope :: KindOfName -> C.Name -> AbstractName -> ScopeInfo -> ScopeInfo+addNameToInverseScope kind x y s =+ let !y' = anameName y+ in s { _scopeInScope = Set.insert y' (_scopeInScope s)+ , _scopeInverseName = HMap.insertWith (<>) (A.nameId y')+ (NameMapEntry kind (C.QName x :| [])) (_scopeInverseName s)+ }++-- | Bind a name. Returns the 'TypeError' if exists, but does not throw it.+bindName'' :: Access -> KindOfName -> NameMetadata -> C.Name -> A.QName -> ScopeM (Maybe TypeError)+bindName'' acc kind meta x y = do+ when (isNoName x) $ do+ modifyScopes $ Map.map $ removeNameFromScope PrivateNS x+ recomputeInverseScope+ r <- resolveName (C.QName x)+ let y' :: Either TypeError AbstractName+ y' = case r of+ -- Binding an anonymous declaration always succeeds.+ -- In case it's not the first one, we simply remove the one that came before+ _ | isNoName x -> success+ DefinedName _ d _ -> clash $ ClashingAbstractName d+ VarName z _ -> clash $ ClashingQName $ A.qualify_ z+ FieldName ds -> ambiguous (== FldName) ds+ ConstructorName i ds-> ambiguous (isJust . isConName) ds+ PatternSynResName n -> ambiguous (== PatternSynName) n+ UnknownName -> success+ let ns = if isNoName x then PrivateNS else localNameSpace acc+ forM_ y' \y' -> do+ modifyCurrentScope $ addNameToScope ns x y'+ modifyScope $ addNameToInverseScope kind x y'+ pure $ either Just (const Nothing) y'+ where+ success = Right $ AbsName y kind Defined meta+ clash n = Left $ ClashingDefinition (C.QName x) n Nothing++ ambiguous f ds =+ if f kind && all (f . anameKind) ds+ then success else clash $ ClashingAbstractName $ List1.head ds++-- | Rebind a name. Use with care!+-- Ulf, 2014-06-29: Currently used to rebind the name defined by an+-- unquoteDecl, which is a 'QuotableName' in the body, but a 'DefinedName'+-- later on.+rebindName :: Access -> KindOfName -> NameMetadata -> C.Name -> A.QName -> ScopeM ()+rebindName acc kind meta x y = do+ if kind == ConName then do+ modifyCurrentScope $+ mapScopeNS (localNameSpace acc)+ (Map.update (nonEmpty . List1.filter ((ConName ==) . anameKind)) x)+ id+ id+ else do+ modifyCurrentScope $ removeNameFromScope (localNameSpace acc) x+ recomputeInverseScope+ bindName' acc kind meta x y++-- András, 2025-08-30: TODO: directly extend inverse scope.+-- | Bind a module name.+bindModule :: Access -> C.Name -> A.ModuleName -> ScopeM ()+bindModule acc x m = do+ modifyCurrentScope $ addModuleToScope (localNameSpace acc) x (AbsModule m Defined)+ recomputeInverseScope++-- | Bind a qualified module name. Adds it to the imports field of the scope.+bindQModule :: Access -> C.QName -> A.ModuleName -> ScopeM ()+bindQModule acc q m = do+ modifyCurrentScope $ \s -> s { scopeImports = Map.insert q m (scopeImports s) }+ recomputeInverseScope++---------------------------------------------------+-- * Operations to do with record constructor names+---------------------------------------------------++-- | Bind the pseudo-name @constructor@ in the scope of the record module,+-- mapping it to the (possibly anonymous) constructor of the record.+--+-- This is what makes @R.constructor@ resolve: @R@ is the record /module/+-- and @constructor@ an ordinary name in it, so no special treatment is+-- needed when resolving the qualified name @R.constructor@.+--+-- Note that @constructor@ is a keyword, thus, it can never be parsed+-- as an unqualified name. In particular, @open R@ does not make the+-- record constructor accessible under the name @constructor@, and+-- @constructor@ cannot be mentioned in @using@, @hiding@ or @renaming@.+--+-- This does not put the record constructor itself into the record module+-- (which would be wrong, see issue #4189, since the record module is+-- parameterized over the record value, but the constructor is not);+-- it only adds this alias for it.+bindRecordConstructorPseudoName :: A.ModuleName -> KindOfName -> A.QName -> ScopeM ()+bindRecordConstructorPseudoName m kind y = do+ modifyNamedScope m $+ addNameToScope PublicNS recordConstructorPseudoName $+ AbsName y kind Defined noMetadata+ -- Note: we cannot use 'addNameToInverseScope' here, since that would+ -- register the unqualified (and thus unparseable) rendering @constructor@.+ recomputeInverseScope++-- | Remove the record constructor pseudo-name from the scope of a record module.+--+-- The alias @constructor@ is only meant to be used in the qualified form+-- @R.constructor@, where @R@ is the record module. Thus, it is not brought+-- into scope by @open R@.+--+-- It is also not copied when the record module @R@ itself is applied to+-- arguments (as in @module M = R@): the record module is parameterized over+-- the record value, but the record constructor is not (issue #4189).+-- (When @R@ is only copied as a submodule of the applied module, the+-- constructor is copied correctly, since the arguments are then taken from+-- the enclosing module.)+dropRecordConstructorPseudoName :: Scope -> Scope+dropRecordConstructorPseudoName s+ | Just IsRecordModule <- scopeDatatypeModule s =+ -- We don't have enough information for an incremental update of the+ -- in-scope sets, so recompute them (cheap: record modules are small).+ recomputeInScopeSets $ mapScope_ (Map.delete recordConstructorPseudoName) id id s+ | otherwise = s++-- | The pseudo-name @constructor@ under which the constructor of a record+-- is bound in the scope of the record module.+--+-- Since @constructor@ is a keyword, this name is only reachable+-- as the tail of a qualified name, e.g., @R.constructor@.+recordConstructorPseudoName :: C.Name+recordConstructorPseudoName = C.simpleName "constructor"++-- | Is this the qualified name which refers to the constructor of a+-- record (like @Foo.constructor@)?+--+-- If so, return the part of the name referring to the record (@Foo@).+--+-- This is only used to produce a good error message when @Foo.constructor@+-- does not resolve; the resolution itself goes through the ordinary+-- scope lookup, see 'bindRecordConstructorPseudoName'.+isRecordConstructor :: C.QName -> Maybe C.QName+isRecordConstructor = fmap to . toplevel where+ toplevel, is :: C.QName -> Maybe [C.Name]+ toplevel (Qual r n) = (r:) <$> is n+ toplevel _ = Nothing++ is (C.Qual r n) = (r:) <$> is n+ is (C.QName n) = case n of+ C.Name _ _ (Id w :| [])+ | w == "constructor" -> pure []+ _ -> Nothing++ to [] = __IMPOSSIBLE__+ to [x] = C.QName x+ to (x:xs) = C.Qual x (to xs)++---------------------------------------------------------------------------+-- * Module manipulation operations+---------------------------------------------------------------------------++-- | Clear the scope of any no names.+stripNoNames :: ScopeM ()+stripNoNames = do+ let stripN = Map.filterWithKey $ const . not . isNoName+ modifyScopes $ Map.map $ mapScope_ stripN stripN id+ recomputeInverseScope++type WSM = StateT ScopeMemo ScopeM++data ScopeMemo = ScopeMemo+ { memoNames :: A.Ren A.QName+ , memoModules :: Map ModuleName (ModuleName, Bool)+ -- ^ Bool: did we copy recursively? We need to track this because we don't+ -- copy recursively when creating new modules for reexported functions+ -- (issue1985), but we might need to copy recursively later.+ }++memoToScopeInfo :: ScopeMemo -> ScopeCopyInfo+memoToScopeInfo (ScopeMemo names mods) =+ ScopeCopyInfo+ { renNames = names+ , renModules = Map.map (pure . fst) mods+ }++-- | Mark a name as being a copy in the TC state, associating it with+-- the given 'A.ScopeCopyRef' for liveness information.+copyName :: A.QName -> A.QName -> ScopeM ()+copyName from to = do+ from <- fromMaybe from . HMap.lookup from <$> useTC stCopiedNames+ modifyTCLens stCopiedNames $ HMap.insert to from+ let+ k Nothing = Just (HSet.singleton to)+ k (Just s) = Just (HSet.insert to s)+ modifyTCLens stNameCopies $ HMap.alter k from++-- | Create a new scope with the given name from an old scope. Renames+-- public names in the old scope to match the new name and returns the+-- renamings.+copyScope :: C.QName -> A.ModuleName -> Scope -> ScopeM (Scope, ScopeCopyInfo)+copyScope oldc new0 s =+ (inScopeBecause (Applied oldc) *** memoToScopeInfo) <$>+ runStateT (copy new0 $ dropRecordConstructorPseudoName s) (ScopeMemo mempty mempty)+ where+ copy :: A.ModuleName -> Scope -> WSM Scope+ copy new s = do+ lift $ reportSLn "scope.copy" 20 $ "Copying scope " ++ prettyShow old ++ " to " ++ prettyShow new+ lift $ reportSLn "scope.copy" 50 $ prettyShow s+ s0 <- lift $ getNamedScope new+ -- Delete private names, then copy names and modules. Recompute inScope+ -- set and name parts rather than trying to copy them.+ s' <- recomputeNameParts . recomputeInScopeSets <$>+ mapScopeM_ copyD copyM return (setNameSpace PrivateNS emptyNameSpace s)+ -- Fix name and parent.+ return $ s' { scopeName = scopeName s0+ , scopeParents = scopeParents s0+ }+ where+ rnew = getRange new+ new' = killRange new+ newL = A.mnameToList new'+ old = scopeName s++ copyD :: NamesInScope -> WSM NamesInScope+ copyD = Map.traverseWithKey \ x -> mapM $ onName $ renNameFor x++ -- Andreas, 2026-08-23:+ -- The pseudo-name @constructor@ bound in a record module+ -- (see 'bindRecordConstructorPseudoName') is only an alias for the record+ -- constructor. If the record has a named constructor, the latter lives+ -- outside the record module, and copying the alias like an ordinary name+ -- would produce a second copy of the constructor (plus a spurious copy of+ -- the module the constructor lives in). Thus, reuse the existing copy.+ renNameFor :: C.Name -> A.QName -> WSM A.QName+ renNameFor x y+ | x == recordConstructorPseudoName =+ maybe (renName y) (return . List1.head) =<< findName y+ | otherwise = renName y++ copyM :: ModulesInScope -> WSM ModulesInScope+ copyM = traverse $ mapM $ lensAmodName renMod++ onName :: (A.QName -> WSM A.QName) -> AbstractName -> WSM AbstractName+ onName f d =+ case anameKind d of+ PatternSynName -> return d -- Pattern synonyms are simply aliased, not renamed+ _ -> lensAnameName f d++ -- Adding to memo structure.+ addName x y = modify $ \ i -> i { memoNames = Map.insertWith (<>) x (pure y) (memoNames i) }+ addMod x y rec = modify $ \ i -> i { memoModules = Map.insert x (y, rec) (memoModules i) }++ -- Querying the memo structure.+ findName :: A.QName -> WSM (Maybe (List1 A.QName))+ findName x = gets (Map.lookup x . memoNames)+ findMod x = gets (Map.lookup x . memoModules)++ refresh :: A.Name -> WSM A.Name+ refresh x = do+ i <- lift fresh+ return $ x { A._nameId = i }++ -- Change a binding M.x -> old.M'.y to M.x -> new.M'.y+ renName :: A.QName -> WSM A.QName+ renName x = do+ -- Issue 1985: For re-exported names we can't use new' as the+ -- module, since it has the wrong telescope. Example:+ --+ -- module M1 (A : Set) where+ -- module M2 (B : Set) where+ -- postulate X : Set+ -- module M3 (C : Set) where+ -- module M4 (D E : Set) where+ -- open M2 public+ --+ -- module M = M1.M3 A C+ --+ -- Here we can't copy M1.M2.X to M.M4.X since we need+ -- X : (B : Set) → Set, but M.M4 has telescope (D E : Set). Thus, we+ -- would break the invariant that all functions in a module share the+ -- module telescope. Instead we copy M1.M2.X to M.M2.X for a fresh+ -- module M2 that gets the right telescope.+ m <- if x `isInModule` old+ then return new'+ else renMod' False (qnameModule x)+ -- Don't copy recursively here, we only know that the+ -- current name x should be copied.+ -- Generate a fresh name for the target.+ -- Andreas, 2015-08-11 Issue 1619:+ -- Names copied by a module macro should get the module macro's+ -- range as declaration range+ -- (maybe rather the one of the open statement).+ -- For now, we just set their range+ -- to the new module name's one, which fixes issue 1619.+ y <- setRange rnew . A.qualify m <$> refresh (qnameName x)+ lift $ reportSLn "scope.copy" 50 $ " Copying " ++ prettyShow x ++ " to " ++ prettyShow y+ addName x y+ lift (copyName x y)+ return y++ -- Change a binding M.x -> old.M'.y to M.x -> new.M'.y+ renMod :: A.ModuleName -> WSM A.ModuleName+ renMod = renMod' True++ renMod' rec x = do+ -- Andreas, issue 1607:+ -- If we have already copied this module, return the copy.+ z <- findMod x+ case z of+ Just (y, False) | rec -> y <$ copyRec x y+ Just (y, _) -> return y+ Nothing -> do+ -- Ulf (issue 1985): If copying a reexported module we put it at the+ -- top-level, to make sure we don't mess up the invariant that all+ -- (abstract) names M.f share the argument telescope of M.+ let newM = if x `isLtChildModuleOf` old then newL else mnameToList new0++ y <- do+ -- Andreas, Jesper, 2015-07-02: Issue 1597+ -- Don't blindly drop a prefix of length of the old qualifier.+ -- If things are imported by open public they do not have the old qualifier+ -- as prefix. Those need just to be linked, not copied.+ -- return $ A.mnameFromList $ (newL ++) $ drop (size old) $ A.mnameToList x+ -- caseMaybe (stripPrefix (A.mnameToList old) (A.mnameToList x)) (return x) $ \ suffix -> do+ -- return $ A.mnameFromList $ newL ++ suffix+ -- Ulf, 2016-02-22: #1726+ -- We still need to copy modules from 'open public'. Same as in renName.+ y <- refresh $ lastWithDefault __IMPOSSIBLE__ $ A.mnameToList x+ return $ A.mnameFromList $ newM ++ [y]+ -- Andreas, Jesper, 2015-07-02: Issue 1597+ -- Don't copy a module over itself, it will just be emptied of its contents.+ if (x == y) then return x else do+ lift $ reportSLn "scope.copy" 50 $ " Copying module " ++ prettyShow x ++ " to " ++ prettyShow y+ addMod x y rec+ lift $ createModule Nothing y+ -- We need to copy the contents of included modules recursively (only when 'rec')+ when rec $ copyRec x y+ return y+ where+ copyRec x y = do+ s0 <- lift $ getNamedScope x+ s <- withCurrentModule' y $ copy y s0+ -- András, 2025-08-30: inverse scope will be computed immediately after copyScope returns+ lift $ modifyNamedScope y (const s)++---------------------------------------------------------------------------+-- * Import directives+---------------------------------------------------------------------------++-- | Warn about useless fixity declarations in @renaming@ directives.+-- Monadic for the sake of error reporting.+checkNoFixityInRenamingModule :: [C.Renaming] -> ScopeM ()+checkNoFixityInRenamingModule ren = do+ whenJust (nonEmpty $ mapMaybe rangeOfUselessInfix ren) $ \ rs -> do+ setCurrentRange rs $ do+ warning $ FixityInRenamingModule rs+ where+ rangeOfUselessInfix :: C.Renaming -> Maybe Range+ rangeOfUselessInfix = \case+ Renaming ImportedModule{} _ mfx _ -> getRange <$> mfx+ _ -> Nothing++-- | Warn about fixity declarations for targets that are non-operators+-- or closed operators:+checkNoFixityForClosedOperator :: [C.Renaming] -> ScopeM ()+checkNoFixityForClosedOperator ren = do+ forM_ ren \case+ Renaming (ImportedName _) (ImportedName x) mfx r+ | Just _ <- mfx, not (isPrePostOrInfixOperator x) -> warnFixityDeclarationForNonOperator r x+ | otherwise -> pure ()+ Renaming ImportedModule{} ImportedModule{} _ _ -> pure ()+ _ -> __IMPOSSIBLE__++-- | Apply an import directive and check that all the names mentioned actually+-- exist.+--+-- Monadic for the sake of error reporting.+applyImportDirectiveM+ :: C.QName -- ^ Name of the scope, only for error reporting.+ -> C.ImportDirective -- ^ Description of how scope is to be modified.+ -> Scope -- ^ Input scope.+ -> ScopeM (A.ImportDirective, Scope) -- ^ Scope-checked description, output scope.+applyImportDirectiveM m (ImportDirective rng usn' hdn' ren' public) scope0 = do++ -- Module names do not come with fixities, thus, we should complain if the+ -- user has supplied fixity annotations to @renaming module@ clauses.+ checkNoFixityInRenamingModule ren'++ -- Andreas, 2026-09-11, issue #1438+ -- Warn about fixities declared for non- or closed-operators.+ checkNoFixityForClosedOperator ren'+ -- TODO (post 2.9.0): purge fixity declarations for closed and non-operators.+ -- See also 'fixitiesAndPolarities.++ -- Andreas, 2020-06-06, issue #4707+ -- Duplicates in @using@ directive are dropped with a warning.+ usingList <- discardDuplicatesInUsing usn'++ -- Check that an import directive doesn't contain repeated names.+ -- Historic note:+ -- The following check was originally performed by the parser.+ -- The Great Ulf Himself added the check back in the dawn of time+ -- (5ba14b647b9bd175733f9563e744176425c39126)+ -- when Agda 2 wasn't even believed to exist yet.+ let names' = usingList ++ hdn' ++ map renFrom ren' -- all mentioned names from the imported module+ -- Report any duplicates in @names'@.+ List1.unlessNull (mapMaybe List2.fromList1Maybe $ List1.group $ List.sort names') \ yss ->+ setCurrentRange yss $ typeError $ RepeatedNamesInImportDirective yss++ -- We start by checking that all of the names talked about in the import+ -- directive do exist. If some do not then we remove them and raise a warning.+ let (missingExports, namesA) = checkExist names'+ () <- List1.unlessNull missingExports \ missingExports1 -> setCurrentRange rng do+ reportSLn "scope.import.apply" 30 $ "non existing names: " ++ prettyShow missingExports+ warning $ ModuleDoesntExport m (Map.keys namesInScope) (Map.keys modulesInScope) missingExports1++ -- We can now define a cleaned-up version of the import directive.+ let notMissing = not . (missingExports `hasElem`) -- #3997, efficient lookup in missingExports+ let usn = filter notMissing usingList -- remove missingExports from usn'+ let hdn = filter notMissing hdn' -- remove missingExports from hdn'+ let ren = filter (notMissing . renFrom) ren' -- and from ren'+ let dir = ImportDirective rng (mapUsing (const usn) usn') hdn ren public++ -- Convenient shorthands for defined names and names brought into scope:+ let names = map renFrom ren ++ hdn ++ usn+ let definedNames = map renTo ren+ let targetNames = usn ++ definedNames++ -- Efficient test of (`elem` names):+ let inNames = (names `hasElem`)++ -- Efficient test of whether a module import should be added to the import+ -- of a definition (like a data or record definition).+ let extra x = inNames (ImportedName x)+ && notMissing (ImportedModule x)+ && (not . inNames $ ImportedModule x)+ -- The last test implies that @hiding (module M)@ prevents @module M@+ -- from entering the @using@ list in @addExtraModule@.++ dir' <- sanityCheck (not . inNames) $ addExtraModules extra dir++ -- Check for duplicate imports in a single import directive.+ -- @dup@ : To be imported names that are mentioned more than once.+ () <- List1.unlessNull (allDuplicates targetNames) $ \ dup ->+ typeError $ DuplicateImports m dup++ -- Apply the import directive.+ let (scope', (nameClashes, moduleClashes)) = applyImportDirective_ dir' scope++ -- Andreas, 2019-11-08, issue #4154, report clashes+ -- introduced by the @renaming@.+ Set1.unlessNull nameClashes \ nameClashes ->+ warning $ ClashesViaRenaming NameNotModule nameClashes+ Set1.unlessNull moduleClashes \ moduleClashes ->+ warning $ ClashesViaRenaming ModuleNotName moduleClashes++ -- Look up the defined names in the new scope.+ let namesInScope' = (allNamesInScope scope' :: ThingsInScope AbstractName)+ let modulesInScope' = (allNamesInScope scope' :: ThingsInScope AbstractModule)+ let look x = List1.head . Map.findWithDefault __IMPOSSIBLE__ x+ -- We set the ranges to the ranges of the concrete names in order to get+ -- highlighting for the names in the import directive.++ let+ -- Amy, 2025-05-12: to support `record where`, we also need to+ -- update the concrete name of the "target" to match the concrete+ -- name that the user wrote--- otherwise we get import directives+ -- from user code like+ --+ -- open Some.Qualified renaming (original to new)+ --+ -- that print (and, more importantly, generate record fields!) like+ --+ -- renaming (Some.Qualifed.original to Some.Qualified.original)+ --+ -- because the new concrete name is a thin alias for the existing+ -- abstract QName, rather than+ --+ -- renaming (Some.Qualified.Original to new)+ --+ -- Andreas, 2026-10-02+ -- Even though @record where@ has been removed again, and @upd@+ -- does not make an observable difference any more, we can leave+ -- @upd@ in.++ upd :: C.Name -> A.QName -> A.QName+ upd x nm = setRange (getRange x) $ qualify_ $ (qnameName nm) { nameConcrete = x }++ definedA = for definedNames $ \case+ ImportedName x -> ImportedName . (x,) . upd x . anameName $ look x namesInScope'+ ImportedModule x -> ImportedModule . (x,) . setRange (getRange x) . amodName $ look x modulesInScope'++ let adir = mapImportDir namesA definedA dir+ return (adir, scope') -- TODO Issue 1714: adir++ where+ -- Andreas, 2020-06-23, issue #4773, fixing regression in 2.5.1.+ -- Import directive may not mention private things.+ -- ```agda+ -- module M where private X = Set+ -- module N = M using (X)+ -- ```+ -- Further, modules (N) need not copy private things (X) from other+ -- modules (M) ever, since they cannot legally referred to+ -- (neither through qualification (N.X) nor open N).+ -- Thus, we can unconditionally remove private definitions+ -- before we apply the import directive.+ scope = restrictPrivate scope0++ -- Return names in the @using@ directive, discarding duplicates.+ -- Monadic for the sake of throwing warnings.+ discardDuplicatesInUsing :: C.Using -> ScopeM [C.ImportedName]+ discardDuplicatesInUsing = \case+ UseEverything -> return []+ Using xs -> do+ let (ys, dups) = nubAndDuplicatesOn id xs+ List1.unlessNull dups $ warning . DuplicateUsing+ return ys++ -- If both @using@ and @hiding@ directive are present,+ -- the hiding directive may only contain modules whose twins are mentioned.+ -- Monadic for the sake of error reporting.+ sanityCheck notMentioned = \case+ dir@(ImportDirective{ using = Using{}, hiding = ys }) -> do+ let useless = \case+ ImportedName{} -> True+ ImportedModule y -> notMentioned (ImportedName y)+ () <- List1.unlessNull (filter useless ys) $ warning . UselessHiding+ -- We can empty @hiding@ now, since there is an explicit @using@ directive+ -- and @hiding@ served its purpose to prevent modules to enter the @Using@ list.+ return dir{ hiding = [] }+ dir -> return dir++ addExtraModules :: (C.Name -> Bool) -> C.ImportDirective -> C.ImportDirective+ addExtraModules extra dir =+ dir{ using = mapUsing (concatMap addExtra) $ using dir+ , hiding = concatMap addExtra $ hiding dir+ , impRenaming = concatMap extraRenaming $ impRenaming dir+ }+ where+ addExtra f@(ImportedName y) | extra y = [f, ImportedModule y]+ addExtra m = [m]++ extraRenaming = \case+ r@(Renaming (ImportedName y) (ImportedName z) _fixity rng) | extra y ->+ [ r , Renaming (ImportedModule y) (ImportedModule z) Nothing rng ]+ r -> [r]++ -- Names and modules (abstract) in scope before the import.+ namesInScope = (allNamesInScope scope :: ThingsInScope AbstractName)+ modulesInScope = (allNamesInScope scope :: ThingsInScope AbstractModule)+ concreteNamesInScope = (Map.keys namesInScope ++ Map.keys modulesInScope :: [C.Name])++ -- AST versions of the concrete names passed as an argument.+ -- We get back a pair consisting of a list of missing exports first,+ -- and a list of successful imports second.+ checkExist :: [ImportedName] -> ([ImportedName], [ImportedName' (C.Name, A.QName) (C.Name, A.ModuleName)])+ checkExist xs = partitionEithers $ for xs $ \ name -> case name of+ ImportedName x -> ImportedName . (x,) . setRange (getRange x) . anameName <$> resolve name x namesInScope+ ImportedModule x -> ImportedModule . (x,) . setRange (getRange x) . amodName <$> resolve name x modulesInScope+ where+ resolve :: Ord a => err -> a -> Map a (List1 b) -> Either err b+ resolve err x m = maybe (Left err) (Right . List1.head) $ Map.lookup x m++-- | Translation of @ImportDirective@.+mapImportDir+ :: (Ord n1, Ord m1)+ => [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of imported names.+ -> [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of names defined by this import.+ -> ImportDirective' n1 m1+ -> ImportDirective' n2 m2+mapImportDir src0 tgt0 (ImportDirective r u h ren open) =+ ImportDirective r+ (mapUsing (map (lookupImportedName src)) u)+ (map (lookupImportedName src) h)+ (map (mapRenaming src tgt) ren)+ open+ where+ src = importedNameMapFromList src0+ tgt = importedNameMapFromList tgt0++-- | A finite map for @ImportedName@s.++data ImportedNameMap n1 n2 m1 m2 = ImportedNameMap+ { inameMap :: Map n1 n2+ , imoduleMap :: Map m1 m2+ }++-- | Create a 'ImportedNameMap'.+importedNameMapFromList+ :: (Ord n1, Ord m1)+ => [ImportedName' (n1,n2) (m1,m2)]+ -> ImportedNameMap n1 n2 m1 m2+importedNameMapFromList = foldr (flip add) $ ImportedNameMap Map.empty Map.empty+ where+ add (ImportedNameMap nm mm) = \case+ ImportedName (x,y) -> ImportedNameMap (Map.insert x y nm) mm+ ImportedModule (x,y) -> ImportedNameMap nm (Map.insert x y mm)++-- | Apply a 'ImportedNameMap'.+lookupImportedName+ :: (Ord n1, Ord m1)+ => ImportedNameMap n1 n2 m1 m2+ -> ImportedName' n1 m1+ -> ImportedName' n2 m2+lookupImportedName (ImportedNameMap nm mm) = \case+ ImportedName x -> ImportedName $ Map.findWithDefault __IMPOSSIBLE__ x nm+ ImportedModule x -> ImportedModule $ Map.findWithDefault __IMPOSSIBLE__ x mm++-- | Translation of @Renaming@.+mapRenaming+ :: (Ord n1, Ord m1)+ => ImportedNameMap n1 n2 m1 m2 -- ^ Translation of 'renFrom' names and module names.+ -> ImportedNameMap n1 n2 m1 m2 -- ^ Translation of 'rento' names and module names.+ -> Renaming' n1 m1 -- ^ Renaming before translation (1).+ -> Renaming' n2 m2 -- ^ Renaming after translation (2).+mapRenaming src tgt (Renaming from to fixity r) =+ Renaming (lookupImportedName src from) (lookupImportedName tgt to) fixity r++---------------------------------------------------------------------------+-- * Opening a module+---------------------------------------------------------------------------++data OpenKind = LetOpenModule | TopOpenModule++noGeneralizedVarsIfLetOpen :: OpenKind -> Scope -> Scope+noGeneralizedVarsIfLetOpen TopOpenModule = id+noGeneralizedVarsIfLetOpen LetOpenModule = disallowGeneralizedVars++-- | Open a module.+openModule_ :: KwRange -> OpenKind -> C.QName -> C.ImportDirective -> ScopeM A.ImportDirective+openModule_ kwr kind cm dir = openModule kwr kind Nothing cm dir++-- | Open a module, possibly given an already resolved module name.+openModule :: KwRange -> OpenKind -> Maybe A.ModuleName -> C.QName -> C.ImportDirective -> ScopeM A.ImportDirective+openModule kwr kind mam cm dir = do+ current <- getCurrentModule+ m <- caseMaybe mam (amodName <$> resolveModule cm) return+ let acc | Nothing <- publicOpen dir = PrivateNS+ | m `isLtChildModuleOf` current = PublicNS+ | otherwise = ImportedNS++ -- Get the scope exported by module to be opened.+ (adir, s') <- applyImportDirectiveM cm dir . inScopeBecause (Opened cm) .+ dropRecordConstructorPseudoName .+ noGeneralizedVarsIfLetOpen kind =<< getNamedScope m+ registerModuleOpening kwr current cm dir s' -- For the unused import warning+ let s = setScopeAccess acc s'+ let ns = scopeNameSpace acc s+ modifyCurrentScope \current -> recomputeNameParts $ mergeScope current s+ recomputeInverseScope+ -- Andreas, 2018-06-03, issue #3057:+ -- If we simply check for ambiguous exported identifiers _after_+ -- importing the new identifiers into the current scope, we also+ -- catch the case of importing an ambiguous identifier.+ checkForClashes++ -- Importing names might shadow existing locals.+ verboseS "scope.locals" 30 $ do+ locals <- mapMaybe (\ (c,x) -> c <$ notShadowedLocal x) <$> getLocalVars+ let newdefs = Map.keys $ nsNames ns+ shadowed = locals `List.intersect` newdefs+ reportSLn "scope.locals" 30 $ "opening module shadows the following locals vars: " ++ prettyShow shadowed+ -- Andreas, 2014-09-03, issue 1266: shadow local variables by imported defs.+ modifyLocalVars $ AssocList.mapWithKey $ \ c x ->+ case Map.lookup c $ nsNames ns of+ Nothing -> x+ Just ys -> shadowLocal ys x++ return adir++ where+ -- Only checks for clashes that would lead to the same+ -- name being exported twice from the module.+ checkForClashes = when (isJust $ publicOpen dir) $ do++ exported <- allThingsInScope . restrictPrivate <$> (getNamedScope =<< getCurrentModule)++ -- Get all exported concrete names that are mapped to at least 2 abstract names+ let defClashes = filter (\ (_c, as) -> length as >= 2) $ Map.toList $ nsNames exported+ modClashes = filter (\ (_c, as) -> length as >= 2) $ Map.toList $ nsModules exported++ -- No ambiguity if concrete identifier is only mapped to+ -- constructor names or only to projection names or only to pattern synonyms.+ defClash (_, qs) = not $ or+ [ all (isJust . isConName) ks+ , all (== FldName) ks+ , all (== PatternSynName) ks+ ]+ where ks = fmap anameKind qs+ -- We report the first clashing exported identifier.+ () <- List1.unlessNull (filter defClash defClashes) $+ \ ((x, q :| _) :| _) -> typeError $ ClashingDefinition (C.QName x) (ClashingAbstractName q) Nothing++ List1.unlessNull modClashes $ \ ((_, ms) :| _) -> do+ caseMaybe (List1.last2 ms) __IMPOSSIBLE__ $ \ (m0, m1) -> do+ typeError $ ClashingModule (amodName m0) (amodName m1)
@@ -0,0 +1,220 @@++-- | Computing scopes of names that are relevant to parsing+-- some raw expression.+module Agda.Syntax.Scope.Operator+ ( OperatorScope(..)+ , getOperatorScope+ , getDefinedNames+ , localNames+ ) where++import Prelude hiding ( (||) )++import Control.Monad+import Data.Bifunctor+import Data.Either (partitionEithers)+import Data.Foldable+import Data.Map.Strict (Map)+import qualified Data.Map.Strict as Map++import Data.Set (Set)+import qualified Data.Set as Set++import Agda.Syntax.Abstract.Name (AbstractName (..), AbstractModule (..), KindOfName(..))+import Agda.Syntax.Abstract.Name qualified as A++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Concrete+import Agda.Syntax.Notation+import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Monad++import Agda.TypeChecking.Monad.Debug++import Agda.Utils.Boolean ( (||) )+import Agda.Utils.Function ( applyWhenJust )+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1, NonEmpty(..))+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.AssocList (AssocList)+import Agda.Utils.Impossible++-- | Looking up all name parts of a QName.+namePartScopeLookup :: QName -> ScopeInfo -> [Map Name (List1 AbstractName)]+namePartScopeLookup q scope = inAllScopes ++! imports+ where+ -- 1. Finding a name in the current scope and its parents.+ inAllScopes :: [Map Name (List1 AbstractName)]+ inAllScopes = concatMap' (findName q) allScopes++ -- 2. Finding a name in the imports belonging to an initial part of the qualifier.+ imports :: [Map Name (List1 AbstractName)]+ imports = do+ let -- return all possible splittings, e.g.+ -- splitName X.Y.Z = [(X, Y.Z), (X.Y, Z)]+ splitName :: QName -> [(QName, QName)]+ splitName (QName x) = []+ splitName (Qual x q) = ((QName x, q):) $! map' (\(m, r) -> (Qual x m, r)) (splitName q)++ (m, x) <- splitName q+ s <- allScopes+ m <- maybeToList $ Map.lookup m $ scopeImports s+ findName x $ restrictPrivate $ moduleScope m++ moduleScope :: A.ModuleName -> Scope+ moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules++ allScopes :: [Scope]+ allScopes = (current :) $! map' moduleScope (scopeParents current) where+ current = moduleScope $ scope ^. scopeCurrent++ findName :: QName -> Scope -> [Map Name (List1 AbstractName)]+ findName q0 s = case q0 of+ QName x -> do+ n <- nameStringParts x+ (_, ns) <- scopeNameSpaces s+ maybeToList $ Map.lookup n (nsNameParts ns)+ Qual x q -> do+ m <- amodName . fst <$!> findNameInScope x s+ let ss = restrictPrivate <$!> (Map.lookup m $ scope ^. scopeModules)+ s' <- maybeToList ss+ findName q s'++getOperatorScope :: Set QName -> ScopeInfo -> OperatorScope+getOperatorScope names scope = let++ nameList :: [QName]+ nameList = Set.toList names++ namePartSet :: Set NameParts+ namePartSet = let+ getParts :: QName -> NameParts+ getParts (QName x) = nameParts x+ getParts (Qual _ x) = getParts x++ go :: Set NameParts -> QName -> Set NameParts+ go acc x = let+ parts = getParts x+ goPart !acc Hole = acc+ goPart acc (Id x) = Set.insert (Id x :| []) acc+ in foldl' goPart (Set.insert parts acc) parts++ in foldl' go mempty nameList++ -- look up the name as a full identifier+ fullNameLookups :: [(QName, List1 AbstractName)]+ fullNameLookups = do+ qname <- nameList+ case scopeLookup qname scope of+ [] -> []+ a:as -> [(qname, a :| as)]++ requalify :: QName -> Name -> QName+ requalify qn n = case qn of+ QName _ -> QName n+ Qual x qn -> Qual x $! requalify qn n++ -- lookup all parts of a name as operator/notation parts+ namePartLookups :: [(QName, List1 AbstractName)]+ namePartLookups = do+ qname <- nameList+ map <- namePartScopeLookup qname scope+ (name, as) <- Map.toList map+ let !name' = requalify qname name+ pure (name', as)++ goLocals :: LocalVars -> (AssocList Name A.Name, Bool)+ goLocals ls = go ls mempty where+ go :: LocalVars -> Set Name -> (AssocList Name A.Name, Bool)+ go [] !seen = ([], False)+ go ((x, a):ls) seen | Set.member x seen = go ls seen+ go ((x, a):ls) seen = case notShadowedLocal a of+ Nothing -> go ls seen+ Just a ->+ let goNamePart = \case+ Id x -> Set.member (Id x :| []) namePartSet+ _ -> False+ goNotPart = \case+ IdPart x -> Set.member (Id (rangedThing x) :| []) namePartSet+ _ -> False+ not = theNotation (A.nameFixity a)+ parts = nameParts x+ anyOp = (any (== Hole) parts && any goNamePart parts) || any goNotPart not+ anyName = Set.member parts namePartSet+ (ls', anyOp') = go ls (Set.insert x seen)+ !anyOp'' = anyOp || anyOp'+ !ls'' = if anyOp || anyName then (x, a):ls' else ls'+ in (ls'', anyOp'')++ (locals, hasLocalOp) = goLocals (scope ^. scopeLocals)++ in if null namePartLookups && not hasLocalOp+ then OpScope False (Map.fromListWith (flip List1.union) fullNameLookups) locals+ else OpScope True (Map.fromListWith (flip List1.union) (fullNameLookups ++! namePartLookups)) locals+++-- | Compute all defined names in scope and their fixities/notations.+-- Note that overloaded names (constructors) can have several+-- fixities/notations. Then we 'mergeNotations'. (See issue 1194.)+getDefinedNames' :: (AbstractName -> Bool) -> OperatorScope -> [List1 NewNotation]+getDefinedNames' f (OpScope _ names _) =+ [ mergeNotations $ List1.map' (namesToNotation x . A.qnameName . anameName) ds+ | (x, ds) <- Map.toList names+ , any f ds+ ]+ -- Andreas, 2013-03-21 see Issue 822+ -- Names can have different kinds, i.e., 'defined' and 'constructor'.+ -- We need to consider all names that have *any* matching kind,+ -- not only those whose first appearing kind is matching.++getDefinedNames :: KindsOfNames -> OperatorScope -> [List1 NewNotation]+getDefinedNames kinds = getDefinedNames' (filterByKind kinds)++filterByKind :: KindsOfNames -> AbstractName -> Bool+filterByKind kinds = (`elemKindsOfNames` kinds) . anameKind++-- | Compute all names (first component) and operators/notations+-- (second component) in scope.+--+-- For 'IsPattern', only constructor-like names are returned.+--+localNames :: ExprKind -> Maybe QName -> OperatorScope -> ScopeM ([QName], [NewNotation])+localNames k top opScope@(OpScope _ _ locals) = do+ -- Construct a filter for the names we consider.+ let+ f = case k of+ IsExpr -> const True+ IsPattern YesDisplayLHS -> const True+ -- #8228: Non-constructor-like operators are useful in DISPLAY+ -- pragmas.+ IsPattern NoDisplayLHS -> let+ -- Andreas, 2025-02-28, issue #7722+ -- Filter by kind.+ -- Just return the constructor-like operators,+ -- otherwise the pattern parser blows up.+ fk = filterByKind (someKindsOfNames $ FldName : conLikeNameKinds)+ -- Filter by name, keeping @top@ in.+ ft = top <&> \ y -> (unqualify y ==) . A.nameConcrete . A.qnameName . anameName+ in applyWhenJust ft (||) fk++ -- Retrieve the names of interest from the flat scope.+ let defs = getDefinedNames' f opScope++ -- Note: Debug printout aligned with the one in+ -- Agda.Syntax.Concrete.Operators.buildParsers.+ reportS "scope.operators" 50+ [ "opScope = " ++ prettyShow opScope+ , "defs = " ++ prettyShow defs+ , "locals = " ++ prettyShow locals+ ]+ let localNots = map' localOp locals+ notLocal = not . hasElem (map' notaName localNots) . notaName+ otherNots = concatMap' (List1.filter' notLocal) defs+ return $! second (map' useDefaultFixity) $ split $ localNots ++! otherNots+ where+ localOp (x, y) = namesToNotation (QName x) y+ split = partitionEithers' . concatMap' opOrNot+ opOrNot n = (Left (notaName n) :) $! [Right n | not (null (notation n))]
@@ -0,0 +1,52 @@+-- | General functions for stateful manipulation of the scope.++-- This module has been originally created to avoid import cycles between+-- Agda.Syntax.Scope.Monad and Agda.Syntax.Scope.UnusedImports.++module Agda.Syntax.Scope.State where++import Agda.Syntax.Abstract.Name as A ( ModuleName )+import Agda.Syntax.Position ( SetRange(setRange), noRange )+import Agda.Syntax.Scope.Base (scopeCurrent)++import Agda.TypeChecking.Monad.Base ( TCM, MonadTCState, ReadTCState )+import Agda.TypeChecking.Monad.State (useScope, modifyScope, recomputeInverseScope)++import Agda.Utils.Lens (set)+import Agda.Utils.Monad (MonadTrans (lift))++---------------------------------------------------------------------------+-- * The scope checking monad+---------------------------------------------------------------------------++-- | To simplify interaction between scope checking and type checking (in+-- particular when chasing imports), we use the same monad.+type ScopeM = TCM++---------------------------------------------------------------------------+-- * Current module+---------------------------------------------------------------------------++getCurrentModule :: ReadTCState m => m A.ModuleName+getCurrentModule = setRange noRange <$> useScope scopeCurrent++setCurrentModule :: MonadTCState m => A.ModuleName -> m ()+setCurrentModule m = do+ modifyScope $ set scopeCurrent m+ recomputeInverseScope++withCurrentModule :: (ReadTCState m, MonadTCState m) => A.ModuleName -> m a -> m a+withCurrentModule new action = do+ old <- getCurrentModule+ setCurrentModule new+ x <- action+ setCurrentModule old+ return x++withCurrentModule' :: (MonadTrans t, Monad (t ScopeM)) => A.ModuleName -> t ScopeM a -> t ScopeM a+withCurrentModule' new action = do+ old <- lift getCurrentModule+ lift $ setCurrentModule new+ x <- action+ lift $ setCurrentModule old+ return x
@@ -0,0 +1,327 @@+-- | Warn about unused imports.+--+-- For each @open@ statement, we want to issue a warning about concrete names+-- and modules brought into scope by this statement which are not referenced subsequently.+--+-- To this end, whenever we lookup a concrete name during scope checking,+-- we mark it as used by calling 'lookedupName' with the results of the lookup,+-- which is an 'AbstractName' or several 'AbstractName's in case the name+-- is ambiguous (e.g. an ambiguous constructor or projection).+-- Likewise, whenever we resolve a concrete module name,+-- we mark the resulting 'AbstractModule' as used by calling 'lookedupModule'.+-- If the concrete name is qualified, e.g. @M.x@,+-- we also mark the module @M@ as used that the qualifier resolved to.+--+-- We also record for each opened module the set of 'AbstractName's+-- and 'AbstractModule's it brought into scope.+--+-- When checking the file is done, we can traverse the each opened module+-- and report all the 'AbstractName's and 'AbstractModule's that we not used.++module Agda.Syntax.Scope.UnusedImports+ ( lookedupName+ , lookedupModule+ , registerModuleOpening+ , warnUnusedImports+ ) where++import Prelude hiding (null, (||))++import Data.IntMap.Strict (IntMap)+import Data.IntMap.Strict qualified as IntMap+import Data.List (partition, sortOn)+import Data.Map qualified as Map+import Data.Set qualified as Set++import Agda.Interaction.Options (optQualifiedInstances)+import Agda.Interaction.Options.Warnings (WarningName (UnusedImports_, UnusedImportsAll_))++import Agda.Syntax.Abstract.Name+ ( WhyInScope(Defined, Opened, Applied),+ AbstractName, anameName, anameLineage,+ AbstractModule, amodName, amodLineage )+import Agda.Syntax.Abstract.Name qualified as A+import Agda.Syntax.Common+ ( IsInstanceDef(isInstanceDef), KwRange+ , ImportDirective'(using, impRenaming, publicOpen)+ , ImportedName'(ImportedName, ImportedModule), fromImportedName, Renaming'(renTo), Using'(Using, UseEverything)+ )+import Agda.Syntax.Common.Pretty (prettyShow, Pretty (pretty))+import Agda.Syntax.Concrete qualified as C+import Agda.Syntax.Position ( HasRange(getRange), SetRange(setRange) )+import Agda.Syntax.Position qualified as P+import Agda.Syntax.Scope.Base as A+import Agda.Syntax.Scope.State ( ScopeM, withCurrentModule )+-- importing Agda.Syntax.Scope.Monad creates import cycles++import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Monad.Debug ( MonadDebug, reportSLn, __IMPOSSIBLE_VERBOSE__ )+import Agda.TypeChecking.Monad.State ( getScope )+import Agda.TypeChecking.Monad.Trace (setCurrentRange)+import Agda.TypeChecking.Warnings (warning)++import Agda.Utils.Boolean ( (||) )+import Agda.Utils.Function ( applyUnless )+import Agda.Utils.Lens ( (<&>), Lens' )+import Agda.Utils.List ( partitionMaybe, hasElem )+import Agda.Utils.List1 ( pattern (:|), List1 )+import Agda.Utils.List1 qualified as List1+import Agda.Utils.List2 ( List2(..) )+import Agda.Utils.List2 qualified as List2+import Agda.Utils.Maybe ( fromMaybe, isJust, mapMaybe, whenNothing )+import Agda.Utils.Monad ( forM_, when, unless, whenM )+import Agda.Utils.Null ( Null(null) )++import Agda.Utils.Impossible++-- | Call these whenever a concrete name was translated to an abstract one.+lookedupName ::+ C.QName -- ^ The concrete name resolved by the scope checker.+ -> ResolvedName -- ^ The resolution of the name.+ -> ScopeM ()+lookedupName x = \case+ DefinedName _access y _suffix -> unamb y >> lookedupQualifier x [y]+ FieldName ys -> add ys+ ConstructorName _ind ys -> add ys+ PatternSynResName ys -> add ys+ VarName{} -> return ()+ UnknownName{} -> return ()+ where+ add ys = do+ case ys of+ y :| [] -> unamb y+ y1 :| y2 : ys -> amb $ List2 y1 y2 ys+ lookedupQualifier x $ List1.toList ys+ unamb = modifyTCLens stUnambiguousLookups . (:)+ amb xs = case rangeToPosPos x of+ -- Andreas, 2025-11-30+ -- It can happen that a concrete identifier has no range,+ -- e.g. when it comes from an expanded ellipsis.+ -- In this case, we do not record the lookup,+ -- since it should have been looked up already+ -- when processing the pattern from the original lhs+ -- (that was duplicated by ellipsis expansion).+ -- See test/Interaction/ExpandEllipsis.+ Nothing -> pure ()+ Just i -> modifyTCLens stAmbiguousLookups $ IntMap.insert i xs++-- | Call this whenever a concrete module name was translated to an abstract one.+lookedupModule ::+ C.QName -- ^ The concrete module name resolved by the scope checker.+ -> AbstractModule -- ^ The resolution of the module name.+ -> ScopeM ()+lookedupModule x m = do+ modifyTCLens stModuleLookups (m :)+ lookedupQualifier x [m]++-- | If the concrete name @x@ is qualified, i.e., of the form @M.y@,+-- mark the modules @M@ as used through which @x@ resolved to (one of) the given things.+lookedupQualifier :: InScope a => C.QName -> [a] -> ScopeM ()+lookedupQualifier x ys = case x of+ C.QName{} -> pure ()+ C.Qual{} -> whenM unusedImportsEnabled do+ ms <- scopeLookupQualifier x ys <$> getScope+ modifyTCLens stModuleLookups (ms ++)++-- | Is the 'UnusedImports' warning on?+-- It is sufficient to check for 'UnusedImports_' since it is implied by 'UnusedImportsAll_'.+unusedImportsEnabled :: ScopeM Bool+unusedImportsEnabled = (UnusedImports_ `Set.member`) <$> useTC stWarningSet++rangeToPosPos :: HasRange a => a -> Maybe Int+rangeToPosPos = fmap (fromIntegral . P.posPos) . P.rStart' . getRange++-- | Call this when opening a module with all the names it brings into scope.+-- When the 'UnusedImports' warning is enabled, we will store this information+-- to later issue a warning connected to this 'open' statement+-- for the names that were not used.+registerModuleOpening ::+ KwRange -- ^ Range of the @open@ keyword.+ -> A.ModuleName -- ^ Parent module: module into which we pour the opened module.+ -> C.QName -- ^ Opened module.+ -> C.ImportDirective -- ^ Directive restricting the scope of the opened module.+ -> Scope -- ^ The scope resulting from applying the import directive.+ -> ScopeM ()+registerModuleOpening kwr currentModule x dir (Scope m0 _parents ns imports _dataOrRec) = do+ -- @imports@ have been removed by 'restrictPrivate'.+ unless (null imports) __IMPOSSIBLE__++ -- When the UnusedImports warning is off, do not collect information about @open@.+ -- E.g. we do not want to see warnings for the automatically inserted+ -- @open import Agda.Primitive using (Set)@.+ doWarn <- unusedImportsEnabled+ reportSLn "warning.unusedImports" 20 $ unlines+ [ "openedModule: " <> prettyShow doWarn+ , "x = " <> prettyShow x+ -- , "currentModule: " <> prettyShow curM+ ]+ when doWarn $ whenNothing (publicOpen dir) do+ let+ m = setRange (getRange x) m0+ names :: NamesInScope -- Map C.Name (List1 AbstractName)+ names = mergeNamesMany $ map (nsNames . snd) ns+ modules :: ModulesInScope -- Map C.Name (List1 AbstractModule)+ modules = mergeNamesMany $ map (nsModules . snd) ns+ -- The modules mentioned in the directive.+ explicitModules = Set.fromList+ [ y | ImportedModule y <- usingList ++ map renTo (impRenaming dir) ]+ usingList = case using dir of+ UseEverything -> []+ Using ys -> ys+ -- Modules that come with a name, e.g. modules of data and record types.+ -- We recognize them either by their abstract name,+ -- or by their concrete name (needed for copies made by module application,+ -- since these get fresh abstract names).+ companions = Map.keysSet (Map.filterWithKey isCompanion modules)+ isCompanion y zs = Set.notMember y explicitModules &&+ (Map.member y names || any ((`Set.member` nameModules) . amodName) zs)+ nameModules = Set.fromList $ map (A.qnameToMName . anameName) $ concatMap List1.toList $ Map.elems names+ !k = fromMaybe __IMPOSSIBLE__ $ rangeToPosPos x+ hasDir = not (null (using dir)) || not (null (impRenaming dir))+ modifyTCLens stOpenedModules $+ IntMap.insert k (OpenedModule kwr m currentModule hasDir names modules companions)++-- | Call this when a file has been checked to generate the unused-imports warnings for each opened module.+-- Assumes that all names have been looked up via 'lookedupName'+-- and all modules via 'lookedupModule'.+-- Needs the disambiguation information from the type checker to correctly report ununsed overloaded names.+warnUnusedImports :: TCM ()+warnUnusedImports = do+ warnAll <- (UnusedImportsAll_ `Set.member`) <$> useTC stWarningSet+ st <- useTC stUnusedImportsState+ disambiguatedNames <- useTC stDisambiguatedNames+ -- If instances can be used qualified, they do not need to be imported,+ -- so we should warn about them.+ qualifiedInstances <- optQualifiedInstances <$> pragmaOptions++ reportSLn "warning.unusedImports" 60 $ "ambiguousLookups: " <> prettyShow (ambiguousLookups st)+ reportSLn "warning.unusedImports" 60 $ "unambiguousLookups: " <> prettyShow (unambiguousLookups st)+ reportSLn "warning.unusedImports" 60 $ "moduleLookups: " <> prettyShow (moduleLookups st)++ let+ -- Disambiguate overloaded lookups.+ addAmbLookup (i :: Int) (ys :: List2 AbstractName) = do+ case IntMap.lookup i disambiguatedNames of+ Just (DisambiguatedName _k x) -> (filter ((x ==) . anameName) (List2.toList ys) ++)+ Nothing -> (List2.toList ys ++) -- __IMPOSSIBLE__+ allLookups :: [AbstractName]+ allLookups = IntMap.foldrWithKey addAmbLookup (unambiguousLookups st) (ambiguousLookups st)++ -- To make a set of the list of looked-up 'AbstractName's,+ -- we need to convert them to 'Imported' lest we+ -- conflate names from different openings.+ -- Same for the 'AbstractModule's.+ lookups :: [Imported AbstractName]+ (unknowns, lookups) = partitionMaybe toImported allLookups+ moduleLookups' :: [Imported AbstractModule]+ moduleLookups' = mapMaybe toImported $ moduleLookups st++ isInst, isUsedName :: Imported AbstractName -> Bool+ isInst = isJust . isInstanceDef . iThing+ isUsedName = applyUnless qualifiedInstances (isInst ||) $ hasElem lookups+ isUsedModule :: Imported AbstractModule -> Bool+ isUsedModule = hasElem moduleLookups'++ reportSLn "warning.unusedImports" 60 $ "allLookups: " <> prettyShow allLookups+ reportSLn "warning.unusedImports" 60 $ "lookups: " <> prettyShow lookups+ reportSLn "warning.unusedImports" 60 $ "unknowns: " <> prettyShow unknowns++ -- Iterate through the @open@ statements and issue warnings.+ forM_ (openedModules st) \ (OpenedModule kwr m parent hasDir names modules companions) -> do++ -- Partition the names and modules brought into scope by the open statement+ -- into used and unused ones.+ (usedNames, unusedNames) <- partitionUsed isUsedName names+ (usedModules, unusedModules) <- partitionUsed isUsedModule modules++ let+ used = not (null usedNames && null usedModules)+ -- Unused things to report individually, in alphabetical order.+ -- We omit the modules of data and record types not mentioned explicitly,+ -- since we report their names already.+ unused :: [C.ImportedName]+ unused = sortOn fromImportedName $ concat+ [ map ImportedName unusedNames+ , map ImportedModule $ filter (`Set.notMember` companions) unusedModules+ ]++ -- Commands to issue the warnings:+ warn = setCurrentRange (getRange (kwr, m)) . withCurrentModule parent . warning . UnusedImports m+ warnModule = warn Nothing+ warnEach = List1.unlessNull unused $ warn . Just++ -- Issue warning.+ -- If nothing was used, we warn about the whole import.+ -- If the open statement has a 'using' or 'renaming' directive,+ -- or if the 'UnusedImportsAll_' warning is enabled,+ -- we warn about each unused name individually.+ -- Otherwise, we just warn once about the whole import.+ if | hasDir -> warnEach+ | not used -> warnModule+ | warnAll -> warnEach+ | otherwise -> pure ()++-- | Partition the things brought into scope by an @open@ statement+-- into the used and unused ones.+-- Returns the concrete names they are in scope under.+partitionUsed :: forall a m. (Lineage a, MonadDebug m)+ => (Imported a -> Bool) -- ^ Was the thing used?+ -> ThingsInScope a -- ^ The things brought into scope by the @open@.+ -> m ([C.Name], [C.Name])+partitionUsed isUsed sc = do+ let+ imps, used, unused :: [(C.Name, List1 (Imported a))]+ (other, imps) = partitionMaybe (traverse $ traverse toImported) $ Map.toList sc+ (used, unused) = partition (any isUsed . snd) imps+ reportSLn "warning.unusedImports" 60 $ "used: " <> prettyShow used+ reportSLn "warning.unusedImports" 60 $ "unused: " <> prettyShow unused+ unless (null other) $ __IMPOSSIBLE_VERBOSE__ (show other)+ return (map fst used, map fst unused)++------------------------------------------------------------------------------+-- * Auxiliary definitions++-- | Things (names and modules) that remember how they came into scope.+class (Ord a, Show a, Pretty a) => Lineage a where+ lineage :: a -> WhyInScope++instance Lineage AbstractName where+ lineage = anameLineage++instance Lineage AbstractModule where+ lineage = amodLineage++-- | A wrapper around 'AbstractName' or 'AbstractModule'+-- to make the position of the 'Opened' in the lineage available.+-- This wrapper is needed when 'AbstractName's are stored in sets+-- so that we do not conflate different 'AbstractName's with the same underlying 'A.QName'+-- that were brought into scope by different 'open' statements.+data Imported a = Imported+ { iWhere :: Int -- Position of 'Opened' extracted from the 'AbstractName'.+ , iThing :: a+ } deriving (Eq, Ord, Show)++instance Pretty a => Pretty (Imported a) where+ pretty (Imported i n) = pretty n <> " (at position " <> pretty i <> ")"++-- | Convert an 'AbstractName' or 'AbstractModule' to an 'Imported'+-- if it was brought into scope by an 'open' statement.+toImported :: Lineage a => a -> Maybe (Imported a)+toImported x = case lineage x of+ Opened m _ -> rangeToPosPos m <&> (`Imported` x)+ Applied{} -> Nothing+ Defined{} -> Nothing++-- Lenses for the components of the UnusedImportsState in the TCState.++stUnambiguousLookups :: Lens' TCState [AbstractName]+stUnambiguousLookups = stUnusedImportsState . lensUnambiguousLookups++stAmbiguousLookups :: Lens' TCState (IntMap (List2 AbstractName))+stAmbiguousLookups = stUnusedImportsState . lensAmbiguousLookups++stModuleLookups :: Lens' TCState [AbstractModule]+stModuleLookups = stUnusedImportsState . lensModuleLookups++stOpenedModules :: Lens' TCState (IntMap OpenedModule)+stOpenedModules = stUnusedImportsState . lensOpenedModules
@@ -1,100 +0,0 @@-{-# LANGUAGE CPP #-}--module Agda.Syntax.Strict where--import Data.Generics (everything)--import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.Syntax.Parser.Tokens-import qualified Agda.Syntax.Concrete as C-import qualified Agda.Syntax.Concrete.Definitions as C--#include "../undefined.h"-import Agda.Utils.Impossible---- | @force@ is the recursive @const 0@ function, to force Haskell to evaluate.-class Strict a where- force :: a -> Int--instance Strict Term where- force t = case t of- Var _ ts -> force ts- Def _ ts -> force ts- Con _ ts -> force ts- Lam _ t -> force t- Lit _ -> 0- Level l -> force l- Pi a b -> force (a,b)- Sort s -> force s- MetaV _ ts -> force ts- DontCare mt -> force mt--instance Strict Type where- force (El s t) = force (s,t)--instance Strict Sort where- force s = case s of- Type n -> force n- Prop -> 0- Inf -> 0- DLub s1 s2 -> force (s1, s2)--instance Strict Level where- force (Max as) = force as--instance Strict PlusLevel where- force ClosedLevel{} = 0- force (Plus _ l) = force l--instance Strict LevelAtom where- force l = case l of- MetaLevel _ vs -> force vs- NeutralLevel v -> force v- BlockedLevel _ v -> force v- UnreducedLevel v -> force v--instance Strict ClauseBody where- force (Body t) = force t- force (Bind b) = force b- force NoBody = 0--instance Strict C.Expr where- force e = everything (+) (const 1) e--instance Strict C.Declaration where- force e = everything (+) (const 1) e--instance Strict C.Pragma where- force e = everything (+) (const 1) e--instance Strict C.NiceDeclaration where- force d = everything (+) (const 1) d--instance (Strict a, Strict b) => Strict (a,b) where- force (x,y) = force x + force y--instance Strict a => Strict (Arg a) where- force = force . unArg--instance Strict a => Strict [a] where- force = sum . map force--instance Strict a => Strict (Maybe a) where- force = maybe 0 force--instance Strict a => Strict (Abs a) where- force = force . unAbs--instance Strict Token where- -- TODO: This is just a dummy instance. Why can't we just use the- -- NFData derivation provided by Drift?- force = (`seq` 0)--infixr 0 $!!--($!!) :: Strict a => (a -> b) -> a -> b-f $!! x = force x `seq` f x--strict :: Strict a => a -> a-strict x = id $!! x
@@ -0,0 +1,204 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}++------------------------------------------------------------------------+-- Top-level module names+------------------------------------------------------------------------++module Agda.Syntax.TopLevelModuleName+ ( module Agda.Syntax.TopLevelModuleName+ , module Agda.Syntax.TopLevelModuleName.Boot+ ) where++import Agda.Syntax.TopLevelModuleName.Boot+import Agda.Syntax.Abstract.Name (isNoName)++import Control.DeepSeq++import Data.Function (on)+import qualified Data.List as List+import qualified Data.Text as T++import GHC.Generics (Generic)++import System.FilePath++import qualified Agda.Syntax.Abstract.Name as A+import qualified Agda.Syntax.Concrete as C+import Agda.Syntax.Position++import Agda.Utils.FileName+import Agda.Utils.Function (iterate')+import Agda.Utils.Hash+import Agda.Utils.Impossible+import Agda.Utils.Lens+import qualified Agda.Utils.List1 as List1+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton+import Agda.Utils.Size++------------------------------------------------------------------------+-- Raw top-level module names++-- | Raw top-level module names (with linear-time comparisons).++data RawTopLevelModuleName = RawTopLevelModuleName+ { rawModuleNameRange :: Range+ , rawModuleNameParts :: TopLevelModuleNameParts+ , rawModuleNameInferred :: !Bool+ -- ^ Was this module name constructed from a file name+ -- rather than declared in the file?+ }+ deriving (Show, Generic)++instance Eq RawTopLevelModuleName where+ (==) = (==) `on` rawModuleNameParts++instance Ord RawTopLevelModuleName where+ compare = compare `on` rawModuleNameParts++instance Sized RawTopLevelModuleName where+ size = size . rawModuleNameParts+ natSize = natSize . rawModuleNameParts++instance Pretty RawTopLevelModuleName where+ pretty = text . rawTopLevelModuleNameToString++instance HasRange RawTopLevelModuleName where+ getRange = rawModuleNameRange++instance SetRange RawTopLevelModuleName where+ setRange r (RawTopLevelModuleName _ x z) = RawTopLevelModuleName r x z++instance KillRange RawTopLevelModuleName where+ killRange (RawTopLevelModuleName _ x z) =+ RawTopLevelModuleName noRange x z++instance C.IsNoName RawTopLevelModuleName where+ isNoName m = rawModuleNameParts m == singleton "_"++-- | The 'Range' is not forced.++instance NFData RawTopLevelModuleName where+ rnf (RawTopLevelModuleName _ x _) = rnf x++-- | Turns a raw top-level module name into a string.++rawTopLevelModuleNameToString :: RawTopLevelModuleName -> String+rawTopLevelModuleNameToString =+ List.intercalate "." .+ map T.unpack . List1.toList . rawModuleNameParts++-- | Hashes a raw top-level module name.++hashRawTopLevelModuleName :: RawTopLevelModuleName -> ModuleNameHash+hashRawTopLevelModuleName =+ ModuleNameHash . hashString . rawTopLevelModuleNameToString++-- | Turns a qualified name into a 'RawTopLevelModuleName'. The+-- qualified name is assumed to represent a top-level module name.++rawTopLevelModuleNameForQName :: C.QName -> RawTopLevelModuleName+rawTopLevelModuleNameForQName q = RawTopLevelModuleName+ { rawModuleNameRange = getRange q+ , rawModuleNameParts =+ fmap (T.pack . C.nameToRawName) $ C.qnameParts q+ , rawModuleNameInferred = C.isNoName q+ }++-- | Computes the 'RawTopLevelModuleName' corresponding to the given+-- module name, which is assumed to represent a top-level module name.+--+-- Precondition: The module name must be well-formed.++rawTopLevelModuleNameForModuleName ::+ A.ModuleName -> RawTopLevelModuleName+rawTopLevelModuleNameForModuleName x@(A.MName ms) =+ List1.ifNull ms __IMPOSSIBLE__ $ \ms ->+ RawTopLevelModuleName+ { rawModuleNameRange = getRange ms+ , rawModuleNameParts =+ fmap (T.pack . C.nameToRawName . A.nameConcrete) ms+ , rawModuleNameInferred = isNoName x+ }++-- | Retrieves the top-level module name.++rawTopLevelModuleNameForModule :: C.Module -> RawTopLevelModuleName+rawTopLevelModuleNameForModule (C.Mod n _pragmas _decls) = rawTopLevelModuleNameForQName n++------------------------------------------------------------------------+-- Top-level module names++-- | Top-level module names (with constant-time comparisons).++type TopLevelModuleName = TopLevelModuleName' Range++instance Sized TopLevelModuleName where+ size = size . rawTopLevelModuleName+ natSize = natSize . rawTopLevelModuleName++instance Pretty TopLevelModuleName where+ pretty = pretty . rawTopLevelModuleName++-- | A lens focusing on the 'moduleNameParts'.++lensTopLevelModuleNameParts ::+ Lens' TopLevelModuleName TopLevelModuleNameParts+lensTopLevelModuleNameParts f m =+ f (moduleNameParts m) <&> \ xs -> m{ moduleNameParts = xs }++-- | Converts a top-level module name to a raw top-level module name.++rawTopLevelModuleName :: TopLevelModuleName -> RawTopLevelModuleName+rawTopLevelModuleName m = RawTopLevelModuleName+ { rawModuleNameRange = moduleNameRange m+ , rawModuleNameParts = moduleNameParts m+ , rawModuleNameInferred = moduleNameInferred m+ }++-- | Converts a raw top-level module name and a hash to a top-level+-- module name.+--+-- This function does not ensure that there are no hash collisions,+-- that is taken care of by+-- 'Agda.TypeChecking.Monad.State.topLevelModuleName'.++unsafeTopLevelModuleName ::+ RawTopLevelModuleName -> ModuleNameHash -> TopLevelModuleName+unsafeTopLevelModuleName m h = TopLevelModuleName+ { moduleNameRange = rawModuleNameRange m+ , moduleNameParts = rawModuleNameParts m+ , moduleNameId = h+ , moduleNameInferred = rawModuleNameInferred m+ }++-- | A corresponding 'C.QName'. The range of each 'Name' part is the+-- whole range of the 'TopLevelModuleName'.++topLevelModuleNameToQName :: TopLevelModuleName -> C.QName+topLevelModuleNameToQName m =+ List1.foldr C.Qual C.QName $+ fmap (C.Name (getRange m) C.NotInScope .+ C.stringNameParts . T.unpack) $+ moduleNameParts m++-- | Turns a top-level module name into a file name with the given+-- suffix.++moduleNameToFileName :: TopLevelModuleName -> String -> FilePath+moduleNameToFileName TopLevelModuleName{ moduleNameParts = ms } ext =+ joinPath (map T.unpack $ List1.init ms) </>+ T.unpack (List1.last ms) <.> ext++-- | Finds the current project's \"root\" directory, given a project+-- file and the corresponding top-level module name.+--+-- Example: If the module \"A.B.C\" is located in the file+-- \"/foo/A/B/C.agda\", then the root is \"/foo/\".+--+-- Precondition: The module name must be well-formed.++projectRoot :: AbsolutePath -> TopLevelModuleName -> AbsolutePath+projectRoot file TopLevelModuleName{ moduleNameParts = m } =+ mkAbsolute $ iterate' (length m) takeDirectory $ filePath file
@@ -0,0 +1,63 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.Syntax.TopLevelModuleName.Boot where++import Control.DeepSeq (NFData, rnf)+import Data.Function (on)+import Data.Hashable (Hashable, hashWithSalt)+import Data.Text (Text)+import Data.Word (Word64)+import GHC.Generics (Generic)++import Agda.Utils.BiMap (HasTag, Tag, tag)+import Agda.Utils.List1 (List1)+import Agda.Utils.Null++newtype ModuleNameHash = ModuleNameHash { moduleNameHash :: Word64 }+ deriving (Eq, Ord, Hashable, Null)++instance NFData ModuleNameHash where+ rnf _ = ()++instance HasTag ModuleNameHash where+ type Tag ModuleNameHash = ModuleNameHash+ tag = Just++noModuleNameHash :: ModuleNameHash+noModuleNameHash = empty++-- | The record selector is not included in the resulting strings.++instance Show ModuleNameHash where+ showsPrec p (ModuleNameHash h) = showParen (p > 0) $+ showString "ModuleNameHash " . shows h++type TopLevelModuleNameParts = List1 Text++data TopLevelModuleName' range = TopLevelModuleName+ { moduleNameRange :: range+ , moduleNameId :: {-# UNPACK #-} !ModuleNameHash+ , moduleNameParts :: TopLevelModuleNameParts+ , moduleNameInferred :: !Bool+ -- ^ Was this module name constructed from a file name+ -- rather than declared in the file?+ }+ deriving (Show, Generic)++instance HasTag (TopLevelModuleName' range) where+ type Tag (TopLevelModuleName' range) = ModuleNameHash+ tag = Just . moduleNameId++instance Eq (TopLevelModuleName' range) where+ (==) = (==) `on` moduleNameId++instance Ord (TopLevelModuleName' range) where+ compare = compare `on` moduleNameId++instance Hashable (TopLevelModuleName' range) where+ hashWithSalt salt = hashWithSalt salt . moduleNameId++-- | The 'range' is not forced.++instance NFData (TopLevelModuleName' range) where+ rnf (TopLevelModuleName _ x y _) = rnf (x, y)
@@ -1,853 +1,1944 @@-{-# LANGUAGE CPP, PatternGuards, MultiParamTypeClasses, FunctionalDependencies,- TypeSynonymInstances, FlexibleInstances, UndecidableInstances- #-}--{-| The translation of abstract syntax to concrete syntax has two purposes.- First it allows us to pretty print abstract syntax values without having to- write a dedicated pretty printer, and second it serves as a sanity check- for the concrete to abstract translation: translating from concrete to- abstract and then back again should be (more or less) the identity.--}-module Agda.Syntax.Translation.AbstractToConcrete- ( ToConcrete(..)- , toConcreteCtx- , abstractToConcrete_- , runAbsToCon- , RangeAndPragma(..)- , abstractToConcreteCtx- , withScope- , makeEnv- , abstractToConcrete- , AbsToCon, DontTouchMe, Env- , noTakenNames- ) where--import Control.Applicative-import Control.Monad.Reader-import Data.Char-import qualified Data.Map as Map-import Data.Map (Map)-import qualified Data.Set as Set-import Data.Set (Set)-import Data.List as List-import qualified Data.Traversable as Trav--import Agda.Syntax.Common-import Agda.Syntax.Position-import Agda.Syntax.Info-import Agda.Syntax.Fixity-import Agda.Syntax.Concrete as C-import Agda.Syntax.Concrete.Pretty-import Agda.Syntax.Abstract as A-import Agda.Syntax.Abstract.Views as AV-import Agda.Syntax.Scope.Base--import Agda.TypeChecking.Monad.State (getScope)-import Agda.TypeChecking.Monad.Base (TCM)--import Agda.Utils.Maybe-import Agda.Utils.Monad hiding (bracket)-import Agda.Utils.Tuple-import Agda.Utils.Suffix--#include "../../undefined.h"-import Agda.Utils.Impossible---- Environment --------------------------------------------------------------data Env = Env { takenNames :: Set C.Name- , currentScope :: ScopeInfo- }--defaultEnv :: Env-defaultEnv = Env { takenNames = Set.empty- , currentScope = emptyScopeInfo- }--makeEnv :: ScopeInfo -> Env-makeEnv scope = Env { takenNames = taken- , currentScope = scope- }- where- ns = everythingInScope scope- taken = Set.union vars defs- vars = Set.fromList $ map fst $ scopeLocals scope- defs = Set.fromList [ x | (x, _) <- Map.toList $ nsNames ns ]--currentPrecedence :: AbsToCon Precedence-currentPrecedence = asks $ scopePrecedence . currentScope--withPrecedence :: Precedence -> AbsToCon a -> AbsToCon a-withPrecedence p = local $ \e ->- e { currentScope = (currentScope e) { scopePrecedence = p } }--withScope :: ScopeInfo -> AbsToCon a -> AbsToCon a-withScope scope = local $ \e -> e { currentScope = scope }--noTakenNames :: AbsToCon a -> AbsToCon a-noTakenNames = local $ \e -> e { takenNames = Set.empty }---- The Monad ------------------------------------------------------------------ | We make the translation monadic for modularity purposes.-type AbsToCon = Reader Env--runAbsToCon :: AbsToCon a -> TCM a-runAbsToCon m = do- scope <- getScope- return $ runReader m (makeEnv scope)--abstractToConcrete :: ToConcrete a c => Env -> a -> c-abstractToConcrete flags a = runReader (toConcrete a) flags--abstractToConcreteCtx :: ToConcrete a c => Precedence -> a -> TCM c-abstractToConcreteCtx ctx x = do- scope <- getScope- let scope' = scope { scopePrecedence = ctx }- return $ abstractToConcrete (makeEnv scope') x- where- scope = (currentScope defaultEnv) { scopePrecedence = ctx }--abstractToConcrete_ :: ToConcrete a c => a -> TCM c-abstractToConcrete_ x = do- scope <- getScope- return $ abstractToConcrete (makeEnv scope) x---- Dealing with names --------------------------------------------------------- | Names in abstract syntax are fully qualified, but the concrete syntax--- requires non-qualified names in places. In theory (if all scopes are--- correct), we should get a non-qualified name when translating back to a--- concrete name, but I suspect the scope isn't always perfect. In these--- cases we just throw away the qualified part. It's just for pretty printing--- anyway...-unsafeQNameToName :: C.QName -> C.Name-unsafeQNameToName (C.QName x) = x-unsafeQNameToName (C.Qual _ x) = unsafeQNameToName x--lookupName :: A.Name -> AbsToCon C.Name-lookupName x = do- names <- asks $ scopeLocals . currentScope- case lookup x $ map swap names of- Just y -> return y- Nothing -> return $ nameConcrete x- where- swap (x, y) = (y, x)--lookupQName :: A.QName -> AbsToCon C.QName-lookupQName x =- do scope <- asks currentScope- case inverseScopeLookupName x scope of- Just y -> return y- Nothing- | show (qnameToConcrete x) == "_" -> return $ qnameToConcrete x- | otherwise -> return $ C.Qual (C.Name noRange [Id ""]) $ qnameToConcrete x- -- this is what happens for names that are not in scope (private names)--lookupModule :: A.ModuleName -> AbsToCon C.QName-lookupModule x =- do scope <- asks currentScope- case inverseScopeLookupModule x scope of- Just y -> return y- Nothing -> return $ mnameToConcrete x- -- this is what happens for names that are not in scope (private names)--bindName :: A.Name -> (C.Name -> AbsToCon a) -> AbsToCon a-bindName x ret = do- names <- asks takenNames- let y = nameConcrete x- case (Set.member y names) of- _ | C.isNoName y -> ret y- True -> bindName (nextName x) ret- False ->- local (\e -> e { takenNames = Set.insert y $ takenNames e- , currentScope = (currentScope e)- { scopeLocals = (y, x) : scopeLocals (currentScope e)- }- }- ) $ ret y---- Dealing with precedences --------------------------------------------------- | General bracketing function.-bracket' :: (e -> e) -- ^ the bracketing function- -> (Precedence -> Bool) -- ^ Should we bracket things- -- which have the given- -- precedence?- -> e -> AbsToCon e-bracket' paren needParen e =- do p <- currentPrecedence- return $ if needParen p then paren e else e---- | Expression bracketing-bracket :: (Precedence -> Bool) -> AbsToCon C.Expr -> AbsToCon C.Expr-bracket par m =- do e <- m- bracket' (Paren (getRange e)) par e---- | Pattern bracketing-bracketP_ :: (Precedence -> Bool) -> AbsToCon C.Pattern -> AbsToCon C.Pattern-bracketP_ par m =- do e <- m- bracket' (ParenP (getRange e)) par e---- | Pattern bracketing-bracketP :: (Precedence -> Bool) -> (C.Pattern -> AbsToCon a)- -> ((C.Pattern -> AbsToCon a) -> AbsToCon a)- -> AbsToCon a-bracketP par ret m = m $ \p -> do- p <- bracket' (ParenP $ getRange p) par p- ret p---- Dealing with infix declarations -------------------------------------------- | If a name is defined with a fixity that differs from the default, we have--- to generate a fixity declaration for that name.-withInfixDecl :: DefInfo -> C.Name -> AbsToCon [C.Declaration] -> AbsToCon [C.Declaration]-withInfixDecl i x m = do- ds <- m- return $ fixDecl ++ synDecl ++ ds- where fixDecl = [C.Infix (theFixity $ defFixity i) [x] | theFixity (defFixity i) /= defaultFixity]- synDecl = [C.Syntax x (theNotation (defFixity i))]--withInfixDecls :: [(DefInfo, C.Name)] -> AbsToCon [C.Declaration] -> AbsToCon [C.Declaration]-withInfixDecls = foldr (.) id . map (uncurry withInfixDecl)---- Dealing with private definitions -----------------------------------------withAbstractPrivate :: DefInfo -> AbsToCon [C.Declaration] -> AbsToCon [C.Declaration]-withAbstractPrivate i m =- case (defAccess i, defAbstract i) of- (PublicAccess, ConcreteDef) -> m- (p,a) ->- do ds <- m- return $ abst a $ priv p $ ds- where- priv PrivateAccess ds = [ C.Private (getRange ds) ds ]- priv _ ds = ds- abst AbstractDef ds = [ C.Abstract (getRange ds) ds ]- abst _ ds = ds---- The To Concrete Class ----------------------------------------------------class ToConcrete a c | a -> c where- toConcrete :: a -> AbsToCon c- bindToConcrete :: a -> (c -> AbsToCon b) -> AbsToCon b-- toConcrete x = bindToConcrete x return- bindToConcrete x ret = ret =<< toConcrete x---- | Translate something in a context of the given precedence.-toConcreteCtx :: ToConcrete a c => Precedence -> a -> AbsToCon c-toConcreteCtx p x = withPrecedence p $ toConcrete x---- | Translate something in a context of the given precedence.-bindToConcreteCtx :: ToConcrete a c => Precedence -> a -> (c -> AbsToCon b) -> AbsToCon b-bindToConcreteCtx p x ret = withPrecedence p $ bindToConcrete x ret---- General instances --------------------------------------------------------instance ToConcrete a c => ToConcrete [a] [c] where- toConcrete = mapM toConcrete- bindToConcrete = thread bindToConcrete--instance (ToConcrete a1 c1, ToConcrete a2 c2) => ToConcrete (a1,a2) (c1,c2) where- toConcrete (x,y) = liftM2 (,) (toConcrete x) (toConcrete y)- bindToConcrete (x,y) ret =- bindToConcrete x $ \x ->- bindToConcrete y $ \y ->- ret (x,y)--instance (ToConcrete a1 c1, ToConcrete a2 c2, ToConcrete a3 c3) =>- ToConcrete (a1,a2,a3) (c1,c2,c3) where- toConcrete (x,y,z) = reorder <$> toConcrete (x,(y,z))- where- reorder (x,(y,z)) = (x,y,z)-- bindToConcrete (x,y,z) ret = bindToConcrete (x,(y,z)) $ ret . reorder- where- reorder (x,(y,z)) = (x,y,z)--instance ToConcrete a c => ToConcrete (Arg a) (Arg c) where- toConcrete (Arg h@Hidden r x) = Arg h r <$> toConcreteCtx TopCtx x- toConcrete (Arg h@Instance r x) = Arg h r <$> toConcreteCtx TopCtx x- toConcrete (Arg h@NotHidden r x) = Arg h r <$> toConcrete x-- bindToConcrete (Arg h r x) ret = bindToConcreteCtx (hiddenArgumentCtx h) x $ ret . Arg h r--instance ToConcrete a c => ToConcrete (Named name a) (Named name c) where- toConcrete (Named n x) = Named n <$> toConcrete x- bindToConcrete (Named n x) ret = bindToConcrete x $ ret . Named n--newtype DontTouchMe a = DontTouchMe a--instance ToConcrete (DontTouchMe a) a where- toConcrete (DontTouchMe x) = return x---- Names --------------------------------------------------------------------instance ToConcrete A.Name C.Name where- toConcrete = lookupName- bindToConcrete x = bindName x--instance ToConcrete A.QName C.QName where- toConcrete = lookupQName--instance ToConcrete A.ModuleName C.QName where- toConcrete = lookupModule---- Expression instance ------------------------------------------------------instance ToConcrete A.Expr C.Expr where- toConcrete (Var x) = Ident . C.QName <$> toConcrete x- toConcrete (Def x) = Ident <$> toConcrete x- toConcrete (Con (AmbQ (x:_))) = Ident <$> toConcrete x- toConcrete (Con (AmbQ [])) = __IMPOSSIBLE__- -- for names we have to use the name from the info, since the abstract- -- name has been resolved to a fully qualified name (except for- -- variables)- toConcrete (A.Lit l) = return $ C.Lit l-- toConcrete (A.QuestionMark i) = return $ C.QuestionMark- (getRange i)- (metaNumber i)- toConcrete (A.Underscore i) = return $ C.Underscore- (getRange i)- (metaNumber i)-- toConcrete e@(A.App i e1 e2) =- tryToRecoverOpApp e- -- or fallback to App- $ bracket appBrackets- $ do e1' <- toConcreteCtx FunctionCtx e1- e2' <- toConcreteCtx ArgumentCtx e2- return $ C.App (getRange i) e1' e2'-- toConcrete (A.WithApp i e es) =- bracket withAppBrackets $ do- e <- toConcreteCtx WithFunCtx e- es <- mapM (toConcreteCtx WithArgCtx) es- return $ C.WithApp (getRange i) e es-- toConcrete (A.AbsurdLam i h) =- bracket lamBrackets $ return $ C.AbsurdLam (getRange i) h- toConcrete e@(A.Lam i _ _) =- bracket lamBrackets- $ case lamView e of- (bs, e) ->- bindToConcrete (map makeDomainFree bs) $ \bs -> do- e <- toConcreteCtx TopCtx e- return $ C.Lam (getRange i) bs e- where- lamView (A.Lam _ b@(A.DomainFree _ _ _) e) =- case lamView e of- ([], e) -> ([b], e)- (bs@(A.DomainFree _ _ _ : _), e) -> (b:bs, e)- _ -> ([b], e)- lamView (A.Lam _ b@(A.DomainFull _) e) =- case lamView e of- ([], e) -> ([b], e)- (bs@(A.DomainFull _ : _), e) -> (b:bs, e)- _ -> ([b], e)- lamView e = ([], e)- toConcrete (A.ExtendedLam i di qname cs) = do- decls <- toConcrete cs- let removeApp (C.RawAppP r (lam:es)) = C.RawAppP r es- removeApp (C.AppP p np) = namedThing $ unArg np- removeApp _ = __IMPOSSIBLE__- let decl2clause (C.FunClause lhs rhs wh) = (lhs {lhsOriginalPattern = removeApp $ lhsOriginalPattern lhs},rhs,wh)- decl2clause _ = __IMPOSSIBLE__- return $ C.ExtendedLam (getRange i) (map decl2clause $ concat decls)- toConcrete (A.Pi _ [] e) = toConcrete e- toConcrete t@(A.Pi i _ _) = case piTel t of- (tel, e) ->- bracket piBrackets- $ bindToConcrete tel $ \b' -> do- e' <- toConcreteCtx TopCtx e- return $ C.Pi b' e'- where- piTel (A.Pi _ tel e) = (tel ++) -*- id $ piTel e- piTel e = ([], e)-- toConcrete (A.Fun i a b) =- bracket piBrackets- $ do a' <- toConcreteCtx (if irr then DotPatternCtx else FunctionSpaceDomainCtx) a- b' <- toConcreteCtx TopCtx b- return $ C.Fun (getRange i) (addDot a' $ mkArg a') b'- where- irr = argRelevance a == Irrelevant- addDot a e = if irr then Dot (getRange a) e else e- mkArg (Arg Hidden r e) = HiddenArg (getRange e) (unnamed e)- mkArg (Arg Instance r e) = InstanceArg (getRange e) (unnamed e)- mkArg (Arg NotHidden r e) = e-- toConcrete (A.Set i 0) = return $ C.Set (getRange i)- toConcrete (A.Set i n) = return $ C.SetN (getRange i) n- toConcrete (A.Prop i) = return $ C.Prop (getRange i)-- toConcrete (A.Let i ds e) =- bracket lamBrackets- $ bindToConcrete ds $ \ds' -> do- e' <- toConcreteCtx TopCtx e- return $ C.Let (getRange i) (concat ds') e'-- toConcrete (A.Rec i fs) =- bracket appBrackets $ do- let (xs, es) = unzip fs- es <- toConcreteCtx TopCtx es- return $ C.Rec (getRange i) $ zip xs es-- toConcrete (A.RecUpdate i e fs) =- bracket appBrackets $ do- let (xs, es) = unzip fs- e <- toConcrete e- es <- toConcreteCtx TopCtx es- return $ C.RecUpdate (getRange i) e $ zip xs es-- toConcrete (A.ETel tel) = do- tel <- toConcrete tel- return $ C.ETel tel-- toConcrete (A.ScopedExpr _ e) = toConcrete e-- toConcrete (A.QuoteGoal i x e) =- bracket lamBrackets $- bindToConcrete x $ \ x' -> do- e' <- toConcrete e- return $ C.QuoteGoal (getRange i) x' e'- toConcrete (A.Quote i) = return $ C.Quote (getRange i)- toConcrete (A.QuoteTerm i) = return $ C.QuoteTerm (getRange i)- toConcrete (A.Unquote i) = return $ C.Unquote (getRange i)-- -- Andreas, 2010-10-05 print irrelevant things as ordinary things- toConcrete (A.DontCare e) = toConcrete e--- toConcrete (A.DontCare e) = C.DontCare <$> toConcreteCtx TopCtx e-{-- -- Andreas, 2010-09-21 abuse C.Underscore to print irrelevant things- toConcrete (A.DontCare) = return $ C.Underscore noRange Nothing--}--makeDomainFree :: A.LamBinding -> A.LamBinding-makeDomainFree b@(A.DomainFull (A.TypedBindings r (Arg h rel (A.TBind _ [x] t)))) =- case unScope t of- A.Underscore MetaInfo{metaNumber = Nothing} -> A.DomainFree h rel x- _ -> b- where- unScope (A.ScopedExpr _ e) = unScope e- unScope e = e-makeDomainFree b = b---- Binder instances ---------------------------------------------------------instance ToConcrete A.LamBinding C.LamBinding where- bindToConcrete (A.DomainFree h rel x) ret = bindToConcrete x $ ret . C.DomainFree h rel . mkBoundName_- bindToConcrete (A.DomainFull b) ret = bindToConcrete b $ ret . C.DomainFull--instance ToConcrete A.TypedBindings C.TypedBindings where- bindToConcrete (A.TypedBindings r bs) ret =- bindToConcrete bs $ \bs ->- ret (C.TypedBindings r bs)--instance ToConcrete A.TypedBinding C.TypedBinding where- bindToConcrete (A.TBind r xs e) ret =- bindToConcrete xs $ \xs -> do- e <- toConcreteCtx TopCtx e- ret (C.TBind r (map mkBoundName_ xs) e)- bindToConcrete (A.TNoBind e) ret = do- e <- toConcreteCtx TopCtx e- ret (C.TNoBind e)--instance ToConcrete LetBinding [C.Declaration] where- bindToConcrete (LetBind i rel x t e) ret =- bindToConcrete x $ \x ->- do (t,(e, [], [], [])) <- toConcrete (t, A.RHS e)- ret [ C.TypeSig rel x t- , C.FunClause (C.LHS (C.IdentP $ C.QName x) [] [] [])- e C.NoWhere- ]- bindToConcrete (LetApply i x modapp _ _) ret = do- x' <- unqualify <$> toConcrete x- modapp <- toConcrete modapp- let r = getRange modapp- open = maybe DontOpen id $ minfoOpenShort i- dir = maybe (ImportDirective r (Hiding []) [] False) id $ minfoDirective i- -- This is no use since toAbstract LetDefs is in localToAbstract.- local (openModule' x dir id) $- ret [ C.ModuleMacro (getRange i) x' modapp open dir ]- bindToConcrete (LetOpen i x) ret = do- x' <- toConcrete x- let dir = maybe defaultImportDir id $ minfoDirective i- local (openModule' x dir restrictPrivate) $- ret [ C.Open (getRange i) x' dir ]--data AsWhereDecls = AsWhereDecls [A.Declaration]--instance ToConcrete AsWhereDecls WhereClause where- bindToConcrete (AsWhereDecls []) ret = ret C.NoWhere- bindToConcrete (AsWhereDecls ds@[Section _ am _ _]) ret = do- ds' <- declsToConcrete ds- cm <- unqualify <$> lookupModule am- let wh' = (if isNoName cm then AnyWhere else SomeWhere cm) $ ds'- local (openModule' am defaultImportDir id) $ ret wh'- bindToConcrete (AsWhereDecls ds) ret =- ret . AnyWhere =<< declsToConcrete ds--mergeSigAndDef :: [C.Declaration] -> [C.Declaration]-mergeSigAndDef (C.RecordSig _ x bs e : C.Record r y c _ Nothing fs : ds)- | x == y = C.Record r y c bs (Just e) fs : mergeSigAndDef ds-mergeSigAndDef (C.DataSig _ _ x bs e : C.Data r i y _ Nothing cs : ds)- | x == y = C.Data r i y bs (Just e) cs : mergeSigAndDef ds-mergeSigAndDef (d : ds) = d : mergeSigAndDef ds-mergeSigAndDef [] = []--openModule' :: A.ModuleName -> ImportDirective -> (Scope -> Scope) -> Env -> Env-openModule' x dir restrict env = env{currentScope = sInfo{scopeModules = mods'}}- where sInfo = currentScope env- amod = scopeCurrent sInfo- mods = scopeModules sInfo- news = setScopeAccess PrivateNS- $ applyImportDirective dir- $ maybe emptyScope restrict- $ Map.lookup x mods- mods' = Map.update (Just . (`mergeScope` news)) amod mods----- Declaration instances ----------------------------------------------------declsToConcrete :: [A.Declaration] -> AbsToCon [C.Declaration]-declsToConcrete ds = mergeSigAndDef . concat <$> toConcrete ds--instance ToConcrete A.RHS (C.RHS, [C.Expr], [C.Expr], [C.Declaration]) where- toConcrete (A.RHS e) = do- e <- toConcrete e- return (C.RHS e, [], [], [])- toConcrete A.AbsurdRHS = return (C.AbsurdRHS, [], [], [])- toConcrete (A.WithRHS _ es cs) = do- es <- toConcrete es- cs <- concat <$> toConcrete cs- return (C.AbsurdRHS, [], es, cs)- toConcrete (A.RewriteRHS _ eqs rhs wh) = do- wh <- declsToConcrete wh- (rhs, eqs', es, whs) <- toConcrete rhs- unless (null eqs')- __IMPOSSIBLE__- eqs <- toConcrete eqs- return (rhs, eqs, es, wh ++ whs)--instance ToConcrete (Maybe A.QName) (Maybe C.Name) where- toConcrete Nothing = return Nothing- toConcrete (Just x) = do- x' <- toConcrete (qnameName x)- return $ Just x'---- | Helper function used in instance @ToConcrete Definition@.-telToTypedBindingss :: [C.LamBinding] -> [C.TypedBindings]-telToTypedBindingss = map lamBindingToTypedBindings where-- lamBindingToTypedBindings :: C.LamBinding -> C.TypedBindings- lamBindingToTypedBindings b =- case b of- C.DomainFull t -> t- C.DomainFree h r n -> C.TypedBindings noRange $- Arg h r $ C.TBind noRange [n] $ C.Underscore noRange Nothing--instance ToConcrete (Constr A.Constructor) C.Declaration where- toConcrete (Constr (A.ScopedDecl scope [d])) =- withScope scope $ toConcrete (Constr d)- toConcrete (Constr (A.Axiom i rel x t)) = do- x' <- unsafeQNameToName <$> toConcrete x- t' <- toConcreteCtx TopCtx t- return $ C.TypeSig rel x' t'- toConcrete (Constr d) = head <$> toConcrete d--instance ToConcrete A.Clause [C.Declaration] where- toConcrete (A.Clause lhs rhs wh) =- bindToConcrete lhs $ \lhs ->- case lhs of- C.LHS p wps _ _ -> do- bindToConcrete (AsWhereDecls wh) $ \wh' -> do- (rhs', eqs, with, wcs) <- toConcreteCtx TopCtx rhs- return $ FunClause (C.LHS p wps eqs with) rhs' wh' : wcs- C.Ellipsis {} -> __IMPOSSIBLE__- -- TODO: Is the case above impossible? Previously there was- -- no code for it, but GHC 7's completeness checker spotted- -- that the case was not covered.--instance ToConcrete A.ModuleApplication C.ModuleApplication where- toConcrete (A.SectionApp tel y es) = do- y <- toConcrete y- bindToConcrete tel $ \tel -> do- es <- toConcrete es- let r = fuseRange y es- return $ C.SectionApp r tel (foldl (C.App r) (C.Ident y) es)- toConcrete (A.RecordModuleIFS rec) = do- rec <- toConcrete rec- return $ C.RecordModuleIFS (getRange rec) rec--instance ToConcrete A.Declaration [C.Declaration] where- toConcrete (ScopedDecl scope ds) =- withScope scope (declsToConcrete ds)-- toConcrete (Axiom i rel x t) = do- x' <- unsafeQNameToName <$> toConcrete x- withAbstractPrivate i $- withInfixDecl i x' $ do- t' <- toConcreteCtx TopCtx t- return [C.Postulate (getRange i) [C.TypeSig rel x' t']]-- toConcrete (A.Field i x t) = do- x' <- unsafeQNameToName <$> toConcrete x- withAbstractPrivate i $- withInfixDecl i x' $ do- t' <- toConcreteCtx TopCtx t- return [C.Field x' t']-- toConcrete (A.Primitive i x t) = do- x' <- unsafeQNameToName <$> toConcrete x- withAbstractPrivate i $- withInfixDecl i x' $ do- t' <- toConcreteCtx TopCtx t- return [C.Primitive (getRange i) [C.TypeSig Relevant x' t']]- -- Primitives are always relevant.-- toConcrete (A.FunDef i _ cs) =- withAbstractPrivate i $ concat <$> toConcrete cs-- toConcrete (A.DataSig i x bs t) =- withAbstractPrivate i $- bindToConcrete bs $ \tel' -> do- x' <- unsafeQNameToName <$> toConcrete x- t' <- toConcreteCtx TopCtx t- return [ C.DataSig (getRange i) Inductive x' (map C.DomainFull tel') t' ]-- toConcrete (A.DataDef i x bs cs) =- withAbstractPrivate i $- bindToConcrete (map makeDomainFree bs) $ \tel' -> do- (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs)- return [ C.Data (getRange i) Inductive x' tel' Nothing cs' ]-- toConcrete (A.RecSig i x bs t) =- withAbstractPrivate i $- bindToConcrete bs $ \tel' -> do- x' <- unsafeQNameToName <$> toConcrete x- t' <- toConcreteCtx TopCtx t- return [ C.RecordSig (getRange i) x' (map C.DomainFull tel') t' ]-- toConcrete (A.RecDef i x c bs t cs) =- withAbstractPrivate i $- bindToConcrete (map makeDomainFree bs) $ \tel' -> do- (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs)- return [ C.Record (getRange i) x' Nothing tel' Nothing cs' ]-- toConcrete (A.Mutual i ds) = declsToConcrete ds-- toConcrete (A.Section i x tel ds) = do- x <- toConcrete x- bindToConcrete tel $ \tel -> do- ds <- declsToConcrete ds- return [ C.Module (getRange i) x tel ds ]-- toConcrete (A.Apply i x modapp _ _) = do- x <- unsafeQNameToName <$> toConcrete x- modapp <- toConcrete modapp- let r = getRange modapp- open = maybe DontOpen id $ minfoOpenShort i- dir = maybe (ImportDirective r (Hiding []) [] False) id $ minfoDirective i- return [ C.ModuleMacro (getRange i) x modapp open dir ]-- toConcrete (A.Import i x) = do- x <- toConcrete x- let open = maybe DontOpen id $ minfoOpenShort i- dir = maybe defaultImportDir id $ minfoDirective i- return [ C.Import (getRange i) x Nothing open dir]-- toConcrete (A.Pragma i p) = do- p <- toConcrete $ RangeAndPragma (getRange i) p- return [C.Pragma p]-- toConcrete (A.Open i x) = do- x <- toConcrete x- return [C.Open (getRange i) x defaultImportDir]--data RangeAndPragma = RangeAndPragma Range A.Pragma--instance ToConcrete RangeAndPragma C.Pragma where- toConcrete (RangeAndPragma r p) = case p of- A.OptionsPragma xs -> return $ C.OptionsPragma r xs- A.BuiltinPragma b x -> do- x <- toConcrete x- return $ C.BuiltinPragma r b x- A.CompiledTypePragma x hs -> do- x <- toConcrete x- return $ C.CompiledTypePragma r x hs- A.CompiledDataPragma x hs hcs -> do- x <- toConcrete x- return $ C.CompiledDataPragma r x hs hcs- A.CompiledPragma x hs -> do- x <- toConcrete x- return $ C.CompiledPragma r x hs- A.CompiledEpicPragma x e -> do- x <- toConcrete x- return $ C.CompiledEpicPragma r x e- A.CompiledJSPragma x e -> do- x <- toConcrete x- return $ C.CompiledJSPragma r x e- A.StaticPragma x -> do- x <- toConcrete x- return $ C.StaticPragma r x- A.EtaPragma x -> C.EtaPragma r <$> toConcrete x---- Left hand sides ----------------------------------------------------------noImplicitArgs = filter (noImplicit . namedThing . unArg)-noImplicitPats = filter noImplicit--noImplicit (A.ImplicitP _) = False-noImplicit _ = True--instance ToConcrete A.LHS C.LHS where- bindToConcrete (A.LHS i x args wps) ret = do- bindToConcreteCtx TopCtx (A.DefP info x args) $ \lhs ->- bindToConcreteCtx TopCtx (noImplicitPats wps) $ \wps ->- ret $ C.LHS lhs wps [] []- where info = PatRange (getRange i)--appBrackets' :: [arg] -> Precedence -> Bool-appBrackets' [] _ = False-appBrackets' (_:_) ctx = appBrackets ctx---- TODO: bind variables properly-instance ToConcrete A.Pattern C.Pattern where- toConcrete (VarP x) = toConcrete x >>= return . IdentP . C.QName- toConcrete (A.WildP i) =- return $ C.WildP (getRange i)- toConcrete (ConP i (AmbQ []) args) = __IMPOSSIBLE__- toConcrete p@(ConP i (AmbQ (x:_)) args) =- tryToRecoverOpAppP p $- bracketP_ (appBrackets' args) $ do- x <- toConcrete x- args <- toConcreteCtx ArgumentCtx (noImplicitArgs args)- return $ foldl AppP (C.IdentP x) args- toConcrete p@(DefP i x args) =- tryToRecoverOpAppP p $- bracketP_ (appBrackets' args) $ do- x <- toConcrete x- args <- toConcreteCtx ArgumentCtx (noImplicitArgs args)- return $ foldl AppP (C.IdentP x) args- toConcrete (A.AsP i x p) = do- (x, p) <- toConcreteCtx ArgumentCtx (x,p)- return $ C.AsP (getRange i) x p- toConcrete (A.AbsurdP i) = return $ C.AbsurdP (getRange i)- toConcrete (A.LitP l) = return $ C.LitP l- toConcrete (A.DotP i e) = do- e <- toConcreteCtx DotPatternCtx e- return $ C.DotP (getRange i) e- -- just for debugging purposes (shouldn't show up in practise)- toConcrete (A.ImplicitP i) = return $ C.IdentP (C.QName $ C.Name noRange [C.Id "(implicit)"])---- Helpers for recovering C.OpApp --------------------------------------------data Hd = HdVar A.Name | HdCon A.QName | HdDef A.QName--cOpApp :: Range -> C.Name -> [C.Expr] -> C.Expr-cOpApp r n es = C.OpApp r n (map Ordinary es)--tryToRecoverOpApp :: A.Expr -> AbsToCon C.Expr -> AbsToCon C.Expr-tryToRecoverOpApp e def = recoverOpApp bracket cOpApp view e def- where- view e = case AV.appView e of- --NonApplication _ -> Nothing- Application (Var x) args -> Just (HdVar x, args)- Application (Def f) args -> Just (HdDef f, args)- Application (Con (AmbQ (c:_))) args -> Just (HdCon c, args)- Application (Con (AmbQ [])) args -> __IMPOSSIBLE__- _ -> Nothing--tryToRecoverOpAppP :: A.Pattern -> AbsToCon C.Pattern -> AbsToCon C.Pattern-tryToRecoverOpAppP p def = recoverOpApp bracketP_ C.OpAppP view p def- where- view p = case p of- ConP _ (AmbQ (c:_)) ps -> Just (HdCon c, ps)- DefP _ f ps -> Just (HdDef f, ps)- _ -> Nothing--recoverOpApp :: (ToConcrete a c, HasRange c) =>- ((Precedence -> Bool) -> AbsToCon c -> AbsToCon c) ->- (Range -> C.Name -> [c] -> c) -> (a -> Maybe (Hd, [NamedArg a])) -> a ->- AbsToCon c -> AbsToCon c-recoverOpApp bracket opApp view e mdefault = case view e of- Nothing -> mdefault- Just (hd, args)- | all notHidden args -> do- let args' = map (namedThing . unArg) args- case hd of- HdVar n | isNoName n -> mdefault- | otherwise -> do- x <- toConcrete n- doCName (theFixity $ nameFixity n) x args'- HdDef qn -> doQName qn args'- HdCon qn -> doQName qn args'- | otherwise -> mdefault- where-- isNoName x = C.isNoName $ A.nameConcrete x-- notHidden a = argHiding a == NotHidden-- -- qualified names can't use mixfix syntax- doQName qn as = do- x <- toConcrete qn- case x of- C.QName x -> doCName (theFixity $ nameFixity $ qnameName qn) x as- _ -> mdefault-- -- fall-back (wrong number of arguments or no holes)- doCName _ cn@(C.Name _ xs) es- | length xs == 1 = mdefault- | length es /= numHoles = mdefault- | List.null es = mdefault- where numHoles = length [ () | Hole <- xs ]- msg = "doCName " ++ showList xs "" ++ " on " ++ show (length es) ++ " args"-- -- binary case- doCName fixity cn@(C.Name _ xs) as- | Hole <- head xs- , Hole <- last xs = do- let a1 = head as- an = last as- as' = case as of- as@(_:_:_) -> init $ tail as- _ -> __IMPOSSIBLE__- e1 <- toConcreteCtx (LeftOperandCtx fixity) a1- es <- mapM (toConcreteCtx InsideOperandCtx) as'- en <- toConcreteCtx (RightOperandCtx fixity) an- bracket (opBrackets fixity)- $ return $ opApp (getRange (e1,en)) cn ([e1] ++ es ++ [en])-- -- prefix- doCName fixity cn@(C.Name _ xs) as- | Hole <- last xs = do- let an = last as- as' = case as of- as@(_:_) -> init as- _ -> __IMPOSSIBLE__- es <- mapM (toConcreteCtx InsideOperandCtx) as'- en <- toConcreteCtx (RightOperandCtx fixity) an- bracket (opBrackets fixity)- $ return $ opApp (getRange (cn,en)) cn (es ++ [en])-- -- postfix- doCName fixity cn@(C.Name _ xs) as- | Hole <- head xs = do- let a1 = head as- as' = tail as- e1 <- toConcreteCtx (LeftOperandCtx fixity) a1- es <- mapM (toConcreteCtx InsideOperandCtx) as'- bracket (opBrackets fixity)- $ return $ opApp (getRange (e1,cn)) cn ([e1] ++ es)-- -- roundfix- doCName _ cn as = do- es <- mapM (toConcreteCtx InsideOperandCtx) as- bracket roundFixBrackets- $ return $ opApp (getRange cn) cn es+-- {-# OPTIONS -fwarn-unused-binds #-}++{-| The translation of abstract syntax to concrete syntax has two purposes.+ First it allows us to pretty print abstract syntax values without having to+ write a dedicated pretty printer, and second it serves as a sanity check+ for the concrete to abstract translation: translating from concrete to+ abstract and then back again should be (more or less) the identity.+-}+module Agda.Syntax.Translation.AbstractToConcrete+ ( ToConcrete(..)+ , toConcreteCtx+ , MonadAbsToCon+ , abstractToConcrete_+ , abstractToConcreteCtx+ , abstractToConcreteHiding+ , abstractToConcreteQName+ , abstractToConcreteScope+ , abstractToConcreteTelescope+ , abstractToConcreteUnqualify+ , RangeAndPragma(..)+ , noTakenNames+ ) where++import Prelude hiding (null)++import Control.Monad.Except ( runExceptT )+import Control.Monad.Reader ( MonadReader(..), asks, ReaderT, runReaderT )+import Control.Monad.State ( StateT(..), runStateT )++import Data.Bifunctor ( first )+import qualified Data.Map as Map+import Data.Maybe+import Data.Monoid+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Map (Map)+import qualified Data.Foldable as Fold+import Data.Void+import Data.List (sortBy)+import Data.Semigroup ( sconcat )+import Data.String++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty+import Agda.Syntax.Position+import Agda.Syntax.Literal+import Agda.Syntax.Info as A+import qualified Agda.Syntax.Internal as I+import Agda.Syntax.Fixity+import Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Pattern as C+import Agda.Syntax.Concrete.Glyph+import Agda.Syntax.Abstract as A+import Agda.Syntax.Abstract.Views as A+import Agda.Syntax.Abstract.Pattern as A+import Agda.Syntax.Abstract.PatternSynonyms+import Agda.Syntax.Scope.Base+import Agda.Syntax.Scope.Monad ( tryResolveName )++import Agda.TypeChecking.Monad.State (getScope, getAllPatternSyns)+import Agda.TypeChecking.Monad.Base as I+import Agda.TypeChecking.Monad.Context+import Agda.TypeChecking.Monad.Debug+import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Monad.MetaVars+import Agda.TypeChecking.Monad.Pure+import Agda.TypeChecking.Monad.Trace+import Agda.TypeChecking.Monad.Signature+import {-# SOURCE #-} Agda.TypeChecking.Records (isRecord)+import {-# SOURCE #-} Agda.TypeChecking.Pretty (prettyTCM)+import Agda.Interaction.Options++import qualified Agda.Utils.AssocList as AssocList+import Agda.Utils.Either+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|), (<|) )+import Agda.Utils.List2 (List2, pattern List2)+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import qualified Agda.Syntax.Common.Aspect as Asp+import Agda.Utils.Set1 (Set1)+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Singleton+import Agda.Utils.Suffix++import Agda.Utils.Impossible++---------------------------------------------------------------------------+-- * The Interface+---------------------------------------------------------------------------++-- | Preconditions to run the AbstractToConcrete translation.+--+type MonadAbsToCon m =+ ( MonadFileId m+ , MonadFresh NameId m+ , MonadInteractionPoints m+ , MonadStConcreteNames m+ , HasOptions m+ , PureTCM m+ , IsString (m Doc)+ , Null (m Doc)+ , Semigroup (m Doc)+ )++abstractToConcreteScope :: (ToConcrete a, MonadAbsToCon m)+ => ScopeInfo -> a -> m (ConOfAbs a)+abstractToConcreteScope scope a = runReaderT (unAbsToCon $ toConcrete a) =<< makeEnv scope++abstractToConcreteCtx :: (ToConcrete a, MonadAbsToCon m)+ => Precedence -> a -> m (ConOfAbs a)+abstractToConcreteCtx ctx x = runAbsToCon $ withPrecedence ctx (toConcrete x)++abstractToConcrete_ :: (ToConcrete a, MonadAbsToCon m)+ => a -> m (ConOfAbs a)+abstractToConcrete_ = runAbsToCon . toConcrete++abstractToConcreteHiding :: (LensHiding i, ToConcrete a, MonadAbsToCon m)+ => i -> a -> m (ConOfAbs a)+abstractToConcreteHiding i = runAbsToCon . toConcreteHiding i++abstractToConcreteTelescope :: MonadAbsToCon m+ => A.Telescope -> m [Maybe C.TypedBinding]+abstractToConcreteTelescope tel = runAbsToCon $ bindToConcrete tel return++abstractToConcreteQName :: MonadAbsToCon m+ => AllowAmbiguousNames -> A.QName -> m (C.QName)+abstractToConcreteQName amb = runAbsToCon . lookupQName amb++abstractToConcreteUnqualify :: (ToConcrete a, MonadAbsToCon m)+ => a -> m (ConOfAbs a)+abstractToConcreteUnqualify = runAbsToCon . doUnqualifyOutOfScopeNames . toConcrete++---------------------------------------------------------------------------+-- * The Monad for the implementation+---------------------------------------------------------------------------++type MonadToConcrete m =+ ( MonadFileId m+ , MonadAbsToCon m+ , MonadReader Env m+ )++newtype AbsToConT m a = AbsToCon { unAbsToCon :: ReaderT Env m a }+ deriving+ ( Functor, Applicative, Monad, MonadReader Env+ , HasBuiltins+ , HasConstInfo+ , HasOptions+ , MonadAddContext+ , MonadDebug+ , MonadFileId+ , MonadInteractionPoints+ , MonadReduce+ , MonadStConcreteNames+ , MonadTCEnv+ , PureTCM+ , ReadTCState+ )++deriving instance MonadFresh NameId m => MonadFresh NameId (AbsToConT m)+deriving instance (Monad m, IsString (m Doc)) => IsString (AbsToConT m Doc)+deriving instance (Monad m, Null (m Doc)) => Null (AbsToConT m Doc)+deriving instance (Monad m) => Semigroup (AbsToConT m Doc)++runAbsToCon :: MonadAbsToCon m => AbsToConT m c -> m c+runAbsToCon m = do+ scope <- getScope+ verboseBracket "toConcrete" 50 "runAbsToCon" $ do+ reportSLn "toConcrete" 50 $ render $ hsep $+ [ "entering AbsToCon with scope:"+ , prettyList_ (map (text . C.nameToRawName . fst) $ scope ^. scopeLocals)+ ]+ x <- runReaderT (unAbsToCon m) =<< makeEnv scope+ reportSLn "toConcrete" 50 $ "leaving AbsToCon"+ return x++---------------------------------------------------------------------------+-- * The Environment+---------------------------------------------------------------------------++data Env = Env+ { takenVarNames :: Set A.Name+ -- ^ Abstract names currently in scope.+ -- Unlike the 'ScopeInfo', this includes names for hidden arguments+ -- inserted by the system.+ , takenDefNames :: Set C.NameParts+ -- ^ Concrete names of all definitions in scope.+ , currentScope :: ScopeInfo+ , builtins :: Map BuiltinId A.QName+ -- ^ Certain builtins (like `fromNat`) have special printing.+ , preserveIIds :: Bool+ -- ^ Preserve interaction point ids?+ , foldPatternSynonyms :: Bool+ , unqualifyOutOfScopeNames :: Bool+ -- ^ Print out-of-scope names unqualified (`a` instead of `A.B.a`).+ }++makeEnv :: MonadAbsToCon m => ScopeInfo -> m Env+makeEnv scope = do+ -- zero and suc doesn't have to be in scope for natural number literals to work+ let noScopeCheck b = b `elem` [builtinZero, builtinSuc]+ name (I.Def q _) = Just q+ name (I.Con q _ _) = Just (I.conName q)+ name _ = Nothing+ builtin b = getBuiltin' b >>= \ case+ Just v | Just q <- name v,+ noScopeCheck b || isNameInScope q scope -> return [(b, q)]+ _ -> return []+ ctxVars <- getContextNames'+ letVars <- Map.keys <$> viewTC eLetBindings+ let vars = ctxVars ++! letVars++ -- pick concrete names for in-scope names now so we don't+ -- accidentally shadow them+ forM_ (scope ^. scopeLocals) $ \(y , x) -> do+ pickConcreteName (localVar x) y++ builtinList <- concat <$> mapM builtin [ builtinFromNat, builtinFromString, builtinFromNeg, builtinZero, builtinSuc ]+ foldPatSyns <- optPrintPatternSynonyms <$> pragmaOptions+ return $+ Env { takenVarNames = Set.fromList vars+ , takenDefNames = defs+ , currentScope = scope+ , builtins = Map.fromListWith __IMPOSSIBLE__ builtinList+ , preserveIIds = False+ , foldPatternSynonyms = foldPatSyns+ , unqualifyOutOfScopeNames = False+ }+ where+ defs = Set.fromList $ map (nameParts . fst) $+ filter (uncurry usefulDef) $+ Map.toList $ nsNames $ everythingInScope scope++ -- Jesper, 2018-12-10: It's fine to shadow generalizable names as+ -- they will never show up directly in printed terms.+ notGeneralizeName AbsName{ anameKind = k } =+ not (k == GeneralizeName || k == DisallowedGeneralizeName)++ usefulDef C.NoName{} _ = False+ usefulDef C.Name{} names = all notGeneralizeName names++ nameParts (C.NoName {}) = __IMPOSSIBLE__+ nameParts (C.Name { nameNameParts }) = nameNameParts++-- | Bind a concrete name to an abstract in the translation environment.+addBinding :: C.Name -> A.Name -> Env -> Env+addBinding y x e =+ e { takenVarNames = Set.insert x $ takenVarNames e+ , currentScope = (`updateScopeLocals` currentScope e) $+ AssocList.insert y (LocalVar x __IMPOSSIBLE__ [])+ }++---------------------------------------------------------------------------+-- * Service functions+---------------------------------------------------------------------------++currentPrecedence :: MonadToConcrete m => m PrecedenceStack+currentPrecedence = asks $ (^. scopePrecedence) . currentScope++preserveInteractionIds :: MonadToConcrete m => m a -> m a+preserveInteractionIds = local $ \ e -> e { preserveIIds = True }++localPrecedenceStack :: MonadToConcrete m+ => (PrecedenceStack -> PrecedenceStack) -> m a -> m a+localPrecedenceStack f = local \ env ->+ env{ currentScope = over scopePrecedence f (currentScope env) }++withPrecedence' :: MonadToConcrete m => PrecedenceStack -> m a -> m a+withPrecedence' = localPrecedenceStack . const++withPrecedence :: MonadToConcrete m => Precedence -> m a -> m a+withPrecedence = localPrecedenceStack . pushPrecedence++withScope :: MonadToConcrete m => ScopeInfo -> m a -> m a+withScope scope = local $ \e -> e { currentScope = scope }++noTakenNames :: MonadToConcrete m => m a -> m a+noTakenNames = local $ \e -> e { takenVarNames = Set.empty }++dontFoldPatternSynonyms :: MonadToConcrete m => m a -> m a+dontFoldPatternSynonyms = local $ \ e -> e { foldPatternSynonyms = False }++doUnqualifyOutOfScopeNames :: MonadToConcrete m => m a -> m a+doUnqualifyOutOfScopeNames = local $ \ e -> e { unqualifyOutOfScopeNames = True }++-- | Get a function to check if a name refers to a particular builtin function.+isBuiltinFun :: MonadToConcrete m => m (A.QName -> BuiltinId -> Bool)+isBuiltinFun = asks $ is . builtins+ where is m q b = Just q == Map.lookup b m++-- | Resolve a concrete name. If illegally ambiguous fail with the ambiguous names.+resolveName :: MonadToConcrete m => KindsOfNames -> Maybe (Set1 A.Name) -> C.QName -> m (Either NameResolutionError ResolvedName)+resolveName kinds candidates q = runExceptT $ tryResolveName kinds candidates q++-- | Treat illegally ambiguous names as UnknownNames.+resolveName_ :: MonadToConcrete m => C.QName -> A.Name -> m ResolvedName+resolveName_ q cand = fromRight (const UnknownName) <$> resolveName allKindsOfNames (Just $ singleton cand) q++---------------------------------------------------------------------------+-- ** Dealing with names+---------------------------------------------------------------------------++-- | Names in abstract syntax are fully qualified, but the concrete syntax+-- requires non-qualified names in places. In theory (if all scopes are+-- correct), we should get a non-qualified name when translating back to a+-- concrete name, but I suspect the scope isn't always perfect. In these+-- cases we just throw away the qualified part. It's just for pretty printing+-- anyway...+unsafeQNameToName :: C.QName -> C.Name+unsafeQNameToName = C.unqualify++-- | Like 'isRecordConstructor' but does not throw IMPOSSIBLE if the+-- name is not in scope.+isExistingRecordConstructor :: MonadToConcrete m => A.QName -> m (Maybe (A.QName, RecordData))+isExistingRecordConstructor c = getConstInfo' c >>= \case+ Left (SigUnknown err) -> return Nothing+ Left SigCubicalNotErasure -> return Nothing+ Left SigAbstract -> return Nothing+ Right def -> case theDef $ def of+ I.Constructor{ conData = r } -> fmap (r,) <$> isRecord r+ _ -> return Nothing+++lookupQName :: MonadToConcrete m => AllowAmbiguousNames -> A.QName -> m C.QName+lookupQName ambCon x | Just s <- getGeneralizedFieldName x =+ return (C.QName $ C.Name noRange C.InScope $ C.stringNameParts s)+lookupQName ambCon x = ignoreAbstractMode (isExistingRecordConstructor x) >>= \case+ -- If the QName is the internal name of a record with no named+ -- constructor, we should first concretise the name *of the record*,+ -- since that will *actually* be in scope through a concrete QName.+ Just (r, def) | not (_recNamedCon def) -> do+ reportSLn "scope.inverse" 100 $+ "inverse lookup of record constructor " ++ prettyShow x+ recr <- lookupQName ambCon r+ pure (recr `C.qualify` simpleName "constructor")++ _ -> do+ ys <- asks (inverseScopeLookupName' ambCon x . currentScope)+ reportSLn "scope.inverse" 100 $+ "inverse looking up abstract name " ++ prettyShow x ++ " yields " ++ prettyShow ys+ loop ys++ where+ -- Found concrete name: check that it is not shadowed by a local+ loop (qy@Qual{} : _ ) = return qy -- local names cannot be qualified+ loop (qy@(C.QName y) : ys) = lookupNameInScope y >>= \case+ Just x' | x' /= qnameName x -> loop ys+ _ -> return qy+ -- Found no concrete name:+ loop [] = case qnameToConcrete x of+ -- The name is qualified: in this case, we are likely dealing with a parameterised+ -- module, and the unqualified name might actually be in scope (see #3209).+ -- To make case splitting more useful in that situation, we unqualify the name+ -- if we are generating clauses for a case split.+ qy@Qual{} -> do+ doUnqualify <- asks unqualifyOutOfScopeNames+ return $ setNotInScope $ if doUnqualify then C.QName (unqualify qy) else qy+ -- The name is unqualified: make up a new one+ qy@C.QName{} -> C.QName <$> chooseName (qnameName x)++lookupModule :: MonadToConcrete m => A.ModuleName -> m C.QName+lookupModule (A.MName []) = return $ C.QName $ C.simpleName "-1"+ -- Andreas, 2016-10-10 it can happen that we have an empty module name+ -- for instance when we query the current module inside the+ -- frontmatter or module telescope of the top level module.+ -- In this case, we print it as an invalid module name.+ -- (Should only affect debug printing.)+lookupModule x =+ do scope <- asks currentScope+ case inverseScopeLookupModule x scope of+ (y : _) -> return y+ [] -> return $ mnameToConcrete x+ -- this is what happens for names that are not in scope (private names)++-- | Is this concrete name currently in use by a particular abstract+-- name in the current scope?+lookupNameInScope :: MonadToConcrete m => C.Name -> m (Maybe A.Name)+lookupNameInScope y =+ asks ((fmap localVar . lookup y) . ((^. scopeLocals) . currentScope))++-- | Have we already committed to a specific concrete name for this+-- abstract name? If yes, return the concrete name(s).+hasConcreteNames :: (MonadStConcreteNames m) => A.Name -> m [C.Name]+hasConcreteNames x = maybe [] List1.toList . Map.lookup x <$> useConcreteNames++-- | Commit to a specific concrete name for printing the given+-- abstract name. If the abstract name already has associated+--- concrete name(s), the new name is only used when all previous+--- names are shadowed. Precondition: the abstract name should be in+-- scope.+pickConcreteName :: (MonadStConcreteNames m) => A.Name -> C.Name -> m ()+pickConcreteName x y = modifyConcreteNames $ flip Map.alter x $ Just . \case+ Nothing -> singleton y+ Just ys -> List1.snoc (List1.toList ys) y++-- | For the given abstract name, return the names that could shadow it.+shadowingNames :: (ReadTCState m)+ => A.Name -> m (Set RawName)+shadowingNames x = pure mempty -- TODO++toConcreteName :: MonadToConcrete m => A.Name -> m C.Name+toConcreteName x | y <- nameConcrete x , isNoName y = return y+toConcreteName x = hasConcreteNames x >>= loop+ where+ -- case: we already have picked some name(s) for x+ loop (y:ys) = ifM (isGoodName x y) (return y) (loop ys)++ -- case: we haven't picked a concrete name yet, or all previously+ -- picked names are shadowed, so we pick a new name now+ loop [] = do+ y <- chooseName x+ pickConcreteName x y+ return y++ -- Is 'y' a good concrete name for abstract name 'x'?+ isGoodName :: MonadToConcrete m => A.Name -> C.Name -> m Bool+ isGoodName x y = do+ zs <- asks (Set.toList . takenVarNames)+ forallM zs $ \ z -> pure (x == z) `or2M` (notElem y <$> hasConcreteNames z)+++-- | Choose a new unshadowed name for the given abstract name+-- | NOTE: See @withName@ in @Agda.Syntax.Translation.ReflectedToAbstract@ for similar logic.+-- | NOTE: See @freshConcreteName@ in @Agda.Syntax.Scope.Monad@ also for similar logic.+chooseName :: MonadToConcrete m => A.Name -> m C.Name+chooseName x = lookupNameInScope (nameConcrete x) >>= \case+ -- If the name is currently in scope, we do not rename it+ Just x' | x == x' -> do+ reportSLn "toConcrete.bindName" 80 $+ "name " ++ C.nameToRawName (nameConcrete x) ++ " already in scope, so not renaming"+ return $ nameConcrete x+ -- Otherwise we pick a name that does not shadow other names+ _ -> do+ takenDefs <- asks takenDefNames+ taken <- takenNames+ toAvoid <- shadowingNames x+ glyphMode <- optUseUnicode <$> pragmaOptions+ let freshNameMode = case glyphMode of+ UnicodeOk -> A.UnicodeSubscript+ AsciiOnly -> A.AsciiCounter++ shouldAvoid C.NoName {} = False+ shouldAvoid name@C.Name { nameNameParts } =+ let raw = C.nameToRawName name in+ nameNameParts `Set.member` takenDefs ||+ raw `Set.member` taken ||+ raw `Set.member` toAvoid++ y = firstNonTakenName freshNameMode shouldAvoid $ nameConcrete x+ reportSLn "toConcrete.bindName" 80 $ render $ vcat+ [ "picking concrete name for:" <+> text (C.nameToRawName $ nameConcrete x)+ , "names already taken: " <+> prettyList_ (Set.toList taken)+ , "names to avoid: " <+> prettyList_ (Set.toList toAvoid)+ , "concrete name chosen: " <+> text (C.nameToRawName y)+ ]+ return y++ where+ takenNames :: MonadToConcrete m => m (Set RawName)+ takenNames = do+ ys0 <- Set.toList <$> asks takenVarNames+ reportSLn "toConcrete.bindName" 90 $ render $ "abstract names of local vars: " <+> prettyList_ (map (C.nameToRawName . nameConcrete) ys0)+ Set.fromList . map C.nameToRawName . concat <$> mapM hasConcreteNames ys0+++-- | Add a abstract name to the scope and produce an available concrete version of it.+bindName :: MonadToConcrete m => A.Name -> (C.Name -> m a) -> m a+bindName x ret = do+ y <- toConcreteName x+ reportSLn "toConcrete.bindName" 30 $ "adding " ++ C.nameToRawName (nameConcrete x) ++ " to the scope under concrete name " ++ C.nameToRawName y+ local (addBinding y x) $ ret y++-- | Like 'bindName', but do not care whether name is already taken.+bindName' :: MonadToConcrete m => A.Name -> m a -> m a+bindName' x ret = do+ reportSLn "toConcrete.bindName" 30 $ "adding " ++ C.nameToRawName (nameConcrete x) ++ " to the scope with forced name"+ pickConcreteName x y+ applyUnless (isNoName y) (local $ addBinding y x) ret+ where y = nameConcrete x++---------------------------------------------------------------------------+-- ** Dealing with precedences+---------------------------------------------------------------------------++-- | General bracketing function.+bracket' :: MonadToConcrete m+ => (e -> e)+ -- ^ The bracketing function.+ -> (PrecedenceStack -> Bool)+ -- ^ Should we bracket things which have the given precedence?+ -> e+ -> m e+bracket' paren needParen e =+ do p <- currentPrecedence+ return $ if needParen p then paren e else e++-- | Expression bracketing+bracket :: MonadToConcrete m => (PrecedenceStack -> Bool) -> m C.Expr -> m C.Expr+bracket par m =+ do e <- m+ bracket' (Paren (getRange e)) par e++-- | Pattern bracketing+bracketP_ :: MonadToConcrete m => (PrecedenceStack -> Bool) -> m C.Pattern -> m C.Pattern+bracketP_ par m =+ do e <- m+ bracket' (ParenP (getRange e)) par e++-- | Applications where the argument is a lambda without parentheses need+-- parens more often than other applications.+isLambda :: NamedArg A.Expr -> Bool+isLambda e | notVisible e = False+isLambda e =+ case unScope $ namedArg e of+ A.Lam{} -> True+ A.AbsurdLam{} -> True+ A.ExtendedLam{} -> True+ _ -> False++---------------------------------------------------------------------------+-- ** Dealing with infix declarations+---------------------------------------------------------------------------++-- | If a name is defined with a fixity that differs from the default, we have+-- to generate a fixity declaration for that name.+withInfixDecl :: MonadToConcrete m => DefInfo -> C.Name -> m [C.Declaration] -> m [C.Declaration]+withInfixDecl i x m = ((fixDecl ++ synDecl) ++) <$> m+ where+ fixDecl = [ C.Infix (theFixity $ defFixity i) $ singleton x+ | theFixity (defFixity i) /= noFixity+ ]+ synDecl = [ C.Syntax x $ theNotation $ defFixity i ]++---------------------------------------------------------------------------+-- ** Dealing with private definitions+---------------------------------------------------------------------------++-- | Add @abstract@, @private@, @instance@ modifiers.+withAbstractPrivate :: MonadToConcrete m => DefInfo -> m [C.Declaration] -> m [C.Declaration]+withAbstractPrivate i m =+ priv (defAccess i)+ . abst (A.defAbstract i)+ . addInstanceB (case A.defInstance i of InstanceDef r -> Just r; NotInstanceDef -> Nothing)+ <$> m+ where+ priv (PrivateAccess kwr UserWritten)+ ds = [ C.Private kwr UserWritten ds ]+ priv _ ds = ds+ abst AbstractDef ds = [ C.Abstract empty ds ]+ abst ConcreteDef ds = ds++addInstanceB :: Maybe KwRange -> [C.Declaration] -> [C.Declaration]+addInstanceB (Just r) ds = [ C.InstanceB r ds ]+addInstanceB Nothing ds = ds++---------------------------------------------------------------------------+-- * The To Concrete Class+---------------------------------------------------------------------------++class ToConcrete a where+ type ConOfAbs a+ toConcrete :: MonadToConcrete m => a -> m (ConOfAbs a)+ bindToConcrete :: MonadToConcrete m => a -> (ConOfAbs a -> m b) -> m b++ -- Christian Sattler, 2017-08-05:+ -- These default implementations are not valid semantically (at least+ -- the second one). Perhaps they (it) should be removed.+ toConcrete x = bindToConcrete x return+ bindToConcrete x ret = ret =<< toConcrete x++ {-# MINIMAL toConcrete | bindToConcrete #-}++-- | Translate something in a context of the given precedence.+toConcreteCtx :: MonadToConcrete m => ToConcrete a => Precedence -> a -> m (ConOfAbs a)+toConcreteCtx p x = withPrecedence p $ toConcrete x++-- | Translate something in a context of the given precedence.+bindToConcreteCtx :: MonadToConcrete m => ToConcrete a => Precedence -> a -> (ConOfAbs a -> m b) -> m b+bindToConcreteCtx p x ret = withPrecedence p $ bindToConcrete x ret++-- | Translate something in the top context.+toConcreteTop :: MonadToConcrete m => ToConcrete a => a -> m (ConOfAbs a)+toConcreteTop = toConcreteCtx TopCtx++-- | Translate something in the top context.+bindToConcreteTop :: MonadToConcrete m => ToConcrete a => a -> (ConOfAbs a -> m b) -> m b+bindToConcreteTop = bindToConcreteCtx TopCtx++-- | Translate something in a context indicated by 'Hiding' info.+toConcreteHiding :: MonadToConcrete m => (LensHiding h, ToConcrete a) => h -> a -> m (ConOfAbs a)+toConcreteHiding h =+ case getHiding h of+ NotHidden -> toConcrete+ Hidden -> toConcreteTop+ Instance{} -> toConcreteTop++-- | Translate something in a context indicated by 'Hiding' info.+bindToConcreteHiding :: MonadToConcrete m => (LensHiding h, ToConcrete a) => h -> a -> (ConOfAbs a -> m b) -> m b+bindToConcreteHiding h =+ case getHiding h of+ NotHidden -> bindToConcrete+ Hidden -> bindToConcreteTop+ Instance{} -> bindToConcreteTop++-- Base type instances ------------------------------------------------------++instance ToConcrete () where+ type ConOfAbs () = ()+ toConcrete = pure++instance ToConcrete Bool where+ type ConOfAbs Bool = Bool+ toConcrete = pure++instance ToConcrete Char where+ type ConOfAbs Char = Char+ toConcrete = pure++instance ToConcrete C.Name where+ type ConOfAbs C.Name = C.Name+ toConcrete = pure++-- Functors ---------------------------------------------------------------++instance ToConcrete a => ToConcrete [a] where+ type ConOfAbs [a] = [ConOfAbs a]++ toConcrete = mapM toConcrete+ bindToConcrete [] ret = ret []+ bindToConcrete (a:as) ret = bindToConcrete (a :| as) $ \ (c :| cs) -> ret (c:cs)++instance ToConcrete a => ToConcrete (List1 a) where+ type ConOfAbs (List1 a) = List1 (ConOfAbs a)++ toConcrete = mapM toConcrete+ -- Andreas, 2017-04-11, Issue #2543+ -- The naive `thread'ing does not work as we have to undo+ -- changes to the Precedence.+ -- bindToConcrete = thread bindToConcrete+ bindToConcrete (a :| as) ret = do+ p <- currentPrecedence -- save precedence+ bindToConcrete a $ \ c ->+ withPrecedence' p $ -- reset precedence+ bindToConcrete as $ \ cs ->+ ret (c :| cs)++instance ToConcrete a => ToConcrete (Maybe a) where+ type ConOfAbs (Maybe a) = Maybe (ConOfAbs a)+ toConcrete = traverse toConcrete+ bindToConcrete (Just x) ret = bindToConcrete x $ ret . Just+ bindToConcrete Nothing ret = ret Nothing++-- Bifunctors etc. --------------------------------------------------------++instance (ToConcrete a1, ToConcrete a2) => ToConcrete (Either a1 a2) where+ type ConOfAbs (Either a1 a2) = Either (ConOfAbs a1) (ConOfAbs a2)++ toConcrete = traverseEither toConcrete toConcrete+ bindToConcrete (Left x) ret =+ bindToConcrete x $ \x ->+ ret (Left x)+ bindToConcrete (Right y) ret =+ bindToConcrete y $ \y ->+ ret (Right y)++instance (ToConcrete a1, ToConcrete a2) => ToConcrete (a1, a2) where+ type ConOfAbs (a1, a2) = (ConOfAbs a1, ConOfAbs a2)++ toConcrete (x,y) = liftM2 (,) (toConcrete x) (toConcrete y)+ bindToConcrete (x,y) ret =+ bindToConcrete x $ \x ->+ bindToConcrete y $ \y ->+ ret (x,y)++instance (ToConcrete a1, ToConcrete a2, ToConcrete a3) => ToConcrete (a1,a2,a3) where+ type ConOfAbs (a1, a2, a3) = (ConOfAbs a1, ConOfAbs a2, ConOfAbs a3)++ toConcrete (x,y,z) = reorder <$> toConcrete (x,(y,z))+ where+ reorder (x,(y,z)) = (x,y,z)++ bindToConcrete (x,y,z) ret = bindToConcrete (x,(y,z)) $ ret . reorder+ where+ reorder (x,(y,z)) = (x,y,z)++-- Decorations ------------------------------------------------------------++instance ToConcrete a => ToConcrete (Arg a) where+ type ConOfAbs (Arg a) = Arg (ConOfAbs a)++ toConcrete (Arg i a) = Arg i <$> toConcreteHiding i a++ bindToConcrete (Arg info x) ret =+ bindToConcreteHiding info x $ ret . Arg info++instance ToConcrete a => ToConcrete (WithHiding a) where+ type ConOfAbs (WithHiding a) = WithHiding (ConOfAbs a)++ toConcrete (WithHiding h a) = WithHiding h <$> toConcreteHiding h a+ bindToConcrete (WithHiding h a) ret = bindToConcreteHiding h a $ \ a ->+ ret $ WithHiding h a++instance ToConcrete a => ToConcrete (Named name a) where+ type ConOfAbs (Named name a) = Named name (ConOfAbs a)+ toConcrete = traverse toConcrete+ bindToConcrete (Named n x) ret = bindToConcrete x $ ret . Named n++instance ToConcrete a => ToConcrete (Ranged a) where+ type ConOfAbs (Ranged a) = Ranged (ConOfAbs a)+ toConcrete = traverse toConcrete+ bindToConcrete (Ranged r x) ret = bindToConcrete x $ ret . Ranged r++-- Christian Sattler, 2017-08-05, fixing #2669+-- Both methods of ToConcrete (FieldAssignment' a) need+-- to be implemented, each in terms of the corresponding one of ToConcrete a.+-- This mirrors the instance ToConcrete (Ranged a).+-- The default implementations of ToConcrete are not valid semantically.+instance ToConcrete a => ToConcrete (FieldAssignment' a) where+ type ConOfAbs (FieldAssignment' a) = FieldAssignment' (ConOfAbs a)+ toConcrete = traverse toConcrete++ bindToConcrete (FieldAssignment name a) ret =+ bindToConcrete a $ ret . FieldAssignment name++-- Newtypes ---------------------------------------------------------------++-- Deriving this requires UndecidableInstances,+-- as TacticAttribute' is not larger than its expansion (Maybe . Ranged).+-- (Also the derived instance produce a type error.)+instance ToConcrete a => ToConcrete (TacticAttribute' a) where+ type ConOfAbs (TacticAttribute' a) = TacticAttribute' (ConOfAbs a)+ toConcrete = traverse toConcrete+ bindToConcrete (TacticAttribute a) ret = bindToConcrete a $ ret . TacticAttribute++-- Names ------------------------------------------------------------------++instance ToConcrete A.Name where+ type ConOfAbs A.Name = C.Name++ toConcrete = toConcreteName+ bindToConcrete x = bindName x++instance ToConcrete BindName where+ type ConOfAbs BindName = C.BoundName++ toConcrete = fmap C.mkBoundName_ . toConcreteName . unBind+ bindToConcrete x = bindName (unBind x) . (. C.mkBoundName_)++instance ToConcrete A.QName where+ type ConOfAbs A.QName = C.QName++ toConcrete = lookupQName AmbiguousConProjs++instance ToConcrete A.ModuleName where+ type ConOfAbs A.ModuleName = C.QName+ toConcrete = lookupModule++instance ToConcrete AbstractName where+ type ConOfAbs AbstractName = C.QName+ toConcrete = toConcrete . anameName++-- | Assumes name is not 'UnknownName'.+instance ToConcrete ResolvedName where+ type ConOfAbs ResolvedName = C.QName++ toConcrete = \case+ VarName x _ -> C.QName <$> toConcrete x+ DefinedName _ x s -> addSuffixConcrete s $ toConcrete x+ FieldName xs -> toConcrete (List1.head xs)+ ConstructorName _ xs -> toConcrete (List1.head xs)+ PatternSynResName xs -> toConcrete (List1.head xs)+ UnknownName -> __IMPOSSIBLE__++addSuffixConcrete :: HasOptions m => A.Suffix -> m C.QName -> m C.QName+addSuffixConcrete A.NoSuffix x = x+addSuffixConcrete (A.Suffix i) x = do+ glyphMode <- optUseUnicode <$> pragmaOptions+ addSuffixConcrete' glyphMode i <$> x++addSuffixConcrete' :: UnicodeOrAscii -> Integer -> C.QName -> C.QName+addSuffixConcrete' glyphMode i = set (C.lensQNameName . nameSuffix) suffix+ where+ suffix = Just $ case glyphMode of+ UnicodeOk -> Subscript $ fromInteger i+ AsciiOnly -> Index $ fromInteger i++-- Expression instance ----------------------------------------------------++class NameAspects a where+ -- | Wrap the given 'Asp.NameKind' into an 'Asp.Aspects' which+ -- contains extra information generically derived (e.g. binding site)+ -- from the name.+ nameAspects+ :: Bool -- ^ Is this an operator part?+ -> Asp.NameKind -- ^ Specific syntax-highlighting information+ -> a -- ^ The name+ -> Asp.Aspects++instance NameAspects A.Name where+ nameAspects opp nk qn = (Asp.rangeDefinitionSite (nameBindingSite qn))+ { Asp.tokenBased = Asp.NotOnlyTokenBased+ , Asp.aspect = Just (Asp.Name (Just nk) opp)+ }++instance NameAspects A.QName where+ nameAspects opp nk = nameAspects opp nk . qnameName++-- | Only adds a binding site if the name is unambiguous.+instance NameAspects A.AmbiguousQName where+ nameAspects op nk amb+ | Just q <- A.getUnambiguous amb = nameAspects op nk (qnameName q)++ nameAspects op nk amb = empty+ { Asp.tokenBased = Asp.NotOnlyTokenBased+ , Asp.aspect = Just (Asp.Name (Just nk) False)+ }++knownIdent :: NameAspects a => Asp.NameKind -> a -> C.QName -> C.Expr+knownIdent nk a c = C.KnownIdent (nameAspects False nk a) c++instance ToConcrete A.Expr where+ type ConOfAbs A.Expr = C.Expr++ toConcrete (Var x) = knownIdent Asp.Bound x . C.QName <$> toConcrete x+ toConcrete (Def' x suffix) = knownIdent Asp.Function (qnameName x) <$> addSuffixConcrete suffix (toConcrete x)+ toConcrete (Proj ProjPrefix p) = knownIdent Asp.Field p <$> toConcrete (headAmbQ p)+ toConcrete (Proj _ p) = C.Dot empty . knownIdent Asp.Field p <$> toConcrete (headAmbQ p)+ toConcrete (A.Macro x) = knownIdent Asp.Macro (qnameName x) <$> toConcrete x+ toConcrete (A.PatternSyn n) = knownIdent (Asp.Constructor Inductive) n <$> toConcrete (headAmbQ n)+ toConcrete (A.Highlighted a b) = C.Highlighted a <$> toConcrete b++ toConcrete e@(Con c) = tryToRecoverPatternSyn e $+ knownIdent (Asp.Constructor Inductive) c <$> toConcrete (headAmbQ c)++ -- for names we have to use the name from the info, since the abstract+ -- name has been resolved to a fully qualified name (except for+ -- variables)+ toConcrete e@(A.Lit i (LitQName x)) = tryToRecoverPatternSyn e $ do+ x <- lookupQName AmbiguousNothing x+ let r = getRange i+ bracket appBrackets $ return $+ C.App r (C.Quote r) (defaultNamedArg $ C.Ident x)+ toConcrete e@(A.Lit i l) = tryToRecoverPatternSyn e $ return $ C.Lit (getRange i) l++ -- Andreas, 2014-05-17 We print question marks with their+ -- interaction id, in case @metaNumber /= Nothing@+ -- Ulf, 2017-09-20 ... or @preserveIIds == True@.+ toConcrete (A.QuestionMark i ii) = do+ preserve <- asks preserveIIds+ return $ C.QuestionMark (getRange i) $+ interactionId ii <$ guard (preserve || isJust (metaNumber i))++ toConcrete (A.Underscore i) =+ C.Underscore (getRange i) <$>+ traverse (render <.> prettyTCM)+ (NamedMeta (metaNameSuggestion i) <$> metaNumber i)++ toConcrete (A.Dot i e) =+ C.Dot empty <$> toConcrete e++ toConcrete e@(A.App i e1 e2) = do+ is <- isBuiltinFun+ -- Special printing of desugared overloaded literals:+ -- fromNat 4 --> 4+ -- fromNeg 4 --> -4+ -- fromString "foo" --> "foo"+ -- Only when the corresponding conversion function is in scope and was+ -- inserted by the system.+ case (getHead e1, namedArg e2) of+ (Just (HdDef q), l@A.Lit{})+ | any (is q) [builtinFromNat, builtinFromString], visible e2,+ getOrigin i == Inserted -> toConcrete l+ (Just (HdDef q), A.Lit r (LitNat n))+ | q `is` builtinFromNeg, visible e2,+ getOrigin i == Inserted -> toConcrete (A.Lit r (LitNat (-n)))+ _ ->+ tryToRecoverPatternSyn e+ $ tryToRecoverOpApp e+ $ tryToRecoverNatural e+ -- or fallback to App+ $ bracket (appBrackets' $ preferParenless (appParens i) && isLambda e2)+ $ do e1' <- toConcreteCtx FunctionCtx e1+ e2' <- toConcreteCtx (ArgumentCtx $ appParens i) e2+ return $ C.App (getRange i) e1' e2'++ toConcrete (A.WithApp i e es) =+ bracket withAppBrackets $ do+ e <- toConcreteCtx WithFunCtx e+ es <- mapM (toConcreteCtx WithArgCtx) es+ return $ C.WithApp (getRange i) e es++ toConcrete (A.AbsurdLam i h) =+ bracket lamBrackets $ return $ C.AbsurdLam (getRange i) h+ toConcrete e@(A.Lam i _ _) =+ tryToRecoverOpApp e $ -- recover sections+ bindToConcrete (fmap makeDomainFree bs) $ \ bs' -> do+ List1.ifNull (catMaybes bs')+ {-then-} (toConcrete e')+ {-else-} $ \ bs -> bracket lamBrackets $+ C.Lam (getRange i) bs <$> toConcreteTop e'+ where+ (bs, e') = lamView e+ -- #3238 GA: We drop the hidden lambda abstractions which have+ -- been inserted by the machine rather than the user. This means+ -- that the result of lamView may actually be an empty list of+ -- binders.+ lamView :: A.Expr -> ([A.LamBinding], A.Expr)+ lamView (A.Lam _ b@(A.DomainFree _ x) e)+ | isInsertedHidden x = lamView e+ | otherwise = case lamView e of+ (bs@(A.DomainFree{} : _), e) -> (b:bs, e)+ _ -> ([b] , e)+ lamView (A.Lam _ b@(A.DomainFull A.TLet{}) e) = case lamView e of+ (bs@(A.DomainFull _ : _), e) -> (b:bs, e)+ _ -> ([b], e)+ lamView (A.Lam _ (A.DomainFull (A.TBind r t xs ty)) e) =+ case List1.filter (not . isInsertedHidden) xs of+ [] -> lamView e+ x:xs' -> let b = A.DomainFull (A.TBind r t (x :| xs') ty) in+ case lamView e of+ (bs@(A.DomainFull _ : _), e) -> (b:bs, e)+ _ -> ([b], e)+ lamView e = ([], e)+ toConcrete (A.ExtendedLam i di erased qname cs) =+ bracket lamBrackets $ do+ decls <- sconcat <$> toConcrete cs+ puns <- optHiddenArgumentPuns <$> pragmaOptions+ let -- If --hidden-argument-puns is active, then {x} is+ -- replaced by {(x)} and ⦃ x ⦄ by ⦃ (x) ⦄.+ noPun (Named Nothing p@C.IdentP{}) | puns =+ Named Nothing (C.ParenP noRange p)+ noPun p = p++ namedPat np = case getHiding np of+ NotHidden -> namedArg np+ Hidden -> C.HiddenP noRange (noPun (unArg np))+ Instance{} -> C.InstanceP noRange (noPun (unArg np))+ -- we know all lhs are of the form `.extlam p1 p2 ... pn`,+ -- with the name .extlam leftmost. It is our mission to remove it.+ let removeApp :: MonadToConcrete m => C.Pattern -> m [C.Pattern]+ removeApp (C.RawAppP _ (List2 _ p ps)) = return $ p:ps+ removeApp (C.AppP (C.IdentP _ _) np) = return [namedPat np]+ removeApp (C.AppP p np) = removeApp p <&> (++ [namedPat np])+ -- Andreas, 2018-06-18, issue #3136+ -- Empty pattern list also allowed in extended lambda,+ -- thus, we might face the unapplied .extendedlambda identifier.+ removeApp x@C.IdentP{} = return []++ removeApp p = do+ reportSLn "extendedlambda" 50 $ "abstractToConcrete removeApp p = " ++ show p+ return [p] -- __IMPOSSIBLE__+ -- Andreas, this is actually not impossible,+ -- my strictification exposed this sleeping bug+ let decl2clause (C.FunClause ai (C.LHS p [] []) rhs C.NoWhere ca) = do+ reportSLn "extendedlambda" 50 $ "abstractToConcrete extended lambda pattern p = " ++ show p+ ps <- removeApp p+ reportSLn "extendedlambda" 50 $ "abstractToConcrete extended lambda patterns ps = " ++ prettyShow ps+ return $ LamClause ps rhs ca+ decl2clause _ = __IMPOSSIBLE__+ C.ExtendedLam (getRange i) erased <$>+ mapM decl2clause decls++ toConcrete (A.Pi _ tel1 e0) = do+ let (tel, e) = piTel1 tel1 e0+ bracket piBrackets $+ bindToConcrete tel $ \ tel' ->+ C.makePi (List1.catMaybes tel') <$> toConcreteTop e+ where+ piTel1 tel e = first (List1.appendList tel) $ piTel e+ piTel (A.Pi _ tel e) = first List1.toList $ piTel1 tel e+ piTel e = ([], e)++ toConcrete (A.Generalized _ e) = C.Generalized <$> toConcrete e++ toConcrete (A.Fun i a b) =+ bracket piBrackets+ $ do a' <- toConcreteCtx ctx a+ b' <- toConcreteTop b+ -- NOTE We set relevance to Relevant in arginfo because we wrap+ -- with C.Dot or C.DoubleDot using addRel instead.+ let dom = setRelevance relevant $ setModality (getModality a') $ defaultArg $ addRel a' $ mkArg a'+ return $ C.Fun (getRange i) dom b'+ -- Andreas, 2018-06-14, issue #2513+ -- TODO: print attributes+ where+ ctx = if isRelevant a then FunctionSpaceDomainCtx else DotPatternCtx+ addRel a e =+ case getRelevance a of+ Irrelevant {} -> C.Dot empty e+ ShapeIrrelevant {} -> C.DoubleDot empty e+ Relevant {} -> e+ mkArg (Arg info e) = case getHiding info of+ Hidden -> HiddenArg (getRange e) (unnamed e)+ Instance{} -> InstanceArg (getRange e) (unnamed e)+ NotHidden -> e++ toConcrete (A.Let i ds e) =+ bracket lamBrackets+ $ bindToConcrete ds $ \ds' -> do+ e' <- toConcreteTop e+ return $ C.mkLet (getRange i) (concat ds') e'++ toConcrete (A.Rec kwr i fs) =+ bracket appBrackets $ do+ C.Rec kwr (getRange i) . map (fmap (\x -> ModuleAssignment x [] defaultImportDir)) <$> toConcreteTop fs++ toConcrete (A.RecUpdate kwr i e fs) =+ bracket appBrackets $ do+ C.RecUpdate kwr (getRange i) <$> toConcrete e <*> toConcreteTop fs++ -- Annotated 'leftovers' from the scope-checker+ toConcrete (A.ScopedExpr _ e) = toConcrete e+ toConcrete (A.Qualified _ e) = toConcrete e++ -- Reflection keywords:+ toConcrete (A.Quote i) = return $ C.Quote (getRange i)+ toConcrete (A.QuoteTerm i) = return $ C.QuoteTerm (getRange i)+ toConcrete (A.Unquote i) = return $ C.Unquote (getRange i)++ -- Andreas, 2012-04-02: TODO! print DontCare as irrAxiom+ -- Andreas, 2010-10-05 print irrelevant things as ordinary things+ toConcrete (A.DontCare e) = C.Dot empty . C.Paren r <$> toConcrete e+ where r = getRange e++makeDomainFree :: A.LamBinding -> A.LamBinding+makeDomainFree b@(A.DomainFull (A.TBind _ tac (x :| []) t)) =+ case unScope t of+ A.Underscore A.MetaInfo{metaNumber = Nothing} ->+ A.DomainFree (tbTacticAttr tac) x+ _ -> b+makeDomainFree b = b+++-- Binder instances -------------------------------------------------------++-- If there is no label we set it to the bound name, to make renaming the bound+-- name safe.+forceNameIfHidden :: NamedArg A.Binder -> NamedArg A.Binder+forceNameIfHidden x+ | isJust $ getNameOf x = x+ | visible x = x+ | otherwise = setNameOf (Just name) x+ where+ name = WithOrigin Inserted+ $ Ranged (getRange x)+ $ C.nameToRawName $ nameConcrete+ $ unBind $ A.binderName $ namedArg x++instance ToConcrete a => ToConcrete (A.Binder' a) where+ type ConOfAbs (A.Binder' a) = C.Binder' (ConOfAbs a)++ bindToConcrete (A.Binder p o a) ret =+ bindToConcrete a $ \ a ->+ bindToConcrete p $ \ p ->+ ret $ C.Binder p o a++instance ToConcrete A.LamBinding where+ type ConOfAbs A.LamBinding = Maybe C.LamBinding++ bindToConcrete (A.DomainFree t x) ret = do+ t <- traverse toConcrete t+ let setTac x = x { bnameTactic = t }+ bindToConcrete (forceNameIfHidden x) $+ ret . Just . C.DomainFree . updateNamedArg (fmap setTac)+ bindToConcrete (A.DomainFull b) ret = bindToConcrete b $ ret . fmap C.DomainFull++instance ToConcrete A.TypedBinding where+ type ConOfAbs A.TypedBinding = Maybe C.TypedBinding++ bindToConcrete (A.TBind r t xs e) ret = do+ tac <- traverse toConcrete (tbTacticAttr t)+ bindToConcrete (fmap forceNameIfHidden xs) $ \ xs -> do+ e <- toConcreteTop e+ let setTac x = x { bnameTactic = tac , C.bnameIsFinite = tbFinite t }+ ret $ Just $ C.TBind r (fmap (updateNamedArg (fmap setTac)) xs) e+ bindToConcrete (A.TLet r lbs) ret =+ bindToConcrete lbs $ \ ds -> do+ ret $ C.mkTLet r $ concat ds++instance ToConcrete A.LetBinding where+ type ConOfAbs A.LetBinding = [C.Declaration]++ bindToConcrete (A.LetBind i info x t e) ret =+ bindToConcrete x \ x -> do+ let+ keep C.Underscore{} = False+ keep _ = True+ toConcrete (t, A.RHS e Nothing) >>= \case+ (t, (e, [], [], [])) ->+ ret $ addInstanceB (if isInstance info then Just empty else Nothing) $+ [ C.TypeSig info empty (C.boundName x) t | keep t ] <>+ [ C.FunClause info+ (C.LHS (C.IdentP True $ C.QName $ C.boundName x) [] [])+ e C.NoWhere empty+ ]+ _ -> __IMPOSSIBLE__+ bindToConcrete (A.LetAxiom i info x t) ret = bindToConcrete x \x -> do+ t <- toConcrete t+ ret $ addInstanceB (if isInstance info then Just empty else Nothing) $+ [ C.TypeSig info empty (C.boundName x) t ]+ -- TODO: bind variables+ bindToConcrete (LetPatBind i ai p e) ret = do+ p <- toConcrete p+ e <- toConcrete e+ ret [ C.FunClause ai (C.LHS p [] []) (C.RHS e) NoWhere empty ]+ bindToConcrete (LetApply i erased x modapp _ _) ret = do+ x' <- unqualify <$> toConcrete x+ modapp <- toConcrete modapp+ let r = getRange modapp+ open = minfoOpenShort i+ dir = fromMaybe defaultImportDir{ importDirRange = r } $ minfoDirective i+ -- This is no use since toAbstract LetDefs is in localToAbstract.+ local (openModule' x dir id) $+ ret [ C.ModuleMacro (getRange i) erased x' modapp open dir ]+ bindToConcrete (LetOpen i x _) ret = do+ x' <- toConcrete x+ let dir = fromMaybe defaultImportDir $ minfoDirective i+ local (openModule' x dir restrictPrivate) $+ ret [ C.Open (kwRange i) x' dir ]+ -- Andreas, 2025-11-27, kwRange is a lie,+ -- but we do not have the range of the @open@ keyword here.++instance ToConcrete A.WhereDeclarations where+ type ConOfAbs A.WhereDeclarations = WhereClause++ bindToConcrete (A.WhereDecls _ _ Nothing) ret = ret C.NoWhere+ bindToConcrete (A.WhereDecls (Just am) False+ (Just (A.Section _ erased _ _ ds)))+ ret = do+ ds' <- declsToConcrete ds+ cm <- unqualify <$> lookupModule am+ -- Andreas, 2016-07-08 I put PublicAccess in the following SomeWhere+ -- Should not really matter for printing...+ let wh' = if isNoName cm && not (isErased erased)+ then AnyWhere noRange ds'+ else SomeWhere noRange erased cm PublicAccess ds'+ local (openModule' am defaultImportDir id) $ ret wh'+ bindToConcrete (A.WhereDecls _ _ (Just d)) ret =+ ret . AnyWhere noRange =<< toConcrete d++mergeSigAndDef :: [C.Declaration] -> [C.Declaration]+mergeSigAndDef (C.RecordSig _ er x bs e : C.RecordDef r y dir _ fs : ds)+ | x == y = C.Record r er y dir bs e fs : mergeSigAndDef ds+mergeSigAndDef (C.DataSig _ er x bs e : C.DataDef r y _ cs : ds)+ | x == y = C.Data r er y bs e cs : mergeSigAndDef ds+mergeSigAndDef (d : ds) = d : mergeSigAndDef ds+mergeSigAndDef [] = []++openModule' :: A.ModuleName -> C.ImportDirective -> (Scope -> Scope) -> Env -> Env+openModule' x dir restrict env = env{currentScope = set scopeModules mods' sInfo}+ where sInfo = currentScope env+ amod = sInfo ^. scopeCurrent+ mods = sInfo ^. scopeModules+ news = setScopeAccess PrivateNS+ $ applyImportDirective dir+ $ maybe emptyScope restrict+ $ Map.lookup x mods+ mods' = Map.update (Just . (`mergeScope` news)) amod mods+++-- Declaration instances --------------------------------------------------++declsToConcrete :: MonadToConcrete m => [A.Declaration] -> m [C.Declaration]+declsToConcrete ds = mergeSigAndDef . concat <$> toConcrete ds++instance ToConcrete A.RHS where+ type ConOfAbs A.RHS = (C.RHS, [C.RewriteEqn], [C.WithExpr], [C.Declaration])++ toConcrete (A.RHS e (Just c)) = return (C.RHS c, [], [], [])+ toConcrete (A.RHS e Nothing) = do+ e <- toConcrete e+ return (C.RHS e, [], [], [])+ toConcrete A.AbsurdRHS = return (C.AbsurdRHS, [], [], [])+ toConcrete (A.WithRHS _ es cs) = do+ es <- do es <- toConcrete es+ forM es $ \ (Named n e) -> do+ n <- traverse toConcrete n+ pure $ Named (C.boundName <$> n) e+ cs <- noTakenNames $ sconcat <$> toConcrete cs+ return (C.AbsurdRHS, [], List1.toList es, List1.toList cs)+ toConcrete (A.RewriteRHS xeqs _spats rhs wh) = do+ wh <- maybe (return []) toConcrete $ A.whereDecls wh+ (rhs, eqs', es, whs) <- toConcrete rhs+ unless (null eqs') __IMPOSSIBLE__+ eqs <- toConcrete xeqs+ return (rhs, eqs, es, wh ++ whs)++instance (ToConcrete p, ToConcrete a) => ToConcrete (RewriteEqn' qn A.BindName p a) where+ type ConOfAbs (RewriteEqn' qn A.BindName p a) = (RewriteEqn' () C.Name (ConOfAbs p) (ConOfAbs a))++ toConcrete = \case+ Rewrite es -> Rewrite <$> mapM (toConcrete . (\ (_, e) -> ((),e))) es+ Invert qn pes -> fmap (Invert ()) $ forM pes $ \ (Named n pe) -> do+ pe <- toConcrete pe+ n <- fmap C.boundName <$> toConcrete n+ pure $ Named n pe+ LeftLet pes -> LeftLet <$> mapM toConcrete pes++instance ToConcrete (Constr A.Constructor) where+ type ConOfAbs (Constr A.Constructor) = C.Declaration++ toConcrete (Constr (A.ScopedDecl scope (d :| []))) =+ withScope scope $ toConcrete (Constr d)+ toConcrete (Constr (A.Axiom _ i info Nothing x t)) = do+ x' <- unsafeQNameToName <$> toConcrete x+ t' <- toConcreteTop t+ return $ C.TypeSig info empty x' t'+ toConcrete (Constr (A.Axiom _ _ _ (Just _) _ _)) = __IMPOSSIBLE__+ toConcrete (Constr d) = headWithDefault __IMPOSSIBLE__ <$> toConcrete d++instance (ToConcrete a, ConOfAbs a ~ C.LHS) => ToConcrete (A.Clause' a) where+ type ConOfAbs (A.Clause' a) = List1 C.Declaration++ toConcrete (A.Clause lhs _ rhs wh catchall) =+ bindToConcrete lhs $ \case+ C.LHS p _ _ -> do+ bindToConcrete wh $ \ wh' -> do+ (rhs', eqs, with, wcs) <- toConcreteTop rhs+ return $ FunClause defaultArgInfo (C.LHS p eqs with) rhs' wh' catchall :| wcs++instance ToConcrete A.ModuleApplication where+ type ConOfAbs A.ModuleApplication = C.ModuleApplication++ toConcrete (A.SectionApp tel y es) = do+ y <- toConcreteCtx FunctionCtx y+ bindToConcrete tel $ \ tel -> do+ es <- toConcreteCtx argumentCtx_ es+ let r = fuseRange y es+ return $ C.SectionApp r (catMaybes tel) y $ map unNamedArg es++ toConcrete (A.RecordModuleInstance recm) = do+ recm <- toConcrete recm+ return $ C.RecordModuleInstance (getRange recm) recm++instance ToConcrete A.RecordDirectives where+ type ConOfAbs A.RecordDirectives = [C.RecordDirective]++ toConcrete dir = C.ungatherRecordDirectives <$> traverse f dir+ where+ f :: MonadToConcrete m => RecordConName -> m (Maybe (C.Name, IsInstance))+ f (FreshRecCon _) = pure Nothing+ f (NamedRecCon nm) = Just . (, NotInstanceDef) . C.unqualify <$> toConcrete nm+++instance ToConcrete A.Declaration where+ type ConOfAbs A.Declaration = [C.Declaration]++ toConcrete (ScopedDecl scope ds) =+ withScope scope $ declsToConcrete $ List1.toList ds++ toConcrete (A.Axiom _ i info mp x t) = do+ x' <- unsafeQNameToName <$> toConcrete x+ withAbstractPrivate i $+ withInfixDecl i x' $ do+ t' <- toConcreteTop t+ return $+ (case mp of+ Nothing -> []+ Just occs -> [C.Pragma (PolarityPragma noRange x' $ List1.toList occs)]) +++ [C.Postulate empty [C.TypeSig info empty x' t']]++ toConcrete (A.Generalize s i j x t) = do+ x' <- unsafeQNameToName <$> toConcrete x+ tac <- toConcrete (defTactic i)+ withAbstractPrivate i $+ withInfixDecl i x' $ do+ t' <- toConcreteTop t+ return [C.Generalize empty [C.TypeSig j tac x' $ C.Generalized t']]++ toConcrete (A.Field i x t) = do+ x' <- unsafeQNameToName <$> toConcrete x+ tac <- toConcrete (defTactic i)+ withAbstractPrivate i $+ withInfixDecl i x' $ do+ t' <- toConcreteTop t+ return [C.FieldSig (A.defInstance i) tac x' t']++ toConcrete (A.Primitive i x t) = do+ x' <- unsafeQNameToName <$> toConcrete x+ withAbstractPrivate i $+ withInfixDecl i x' $ do+ t' <- traverse toConcreteTop t+ return [C.Primitive empty [C.TypeSig (argInfo t') empty x' (unArg t')]]+ -- Primitives are always relevant.++ toConcrete (A.FunDef i _ cs) =+ withAbstractPrivate i $ List1.toList . sconcat <$> toConcrete cs++ toConcrete (A.DataSig i erased x bs t) =+ withAbstractPrivate i $+ bindToConcrete (A.generalizeTel bs) $ \ tel' -> do+ x' <- unsafeQNameToName <$> toConcrete x+ t' <- toConcreteTop t+ return [ C.DataSig (getRange i) erased x'+ (map C.DomainFull $ catMaybes tel') t' ]++ toConcrete (A.DataDef i x _pc _uc bs cs) =+ withAbstractPrivate i $+ bindToConcrete (map makeDomainFree $ dataDefParams bs) $ \ tel' -> do+ (x',cs') <- first unsafeQNameToName <$> toConcrete (x, map Constr cs)+ return [ C.DataDef (getRange i) x' (catMaybes tel') cs' ]++ toConcrete (A.RecSig i erased x bs t) =+ withAbstractPrivate i $+ bindToConcrete (A.generalizeTel bs) $ \ tel' -> do+ x' <- unsafeQNameToName <$> toConcrete x+ t' <- toConcreteTop t+ return [ C.RecordSig (getRange i) erased x'+ (map C.DomainFull $ catMaybes tel') t' ]++ toConcrete (A.RecDef i x _pc _uc _eta dir bs t cs) =+ withAbstractPrivate i $+ bindToConcrete (map makeDomainFree $ dataDefParams bs) $ \ tel' -> do+ dirs <- toConcrete dir+ (x',cs') <- first unsafeQNameToName <$> toConcrete (x, map Constr cs)+ return [ C.RecordDef (getRange i) x' dirs (catMaybes tel') cs' ]++ toConcrete (A.Mutual i ds) = pure . C.Mutual empty <$> declsToConcrete (List1.toList ds)++ toConcrete (A.Section i erased x (A.GeneralizeTel _ tel) ds) = do+ x <- toConcrete x+ bindToConcrete tel $ \ tel -> do+ ds <- declsToConcrete ds+ return [ C.Module (getRange i) erased x (catMaybes tel) ds ]++ toConcrete (A.Apply i erased x modapp _ _) = do+ x <- unsafeQNameToName <$> toConcrete x+ modapp <- toConcrete modapp+ let r = getRange modapp+ open = minfoOpenShort i+ dir = fromMaybe defaultImportDir{ importDirRange = r } $ minfoDirective i+ return [ C.ModuleMacro (getRange i) erased x modapp open dir ]++ toConcrete (A.Import i x _) = do+ x <- toConcrete x+ let open = minfoOpenShort i+ dir = fromMaybe defaultImportDir $ minfoDirective i+ return [ C.Import open (kwRange i) x empty dir]++ toConcrete (A.Pragma i p) = do+ p <- toConcrete $ RangeAndPragma (getRange i) p+ return [C.Pragma p]++ toConcrete (A.Open i x _) = do+ x <- toConcrete x+ return [C.Open (kwRange i) x defaultImportDir]+ -- Andreas, 2025-11-27, kwRange is a lie,+ -- but we do not have the range of the @open@ keyword here.++ toConcrete (A.PatternSynDef x xs p) = toConcrete x >>= \case+ C.QName x -> bindToConcrete (map (fmap A.unBind) xs) \ xs ->+ singleton . C.PatternSyn (getRange x) x xs <$> do+ dontFoldPatternSynonyms $ toConcrete (vacuous p :: A.Pattern)+ _ -> __IMPOSSIBLE__++ toConcrete (A.UnquoteDecl _ i xs e) = do+ let unqual (C.QName x) = return x+ unqual _ = __IMPOSSIBLE__+ xs <- mapM (unqual <=< toConcrete) xs+ (:[]) . C.UnquoteDecl (getRange i) xs <$> toConcrete e++ toConcrete (A.UnquoteDef i xs e) = do+ let unqual (C.QName x) = return x+ unqual _ = __IMPOSSIBLE__+ xs <- mapM (unqual <=< toConcrete) xs+ (:[]) . C.UnquoteDef (getRange i) xs <$> toConcrete e++ toConcrete (A.UnquoteData i xs uc j cs e) = __IMPOSSIBLE__+ toConcrete (A.UnfoldingDecl r ns) = pure []++data RangeAndPragma = RangeAndPragma Range A.Pragma++instance ToConcrete RangeAndPragma where+ type ConOfAbs RangeAndPragma = C.Pragma++ toConcrete (RangeAndPragma r p) = case p of+ A.OptionsPragma xs -> return $ C.OptionsPragma r xs+ A.BuiltinPragma b x -> C.BuiltinPragma r b <$> toConcrete x+ A.BuiltinNoDefPragma b _kind x -> C.BuiltinPragma r b <$> toConcrete x+ A.RewritePragma r' x -> C.RewritePragma r r' <$> toConcrete x+ A.CompilePragma b x s -> do+ x <- toConcrete x+ return $ C.CompilePragma r b x s+ A.ForeignPragma b s -> return $ C.ForeignPragma r b s+ A.StaticPragma x -> C.StaticPragma r <$> toConcrete x+ A.InjectivePragma x -> C.InjectivePragma r <$> toConcrete x+ A.InjectiveForInferencePragma x -> C.InjectiveForInferencePragma r <$> toConcrete x+ A.InlinePragma b x -> C.InlinePragma r b <$> toConcrete x+ A.NotProjectionLikePragma q -> C.NotProjectionLikePragma r <$> toConcrete q+ A.OverlapPragma q i -> C.OverlapPragma r <$> (fmap pure (toConcrete q)) <*> pure i+ A.DisplayPragma f ps rhs ->+ C.DisplayPragma r <$> toConcrete (A.DefP (PatRange noRange) (unambiguous f) ps) <*> toConcrete rhs++-- Left hand sides --------------------------------------------------------++instance ToConcrete A.SpineLHS where+ type ConOfAbs A.SpineLHS = C.LHS++ bindToConcrete lhs = bindToConcrete (A.spineToLhs lhs :: A.LHS)++instance ToConcrete A.LHS where+ type ConOfAbs A.LHS = C.LHS++ bindToConcrete (A.LHS i lhscore) ret = do+ bindToConcreteCtx TopCtx lhscore $ \ lhs ->+ ret $ C.LHS (reintroduceEllipsis (lhsEllipsis i) lhs) [] []++instance ToConcrete A.LHSCore where+ type ConOfAbs A.LHSCore = C.Pattern+ bindToConcrete = bindToConcrete . lhsCoreToPattern++appBracketsArgs :: [arg] -> PrecedenceStack -> Bool+appBracketsArgs [] _ = False+appBracketsArgs (_:_) ctx = appBrackets ctx++-- Auxiliary wrappers for processing the bindings in patterns in the right order.+newtype UserPattern a = UserPattern a+newtype SplitPattern a = SplitPattern a+newtype BindingPattern = BindingPat A.Pattern+newtype FreshenName = FreshenName BindName++instance ToConcrete FreshenName where+ type ConOfAbs FreshenName = A.Name+ bindToConcrete (FreshenName BindName{ unBind = x }) ret = bindToConcrete x $ \ y -> ret x { nameConcrete = y }++-- Pass 1: (Issue #2729)+-- Takes care of binding the originally user-written pattern variables, but doesn't actually+-- translate anything to Concrete.+instance ToConcrete (UserPattern A.Pattern) where+ type ConOfAbs (UserPattern A.Pattern) = A.Pattern++ bindToConcrete (UserPattern p) ret = do+ reportSLn "toConcrete.pat" 100 $ "binding pattern (pass 1)" ++ show p+ case p of+ A.VarP bx -> do+ let x = unBind bx+ case isInScope x of+ InScope -> bindName' x $ ret $ A.VarP bx+ C.NotInScope -> bindName x $ \y ->+ ret $ A.VarP $ mkBindName $ x { nameConcrete = y }+ A.WildP{} -> ret p+ A.ProjP{} -> ret p+ A.AbsurdP{} -> ret p+ A.LitP{} -> ret p+ A.DotP{} -> ret p+ A.EqualP{} -> ret p+ -- Andreas, 2017-09-03, issue #2729:+ -- Do not go into patterns generated by case-split here!+ -- They are treated in a second pass.+ A.ConP i c args+ | conPatOrigin i == ConOSplit -> ret p+ | otherwise -> bindToConcrete (map UserPattern args) $ ret . A.ConP i c+ A.DefP i f args -> bindToConcrete (map UserPattern args) $ ret . A.DefP i f+ A.PatternSynP i f args -> bindToConcrete (map UserPattern args) $ ret . A.PatternSynP i f+ A.RecP kwr i args+ | conPatOrigin i == ConOSplit -> ret p+ | otherwise -> bindToConcrete ((map . fmap) UserPattern args) $ ret . A.RecP kwr i+ A.AsP i x p -> bindName' (unBind x) $+ bindToConcrete (UserPattern p) $ \ p ->+ ret (A.AsP i x p)+ A.WithP i p -> bindToConcrete (UserPattern p) $ ret . A.WithP i++instance ToConcrete (UserPattern (NamedArg A.Pattern)) where+ type ConOfAbs (UserPattern (NamedArg A.Pattern)) = NamedArg A.Pattern++ bindToConcrete (UserPattern np) ret =+ case getOrigin np of+ CaseSplit -> ret np+ _ -> bindToConcrete (fmap (fmap UserPattern) np) ret++-- Pass 2a: locate case-split pattern. Don't bind anything!+instance ToConcrete (SplitPattern A.Pattern) where+ type ConOfAbs (SplitPattern A.Pattern) = A.Pattern++ bindToConcrete (SplitPattern p) ret = do+ reportSLn "toConcrete.pat" 100 $ "binding pattern (pass 2a)" ++ show p+ case p of+ A.VarP x -> ret p+ A.WildP{} -> ret p+ A.ProjP{} -> ret p+ A.AbsurdP{} -> ret p+ A.LitP{} -> ret p+ A.DotP{} -> ret p+ A.EqualP{} -> ret p+ -- Andreas, 2017-09-03, issue #2729:+ -- For patterns generated by case-split here, switch to freshening & binding.+ A.ConP i c args+ | conPatOrigin i == ConOSplit+ -> bindToConcrete ((map . fmap . fmap) BindingPat args) $ ret . A.ConP i c+ | otherwise -> bindToConcrete (map SplitPattern args) $ ret . A.ConP i c+ A.DefP i f args -> bindToConcrete (map SplitPattern args) $ ret . A.DefP i f+ A.PatternSynP i f args -> bindToConcrete (map SplitPattern args) $ ret . A.PatternSynP i f+ A.RecP kwr i args+ | conPatOrigin i == ConOSplit+ -> bindToConcrete ((map . fmap) BindingPat args) $ ret . A.RecP kwr i+ | otherwise -> bindToConcrete ((map . fmap) SplitPattern args) $ ret . A.RecP kwr i+ A.AsP i x p -> bindToConcrete (SplitPattern p) $ \ p ->+ ret (A.AsP i x p)+ A.WithP i p -> bindToConcrete (SplitPattern p) $ ret . A.WithP i++instance ToConcrete (SplitPattern (NamedArg A.Pattern)) where+ type ConOfAbs (SplitPattern (NamedArg A.Pattern)) = NamedArg A.Pattern+ bindToConcrete (SplitPattern np) ret =+ case getOrigin np of+ CaseSplit -> bindToConcrete (fmap (fmap BindingPat ) np) ret+ _ -> bindToConcrete (fmap (fmap SplitPattern) np) ret+++-- Pass 2b:+-- Takes care of freshening and binding pattern variables introduced by case split.+-- Still does not translate anything to Concrete.+instance ToConcrete BindingPattern where+ type ConOfAbs BindingPattern = A.Pattern+ bindToConcrete (BindingPat p) ret = do+ reportSLn "toConcrete.pat" 100 $ "binding pattern (pass 2b)" ++ show p+ case p of+ A.VarP x -> bindToConcrete (FreshenName x) $ ret . A.VarP . mkBindName+ A.WildP{} -> ret p+ A.ProjP{} -> ret p+ A.AbsurdP{} -> ret p+ A.LitP{} -> ret p+ A.DotP{} -> ret p+ A.EqualP{} -> ret p+ A.ConP i c args -> bindToConcrete (map (updateNamedArg BindingPat) args) $ ret . A.ConP i c+ A.DefP i f args -> bindToConcrete (map (updateNamedArg BindingPat) args) $ ret . A.DefP i f+ A.PatternSynP i f args -> bindToConcrete (map (updateNamedArg BindingPat) args) $ ret . A.PatternSynP i f+ A.RecP kwr i args -> bindToConcrete ((map . fmap) BindingPat args) $ ret . A.RecP kwr i+ A.AsP i x p -> bindToConcrete (FreshenName x) $ \ x ->+ bindToConcrete (BindingPat p) $ \ p ->+ ret (A.AsP i (mkBindName x) p)+ A.WithP i p -> bindToConcrete (BindingPat p) $ ret . A.WithP i++instance ToConcrete A.Pattern where+ type ConOfAbs A.Pattern = C.Pattern++ bindToConcrete p ret = do+ prec <- currentPrecedence+ bindToConcrete (UserPattern p) $ \ p -> do+ bindToConcrete (SplitPattern p) $ \ p -> do+ ret =<< do withPrecedence' prec $ toConcrete p+ toConcrete p =+ case p of+ A.VarP x ->+ C.IdentP True . C.QName . C.boundName <$> toConcrete x++ A.WildP i ->+ return $ C.WildP (getRange i)++ A.ConP i c args -> tryOp (headAmbQ c) (A.ConP i c) args++ A.ProjP i ProjPrefix p -> C.IdentP True <$> toConcrete (headAmbQ p)+ A.ProjP i _ p -> C.DotP empty noRange CouldBeProjectionPattern . C.Ident <$> toConcrete (headAmbQ p)++ A.DefP i x args -> tryOp (headAmbQ x) (A.DefP i x) args++ A.AsP i x p -> do+ (x, p) <- toConcreteCtx argumentCtx_ (x, p)+ return $ C.AsP (getRange i) (C.boundName x) p++ A.AbsurdP i ->+ return $ C.AbsurdP (getRange i)++ A.LitP i (LitQName x) -> do+ x <- lookupQName AmbiguousNothing x+ bracketP_ appBrackets $ return $+ C.AppP (C.QuoteP (getRange i))+ (defaultNamedArg (C.IdentP True x))+ A.LitP i l ->+ return $ C.LitP (getRange i) l++ -- Andreas, 2018-06-19, issue #3130+ -- Print .p as .(p) if p is a projection+ -- to avoid confusion with projection pattern.+ A.DotP i e@A.Proj{} -> C.DotP empty r CannotBeProjectionPattern . C.Paren r <$> toConcreteCtx TopCtx e+ where r = getRange i++ -- gallais, 2019-02-12, issue #3491+ -- Print .p as .(p) if p is a variable but there is a projection of the+ -- same name in scope.+ A.DotP i e@(A.Var v) -> do+ let r = getRange i+ -- Erase @v@ to a concrete name and resolve it back to check whether+ -- we have a conflicting field name.+ cn <- toConcreteName v+ resolveName (someKindsOfNames [FldName]) Nothing (C.QName cn) >>= \ case+ -- If we do then we print .(v) rather than .v+ Right FieldName{} -> do+ reportSLn "print.dotted" 50 $ "Wrapping ambiguous name " ++ prettyShow (nameConcrete v)+ C.DotP empty r CannotBeProjectionPattern . C.Paren r <$> toConcrete (A.Var v)+ Right _ -> printDotDefault i e+ Left _ -> __IMPOSSIBLE__++ A.DotP i e -> printDotDefault i e++ A.EqualP i es -> do+ C.EqualP (getRange i) <$> toConcrete es++ A.PatternSynP i n args -> tryOp (headAmbQ n) (A.PatternSynP i n) args++ A.RecP kwr i as ->+ C.RecP kwr (getRange i) <$> mapM (traverse toConcrete) as++ A.WithP i p -> C.WithP (getRange i) <$> toConcreteCtx WithArgCtx p++ where++ printDotDefault :: MonadToConcrete m => PatInfo -> A.Expr -> m C.Pattern+ printDotDefault i e = do+ c <- toConcreteCtx DotPatternCtx e+ let r = getRange i+ case c of+ -- Andreas, 2016-02-04 print ._ pattern as _ pattern,+ -- following the fusing of WildP and ImplicitP.+ C.Underscore{} -> return $ C.WildP r+ _ -> return $ C.DotP empty r CannotBeProjectionPattern c++ tryOp :: MonadToConcrete m => A.QName -> (A.Patterns -> A.Pattern) -> A.Patterns -> m C.Pattern+ tryOp x f args = do+ -- Andreas, 2016-02-04, Issue #1792+ -- To prevent failing of tryToRecoverOpAppP for overapplied operators,+ -- we take off the exceeding arguments first+ -- and apply them pointwise with C.AppP later.+ let (args1, args2) = splitAt (numHoles x) args+ let funCtx = applyUnless (null args2) (withPrecedence FunctionCtx)+ tryToRecoverPatternSynP (f args) $ funCtx (tryToRecoverOpAppP $ f args1) >>= \case+ Just c -> applyTo args2 c+ Nothing -> applyTo args . C.IdentP True =<< toConcrete x+ -- Note: applyTo [] c = return c+ applyTo args c = bracketP_ (appBracketsArgs args) $ do+ foldl C.AppP c <$>+ (mapM avoidPun =<< toConcreteCtx argumentCtx_ args)++ -- If --hidden-argument-puns is active, then {x} is replaced by+ -- {(x)} and ⦃ x ⦄ by ⦃ (x) ⦄.+ avoidPun :: MonadToConcrete m => NamedArg C.Pattern -> m (NamedArg C.Pattern)+ avoidPun arg =+ ifM (optHiddenArgumentPuns <$> pragmaOptions)+ (return $ case arg of+ Arg i (Named Nothing x@C.IdentP{}) | notVisible i ->+ Arg i (Named Nothing (C.ParenP noRange x))+ arg -> arg)+ (return arg)++-- Helpers for recovering natural number literals++tryToRecoverNatural :: MonadToConcrete m => A.Expr -> m C.Expr -> m C.Expr+tryToRecoverNatural e def = do+ is <- isBuiltinFun+ caseMaybe (recoverNatural is e) def $ return . C.Lit noRange . LitNat++recoverNatural :: (A.QName -> BuiltinId -> Bool) -> A.Expr -> Maybe Integer+recoverNatural is e = explore (`is` builtinZero) (`is` builtinSuc) 0 e+ where+ explore :: (A.QName -> Bool) -> (A.QName -> Bool) -> Integer -> A.Expr -> Maybe Integer+ explore isZero isSuc k (A.App _ (A.Con c) t) | Just f <- getUnambiguous c, isSuc f+ = (explore isZero isSuc $! k + 1) (namedArg t)+ explore isZero isSuc k (A.Con c) | Just x <- getUnambiguous c, isZero x = Just k+ explore isZero isSuc k (A.Lit _ (LitNat l)) = Just (k + l)+ explore _ _ _ _ = Nothing++-- Helpers for recovering C.OpApp ------------------------------------------++data Hd = HdVar A.Name | HdCon A.QName | HdDef A.QName | HdSyn A.QName++data MaybeSection a+ = YesSection+ | NoSection a+ deriving (Eq, Show, Functor, Foldable, Traversable)++fromNoSection :: a -> MaybeSection a -> a+fromNoSection fallback = \case+ YesSection -> fallback+ NoSection x -> x++instance HasRange a => HasRange (MaybeSection a) where+ getRange = \case+ YesSection -> noRange+ NoSection a -> getRange a++getHead :: A.Expr -> Maybe Hd+getHead (Var x) = Just (HdVar x)+getHead (Def f) = Just (HdDef f)+getHead (Proj o f) = Just (HdDef $ headAmbQ f)+getHead (Con c) = Just (HdCon $ headAmbQ c)+getHead (A.PatternSyn n) = Just (HdSyn $ headAmbQ n)+getHead _ = Nothing++cOpApp :: Asp.Aspects -> Range -> C.QName -> A.Name -> List1 (MaybeSection C.Expr) -> C.Expr+cOpApp nk r x n es =+ C.KnownOpApp nk r x (singleton n) $+ fmap (defaultNamedArg . placeholder) $+ List1.zip es positions+ where+ x0 = C.unqualify x+ positions | isPrefix x0 = (const Middle <$> List1.drop 1 es) `List1.snoc` End+ | isPostfix x0 = Beginning :| (const Middle <$> List1.drop 1 es)+ | isInfix x0 = Beginning :| (const Middle <$> List1.drop 2 es) ++ [ End ]+ | otherwise = const Middle <$> es+ placeholder (YesSection , pos ) = Placeholder pos+ placeholder (NoSection e, _pos) = noPlaceholder (Ordinary e)++tryToRecoverOpApp :: MonadToConcrete m => A.Expr -> m C.Expr -> m C.Expr+tryToRecoverOpApp e def = fromMaybeM def $+ recoverOpApp bracket (isLambda . defaultNamedArg) cOpApp view e+ where+ view :: A.Expr -> Maybe (Hd, [NamedArg (MaybeSection (AppInfo, A.Expr))])+ view e+ -- Do we have a series of inserted lambdas?+ | Just xs@(_:_) <- traverse insertedName bs =+ (,) <$> getHead hd <*> sectionArgs (map (unBind . A.binderName) xs) args+ where+ LamView bs body = A.lamView e+ Application hd args = A.appView' body++ -- Only inserted domain-free visible lambdas come from sections.+ insertedName (A.DomainFree _ x)+ | getOrigin x == Inserted && visible x = Just $ namedArg x+ insertedName _ = Nothing++ -- Build section arguments. Need to check that:+ -- lambda bound variables appear in the right order and only as+ -- top-level arguments.+ sectionArgs :: [A.Name] -> [NamedArg (AppInfo, A.Expr)] -> Maybe [NamedArg (MaybeSection (AppInfo, A.Expr))]+ sectionArgs xs = go xs+ where+ noXs = getAll . foldExpr (\ case A.Var x -> All (x `notElem` xs)+ _ -> All True) . snd . namedArg+ go [] [] = return []+ go (y : ys) (arg : args)+ | visible arg+ , A.Var y' <- snd $ namedArg arg+ , y == y' = (fmap (YesSection <$) arg :) <$> go ys args+ go ys (arg : args)+ | visible arg, noXs arg = ((fmap . fmap) NoSection arg :) <$> go ys args+ go _ _ = Nothing++ view e = (, (map . fmap . fmap) NoSection args) <$> getHead hd+ where Application hd args = A.appView' e++tryToRecoverOpAppP :: MonadToConcrete m => A.Pattern -> m (Maybe C.Pattern)+tryToRecoverOpAppP p = do+ res <- recoverOpApp bracketP_ (const False) (const opApp) view p+ reportS "print.op" 90+ [ "tryToRecoverOpApp"+ , "in: " ++ show p+ , "out: " ++ show res+ ]+ return res+ where+ opApp r x n ps = C.OpAppP r x (singleton n) $+ fmap (defaultNamedArg . fromNoSection __IMPOSSIBLE__) $+ -- `view` does not generate any `Nothing`s+ ps++ appInfo = defaultAppInfo_++ view :: A.Pattern -> Maybe (Hd, [NamedArg (MaybeSection (AppInfo, A.Pattern))])+ view = \case+ ConP _ cs ps -> Just (HdCon (headAmbQ cs), (map . fmap . fmap) (NoSection . (appInfo,)) ps)+ DefP _ fs ps -> Just (HdDef (headAmbQ fs), (map . fmap . fmap) (NoSection . (appInfo,)) ps)+ PatternSynP _ ns ps -> Just (HdSyn (headAmbQ ns), (map . fmap . fmap) (NoSection . (appInfo,)) ps)+ _ -> Nothing+ -- ProjP _ _ d -> Just (HdDef (headAmbQ d), []) -- ? Andreas, 2016-04-21++recoverOpApp :: forall a c m. (ToConcrete a, c ~ ConOfAbs a, HasRange c, MonadToConcrete m)+ => ((PrecedenceStack -> Bool) -> m c -> m c)+ -> (a -> Bool) -- ^ Check for lambdas+ -> (Asp.Aspects -> Range -> C.QName -> A.Name -> List1 (MaybeSection c) -> c) -- ^ @opApp@+ -> (a -> Maybe (Hd, [NamedArg (MaybeSection (AppInfo, a))]))+ -> a+ -> m (Maybe c)+recoverOpApp bracket isLam opApp view e = case view e of+ Nothing -> mDefault+ Just (hd, args)+ | all visible args -> do+ let args' = map namedArg args+ case hd of+ HdVar n+ | isNoName n -> mDefault+ | otherwise -> doQNameHelper (Left n) args'+ HdDef qn+ | isExtendedLambdaName qn+ -> mDefault+ | otherwise -> doQNameHelper (Right qn) args'+ -- HdDef qn -> doQNameHelper (Right qn) args'+ HdCon qn -> doQNameHelper (Right qn) args'+ HdSyn qn -> doQNameHelper (Right qn) args'+ | otherwise -> mDefault+ where+ mDefault = return Nothing++ skipParens :: MaybeSection (AppInfo, a) -> Bool+ skipParens = \case+ YesSection -> False+ NoSection (i, e) -> isLam e && preferParenless (appParens i)++ doQNameHelper :: Either A.Name A.QName -> [MaybeSection (AppInfo, a)] -> m (Maybe c)+ doQNameHelper n args = do+ x <- either (C.QName <.> toConcrete) toConcrete n+ let n' = either id A.qnameName n+ -- #1346: The fixity of the abstract name is not necessarily correct, it depends on which+ -- concrete name we choose! Make sure to resolve ambiguities with n'.+ (fx, nk) <- resolveName_ x n' <&> \ case+ VarName y _ -> (y ^. lensFixity, Asp.Bound)+ DefinedName _ q _ -> (q ^. lensFixity, Asp.Function)+ FieldName (q :| _) -> (q ^. lensFixity, Asp.Field)+ ConstructorName _ (q :| _) -> (q ^. lensFixity, Asp.Constructor Asp.Inductive)+ PatternSynResName (q :| _) -> (q ^. lensFixity, Asp.Constructor Asp.Inductive)+ UnknownName -> (noFixity, Asp.Bound)+ List1.ifNull args {-then-} mDefault {-else-} $ \ as ->+ doQName (nameAspects True nk n') fx x n' as (C.nameParts $ C.unqualify x)++ doQName :: Asp.Aspects -> Fixity -> C.QName -> A.Name -> List1 (MaybeSection (AppInfo, a)) -> NameParts -> m (Maybe c)++ -- fall-back (wrong number of arguments or no holes)+ doQName nk _ x _ as xs+ | length as /= numHoles x = mDefault++ -- binary case+ doQName nk fixity x n (a1 :| as) xs+ | Hole <- List1.head xs+ , Hole <- List1.last xs = do+ let (as', an) = List1.ifNull as {-then-} __IMPOSSIBLE__ {-else-} List1.initLast+ Just <$> do+ bracket (opBrackets' (skipParens an) fixity) $ do+ e1 <- traverse (toConcreteCtx (LeftOperandCtx fixity) . snd) a1+ es <- (mapM . traverse) (toConcreteCtx InsideOperandCtx . snd) as'+ en <- traverse (uncurry $ toConcreteCtx . RightOperandCtx fixity . appParens) an+ return $ opApp nk (getRange (e1, en)) x n (e1 :| es ++ [en])++ -- prefix+ doQName nk fixity x n as xs+ | Hole <- List1.last xs = do+ let (as', an) = List1.initLast as+ Just <$> do+ bracket (opBrackets' (skipParens an) fixity) $ do+ es <- (mapM . traverse) (toConcreteCtx InsideOperandCtx . snd) as'+ en <- traverse (\ (i, e) -> toConcreteCtx (RightOperandCtx fixity $ appParens i) e) an+ return $ opApp nk (getRange (n, en)) x n (List1.snoc es en)++ -- postfix+ doQName nk fixity x n as xs+ | Hole <- List1.head xs = do+ let a1 = List1.head as+ as' = List1.tail as+ e1 <- traverse (toConcreteCtx (LeftOperandCtx fixity) . snd) a1+ es <- (mapM . traverse) (toConcreteCtx InsideOperandCtx . snd) as'+ Just <$> do+ bracket (opBrackets fixity) $+ return $ opApp nk (getRange (e1, n)) x n (e1 :| es)++ -- roundfix+ doQName nk _ x n as _ = do+ es <- (mapM . traverse) (toConcreteCtx InsideOperandCtx . snd) as+ Just <$> do+ bracket roundFixBrackets $+ return $ opApp nk (getRange x) x n es++-- Recovering pattern synonyms --------------------------------------------++-- | Recover pattern synonyms for expressions.+tryToRecoverPatternSyn :: MonadToConcrete m => A.Expr -> m C.Expr -> m C.Expr+tryToRecoverPatternSyn e fallback+ | userWritten e = fallback+ | litOrCon e = recoverPatternSyn apply matchPatternSyn e fallback+ | otherwise = fallback+ where+ userWritten (A.App info _ _) = getOrigin info == UserWritten+ userWritten _ = False -- this means we always use pattern synonyms for nullary constructors++ -- Only literals or constructors can head pattern synonym definitions+ litOrCon e =+ case A.appView e of+ Application Con{} _ -> True+ Application A.Lit{} _ -> True+ _ -> False++ apply c args = A.unAppView $ Application (A.PatternSyn $ unambiguous c) args++-- | Recover pattern synonyms in patterns.+tryToRecoverPatternSynP :: MonadToConcrete m => A.Pattern -> m C.Pattern -> m C.Pattern+tryToRecoverPatternSynP = recoverPatternSyn apply matchPatternSynP+ where apply c args = PatternSynP patNoRange (unambiguous c) args++-- | General pattern synonym recovery parameterised over expression type.+recoverPatternSyn :: forall a m. (ToConcrete a, MonadToConcrete m)+ => (A.QName -> [NamedArg a] -> a) -- applySyn+ -> (PatternSynDefn -> a -> Maybe [WithHiding a]) -- match+ -> a -- expressions+ -> m (ConOfAbs a) -- fallback+ -> m (ConOfAbs a)+recoverPatternSyn applySyn match e fallback = do+ doFold <- asks foldPatternSynonyms+ if not doFold then fallback else do+ psyns <- getAllPatternSyns+ scope <- getScope+ reportSLn "toConcrete.patsyn" 100 $ render $ hsep $+ [ "Scope when attempting to recover pattern synonyms:"+ , pretty scope+ ]+ let isConP ConP{} = True -- #2828: only fold pattern synonyms with+ isConP _ = False -- constructor rhs+ cands = [ (q, args, score rhs)+ | (q, psyndef@(PatternSynDefn _ rhs)) <- reverse $ Map.toList psyns+ , isConP rhs+ , Just args <- [match psyndef e]+ -- #3879: only fold pattern synonyms with an unqualified concrete name in scope+ -- Note that we only need to consider the head of the inverse lookup result: they+ -- are already sorted from shortest to longest!+ , C.QName{} <- Fold.toList $ listToMaybe $ inverseScopeLookupName q scope+ ]+ cmp (_, _, x) (_, _, y) = compare y x+ reportSLn "toConcrete.patsyn" 50 $ render $ hsep $+ [ "Found pattern synonym candidates:"+ , prettyList_ $ map (\ (q,_,_) -> q) cands+ ]+ case sortBy cmp cands of+ (q, args, _) : _ -> toConcrete $ applySyn q $+ for args $ \ (WithHiding h arg) -> setHiding h $ defaultNamedArg arg+ [] -> fallback+ where+ -- Heuristic to pick the best pattern synonym: the one that folds the most+ -- constructors.+ score :: Pattern' Void -> Int+ score = getSum . foldAPattern con+ where con ConP{} = 1+ con _ = 0++-- Some instances that are related to interaction with users -----------++instance ToConcrete InteractionId where+ type ConOfAbs InteractionId = C.Expr+ toConcrete (InteractionId i) = return $ C.QuestionMark noRange (Just i)++instance ToConcrete NamedMeta where+ type ConOfAbs NamedMeta = C.Expr+ toConcrete i =+ C.Underscore noRange . Just . render <$> prettyTCM i
@@ -1,1256 +1,4057 @@-{-# LANGUAGE CPP, MultiParamTypeClasses, FunctionalDependencies,- FlexibleInstances, UndecidableInstances, OverlappingInstances- #-}--{-| Translation from "Agda.Syntax.Concrete" to "Agda.Syntax.Abstract". Involves scope analysis,- figuring out infix operator precedences and tidying up definitions.--}-module Agda.Syntax.Translation.ConcreteToAbstract- ( ToAbstract(..), localToAbstract- , concreteToAbstract_- , concreteToAbstract- , NewModuleQName(..)- , OldName(..)- , TopLevel(..)- , TopLevelInfo(..)- , topLevelModuleName- , AbstractRHS- , NewModuleName, OldModuleName- , NewName, OldQName- , LeftHandSide, RightHandSide- , PatName, APatName, LetDef, LetDefs- ) where--import Prelude hiding (mapM)-import Control.Applicative-import Control.Monad.Reader hiding (mapM)-import Control.Monad.Error hiding (mapM)-import Data.Typeable-import Data.Traversable (mapM)-import Data.List ((\\), nub)-import qualified Data.Map as Map--import Agda.Syntax.Concrete as C hiding (topLevelModuleName)-import Agda.Syntax.Concrete.Operators-import Agda.Syntax.Abstract as A-import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Info-import Agda.Syntax.Concrete.Definitions as C-import Agda.Syntax.Concrete.Operators-import Agda.Syntax.Concrete.Pretty-import Agda.Syntax.Abstract.Pretty-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad-import Agda.Syntax.Strict--import Agda.TypeChecking.Monad.Base (TypeError(..), Call(..), typeError,- TCErr(..), TCErr'(..), extendlambdaname)-import Agda.TypeChecking.Monad.Trace (traceCall, traceCallCPS, setCurrentRange)-import Agda.TypeChecking.Monad.State-import Agda.TypeChecking.Monad.Options--import {-# SOURCE #-} Agda.Interaction.Imports (scopeCheckImport)-import Agda.Interaction.Options--import Agda.Utils.Monad-import Agda.Utils.Tuple-import Agda.Utils.List-import Agda.Utils.Fresh-import Agda.Utils.Pretty--#include "../../undefined.h"-import Agda.Utils.Impossible-import Agda.ImpossibleTest (impossibleTest)--{--------------------------------------------------------------------------- Exceptions- --------------------------------------------------------------------------}--notAModuleExpr e = typeError $ NotAModuleExpr e-notAnExpression e = typeError $ NotAnExpression e-notAValidLetBinding d = typeError $ NotAValidLetBinding d-nothingAppliedToHiddenArg e = typeError $ NothingAppliedToHiddenArg e-nothingAppliedToInstanceArg e = typeError $ NothingAppliedToInstanceArg e---- Debugging--printLocals :: Int -> String -> ScopeM ()-printLocals v s = verboseS "scope.top" v $ do- locals <- getLocalVars- reportSLn "" 0 $ s ++ " " ++ show locals--printScope :: String -> Int -> String -> ScopeM ()-printScope tag v s = verboseS ("scope." ++ tag) v $ do- scope <- getScope- reportSLn "" 0 $ s ++ " " ++ show scope--{--------------------------------------------------------------------------- Helpers- --------------------------------------------------------------------------}--lhsArgs :: C.Pattern -> (C.Name, [NamedArg C.Pattern])-lhsArgs p = case appView p of- Arg _ _ (Named _ (IdentP (C.QName x))) : ps -> (x, ps)- _ -> __IMPOSSIBLE__- where- mkHead = Arg NotHidden Relevant . unnamed- notHidden = Arg NotHidden Relevant . unnamed- appView p = case p of- AppP p arg -> appView p ++ [arg]- OpAppP _ x ps -> mkHead (IdentP $ C.QName x) : map notHidden ps- ParenP _ p -> appView p- RawAppP _ _ -> __IMPOSSIBLE__- _ -> [ mkHead p ]--annotateDecl :: ScopeM A.Declaration -> ScopeM A.Declaration-annotateDecl m = annotateDecls $ (:[]) <$> m--annotateDecls :: ScopeM [A.Declaration] -> ScopeM A.Declaration-annotateDecls m = do- ds <- m- s <- getScope- return $ ScopedDecl s ds--annotateExpr :: ScopeM A.Expr -> ScopeM A.Expr-annotateExpr m = do- e <- m- s <- getScope- return $ ScopedExpr s e--expandEllipsis :: C.Pattern -> [C.Pattern] -> C.Clause -> C.Clause-expandEllipsis _ _ c@(C.Clause _ C.LHS{} _ _ _) = c-expandEllipsis p ps (C.Clause x (C.Ellipsis _ ps' eqs es) rhs wh wcs) =- C.Clause x (C.LHS p (ps ++ ps') eqs es) rhs wh wcs---- | Make sure that each variable occurs only once.-checkPatternLinearity :: [A.Pattern' e] -> ScopeM ()-checkPatternLinearity ps = case xs \\ nub xs of- [] -> return ()- ys -> typeError $ RepeatedVariablesInPattern $ nub ys- where- xs = concatMap vars ps- vars :: A.Pattern' e -> [C.Name]- vars p = case p of- A.VarP x -> [nameConcrete x]- A.ConP _ _ args -> concatMap (vars . namedThing . unArg) args- A.WildP _ -> []- A.AsP _ x p -> nameConcrete x : vars p- A.DotP _ _ -> []- A.AbsurdP _ -> []- A.LitP _ -> []- A.DefP _ _ args -> __IMPOSSIBLE__- A.ImplicitP _ -> __IMPOSSIBLE__---- | Compute the type of the record constructor (with bogus target type)-recordConstructorType :: [NiceDeclaration] -> C.Expr-recordConstructorType fields = build fs- where- fs = reverse $ dropWhile notField $ reverse fields-- notField NiceField{} = False- notField _ = True-- build (NiceField r f _ _ x (Arg h rel e) : fs) =- C.Pi [C.TypedBindings r $ Arg h rel (C.TBind r [BName x f] e)] $ build fs- where r = getRange x- build (d : fs) = C.Let noRange (notSoNiceDeclarations [d]) $ build fs- build [] = C.SetN noRange 0 -- todo: nicer--checkModuleApplication (C.SectionApp _ tel e) m0 x dir' =- withCurrentModule m0 $ do- (m, args) <- case appView e of- AppView (Ident m) args -> return (m, args)- _ -> notAModuleExpr e-- tel' <- toAbstract tel- (m1,args') <- toAbstract (OldModuleName m- , args- )- s <- getNamedScope m1- -- Drop constructors (OnlyQualified) if there are arguments. The record constructor- -- isn't properly in the record module, so copying it will lead to badness.- let noRecConstr | null args = id- | otherwise = removeOnlyQualified- (s', (renM, renD)) <- copyScope m0 . noRecConstr =<< getNamedScope m1- s' <- applyImportDirectiveM (C.QName x) dir' s'- modifyCurrentScope $ const s'- printScope "mod.inst" 20 "copied source module"- reportSLn "scope.mod.inst" 30 $ "renamings:\n " ++ show renD ++ "\n " ++ show renM- return ((A.SectionApp tel' m1 args'), renD, renM)-checkModuleApplication (C.RecordModuleIFS _ rec) m0 x dir' =- withCurrentModule m0 $ do- m1 <- toAbstract $ OldModuleName rec- s <- getNamedScope m1- (s', (renM, renD)) <- copyScope m0 s- s' <- applyImportDirectiveM rec dir' s'- modifyCurrentScope $ const s'-- printScope "mod.inst" 20 "copied record module"- return ((A.RecordModuleIFS m1), renD, renM)--checkModuleMacro apply r p x modapp open dir = withLocalVars $ do- notPublicWithoutOpen open dir-- m0 <- toAbstract (NewModuleName x)-- printScope "mod.inst" 20 "module macro"-- -- If we're opening, the import directive is applied to the open,- -- otherwise to the module itself.- let dir' = case open of- DontOpen -> dir- DoOpen -> defaultImportDir-- (modapp', renD, renM) <- checkModuleApplication modapp m0 x dir'- bindModule p x m0- printScope "mod.inst.copy.after" 20 "after copying"- case open of- DoOpen -> openModule_ (C.QName x) dir- DontOpen -> return ()- printScope "mod.inst" 20 $ show open- stripNoNames- printScope "mod.inst" 10 $ "after stripping"- return [ apply info (m0 `withRangesOf` [x]) modapp' renD renM ]- where- info = ModuleInfo- { minfoRange = r- , minfoAsName = Nothing- , minfoAsTo = renamingRange dir- , minfoOpenShort = Just open- , minfoDirective = Just dir- }---- | The @public@ keyword must only be used together with @open@.--notPublicWithoutOpen :: OpenShortHand -> ImportDirective -> ScopeM ()-notPublicWithoutOpen DoOpen dir = return ()-notPublicWithoutOpen DontOpen dir = when (publicOpen dir) $ typeError $- GenericError- "The public keyword must only be used together with the open keyword"---- | Computes the range of all the \"to\" keywords used in a renaming--- directive.--renamingRange = getRange . map renToRange . renaming--{--------------------------------------------------------------------------- Translation- --------------------------------------------------------------------------}--concreteToAbstract_ :: ToAbstract c a => c -> ScopeM a-concreteToAbstract_ x = toAbstract x--concreteToAbstract :: ToAbstract c a => ScopeInfo -> c -> ScopeM a-concreteToAbstract scope x = withScope_ scope (toAbstract x)---- | Things that can be translated to abstract syntax are instances of this--- class.-class ToAbstract concrete abstract | concrete -> abstract where- toAbstract :: concrete -> ScopeM abstract---- | This function should be used instead of 'toAbstract' for things that need--- to keep track of precedences to make sure that we don't forget about it.-toAbstractCtx :: ToAbstract concrete abstract =>- Precedence -> concrete -> ScopeM abstract-toAbstractCtx ctx c = withContextPrecedence ctx $ toAbstract c--setContextCPS :: Precedence -> (a -> ScopeM b) ->- ((a -> ScopeM b) -> ScopeM b) -> ScopeM b-setContextCPS p ret f = do- p' <- getContextPrecedence- withContextPrecedence p $ f $ withContextPrecedence p' . ret--localToAbstractCtx :: ToAbstract concrete abstract =>- Precedence -> concrete -> (abstract -> ScopeM a) -> ScopeM a-localToAbstractCtx ctx c ret = setContextCPS ctx ret (localToAbstract c)---- | This operation does not affect the scope, i.e. the original scope--- is restored upon completion.-localToAbstract :: ToAbstract c a => c -> (a -> ScopeM b) -> ScopeM b-localToAbstract x ret = fst <$> localToAbstract' x ret---- | Like 'localToAbstract' but returns the scope after the completion of the--- second argument.-localToAbstract' :: ToAbstract c a => c -> (a -> ScopeM b) -> ScopeM (b, ScopeInfo)-localToAbstract' x ret = do- scope <- getScope- withScope scope $ ret =<< toAbstract x--instance (ToAbstract c1 a1, ToAbstract c2 a2) => ToAbstract (c1,c2) (a1,a2) where- toAbstract (x,y) =- (,) <$> toAbstract x <*> toAbstract y--instance (ToAbstract c1 a1, ToAbstract c2 a2, ToAbstract c3 a3) =>- ToAbstract (c1,c2,c3) (a1,a2,a3) where- toAbstract (x,y,z) = flatten <$> toAbstract (x,(y,z))- where- flatten (x,(y,z)) = (x,y,z)--instance ToAbstract c a => ToAbstract [c] [a] where- toAbstract = mapM toAbstract--instance ToAbstract c a => ToAbstract (Maybe c) (Maybe a) where- toAbstract Nothing = return Nothing- toAbstract (Just x) = Just <$> toAbstract x---- Names --------------------------------------------------------------------newtype NewName a = NewName a-newtype OldQName = OldQName C.QName-newtype OldName = OldName C.Name-newtype PatName = PatName C.QName--instance ToAbstract (NewName C.Name) A.Name where- toAbstract (NewName x) = do- y <- freshAbstractName_ x- bindVariable x y- return y--instance ToAbstract (NewName C.BoundName) A.Name where- toAbstract (NewName (BName x fx)) = do- y <- freshAbstractName fx x- bindVariable x y- return y--nameExpr :: AbstractName -> A.Expr-nameExpr d = mk (anameKind d) $ anameName d- where- mk DefName = Def- mk ConName = Con . AmbQ . (:[])--instance ToAbstract OldQName A.Expr where- toAbstract (OldQName x) = do- qx <- resolveName x- reportSLn "scope.name" 10 $ "resolved " ++ show x ++ ": " ++ show qx- case qx of- VarName x' -> return $ A.Var x'- DefinedName _ d -> return $ nameExpr d- ConstructorName ds -> return $ A.Con $ AmbQ (map anameName ds)- UnknownName -> notInScope x--data APatName = VarPatName A.Name- | ConPatName [AbstractName]--instance ToAbstract PatName APatName where- toAbstract (PatName x) = do- reportSLn "scope.pat" 10 $ "checking pattern name: " ++ show x- rx <- resolveName x- z <- case (rx, x) of- -- TODO: warn about shadowing- (VarName y, C.QName x) -> return $ Left x -- typeError $ RepeatedVariableInPattern y x- (DefinedName _ d, C.QName x) | DefName == anameKind d -> return $ Left x- (UnknownName, C.QName x) -> return $ Left x- (ConstructorName ds, _) -> return $ Right ds- _ ->- typeError $ GenericError $- "Cannot pattern match on " ++ show x ++ ", because it is not a constructor"- case z of- Left x -> do- reportSLn "scope.pat" 10 $ "it was a var: " ++ show x- p <- VarPatName <$> toAbstract (NewName x)- printLocals 10 "bound it:"- return p- Right cs -> do- reportSLn "scope.pat" 10 $ "it was a con: " ++ show (map anameName cs)- return $ ConPatName cs---- Should be a defined name.-instance ToAbstract OldName A.QName where- toAbstract (OldName x) = do- rx <- resolveName (C.QName x)- case rx of- DefinedName _ d -> return $ anameName d- _ -> error $ show x ++ " - " ++ show rx--newtype NewModuleName = NewModuleName C.Name-newtype NewModuleQName = NewModuleQName C.QName-newtype OldModuleName = OldModuleName C.QName--freshQModule :: A.ModuleName -> C.Name -> ScopeM A.ModuleName-freshQModule m x = A.qualifyM m . mnameFromList . (:[]) <$> freshAbstractName_ x--checkForModuleClash :: C.Name -> ScopeM ()-checkForModuleClash x = do- ms <- scopeLookup (C.QName x) <$> getScope- unless (null ms) $- setCurrentRange (getRange x) $- typeError $ ShadowedModule $- map ((`withRangeOf` x) . amodName) ms--instance ToAbstract NewModuleName A.ModuleName where- toAbstract (NewModuleName x) = do- checkForModuleClash x- m <- getCurrentModule- y <- freshQModule m x- createModule y- return y--instance ToAbstract NewModuleQName A.ModuleName where- toAbstract (NewModuleQName m) = toAbs noModuleName m- where- toAbs m (C.QName x) = do- y <- freshQModule m x- createModule y- return y- toAbs m (C.Qual x q) = do- m' <- freshQModule m x- toAbs m' q--instance ToAbstract OldModuleName A.ModuleName where- toAbstract (OldModuleName q) = amodName <$> resolveModule q---- Expressions ---------------------------------------------------------------- | Peel off 'C.HiddenArg' and represent it as an 'NamedArg'.-mkNamedArg :: C.Expr -> NamedArg C.Expr-mkNamedArg (C.HiddenArg _ e) = Arg Hidden Relevant e-mkNamedArg (C.InstanceArg _ e) = Arg Instance Relevant e-mkNamedArg e = Arg NotHidden Relevant $ unnamed e---- | Peel off 'C.HiddenArg' and represent it as an 'Arg', throwing away any name.-mkArg' :: Relevance -> C.Expr -> Arg C.Expr-mkArg' r (C.HiddenArg _ e) = Arg Hidden r $ namedThing e-mkArg' r (C.InstanceArg _ e) = Arg Instance r $ namedThing e-mkArg' r e = Arg NotHidden r e---- | By default, arguments are @Relevant@.-mkArg :: C.Expr -> Arg C.Expr--- mkArg (C.Dot _ e) = mkArg' Irrelevant e-mkArg e = mkArg' Relevant e----- | Parse a possibly dotted C.Expr as A.Expr. Bool = True if dotted.-toAbstractDot :: Precedence -> C.Expr -> ScopeM (A.Expr, Bool)-toAbstractDot prec e = do- reportSLn "scope.irrelevance" 100 $ "toAbstractDot: " ++ (render $ pretty e)- traceCall (ScopeCheckExpr e) $ case e of- -- annotateExpr e = ScopedExpr <scope from Monad> e- C.Dot _ e -> do- e <- toAbstractCtx prec e- return (e, True)-- C.RawApp r es -> do- e <- parseApplication es- toAbstractDot prec e-- C.Paren _ e -> toAbstractDot TopCtx e-- e -> do- e <- toAbstractCtx prec e- return (e, False)--toAbstractOpArg :: Precedence -> OpApp C.Expr -> ScopeM A.Expr-toAbstractOpArg ctx (Ordinary e) = toAbstractCtx ctx e-toAbstractOpArg ctx (SyntaxBindingLambda r bs e) = toAbstractLam r bs e ctx--toAbstractLam :: Range -> [C.LamBinding] -> C.Expr -> Precedence -> ScopeM A.Expr-toAbstractLam r bs e ctx = do- localToAbstract (map makeDomainFull bs) $ \bs ->- case bs of- b:bs' -> do- e <- toAbstractCtx ctx e- let info = ExprRange r- return $ A.Lam info b $ foldr mkLam e bs'- where- mkLam b e = A.Lam (ExprRange $ fuseRange b e) b e- [] -> __IMPOSSIBLE__---instance ToAbstract C.Expr A.Expr where- toAbstract e =- traceCall (ScopeCheckExpr e) $ annotateExpr $ case e of- -- annotateExpr e = ScopedExpr <scope from Monad> e-- -- Names- Ident x -> toAbstract (OldQName x)-- -- Literals- C.Lit l -> return $ A.Lit l-- -- Meta variables- C.QuestionMark r n -> do- scope <- getScope- return $ A.QuestionMark $ MetaInfo- { metaRange = r- , metaScope = scope- , metaNumber = n- }- C.Underscore r n -> do- scope <- getScope- return $ A.Underscore $ MetaInfo- { metaRange = r- , metaScope = scope- , metaNumber = n- }-- -- Raw application- C.RawApp r es -> do- e <- parseApplication es- toAbstract e--{- Andreas, 2010-09-06 STALE COMMENT- -- Dots are used in dot patterns and in irrelevant function space .A n -> B- -- we propagate dots out from the head of applications-- C.Dot r e1 -> do- t1 <- toAbstract e1- return $ A.Dot t1--}-- -- Application- C.App r e1 e2 -> do- e1 <- toAbstractCtx FunctionCtx e1- e2 <- toAbstractCtx ArgumentCtx e2- return $ A.App (ExprRange r) e1 e2-- -- Operator application- C.OpApp r op es -> toAbstractOpApp op es-- -- With application- C.WithApp r e es -> do- e <- toAbstractCtx WithFunCtx e- es <- mapM (toAbstractCtx WithArgCtx) es- return $ A.WithApp (ExprRange r) e es-- -- Malplaced hidden argument- C.HiddenArg _ _ -> nothingAppliedToHiddenArg e- C.InstanceArg _ _ -> nothingAppliedToInstanceArg e-- -- Lambda- C.AbsurdLam r h -> return $ A.AbsurdLam (ExprRange r) h-- C.Lam r bs e -> toAbstractLam r bs e TopCtx-- -- Extended Lambda- C.ExtendedLam r cs -> do--- m <- getCurrentModule- cname <- nextlamname r 0 extendlambdaname- name <- freshAbstractName_ cname- reportSLn "toabstract.extendlambda" 10 $ "new extended lambda name: " ++ show name- qname <- qualifyName_ name- bindName PrivateAccess DefName cname qname- let insertApp (C.RawAppP r es) = C.RawAppP r ((IdentP (C.QName cname)) : es)- insertApp (C.IdentP q) = C.RawAppP (getRange q) ((IdentP (C.QName cname)) : [C.IdentP q])- insertApp _ = __IMPOSSIBLE__- insertHead (C.LHS p wps eqs with) = C.LHS (insertApp p) wps eqs with- insertHead (C.Ellipsis r wps eqs with) = C.Ellipsis r wps eqs with- scdef <- toAbstract (C.FunDef r [] defaultFixity' ConcreteDef cname- (map (\(lhs,rhs,wh) -> -- wh = NoWhere, see parser for more info- C.Clause cname (insertHead lhs) rhs wh []) cs))- case scdef of- (A.ScopedDecl si [A.FunDef di qname' cs]) -> do- setScope si- return $ A.ExtendedLam (ExprRange r) di qname' cs- _ -> __IMPOSSIBLE__- where- nextlamname :: Range -> Int -> String -> ScopeM C.Name- nextlamname r i s = do- let cname_pre = C.Name r [Id $ s ++ show i]- rn <- resolveName (C.QName cname_pre)- case rn of- UnknownName -> return $ cname_pre- _ -> nextlamname r (i+1) s---- Irrelevant non-dependent function type-- C.Fun r e1 e2 -> do- Arg h rel (e0, dotted) <- fmapM (toAbstractDot FunctionSpaceDomainCtx) $ mkArg e1- let e1 = Arg h (if dotted then Irrelevant else rel) e0- e2 <- toAbstractCtx TopCtx e2- let info = ExprRange r- return $ A.Fun info e1 e2--{---- Other function types-- C.Fun r e1 e2 -> do- e1 <- toAbstractCtx FunctionSpaceDomainCtx $ mkArg e1- e2 <- toAbstractCtx TopCtx e2- let info = ExprRange r- return $ A.Fun info e1 e2--}-- e0@(C.Pi tel e) ->- localToAbstract tel $ \tel -> do- e <- toAbstractCtx TopCtx e- let info = ExprRange (getRange e0)- return $ A.Pi info tel e-- -- Sorts- C.Set _ -> return $ A.Set (ExprRange $ getRange e) 0- C.SetN _ n -> return $ A.Set (ExprRange $ getRange e) n- C.Prop _ -> return $ A.Prop $ ExprRange $ getRange e-- -- Let- e0@(C.Let _ ds e) ->- localToAbstract (LetDefs ds) $ \ds' -> do- e <- toAbstractCtx TopCtx e- let info = ExprRange (getRange e0)- return $ A.Let info ds' e-- -- Record construction- C.Rec r fs -> do- let (xs, es) = unzip fs- es <- toAbstractCtx TopCtx es- return $ A.Rec (ExprRange r) $ zip xs es-- -- Record update- C.RecUpdate r e fs -> do- let (xs, es) = unzip fs- e <- toAbstract e- es <- toAbstractCtx TopCtx es- return $ A.RecUpdate (ExprRange r) e $ zip xs es-- -- Parenthesis- C.Paren _ e -> toAbstractCtx TopCtx e-- -- Pattern things- C.Dot _ _ -> notAnExpression e- C.As _ _ _ -> notAnExpression e- C.Absurd _ -> notAnExpression e-- -- Impossible things- C.ETel _ -> __IMPOSSIBLE__-- -- Quoting- C.QuoteGoal _ x e -> do- x' <- toAbstract (NewName x)- e' <- toAbstract e- return $ A.QuoteGoal (ExprRange $ getRange e) x' e'- C.Quote r -> return $ A.Quote (ExprRange r)- C.QuoteTerm r -> return $ A.QuoteTerm (ExprRange r)- C.Unquote r -> return $ A.Unquote (ExprRange r)-- -- DontCare- C.DontCare e -> A.DontCare <$> toAbstract e--instance ToAbstract C.LamBinding A.LamBinding where- toAbstract (C.DomainFree h rel x) = A.DomainFree h rel <$> toAbstract (NewName x)- toAbstract (C.DomainFull tb) = A.DomainFull <$> toAbstract tb--makeDomainFull :: C.LamBinding -> C.LamBinding-makeDomainFull b@C.DomainFull{} = b-makeDomainFull (C.DomainFree h rel x) =- C.DomainFull $ C.TypedBindings r $ Arg h rel $ C.TBind r [x] $ C.Underscore r Nothing- where r = getRange x-instance ToAbstract C.TypedBindings A.TypedBindings where- toAbstract (C.TypedBindings r bs) = A.TypedBindings r <$> toAbstract bs--instance ToAbstract C.TypedBinding A.TypedBinding where- toAbstract (C.TBind r xs t) = do- t' <- toAbstractCtx TopCtx t- xs' <- toAbstract (map NewName xs)- return $ A.TBind r xs' t'- toAbstract (C.TNoBind e) = do- e <- toAbstractCtx TopCtx e- return (A.TNoBind e)---- | Returns the scope inside the checked module.-scopeCheckModule :: Range -> C.QName -> A.ModuleName -> C.Telescope -> [C.Declaration] ->- ScopeM (ScopeInfo, [A.Declaration])-scopeCheckModule r x qm tel ds = do- printScope "module" 20 $ "checking module " ++ show x- res <- withCurrentModule qm $ do- -- pushScope m- -- qm <- getCurrentModule- printScope "module" 20 $ "inside module " ++ show x- withLocalVars $ do- tel <- toAbstract tel- ds <- (:[]) . A.Section info (qm `withRangesOfQ` x) tel <$>- toAbstract ds- scope <- getScope- return (scope, ds)-- -- Binding is done by the caller- printScope "module" 20 $ "after module " ++ show x- return res- where- info = ModuleInfo r noRange Nothing Nothing Nothing--newtype TopLevel a = TopLevel a--data TopLevelInfo = TopLevelInfo- { topLevelDecls :: [A.Declaration]- , outsideScope :: ScopeInfo- , insideScope :: ScopeInfo- }---- | The top-level module name.--topLevelModuleName :: TopLevelInfo -> A.ModuleName-topLevelModuleName topLevel = scopeCurrent (insideScope topLevel)---- Top-level declarations are always (import|open)* module-instance ToAbstract (TopLevel [C.Declaration]) TopLevelInfo where- toAbstract (TopLevel ds) = case splitAt (length ds - 1) ds of- (ds', [C.Module r m tel ds]) -> do- setTopLevelModule m- am <- toAbstract (NewModuleQName m)- ds' <- toAbstract ds'- (scope0, ds) <- scopeCheckModule r m am tel ds- scope <- getScope- return $ TopLevelInfo (ds' ++ ds) scope scope0- _ -> __IMPOSSIBLE__---- | runs Syntax.Concrete.Definitions.niceDeclarations on main module-niceDecls :: [C.Declaration] -> ScopeM [NiceDeclaration]-niceDecls ds = case runNice $ niceDeclarations ds of- Left e -> throwError $ TCErr Nothing $ Exception (getRange e) (show e)- Right ds -> return ds--instance ToAbstract [C.Declaration] [A.Declaration] where- toAbstract ds = toAbstract =<< niceDecls ds--newtype LetDefs = LetDefs [C.Declaration]-newtype LetDef = LetDef NiceDeclaration--instance ToAbstract LetDefs [A.LetBinding] where- toAbstract (LetDefs ds) =- concat <$> (toAbstract =<< map LetDef <$> niceDecls ds)--instance ToAbstract LetDef [A.LetBinding] where- toAbstract (LetDef d) =- case d of- NiceMutual _ d@[C.FunSig _ fx _ rel x t, C.FunDef _ _ _ abstract _ [cl]] ->- do when (abstract == AbstractDef) $ do- typeError $ GenericError $ "abstract not allowed in let expressions"- e <- letToAbstract cl- t <- toAbstract t- x <- toAbstract (NewName $ C.BName x fx)- return [ A.LetBind (LetRange $ getRange d) rel x t e ]-- -- You can't open public in a let- NiceOpen r x dirs | not (C.publicOpen dirs) -> do- m <- toAbstract (OldModuleName x)- n <- length . scopeLocals <$> getScope- openModule_ x dirs- return [A.LetOpen (ModuleInfo- { minfoRange = r- , minfoAsName = Nothing- , minfoAsTo = renamingRange dirs- , minfoOpenShort = Nothing- , minfoDirective = Just dirs- })- m- ]-- NiceModuleMacro r p a x modapp open dir | not (C.publicOpen dir) ->- checkModuleMacro LetApply r p x modapp open dir-- _ -> notAValidLetBinding d- where- letToAbstract (C.Clause top clhs@(C.LHS p [] [] []) (C.RHS rhs) NoWhere []) = do- p <- parseLHS (Just top) p- localToAbstract (snd $ lhsArgs p) $ \args ->- do rhs <- toAbstract rhs- foldM lambda rhs (reverse args) -- just reverse because these DomainFree- letToAbstract _ = notAValidLetBinding d-- -- Named patterns not allowed in let definitions- lambda e (Arg h rel (Named Nothing (A.VarP x))) = return $ A.Lam i (A.DomainFree h rel x) e- where- i = ExprRange (fuseRange x e)- lambda e (Arg h rel (Named Nothing (A.WildP i))) =- do x <- freshNoName (getRange i)- return $ A.Lam i' (A.DomainFree h rel x) e- where- i' = ExprRange (fuseRange i e)- lambda _ _ = notAValidLetBinding d---- The only reason why we return a list is that open declarations disappears.--- For every other declaration we get a singleton list.-instance ToAbstract NiceDeclaration A.Declaration where-- toAbstract d = annotateDecls $- traceCall (ScopeCheckDeclaration d) $- case d of-- -- Axiom- C.Axiom r f p rel x t -> do- clo <- commandLineOptions- when (optSafe clo) (typeError (SafeFlagPostulate x))- t' <- toAbstractCtx TopCtx t- y <- freshAbstractQName f x- bindName p DefName x y- return [ A.Axiom (mkDefInfo x f p ConcreteDef r) rel y t' ]-- -- Fields- C.NiceField r f p a x t -> do- t' <- toAbstractCtx TopCtx t- y <- freshAbstractQName f x- irrProj <- optIrrelevantProjections <$> pragmaOptions- unless (argRelevance t == Irrelevant && not irrProj) $- -- Andreas, 2010-09-24: irrelevant fields are not in scope- -- this ensures that projections out of irrelevant fields cannot occur- -- Ulf: unless you turn on --irrelevant-projections- bindName p DefName x y- return [ A.Field (mkDefInfo x f p a r) y t' ]-- -- Primitive function- PrimitiveFunction r f p a x t -> do- t' <- toAbstractCtx TopCtx t- y <- freshAbstractQName f x- bindName p DefName x y- return [ A.Primitive (mkDefInfo x f p a r) y t' ]-- -- Definitions (possibly mutual)- NiceMutual r ds -> do- ds' <- toAbstract ds- return [ A.Mutual (DeclInfo C.noName_ r) ds' ]- -- TODO: what does the info mean here?-- C.NiceRecSig r f a x ls t -> withLocalVars $ do- let toTypeBinding :: C.LamBinding -> C.TypedBindings- toTypeBinding b = case makeDomainFull b of- C.DomainFull b -> b- _ -> __IMPOSSIBLE__- ls' <- toAbstract (map toTypeBinding ls)- x' <- freshAbstractQName f x- bindName a DefName x x'- t' <- toAbstract t- return [ A.RecSig (mkDefInfo x f a ConcreteDef r) x' ls' t' ]- C.NiceDataSig r f a x ls t -> withLocalVars $ do- printScope "scope.data.sig" 20 ("checking DataSig for " ++ show x)- let toTypeBinding :: C.LamBinding -> C.TypedBindings- toTypeBinding b = case makeDomainFull b of- C.DomainFull b -> b- _ -> __IMPOSSIBLE__- ls' <- toAbstract (map toTypeBinding ls)- x' <- freshAbstractQName f x- bindName a DefName x x'- t' <- toAbstract t- return [ A.DataSig (mkDefInfo x f a ConcreteDef r) x' ls' t' ]- -- Type signatures- C.FunSig r f p rel x t -> (:[]) <$> toAbstract (C.Axiom r f p rel x t)- -- Function definitions- C.FunDef r ds f a x cs -> do- printLocals 10 $ "checking def " ++ show x- (x',cs') <- toAbstract (OldName x,cs)- return [ A.FunDef (mkDefInfo x f PublicAccess a r) x' cs' ]-- -- Data definitions- C.DataDef r f a x pars cons -> withLocalVars $ do- printScope "scope.data.def" 20 ("checking DataDef for " ++ show x)- -- Check for duplicate constructors- do let cs = map conName cons- dups = nub $ cs \\ nub cs- bad = filter (`elem` dups) cs- unless (distinct cs) $- setCurrentRange (getRange bad) $- typeError $ DuplicateConstructors dups-- pars <- toAbstract pars- DefinedName p ax <- resolveName (C.QName x)- let x' = anameName ax- -- Create the module for the qualified constructors- checkForModuleClash x -- disallow shadowing previously defined modules- let m = mnameFromList $ qnameToList x'- createModule m- bindModule p x m -- make it a proper module- cons <- toAbstract (map (ConstrDecl NoRec m a p) cons)- -- Open the module- -- openModule_ (C.QName x) defaultImportDir{ publicOpen = True }- printScope "data" 20 $ "Checked data " ++ show x- return [ A.DataDef (mkDefInfo x f PublicAccess a r) x' pars cons ]- where- conName (C.Axiom _ _ _ _ c _) = c- conName _ = __IMPOSSIBLE__-- -- Record definitions (mucho interesting)- C.RecDef r f a x cm pars fields ->- withLocalVars $ do- -- Check that the generated module doesn't clash with a previously- -- defined module- checkForModuleClash x- pars <- toAbstract pars- DefinedName p ax <- resolveName (C.QName x)- let x' = anameName ax- contel <- toAbstract $ recordConstructorType fields- m0 <- getCurrentModule- let m = A.qualifyM m0 $ mnameFromList $ (:[]) $ last $ qnameToList x'- printScope "rec" 15 "before record"- createModule m- afields <- withCurrentModule m $ do- afields <- toAbstract fields- printScope "rec" 15 "checked fields"- return afields- bindModule p x m- cm' <- mapM (\(ThingWithFixity c f) -> bindConstructorName m c f a p YesRec) cm- printScope "rec" 15 "record complete"- return [ A.RecDef (mkDefInfo x f PublicAccess a r) x' cm' pars contel afields ]-- NiceModule r p a (C.QName name) tel ds ->- traceCall (ScopeCheckDeclaration $ NiceModule r p a (C.QName name) tel []) $ do- aname <- toAbstract (NewModuleName name)- x <- snd <$> scopeCheckModule r (C.QName name) aname tel ds- bindModule p name aname- return x-- NiceModule _ _ _ C.Qual{} _ _ -> __IMPOSSIBLE__-- NiceModuleMacro r p a x modapp open dir ->- checkModuleMacro Apply r p x modapp open dir-- NiceOpen r x dir -> do- m <- toAbstract (OldModuleName x)- printScope "open" 20 $ "opening " ++ show x- openModule_ x dir- printScope "open" 20 $ "result:"- return [A.Open (ModuleInfo- { minfoRange = r- , minfoAsName = Nothing- , minfoAsTo = renamingRange dir- , minfoOpenShort = Nothing- , minfoDirective = Just dir- })- m]-- NicePragma r p -> do- ps <- toAbstract p- return $ map (A.Pragma r) ps-- NiceImport r x as open dir -> do- notPublicWithoutOpen open dir-- -- First scope check the imported module and return its name and- -- interface. This is done with that module as the top-level module.- -- This is quite subtle. We rely on the fact that when setting the- -- top-level module and generating a fresh module name the generated- -- name will be exactly the same as the name generated when checking- -- the imported module.- (m, i) <- withCurrentModule noModuleName $ withTopLevelModule x $ do- m <- toAbstract $ NewModuleQName x- printScope "import" 10 "before import:"- (m, i) <- scopeCheckImport m- printScope "import" 10 $ "scope checked import: " ++ show i- -- We don't want the top scope of the imported module (things happening- -- before the module declaration)- return (m, Map.delete noModuleName i)-- -- Merge the imported scopes with the current scopes- modifyScopeInfo $ \s -> s { scopeModules = Map.unionWith mergeScope- (Map.delete m $ scopeModules s) i }-- -- Bind the desired module name to the right abstract name.- case as of- Nothing -> bindQModule PrivateAccess x m- Just y -> bindModule PrivateAccess (asName y) m-- printScope "import" 10 "merged imported sig:"-- -- Open if specified, otherwise apply import directives- let (name, theAsSymbol, theAsName) = case as of- Nothing -> (x, noRange, Nothing)- Just a -> (C.QName (asName a), asRange a, Just (asName a))- case open of- DoOpen -> do- toAbstract [ C.Open r name dir ]- return ()- DontOpen -> do- -- If not opening import directives are applied to the original scope- modifyNamedScopeM m $ applyImportDirectiveM x dir- return [ A.Import (ModuleInfo- { minfoRange = r- , minfoAsName = theAsName- , minfoAsTo =- getRange (theAsSymbol, renamingRange dir)- , minfoOpenShort = Just open- , minfoDirective = Just dir- })- m ]---data IsRecordCon = YesRec | NoRec-data ConstrDecl = ConstrDecl IsRecordCon A.ModuleName IsAbstract Access C.NiceDeclaration--bindConstructorName m x f a p rec = do- -- The abstract name is the qualified one- y <- withCurrentModule m $ freshAbstractQName f x- -- Bind it twice, once unqualified and once qualified- bindName p' ConName x y- withCurrentModule m $ bindName p'' ConName x y- return y- where- -- An abstract constructor is private (abstract constructor means- -- abstract datatype, so the constructor should not be exported).- p' = case a of- AbstractDef -> PrivateAccess- _ -> p- p'' = case (a, rec) of- (AbstractDef, _) -> PrivateAccess- (_, YesRec) -> OnlyQualified -- record constructors aren't really in the record module- _ -> PublicAccess--instance ToAbstract ConstrDecl A.Declaration where- toAbstract (ConstrDecl rec m a p (C.Axiom r f _ rel x t)) = do -- rel==Relevant- t' <- toAbstractCtx TopCtx t- -- The abstract name is the qualified one- -- Bind it twice, once unqualified and once qualified- y <- bindConstructorName m x f a p rec- printScope "con" 15 "bound constructor"- return $ A.Axiom (mkDefInfo x f p ConcreteDef r) rel y t'-- toAbstract _ = __IMPOSSIBLE__ -- a constructor is always an axiom--instance ToAbstract C.Pragma [A.Pragma] where- toAbstract (C.ImpossiblePragma _) = impossibleTest- toAbstract (C.OptionsPragma _ opts) = return [ A.OptionsPragma opts ]- toAbstract (C.CompiledTypePragma _ x hs) = do- e <- toAbstract $ OldQName x- case e of- A.Def x -> return [ A.CompiledTypePragma x hs ]- _ -> fail $ "Bad compiled type: " ++ show x -- TODO: error message- toAbstract (C.CompiledDataPragma _ x hs hcs) = do- e <- toAbstract $ OldQName x- case e of- A.Def x -> return [ A.CompiledDataPragma x hs hcs ]- _ -> fail $ "Not a datatype: " ++ show x -- TODO: error message- toAbstract (C.CompiledPragma _ x hs) = do- e <- toAbstract $ OldQName x- y <- case e of- A.Def x -> return x- A.Con _ -> fail "Use COMPILED_DATA for constructors" -- TODO- _ -> __IMPOSSIBLE__- return [ A.CompiledPragma y hs ]- toAbstract (C.CompiledEpicPragma _ x ep) = do- e <- toAbstract $ OldQName x- y <- case e of- A.Def x -> return x- _ -> __IMPOSSIBLE__- return [ A.CompiledEpicPragma y ep ]- toAbstract (C.CompiledJSPragma _ x ep) = do- e <- toAbstract $ OldQName x- y <- case e of- A.Def x -> return x- A.Con (AmbQ [x]) -> return x- A.Con x -> fail ("COMPILED_JS used on ambiguous name " ++ show x)- _ -> __IMPOSSIBLE__- return [ A.CompiledJSPragma y ep ]- toAbstract (C.StaticPragma _ x) = do- e <- toAbstract $ OldQName x- y <- case e of- A.Def x -> return x- _ -> __IMPOSSIBLE__- return [ A.StaticPragma y ]- toAbstract (C.BuiltinPragma _ b e) = do- e <- toAbstract e- return [ A.BuiltinPragma b e ]- toAbstract (C.ImportPragma _ i) = do- addHaskellImport i- return []- toAbstract (C.EtaPragma _ x) = do- e <- toAbstract $ OldQName x- case e of- A.Def x -> return [ A.EtaPragma x ]- _ -> fail "Bad ETA pragma"--instance ToAbstract C.Clause A.Clause where- toAbstract (C.Clause top C.Ellipsis{} _ _ _) = fail "bad '...'" -- TODO: errors message- toAbstract (C.Clause top lhs@(C.LHS p wps eqs with) rhs wh wcs) = withLocalVars $ do- let wcs' = map (expandEllipsis p wps) wcs- lhs' <- toAbstract (LeftHandSide top p wps)- printLocals 10 "after lhs:"- let (whname, whds) = case wh of- NoWhere -> (Nothing, [])- AnyWhere ds -> (Nothing, ds)- SomeWhere m ds -> (Just m, ds)- if not (null eqs)- then do- rhs <- toAbstract =<< toAbstractCtx TopCtx (RightHandSide eqs with wcs' rhs whds)- return $ A.Clause lhs' rhs []- else do- -- the right hand side is checked inside the module of the local definitions- (rhs, ds) <- whereToAbstract (getRange wh) whname whds $- toAbstractCtx TopCtx (RightHandSide eqs with wcs' rhs [])- rhs <- toAbstract rhs- return $ A.Clause lhs' rhs ds--whereToAbstract :: Range -> Maybe C.Name -> [C.Declaration] -> ScopeM a -> ScopeM (a, [A.Declaration])-whereToAbstract _ _ [] inner = do- x <- inner- return (x, [])-whereToAbstract r whname whds inner = do- m <- maybe (nameConcrete <$> freshNoName noRange) return whname- let acc = maybe PrivateAccess (const PublicAccess) whname -- unnamed where's are private- let tel = []- old <- getCurrentModule- am <- toAbstract (NewModuleName m)- (scope, ds) <- scopeCheckModule r (C.QName m) am tel whds- setScope scope- x <- inner- setCurrentModule old- bindModule acc m am- return (x, ds)--data RightHandSide = RightHandSide [C.Expr] [C.Expr] [C.Clause] C.RHS [C.Declaration]-data AbstractRHS = AbsurdRHS'- | WithRHS' [A.Expr] [C.Clause] -- ^ The with clauses haven't been translated yet- | RHS' A.Expr- | RewriteRHS' [A.Expr] AbstractRHS [A.Declaration]--qualifyName_ :: A.Name -> ScopeM A.QName-qualifyName_ x = do- m <- getCurrentModule- return $ A.qualify m x--withFunctionName :: String -> ScopeM A.QName-withFunctionName s = do- NameId i _ <- fresh- qualifyName_ =<< freshName_ (s ++ show i)--instance ToAbstract AbstractRHS A.RHS where- toAbstract AbsurdRHS' = return A.AbsurdRHS- toAbstract (RHS' e) = return $ A.RHS e- toAbstract (RewriteRHS' eqs rhs wh) = do- auxs <- replicateM (length eqs) $ withFunctionName "rewrite-"- rhs <- toAbstract rhs- return $ RewriteRHS auxs eqs rhs wh- toAbstract (WithRHS' es cs) = do- aux <- withFunctionName "with-"- A.WithRHS aux es <$> toAbstract cs--instance ToAbstract RightHandSide AbstractRHS where- toAbstract (RightHandSide eqs@(_:_) es cs rhs wh) = do- eqs <- toAbstractCtx TopCtx eqs- -- TODO: remember named where- (rhs, ds) <- whereToAbstract (getRange wh) Nothing wh $- toAbstract (RightHandSide [] es cs rhs [])- return $ RewriteRHS' eqs rhs ds- toAbstract (RightHandSide [] [] (_ : _) _ _) = __IMPOSSIBLE__- toAbstract (RightHandSide [] (_ : _) _ (C.RHS _) _) = typeError $ BothWithAndRHS- toAbstract (RightHandSide [] [] [] rhs []) = toAbstract rhs- toAbstract (RightHandSide [] es cs C.AbsurdRHS []) = do- es <- toAbstractCtx TopCtx es- return $ WithRHS' es cs- -- TODO: some of these might be possible- toAbstract (RightHandSide [] (_ : _) _ C.AbsurdRHS (_ : _)) = __IMPOSSIBLE__- toAbstract (RightHandSide [] [] [] (C.RHS _) (_ : _)) = __IMPOSSIBLE__- toAbstract (RightHandSide [] [] [] C.AbsurdRHS (_ : _)) = __IMPOSSIBLE__--instance ToAbstract C.RHS AbstractRHS where- toAbstract C.AbsurdRHS = return $ AbsurdRHS'- toAbstract (C.RHS e) = RHS' <$> toAbstract e--data LeftHandSide = LeftHandSide C.Name C.Pattern [C.Pattern]--instance ToAbstract LeftHandSide A.LHS where- toAbstract (LeftHandSide top lhs wps) =- traceCall (ScopeCheckLHS top lhs) $ do- p <- parseLHS (Just top) lhs- printLocals 10 "before lhs:"- let (x, ps) = lhsArgs p- x <- withLocalVars $ setLocalVars [] >> toAbstract (OldName x)- args <- toAbstract ps- wps <- toAbstract =<< mapM (parseLHS Nothing) wps- checkPatternLinearity (map (namedThing . unArg) args ++ wps)- printLocals 10 "checked pattern:"- args <- toAbstract args -- take care of dot patterns- wps <- toAbstract wps- printLocals 10 "checked dots:"- return $ A.LHS (LHSRange $ getRange (lhs, wps)) x args wps--instance ToAbstract c a => ToAbstract (Arg c) (Arg a) where- toAbstract (Arg h r e) = Arg h r <$> toAbstractCtx (hiddenArgumentCtx h) e--instance ToAbstract c a => ToAbstract (Named name c) (Named name a) where- toAbstract (Named n e) = Named n <$> toAbstract e---- Patterns are done in two phases. First everything but the dot patterns, and--- then the dot patterns. This is because dot patterns can refer to variables--- bound anywhere in the pattern.--instance ToAbstract c a => ToAbstract (A.Pattern' c) (A.Pattern' a) where- toAbstract = mapM toAbstract--instance ToAbstract C.Pattern (A.Pattern' C.Expr) where-- toAbstract p@(C.IdentP x) = do- px <- toAbstract (PatName x)- case px of- VarPatName y -> return $ VarP y- ConPatName ds -> return $ ConP (PatRange (getRange p))- (AmbQ $ map anameName ds)- []-- toAbstract p0@(AppP p q) = do- (p', q') <- toAbstract (p,q)- case p' of- ConP _ x as -> return $ ConP info x (as ++ [q'])- DefP _ x as -> return $ DefP info x (as ++ [q'])- _ -> typeError $ InvalidPattern p0- where- r = getRange p0- info = PatSource r $ \pr -> if appBrackets pr then ParenP r p0 else p0-- toAbstract p0@(OpAppP r op ps) = do- p <- toAbstract (IdentP $ C.QName op)- ps <- toAbstract ps- case p of- ConP _ x as -> return $ ConP info x (as ++ map (Arg NotHidden Relevant . unnamed) ps)- DefP _ x as -> return $ DefP info x (as ++ map (Arg NotHidden Relevant. unnamed) ps)- _ -> __IMPOSSIBLE__- where- r = getRange p0- info = PatSource r $ \pr -> if appBrackets pr then ParenP r p0 else p0-- -- Removed when parsing- toAbstract (HiddenP _ _) = __IMPOSSIBLE__- toAbstract (InstanceP _ _) = __IMPOSSIBLE__- toAbstract (RawAppP _ _) = __IMPOSSIBLE__-- toAbstract p@(C.WildP r) = return $ A.WildP (PatSource r $ const p)- toAbstract (C.ParenP _ p) = toAbstract p- toAbstract (C.LitP l) = return $ A.LitP l- toAbstract p0@(C.AsP r x p) = typeError $ NotSupported "@-patterns"- {- do- x <- toAbstract (NewName x)- p <- toAbstract p- return $ A.AsP info x p- where- info = PatSource r $ \_ -> p0- -}- -- we have to do dot patterns at the end- toAbstract p0@(C.DotP r e) = return $ A.DotP info e- where info = PatSource r $ \_ -> p0- toAbstract p0@(C.AbsurdP r) = return $ A.AbsurdP info- where- info = PatSource r $ \_ -> p0---- | Turn an operator application into abstract syntax. Make sure to record the--- right precedences for the various arguments.-toAbstractOpApp :: C.Name -> [OpApp C.Expr] -> ScopeM A.Expr-toAbstractOpApp op@(C.NoName _ _) es = __IMPOSSIBLE__-toAbstractOpApp op@(C.Name _ _) es = do- f <- getFixity (C.QName op)- let (_,_,parts) = oldToNewNotation $ (op, f)- op <- toAbstract (OldQName $ C.QName op)- foldl app op <$> left (theFixity f) [p | p <- parts, not (isBindingHole p)] es- where- app e arg = A.App (ExprRange (fuseRange e arg)) e- $ Arg NotHidden Relevant $ unnamed arg-- left f (IdPart _ : xs) es = inside f xs es- left f (_ : xs) (e : es) = do- e <- toAbstractOpArg (LeftOperandCtx f) e- es <- inside f xs es- return (e : es)- left f (_ : _) [] = __IMPOSSIBLE__- left f [] _ = __IMPOSSIBLE__-- inside f [x] es = right f x es- inside f (IdPart _ : xs) es = inside f xs es- inside f (_ : xs) (e : es) = do- e <- toAbstractOpArg InsideOperandCtx e- es <- inside f xs es- return (e : es)- inside _ (_ : _) [] = __IMPOSSIBLE__- inside _ [] _ = __IMPOSSIBLE__-- right _ (IdPart _) [] = return []- right f _ [e] = do- e <- toAbstractOpArg (RightOperandCtx f) e- return [e]- right _ _ _ = __IMPOSSIBLE__+{-| Translation from "Agda.Syntax.Concrete" to "Agda.Syntax.Abstract".+ Involves scope analysis,+ figuring out infix operator precedences and tidying up definitions.+-}++module Agda.Syntax.Translation.ConcreteToAbstract+ ( ToAbstract(..), localToAbstract+ , concreteToAbstract_+ , concreteToAbstract+ , TopLevel(..)+ , TopLevelInfo(..)+ , topLevelModuleName+ , importPrimitives+ , checkAttributes+ ) where++import Prelude hiding ( null, (||) )++import Control.Monad ( (>=>), foldM, forM, forM_, zipWithM, zipWithM_ )+import Control.Applicative ( liftA2, liftA3 )+import Control.Monad.Except ( runExceptT, MonadError(..) )+import Control.Monad.State ( StateT, execStateT, get, put )+import Control.Monad.Trans.Maybe+import Control.Monad.Trans ( lift )++import Data.Bifunctor+import Data.Foldable (traverse_)+import Data.Set (Set)+import Data.Map (Map)+import Data.Functor (void)+import qualified Data.List as List+import qualified Data.Set as Set+import qualified Data.Map as Map+import qualified Data.HashSet as HashSet+import Data.Maybe+import Data.Text qualified as Text+import Data.Void++import Agda.Syntax.Common+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Common.Pretty (render, Pretty, pretty, prettyShow)+import Agda.Syntax.Concrete as C+import Agda.Syntax.Concrete.Attribute as CA+import Agda.Syntax.Concrete.Generic+import Agda.Syntax.Concrete.Operators+import Agda.Syntax.Concrete.Pattern+import Agda.Syntax.Abstract as A+import Agda.Syntax.Abstract.Pattern as A+ ( patternVars, checkPatternLinearity, containsAsPattern, lhsCoreApp, lhsCoreWith, noDotOrEqPattern )+import Agda.Syntax.Abstract.Pretty+import Agda.Syntax.Abstract.UsedNames+ ( allUsedNames )+import qualified Agda.Syntax.Internal as I+import Agda.Syntax.Position+import Agda.Syntax.Literal+import Agda.Syntax.Info as Info+import Agda.Syntax.Concrete.Definitions as C+import Agda.Syntax.Fixity+import Agda.Syntax.Concrete.Fixity (DoWarn(..))+import Agda.Syntax.Notation+import Agda.Syntax.Scope.Base as A+import Agda.Syntax.Scope.Monad+import Agda.Syntax.Scope.UnusedImports (lookedupName)+import Agda.Syntax.Translation.AbstractToConcrete (ToConcrete, ConOfAbs)+import Agda.Syntax.DoNotation+import Agda.Syntax.IdiomBrackets+import Agda.Syntax.TopLevelModuleName++import qualified Agda.TypeChecking.Monad.Base.Warning as W+import Agda.TypeChecking.Monad.Base hiding (ModuleInfo, MetaInfo)+import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Monad.Options (isTwoLevelEnabled, isPropEnabled)+import Agda.TypeChecking.Monad.Trace (traceCall, setCurrentRange)+import Agda.TypeChecking.Monad.State hiding (topLevelModuleName)+import qualified Agda.TypeChecking.Monad.State as TCM (topLevelModuleName)+import Agda.TypeChecking.Monad.Signature (notUnderOpaque)+import Agda.TypeChecking.Monad.MetaVars (registerInteractionPoint)+import Agda.TypeChecking.Monad.Debug+import Agda.TypeChecking.Monad.Env (insideDotPattern, isInsideDotPattern, getCurrentPath, currentModule)+import Agda.TypeChecking.Rules.Builtin (isUntypedBuiltin, bindUntypedBuiltin, builtinKindOfName)++import Agda.TypeChecking.Patterns.Abstract (expandPatternSynonyms)+import Agda.TypeChecking.Pretty hiding (pretty, prettyA)+import Agda.TypeChecking.Quote (quotedName)+import Agda.TypeChecking.Opacity+import Agda.TypeChecking.Warnings++import Agda.Interaction.FindFile (checkModuleName, rootNameModule, SourceFile(SourceFile))+-- import Agda.Interaction.Imports -- for type-checking in ghci+import {-# SOURCE #-} Agda.Interaction.Imports (scopeCheckFileImport)+import Agda.Interaction.Options+import qualified Agda.Interaction.Options.Lenses as Lens+import Agda.Interaction.Options.Warnings++import qualified Agda.Utils.AssocList as AssocList+import Agda.Utils.Boolean ( (||), ifThenElse )+import Agda.Utils.CallStack ( HasCallStack, withCurrentCallStack )+import Agda.Utils.Char+import Agda.Utils.Either+import Agda.Utils.FileName+import Agda.Utils.Function ( applyWhen, applyWhenJust, applyWhenM, applyUnless )+import Agda.Utils.Functor+import Agda.Utils.Hash (hashString)+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 ( List1, pattern (:|) )+import Agda.Utils.List2 ( List2, pattern List2 )+import qualified Agda.Utils.List1 as List1+import qualified Agda.Utils.Map as Map+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Set1 ( Set1 )+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Singleton+import Agda.Utils.Tuple+import Agda.Utils.POMonoid (hasLeftAdjoint)++import Agda.Utils.Impossible ( __IMPOSSIBLE__ )+import Agda.ImpossibleTest (impossibleTest, impossibleTestReduceM)+++{--------------------------------------------------------------------------+ Exceptions+ --------------------------------------------------------------------------}++notAnExpression :: (HasCallStack, MonadTCError m) => C.Expr -> m a+notAnExpression = locatedTypeError NotAnExpression++notAValidLetBinding :: (HasCallStack, MonadTCError m) => Maybe NotAValidLetBinding -> m a+notAValidLetBinding = locatedTypeError NotAValidLetBinding++{--------------------------------------------------------------------------+ Helpers+ --------------------------------------------------------------------------}++newtype RecordConstructorType = RecordConstructorType [C.Declaration]++instance ToAbstract RecordConstructorType where+ type AbsOfCon RecordConstructorType = A.Expr+ toAbstract (RecordConstructorType ds) = recordConstructorType ds++-- | Compute the type of the record constructor (with bogus target type)+recordConstructorType :: [C.Declaration] -> ScopeM A.Expr+recordConstructorType decls =+ -- Nicify all declarations since there might be fixity declarations after+ -- the the last field. Use NoWarn to silence fixity warnings. We'll get+ -- them again when scope checking the declarations to build the record+ -- module.+ niceDecls NoWarn decls $ buildType . takeFields+ where+ takeFields = List.dropWhileEnd notField++ notField NiceField{} = False+ notField _ = True++ buildType :: [C.NiceDeclaration] -> ScopeM A.Expr+ -- TODO: Telescope instead of Expr in abstract RecDef+ buildType ds = do+ -- The constructor target type is computed in the type checker.+ -- For now, we put a dummy expression there.+ -- Andreas, 2022-10-06, issue #6165:+ -- The dummy was builtinSet, but this might not be defined yet.+ let dummy = A.Lit empty $ LitString "TYPE"+ tel <- catMaybes <$> mapM makeBinding ds+ return $ A.mkPi (ExprRange (getRange ds)) tel dummy++ makeBinding :: C.NiceDeclaration -> ScopeM (Maybe A.TypedBinding)+ makeBinding d = do+ let failure = typeError $ NotValidBeforeField d+ r = getRange d+ mkLet :: C.NiceDeclaration -> ScopeM (Maybe A.TypedBinding)+ mkLet d = Just . A.TLet r <$> scopeCheckLetDef RecordLetDef d+ setCurrentRange r $ case d of++ C.NiceField r pr ab inst tac x (Arg ai t) -> do+ fx <- getConcreteFixity x+ ai <- checkFieldArgInfo True ai+ let bv = Arg ai $ unnamed $ C.mkBinder $ (C.mkBoundName x fx) { bnameTactic = tac }+ toAbstract $ C.TBind r (singleton bv) t++ -- Public open is allowed and will take effect when scope checking as+ -- proper declarations.+ C.NiceOpen kwr m dir -> do+ mkLet $ C.NiceOpen kwr m dir{ publicOpen = Nothing }+ C.NiceModuleMacro r p e x modapp open dir -> do+ mkLet $ C.NiceModuleMacro r p e x modapp open+ dir{ publicOpen = Nothing }++ -- Do some rudimentary matching here to get NotValidBeforeField instead+ -- of NotAValidLetDecl.+ C.NiceMutual _ _ _ _+ ( C.FunSig _ _ _ _ macro _ _ _ _ _+ :| [ C.FunDef _ _ abstract _ _ _ _+ (C.Clause _ _ _ (C.LHS _p [] []) (C.RHS _) NoWhere [] :| [])+ ]) | abstract /= AbstractDef && macro /= MacroDef -> do+ mkLet d++ C.NiceLoneConstructor{} -> failure+ C.NiceMutual{} -> failure+ -- TODO: some of these cases might be __IMPOSSIBLE__+ C.Axiom{} -> failure+ C.PrimitiveFunction{} -> failure+ C.NiceModule{} -> failure+ C.NiceImport{} -> failure+ C.NicePragma{} -> failure+ C.NiceRecSig{} -> failure+ C.NiceDataSig{} -> failure+ C.NiceFunClause{} -> failure+ C.FunSig{} -> failure -- Note: these are bundled with FunDef in NiceMutual+ C.FunDef{} -> failure+ C.NiceDataDef{} -> failure+ C.NiceRecDef{} -> failure+ C.NicePatternSyn{} -> failure+ C.NiceGeneralize{} -> failure+ C.NiceUnquoteDecl{} -> failure+ C.NiceUnquoteDef{} -> failure+ C.NiceUnquoteData{} -> failure+ C.NiceOpaque{} -> failure++checkModuleApplication+ :: C.ModuleApplication+ -> ModuleName+ -> C.Name+ -> C.ImportDirective+ -> ScopeM (A.ModuleApplication, ScopeCopyInfo, A.ImportDirective)++checkModuleApplication (C.SectionApp _ tel m es) m0 x dir' = do+ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checking ModuleApplication " ++ prettyShow x+ ]++ -- For the following, set the current module to be m0.+ withCurrentModule m0 $ do+ -- Parse the raw arguments of the module application. (See issue #1245.)+ args <- parseArguments (C.Ident m) es+ -- Scope check the telescope (introduces bindings!).+ tel' <- catMaybes <$> toAbstract tel+ -- Scope check the old module name and the module args.+ m1 <- toAbstract $ OldModuleName m+ args' <- toAbstractCtx (ArgumentCtx PreferParen) args+ -- Copy the scope associated with m and take the parts actually imported.+ (adir, s) <- applyImportDirectiveM (C.QName x) dir' =<< getNamedScope m1+ (s', copyInfo) <- copyScope m m0 s+ -- Set the current scope to @s'@+ modifyCurrentScope $ const s'+ recomputeInverseScope++ printScope "mod.inst" 40 "copied source module"+ reportS "scope.mod.inst" 30 $ pretty copyInfo+ let amodapp = A.SectionApp tel' m1 args'+ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checked ModuleApplication " ++ prettyShow x+ ]+ reportSDoc "scope.decl" 70 $ vcat $+ [ nest 2 $ prettyA amodapp+ ]+ return (amodapp, copyInfo, adir)++checkModuleApplication (C.RecordModuleInstance _ recN) m0 x dir' =+ withCurrentModule m0 $ do+ m1 <- toAbstract $ OldModuleName recN+ s <- getNamedScope m1+ (adir, s) <- applyImportDirectiveM recN dir' s+ (s', copyInfo) <- copyScope recN m0 s+ modifyCurrentScope $ const s'+ recomputeInverseScope++ printScope "mod.inst" 40 "copied record module"+ return (A.RecordModuleInstance m1, copyInfo, adir)++-- | @checkModuleMacro mkApply range access concreteName modapp open dir@+--+-- Preserves local variables.++checkModuleMacro :: (ToConcrete a, Pretty (ConOfAbs a))+ => (ModuleInfo+ -> Erased+ -> ModuleName+ -> A.ModuleApplication+ -> ScopeCopyInfo+ -> A.ImportDirective+ -> a)+ -> OpenKind+ -- ^ 'LetOpen' or ordinary 'Open'.+ -> Range+ -- ^ Range of the module definition.+ -> Access+ -- ^ Whether the new module will be public or private.+ -> Erased+ -- ^ Whether the contents of the new module will be marked as erased.+ -> C.Name+ -- ^ Name of the new module.+ -> C.ModuleApplication+ -- ^ Definition of the new module.+ -> OpenShortHand+ -- ^ Whether to open it.+ -> C.ImportDirective+ -- ^ Restricting the exports of the module.+ -> ScopeM a+checkModuleMacro apply kind r p e x modapp open dir = do+ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checking ModuleMacro " ++ prettyShow x+ ]+ dir <- notPublicWithoutOpen open dir++ m0 <- toAbstract (NewModuleName x)+ reportSDoc "scope.decl" 90 $ "NewModuleName: m0 =" <+> prettyA m0++ printScope "mod.inst" 40 "module macro"++ -- If we're opening a /named/ module, the import directive is+ -- applied to the "open", otherwise to the module itself. However,+ -- "public" is always applied to the "open".+ let (moduleDir, openDir) = case (open, isNoName x) of+ (DoOpen _, False) -> (defaultImportDir, dir)+ (DoOpen _, True) -> ( dir { publicOpen = Nothing }+ , defaultImportDir { publicOpen = publicOpen dir }+ )+ (DontOpen, _) -> (dir, defaultImportDir)++ -- Restore the locals after module application has been checked.+ (modapp', copyInfo, adir') <- withLocalVars $ checkModuleApplication modapp m0 x moduleDir++ printScope "mod.inst.app" 40 "checkModuleMacro, after checkModuleApplication"++ reportSDoc "scope.decl" 90 $ "after mod app: trying to print m0 ..."+ reportSDoc "scope.decl" 90 $ "after mod app: m0 =" <+> prettyA m0++ bindModule p x m0+ reportSDoc "scope.decl" 90 $ "after bindMod: m0 =" <+> prettyA m0++ printScope "mod.inst.copy.after" 40 "after copying"++ -- Open the module if DoOpen.+ -- Andreas, 2014-09-02: @openModule@ might shadow some locals!+ adir <- case open of+ DontOpen -> return adir'+ DoOpen kwr -> do+ adir'' <- openModule kwr kind (Just m0) (C.QName x) openDir+ -- Andreas, 2020-05-14, issue #4656+ -- Keep the more meaningful import directive for highlighting+ -- (the other one is a defaultImportDir).+ return $ if isNoName x then adir' else adir''++ printScope "mod.inst" 40 $ show open+ reportSDoc "scope.decl" 90 $ "after open : m0 =" <+> prettyA m0++ stripNoNames+ printScope "mod.inst.strip" 30 $ "after stripping"+ reportSDoc "scope.decl" 90 $ "after stripNo: m0 =" <+> prettyA m0++ let m = m0 `withRangesOf` singleton x+ adecl = apply info e m modapp' copyInfo adir++ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checked ModuleMacro " ++ prettyShow x+ ]+ reportSLn "scope.decl" 90 $ "info = " ++ show info+ reportSLn "scope.decl" 90 $ "m = " ++ prettyShow m+ reportSLn "scope.decl" 90 $ "modapp' = " ++ show modapp'+ reportS "scope.decl" 90 $ pretty copyInfo+ reportSDoc "scope.decl" 70 $ nest 2 $ prettyA adecl+ return adecl+ where+ info = ModuleInfo+ { minfoRange = r+ , minfoAsName = Nothing+ , minfoAsTo = renamingRange dir+ , minfoOpenShort = open+ , minfoDirective = Just dir+ }++-- | The @public@ keyword must only be used together with @open@.++notPublicWithoutOpen :: OpenShortHand -> C.ImportDirective -> ScopeM C.ImportDirective+notPublicWithoutOpen (DoOpen _kwr) = return+notPublicWithoutOpen DontOpen = uselessPublic UselessPublicNoOpen++-- | Warn about useless @public@.++uselessPublic :: UselessPublicReason -> C.ImportDirective -> ScopeM C.ImportDirective+uselessPublic reason dir = do+ whenJust (publicOpen dir) \ r ->+ setCurrentRange r $ warning $ UselessPublic reason+ return $ dir { publicOpen = Nothing }++-- | Computes the range of all the \"to\" keywords used in a renaming+-- directive.++renamingRange :: C.ImportDirective -> Range+renamingRange = getRange . map renToRange . impRenaming++-- | Scope check a 'NiceOpen'.+checkOpen+ :: KwRange -- ^ Range of the @open@ keyword.+ -> Maybe A.ModuleName -- ^ Resolution of concrete module name (if already resolved).+ -> C.QName -- ^ Module to open.+ -> C.ImportDirective -- ^ Scope modifier.+ -> ScopeM (ModuleInfo, A.ModuleName, A.ImportDirective) -- ^ Arguments of 'A.Open'+checkOpen kwr mam x dir = do+ cm <- getCurrentModule+ reportSDoc "scope.decl" 70 $ do+ vcat $+ [ text "scope checking NiceOpen " <> return (pretty x)+ , text " getCurrentModule = " <> prettyA cm+ , text $ " getCurrentModule (raw) = " ++ show cm+ , text $ " C.ImportDirective = " ++ prettyShow dir+ ]+ -- Andreas, 2017-01-01, issue #2377: warn about useless `public`+ dir <- if null cm then uselessPublic UselessPublicPreamble dir else return dir++ m <- caseMaybe mam (toAbstract (OldModuleName x)) return+ printScope "open" 40 $ "opening " ++ prettyShow x+ adir <- openModule kwr TopOpenModule (Just m) x dir+ printScope "open" 40 $ "result:"+ let minfo = ModuleInfo+ { minfoRange = getRange (kwr, x, dir)+ , minfoAsName = Nothing+ , minfoAsTo = renamingRange dir+ , minfoOpenShort = DoOpen kwr+ , minfoDirective = Just dir+ }+ let adecls = [A.Open minfo m adir]+ reportSDoc "scope.decl" 70 $ vcat $+ text ( "scope checked NiceOpen " ++ prettyShow x+ ) : map (nest 2 . prettyA) adecls+ return (minfo, m, adir)++-- | Check a literal, issuing an error warning for bad literals.+checkLiteral :: Literal -> ScopeM ()+checkLiteral = \case+ LitChar c -> when (isSurrogateCodePoint c) $ warning $ InvalidCharacterLiteral c+ LitNat _ -> return ()+ LitWord64 _ -> return ()+ LitFloat _ -> return ()+ LitString _ -> return ()+ LitQName _ -> return ()+ LitMeta _ _ -> return ()++{--------------------------------------------------------------------------+ Translation+ --------------------------------------------------------------------------}++concreteToAbstract_ :: ToAbstract c => c -> ScopeM (AbsOfCon c)+concreteToAbstract_ = toAbstract++concreteToAbstract :: ToAbstract c => ScopeInfo -> c -> ScopeM (AbsOfCon c)+concreteToAbstract scope x = evalWithScope scope (toAbstract x)++-- | Things that can be translated to abstract syntax are instances of this+-- class.+class ToAbstract c where+ type AbsOfCon c+ toAbstract :: c -> ScopeM (AbsOfCon c)++-- | This function should be used instead of 'toAbstract' for things that need+-- to keep track of precedences to make sure that we don't forget about it.+toAbstractCtx :: ToAbstract c => Precedence -> c-> ScopeM (AbsOfCon c)+toAbstractCtx ctx c = withContextPrecedence ctx $ toAbstract c++--UNUSED Liang-Ting Chen 2019-07-16+--toAbstractTopCtx :: ToAbstract c a => c -> ScopeM a+--toAbstractTopCtx = toAbstractCtx TopCtx++toAbstractHiding :: (LensHiding h, ToAbstract c) => h -> c -> ScopeM (AbsOfCon c)+toAbstractHiding h | visible h = toAbstract -- don't change precedence if visible+toAbstractHiding _ = toAbstractCtx TopCtx++--UNUSED Liang-Ting Chen 2019-07-16+--setContextCPS :: Precedence -> (a -> ScopeM b) ->+-- ((a -> ScopeM b) -> ScopeM b) -> ScopeM b+--setContextCPS p ret f = do+-- old <- useScope scopePrecedence+-- withContextPrecedence p $ f $ \ x -> setContextPrecedence old >> ret x+--+--localToAbstractCtx :: ToAbstract c =>+-- Precedence -> c -> (AbsOfCon -> ScopeM (AbsOfCon c)) -> ScopeM (AbsOfCon c)+--localToAbstractCtx ctx c ret = setContextCPS ctx ret (localToAbstract c)++-- | This operation does not affect the scope, i.e. the original scope+-- is restored upon completion.+localToAbstract :: ToAbstract c => c -> (AbsOfCon c -> ScopeM b) -> ScopeM b+localToAbstract x ret = localScope $ ret =<< toAbstract x++instance ToAbstract () where+ type AbsOfCon () = ()+ toAbstract = pure++instance (ToAbstract c1, ToAbstract c2) => ToAbstract (c1, c2) where+ type AbsOfCon (c1, c2) = (AbsOfCon c1, AbsOfCon c2)+ toAbstract (x,y) = (,) <$> toAbstract x <*> toAbstract y++instance (ToAbstract c1, ToAbstract c2, ToAbstract c3) => ToAbstract (c1, c2, c3) where+ type AbsOfCon (c1, c2, c3) = (AbsOfCon c1, AbsOfCon c2, AbsOfCon c3)+ toAbstract (x,y,z) = flatten <$> toAbstract (x,(y,z))+ where+ flatten (x,(y,z)) = (x,y,z)++instance ToAbstract c => ToAbstract [c] where+ type AbsOfCon [c] = [AbsOfCon c]+ toAbstract = mapM toAbstract++instance ToAbstract c => ToAbstract (List1 c) where+ type AbsOfCon (List1 c) = List1 (AbsOfCon c)+ toAbstract = mapM toAbstract++instance (ToAbstract c1, ToAbstract c2) => ToAbstract (Either c1 c2) where+ type AbsOfCon (Either c1 c2) = Either (AbsOfCon c1) (AbsOfCon c2)+ toAbstract = traverseEither toAbstract toAbstract++instance ToAbstract c => ToAbstract (Maybe c) where+ type AbsOfCon (Maybe c) = Maybe (AbsOfCon c)+ toAbstract = traverse toAbstract++-- Names ------------------------------------------------------------------++data NewName a = NewName+ { newBinder :: A.BindingSource -- what kind of binder?+ , newName :: a+ } deriving (Functor)++data OldQName = OldQName+ C.QName+ -- ^ Concrete name to be resolved.+ (Maybe (Set1 A.Name))+ -- ^ If a set is given, then the first name must+ -- correspond to one of the names in the set.++-- | We sometimes do not want to fail hard if the name is not actually+-- in scope because we have a strategy to recover from this problem+-- (e.g. drop the offending COMPILE pragma)+data MaybeOldQName = MaybeOldQName OldQName++-- | Wrapper to resolve a name in a pattern.+data PatName = PatName+ C.QName+ -- ^ Concrete name to be resolved in a pattern.+ (Maybe (Set1 A.Name))+ -- ^ If a set is given, then the first name must correspond to one+ -- of the names in the set.+ Hiding+ -- ^ If pattern variable is hidden, its status is indicated in 'Hiding'.+ DisplayLHS+ -- ^ If we parse the lhs of a 'DisplayPragma',+ -- names of arbitrary definitions count as constructors.++instance ToAbstract (NewName C.Name) where+ type AbsOfCon (NewName C.Name) = A.Name+ toAbstract (NewName b x) = do+ y <- freshAbstractName_ x+ bindVariable b x y+ return y++instance ToAbstract (NewName C.BoundName) where+ type AbsOfCon (NewName C.BoundName) = A.BindName+ toAbstract NewName{ newBinder = b, newName = BName{ boundName = x, bnameFixity = fx }} = do+ y <- freshAbstractName fx x+ bindVariable b x y+ return $ A.BindName y++instance ToAbstract OldQName where+ type AbsOfCon OldQName = A.Expr+ toAbstract q@(OldQName x _) =+ fromMaybeM (notInScopeError x) $ toAbstract (MaybeOldQName q)++instance ToAbstract MaybeOldQName where+ type AbsOfCon MaybeOldQName = Maybe A.Expr+ toAbstract (MaybeOldQName (OldQName x ns)) = do+ qx <- resolveName' allKindsOfNames ns x+ lookedupName x qx -- Mark this name as used for the unused-imports analysis+ reportSLn "scope.name" 30 $ "resolved " ++ prettyShow x ++ ": " ++ prettyShow qx+ case qx of+ VarName x' _ -> return $ Just $ A.Var x'+ DefinedName _ d suffix -> do+ raiseWarningsOnUsage $ anameName d+ -- then we take note of generalized names used+ addGeneralizable d+ -- and then we return the name+ return $ withSuffix suffix $ nameToExpr d+ where+ withSuffix NoSuffix e = Just e+ withSuffix s@Suffix{} (A.Def x) = Just $ A.Def' x s+ withSuffix _ _ = Nothing++ FieldName ds -> ambiguous (A.Proj ProjPrefix) ds+ ConstructorName _ ds -> ambiguous A.Con ds+ PatternSynResName ds -> ambiguous A.PatternSyn ds+ UnknownName -> do+ reportSLn "scope.name.unknown" 80 $ "resolved : unknown " ++ prettyShow x+ pure Nothing+ where+ ambiguous :: (AmbiguousQName -> A.Expr) -> List1 AbstractName -> ScopeM (Maybe A.Expr)+ ambiguous f ds = do+ raiseWarningsOnUsageIfUnambiguous ds+ return $ Just $ f $ ambigName ds++ -- Note: user warnings on ambiguous names will be raised by the type checker,+ -- see 'storeDisambiguatedName'.+ raiseWarningsOnUsageIfUnambiguous :: List1 AbstractName -> ScopeM ()+ raiseWarningsOnUsageIfUnambiguous = \case+ x :| [] -> raiseWarningsOnUsage $ anameName x+ _ -> return ()++-- | Resolve a name and fail hard if it is not in scope.+--+resolveQName :: C.QName -> ScopeM ResolvedName+resolveQName x = resolveName x >>= \case+ UnknownName -> notInScopeError x+ q -> q <$ addGeneralizable q+ -- Issue #7575:+ -- If the name is a @variable@, add it to the things we wish to generalize.+ -- If generalization is not supported here, this will throw an error.++-- | A name resolved in a pattern.+data APatName+ = VarPatName A.Name+ -- ^ Pattern variable.+ | ConPatName (List1 AbstractName)+ -- ^ A (possibly ambiguous) constructor.+ -- When parsing a 'C.DisplayPragma', this can be the name of a definition.+ | PatternSynPatName (List1 AbstractName)+ -- ^ A (possibly ambiguous) pattern synonym.+ | DefPatName AbstractName+ -- ^ A defined name, only possible when checking a 'C.DisplayPragma'.++instance ToAbstract PatName where+ type AbsOfCon PatName = APatName+ toAbstract (PatName x ns h displayLhs) = do+ reportSLn "scope.pat" 30 $ "checking pattern name: " ++ prettyShow x+ let kinds = applyWhen displayLhs (defNameKinds ++) conLikeNameKinds+ rx <- resolveName' (someKindsOfNames kinds) ns x+ -- Andreas, 2013-03-21 ignore conflicting names which cannot+ -- be meant since we are in a pattern+ -- Andreas, 2020-04-11 CoConName:+ -- coinductive constructors will be rejected later, in the type checker+ reportSLn "scope.pat" 40 $ "resolved as " ++ prettyShow rx+ lookedupName x rx+ case rx of+ ConstructorName _ ds -> ConPatName ds <$ do+ reportSLn "scope.pat" 30 $ "it was a con: " ++ prettyShow (fmap anameName ds)+ PatternSynResName ds -> PatternSynPatName ds <$ do+ reportSLn "scope.pat" 30 $ "it was a pat syn: " ++ prettyShow (fmap anameName ds)+ DefinedName _ d suffix | YesDisplayLHS <- displayLhs, null suffix -> DefPatName d <$ do+ reportSLn "scope.pat" 30 $ "it was a def: " ++ prettyShow (anameName d)+ _ -> case x of+ C.QName y -> VarPatName <$> bindPatternVariable h y+ C.Qual{} -> typeError $ InvalidPattern $ C.IdentP True x++-- | Translate and possibly bind a pattern variable+-- (which could have been bound before due to non-linearity).+bindPatternVariable :: Hiding -> C.Name -> ScopeM A.Name+bindPatternVariable h x = do+ y <- (AssocList.lookup x <$> getVarsToBind) >>= \case+ Just (LocalVar y _ _) -> do+ reportSLn "scope.pat" 30 $ "it was a old var: " ++ prettyShow x+ return $ setRange (getRange x) y+ Nothing -> do+ reportSLn "scope.pat" 30 $ "it was a new var: " ++ prettyShow x+ freshAbstractName_ x+ addVarToBind x $ LocalVar y (PatternBound h) []+ return y++class ToQName a where+ toQName :: a -> C.QName++instance ToQName C.Name where toQName = C.QName+instance ToQName C.QName where toQName = id++-- | Resolve a concrete name that we already bound to an 'A.Def'.+toAbstractOldName :: ToQName a => a -> ScopeM A.QName+toAbstractOldName x = do+ resolveName (toQName x) >>= \case+ DefinedName _ d NoSuffix -> return $ anameName d+ DefinedName _ d Suffix{} -> __IMPOSSIBLE__+ VarName{} -> __IMPOSSIBLE__+ UnknownName -> __IMPOSSIBLE__+ -- We can get the cases below for DISPLAY pragmas+ ConstructorName _ ds -> return $ anameName (List1.head ds) -- We'll throw out this one, so it doesn't matter which one we pick+ FieldName ds -> return $ anameName (List1.head ds)+ PatternSynResName ds -> return $ anameName (List1.head ds)++newtype NewModuleName = NewModuleName C.Name+newtype NewModuleQName = NewModuleQName C.QName+newtype OldModuleName = OldModuleName C.QName++freshQModule :: A.ModuleName -> C.Name -> ScopeM A.ModuleName+freshQModule m x = A.qualifyM m . mnameFromList1 . singleton <$> freshAbstractName_ x++checkForModuleClash :: C.Name -> ScopeM ()+checkForModuleClash x = do+ ms :: [AbstractModule] <- scopeLookup (C.QName x) <$> getScope+ List1.unlessNull ms \ ms -> do+ reportSLn "scope.clash" 40 $ "clashing modules ms = " ++ prettyShow ms+ reportSLn "scope.clash" 60 $ "clashing modules ms = " ++ show ms+ setCurrentRange x $+ typeError $ ShadowedModule x $ fmap ((`withRangeOf` x) . amodName) ms++instance ToAbstract NewModuleName where+ type AbsOfCon NewModuleName = A.ModuleName+ toAbstract (NewModuleName x) = do+ checkForModuleClash x+ m <- getCurrentModule+ y <- freshQModule m x+ createModule Nothing y+ return y++instance ToAbstract NewModuleQName where+ type AbsOfCon NewModuleQName = A.ModuleName+ toAbstract (NewModuleQName m) = toAbs noModuleName m+ where+ toAbs m (C.QName x) = do+ y <- freshQModule m x+ createModule Nothing y+ return y+ toAbs m (C.Qual x q) = do+ m' <- freshQModule m x+ toAbs m' q++instance ToAbstract OldModuleName where+ type AbsOfCon OldModuleName = A.ModuleName++ toAbstract (OldModuleName q) = setCurrentRange q $ do+ amodName <$> resolveModule q++-- Expressions ------------------------------------------------------------+--UNUSED Liang-Ting Chen 2019-07-16+---- | Peel off 'C.HiddenArg' and represent it as an 'NamedArg'.+--mkNamedArg :: C.Expr -> NamedArg C.Expr+--mkNamedArg (C.HiddenArg _ e) = Arg (hide defaultArgInfo) e+--mkNamedArg (C.InstanceArg _ e) = Arg (makeInstance defaultArgInfo) e+--mkNamedArg e = Arg defaultArgInfo $ unnamed e++-- | Peel off 'C.HiddenArg' and represent it as an 'Arg', throwing away any name.+mkArg' :: ArgInfo -> C.Expr -> Arg C.Expr+mkArg' info (C.HiddenArg _ e) = Arg (hide info) $ namedThing e+mkArg' info (C.InstanceArg _ e) = Arg (makeInstance info) $ namedThing e+mkArg' info e = Arg (setHiding NotHidden info) e++inferParenPreference :: C.Expr -> ParenPreference+inferParenPreference C.Paren{} = PreferParen+inferParenPreference _ = PreferParenless++-- | Scope check the argument in an 'C.App', giving special treatment to 'C.Dot'+-- which in some situation can be interpreted as post-fix projection.+toAbstractArgument :: NamedArg C.Expr -> ScopeM (NamedArg A.Expr, ParenPreference)+toAbstractArgument e = do+ case namedArg e of++ -- Andreas, 2025-07-15, issue #7954: do not allow parentheses around postfix projections.+ C.Dot kwr ex+ | null (getArgInfo e) -> do+ -- @ex@ may only be an identifier+ y <- toAbstractIdent ex $ fail InvalidDottedExpression+ return (defaultNamedArg $ A.Dot (ExprRange $ getRange e) y, PreferParenless)++ -- Andreas, 2021-02-10, issue #3289: reject @e {.p}@ and @e ⦃ .p ⦄@.+ -- Raise an error if argument is a C.Dot with Hiding info.+ | otherwise -> fail $ IllegalHidingInPostfixProjection e++ -- Ordinary function argument.+ _ -> do+ let parenPref = inferParenPreference (namedArg e)+ (,parenPref) <$> toAbstractCtx (ArgumentCtx parenPref) e+ where+ fail :: TypeError -> ScopeM a+ fail = setCurrentRange e . typeError+++-- | Check an identifier in scope.+toAbstractIdent :: C.Expr -> ScopeM A.Expr -> ScopeM A.Expr+toAbstractIdent e fallback = traceCall (ScopeCheckExpr e) do+ case e of+ C.Ident x -> toAbstract (OldQName x Nothing)+ C.KnownIdent _ x -> toAbstract (OldQName x Nothing)+ _ -> fallback++-- | Parse a possibly dotted and braced @C.Expr@ as @A.Expr@,+-- interpreting dots as relevance and braces as hiding.+-- Only accept a layer of dotting/bracing if the respective accumulator is @Nothing@.+toAbstractDotHiding :: Maybe Relevance -> Maybe Hiding -> Precedence -> C.Expr -> ScopeM (A.Expr, Relevance, Hiding)+toAbstractDotHiding mr mh prec e = do+ reportSLn "scope.irrelevance" 100 $ "toAbstractDotHiding: " ++ render (pretty e)+ traceCall (ScopeCheckExpr e) $ case e of++ C.RawApp _ es -> toAbstractDotHiding mr mh prec =<< parseApplication es+ C.Paren _ e -> toAbstractDotHiding mr mh TopCtx e++ C.Dot kwr e+ | Nothing <- mr -> toAbstractDotHiding (Just $ Irrelevant $ OIrrDot $ getRange kwr) mh prec e++ C.DoubleDot kwr e+ | Nothing <- mr -> toAbstractDotHiding (Just $ ShapeIrrelevant $ OShIrrDotDot $ getRange kwr) mh prec e++ C.HiddenArg _ (Named Nothing e)+ | Nothing <- mh -> toAbstractDotHiding mr (Just Hidden) TopCtx e++ C.InstanceArg _ (Named Nothing e)+ | Nothing <- mh -> toAbstractDotHiding mr (Just $ Instance NoOverlap) TopCtx e++ e -> (, fromMaybe relevant mr, fromMaybe NotHidden mh) <$>+ toAbstractCtx prec e++-- | Translate concrete expression under at least one binder into nested+-- lambda abstraction in abstract syntax.+toAbstractLam :: Range -> List1 C.LamBinding -> C.Expr -> Precedence -> ScopeM A.Expr+toAbstractLam r bs e ctx = do+ -- Translate the binders+ lvars0 <- getLocalVars+ localToAbstract (fmap (C.DomainFull . makeDomainFull) bs) $ \ bs -> do+ lvars1 <- getLocalVars+ checkNoShadowing lvars0 lvars1+ -- Translate the body+ e <- toAbstractCtx ctx e+ -- We have at least one binder. Get first @b@ and rest @bs@.+ return $ case List1.catMaybes bs of+ -- Andreas, 2020-06-18+ -- There is a pathological case in which we end up without binder:+ -- λ (let+ -- mutual -- warning: empty mutual block+ -- ) -> Set+ [] -> e+ b:bs -> A.Lam (ExprRange r) b $ foldr mkLam e bs+ where+ mkLam b e = A.Lam (ExprRange $ fuseRange b e) b e++-- | Scope check extended lambda expression.+scopeCheckExtendedLam ::+ Range -> Erased -> List1 C.LamClause -> ScopeM A.Expr+scopeCheckExtendedLam r e cs = do+ whenM isInsideDotPattern $ typeError $ NotAllowedInDotPatterns PatternLambdas++ -- Find an unused name for the extended lambda definition.+ cname <- freshConcreteName r 0 extendedLambdaName+ name <- freshAbstractName_ cname+ a <- asksTC (^. lensIsAbstract)+ reportSDoc "scope.extendedLambda" 30 $ vcat+ [ text $ "new extended lambda name (" ++ show a ++ "): " ++ prettyShow name+ ]+ verboseS "scope.extendedLambda" 60 $ do+ forM_ cs $ \ c -> do+ reportSLn "scope.extendedLambda" 60 $ "extended lambda lhs: " ++ show (C.lamLHS c)+ qname <- qualifyName_ name+ bindName privateAccessInserted FunName cname qname++ -- Andreas, 2019-08-20+ -- Keep the following __IMPOSSIBLE__, which is triggered by -v scope.decl.trace:80,+ -- for testing issue #4016.+ d <- C.FunDef r __IMPOSSIBLE__ a NotInstanceDef __IMPOSSIBLE__ __IMPOSSIBLE__ cname <$> do+ forM cs $ \ (LamClause ps rhs ca) -> do+ let p = C.rawAppP $+ killRange (IdentP True $ C.QName cname) :| ps+ let lhs = C.LHS p [] []+ return $ C.Clause cname ca defaultArgInfo lhs rhs NoWhere []+ scdef <- fromMaybe __IMPOSSIBLE__ <$> toAbstract d++ -- Create the abstract syntax for the extended lambda.+ case scdef of+ A.ScopedDecl si (A.FunDef di qname' cs :| []) -> do+ setScope si -- This turns into an A.ScopedExpr si $ A.ExtendedLam...+ return $+ A.ExtendedLam (ExprRange r) di e qname' cs+ _ -> __IMPOSSIBLE__++-- | Scope check an expression.++instance ToAbstract C.Expr where+ type AbsOfCon C.Expr = A.Expr++ toAbstract e =+ traceCall (ScopeCheckExpr e) $ annotateExpr $ case e of++ -- Names+ C.Ident x -> toAbstract (OldQName x Nothing)+ C.KnownIdent _ x -> toAbstract (OldQName x Nothing)+ -- Just discard the syntax highlighting information.++ -- Literals+ C.Lit r l -> do+ checkLiteral l+ case l of+ LitNat n -> do+ let builtin | n < 0 = Just <$> primFromNeg -- negative literals are only allowed if FROMNEG is defined+ | otherwise = ensureInScope =<< getBuiltin' builtinFromNat+ builtin >>= \case+ Just (I.Def q _) -> return $ mkApp q $ A.Lit i $ LitNat $ abs n+ _ -> return alit++ LitString s -> do+ getBuiltin' builtinFromString >>= ensureInScope >>= \case+ Just (I.Def q _) -> return $ mkApp q alit+ _ -> return alit++ _ -> return alit+ where+ i = ExprRange r+ alit = A.Lit i l+ mkApp q = A.App (defaultAppInfo r) (A.Def q) . defaultNamedArg++ -- #4925: Require fromNat/fromNeg to be in scope *unqualified* for literal overloading to+ -- apply.+ ensureInScope :: Maybe I.Term -> ScopeM (Maybe I.Term)+ ensureInScope v@(Just (I.Def q _)) =+ ifM (isNameInScopeUnqualified q <$> getScope) (return v) (return Nothing)+ ensureInScope _ = return Nothing++ -- Meta variables+ C.QuestionMark r n -> do+ scope <- getScope+ -- Andreas, 2014-04-06 create interaction point.+ ii <- registerInteractionPoint True r n++ let info = MetaInfo+ { metaRange = r+ , metaScope = scope+ , metaNumber = Nothing+ , metaNameSuggestion = ""+ , metaKind = UnificationMeta+ }+ return $ A.QuestionMark info ii+ C.Underscore r n -> do+ scope <- getScope+ return $ A.Underscore $ MetaInfo+ { metaRange = r+ , metaScope = scope+ , metaNumber = __IMPOSSIBLE__ =<< n+ , metaNameSuggestion = fromMaybe "" n+ , metaKind = UnificationMeta+ }++ -- Raw application+ C.RawApp r es -> do+ e <- parseApplication es+ toAbstract e++ -- Application+ C.App r e1 e2 -> do+ e1 <- toAbstractCtx FunctionCtx e1+ (e2, parenPref) <- toAbstractArgument e2+ let info = (defaultAppInfo r) { appOrigin = UserWritten, appParens = parenPref }+ return $ A.App info e1 e2++ -- Operator application+ C.OpApp r op ns es -> toAbstractOpApp op ns es+ C.KnownOpApp _ r op ns es -> toAbstractOpApp op ns es++ -- With application+ C.WithApp r e es -> do+ e <- toAbstractCtx WithFunCtx e+ es <- mapM (toAbstractCtx WithArgCtx) es+ return $ A.WithApp (ExprRange r) e es++ -- Misplaced hidden argument. We can treat these as parentheses and+ -- raise an error-warning+ C.HiddenArg _ e' -> do+ warning (HiddenNotInArgumentPosition e)+ toAbstract (namedThing e')++ C.InstanceArg _ e' -> do+ warning (InstanceNotInArgumentPosition e)+ toAbstract (namedThing e')++ -- Lambda+ C.AbsurdLam r h -> return $ A.AbsurdLam (ExprRange r) h++ C.Lam r bs e -> toAbstractLam r bs e TopCtx++ -- Extended Lambda+ C.ExtendedLam r e cs -> scopeCheckExtendedLam r e cs++ -- Relevant and irrelevant non-dependent function type+ C.Fun r (Arg info1 e1) e2 -> do+ let arg = mkArg' info1 e1+ let mr = case getRelevance arg of+ Relevant{} -> Nothing+ r -> Just r+ let mh = case getHiding arg of+ NotHidden -> Nothing+ h -> Just h+ Arg info (e1', rel, hid) <- traverse (toAbstractDotHiding mr mh FunctionSpaceDomainCtx) arg+ let updRel = applyUnless (isRelevant rel) $ setRelevance rel+ let updHid = case hid of+ NotHidden -> id+ hid -> setHiding hid+ A.Fun (ExprRange r) (Arg (updRel $ updHid info) e1') <$> toAbstractCtx TopCtx e2++ -- Dependent function type+ e0@(C.Pi tel e) -> do+ lvars0 <- getLocalVars+ localToAbstract tel $ \tel -> do+ lvars1 <- getLocalVars+ checkNoShadowing lvars0 lvars1+ e <- toAbstractCtx TopCtx e+ let info = ExprRange (getRange e0)+ return $ A.mkPi info (List1.catMaybes tel) e++ -- Let+ e0@(C.Let _ ds (Just e)) ->+ ifM isInsideDotPattern (typeError $ NotAllowedInDotPatterns LetExpressions) {-else-} do+ localToAbstract (LetDefs ExprLetDef ds) $ \ds' -> do+ e <- toAbstractCtx TopCtx e+ let info = ExprRange (getRange e0)+ return $ A.mkLet info ds' e+ C.Let _ _ Nothing -> typeError $ NotAValidLetExpression MissingBody++ -- Record construction+ C.Rec kwr r fs -> do+ fs' <- toAbstractCtx TopCtx fs+ let ds' = [ d | Right (_, Just d) <- fs' ]+ fs'' = map (mapRight fst) fs'+ i = ExprRange r+ return $ A.mkLet i ds' (A.Rec kwr i fs'')++ -- Record update+ C.RecUpdate kwr r e fs -> do+ A.RecUpdate kwr (ExprRange r) <$> toAbstract e <*> toAbstractCtx TopCtx fs++ -- Parenthesis+ C.Paren _ e -> toAbstractCtx TopCtx e++ -- Idiom brackets+ C.IdiomBrackets r q es -> qualifiedExpression q $+ toAbstractCtx TopCtx =<< parseIdiomBracketsSeq r q es++ -- Do notation+ C.DoBlock _kwr q ss -> qualifiedExpression q $+ toAbstractCtx TopCtx =<< desugarDoNotation q ss++ -- Post-fix projections+ C.Dot _ _ -> typeError InvalidDottedExpression++ -- Pattern things+ C.As _ _ _ -> notAnExpression e+ C.Absurd _ -> notAnExpression e++ -- Impossible things+ C.Equal{} -> syntaxError "unexpected '='" -- triggered by 'f = (x = e)'+ C.Ellipsis _ -> syntaxError "unexpected '...'" -- triggered by 'f = ...'+ C.DoubleDot _ _ -> syntaxError "unexpected '..'" -- triggered by 'f = ..x'++ -- Quoting+ C.Quote r -> return $ A.Quote (ExprRange r)+ C.QuoteTerm r -> return $ A.QuoteTerm (ExprRange r)+ C.Unquote r -> return $ A.Unquote (ExprRange r)++ C.Tactic r e -> syntaxError "'tactic' can only appear in attributes"++ -- 'Flagged' expressions from internal syntax+ C.DontCare e -> A.DontCare <$> toAbstract e+ C.Highlighted m a -> A.Highlighted m <$> toAbstract a++ -- forall-generalize+ C.Generalized e -> do+ (s, e) <- collectGeneralizables $ toAbstract e+ pure $ A.generalized s e++instance ToAbstract C.ModuleAssignment where+ type AbsOfCon C.ModuleAssignment = (A.ModuleName, Maybe A.LetBinding)+ toAbstract (C.ModuleAssignment m es i)+ | null es && isDefaultImportDir i = (, Nothing) <$> toAbstract (OldModuleName m)+ | otherwise = do+ x <- C.NoName (getRange m) <$> fresh+ r <- checkModuleMacro LetApply LetOpenModule+ (getRange (m, es, i)) PublicAccess defaultErased x+ (C.SectionApp (getRange (m , es)) [] m es)+ DontOpen i+ case r of+ LetApply _ _ m' _ _ _ -> return (m', Just r)+ _ -> __IMPOSSIBLE__++instance ToAbstract c => ToAbstract (FieldAssignment' c) where+ type AbsOfCon (FieldAssignment' c) = FieldAssignment' (AbsOfCon c)++ toAbstract = traverse toAbstract++instance ToAbstract (C.Binder' (NewName C.BoundName)) where+ type AbsOfCon (C.Binder' (NewName C.BoundName)) = A.Binder++ toAbstract (C.Binder p o n) = do+ let name = C.boundName $ newName n++ -- If we do have a pattern then the variable needs to be inserted+ -- so we do need a proper internal name for it.+ --+ -- Amy, 2024-10-18: If we generated a name, then mark the binder+ -- name as being inserted.+ (n, o) <- if not (isNoName name && isJust p) then pure (n, o) else do+ n' <- freshConcreteName (getRange $ newName n) 0 patternInTeleName+ pure (fmap (\ n -> n { C.boundName = n' }) n, InsertedBinderName)++ n <- toAbstract n+ -- Expand puns if optHiddenArgumentPuns is True.+ p <- traverse expandPunsOpt p+ -- Actually parsing the pattern, checking it is linear,+ -- and bind its variables+ p <- traverse parsePattern p+ p <- toAbstract p+ checkPatternLinearity p $ \ys ->+ typeError $ RepeatedVariablesInPattern ys+ bindVarsToBind+ p <- toAbstract p+ pure $ A.Binder p o n++instance ToAbstract C.LamBinding where+ type AbsOfCon C.LamBinding = Maybe A.LamBinding++ toAbstract (C.DomainFree x) = do+ tac <- scopeCheckTactic x+ Just . A.DomainFree tac <$> toAbstract (updateNamedArg (fmap $ NewName LambdaBound) x)+ toAbstract (C.DomainFull tb) = fmap A.DomainFull <$> toAbstract tb++-- | Scope check tactic attribute, make sure they are only used in hidden arguments.+scopeCheckTactic :: NamedArg C.Binder -> ScopeM A.TacticAttribute+scopeCheckTactic x = do+ let ctac = bnameTactic $ C.binderName $ namedArg x+ let r = getRange ctac+ setCurrentRange r $ do+ tac <- traverse toAbstract ctac+ if null tac || hidden x then return tac else empty <$ warning UselessTactic++makeDomainFull :: C.LamBinding -> C.TypedBinding+makeDomainFull (C.DomainFull b) = b+makeDomainFull (C.DomainFree x) = C.TBind r (singleton x) $ C.Underscore r Nothing+ where r = getRange x++-- | Common code for finishing the scope checking of a "qualified" operation.+-- By itself, does not affect name resolution at all!+--+-- If the 'C.QName' is present, then it must refer to an existing+-- module, and a 'A.Qualified' wrapper is generated around the+-- expression.+qualifiedExpression :: Maybe C.QName -> ScopeM A.Expr -> ScopeM A.Expr+qualifiedExpression Nothing cont = cont+qualifiedExpression (Just mod) cont = do+ mod <- toAbstract (OldModuleName mod)+ A.Qualified mod <$> cont++instance ToAbstract C.TypedBinding where+ type AbsOfCon C.TypedBinding = Maybe A.TypedBinding++ toAbstract (C.TBind r xs t) = do+ t' <- toAbstractCtx TopCtx t+ -- Invariant: all tactics are the same+ -- (distributed in the parser, TODO: don't)+ let tacArg = List1.find (not . null . bnameTactic . C.binderName . namedArg) xs+ tac <- maybe (pure empty) scopeCheckTactic tacArg++ let fin = all (bnameIsFinite . C.binderName . namedArg) xs+ xs' <- toAbstract $ fmap (updateNamedArg (fmap $ NewName LambdaBound)) xs++ return $ Just $ A.TBind r (TypedBindingInfo tac fin) xs' t'+ toAbstract (C.TLet r ds) = A.mkTLet r <$> toAbstract (LetDefs ExprLetDef ds)++-- | Scope check a module (top level function).+--+scopeCheckNiceModule+ :: Range+ -> Access+ -> Erased+ -> C.Name+ -> C.Telescope+ -> ScopeM [A.Declaration]+ -> ScopeM A.Declaration+ -- ^ The returned declaration is an 'A.Section'.+scopeCheckNiceModule r p e name tel checkDs = do+ -- Andreas, 2025-03-29: clear @envCheckingWhere@+ -- We are no longer directly in a @where@ block if we enter a module.+ localTC (set eCheckingWhere C.NoWhere_) $+ checkWrappedModules p (splitModuleTelescope tel)+ where+ -- Andreas, 2013-12-10:+ -- If the module telescope contains open statements+ -- or module macros (Issue 1299),+ -- add an extra anonymous module around the current one.+ -- Otherwise, the open statements would create+ -- identifiers in the parent scope of the current module.+ -- But open statements in the module telescope should+ -- only affect the current module!+ -- Ulf, 2024-11-21 (#7440): We need the wrapper module to have to correct parameters, otherwise+ -- open public of a module created in the telescope will behave incorrectly when applying the+ -- outer module.+ splitModuleTelescope :: C.Telescope -> [C.Telescope]+ splitModuleTelescope [] = [[]]+ splitModuleTelescope (b : tel) =+ case b of+ C.TLet _ ds | any needsWrapper ds -> [] : addBind b (splitModuleTelescope tel)+ _ -> addBind b $ splitModuleTelescope tel+ where+ addBind b (tel : ms) = (b : tel) : ms+ addBind _ [] = __IMPOSSIBLE__++ needsWrapper C.ModuleMacro{} = True+ needsWrapper C.Open{} = True+ needsWrapper C.Import{} = True -- not __IMPOSSIBLE__, see Issue #1718+ -- However, it does not matter what we return here, as this will+ -- become an error later: "Not a valid let-declaration".+ -- (Andreas, 2015-11-17)+ needsWrapper (C.Mutual _ ds) = any needsWrapper ds+ needsWrapper (C.Abstract _ ds) = any needsWrapper ds+ needsWrapper (C.Private _ _ ds) = any needsWrapper ds+ needsWrapper _ = False++ checkWrappedModules :: Access -> [C.Telescope] -> ScopeM A.Declaration+ checkWrappedModules _ [] = __IMPOSSIBLE__+ checkWrappedModules p [tel] = scopeCheckNiceModule_ r p name tel checkDs+ checkWrappedModules p (tel : tels) =+ scopeCheckNiceModule_ r p noName_ tel $ singleton <$>+ checkWrappedModules PublicAccess tels -- Inner modules are PublicAccess (see #4350)++ -- The actual workhorse:+ scopeCheckNiceModule_ :: Range -> Access -> C.Name -> C.Telescope -> ScopeM [A.Declaration] -> ScopeM A.Declaration+ scopeCheckNiceModule_ r p name tel checkDs = do++ -- Check whether we are dealing with an anonymous module.+ -- This corresponds to a Coq/LEGO section.+ (name, p', open) <- do+ if isNoName name then do+ (i :: NameId) <- fresh+ return (C.NoName (getRange name) i, privateAccessInserted, True)+ else return (name, p, False)++ -- Check and bind the module, using the supplied check for its contents.+ aname <- toAbstract (NewModuleName name)+ d <- snd <$> do+ scopeCheckModule r e (C.QName name) aname tel checkDs+ bindModule p' name aname++ -- If the module was anonymous open it public+ -- unless it's private, in which case we just open it (#2099)+ when open $+ void $ -- We can discard the returned default A.ImportDirective.+ openModule empty TopOpenModule (Just aname) (C.QName name) $+ defaultImportDir { publicOpen = boolToMaybe (p == PublicAccess) empty }+ return d++-- | We for now disallow let-bindings in @data@ and @record@ telescopes.+-- This due "nested datatypes"; there is no easy interpretation of+-- @+-- data D (A : Set) (open M A) (b : B) : Set where+-- c : D (A × A) b → D A b+-- @+-- where @B@ is brought in scope by @open M A@.++class EnsureNoLetStms a where+ ensureNoLetStms :: a -> ScopeM ()++ default ensureNoLetStms :: (Foldable t, EnsureNoLetStms b, t b ~ a) => a -> ScopeM ()+ ensureNoLetStms = traverse_ ensureNoLetStms++instance EnsureNoLetStms C.Binder where+ ensureNoLetStms arg@(C.Binder p _ n) =+ when (isJust p) $ typeError $ IllegalPatternInTelescope arg++instance EnsureNoLetStms C.TypedBinding where+ ensureNoLetStms = \case+ tb@C.TLet{} -> typeError $ IllegalLetInTelescope tb+ C.TBind _ xs _ -> traverse_ (ensureNoLetStms . namedArg) xs++instance EnsureNoLetStms a => EnsureNoLetStms (LamBinding' a) where+ ensureNoLetStms = \case+ -- GA: DO NOT use traverse here: `LamBinding'` only uses its parameter in+ -- the DomainFull constructor so we would miss out on some potentially+ -- illegal lets! Cf. #4402+ C.DomainFree a -> ensureNoLetStms a+ C.DomainFull a -> ensureNoLetStms a++instance EnsureNoLetStms a => EnsureNoLetStms (Named_ a) where+instance EnsureNoLetStms a => EnsureNoLetStms (NamedArg a) where+instance EnsureNoLetStms a => EnsureNoLetStms [a] where+++-- | Returns the scope inside the checked module.+scopeCheckModule+ :: Range -- ^ The range of the module.+ -> Erased -- ^ Is the module erased?+ -> C.QName -- ^ The concrete name of the module.+ -> A.ModuleName -- ^ The abstract name of the module.+ -> C.Telescope -- ^ The module telescope.+ -> ScopeM [A.Declaration] -- ^ The code for checking the module contents.+ -> ScopeM (ScopeInfo, A.Declaration)+ -- ^ The returned declaration is an 'A.Section'.+scopeCheckModule r e x qm tel checkDs = do+ printScope "module" 40 $ "checking module " ++ prettyShow x+ -- Andreas, 2013-12-10: Telescope does not live in the new module+ -- but its parent, so check it before entering the new module.+ -- This is important for Nicolas Pouillard's open parametrized modules+ -- statements inside telescopes.+ res <- withLocalVars $ do+ tel <- toAbstract (GenTel tel)+ withCurrentModule qm $ do+ -- pushScope m+ -- qm <- getCurrentModule+ printScope "module" 40 $ "inside module " ++ prettyShow x+ ds <- checkDs+ scope <- getScope+ return (scope, A.Section r e (qm `withRangesOfQ` x) tel ds)++ -- Binding is done by the caller+ printScope "module" 40 $ "after module " ++ prettyShow x+ return res++-- | Temporary data type to scope check a file.+data TopLevel a = TopLevel+ { topLevelSourceFile :: SourceFile+ -- ^ The file from which we loaded this module.+ , topLevelExpectedName :: TopLevelModuleName+ -- ^ The expected module name+ -- (coming from the import statement that triggered scope checking this file).+ , topLevelTheThing :: a+ -- ^ The file content.+ }++data TopLevelInfo = TopLevelInfo+ { topLevelDecls :: [A.Declaration]+ , topLevelScope :: ScopeInfo -- ^ as seen from inside the module+ }++-- | The top-level module name.++topLevelModuleName :: TopLevelInfo -> A.ModuleName+topLevelModuleName = (^. scopeCurrent) . topLevelScope++-- | Top-level declarations are always+-- @+-- (import|open)* -- a bunch of possibly opened imports+-- module ThisModule ... -- the top-level module of this file+-- @+instance ToAbstract (TopLevel [C.Declaration]) where+ type AbsOfCon (TopLevel [C.Declaration]) = TopLevelInfo++ toAbstract (TopLevel src expectedMName ds) =+ -- A file is a bunch of preliminary decls (imports etc.)+ -- plus a single module decl.+ case C.spanAllowedBeforeModule ds of++ -- If there are declarations after the top-level module+ -- we have to report a parse error here.+ (_, C.Module{} : d : _) -> setCurrentRange d $ typeError DeclarationsAfterTopLevelModule++ -- Otherwise, proceed.+ (outsideDecls, [ C.Module r e m0 tel insideDecls ]) -> do+ -- If the module name is _ compute the name from the file path+ (m, top) <- if isNoName m0+ then do+ -- Andreas, 2017-07-28, issue #1077+ -- Check if the insideDecls end in a single module which has the same+ -- name as the file. In this case, it is highly likely that the user+ -- put some non-allowed declarations before the top-level module in error.+ -- Andreas, 2017-10-19, issue #2808+ -- Widen this check to:+ -- If the first module of the insideDecls has the same name as the file,+ -- report an error.+ case flip span insideDecls $ \case { C.Module{} -> False; _ -> True } of+ (ds0, (C.Module _ _ m1 _ _ : _))+ | rawTopLevelModuleNameForQName m1 ==+ rawTopLevelModuleName expectedMName+ -- If the anonymous module comes from the user,+ -- the range cannot be the beginningOfFile.+ -- That is the range if the parser inserted the anon. module.+ , r == beginningOfFile (getRange insideDecls) -> do++ -- GA #4888: We know we are in a bad place. But we still scopecheck+ -- the initial segment on the off chance we generate a better error+ -- message.+ void importPrimitives+ void $ scopeCheckDeclarations outsideDecls+ void $ scopeCheckDeclarations ds0+ -- Fail with a crude error otherwise+ setCurrentRange ds0 $ typeError IllegalDeclarationBeforeTopLevelModule++ -- Otherwise, reconstruct the top-level module name+ _ -> do+ file <- srcFilePath src+ let m = C.QName $ setRange (getRange m0) $+ C.simpleName $ stringToRawName $+ rootNameModule file+ top <- TCM.topLevelModuleName+ (rawTopLevelModuleNameForQName m){ rawModuleNameInferred = True }+ -- Andreas, 2026-03-01, issue #6173+ -- Need to make sure the reconstructed module name+ -- matches the one we use to import it,+ -- otherwise we get internal errors later.+ checkModuleName top src (Just expectedMName)+ return (m, top)+ -- Andreas, 2017-05-17, issue #2574, keep name as jump target!+ -- Andreas, 2016-07-12, ALTERNATIVE:+ -- -- We assign an anonymous file module the name expected from+ -- -- its import. For flat file structures, this is the same.+ -- -- For hierarchical file structures, this reverses the behavior:+ -- -- Loading the file by itself will fail, but it can be imported.+ -- -- The previous behavior is: it can be loaded by itself, but not+ -- -- be imported+ -- then return $ C.fromTopLevelModuleName expectedMName+ else do+ -- Andreas, 2014-03-28 Issue 1078+ -- We need to check the module name against the file name here.+ -- Otherwise one could sneak in a lie and confuse the scope+ -- checker.+ top <- TCM.topLevelModuleName+ (rawTopLevelModuleNameForQName m0)+ checkModuleName top src (Just expectedMName)+ return (m0, top)+ setTopLevelModule top+ am <- toAbstract (NewModuleQName m)+ primitiveImport <- importPrimitives+ -- Scope check the declarations outside+ outsideDecls <- scopeCheckDeclarations outsideDecls+ (insideScope, insideDecl) <- scopeCheckModule r e m am tel $+ scopeCheckDeclarations insideDecls+ -- Andreas, 2020-05-13, issue #1804, #4647+ -- Do not eagerly remove private definitions, only when serializing+ -- let scope = over scopeModules (fmap $ restrictLocalPrivate am) insideScope+ let scope = insideScope+ setScope scope++ -- While scope-checking the top-level module we might have+ -- encountered several (possibly nested) opaque blocks. We+ -- must now ensure that these have transitively-closed+ -- unfolding sets.+ saturateOpaqueBlocks++ return $ TopLevelInfo (primitiveImport ++ outsideDecls ++ [ insideDecl ]) scope++ -- We hit a declaration that is not allowed before the top-level module:+ (_, d : _) -> setCurrentRange d $ typeError IllegalDeclarationBeforeTopLevelModule++ -- We already inserted the missing top-level module, see+ -- 'Agda.Syntax.Parser.Parser.figureOutTopLevelModule',+ -- thus, the case of no top-level module is impossible:+ _ -> __IMPOSSIBLE__+++-- | Declaration @open import Agda.Primitive using (Set)@ when 'optImportSorts'.+-- @Prop@ is added when 'optProp', and @SSet@ when 'optTwoLevel'.+importPrimitives :: ScopeM [A.Declaration]+importPrimitives = do+ ifNotM (optImportSorts <$> pragmaOptions) (return []) {- else -} do+ prop <- isPropEnabled+ twoLevel <- isTwoLevelEnabled+ -- Add implicit `open import Agda.Primitive using (Prop; Set; SSet)`+ let agdaPrimitiveName = Qual (C.simpleName "Agda") $ C.QName $ C.simpleName "Primitive"+ usingDirective = map (ImportedName . C.simpleName) $ concat+ [ [ "Prop" | prop ]+ , [ "Set" | True ]+ , [ "SSet" | twoLevel ]+ ]+ directives = ImportDirective noRange (Using usingDirective) [] [] Nothing+ importAgdaPrimitive = [C.Import (C.DoOpen empty) empty agdaPrimitiveName empty directives]+ -- We don't want UnusedImports warnings when importing the primitives,+ -- since the open statement was not assembled by the user.+ locallyTCState stWarningSet (Set.\\ unusedImportsWarnings) do+ scopeCheckDeclarations importAgdaPrimitive++-- | runs Syntax.Concrete.Definitions.niceDeclarations on main module+niceDecls :: DoWarn -> [C.Declaration] -> ([NiceDeclaration] -> ScopeM a) -> ScopeM a+niceDecls warn ds ret = setCurrentRange ds $ computeFixitiesAndPolarities warn ds $ do++ -- Some pragmas are not allowed in safe mode unless we are in a builtin module.+ -- So we need to tell the nicifier whether it should yell about unsafe pragmas.+ isSafe <- Lens.getSafeMode <$> pragmaOptions+ safeButNotBuiltin <- and2M+ -- NB: BlockArguments allow bullet-point style argument lists using @do@, hehe!+ do pure isSafe+ do not <$> do isBuiltinModuleWithSafePostulates . fromMaybe __IMPOSSIBLE__ =<< viewTC eCurrentPath++ -- We need to pass the fixities to the nicifier for clause grouping.+ fixs <- useScope scopeFixities+ niceEnv <- NiceEnv safeButNotBuiltin <$> viewTC eCheckingWhere++ -- Run nicifier.+ let (result, warns) = runNice niceEnv $ niceDeclarations fixs ds++ -- Respect the @DoWarn@ directive. For this to be sound, we need to know for+ -- sure that each @Declaration@ is checked at least once with @DoWarn@.+ unless (warn == NoWarn || null warns) $ do+ -- If there are some warnings and the --safe flag is set,+ -- we check that none of the NiceWarnings are fatal+ when isSafe $ do+ let (errs, ws) = List.partition unsafeDeclarationWarning warns+ -- If some of them are, we fail+ List1.unlessNull errs \ errs -> do+ List1.unlessNull ws \ ws -> warnings $ fmap NicifierIssue ws+ tcerrs <- mapM (warning_ . NicifierIssue) errs+ setCurrentRange errs $ typeError $ NonFatalErrors $ Set1.fromList tcerrs+ -- Otherwise we simply record the warnings+ mapM_ (\ w -> warning' (dwLocation w) $ NicifierIssue w) warns+ case result of+ Left (DeclarationException loc e) -> do+ reportSLn "error" 2 $ "Error raised at " ++ prettyShow loc+ setCurrentRange e $ typeError $ NicifierError e+ Right ds -> ret ds++-- | Wrapper to avoid instance conflict with generic list instance.+scopeCheckDeclarations :: [C.Declaration] -> ScopeM [A.Declaration]+scopeCheckDeclarations ds = niceDecls DoWarn ds \ niceds -> catMaybes <$> toAbstract niceds++-- | Where did these 'LetDef's come from?+data LetDefOrigin+ = ExprLetDef+ -- ^ A let expression or do statement+ | RecordLetDef+ -- ^ Definitions in a record declaration, before the last field+ deriving (Eq, Show)++data LetDefs = LetDefs LetDefOrigin (List1 C.Declaration)++instance ToAbstract LetDefs where+ type AbsOfCon LetDefs = [A.LetBinding]++ toAbstract :: LetDefs -> ScopeM (AbsOfCon LetDefs)+ toAbstract (LetDefs wh ds) =+ List1.concat <$> niceDecls DoWarn (List1.toList ds) \ nds -> mapM (scopeCheckLetDef wh) nds++-- | Raise appropriate (error-)warnings for if a declaration with+-- illegal access, macro flag, or abstractness appear in a let+-- expression.+checkLetDefInfo :: LetDefOrigin -> Access -> IsMacro -> IsAbstract -> ScopeM ()+checkLetDefInfo wh access macro abstract = do+ when (abstract == AbstractDef) $ warning AbstractInLetBindings++ when (macro == MacroDef) $ warning MacroInLetBindings++ case access of+ -- Marking a let declaration as private should only raise a warning+ -- in explicit, user-written expressions.+ --+ -- It should not raise a warning when scope-checking the type of a+ -- record constructor (it has an effect there).+ PrivateAccess rng _+ | wh == ExprLetDef -> scopeWarning (UselessPrivate rng)+ _ -> pure ()++scopeCheckLetDef :: LetDefOrigin -> NiceDeclaration -> ScopeM (List1 A.LetBinding)+scopeCheckLetDef wh d = setCurrentRange d do+ case d of+ NiceMutual _ _ _ _ d@(C.FunSig _ access _ instanc macro info _ _ x t :| [C.FunDef _ _ abstract _ _ _ _ (cl :| [])]) -> do+ checkLetDefInfo wh access macro abstract++ t <- toAbstract t+ -- We bind the name here to make sure it's in scope for the LHS (#917).+ -- It's unbound for the RHS in letToAbstract.+ fx <- getConcreteFixity x++ x <- A.unBind <$> toAbstract (NewName LetBound $ mkBoundName x fx)+ (x', e) <- letToAbstract cl++ -- There are sometimes two instances of the let-bound variable,+ -- one declaration and one definition (see issue #1618).+ -- Andreas, 2015-08-27 keeping both the range of x and x' solves Issue 1618.+ -- The situation is+ -- @+ -- let y : t+ -- y = e+ -- @+ -- and we need to store the ranges of both occurences of y so that+ -- the highlighter does the right thing.+ let x2 = setRange (fuseRange x x') x++ -- If InstanceDef set info to Instance+ let info' = case instanc of+ InstanceDef _ -> makeInstance info+ NotInstanceDef -> info++ return $+ A.LetBind (LetRange $ getRange d) info' (A.mkBindName x2) t e :|+ []++ -- Function signature without a body+ C.Axiom _ acc abs instanc info x t -> do+ checkLetDefInfo wh acc NotMacroDef abs++ t <- toAbstract t+ fx <- getConcreteFixity x+ x <- toAbstract (NewName LetBound $ mkBoundName x fx)++ mod <- currentModule+ checkAllowedAxiom info $ A.qualify mod (unBind x)++ let+ info' = case instanc of+ InstanceDef _ -> makeInstance info+ NotInstanceDef -> info++ pure $ A.LetAxiom (LetRange $ getRange d) info' x t :| []++ -- irrefutable let binding, like .(x , y) = rhs+ NiceFunClause r PublicAccess ConcreteDef tc cc catchall d@(C.FunClause ai lhs@(C.LHS p0 [] []) rhs0 whcl ca) -> do+ noWhereInLetBinding whcl+ rhs <- letBindingMustHaveRHS rhs0+ -- Expand puns if optHiddenArgumentPuns is True.+ p0 <- expandPunsOpt p0+ mp <- setCurrentRange p0 $+ (Right <$> parsePattern p0)+ `catchError`+ (return . Left)+ case mp of+ Right p -> do+ rhs <- toAbstract rhs+ setCurrentRange p0 $ do+ p <- toAbstract p+ checkValidLetPattern p+ checkPatternLinearity p $ \ys ->+ typeError $ RepeatedVariablesInPattern ys+ bindVarsToBind+ p <- toAbstract p+ return $ singleton $ A.LetPatBind (LetRange r) ai p rhs+ -- It's not a record pattern, so it should be a prefix left-hand side+ Left err ->+ case definedName p0 of+ Nothing -> throwError err+ Just x -> scopeCheckLetDef wh $ NiceMutual empty tc cc YesPositivityCheck+ (C.FunSig r PublicAccess ConcreteDef NotInstanceDef NotMacroDef+ info tc cc x (C.Underscore (getRange x) Nothing)+ :| [ C.FunDef r __IMPOSSIBLE__ ConcreteDef NotInstanceDef __IMPOSSIBLE__ __IMPOSSIBLE__ __IMPOSSIBLE__+ $ singleton $ C.Clause x (ca <> catchall) ai lhs (C.RHS rhs) NoWhere []+ ])+ where info = setOrigin Inserted ai+ where+ definedName (C.IdentP _ (C.QName x)) = Just x+ definedName C.IdentP{} = Nothing+ definedName (C.RawAppP _ (List2 p _ _)) = definedName p+ definedName (C.ParenP _ p) = definedName p+ definedName C.WildP{} = Nothing -- for instance let _ + x = x in ... (not allowed)+ definedName C.AbsurdP{} = Nothing+ definedName C.AsP{} = Nothing+ definedName C.DotP{} = Nothing+ definedName C.EqualP{} = Nothing+ definedName C.LitP{} = Nothing+ definedName C.RecP{} = Nothing+ definedName C.QuoteP{} = Nothing+ definedName C.HiddenP{} = Nothing -- Not impossible, see issue #2291+ definedName C.InstanceP{} = Nothing+ definedName C.WithP{} = Nothing+ definedName C.AppP{} = Nothing -- Not impossible, see issue #4586+ definedName C.OpAppP{} = __IMPOSSIBLE__+ definedName C.EllipsisP{} = Nothing -- Not impossible, see issue #3937++ -- You can't open public in a let+ NiceOpen kwr x dir -> do+ dir <- uselessPublic UselessPublicLet dir+ m <- toAbstract (OldModuleName x)+ adir <- openModule_ kwr LetOpenModule x dir+ let minfo = ModuleInfo+ { minfoRange = getRange (kwr, x, dir)+ , minfoAsName = Nothing+ , minfoAsTo = renamingRange dir+ , minfoOpenShort = DoOpen kwr+ , minfoDirective = Just dir+ }+ return $ singleton $ A.LetOpen minfo m adir++ NiceModuleMacro r p erased x modapp open dir -> do+ dir <- uselessPublic UselessPublicLet dir+ -- Andreas, 2014-10-09, Issue 1299: module macros in lets need+ -- to be private+ singleton <$> checkModuleMacro LetApply LetOpenModule r+ privateAccessInserted erased x modapp open dir++ _ -> notAValidLetBinding Nothing++ where+ letToAbstract (C.Clause top _catchall _ai (C.LHS p [] []) rhs0 wh []) = do+ noWhereInLetBinding wh+ rhs <- letBindingMustHaveRHS rhs0+ (x, args) <- do+ res <- setCurrentRange p $ parseLHS NoDisplayLHS (C.QName top) p+ case res of+ C.LHSHead x args -> return (x, args)+ C.LHSProj{} -> notAValidLetBinding $ Just CopatternsNotAllowed+ C.LHSWith{} -> __IMPOSSIBLE__ -- notAValidLetBinding $ Just WithPatternsNotAllowed+ C.LHSEllipsis{} -> __IMPOSSIBLE__ -- notAValidLetBinding $ Just EllipsisNotAllowed++ e <- localToAbstract args $ \args -> do+ bindVarsToBind+ -- Make sure to unbind the function name in the RHS, since lets are non-recursive.+ rhs <- unbindVariable top $ toAbstract rhs+ foldM lambda rhs (reverse args) -- just reverse because these are DomainFree+ return (x, e)++ letToAbstract _ = notAValidLetBinding Nothing++ -- These patterns all have a chance of being accepted in a lambda:+ allowedPat A.VarP{} = True+ allowedPat A.ConP{} = True+ allowedPat A.WildP{} = True+ allowedPat (A.AsP _ _ x) = allowedPat x+ allowedPat (A.RecP _ _ as) = all (allowedPat . view exprFieldA) as+ allowedPat (A.PatternSynP _ _ as) = all (allowedPat . namedArg) as++ -- These have no chance:+ allowedPat A.AbsurdP{} = False+ allowedPat A.ProjP{} = False+ allowedPat A.DefP{} = False+ allowedPat A.EqualP{} = False+ allowedPat A.WithP{} = False+ allowedPat A.DotP{} = False+ allowedPat A.LitP{} = False++ patternName (A.VarP bn) = Just bn+ patternName (A.AsP _ bn _) = Just bn+ patternName _ = Nothing++ -- Named patterns not allowed in let definitions+ lambda :: A.Expr -> NamedArg (A.Pattern' C.Expr) -> TCM A.Expr+ lambda e ai@(Arg info (Named thing pat)) | allowedPat pat = do+ let+ i = ExprRange (fuseRange pat e)++ pat <- toAbstract pat++ bn <- case pat of+ A.VarP bn -> pure bn+ A.AsP _ bn _ -> pure bn+ _ -> fmap mkBindName . freshAbstractName_ =<< freshConcreteName (getRange pat) 0 patternInTeleName++ -- Annoyingly, for the lambdas to be elaborated properly, we+ -- have to generate domainful binders. Domain-free binders can+ -- not be named (or have pattern matching!).+ --+ -- Moreover, we need to avoid generating named patterns that are+ -- like {B = B @ B}.++ let+ pat' = case pat of+ A.VarP{} -> Nothing+ pat -> Just pat+ binder = Arg info (Named thing (A.Binder pat' InsertedBinderName bn)) :| []++ pure $ A.Lam i (A.DomainFull (A.TBind (getRange ai) empty binder (A.Underscore empty))) e++ lambda _ _ = notAValidLetBinding Nothing++ noWhereInLetBinding :: C.WhereClause -> ScopeM ()+ noWhereInLetBinding = \case+ NoWhere -> return ()+ wh -> setCurrentRange wh $ notAValidLetBinding $ Just WhereClausesNotAllowed+ letBindingMustHaveRHS :: C.RHS -> ScopeM C.Expr+ letBindingMustHaveRHS = \case+ C.RHS e -> return e+ C.AbsurdRHS -> notAValidLetBinding $ Just MissingRHS++ -- Only record patterns allowed, but we do not exclude data constructors here.+ -- They will fail in the type checker.+ checkValidLetPattern :: A.Pattern' e -> ScopeM ()+ checkValidLetPattern a = unless (allowedPat a) do+ notAValidLetBinding $ Just NotAValidLetPattern++checkFieldArgInfo :: Bool -> ArgInfo -> ScopeM ArgInfo+checkFieldArgInfo warn =+ ensureLeftAdjoint msg >=>+ ensureMixedPolarity msg >=>+ ensureNotRew msg+ where+ msg = if warn then Just "field" else Nothing++instance ToAbstract NiceDeclaration where+ type AbsOfCon NiceDeclaration = Maybe A.Declaration++ toAbstract d = annotateDecls $+ traceS "scope.decl.trace" 50+ [ "scope checking declaration"+ , " " ++ prettyShow d+ ] $+ traceS "scope.decl.trace" 80 -- keep this debug message for testing issue #4016+ [ "scope checking declaration (raw)"+ , " " ++ show d+ ] $+ traceCall (ScopeCheckDeclaration d) $+ -- Andreas, 2015-10-05, Issue 1677:+ -- We record in the environment whether we are scope checking an+ -- abstract definition. This way, we can propagate this attribute+ -- the extended lambdas.+ applyWhenJust (niceHasAbstract d)+ (\ a -> localTC (set eAbstractMode (aDefToMode a))) $+ case d of++ -- Axiom (actual postulate)+ C.Axiom r p a i rel x t -> do+ (y, decl) <- toAbstractNiceAxiom AxiomName d+ checkAllowedAxiom rel y+ -- check the postulate+ return $ singleton decl++ C.NiceGeneralize r p i tac x t -> do+ reportSLn "scope.decl" 30 $ "found nice generalize: " ++ prettyShow x+ tac <- traverse (toAbstractCtx TopCtx) tac+ t_ <- toAbstractCtx TopCtx t+ let (s, t) = unGeneralized t_+ reportSLn "scope.decl" 50 $ "generalizations: " ++ show (Set.toList s, t)+ f <- getConcreteFixity x+ y <- freshAbstractQName f x+ bindName p GeneralizeName x y+ let info = (mkDefInfo x f p ConcreteDef r) { defTactic = tac }+ return $ singleton $ A.Generalize s info i y t++ -- Fields+ C.NiceField r p a i tac x (Arg ai t) -> do+ unless (p == PublicAccess) $ typeError PrivateRecordField+ ai <- checkFieldArgInfo False ai -- we already warned in recordConstructorType+ tac <- traverse (toAbstractCtx TopCtx) tac+ -- Interaction points for record fields have already been introduced+ -- when checking the type of the record constructor.+ -- To avoid introducing interaction points (IP) twice, we turn+ -- all question marks to underscores. (See issue 1138.)+ let maskIP (C.QuestionMark r _) = C.Underscore r Nothing+ maskIP e = e+ t <- toAbstractCtx TopCtx $ mapExpr maskIP t+ f <- getConcreteFixity x+ y <- freshAbstractQName f x+ -- Andreas, 2018-06-09 issue #2170+ -- We want dependent irrelevance without irrelevant projections,+ -- thus, do not disable irrelevant projections via the scope checker.+ -- irrProj <- optIrrelevantProjections <$> pragmaOptions+ -- unless (isIrrelevant t && not irrProj) $+ -- -- Andreas, 2010-09-24: irrelevant fields are not in scope+ -- -- this ensures that projections out of irrelevant fields cannot occur+ -- -- Ulf: unless you turn on --irrelevant-projections+ bindName' p FldName (instanceMetadata i) x y+ let info = (mkDefInfoInstance x f p a i NotMacroDef r) { defTactic = tac }+ return $ singleton $ A.Field info y (Arg ai t)++ -- Primitive function+ PrimitiveFunction r p a x t -> notAffectedByOpaque $ do+ t' <- traverse (toAbstractCtx TopCtx) t+ f <- getConcreteFixity x+ y <- freshAbstractQName f x+ bindName p PrimName x y+ unfoldFunction y+ let di = mkDefInfo x f p a r+ return $ singleton $ A.Primitive di y t'++ -- Definitions (possibly mutual)+ NiceMutual kwr tc cc pc ds -> do+ reportSLn "scope.mutual" 40 ("starting checking mutual definitions: " ++ prettyShow ds)+ ds' <- catMaybes <$> toAbstract (List1.toList ds)+ reportSLn "scope.mutual" 40 ("finishing checking mutual definitions")+ -- We only termination check blocks that do not have a measure.+ maybeToList <$> forM (List1.nonEmpty ds') \ ds' ->+ return $ A.Mutual (MutualInfo tc cc pc (fuseRange kwr ds)) ds'++ -- Type signatures+ C.FunSig r p a i m rel _ _ x t -> do+ let kind = if m == MacroDef then MacroName else FunName+ singleton . snd <$> toAbstractNiceAxiom kind (C.Axiom r p a i rel x t)++ -- Function definitions+ C.FunDef r ds a i _ _ x cs -> do+ printLocals 30 $ "checking def " ++ prettyShow x+ x' <- toAbstractOldName x+ cs <- toAbstract cs+ -- Andreas, 2017-12-04 the name must reside in the current module+ unlessM ((A.qnameModule x' ==) <$> getCurrentModule) $+ __IMPOSSIBLE__+ f <- getConcreteFixity x++ unfoldFunction x'+ di <- updateDefInfoOpacity (mkDefInfoInstance x f PublicAccess a i NotMacroDef r)+ return $ singleton $ A.FunDef di x' cs++ -- Uncategorized function clauses+ C.NiceFunClause _ _ _ _ _ _ (C.FunClause _ lhs _ _ _) ->+ typeError $ MissingTypeSignature $ MissingFunctionSignature lhs+ C.NiceFunClause{} -> __IMPOSSIBLE__++ -- Data definitions+ C.NiceDataSig r er p a pc uc x ls t -> do+ reportSLn "scope.data.sig" 40 ("checking DataSig for " ++ prettyShow x)+ singleton <$> scopeCheckDataOrRecSig IsData r er p a pc uc x ls t++ C.NiceDataDef r o a pc uc x pars cons -> singleton <$>+ scopeCheckDataDef r o a pc uc x pars cons++ -- Record definitions (mucho interesting)+ C.NiceRecSig r er p a pc uc eta x ls t -> do+ singleton <$> scopeCheckDataOrRecSig (IsRecord eta) r er p a pc uc x ls t++ C.NiceRecDef r o a pc uc eta x directives pars fields -> singleton <$>+ scopeCheckRecDef r o a pc uc eta x directives pars fields++ NiceModule r p a e x@(C.QName name) tel ds -> notAffectedByOpaque $ do+ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checking NiceModule " ++ prettyShow x+ ]++ adecl <- traceCall (ScopeCheckDeclaration $+ NiceModule r p a e x tel []) $ do+ scopeCheckNiceModule r p e name tel $+ scopeCheckDeclarations ds++ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checked NiceModule " ++ prettyShow x+ , nest 2 $ prettyA adecl+ ]+ return $ singleton adecl++ NiceModule _ _ _ _ m@C.Qual{} _ _ -> typeError QualifiedLocalModule++ NiceModuleMacro r p e x modapp open dir -> do+ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checking NiceModuleMacro " ++ prettyShow x+ ]++ adecl <- checkModuleMacro Apply TopOpenModule+ r p e x modapp open dir++ reportSDoc "scope.decl" 70 $ vcat $+ [ text $ "scope checked NiceModuleMacro " ++ prettyShow x+ , nest 2 $ prettyA adecl+ ]+ return $ singleton adecl++ NiceOpen kwr x dir -> do+ (minfo, m, adir) <- checkOpen kwr Nothing x dir+ return $ singleton $ A.Open minfo m adir++ NicePragma r p -> do+ ps <- toAbstract p -- could result in empty list of pragmas+ return $ map (A.Pragma r) ps++ NiceImport doOpen kwR m (Left asClause) dir ->+ -- Case: already parsed @as@ clause.+ scopeCheckImport r m (Just asClause) doOpen dir+ where+ -- The Range of the whole declaration.+ r = getRange (doOpen, kwR, m, asClause, dir)++ NiceImport doOpen kwR m (Right []) dir ->+ -- Case: no module arguments, no @as@ clause.+ scopeCheckImport r m Nothing doOpen dir+ where+ -- The Range of the whole declaration.+ r = getRange (doOpen, kwR, m, dir)++ -- Case: some module arguments+ NiceImport doOpen kwR m (Right es) dir++ -- Subcase: @as@ clause+ | Just (asR, as) <- parseAsClause -> do++ -- Andreas, 2018-11-03, issue #3364, parse expression in as-clause as Name.+ let illformedAs s = setCurrentRange as $ do+ -- If @as@ is followed by something that is not a simple name,+ -- throw a warning and discard the as-clause.+ Nothing <$ warning (IllformedAsClause s)+ m' <- case as of+ -- Ok if no as-clause or it (already) contains a Name.+ Right asName -> return $ Just asName+ Left (C.Ident (C.QName asName)) -> return $ Just asName+ Left (C.Underscore r _) -> return $ Just $ C.noName r+ Left (C.Ident C.Qual{}) -> illformedAs "; a qualified name is not allowed here"+ Left e -> illformedAs ""++ if null initArgs then+ scopeCheckImport (getRange (doOpen, kwR, m, asR, m', dir)) m (m' <&> (`AsName` asR)) doOpen dir+ else do+ snoc <$> impStm asR+ <*> appStm (fromMaybe fresh' m') initArgs++ -- Subcase: no @as@ clause+ | DontOpen <- doOpen -> [] <$ do+ declarationWarning $ UselessImport fullRange+ | otherwise -> do+ snoc <$> impStm noRange+ <*> appStm (noName $ beginningOf $ getRange m) es++ where+ fullRange = getRange (doOpen, kwR, m, es, dir)+ impStm asR =+ scopeCheckImport (getRange (kwR, m))+ m (Just (AsName fresh asR))+ DontOpen defaultImportDir+ appStm m' es =+ checkModuleMacro Apply TopOpenModule (getRange (doOpen, m, es, dir))+ (PrivateAccess empty Inserted)+ defaultErased m' (C.SectionApp (getRange es) [] (C.QName fresh) es)+ doOpen dir+ (initArgs, last2Args) = splitAt (length es - 2) es+ parseAsClause = case last2Args of+ [ Ident (C.QName (C.Name asR InScope (Id x :| []))), e ]+ -- Andreas, 2018-11-03, issue #3364, accept anything after 'as'+ -- but require it to be a 'Name' in the scope checker.+ | rawNameToString x == "as" -> Just . (asR,) $+ if | Ident (C.QName m') <- e -> Right m'+ | otherwise -> Left e+ _ -> Nothing+ mkFresh i = C.Name (getRange m) C.NotInScope $ singleton $ Id $ stringToRawName $ ".#" ++ prettyShow m ++ "-" ++ show i+ unique = hashString $ prettyShow $ getRangeWithoutFile fullRange+ -- turn range into unique id, but delete file path+ -- which is absolute and messes up suite of failing tests+ -- (different hashs on different installations)+ -- TODO: Don't use (insecure) hashes in this way.+ fresh = mkFresh unique+ fresh' = mkFresh $ unique + 1++ NiceUnquoteDecl r p a i tc cc xs e -> do+ fxs <- mapM getConcreteFixity xs+ ys <- zipWithM freshAbstractQName fxs xs+ let meta = instanceMetadata i+ zipWithM_ (bindName' p QuotableName meta) xs ys+ e <- toAbstract e+ zipWithM_ (rebindName p OtherDefName meta) xs ys+ let mi = MutualInfo tc cc YesPositivityCheck r+ mapM_ unfoldFunction ys+ opaque <- contextIsOpaque+ return $ singleton $ A.Mutual mi $ singleton $+ A.UnquoteDecl mi+ [ (mkDefInfoInstance x fx p a i NotMacroDef r) { Info.defOpaque = opaque } | (fx, x) <- zip fxs xs ]+ ys e++ NiceUnquoteDef r p a _ _ xs e -> do+ fxs <- mapM getConcreteFixity xs+ ys <- mapM toAbstractOldName xs+ zipWithM_ (rebindName p QuotableName noMetadata) xs ys+ e <- toAbstract e+ zipWithM_ (rebindName p OtherDefName noMetadata) xs ys+ mapM_ unfoldFunction ys+ opaque <- contextIsOpaque+ return $ singleton $+ A.UnquoteDef+ [ (mkDefInfo x fx PublicAccess a r) { Info.defOpaque = opaque } | (fx, x) <- zip fxs xs ]+ ys e++ NiceUnquoteData r p a pc uc x cs e -> notAffectedByOpaque $ do+ fx <- getConcreteFixity x+ x' <- freshAbstractQName fx x+ bindName p QuotableName x x'++ -- Create the module for the qualified constructors+ checkForModuleClash x+ let m = qnameToMName x'+ createModule (Just IsDataModule) m+ bindModule p x m -- make it a proper module++ cs' <- mapM (bindUnquoteConstructorName m p) cs++ e <- withCurrentModule m $ toAbstract e++ rebindName p DataName noMetadata x x'+ zipWithM_ (rebindName p ConName noMetadata) cs cs'+ withCurrentModule m $ zipWithM_ (rebindName p ConName noMetadata) cs cs'++ fcs <- mapM getConcreteFixity cs+ let mi = MutualInfo TerminationCheck YesCoverageCheck pc r+ return $ singleton $+ A.Mutual mi $ singleton $+ A.UnquoteData+ [ mkDefInfo x fx p a r ]+ x'+ uc+ [ mkDefInfo c fc p a r | (fc, c) <- zip fcs cs]+ cs'+ e+++ NicePatternSyn r a n as p -> do+ reportSLn "scope.pat" 30 $ "found nice pattern syn: " ++ prettyShow n+ reportSLn "scope.pat" 40 $ "arguments: " ++ prettyShow as+ (as, p) <- withLocalVars $ do+ -- Expand puns if optHiddenArgumentPuns is True.+ p <- parsePatternSyn =<< expandPunsOpt p+ p <- toAbstract p+ when (containsAsPattern p) $+ typeError AsPatternInPatternSynonym+ checkPatternLinearity p $ \ys ->+ typeError $ RepeatedVariablesInPattern ys+ -- Bind the pattern variables accumulated by @ToAbstract Pattern@ applied to the rhs.+ bindVarsToBind+ p <- A.noDotOrEqPattern (typeError DotPatternInPatternSynonym) p+ as <- mapM checkPatSynParam as+ List1.unlessNull (patternVars p List.\\ map whThing as) $ \ xs -> do+ typeError $ UnboundVariablesInPatternSynonym xs+ return (as, p)+ y <- freshAbstractQName' n+ bindName a PatternSynName n y+ -- Expanding pattern synonyms already at definition makes it easier to+ -- fold them back when printing (issue #2762).+ ep <- expandPatternSynonyms p+ modifyPatternSyns (Map.insert y (PatternSynDefn as ep))+ return $ singleton $ A.PatternSynDef y (map (fmap BindName) as) p -- only for highlighting, so use unexpanded version+ where+ checkPatSynParam :: WithHiding C.Name -> ScopeM (WithHiding A.Name)+ checkPatSynParam (WithHiding h x)+ | isUnderscore x = err $ UnusedVariableInPatternSynonym x+ | otherwise = resolveName (C.QName x) >>= \case+ VarName a (PatternBound h')+ | isInstance h, not (isInstance h') -> err $ IllegalInstanceVariableInPatternSynonym x+ | otherwise -> return $ WithHiding h a+ ConstructorName _ ys -> err $ PatternSynonymArgumentShadows IsConstructor x ys+ PatternSynResName ys -> err $ PatternSynonymArgumentShadows IsPatternSynonym x ys+ -- In the remaining cases, the name has not been bound by the pattern syn rhs.+ DefinedName{} -> failure+ FieldName{} -> failure+ VarName _ LambdaBound -> failure+ VarName _ LetBound -> failure+ VarName _ WithBound -> failure+ VarName _ MacroBound -> failure+ UnknownName -> failure+ where+ err = setCurrentRange x . typeError+ failure = err $ UnusedVariableInPatternSynonym x++ d@NiceLoneConstructor{} -> [] <$ do+ declarationWarning $ InvalidConstructorBlock $ getRange d++ d@(NiceOpaque kwr xs decls) -> do+ -- The names in an 'unfolding' clause must be unambiguous names of definitions:+ -- Resolve all the names, and use them as an initial unfolding set:+ names <- catMaybes <$> forM xs \ x -> do+ setCurrentRange x $ unambiguousConOrDef (const . UnfoldingWrongName) x+ -- Generate the identifier for this block:+ oid <- fresh+ -- Record the parent unfolding block, if any:+ parent <- viewTC eCurrentOpaqueId++ let r = getRange d+ stOpaqueBlocks `modifyTCLens` Map.insert oid OpaqueBlock+ { opaqueId = oid+ , opaqueUnfolding = HashSet.fromList names+ , opaqueDecls = mempty+ , opaqueParent = parent+ , opaqueRange = r+ }++ -- Keep going!+ localTC (set eCurrentOpaqueId (Just oid)) do+ out <- catMaybes <$> traverse toAbstract decls+ unless (any interestingOpaqueDecl out) $ setCurrentRange kwr $ warning UselessOpaque+ -- Andreas, 2025-12-12+ -- For reasons of caching, append the UnfoldingDecl (which is only for highlighting purposes)+ -- at the end. Otherwise, any change in the (potentially big) opaque block+ -- will invalidate caching for the whole block.+ -- With UnfoldingDecl at the end, it does not contribute to cache invalidation,+ -- because if something changed in the opaque block, one of its declarations changed+ -- which invalidates the cache for this declaration.+ pure $! out ++! [UnfoldingDecl r names]++declarationWarning :: MonadWarning m => DeclarationWarning' -> m ()+declarationWarning w = withCurrentCallStack \ stk -> do+ warning $ NicifierIssue $ DeclarationWarning stk w++-- | Scope check a data or record signature.+scopeCheckDataOrRecSig ::+ DataOrRecordEta+ -- ^ Whether we are checking a data or record signature.+ -> Range+ -- ^ The range of the data or record signature.+ -> Erased+ -- ^ Whether the data or record type is erased.+ -> Access+ -- ^ Whether the data or record type is private or public.+ -> IsAbstract+ -- ^ Whether the data or record type is abstract.+ -> PositivityCheck+ -- ^ Whether to perform positivity checking.+ -> UniverseCheck+ -- ^ Whether to check the constructors for universe consistency.+ -> C.Name+ -- ^ The name of the data or record type.+ -> C.Parameters+ -- ^ The parameters of the data or record type.+ -> C.Expr+ -- ^ The type of the data or record type.+ -> ScopeM A.Declaration+ -- ^ The resulting data or record signature in abstract syntax.+scopeCheckDataOrRecSig dataOrRec r er p a pc uc x ls t = do+ ensureNoLetStms ls+ withLocalVars $ do+ (ls', t') <- withCheckNoShadowing do+ case dataOrRec of+ IsData -> do+ (,) <$> toAbstract (GenTel $ map makeDomainFull ls)+ <*> toAbstract (C.Generalized t)+ IsRecord _ -> do+ -- Minor hack: record types don't have indices so we include t when+ -- computing generalised parameters, but in the type checker any named+ -- generalizable arguments in the sort should be bound variables.+ (,) <$> (fst <$> toAbstract (GenTelAndType (map makeDomainFull ls) t))+ <*> toAbstract t+ f <- getConcreteFixity x+ x' <- freshAbstractQName f x+ mErr <- bindName'' p namekind (generalizedVarsMetadata $ generalizeTelVars ls') x x'+ whenJust mErr $ \case+ err@(ClashingDefinition cn an _) | qnameModule (clashingQName an) == qnameModule x' -> do+ resolveName (C.QName x) >>= \case+ -- #4435: if a data type signature causes a ClashingDefinition error, and if+ -- the data type name is bound to an Axiom, then the error may be caused by+ -- the illegal type signature. Convert the NiceDataSig into a NiceDataDef+ -- (which removes the type signature) and suggest it as a possible fix.+ DefinedName p ax NoSuffix | anameKind ax == AxiomName -> do+ let suggestion = case dataOrRec of+ IsData -> NiceDataDef r Inserted a pc uc x (parametersToDefParameters ls) []+ IsRecord eta -> NiceRecDef r Inserted a pc uc eta x [] (parametersToDefParameters ls) []+ typeError $ ClashingDefinition cn an (Just suggestion)+ _ -> typeError err+ otherErr -> typeError otherErr+ return $ mkSig (mkDefInfo x f p a r) er x' ls' t'+ where+ namekind = case dataOrRec of+ IsData -> DataName+ IsRecord _ -> RecName+ mkSig = case dataOrRec of+ IsData -> A.DataSig+ IsRecord _ -> A.RecSig++-- | Scope check a data definition.+-- The data signature must have been checked already.+scopeCheckDataDef ::+ Range+ -- ^ The range of the data definition.+ -> Origin+ -- ^ The origin of the data definition.+ -- 'UserWritten' when the definition was written separately from the signature.+ -- 'Inserted' when there was no separate signature.+ -> IsAbstract+ -- ^ Whether the data definition is abstract.+ -> PositivityCheck+ -- ^ Whether to report positivity errors for this data type.+ -> UniverseCheck+ -- ^ Whether to check constructors' types for universe consistency.+ -> C.Name+ -- ^ The name of the data type.+ -> C.DefParameters+ -- ^ The parameters of the data type.+ -> [NiceDeclaration]+ -- ^ The constructors of the data type.+ -> ScopeM A.Declaration+scopeCheckDataDef r o a pc uc x pars cons =+ notAffectedByOpaque do+ reportSLn "scope.data.def" 40 ("checking " ++ show o ++ " DataDef for " ++ prettyShow x)+ (p, ax) <- retrieveDataOrRecName IsData x++ withLocalVars do+ -- Scope check parameters+ gvars <- bindGeneralizablesIfInserted o ax+ pars <- catMaybes <$> toAbstract (defParametersToParameters pars)++ -- Create the data module+ let x' = anameName ax+ -- Create the module for the qualified constructors+ let m = qnameToMName x'+ createModule (Just IsDataModule) m+ bindModule p x m -- make it a proper module++ cons <- checkConstructors cons+ cons <- toAbstract (map (DataConstrDecl m a p) cons)+ printScope "data" 40 $ "Checked data " ++ prettyShow x+ f <- getConcreteFixity x+ return $ A.DataDef (mkDefInfo x f PublicAccess a r) x' pc uc (DataDefParams gvars pars) cons+ where+ -- Filter out non-type signatures and error out on duplicate constructors.+ checkConstructors cons = do+ -- Only type signatures (for constructors) are allowed in data definitions.+ (cs, cons') <- unzip . catMaybes <$> forM cons \case+ d@(C.Axiom _ _ _ _ _ c _) -> pure $ Just (c, d)+ d -> Nothing <$ do+ setCurrentRange d $+ warning $ IllegalDeclarationInDataDefinition $ notSoNiceDeclarations d+ -- Check for duplicate constructors.+ List1.unlessNull (duplicates cs) $ \ dups -> do+ let bad = filter (`elem` dups) cs+ setCurrentRange bad $+ typeError $ DuplicateConstructors dups+ return cons'++-- | Scope check a record definition.+-- The record signature must have been checked already.+scopeCheckRecDef ::+ Range+ -- ^ The range of the record definition.+ -> Origin+ -- ^ The origin of the record definition.+ -- 'UserWritten' when the definition was written separately from the signature.+ -- 'Inserted' when there was no separate signature.+ -> IsAbstract+ -- ^ Whether the record definition is abstract.+ -> PositivityCheck+ -- ^ Whether to report positivity errors for this record type.+ -> UniverseCheck+ -- ^ Whether to check field types for universe consistency.+ -> ForceRecordEta+ -- ^ Whether this record comes with a @{-# ETA_EQUALITY #-}@ pragma.+ -> C.Name+ -- ^ The name of the record type.+ -> [RecordDirective]+ -- ^ The record directives, e.g., 'inductive', 'eta-equality', 'pattern'.+ -> C.DefParameters+ -- ^ The parameters of the record type.+ -> [C.Declaration]+ -- ^ The fields of the record type and other declarations in the record module.+ -> ScopeM A.Declaration+scopeCheckRecDef r o a pc uc forceEta x directives pars fields =+ notAffectedByOpaque do+ reportSLn "scope.rec.def" 40 ("checking " ++ show o ++ " RecDef for " ++ prettyShow x)++ -- #3008: Termination pragmas are ignored in records+ checkNoTerminationPragma InRecordDef fields++ -- Check record directives for consistency.+ RecordDirectives ind eta pat cm <- gatherRecordDirectives directives+ -- Andreas, 2020-04-19, issue #4560+ -- 'pattern' declaration is incompatible with 'coinductive' or 'eta-equality'.+ pat <- case pat of+ Just r+ | Just (Ranged _ CoInductive) <- ind -> Nothing <$ warn "coinductive"+ | Just (Ranged _ YesEta) <- eta -> Nothing <$ warn "eta"+ | otherwise -> return pat+ where warn = setCurrentRange r . warning . UselessPatternDeclarationForRecord+ Nothing -> return pat++ -- Retrieve the abstract name of the record type+ -- that was created when scope checking the record type signature.+ (p, ax) <- retrieveDataOrRecName IsRecord_ x+ let x' = anameName ax++ -- Preserve the local variable set since we add some generalizable ones.+ withLocalVars $ do+ gvars <- bindGeneralizablesIfInserted o ax+ pars <- catMaybes <$> toAbstract (defParametersToParameters pars)++ -- We scope check the fields a first time when putting together+ -- the type of the constructor.+ contel <- localToAbstract (RecordConstructorType fields) return++ -- Use the name @x'@ of the record type also as name of the new record module.+ let m = qnameToMName x'+ printScope "rec" 25 "before record"+ createModule (Just IsRecordModule) m++ -- We scope check the fields a second time, as actual fields.+ afields <- withCurrentModule m $ do+ afields <- scopeCheckDeclarations fields+ printScope "rec" 25 "checked fields"+ return afields++ -- Andreas, 2017-07-13 issue #2642 disallow duplicate fields+ -- Check for duplicate fields. (See "Check for duplicate constructors")+ do let fs :: [C.Name]+ fs = concat $ forMaybe fields $ \case+ C.Field _ fs -> Just $ fs <&> \case+ -- a Field block only contains field signatures+ C.FieldSig _ _ f _ -> f+ _ -> __IMPOSSIBLE__+ _ -> Nothing+ List1.unlessNull (duplicates fs) $ \ dups -> do+ let bad = filter (`elem` dups) fs+ setCurrentRange bad $+ typeError $ DuplicateFields dups++ bindModule p x m++ -- Name kind of the record constructor (inductive/coinductive).+ let conKind = maybe ConName (conKindOfName . rangedThing) ind++ -- Bind the record constructor.+ cm' <- case cm of++ -- Andreas, 2019-11-11, issue #4189, no longer add record constructor to record module.+ Just (c, inst) -> NamedRecCon <$> bindRecordConstructorName c conKind inst a p++ -- Amy, 2024-09-25: if the record does not have a named+ -- constructor, then generate the QName here.+ Nothing -> do+ -- The name is qualified by the record module @m@ so that it is+ -- copied along with the record module by 'copyScope'.+ -- (Record constructor names have a special printing rule in+ -- lookupQName, so the qualification does not show up in output.)+ constr <- withCurrentModule m $+ freshAbstractQName noFixity' $ simpleName "constructor"+ pure $ FreshRecCon constr++ -- Andreas, 2026-08-23: Make the constructor accessible as @R.constructor@+ -- by binding the pseudo-name @constructor@ in the record module.+ -- Note that this is just an alias; the constructor itself does not live+ -- in the record module (issue #4189).+ bindRecordConstructorPseudoName m conKind (recordConName cm')++ -- Return the translated record definition.+ let inst = caseMaybe cm NotInstanceDef snd+ printScope "rec" 25 "record complete"+ f <- getConcreteFixity x+ let params = DataDefParams gvars pars+ let dir' = RecordDirectives ind eta pat cm'+ return $ A.RecDef (mkDefInfoInstance x f PublicAccess a inst NotMacroDef r) x' pc uc forceEta dir' params contel afields++-- | Retrieve the abstract name of a data or record type+-- that was created by scope checking the data or record signature.+--+-- Check that this name does not clash with existing modules.+--+-- Also check that the data/record definition has been placed in the same module+-- as the data/record signature.+retrieveDataOrRecName :: DataOrRecord_ -> C.Name -> ScopeM (Access, AbstractName)+retrieveDataOrRecName dataOrRec x = do++ -- Retrieve the abstract name of the record type+ -- that was created when scope checking the record type signature.+ (p, ax) <- resolveName (C.QName x) >>= \case+ DefinedName p ax NoSuffix -> return (p, ax)+ _ -> typeError $ MissingTypeSignature $ ifThenElse dataOrRec MissingDataSignature MissingRecordSignature $ x++ -- Check for correct placement of this record definition wrt. the existing record signature.+ -- These checks give more precise errors than the generic 'checkForModuleClash' below.+ clashUnless x (ifThenElse dataOrRec DataName RecName) ax -- Andreas 2019-07-07, issue #3892+ livesInCurrentModule ax -- Andreas, 2017-12-04, issue #2862+ clashIfModuleAlreadyDefinedInCurrentModule x ax -- Andreas, 2019-07-07, issue #2576++ -- Andreas, 2026-02-28, issue #8435+ -- The nicifier bubbles signatures up, even beyond their matching definition.+ -- So, check that signature appeared before definition in the file.+ reportSDoc "scope.data.range" 40 $ vcat+ [ "ax = " <+> pure (pretty (PrintRange ax))+ , "defined at " <+> pure (pretty (PrintRange (nameBindingSite ax)))+ ]+ unless (getRange (nameBindingSite ax) <= getRange ax) do+ warning $ DefinitionBeforeDeclaration ax++ -- Check that the generated module doesn't clash with a previously+ -- defined module+ checkForModuleClash x++ return (p, ax)++-- | Scope check @[open] import M [as N] using/hiding/renaming@.+scopeCheckImport ::+ Range+ -- ^ Range of the whole import statement.+ -> C.QName+ -- ^ Name @M@ of the (file) module to import.+ -> Maybe (AsName' C.Name)+ -- ^ Possibly short name @as N@.+ -> OpenShortHand+ -- ^ Possibly @open@.+ -> C.ImportDirective+ -- ^ Limiting the scope.+ --+ -- In the case of @open@, this applies to the names brought in scope.+ --+ -- In the case of no @open@, this applies to the export list+ -- of the imported module itself.+ -- Several imports of the same file module accumulate accumulate exports,+ -- but see <https://github.com/agda/agda/issues/7656>.+ -> ScopeM [A.Declaration]+scopeCheckImport r x as open dir =+ setCurrentRange r do+ dir <- notPublicWithoutOpen open dir++ top <- TCM.topLevelModuleName (rawTopLevelModuleNameForQName x)+ -- First scope check the imported module and return its name and+ -- interface. This is done with that module as the top-level module.+ -- This is quite subtle. We rely on the fact that when setting the+ -- top-level module and generating a fresh module name, the generated+ -- name will be exactly the same as the name generated when checking+ -- the imported module.+ (m, i) <- withCurrentModule noModuleName $+ withTopLevelModule top $ do+ printScope "import" 30 "before import:"+ (m0, i) <- scopeCheckFileImport top+ printScope "import" 30 $ "scope checked import: " ++ prettyShow i+ -- We don't want the top scope of the imported module (things happening+ -- before the module declaration)+ return (m0 `withRangesOfQ` x, Map.delete noModuleName i)++ -- Bind the desired module name to the right abstract name.+ (name, theAsSymbol, theAsName) <- case as of++ Just a | let y = asName a, not (isNoName y) -> do+ bindModule privateAccessInserted y m+ return (C.QName y, asRange a, Just y)++ _ -> do+ -- Don't bind if @import ... as _@ with "no name"+ whenNothing as $ bindQModule (privateAccessInserted) x m+ return (x, noRange, Nothing)++ -- Open if specified, otherwise apply import directives+ adir <- case open of++ -- With @open@ import directives apply to the opening.+ -- The module is thus present in its qualified form without restrictions.+ DoOpen kwr -> do++ -- Merge the imported scopes with the current scopes.+ -- This might override a previous import of @m@, but monotonously (add stuff).+ modifyScopes $ \ ms -> Map.unionWith mergeScope (Map.delete m ms) i+ recomputeInverseScope++ -- Andreas, 2019-05-29, issue #3818.+ -- Pass the resolved name to open instead triggering another resolution.+ -- This helps in situations like+ -- @+ -- module Top where+ -- module M where+ -- open import M+ -- @+ -- It is clear than in @open import M@, name @M@ must refer to a file+ -- rather than the above defined local module @M@.+ -- This already worked in the situation+ -- @+ -- module Top where+ -- module M where+ -- import M+ -- @+ -- Note that the manual desugaring of @open import@ as+ -- @+ -- module Top where+ -- module M where+ -- import M+ -- open M+ -- @+ -- will not work, as @M@ is now ambiguous in @open M@;+ -- the information that @M@ is external is lost here.+ (_minfo, _m, adir) <- checkOpen kwr (Just m) name dir+ return adir++ -- If not opening, import directives are applied to the original scope.+ DontOpen -> do+ (adir, i') <- Map.adjustM' (\m -> fmap recomputeNameParts <$> applyImportDirectiveM x dir m) m i+ -- Andreas, 2020-05-18, issue #3933+ -- We merge the new imports without deleting old imports, to be monotone.+ modifyScopes $ \ ms -> Map.unionWith mergeScope ms i'+ recomputeInverseScope+ return adir++ printScope "import" 30 "merged imported sig:"+ let minfo = ModuleInfo+ { minfoRange = r+ , minfoAsName = theAsName+ , minfoAsTo = getRange (theAsSymbol, renamingRange dir)+ , minfoOpenShort = open+ , minfoDirective = Just dir+ }+ return [ A.Import minfo m adir ]+++-- | Checking postulate or type sig. without checking safe flag.+toAbstractNiceAxiom :: KindOfName -> C.NiceDeclaration -> ScopeM (A.QName, A.Declaration)+toAbstractNiceAxiom kind (C.Axiom r p a i info x t) = do+ -- Amy, 2025-05-04, issue 7856: type signatures (more+ -- importantly extended lambdas within them) should not belong+ -- to opaque blocks+ --+ -- Note that only scope checking the type happens outside the+ -- block since a bit below we need the proper opaque id to+ -- possibly update the info.+ t' <- notUnderOpaque $ toAbstractCtx TopCtx t++ f <- getConcreteFixity x+ mp <- getConcretePolarity x+ y <- freshAbstractQName f x+ let isMacro | kind == MacroName = MacroDef+ | otherwise = NotMacroDef+ bindName' p kind (instanceMetadata i) x y+ definfo <- updateDefInfoOpacity $ mkDefInfoInstance x f p a i isMacro r+ return (y, A.Axiom kind definfo info mp y t')+toAbstractNiceAxiom _ _ = __IMPOSSIBLE__++-- | Check that the name is allowed to be postulated: either we are in a+-- builtin module, we are not in safe mode, or the axiom comes from a+-- lone type signature (and so will be reported later as a missing+-- definition)+checkAllowedAxiom :: ArgInfo -> A.QName -> ScopeM ()+checkAllowedAxiom info x = whenM+ (andM [ pure $ getOrigin info /= Inserted+ , Lens.getSafeMode <$> commandLineOptions+ , not <$> (isBuiltinModuleWithSafePostulates . fromMaybe __IMPOSSIBLE__ =<< viewTC eCurrentPath)+ ])+ (warning $ SafeFlagPostulate x)++interestingOpaqueDecl :: A.Declaration -> Bool+interestingOpaqueDecl (A.Mutual _ ds) = any interestingOpaqueDecl ds+interestingOpaqueDecl (A.ScopedDecl _ ds) = any interestingOpaqueDecl ds++interestingOpaqueDecl A.FunDef{} = True+interestingOpaqueDecl A.UnquoteDecl{} = True+interestingOpaqueDecl A.UnquoteDef{} = True++interestingOpaqueDecl _ = False++-- ** Helper functions for @opaque@+------------------------------------------------------------------------++-- | Add a 'QName' to the set of declarations /contained in/ the current+-- opaque block.+unfoldFunction :: A.QName -> ScopeM ()+unfoldFunction qn = viewTC eCurrentOpaqueId >>= \case+ Just id -> do+ let go Nothing = __IMPOSSIBLE__+ go (Just ob) = Just ob{ opaqueDecls = qn `HashSet.insert` opaqueDecls ob }+ stOpaqueBlocks `modifyTCLens` Map.alter go id+ Nothing -> pure ()++-- | Look up the current opaque identifier as a value in 'IsOpaque'.+contextIsOpaque :: ScopeM IsOpaque+contextIsOpaque = maybe TransparentDef OpaqueDef <$> viewTC eCurrentOpaqueId++updateDefInfoOpacity :: DefInfo -> ScopeM DefInfo+updateDefInfoOpacity di = (\a -> di { Info.defOpaque = a }) <$> contextIsOpaque++-- | Raise a warning indicating that the current Declaration is not+-- affected by opacity, but only if we are actually in an Opaque block.+notAffectedByOpaque :: ScopeM a -> ScopeM a+notAffectedByOpaque k = do+ whenM ((NoWhere_ ==) <$> viewTC eCheckingWhere) $+ whenJustM (viewTC eCurrentOpaqueId) \ _ ->+ warning NotAffectedByOpaque+ notUnderOpaque k++-- * Helper functions for @variable@ generalization+------------------------------------------------------------------------++unGeneralized :: A.Expr -> (Set A.QName, A.Expr)+unGeneralized (A.Generalized s t) = (Set1.toSet s, t)+unGeneralized (A.ScopedExpr si e) = A.ScopedExpr si <$> unGeneralized e+unGeneralized t = (mempty, t)++alreadyGeneralizing :: ScopeM Bool+alreadyGeneralizing = isJust <$> useTC stGeneralizedVars++-- | In the context of scope checking an expression, given a resolved name @d@:+--+-- * If @d@ is a @variable@ (generalizable), add it to the collection 'stGeneralizedVars'+-- of variables we wish to abstract over.+--+-- * Otherwise, do nothing.+--+class AddGeneralizable a where+ addGeneralizable :: a -> ScopeM ()++instance AddGeneralizable AbstractName where+ addGeneralizable :: AbstractName -> ScopeM ()+ addGeneralizable d = case anameKind d of+ GeneralizeName -> do+ gvs <- useTC stGeneralizedVars+ case gvs of -- Subtle: Use (left-biased) union instead of insert to keep the old name if+ -- already present. This way we can sort by source location when generalizing+ -- (Issue 3354).+ Just s -> stGeneralizedVars `setTCLens` Just (s `Set.union` Set.singleton (anameName d))+ Nothing -> typeError $ GeneralizeNotSupportedHere $ anameName d+ DisallowedGeneralizeName -> typeError $ GeneralizedVarInLetOpenedModule $ anameName d+ _ -> return ()++instance AddGeneralizable ResolvedName where+ addGeneralizable = \case+ -- Only 'DefinedName' can be a @variable@.+ DefinedName _ d NoSuffix -> addGeneralizable d+ DefinedName _ d Suffix{} -> return ()+ VarName{} -> return ()+ FieldName{} -> return ()+ ConstructorName{} -> return ()+ PatternSynResName{} -> return ()+ UnknownName{} -> return ()++collectGeneralizables :: ScopeM a -> ScopeM (Set A.QName, a)+collectGeneralizables m =+ -- #5683: No nested generalization+ ifM alreadyGeneralizing ((Set.empty,) <$> m) $+ {-else-} bracket_ open close $ do+ a <- m+ s <- useTC stGeneralizedVars+ case s of+ Nothing -> __IMPOSSIBLE__+ Just s -> return (s, a)+ where+ open = do+ gvs <- useTC stGeneralizedVars+ stGeneralizedVars `setTCLens` Just mempty+ pure gvs+ close = (stGeneralizedVars `setTCLens`)++createBoundNamesForGeneralizables :: Set A.QName -> ScopeM (Map A.QName A.Name)+createBoundNamesForGeneralizables vs =+ flip Map.traverseWithKey (Map.fromSet (const ()) vs) $ \ q _ -> do+ let x = nameConcrete $ qnameName q+ fx = nameFixity $ qnameName q+ freshAbstractName fx x++collectAndBindGeneralizables :: ScopeM a -> ScopeM (Map A.QName A.Name, a)+collectAndBindGeneralizables m = do+ fvBefore <- length <$> getLocalVars+ (s, res) <- collectGeneralizables m+ fvAfter <- length <$> getLocalVars+ -- We should bind the named generalizable variables as fresh variables+ binds <- createBoundNamesForGeneralizables s+ -- Issue #3735: We need to bind the generalizable variables outside any variables bound by `m`.+ outsideLocalVars (fvAfter - fvBefore) $ bindGeneralizables binds+ return (binds, res)++bindGeneralizables :: Map A.QName A.Name -> ScopeM ()+bindGeneralizables vars =+ forM_ (Map.toList vars) $ \ (q, y) ->+ bindVariable LambdaBound (nameConcrete $ qnameName q) y++-- | Bind generalizable variables if data or record decl was split by the system+-- (origin == Inserted)+bindGeneralizablesIfInserted :: Origin -> AbstractName -> ScopeM (Set A.Name)+bindGeneralizablesIfInserted Inserted y = bound <$ bindGeneralizables gvars+ where+ gvars = nameDataGeneralizedVars $ anameMetadata y+ bound = Set.fromList (Map.elems gvars)+bindGeneralizablesIfInserted UserWritten _ = return Set.empty+bindGeneralizablesIfInserted _ _ = __IMPOSSIBLE__++newtype GenTel = GenTel C.Telescope+data GenTelAndType = GenTelAndType C.Telescope C.Expr++instance ToAbstract GenTel where+ type AbsOfCon GenTel = A.GeneralizeTelescope+ toAbstract (GenTel tel) =+ uncurry A.GeneralizeTel <$> collectAndBindGeneralizables (catMaybes <$> toAbstract tel)++instance ToAbstract GenTelAndType where+ type AbsOfCon GenTelAndType = (A.GeneralizeTelescope, A.Expr)++ toAbstract (GenTelAndType tel t) = do+ (binds, (tel, t)) <- collectAndBindGeneralizables $+ (,) <$> toAbstract tel <*> toAbstract t+ return (A.GeneralizeTel binds (catMaybes tel), t)++-- ** Record directives+------------------------------------------------------------------------++-- | Check for duplicate record directives.+gatherRecordDirectives :: [C.RecordDirective] -> ScopeM C.RecordDirectives+gatherRecordDirectives ds = mapM_ gatherRecordDirective ds `execStateT` empty++-- | Fill the respective field of 'C.RecordDirectives' by the given 'C.RecordDirective'.+--+-- Ignore it with a dead-code warning if the field is already filled.+--+gatherRecordDirective :: C.RecordDirective -> StateT C.RecordDirectives ScopeM ()+gatherRecordDirective d = do+ dir@RecordDirectives{ recInductive = ind, recHasEta = eta, recPattern = pat, recConstructor = con } <- get+ case d of+ Induction ri -> assertNothing ind $ put dir{ recInductive = Just ri }+ Eta re -> assertNothing eta $ put dir{ recHasEta = Just re }+ PatternOrCopattern r -> assertNothing pat $ put dir{ recPattern = Just r }+ C.Constructor x inst -> assertNothing con $ put dir{ recConstructor = Just (x, inst) }+ where+ assertNothing :: Maybe a -> StateT C.RecordDirectives ScopeM () -> StateT C.RecordDirectives ScopeM ()+ assertNothing Nothing cont = cont+ assertNothing Just{} _ = lift $ setCurrentRange d $ warning $ DuplicateRecordDirective d++-- ** Helper functions for name clashes+------------------------------------------------------------------------++-- | Make sure definition is in same module as signature.+class LivesInCurrentModule a where+ livesInCurrentModule :: a -> ScopeM ()++instance LivesInCurrentModule AbstractName where+ livesInCurrentModule = livesInCurrentModule . anameName++instance LivesInCurrentModule A.QName where+ livesInCurrentModule x = do+ m <- getCurrentModule+ reportS "scope.data.def" 30+ [ " A.QName of data type: " ++ prettyShow x+ , " current module: " ++ prettyShow m+ ]+ unless (A.qnameModule x == m) $+ typeError $ DefinitionInDifferentModule x++-- | Unless the resolved 'AbstractName' has the given 'KindOfName',+-- report a 'ClashingDefinition' for the 'C.Name'.+clashUnless :: C.Name -> KindOfName -> AbstractName -> ScopeM ()+clashUnless x k ax = unless (anameKind ax == k) $+ typeError $ ClashingDefinition (C.QName x) (ClashingAbstractName ax) Nothing++-- | If a (data/record) module with the given name is already present in the current module,+-- we take this as evidence that a data/record with that name is already defined.+clashIfModuleAlreadyDefinedInCurrentModule :: C.Name -> AbstractName -> ScopeM ()+clashIfModuleAlreadyDefinedInCurrentModule x ax = do+ datRecMods <- catMaybes <$> do+ mapM (isDatatypeModule . amodName) =<< lookupModuleInCurrentModule x+ unlessNull datRecMods $ const $+ typeError $ ClashingDefinition (C.QName x) (ClashingAbstractName ax) Nothing++lookupModuleInCurrentModule :: C.Name -> ScopeM [AbstractModule]+lookupModuleInCurrentModule x =+ List1.toList' . Map.lookup x . nsModules . thingsInScope [PublicNS, PrivateNS] <$> getCurrentScope++-- ** Helper functions for constructor declarations+------------------------------------------------------------------------++data DataConstrDecl = DataConstrDecl A.ModuleName IsAbstract Access C.NiceDeclaration++-- | Bind a @data@ constructor.+bindConstructorName ::+ ModuleName -- ^ Name of @data@/@record@ module.+ -> C.Name -- ^ Constructor name.+ -> IsInstance+ -> IsAbstract+ -> Access+ -> ScopeM A.QName+bindConstructorName m x i a p = do+ f <- getConcreteFixity x+ -- The abstract name is the qualified one+ y <- withCurrentModule m $ freshAbstractQName f x+ -- Bind it twice, once unqualified and once qualified+ let meta = instanceMetadata i+ bindName' p' ConName meta x y+ withCurrentModule m $ bindName' p'' ConName meta x y+ return y+ where+ -- An abstract constructor is private (abstract constructor means+ -- abstract datatype, so the constructor should not be exported).+ p' = case a of+ AbstractDef -> privateAccessInserted+ _ -> p+ p'' = case a of+ AbstractDef -> privateAccessInserted+ _ -> PublicAccess++-- | Record constructors do not live in the record module (as it is parameterized).+-- Abstract constructors are bound privately, so that they are not exported.+bindRecordConstructorName :: C.Name -> KindOfName -> IsInstance -> IsAbstract -> Access -> ScopeM A.QName+bindRecordConstructorName x kind inst a p = do+ y <- freshAbstractQName' x+ bindName' p' kind (instanceMetadata inst) x y+ return y+ where+ -- An abstract constructor is private (abstract constructor means+ -- abstract datatype, so the constructor should not be exported).+ p' = case a of+ AbstractDef -> privateAccessInserted+ _ -> p++bindUnquoteConstructorName :: ModuleName -> Access -> C.Name -> ScopeM A.QName+bindUnquoteConstructorName m p c = do+ r <- resolveName (C.QName c)+ fc <- getConcreteFixity c+ c' <- withCurrentModule m $ freshAbstractQName fc c+ let aname qn = AbsName qn QuotableName Defined noMetadata+ addName = do+ modifyCurrentScope $ addNameToScope (localNameSpace p) c $ aname c'+ recomputeInverseScope -- András 2025-08-30: TODO: use addNameToInverseScope instead+ success = addName >> (withCurrentModule m $ addName)+ failure y = typeError $ ClashingDefinition (C.QName c) y Nothing+ case r of+ _ | isNoName c -> success+ UnknownName -> success+ ConstructorName i ds -> if all (isJust . isConName . anameKind) ds+ then success+ else failure $ ClashingAbstractName $ List1.head ds+ DefinedName _ d _ -> failure $ ClashingAbstractName d+ FieldName ds -> failure $ ClashingAbstractName $ List1.head ds+ PatternSynResName ds -> failure $ ClashingAbstractName $ List1.head ds+ VarName y _ -> failure $ ClashingQName $ qualify_ y+ return c'++instance ToAbstract DataConstrDecl where+ type AbsOfCon DataConstrDecl = A.Declaration++ toAbstract (DataConstrDecl m a p d) = traceCall (ScopeCheckDeclaration d) do+ case d of+ C.Axiom r p1 a1 i ai x t -> do+ -- unless (p1 == p) __IMPOSSIBLE__ -- This invariant is currently violated by test/Succeed/Issue282.agda+ unless (a1 == a) __IMPOSSIBLE__+ ai <- checkConstructorArgInfo ai+ t' <- toAbstractCtx TopCtx t+ -- The abstract name is the qualified one+ -- Bind it twice, once unqualified and once qualified+ f <- getConcreteFixity x+ y <- bindConstructorName m x i a p+ printScope "con" 25 "bound constructor"+ let defInfo = mkDefInfoInstance x f p a i NotMacroDef r+ return $ A.Axiom ConName defInfo ai Nothing y t'+ _ -> __IMPOSSIBLE__++-- | Delete (with warning) attributes that are illegal for constructor declarations.+checkConstructorArgInfo :: ArgInfo -> ScopeM ArgInfo+checkConstructorArgInfo =+ ensureRelevant msg >=>+ ensureNotLinear msg >=>+ ensureLeftAdjoint msg >=>+ ensureMixedPolarity msg >=>+ ensureNotRew msg+ where+ msg = Just "constructor"++ensureNotRew :: LensRewriteAnn a => Maybe String -> a -> ScopeM a+ensureNotRew ms = ignoreRew $ \ r ->+ whenJust ms \ s -> warning $ IgnoringRew s r++ensureRelevant :: LensRelevance a => Maybe String -> a -> ScopeM a+ensureRelevant ms info = do+ if isRelevant info then return info else do+ whenJust ms \ s -> warning $ FixingRelevance s (getRelevance info) relevant+ return $ setRelevance relevant info++ensureNotLinear :: LensQuantity a => Maybe String -> a -> ScopeM a+ensureNotLinear s info = do+ case getQuantity info of+ Quantityω{} -> return info+ Quantity0{} -> return info+ q@Quantity1{} -> do+ -- Andreas, 2024-08-24, "@1" is still not parsed, so this is impossible.+ __IMPOSSIBLE__+ -- TODO: linearity+ -- let q' = Quantityω QωInferred+ -- warning $ FixingQuantity s q q'+ -- return $ setQuantity q' info++ensureLeftAdjoint :: LensCohesion a => Maybe String -> a -> ScopeM a+ensureLeftAdjoint ms info+ | hasLeftAdjoint (UnderComposition (getCohesion info)) = return info+ | otherwise = setCohesion Continuous info <$ do+ whenJust ms \ s -> warning $ FixingCohesion s (getCohesion info) Continuous++ensureMixedPolarity :: LensModalPolarity a => Maybe String -> a -> ScopeM a+ensureMixedPolarity ms info+ | splittablePolarity info = return info+ | otherwise = setModalPolarity mixedPolarity info <$ do+ whenJust ms \ s -> warning $ FixingPolarity s (getModalPolarity info) mixedPolarity++-- ** More scope checking+------------------------------------------------------------------------++instance ToAbstract C.Pragma where+ type AbsOfCon C.Pragma = [A.Pragma]++ toAbstract (C.ImpossiblePragma _ strs) =+ case strs of+ "ReduceM" : _ -> impossibleTestReduceM strs+ _ -> impossibleTest strs++ toAbstract (C.OptionsPragma _ opts) = return [ A.OptionsPragma opts ]++ toAbstract (C.RewritePragma _ r xs) = do+ rewritingOption >>= \case++ -- If --rewriting is off, ignore the pragma.+ False -> [] <$ do+ warning $ UselessPragma r "Ignoring REWRITE pragma since option --rewriting is off"++ -- Warn about empty pragmas.+ True -> if null xs then [] <$ warning EmptyRewritePragma else do++ -- Check that names of rewrite rules are unambiguous.+ singleton . A.RewritePragma r . catMaybes <$> do+ forM xs \ x -> setCurrentRange x $ unambiguousConOrDef NotARewriteRule x++ toAbstract (C.ForeignPragma _ rb s) = pure [ A.ForeignPragma rb s ]+ -- Issue #8647: for the sake of caching, handle FOREIGN code in the type checker++ toAbstract (C.CompilePragma _ rb x s) =+ maybe [] (\ y -> [ A.CompilePragma rb y s ]) <$>+ unambiguousConOrDef PragmaCompileWrongName x++ toAbstract (C.StaticPragma _ x) = do+ map A.StaticPragma . maybeToList <$> do+ unambiguousDef (PragmaExpectsUnambiguousProjectionOrFunction "STATIC") x++ toAbstract (C.InjectivePragma _ x) = do+ map A.InjectivePragma . maybeToList <$> do+ unambiguousDef (PragmaExpectsUnambiguousProjectionOrFunction "INJECTIVE") x++ toAbstract (C.InjectiveForInferencePragma _ x) = do+ map A.InjectiveForInferencePragma . maybeToList <$> do+ scopeCheckDef (PragmaExpectsDefinedSymbol "INJECTIVE_FOR_INFERENCE") x++ toAbstract pragma@(C.InlinePragma _ b x) = do+ caseMaybeM (toAbstract $ MaybeOldQName $ OldQName x Nothing) notInScope \case+ A.Con c -> concatMapM ret $ List1.toList $ getAmbiguous c+ A.Def x -> ret x+ A.Proj _ p+ | Just x <- getUnambiguous p -> ret x+ | otherwise -> uselessPragma pragma $ sINLINE ++ " used on ambiguous name " ++ prettyShow x+ _ -> uselessPragma pragma $ "Target of " ++ sINLINE ++ " pragma should be a function or constructor"+ where+ sINLINE = if b then "INLINE" else "NOINLINE"+ notInScope = [] <$ notInScopeWarning x+ ret y = return [ A.InlinePragma b y ]++ toAbstract (C.NotProjectionLikePragma _ x) = do+ map A.NotProjectionLikePragma . maybeToList <$> do+ unambiguousDef (PragmaExpectsUnambiguousProjectionOrFunction "NOT_PROJECTION_LIKE") x++ toAbstract (C.OverlapPragma _ xs i) = do+ map (flip A.OverlapPragma i) . catMaybes <$> do+ mapM (unambiguousConOrDef $ PragmaExpectsUnambiguousConstructorOrFunction pragma) xs+ where+ pragma = case i of+ Overlappable -> "OVERLAPPABLE"+ Overlapping -> "OVERLAPPING"+ Overlaps -> "OVERLAPS"+ Incoherent -> "INCOHERENT"+ -- Never written by the user:+ DefaultOverlap -> __IMPOSSIBLE__+ FieldOverlap -> __IMPOSSIBLE__++ toAbstract pragma@(C.BuiltinPragma _ rb qx)+ | Just b' <- b, isUntypedBuiltin b' = do+ q <- resolveQName qx+ bindUntypedBuiltin b' qx q+ return [ A.BuiltinPragma rb q ]+ -- Andreas, 2015-02-14+ -- Some builtins cannot be given a valid Agda type,+ -- thus, they do not come with accompanying postulate or definition.+ | Just b' <- b, isBuiltinNoDef b' = do+ case qx of+ C.QName x -> do+ -- The name shouldn't exist yet. If it does, we raise a warning+ -- and drop the existing definition.+ unlessM ((UnknownName ==) <$> resolveName qx) $ do+ warning $ BuiltinDeclaresIdentifier b'+ modifyCurrentScope $ removeNameFromScope PublicNS x+ recomputeInverseScope+ -- We then happily bind the name+ y <- freshAbstractQName' x+ let kind = fromMaybe __IMPOSSIBLE__ $ builtinKindOfName b'+ bindName PublicAccess kind x y+ return [ A.BuiltinNoDefPragma rb kind y ]+ _ -> uselessPragma pragma $+ "Pragma BUILTIN " ++ getBuiltinId b' ++ ": expected unqualified identifier, " +++ "but found " ++ prettyShow qx+ | otherwise = do+ q0 <- resolveQName qx++ -- Andreas, 2020-04-12, pr #4574. For highlighting purposes:+ -- Rebind 'BuiltinPrim' as 'PrimName' and similar.+ q <- case (q0, b >>= builtinKindOfName, qx) of+ (DefinedName acc y suffix, Just kind, C.QName x)+ | anameKind y /= kind+ , kind `elem` [ PrimName, AxiomName ] -> do+ rebindName acc kind noMetadata x $ anameName y+ return $ DefinedName acc y{ anameKind = kind } suffix+ _ -> return q0++ return [ A.BuiltinPragma rb q ]+ where b = builtinById (rangedThing rb)++ toAbstract pragma@(C.EtaPragma _ x) = do+ uselessPragma pragma "The ETA pragma has been removed, use the attaching ETA_EQUALITY pragma instead"++ toAbstract pragma@(C.DisplayPragma _ lhs rhs) = do+ maybeToList <$> do+ withLocalVars $ runMaybeT do+ let err = failure "DISPLAY pragma left-hand side must have form 'f e1 .. en'"+ getHead (C.IdentP _ x) = return x+ getHead (C.RawAppP _ (List2 p _ _)) = getHead p+ getHead _ = err++ top <- getHead lhs++ (isPatSyn, hd) <- do+ qx <- liftTCM $ resolveName' allKindsOfNames Nothing top+ case qx of+ VarName x' _ -> return . (False,) $ A.qnameFromList $ singleton x'+ DefinedName _ d NoSuffix -> return . (False,) $ anameName d+ DefinedName _ d Suffix{} -> failure $ "Invalid pattern " ++ prettyShow top+ FieldName (d :| []) -> return . (False,) $ anameName d+ FieldName ds -> failure $ "Ambiguous projection " ++ prettyShow top ++ ": " ++ prettyShow (ambigName ds)+ ConstructorName _ (d :| []) -> return . (False,) $ anameName d+ ConstructorName _ ds -> failure $ "Ambiguous constructor " ++ prettyShow top ++ ": " ++ prettyShow (ambigName ds)+ UnknownName -> do liftTCM $ notInScopeWarning top; mzero+ PatternSynResName (d :| []) -> return . (True,) $ anameName d+ PatternSynResName ds -> failure $ "Ambiguous pattern synonym" ++ prettyShow top ++ ": " ++ prettyShow (fmap anameName ds)++ lhs <- liftTCM $ toAbstract $ LeftHandSide top lhs YesDisplayLHS+ ps <- case lhs of+ A.LHS _ (A.LHSHead _ ps) -> return ps+ _ -> err++ -- Andreas, 2016-08-08, issue #2132+ -- Remove pattern synonyms on lhs+ (hd, ps) <- do+ p <- liftTCM $ expandPatternSynonyms $+ (if isPatSyn then A.PatternSynP else A.DefP) (PatRange $ getRange lhs) (unambiguous hd) ps+ case p of+ A.DefP _ f ps | Just hd <- getUnambiguous f -> return (hd, ps)+ A.ConP _ c ps | Just hd <- getUnambiguous c -> return (hd, ps)+ A.PatternSynP{} -> __IMPOSSIBLE__+ _ -> err++ rhs <- liftTCM $ toAbstract rhs++ -- Andreas, 2024-10-06, issue #7533:+ -- Check that all pattern variables occur on the rhs.+ -- Otherwise, there might be a misunderstanding of what display forms do.+ let used = allUsedNames rhs+ List1.unlessNull (filter (not . (isNoName || (`Set.member` used))) $ patternVars ps) $+ warning . UnusedVariablesInDisplayForm++ return $ A.DisplayPragma hd ps rhs+ where+ failure :: forall a. String -> MaybeT ScopeM a+ failure msg = do warning (UselessPragma (getRange pragma) $ P.fwords msg); mzero++ -- A warning attached to an ambiguous name shall apply to all disambiguations.+ toAbstract pragma@(C.WarningOnUsage _ x str) = do+ ys <- resolveName x >>= \case+ ConstructorName _ ds -> return $ List1.toList ds+ FieldName ds -> return $ List1.toList ds+ PatternSynResName ds -> return $ List1.toList ds+ DefinedName _ d NoSuffix -> return $ singleton d+ DefinedName _ d Suffix{} -> [] <$ notInScopeWarning x+ UnknownName -> [] <$ notInScopeWarning x+ VarName x _ -> [] <$ do+ uselessPragma pragma $ "Not a defined name: " ++ prettyShow x+ forM_ ys $ \ y -> stLocalUserWarnings `modifyTCLens` Map.insert (anameName y) str+ return []++ toAbstract (C.WarningOnImport _ str) = do+ stWarningOnImport `setTCLens` Just str+ pure []+++ -- Pragmas that are handled by the nicifier:+ toAbstract C.TerminationCheckPragma{} = __IMPOSSIBLE__+ toAbstract C.NoCoverageCheckPragma{} = __IMPOSSIBLE__+ toAbstract C.NoPositivityCheckPragma{} = __IMPOSSIBLE__+ toAbstract C.NoUniverseCheckPragma{} = __IMPOSSIBLE__+ toAbstract C.CatchallPragma{} = __IMPOSSIBLE__+ toAbstract C.EtaEqualityPragma{} = __IMPOSSIBLE__+ toAbstract C.PolarityPragma{} = __IMPOSSIBLE__++uselessPragma :: HasRange p => p -> String -> ScopeM [a]+uselessPragma pragma = ([] <$) . warning . UselessPragma (getRange pragma) . P.fwords++unambiguousConOrDef :: (C.QName -> IsAmbiguous -> Warning) -> C.QName -> ScopeM (Maybe A.QName)+unambiguousConOrDef warn x = do+ caseMaybeM (toAbstract $ MaybeOldQName $ OldQName x Nothing) notInScope $ \case+ A.Def' y NoSuffix -> ret y+ A.Def' y Suffix{} -> failure NotAmbiguous+ A.Proj _ p+ | Just y <- getUnambiguous p -> ret y+ | otherwise -> failure $ YesAmbiguous p+ A.Con c+ | Just y <- getUnambiguous c -> ret y+ | otherwise -> failure $ YesAmbiguous c+ A.Var{} -> failure NotAmbiguous+ A.PatternSyn{} -> failure NotAmbiguous+ _ -> __IMPOSSIBLE__+ where+ notInScope = Nothing <$ notInScopeWarning x+ failure = (Nothing <$) . warning . warn x+ ret = return . Just++unambiguousDef :: (C.QName -> IsAmbiguous -> Warning) -> C.QName -> ScopeM (Maybe A.QName)+unambiguousDef warn x = do+ caseMaybeM (toAbstract $ MaybeOldQName $ OldQName x Nothing) notInScope $ \case+ A.Def' y NoSuffix -> ret y+ A.Def' y Suffix{} -> failure NotAmbiguous+ A.Proj _ p+ | Just y <- getUnambiguous p -> ret y+ | otherwise -> failure $ YesAmbiguous p+ A.Con{} -> failure NotAmbiguous+ A.Var{} -> failure NotAmbiguous+ A.PatternSyn{} -> failure NotAmbiguous+ _ -> __IMPOSSIBLE__+ where+ notInScope = Nothing <$ notInScopeWarning x+ failure = (Nothing <$) . warning . warn x+ ret = return . Just++scopeCheckDef :: (C.QName -> Warning) -> C.QName -> ScopeM (Maybe A.QName)+scopeCheckDef warn x = do+ caseMaybeM (toAbstract $ MaybeOldQName $ OldQName x Nothing) notInScope $ \case+ A.Def' y NoSuffix -> ret y+ A.Def' y Suffix{} -> failure+ A.Proj{} -> failure+ A.Con{} -> failure+ A.Var{} -> failure+ A.PatternSyn{} -> failure+ _ -> __IMPOSSIBLE__+ where+ notInScope = Nothing <$ notInScopeWarning x+ failure = Nothing <$ do warning $ warn x+ ret = return . Just++-- | Does this left-hand side equation trigger a with-abstraction?+-- @using p <- e@ does not, it merely introduces a let-binding.+withAbstractingEqn :: RewriteEqn' qn nm p e -> Bool+withAbstractingEqn = \case+ Rewrite{} -> True -- @rewrite e@+ Invert{} -> True -- @with p <- e in eq@+ LeftLet{} -> False -- @using p <- e@++instance ToAbstract C.Clause where+ type AbsOfCon C.Clause = A.Clause++ toAbstract (C.Clause top catchall ai lhs@(C.LHS p eqs with) rhs wh wcs) = withLocalVars $ do+ -- Andreas, 2026-09-06, issue #8698:+ -- Establish the invariant of 'RightHandSide':+ -- no named @where@ module under @with@ or @rewrite@.+ -- The @where@ clause of a @rewrite@ clause is passed on to 'RightHandSide',+ -- whereas for @with@ it is the with-subclauses that carry the @where@ clause.+ when (not (null with) || any withAbstractingEqn eqs) do+ mapM_ rejectNamedWhereUnderWith $ wh : map (\ (C.Clause _ _ _ _ _ wh' _) -> wh') wcs++ -- Jesper, 2018-12-10, #3095: pattern variables bound outside the+ -- module are locally treated as module parameters+ modifyScope $ updateScopeLocals $ map $ second patternToModuleBound+ -- Andreas, 2012-02-14: need to reset local vars before checking subclauses+ vars0 <- getLocalVars+ lhs' <- toAbstract $ LeftHandSide (C.QName top) p NoDisplayLHS+ printLocals 30 "after lhs:"+ vars1 <- getLocalVars+ eqs <- mapM (toAbstractCtx TopCtx) eqs+ vars2 <- getLocalVars+ let vars = dropEnd (length vars1) vars2 ++ vars0+ let wcs' = (vars, wcs)++ -- Handle rewrite equations first.+ if not (null eqs)+ then do+ rhs <- toAbstractCtx TopCtx $ RightHandSide eqs with wcs' rhs wh+ rhs <- toAbstract rhs+ return $ A.Clause lhs' [] rhs A.noWhereDecls catchall+ else do+ -- the right hand side is checked with the module of the local definitions opened+ (rhs, ds) <- whereToAbstract (getRange wh) wh $+ toAbstractCtx TopCtx $ RightHandSide [] with wcs' rhs NoWhere+ rhs <- toAbstract rhs+ return $ A.Clause lhs' [] rhs ds catchall+ where+ -- Andreas, 2026-09-06, issue #8698.+ -- Reject a named @where@ module (@module M where@) in a @with@ or @rewrite@+ -- clause. With-abstraction can change the types of the module parameters+ -- inherited by @M@, so instantiating @M@ from outside is unsound.+ rejectNamedWhereUnderWith :: C.WhereClause -> ScopeM ()+ rejectNamedWhereUnderWith = \case+ SomeWhere r _ x _ _+ | isUnderscore x -> return ()+ | otherwise -> setCurrentRange r $ typeError NamedWhereModuleUnderWith+ AnyWhere{} -> return ()+ NoWhere -> return ()+++whereToAbstract+ :: Range -- ^ The range of the @where@ block.+ -> C.WhereClause -- ^ The @where@ block.+ -> ScopeM a -- ^ The scope-checking task to be run in the context of the @where@ module.+ -> ScopeM (a, A.WhereDeclarations) -- ^ Additionally return the scope-checked contents of the @where@ module.+whereToAbstract r wh inner = do+ case wh of+ NoWhere -> ret+ AnyWhere _ [] -> warnEmptyWhere+ AnyWhere _ ds -> enter do+ -- Andreas, 2016-07-17 issues #2081 and #2101+ -- where-declarations are automatically private.+ -- Andreas, 2025-03-29+ -- While since PR #5192 (Feb 2021, issue #481) it is no longer the case+ -- that we check their type signatures in abstract mode,+ -- we still need to mark the declaration as private+ -- e.g. to avoid spurious UnknownFixityInMixfixDecl warnings (issue #2889).+ whereToAbstract1 r defaultErased Nothing+ (singleton $ C.Private empty Inserted ds) inner+ SomeWhere _ e m a ds0 -> enter $+ List1.ifNull ds0 warnEmptyWhere {-else-} \ ds ->+ -- Named where-modules do not default to private.+ whereToAbstract1 r e (Just (m, a)) ds inner+ where+ enter = localTC (set eCheckingWhere (C.whereClause_ wh))+ ret = (,A.noWhereDecls) <$> inner+ warnEmptyWhere = do+ setCurrentRange r $ warning EmptyWhere+ ret++whereToAbstract1+ :: Range -- ^ The range of the @where@-block.+ -> Erased -- ^ Is the where module erased?+ -> Maybe (C.Name, Access) -- ^ The name of the @where@ module (if any).+ -> List1 C.Declaration -- ^ The contents of the @where@ module.+ -> ScopeM a -- ^ The scope-checking task to be run in the context of the @where@ module.+ -> ScopeM (a, A.WhereDeclarations) -- ^ Additionally return the scope-checked contents of the @where@ module.+whereToAbstract1 r e whname whds inner = do+ -- ASR (16 November 2015) Issue 1137: We ban termination+ -- pragmas inside `where` clause.+ checkNoTerminationPragma InWhereBlock whds++ -- Create a fresh concrete name if there isn't (a proper) one.+ (m, acc) <- do+ case whname of+ Just (m, acc) | not (isNoName m) -> return (m, acc)+ _ -> fresh <&> \ x -> (C.NoName (getRange whname) x, privateAccessInserted)+ -- unnamed where's are private+ old <- getCurrentModule+ am <- toAbstract (NewModuleName m)+ (scope, d) <- scopeCheckModule r e (C.QName m) am [] $+ scopeCheckDeclarations $ List1.toList whds+ setScope scope+ x <- inner+ setCurrentModule old+ bindModule acc m am+ -- Issue 848: if the module was anonymous (module _ where) open it public+ let anonymousSomeWhere = maybe False (isNoName . fst) whname+ when anonymousSomeWhere $+ void $ -- We can ignore the returned default A.ImportDirective.+ openModule empty TopOpenModule (Just am) (C.QName m) $+ defaultImportDir { publicOpen = Just empty }+ return (x, A.WhereDecls (Just am) (isNothing whname) $ singleton d)++data WhereOrRecord = InWhereBlock | InRecordDef++checkNoTerminationPragma :: FoldDecl a => WhereOrRecord -> a -> ScopeM ()+checkNoTerminationPragma b ds =+ -- foldDecl traverses into all sub-declarations.+ forM_ (foldDecl (isPragma >=> isTerminationPragma) ds) \ r ->+ setCurrentRange r $ warning $ UselessPragma r $ P.vcat+ [ P.fwords $ "Termination pragmas are ignored in " ++ what b+ , "(see " <> issue b <> ")"+ ]+ where+ what InWhereBlock = "where clauses"+ what InRecordDef = "record definitions"+ issue InWhereBlock = P.githubIssue 3355+ issue InRecordDef = P.githubIssue 3008++ isTerminationPragma :: C.Pragma -> [Range]+ isTerminationPragma = \case+ C.TerminationCheckPragma r _ -> [r]+ C.NoPositivityCheckPragma _ -> []+ C.OptionsPragma _ _ -> []+ C.BuiltinPragma _ _ _ -> []+ C.RewritePragma _ _ _ -> []+ C.ForeignPragma _ _ _ -> []+ C.CompilePragma _ _ _ _ -> []+ C.StaticPragma _ _ -> []+ C.InlinePragma _ _ _ -> []+ C.ImpossiblePragma _ _ -> []+ C.EtaPragma _ _ -> []+ C.WarningOnUsage _ _ _ -> []+ C.WarningOnImport _ _ -> []+ C.InjectivePragma _ _ -> []+ C.InjectiveForInferencePragma{} -> []+ C.DisplayPragma _ _ _ -> []+ C.CatchallPragma _ -> []+ C.EtaEqualityPragma _ -> []+ C.NoCoverageCheckPragma _ -> []+ C.PolarityPragma _ _ _ -> []+ C.NoUniverseCheckPragma _ -> []+ C.NotProjectionLikePragma _ _ -> []+ C.OverlapPragma _ _ _ -> []++-- | The right-hand side of a clause, before scope checking.+--+-- Invariant (issue #8698): if this is a @with@ or @rewrite@ clause,+-- i.e. if @_rhsWithExpr@ is not 'null' or @_rhsRewriteEqn@ contains a+-- 'withAbstractingEqn', then neither @_rhsWhere@ nor the @where@ clause of+-- any of the @_rhsSubclauses@ is a named @where@ module ('SomeWhere').+-- This is established by 'toAbstract' for 'C.Clause', the only producer of+-- 'RightHandSide', which otherwise throws 'NamedWhereModuleUnderWith'.+--+data RightHandSide = RightHandSide+ { _rhsRewriteEqn :: [RewriteEqn' () A.BindName A.Pattern A.Expr]+ -- ^ @rewrite e | with p <- e in eq@ (many).+ , _rhsWithExpr :: [C.WithExpr]+ -- ^ @with e@ (many).+ , _rhsSubclauses :: (LocalVars, [C.Clause])+ -- ^ the subclauses spawned by a @with@.+ , _rhs :: C.RHS+ , _rhsWhere :: WhereClause+ -- ^ @where@ module.+ }++data AbstractRHS+ = AbsurdRHS'+ | WithRHS' (List1 A.WithExpr) (List1 (ScopeM C.Clause))+ -- ^ The with clauses haven't been translated yet+ | RHS' A.Expr C.Expr+ | RewriteRHS' [RewriteEqn' () A.BindName A.Pattern A.Expr] AbstractRHS A.WhereDeclarations++qualifyName_ :: A.Name -> ScopeM A.QName+qualifyName_ x = do+ m <- getCurrentModule+ return $ A.qualify m x++withFunctionName :: String -> ScopeM A.QName+withFunctionName s = do+ NameId i _ <- fresh+ qualifyName_ =<< freshName_ (s ++ show i)++instance ToAbstract (RewriteEqn' () A.BindName A.Pattern A.Expr) where+ type AbsOfCon (RewriteEqn' () A.BindName A.Pattern A.Expr) = A.RewriteEqn+ toAbstract = \case+ Rewrite es -> fmap Rewrite $ forM es $ \ (_, e) -> do+ qn <- withFunctionName "-rewrite"+ pure (qn, e)+ Invert _ pes -> do+ qn <- withFunctionName "-invert"+ pure $ Invert qn pes+ LeftLet pes -> pure $ LeftLet pes++instance ToAbstract C.RewriteEqn where+ type AbsOfCon C.RewriteEqn = RewriteEqn' () A.BindName A.Pattern A.Expr+ toAbstract = \case+ Rewrite es -> Rewrite <$> mapM toAbstract es+ Invert _ npes -> Invert () <$> do+ -- Given a list of irrefutable with expressions of the form @p <- e in q@+ let (nps, es) = List1.unzip+ $ fmap (\ (Named nm (p, e)) -> ((nm, p), e)) npes+ -- we first check the expressions @e@: the patterns may shadow some of the+ -- variables mentioned in them!+ es <- toAbstract es+ -- we then parse the pairs of patterns @p@ and names @q@ for the equality+ -- constraints of the form @p ≡ e@.+ nps <- forM nps $ \ (n, p) -> do+ -- first the pattern+ p <- toAbsPat p+ -- and then the name+ n <- toAbstract $ fmap (NewName WithBound . C.mkBoundName_) n+ pure (n, p)+ -- we finally reassemble the telescope+ pure $ List1.zipWith (\ (n,p) e -> Named n (p, e)) nps es+ LeftLet pes -> fmap LeftLet $ forM pes $ \ (p, e) -> do+ -- first check the expression: the pattern may shadow+ -- some of the variables mentioned in it!+ e <- toAbstract e+ p <- toAbsPat p+ pure (p, e)+ where+ toAbsPat p = do+ -- Expand puns if optHiddenArgumentPuns is True.+ p <- expandPunsOpt p+ p <- parsePattern p+ p <- toAbstract p+ checkPatternLinearity p (typeError . RepeatedVariablesInPattern)+ bindVarsToBind+ toAbstract p++instance ToAbstract AbstractRHS where+ type AbsOfCon AbstractRHS = A.RHS++ toAbstract AbsurdRHS' = return A.AbsurdRHS+ toAbstract (RHS' e c) = return $ A.RHS e $ Just c+ toAbstract (RewriteRHS' eqs rhs wh) = do+ eqs <- toAbstract eqs+ rhs <- toAbstract rhs+ return $ RewriteRHS eqs [] rhs wh+ toAbstract (WithRHS' es cs) = do+ aux <- withFunctionName "with-"+ A.WithRHS aux es <$> do toAbstract =<< sequence cs++instance ToAbstract RightHandSide where+ type AbsOfCon RightHandSide = AbstractRHS+ toAbstract (RightHandSide eqs@(_:_) es cs rhs wh) = do+ (rhs, ds) <- whereToAbstract (getRange wh) wh $+ toAbstract (RightHandSide [] es cs rhs NoWhere)+ return $ RewriteRHS' eqs rhs ds+ toAbstract (RightHandSide [] [] (_ , _:_) _ _) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] (_:_) _ (C.RHS _) _) = typeError BothWithAndRHS -- issue #7760+ toAbstract (RightHandSide [] [] (_ , []) rhs NoWhere) = toAbstract rhs+ toAbstract (RightHandSide [] (z:zs)(lv , c:cs) C.AbsurdRHS NoWhere) = do+ let (ns, es) = List1.unzipWith (\ (Named nm e) -> (NewName WithBound . C.mkBoundName_ <$> nm, e)) $ z :| zs+ es <- toAbstractCtx TopCtx es+ lvars0 <- getLocalVars+ ns <- toAbstract ns+ lvars1 <- getLocalVars+ let lv' = dropEnd (length lvars0) lvars1 ++ lv+ let cs' = for (c :| cs) $ \ c -> setLocalVars lv' $> c+ let nes = List1.zipWith Named ns es+ return $ WithRHS' nes cs'+ -- TODO: some of these might be possible+ toAbstract (RightHandSide [] (_ : _) _ C.AbsurdRHS AnyWhere{}) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] (_ : _) _ C.AbsurdRHS SomeWhere{}) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] (_ : _) _ C.AbsurdRHS NoWhere{}) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] [] (_, []) C.AbsurdRHS AnyWhere{}) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] [] (_, []) C.AbsurdRHS SomeWhere{}) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] [] (_, []) C.RHS{} AnyWhere{}) = __IMPOSSIBLE__+ toAbstract (RightHandSide [] [] (_, []) C.RHS{} SomeWhere{}) = __IMPOSSIBLE__++instance ToAbstract C.RHS where+ type AbsOfCon C.RHS = AbstractRHS++ toAbstract C.AbsurdRHS = return $ AbsurdRHS'+ toAbstract (C.RHS e) = RHS' <$> toAbstract e <*> pure e++-- | Wrapper to check lhs (possibly of a 'C.DisplayPragma').+--+data LeftHandSide = LeftHandSide+ C.QName+ -- ^ Name of the definition we are checking.+ C.Pattern+ -- ^ Full left hand side.+ DisplayLHS+ -- ^ Are we checking a 'C.DisplayPragma'?++instance ToAbstract LeftHandSide where+ type AbsOfCon LeftHandSide = A.LHS++ toAbstract (LeftHandSide top lhs displayLhs) =+ traceCall (ScopeCheckLHS top lhs) $ do+ reportSLn "scope.lhs" 25 $ "original lhs: " ++ prettyShow lhs+ reportSLn "scope.lhs" 60 $ "patternQNames: " ++ prettyShow (patternQNames lhs)+ reportSLn "scope.lhs" 90 $ "original lhs (raw): " ++ show lhs++ -- Expand puns if optHiddenArgumentPuns is True. Note that pun+ -- expansion should happen before the left-hand side is+ -- parsed, because {(x)} is not treated as a pun, whereas {x}+ -- is.+ lhs <- expandPunsOpt lhs+ reportSLn "scope.lhs" 25 $+ "lhs with expanded puns: " ++ prettyShow lhs+ reportSLn "scope.lhs" 60 $+ "lhs with expanded puns (raw): " ++ show lhs++ lhscore <- parseLHS displayLhs top lhs+ let ell = hasExpandedEllipsis lhscore+ reportSLn "scope.lhs" 25 $ "parsed lhs: " ++ prettyShow lhscore+ reportSLn "scope.lhs" 60 $ "parsed lhs (raw): " ++ show lhscore+ printLocals 30 "before lhs:"+ -- error if copattern parsed but --no-copatterns option+ unlessM (optCopatterns <$> pragmaOptions) $+ when (hasCopatterns lhscore) $+ typeError $ NeedOptionCopatterns+ -- scope check patterns except for dot patterns+ lhscore <- toAbstract $ CLHSCore displayLhs lhscore+ bindVarsToBind+ -- reportSLn "scope.lhs" 25 $ "parsed lhs patterns: " ++ prettyShow lhscore -- TODO: Pretty A.LHSCore'+ reportSLn "scope.lhs" 90 $ "parsed lhs patterns: " ++ show lhscore+ printLocals 30 "checked pattern:"+ -- scope check dot patterns+ lhscore <- toAbstract lhscore+ -- reportSLn "scope.lhs" 25 $ "parsed lhs dot patterns: " ++ prettyShow lhscore -- TODO: Pretty A.LHSCore'+ reportSLn "scope.lhs" 90 $ "parsed lhs dot patterns: " ++ show lhscore+ printLocals 30 "checked dots:"+ return $ A.LHS (LHSInfo (getRange lhs) ell) lhscore++-- | Expands hidden argument puns when option 'optHiddenArgumentPuns' is set.++expandPunsOpt :: C.Pattern -> ScopeM C.Pattern+expandPunsOpt p = do+ pragmaOptions <&> optHiddenArgumentPuns <&> \case+ True -> expandPuns p+ False -> p++-- | Expands hidden argument puns.++expandPuns :: C.Pattern -> C.Pattern+expandPuns = mapCPattern \case+ C.HiddenP r p -> C.HiddenP r $ expand p+ C.InstanceP r p -> C.InstanceP r $ expand p+ p -> p+ where+ -- Only patterns of the form {x} or ⦃ x ⦄, where x is an unqualified+ -- name (not @_@), are interpreted as puns.+ expand :: Named_ C.Pattern -> Named_ C.Pattern+ expand+ (Named { namedThing = C.IdentP _ q@(C.QName x@C.Name{})+ , nameOf = Nothing+ }) =+ Named { namedThing = C.IdentP False q+ , nameOf = Just $+ WithOrigin+ { woOrigin = ExpandedPun+ , woThing = unranged (prettyShow x)+ }+ }+ expand p = p++hasExpandedEllipsis :: C.LHSCore -> ExpandedEllipsis+hasExpandedEllipsis core = case core of+ C.LHSHead{} -> NoEllipsis+ C.LHSProj{} -> hasExpandedEllipsis $ namedArg $ C.lhsFocus core -- can this ever be ExpandedEllipsis?+ C.LHSWith{} -> hasExpandedEllipsis $ C.lhsHead core+ C.LHSEllipsis r p -> case p of+ C.LHSWith p wps _ -> hasExpandedEllipsis p <> ExpandedEllipsis r (length wps)+ C.LHSHead{} -> ExpandedEllipsis r 0+ C.LHSProj{} -> ExpandedEllipsis r 0+ C.LHSEllipsis{} -> __IMPOSSIBLE__++-- | Merges adjacent EqualP patterns into one:+-- type checking expects only one pattern for each domain in the telescope.+mergeEqualPs :: [NamedArg (Pattern' e)] -> ScopeM [NamedArg (Pattern' e)]+mergeEqualPs = go (empty, [])+ where+ go acc (p@(Arg ai (Named mn (A.EqualP r es))) : ps) = setCurrentRange p $ do+ -- Face constraint patterns must be defaultNamedArg; check this:+ unless (getModality ai == defaultModality) __IMPOSSIBLE__+ when (notVisible ai) $+ warning $ FaceConstraintCannotBeHidden ai+ whenJust mn $ \ x -> setCurrentRange x $+ warning $ FaceConstraintCannotBeNamed x+ go (acc `mappend` (r, List1.toList es)) ps+ go (r, (e:es)) ps = (defaultNamedArg (A.EqualP r $ e :| es) :) <$> mergeEqualPs ps+ go (_, []) [] = return []+ go (_, []) (p : ps) = (p :) <$> mergeEqualPs ps+++-- | Scope-check a 'C.LHSCore' (of possibly a 'C.DisplayForm').++data CLHSCore = CLHSCore+ DisplayLHS+ -- ^ Are we checking the left hand side of a 'C.DisplayForm'?+ C.LHSCore+ -- ^ The lhs to scope-check.++-- | Scope-check a 'C.LHSCore' not of a 'C.DisplayForm'.++instance ToAbstract C.LHSCore where+ type AbsOfCon C.LHSCore = A.LHSCore' C.Expr++ toAbstract = toAbstract . CLHSCore NoDisplayLHS++-- does not check pattern linearity+instance ToAbstract CLHSCore where+ type AbsOfCon CLHSCore = A.LHSCore' C.Expr++ toAbstract (CLHSCore displayLhs core0) = case core0 of++ C.LHSHead x ps -> do+ x <- withLocalVars do+ setLocalVars []+ toAbstractOldName x+ ps <- toAbstract $ (fmap . fmap . fmap) (CPattern displayLhs) ps+ A.LHSHead x <$> mergeEqualPs ps++ C.LHSProj d ps1 core ps2 -> do+ unless (null ps1) $ typeError $ IllformedProjectionPatternConcrete (foldl C.AppP (C.IdentP True d) ps1)+ x <- resolveName d >>= \case+ FieldName ds -> pure (ambigName ds)+ UnknownName -> notInScopeError d+ _ -> typeError $ CopatternHeadNotProjection d+ core <- toAbstract $ (fmap . fmap) (CLHSCore displayLhs) core+ ps2 <- toAbstract $ (fmap . fmap . fmap) (CPattern displayLhs) ps2+ A.LHSProj x core <$> mergeEqualPs ps2++ C.LHSWith core wps ps -> do+ -- DISPLAY pragmas cannot have @with@, so no need to pass on @displayLhs@.+ core <- toAbstract core+ wps <- fmap defaultArg <$> toAbstract wps+ ps <- toAbstract ps+ return $ A.lhsCoreApp (A.lhsCoreWith core wps) ps++ -- In case of a part of the LHS which was expanded from an ellipsis,+ -- we flush the @scopeVarsToBind@ in order to allow variables bound+ -- in the ellipsis to be shadowed.+ C.LHSEllipsis _ core -> do+ core <- toAbstract core -- Cannot come from a DISPLAY pragma.+ bindVarsToBind+ return core++instance ToAbstract c => ToAbstract (WithHiding c) where+ type AbsOfCon (WithHiding c) = WithHiding (AbsOfCon c)+ toAbstract (WithHiding h a) = WithHiding h <$> toAbstractHiding h a++instance ToAbstract c => ToAbstract (Arg c) where+ type AbsOfCon (Arg c) = Arg (AbsOfCon c)+ toAbstract (Arg info e) =+ Arg info <$> toAbstractHiding info e++instance ToAbstract c => ToAbstract (Named name c) where+ type AbsOfCon (Named name c) = Named name (AbsOfCon c)+ toAbstract = traverse toAbstract++instance ToAbstract c => ToAbstract (Ranged c) where+ type AbsOfCon (Ranged c) = Ranged (AbsOfCon c)+ toAbstract = traverse toAbstract++{- DOES NOT WORK ANYMORE with pattern synonyms+instance ToAbstract c a => ToAbstract (A.LHSCore' c) (A.LHSCore' a) where+ toAbstract = mapM toAbstract+-}++instance ToAbstract (A.LHSCore' C.Expr) where+ type AbsOfCon (A.LHSCore' C.Expr) = A.LHSCore' A.Expr+ toAbstract (A.LHSHead f ps) = A.LHSHead f <$> mapM toAbstract ps+ toAbstract (A.LHSProj d lhscore ps) = A.LHSProj d <$> mapM toAbstract lhscore <*> mapM toAbstract ps+ toAbstract (A.LHSWith core wps ps) = liftA3 A.LHSWith (toAbstract core) (toAbstract wps) (toAbstract ps)++-- Patterns are done in two phases. First everything but the dot patterns, and+-- then the dot patterns. This is because dot patterns can refer to variables+-- bound anywhere in the pattern.++instance ToAbstract (A.Pattern' C.Expr) where+ type AbsOfCon (A.Pattern' C.Expr) = A.Pattern' A.Expr+ toAbstract = traverse $ insideDotPattern . toAbstractCtx DotPatternCtx -- Issue #3033++resolvePatternIdentifier ::+ Bool+ -- ^ Is the identifier allowed to refer to a constructor (or a pattern synonym)?+ --+ -- Value 'False' is only used when 'optHiddenArgumentPuns' is 'True'.+ -- In this case, error 'InvalidPun' is thrown on identifiers that are not variables.+ -> DisplayLHS+ -- ^ Are definitions to be treated as constructors?+ -- 'True' when we are checking a 'C.DisplayForm'.+ -> Hiding+ -- ^ Is the pattern variable hidden?+ -> C.QName+ -- ^ Identifier.+ -> Maybe (Set1 A.Name)+ -- ^ Possibly precomputed resolutions of the identifier (from the operator parser).+ -> ScopeM (A.Pattern' C.Expr)+resolvePatternIdentifier canBeConstructor displayLhs h x ns = do+ reportSLn "scope.pat" 60 $ "resolvePatternIdentifier " ++ prettyShow x ++ " at source position " ++ prettyShow r+ toAbstract (PatName x ns h displayLhs) >>= \case++ VarPatName y -> do+ reportSLn "scope.pat" 60 $ " resolved to VarPatName " ++ prettyShow y ++ " with range " ++ prettyShow (getRange y)+ return $ VarP $ A.mkBindName y++ ConPatName ds -> do+ unless canBeConstructor $ err IsConstructor+ return $ ConP (ConPatInfo ConOCon info ConPatEager) (ambigName ds) []++ PatternSynPatName ds -> do+ unless canBeConstructor $ err IsPatternSynonym+ return $ PatternSynP info (ambigName ds) []++ DefPatName d -> do+ unless displayLhs __IMPOSSIBLE__+ return $ DefP info (unambigName d) []++ where+ r = getRange x+ info = PatRange r+ err s = setCurrentRange r $ typeError $ InvalidPun s x++-- | Apply an abstract syntax pattern head to pattern arguments.+--+-- Fails with 'InvalidPattern' if head is not a constructor pattern+-- (or similar) that can accept arguments.+--+applyAPattern+ :: C.Pattern -- ^ The application pattern in concrete syntax.+ -> A.Pattern' C.Expr -- ^ Head of application.+ -> NAPs1 C.Expr -- ^ Arguments of application.+ -> ScopeM (A.Pattern' C.Expr)+applyAPattern p0 p ps1 = do+ let ps = List1.toList ps1+ setRange (getRange p0) <$> do+ case p of+ A.ConP i x as -> return $ A.ConP i x (as ++ ps)+ A.DefP i x as -> return $ A.DefP i x (as ++ ps)+ A.PatternSynP i x as -> return $ A.PatternSynP i x (as ++ ps)+ -- Dotted constructors are turned into "lazy" constructor patterns.+ A.DotP i (Ident x) -> resolveName x >>= \case+ ConstructorName _ ds -> do+ let cpi = ConPatInfo ConOCon i ConPatLazy+ c = ambigName ds+ return $ A.ConP cpi c ps+ _ -> failure+ A.DotP{} -> failure+ A.VarP{} -> failure+ A.ProjP{} -> failure+ A.WildP{} -> failure+ A.AsP{} -> failure+ A.AbsurdP{} -> failure+ A.LitP{} -> failure+ A.RecP{} -> failure+ A.EqualP{} -> failure+ A.WithP{} -> failure+ where+ failure = typeError $ InvalidPattern p0++-- | Throw-away wrapper type for pattern translation.+data WithHidingInfo a = WithHidingInfo Hiding a++propagateHidingInfo :: NamedArg a -> NamedArg (WithHidingInfo a)+propagateHidingInfo a = fmap (fmap $ WithHidingInfo $ getHiding a) a++-- | Hiding info is only used for pattern variables.+instance ToAbstract (WithHidingInfo C.Pattern) where+ type AbsOfCon (WithHidingInfo C.Pattern) = A.Pattern' C.Expr++ toAbstract (WithHidingInfo h (C.IdentP canBeConstructor x)) =+ resolvePatternIdentifier canBeConstructor NoDisplayLHS h x Nothing++ toAbstract (WithHidingInfo _ p) = toAbstract p++-- | Scope check a 'C.Pattern' (of possibly a 'C.DisplayForm').+--+data CPattern = CPattern+ DisplayLHS+ -- ^ Are we checking a 'C.DisplayForm'?+ C.Pattern+ -- ^ The pattern to scope-check.++-- | Scope check a 'C.Pattern' not belonging to a 'C.DisplayForm'.+--+instance ToAbstract C.Pattern where+ type AbsOfCon C.Pattern = A.Pattern' C.Expr++ toAbstract = toAbstract . CPattern NoDisplayLHS++instance ToAbstract CPattern where+ type AbsOfCon CPattern = A.Pattern' C.Expr++ toAbstract (CPattern displayLhs p0) = do+ case p0 of++ C.IdentP canBeConstructor x ->+ resolvePatternIdentifier canBeConstructor displayLhs empty x Nothing++ QuoteP _r ->+ typeError $ CannotQuote CannotQuoteNothing++ AppP (QuoteP _) p+ | IdentP _ x <- namedArg p -> do+ if visible p then do+ e <- toAbstract (OldQName x Nothing)+ A.LitP (PatRange $ getRange x) . LitQName <$> quotedName e+ else typeError $ CannotQuote CannotQuoteHidden+ | otherwise -> typeError $ CannotQuote $ CannotQuotePattern p++ AppP p q -> do+ reportSLn "scope.pat" 50 $ "distributeDots before = " ++ show p+ p <- distributeDots p+ reportSLn "scope.pat" 50 $ "distributeDots after = " ++ show p+ p' <- toAbstract (wrap p)+ -- Remember hiding info in argument to propagate to 'PatternBound'.+ q' <- ifThenElse displayLhs+ {-then-} (toAbstract $ (fmap . fmap) wrap q)+ {-else-} (toAbstract $ propagateHidingInfo q)+ applyAPattern p0 p' $ singleton q'++ where+ distributeDots :: C.Pattern -> ScopeM C.Pattern+ distributeDots p@(C.DotP kwr r _ppp e) = distributeDotsExpr kwr r e+ distributeDots p = return p++ distributeDotsExpr :: KwRange -> Range -> C.Expr -> ScopeM C.Pattern+ distributeDotsExpr kwr r e = parseRawApp e >>= \case+ C.App r e a ->+ AppP <$> distributeDotsExpr empty r e+ <*> (traverse . traverse) (distributeDotsExpr empty r) a+ OpApp r q ns as ->+ case (traverse . traverse . traverse) fromNoPlaceholder as of+ Just as -> OpAppP r q ns <$>+ (traverse . traverse . traverse) (distributeDotsExpr empty r) as+ Nothing -> return $ C.DotP empty r CannotBeProjectionPattern e+ Paren r e -> ParenP r <$> distributeDotsExpr empty r e+ _ -> return $ C.DotP kwr r CannotBeProjectionPattern e++ fromNoPlaceholder :: MaybePlaceholder (OpApp a) -> Maybe a+ fromNoPlaceholder (NoPlaceholder _ (Ordinary e)) = Just e+ fromNoPlaceholder _ = Nothing++ parseRawApp :: C.Expr -> ScopeM C.Expr+ parseRawApp (RawApp r es) = parseApplication es+ parseRawApp e = return e++ OpAppP r op ns ps -> do+ reportSLn "scope.pat" 60 $ "ConcreteToAbstract.toAbstract OpAppP{}: " ++ show p0+ p <- resolvePatternIdentifier True displayLhs empty op (Just ns)+ -- Remember hiding info in arguments to propagate to 'PatternBound'.+ ps <- ifThenElse displayLhs+ {-then-} (toAbstract $ (fmap . fmap . fmap) wrap ps)+ {-else-} (toAbstract $ fmap propagateHidingInfo ps)+ applyAPattern p0 p ps++ EllipsisP _ mp -> maybe __IMPOSSIBLE__ toAbstract mp -- Not in DISPLAY pragma++ -- Removed when parsing+ HiddenP _ _ -> __IMPOSSIBLE__+ InstanceP _ _ -> __IMPOSSIBLE__+ RawAppP _ _ -> __IMPOSSIBLE__++ C.WildP r -> return $ A.WildP $ PatRange r+ -- Andreas, 2015-05-28 futile attempt to fix issue 819: repeated variable on lhs "_"+ -- toAbstract p@(C.WildP r) = A.VarP <$> freshName r "_"+ C.ParenP _ p -> toAbstract $ wrap p -- Andreas, 2024-09-27 not impossible+ C.LitP r l -> setCurrentRange r $ A.LitP (PatRange r) l <$ checkLiteral l++ C.AsP r x p -> do+ -- Andreas, 2018-06-30, issue #3147: as-variables can be non-linear a priori!+ -- x <- toAbstract (NewName PatternBound x)+ -- Andreas, 2020-05-01, issue #4631: as-variables should not shadow constructors.+ -- x <- bindPatternVariable x+ toAbstract (PatName (C.QName x) Nothing empty NoDisplayLHS) >>= \case+ VarPatName x -> A.AsP (PatRange r) (A.mkBindName x) <$> toAbstract (wrap p)+ ConPatName{} -> ignoreAsPat IsConstructor+ PatternSynPatName{} -> ignoreAsPat IsPatternSynonym+ DefPatName{} -> __IMPOSSIBLE__ -- because of @False@ in @PatName@+ where+ -- An @-bound name which shadows a constructor is illegal and becomes dead code.+ ignoreAsPat b = do+ setCurrentRange x $ warning $ AsPatternShadowsConstructorOrPatternSynonym b+ toAbstract $ wrap p++ C.EqualP r es -> return $ A.EqualP (PatRange r) es++ -- We have to do dot patterns at the end since they can+ -- refer to the variables bound by the other patterns.+ C.DotP _kwr r CannotBeProjectionPattern e -> return $ A.DotP (PatRange r) e+ C.DotP _kwr r CouldBeProjectionPattern e -> do+ reportSLn "scope.pat" 90 $ "ConcreteToAbstract.toAbstract DotP{}: " ++ show p0+ case e of+ C.Ident x -> resolveName x >>= \case+ -- Andreas, 2018-06-19, #3130+ -- We interpret .x as postfix projection if x is a field name in scope+ FieldName xs -> do+ reportSLn "scope.pat" 80 $ "ConcreteToAbstract.toAbstract DotP{}: returning A.ProjP{}"+ return $ A.ProjP (PatRange r) ProjPostfix $ ambigName xs+ _ -> fallback+ _ -> fallback+ where+ fallback = do+ reportSLn "scope.pat" 80 $ "ConcreteToAbstract.toAbstract DotP{}: returning A.DotP{}"+ return $ A.DotP (PatRange r) e++ C.AbsurdP r -> return $ A.AbsurdP $ PatRange r+ C.RecP kwr r fs -> A.RecP kwr (ConPatInfo ConORec (PatRange r) ConPatEager) <$> mapM (traverse $ toAbstract . wrap) fs+ C.WithP r p -> A.WithP (PatRange r) <$> toAbstract p -- not in DISPLAY pragma++ where+ -- Pass on @displayLhs@ context+ wrap = CPattern displayLhs++-- | An argument @OpApp C.Expr@ to an operator can have binders,+-- in case the operator is some @syntax@-notation.+-- For these binders, we have to create lambda-abstractions.+toAbstractOpArg :: Precedence -> OpApp C.Expr -> ScopeM (Ranged A.Expr)+toAbstractOpArg ctx (Ordinary e) = Ranged (getRange e) <$> toAbstractCtx ctx e+toAbstractOpArg ctx (SyntaxBindingLambda r bs e) = Ranged r <$> toAbstractLam r bs e ctx++-- | Turn an operator application into abstract syntax. Make sure to+-- record the right precedences for the various arguments.+toAbstractOpApp :: C.QName -> Set1 A.Name -> OpAppArgs -> ScopeM A.Expr+toAbstractOpApp op ns es = do+ -- Replace placeholders with bound variables.+ (binders, es) <- replacePlaceholders $ List1.toList es+ -- Get the notation for the operator.+ nota <- getNotation op ns+ let parts = notation nota+ -- We can throw away the @VarPart@s, since binders+ -- have been preprocessed into @OpApp C.Expr@.+ let nonBindingParts = filter (not . isBinder) parts+ -- We should be left with as many holes as we have been given args @es@.+ -- If not, crash.+ unless (length (filter isAHole nonBindingParts) == length es) __IMPOSSIBLE__+ -- Translate operator and its arguments (each in the right context).+ op <- toAbstract (OldQName op (Just ns))+ es <- left (notaFixity nota) nonBindingParts es+ -- Prepend the generated section binders (if any).+ let body = List.foldl' app op es+ return $ foldr (A.Lam (ExprRange (getRange body))) body binders+ where+ -- Build an application in the abstract syntax, with correct Range.+ app e (pref, argR) = A.App info e arg+ where arg = (fmap rangedThing) <$> argR+ info = (defaultAppInfo r) { appOrigin = getOrigin arg+ , appParens = pref }+ r = fuseRange e argR++ inferParenPref :: NamedArg (Either A.Expr (OpApp C.Expr)) -> ParenPreference+ inferParenPref e =+ case namedArg e of+ Right (Ordinary e) -> inferParenPreference e+ Left{} -> PreferParenless -- variable inserted by section expansion+ Right{} -> PreferParenless -- syntax lambda++ -- Translate an argument. Returns the paren preference for the argument, so+ -- we can build the correct info for the A.App node.+ toAbsOpArg :: Precedence ->+ NamedArg (Either A.Expr (OpApp C.Expr)) ->+ ScopeM (ParenPreference, NamedArg (Ranged A.Expr))+ toAbsOpArg cxt e = (pref,) <$> (traverse . traverse) (either (return . Ranged noRange) (toAbstractOpArg cxt)) e+ where pref = inferParenPref e++ -- The hole left to the first @IdPart@ is filled with an expression in @LeftOperandCtx@.+ left :: Fixity+ -> [NotationPart]+ -> [NamedArg (Either A.Expr (OpApp C.Expr))]+ -> ScopeM [(ParenPreference, NamedArg (Ranged A.Expr))]+ left f (IdPart _ : xs) es = inside f xs es+ left f (_ : xs) (e : es) = do+ e <- toAbsOpArg (LeftOperandCtx f) e+ es <- inside f xs es+ return (e : es)+ left f (_ : _) [] = __IMPOSSIBLE__+ left f [] _ = __IMPOSSIBLE__++ -- The holes in between the @IdPart@s are filled with an expression in @InsideOperandCtx@.+ inside :: Fixity+ -> [NotationPart]+ -> [NamedArg (Either A.Expr (OpApp C.Expr))]+ -> ScopeM [(ParenPreference, NamedArg (Ranged A.Expr))]+ inside f [x] es = right f x es+ inside f (IdPart _ : xs) es = inside f xs es+ inside f (_ : xs) (e : es) = do+ e <- toAbsOpArg InsideOperandCtx e+ es <- inside f xs es+ return (e : es)+ inside _ [] [] = return []+ inside _ (_ : _) [] = __IMPOSSIBLE__+ inside _ [] (_ : _) = __IMPOSSIBLE__++ -- The hole right of the last @IdPart@ is filled with an expression in @RightOperandCtx@.+ right :: Fixity+ -> NotationPart+ -> [NamedArg (Either A.Expr (OpApp C.Expr))]+ -> ScopeM [(ParenPreference, NamedArg (Ranged A.Expr))]+ right _ (IdPart _) [] = return []+ right f _ [e] = do+ let pref = inferParenPref e+ e <- toAbsOpArg (RightOperandCtx f pref) e+ return [e]+ right _ _ _ = __IMPOSSIBLE__++ replacePlaceholders ::+ OpAppArgs0 e ->+ ScopeM ([A.LamBinding], [NamedArg (Either A.Expr (OpApp e))])+ replacePlaceholders [] = return ([], [])+ replacePlaceholders (a : as) = case namedArg a of+ NoPlaceholder _ x -> second (set (Right x) a :) <$>+ replacePlaceholders as+ Placeholder _ -> do+ x <- freshName noRange "section"+ let i = setOrigin Inserted $ argInfo a+ (ls, ns) <- replacePlaceholders as+ return ( A.mkDomainFree (unnamedArg i $ A.insertedBinder_ x) : ls+ , set (Left (Var x)) a : ns+ )+ where+ set :: a -> NamedArg b -> NamedArg a+ set x arg = fmap (fmap (const x)) arg++-- | Raises an error if the list of attributes contains an unsupported+-- attribute.++checkAttributes :: Attributes -> ScopeM ()+checkAttributes [] = return ()+checkAttributes (Attr r s attr : attrs) =+ case attr of+ RelevanceAttribute{} -> cont+ CA.TacticAttribute{} -> cont+ LockAttribute IsNotLock -> cont+ LockAttribute IsLock{} -> do+ unlessM (optGuarded <$> pragmaOptions) $+ setCurrentRange r $ typeError $ AttributeKindNotEnabled "Lock" "--guarded" s+ cont+ RewriteAttribute rew -> do+ when (isRewrite rew) $ unlessM localRewritingOption $+ setCurrentRange r $ typeError $ AttributeKindNotEnabled "Rewrite" "--local-rewriting" s+ cont+ QuantityAttribute Quantityω{} -> cont+ QuantityAttribute Quantity1{} -> __IMPOSSIBLE__+ QuantityAttribute Quantity0{} -> do+ unlessM (optErasure <$> pragmaOptions) $+ setCurrentRange r $ typeError $ AttributeKindNotEnabled "Erasure" "--erasure" s+ cont+ CohesionAttribute{} -> do+ unlessM (optCohesion <$> pragmaOptions) $+ setCurrentRange r $ typeError $ AttributeKindNotEnabled "Cohesion" "--cohesion" s+ cont+ PolarityAttribute{} -> do+ unlessM (optPolarity <$> pragmaOptions) $+ setCurrentRange r $ typeError $ AttributeKindNotEnabled "Polarity" "--polarity" s+ cont+ where+ cont = checkAttributes attrs++{--------------------------------------------------------------------------+ Things we parse but are not part of the Agda file syntax+ --------------------------------------------------------------------------}++-- | Content of interaction hole.++instance ToAbstract C.HoleContent where+ type AbsOfCon C.HoleContent = A.HoleContent+ toAbstract = \case+ HoleContentExpr e -> HoleContentExpr <$> toAbstract e+ HoleContentRewrite es -> HoleContentRewrite <$> toAbstract es
@@ -1,588 +1,1700 @@-{-# LANGUAGE CPP, MultiParamTypeClasses, FunctionalDependencies,- UndecidableInstances, TypeSynonymInstances, FlexibleInstances- #-}--{-|- Translating from internal syntax to abstract syntax. Enables nice- pretty printing of internal syntax.-- TODO-- - numbers on metas- - fake dependent functions to independent functions- - meta parameters- - shadowing--}-module Agda.Syntax.Translation.InternalToAbstract where--import Prelude hiding (mapM_, mapM)-import Control.Applicative-import Control.Arrow-import Control.Monad.State hiding (mapM_, mapM)-import Control.Monad.Error hiding (mapM_, mapM)--import qualified Data.Set as Set-import Data.Set (Set)-import qualified Data.Map as Map-import Data.Map (Map)-import Data.List hiding (sort)-import Data.Traversable--import Agda.Syntax.Literal-import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Info as Info-import Agda.Syntax.Fixity-import Agda.Syntax.Abstract as A-import qualified Agda.Syntax.Concrete as C-import Agda.Syntax.Internal as I-import Agda.Syntax.Scope.Base-import Agda.Syntax.Scope.Monad--import Agda.TypeChecking.Monad as M-import Agda.TypeChecking.Reduce-import {-# SOURCE #-} Agda.TypeChecking.Records-import Agda.TypeChecking.DisplayForm-import Agda.TypeChecking.Level-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Datatypes-import Agda.TypeChecking.Free-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Telescope--import Agda.Utils.Monad-import Agda.Utils.Tuple-import Agda.Utils.Permutation-import Agda.Utils.Size--#include "../../undefined.h"-import Agda.Utils.Impossible--apps :: (Expr, [Arg Expr]) -> TCM Expr-apps (e, []) = return e-apps (e, arg : args) | isHiddenArg arg =- do showImp <- showImplicitArguments- if showImp then apps (App exprInfo e (unnamed <$> arg), args)- else apps (e, args)-apps (e, arg:args) =- apps (App exprInfo e (unnamed <$> arg), args)--exprInfo :: ExprInfo-exprInfo = ExprRange noRange--reifyApp :: Expr -> [Arg Term] -> TCM Expr-reifyApp e vs = curry apps e =<< reify vs--class Reify i a | i -> a where- reify :: i -> TCM a--instance Reify MetaId Expr where- reify x@(MetaId n) = liftTCM $ do- mi <- getMetaInfo <$> lookupMeta x- let mi' = Info.MetaInfo (getRange mi)- (M.clScope mi)- (Just n)- ifM shouldReifyInteractionPoints- (do iis <- map (snd /\ fst) . Map.assocs- <$> gets stInteractionPoints- case lookup x iis of- Just ii@(InteractionId n)- -> return $ A.QuestionMark $ mi' {metaNumber = Just n}- Nothing -> return $ A.Underscore mi'- ) (return $ A.Underscore mi')--instance Reify DisplayTerm Expr where- reify d = case d of- DTerm v -> reify v- DDot v -> reify v- DCon c vs -> curry apps (A.Con (AmbQ [c])) =<< reify vs- DDef f vs -> curry apps (A.Def f) =<< reify vs- DWithApp us vs -> do- us <- reify us- let wapp [e] = e- wapp (e : es) = A.WithApp exprInfo e es- wapp [] = __IMPOSSIBLE__- reifyApp (wapp us) vs--reifyDisplayForm :: QName -> Args -> TCM A.Expr -> TCM A.Expr-reifyDisplayForm x vs fallback = do- enabled <- displayFormsEnabled- if enabled- then do- md <- liftTCM $ displayForm x vs- case md of- Nothing -> fallback- Just d -> reify d- else fallback--reifyDisplayFormP :: A.LHS -> TCM A.LHS-reifyDisplayFormP lhs@(A.LHS i x ps wps) =- ifM (not <$> displayFormsEnabled) (return lhs) $ do- let vs = [ Arg h Relevant $ I.Var n [] | (n, h) <- zip [0..] $ map argHiding ps]- md <- liftTCM $ displayForm x vs- reportSLn "syntax.reify.display" 20 $- "display form of " ++ show x ++ " " ++ show ps ++ " " ++ show wps ++ ":\n " ++ show md- case md of- Just d | okDisplayForm d ->- reifyDisplayFormP =<< displayLHS (map (namedThing . unArg) ps) wps d- _ -> return lhs- where- okDisplayForm (DWithApp (d : ds) []) =- okDisplayForm d && all okDisplayTerm ds- okDisplayForm (DTerm (I.Def f vs)) = all okArg vs- okDisplayForm (DDef f vs) = all okDArg vs- okDisplayForm DDot{} = False- okDisplayForm DCon{} = False- okDisplayForm DTerm{} = True -- False?- okDisplayForm DWithApp{} = True -- False?-- okDisplayTerm (DTerm v) = okTerm v- okDisplayTerm DDot{} = True- okDisplayTerm DCon{} = True- okDisplayTerm DDef{} = False- okDisplayTerm _ = False-- okDArg = okDisplayTerm . unArg- okArg = okTerm . unArg-- okTerm (I.Var _ []) = True- okTerm (I.Con c vs) = all okArg vs- okTerm (I.Def x []) = show x == "_" -- Handling wildcards in display forms- okTerm _ = True -- False-- flattenWith (DWithApp (d : ds) []) = case flattenWith d of- (f, vs, ds') -> (f, vs, ds' ++ ds)- flattenWith (DDef f vs) = (f, vs, [])- flattenWith (DTerm (I.Def f vs)) = (f, map (fmap DTerm) vs, [])- flattenWith _ = __IMPOSSIBLE__-- displayLHS ps wps d = case flattenWith d of- (f, vs, ds) -> do- ds <- mapM termToPat ds- vs <- mapM argToPat vs- return $ LHS i f vs (ds ++ wps)- where- info = PatRange noRange- argToPat arg = fmap unnamed <$> traverse termToPat arg-- len = genericLength ps-- termToPat :: DisplayTerm -> TCM A.Pattern- termToPat (DTerm (I.Var n [])) = return $ ps !! fromIntegral n- termToPat (DCon c vs) = A.ConP info (AmbQ [c]) <$> mapM argToPat vs- termToPat (DDot v) = A.DotP info <$> termToExpr v- termToPat (DDef _ []) = return $ A.WildP info- termToPat (DTerm (I.Con c vs)) = A.ConP info (AmbQ [c]) <$> mapM (argToPat . fmap DTerm) vs- termToPat (DTerm (I.Def _ [])) = return $ A.WildP info- termToPat v = A.DotP info <$> reify v -- __IMPOSSIBLE__-- argsToExpr = mapM (traverse termToExpr)-- -- TODO: restructure this to avoid having to repeat the code for reify- termToExpr :: Term -> TCM A.Expr- termToExpr (I.Var n [])- | n < len = return $ patToTerm $ ps !! fromIntegral n- termToExpr (I.Con c vs) =- curry apps (A.Con (AmbQ [c])) =<< argsToExpr vs- termToExpr (I.Def f vs) =- curry apps (A.Def f) =<< argsToExpr vs- termToExpr (I.Var n vs) =- apps =<< (,) <$> reify (I.Var (n - len) []) <*> argsToExpr vs- termToExpr _ = return $ A.Underscore minfo-- minfo = MetaInfo noRange emptyScopeInfo Nothing- einfo = ExprRange noRange- app = foldl (App einfo)-- patToTerm :: A.Pattern -> A.Expr- patToTerm (A.VarP x) = A.Var x- patToTerm (A.ConP _ c ps) =- A.Con c `app` map (fmap (fmap patToTerm)) ps- patToTerm (A.DefP _ f ps) =- A.Def f `app` map (fmap (fmap patToTerm)) ps- patToTerm (A.WildP _) = A.Underscore minfo- patToTerm (A.AsP _ _ p) = patToTerm p- patToTerm (A.DotP _ e) = e- patToTerm (A.AbsurdP _) = A.Underscore minfo -- TODO: could this happen?- patToTerm (A.LitP l) = A.Lit l- patToTerm (A.ImplicitP _) = A.Underscore minfo--instance Reify Literal Expr where- reify l@(LitInt {}) = return (A.Lit l)- reify l@(LitFloat {}) = return (A.Lit l)- reify l@(LitString {}) = return (A.Lit l)- reify l@(LitChar {}) = return (A.Lit l)- reify l@(LitQName {}) = return (A.Lit l)--instance Reify Term Expr where- reify v = do- v <- instantiate v- case v of- I.Var n vs -> do- x <- liftTCM $ nameOfBV n `catchError` \_ -> freshName_ ("@" ++ show n)- reifyApp (A.Var x) vs- I.Def x@(QName _ name) vs -> reifyDisplayForm x vs $ do- mdefn <- liftTCM $ (Just <$> getConstInfo x) `catchError` \_ -> return Nothing- (pad, vs) <-- case mdefn of- Nothing -> (,) [] <$> (flip genericDrop vs <$> getDefFreeVars x)- Just defn -> do- let def = theDef defn- -- This is tricky:- -- * getDefFreeVars x tells us how many arguments- -- are part of the local context- -- * some of those arguments might have been dropped- -- due to projection likeness- -- * when showImplicits is on we'd like to see the dropped- -- projection arguments-- -- We should drop this many arguments from the local context.- n <- getDefFreeVars x- -- These are the dropped projection arguments- pad <- case def of- Function{ funProjection = Just (_, np) } -> do- TelV tel _ <- telView (defType defn)- scope <- getScope- let as = take (np - 1) $ telToList tel- whocares = A.Underscore (Info.MetaInfo noRange scope Nothing)- return $ map (fmap $ const whocares) as- _ -> return []- -- Now pad' ++ vs' = drop n (pad ++ vs)- let pad' = genericDrop n pad- vs' = genericDrop (max 0 (n - size pad)) vs- -- If showImplicit then keep the padding otherwise ignore it- ifM showImplicitArguments- (return (pad', vs'))- (return ([], vs'))- df <- displayFormsEnabled- if df && isPrefixOf extendlambdaname (show name)- then do- reportSLn "int2abs.reifyterm.def" 10 $ "reifying extended lambda with definition: " ++ show x- info <- getConstInfo x- cls <- mapM (reify . (NamedClause x)) $ defClauses info- -- Karim: Currently Abs2Conc does not require a DefInfo thus we- -- use __IMPOSSIBLE__.- reifyApp (A.ExtendedLam exprInfo __IMPOSSIBLE__ x cls) vs- else- let apps = foldl (\e a -> A.App exprInfo e (fmap unnamed a)) in- reifyApp (A.Def x `apps` pad) vs- I.Con x vs -> do- isR <- isGeneratedRecordConstructor x- case isR of- True -> do- showImp <- showImplicitArguments- let keep (a, v) = showImp || argHiding a == NotHidden- r <- getConstructorData x- xs <- getRecordFieldNames r- vs <- reify $ map unArg vs- return $ A.Rec exprInfo $ map (unArg *** id) $ filter keep $ zip xs vs- False -> reifyDisplayForm x vs $ do- -- let hide a = a { argHiding = Hidden }- Constructor{conPars = np} <- theDef <$> getConstInfo x- scope <- getScope- let whocares = A.Underscore (Info.MetaInfo noRange scope Nothing)- us = replicate (fromIntegral np) $ Arg Hidden Relevant whocares- n <- getDefFreeVars x- es <- reify vs- apps (A.Con (AmbQ [x]), genericDrop n $ us ++ es)- I.Lam h b -> do- (x,e) <- reify b- return $ A.Lam exprInfo (DomainFree h Relevant x) e- -- Andreas, 2011-04-07 we do not need relevance information at internal Lambda- I.Lit l -> reify l- I.Level l -> reify l- I.Pi a b -> case b of- NoAbs _ b -> uncurry (A.Fun $ exprInfo) <$> reify (a,b)- b -> do- Arg h r a <- reify a- (x, b) <- reify b- return $ A.Pi exprInfo [TypedBindings noRange $ Arg h r (TBind noRange [x] a)] b- I.Sort s -> reify s- I.MetaV x vs -> apps =<< reify (x,vs)- I.DontCare v -> A.DontCare <$> reify v-{- Andreas: I want to see irrelevant, but not implicit arguments- ifM showImplicitArguments- (reify v)- (return A.DontCare)--}-{- Andreas, 2011-09-09- I.DontCare Nothing -> return A.DontCare- I.DontCare (Just v) -> reify v -- leads to paradox error msg in test/fail/UnifyWithIrrelevantArgument--}--instance Reify Elim Expr where- reify e = case e of- I.Apply v -> appl "apply" <$> reify v- I.Proj f -> appl "proj" <$> reify (defaultArg $ I.Def f [])- where- appl :: String -> Arg Expr -> Expr- appl s v = A.App exprInfo (A.Lit (LitString noRange s)) $ fmap unnamed v--data NamedClause = NamedClause QName I.Clause--- Named clause does not need 'Recursion' flag since I.Clause has it--- data NamedClause = NamedClause QName Recursion I.Clause--instance Reify ClauseBody RHS where- reify NoBody = return AbsurdRHS- reify (Body v) = RHS <$> reify v- reify (Bind b) = reify $ absBody b -- the variables should already be bound--stripImplicits :: [NamedArg A.Pattern] -> [A.Pattern] ->- TCM ([NamedArg A.Pattern], [A.Pattern])-stripImplicits ps wps =- ifM showImplicitArguments (return (ps, wps)) $ do- let vars = dotVars (ps, wps)- reportSLn "syntax.reify.implicit" 30 $ unlines- [ "stripping implicits"- , " ps = " ++ show ps- , " wps = " ++ show wps- , " vars = " ++ show vars- ]- let allps = ps ++ map (defaultArg . unnamed) wps- sps = foldl (.) (strip vars) (map rearrangeBinding $ Set.toList vars) $ allps- (ps', wps') = splitAt (length sps - length wps) sps- reportSLn "syntax.reify.implicit" 30 $ unlines- [ " ps' = " ++ show ps'- , " wps' = " ++ show (map (namedThing . unArg) wps')- ]- return (ps', map (namedThing . unArg) wps')- where- argsVars = Set.unions . map argVars- argVars = patVars . namedThing . unArg- patVars p = case p of- A.VarP x -> Set.singleton x- A.ConP _ _ ps -> argsVars ps- A.DefP _ _ ps -> Set.empty- A.DotP _ e -> Set.empty- A.WildP _ -> Set.empty- A.AbsurdP _ -> Set.empty- A.LitP _ -> Set.empty- A.ImplicitP _ -> Set.empty- A.AsP _ _ p -> patVars p-- -- Pick the "best" place to bind the variable. Best in this case- -- is the left-most explicit binding site. But, of course we can't- -- do this since binding site might be forced by a parent clause.- -- Why? Because the binding site we pick might not exist in the- -- generated with function if it corresponds to a dot pattern.- rearrangeBinding x ps = ps-- strip dvs ps = stripArgs ps- where- stripArgs [] = []- stripArgs (a : as) = case argHiding a of- Hidden | canStrip a as -> stripArgs as- _ -> stripArg a : stripArgs as-- canStrip a as = and- [ varOrDot p- , noInterestingBindings p- , all (flip canStrip []) $ takeWhile ((Hidden ==) . argHiding) as- ]- where p = namedThing $ unArg a-- stripArg a = fmap (fmap stripPat) a-- stripPat p = case p of- A.VarP _ -> p- A.ConP i c ps -> A.ConP i c $ stripArgs ps- A.DefP _ _ _ -> p- A.DotP _ e -> p- A.WildP _ -> p- A.AbsurdP _ -> p- A.LitP _ -> p- A.ImplicitP _ -> p- A.AsP i x p -> A.AsP i x $ stripPat p-- noInterestingBindings p =- Set.null $ dvs `Set.intersection` patVars p-- varOrDot A.VarP{} = True- varOrDot A.WildP{} = True- varOrDot A.DotP{} = True- varOrDot A.ImplicitP{} = True- varOrDot _ = False---- | @dotVars ps@ gives all the variables inside of dot patterns of @ps@--- It is only invoked for patternish things. (Ulf O-tone!)--- Use it for printing l.h.sides: which of the implicit arguments--- have to be made explicit.-class DotVars a where- dotVars :: a -> Set Name--instance DotVars a => DotVars (Arg a) where- dotVars a = if isHiddenArg a then Set.empty else dotVars (unArg a)--instance DotVars a => DotVars (Named s a) where- dotVars = dotVars . namedThing--instance DotVars a => DotVars [a] where- dotVars = Set.unions . map dotVars--instance (DotVars a, DotVars b) => DotVars (a, b) where- dotVars (x, y) = Set.union (dotVars x) (dotVars y)---instance DotVars A.Clause where- dotVars (A.Clause _ rhs []) = dotVars rhs- dotVars (A.Clause _ rhs (_:_)) = __IMPOSSIBLE__ -- cannot contain where clauses?--instance DotVars A.Pattern where- dotVars p = case p of- A.VarP _ -> Set.empty -- do not add pattern vars- A.ConP _ _ ps -> dotVars ps- A.DefP _ _ ps -> dotVars ps- A.DotP _ e -> dotVars e- A.WildP _ -> Set.empty- A.AbsurdP _ -> Set.empty- A.LitP _ -> Set.empty- A.ImplicitP _ -> Set.empty- A.AsP _ _ p -> dotVars p---- | Getting all(!) variables of an expression.--- It should only get free ones, but it does not matter to include--- the bound ones.-instance DotVars A.Expr where- dotVars e = case e of- A.ScopedExpr _ e -> dotVars e- A.Var x -> Set.singleton x -- add any expression variable- A.Def _ -> Set.empty- A.Con _ -> Set.empty- A.Lit _ -> Set.empty- A.QuestionMark _ -> Set.empty- A.Underscore _ -> Set.empty- A.App _ e1 e2 -> dotVars (e1, e2)- A.WithApp _ e es -> dotVars (e, es)- A.Lam _ _ e -> dotVars e- A.AbsurdLam _ _ -> Set.empty- A.ExtendedLam _ _ _ cs -> dotVars cs- A.Pi _ tel e -> dotVars (tel, e)- A.Fun _ a b -> dotVars (a, b)- A.Set _ _ -> Set.empty- A.Prop _ -> Set.empty- A.Let _ _ _ -> __IMPOSSIBLE__- A.Rec _ es -> dotVars $ map snd es- A.RecUpdate _ e es -> dotVars (e, map snd es)- A.ETel _ -> __IMPOSSIBLE__- A.QuoteGoal {} -> __IMPOSSIBLE__- A.Quote {} -> __IMPOSSIBLE__- A.QuoteTerm {} -> __IMPOSSIBLE__- A.Unquote {} -> __IMPOSSIBLE__- A.DontCare v -> dotVars v--instance DotVars RHS where- dotVars (RHS e) = dotVars e- dotVars AbsurdRHS = Set.empty- dotVars (WithRHS _ es clauses) = __IMPOSSIBLE__ -- NZ- dotVars (RewriteRHS _ es rhs _) = __IMPOSSIBLE__ -- NZ--instance DotVars TypedBindings where- dotVars (TypedBindings _ bs) = dotVars bs--instance DotVars TypedBinding where- dotVars (TBind _ _ e) = dotVars e- dotVars (TNoBind e) = dotVars e--reifyPatterns :: I.Telescope -> Permutation -> [Arg I.Pattern] -> TCM [NamedArg A.Pattern]-reifyPatterns tel perm ps = evalStateT (reifyArgs ps) 0- where- reifyArgs as = map (fmap unnamed) <$> mapM reifyArg as- reifyArg a = traverse reifyPat a-- tick = do i <- get; put (i + 1); return i-- translate = (vars !!)- where- vars = permute (invertP perm) [0..]-- reifyPat p = case p of- I.VarP s -> do- i <- tick- let j = translate i- lift $ A.VarP <$> nameOfBV (size tel - 1 - j)- I.DotP v -> do- t <- lift $ reify v- let vars = Set.map show (dotVars t)- tick- if Set.member "()" vars- then return $ A.DotP i $ A.Underscore mi- else return $ A.DotP i t- I.LitP l -> return (A.LitP l)- I.ConP c _ ps -> A.ConP i (AmbQ [c]) <$> reifyArgs ps- where- i = PatRange noRange- mi = MetaInfo noRange emptyScopeInfo Nothing--instance Reify NamedClause A.Clause where- reify (NamedClause f (I.Clause _ tel perm ps body)) = addCtxTel tel $ do- ps <- reifyPatterns tel perm ps- lhs <- liftTCM $ reifyDisplayFormP $ LHS info f ps []- nfv <- getDefFreeVars f- lhs <- stripImps $ dropParams nfv lhs- rhs <- reify body- return $ A.Clause lhs rhs []- where- info = LHSRange noRange- dropParams n (LHS i f ps wps) = LHS i f (genericDrop n ps) wps- stripImps (LHS i f ps wps) = do- (ps, wps) <- stripImplicits ps wps- return $ LHS i f ps wps--instance Reify Type Expr where- reify (I.El _ t) = reify t--instance Reify Sort Expr where- reify s =- do s <- instantiateFull s- case s of- I.Type (I.Max []) -> return $ A.Set exprInfo 0- I.Type (I.Max [I.ClosedLevel n]) -> return $ A.Set exprInfo n- I.Type a -> do- a <- reify a- return $ A.App exprInfo (A.Set exprInfo 0)- (defaultArg (unnamed a))- I.Prop -> return $ A.Prop exprInfo- I.Inf -> A.Var <$> freshName_ "Setω"- I.DLub s1 s2 -> do- lub <- freshName_ "dLub" -- TODO: hack- (e1,e2) <- reify (s1, I.Lam NotHidden $ fmap Sort s2)- let app x y = A.App exprInfo x (defaultArg $ unnamed y)- return $ A.Var lub `app` e1 `app` e2--instance Reify Level Expr where- reify l = reify =<< reallyUnLevelView l--instance (Free i, Reify i a) => Reify (Abs i) (Name, a) where- reify (NoAbs x v) = (,) <$> freshName_ x <*> reify v- reify (Abs s v) = do-- -- If the bound variable is free in the body, then the name "_" is- -- replaced by "z".- s <- return $ if s == "_" && 0 `freeIn` v then "z" else s-- x <- freshName_ s- e <- addCtx x (defaultArg $ sort I.Prop) -- type doesn't matter- $ reify v- return (x,e)--instance Reify I.Telescope A.Telescope where- reify EmptyTel = return []- reify (ExtendTel arg tel) = do- Arg h rel e <- reify arg- (x,bs) <- reify tel- let r = getRange e- return $ TypedBindings r (Arg h rel (TBind r [x] e)) : bs--instance Reify i a => Reify (Arg i) (Arg a) where- reify = traverse reify--instance Reify i a => Reify [i] [a] where- reify = traverse reify--instance (Reify i1 a1, Reify i2 a2) => Reify (i1,i2) (a1,a2) where- reify (x,y) = (,) <$> reify x <*> reify y--instance (Reify t t', Reify a a')- => Reify (Judgement t a) (Judgement t' a') where- reify (HasType i t) = HasType <$> reify i <*> reify t- reify (IsSort i t) = IsSort <$> reify i <*> reify t+{-# LANGUAGE NondecreasingIndentation #-}++{-|+ Translating from internal syntax to abstract syntax. Enables nice+ pretty printing of internal syntax.++ TODO++ - numbers on metas+ - fake dependent functions to independent functions+ - meta parameters+ - shadowing+-}+module Agda.Syntax.Translation.InternalToAbstract+ ( Reify(..)+ , MonadReify+ , NamedClause(..)+ , reifyPatterns+ , reifyUnblocked+ , blankNotInScope+ , reifyDisplayFormP+ ) where++import Prelude hiding (null)++import Control.Monad.Trans.Maybe+import Control.Applicative ( liftA2 )+import Control.Monad ( filterM, forM )++import Data.List qualified as List+import Data.Map qualified as Map+import Data.Maybe+import Data.Set (Set)+import Data.Set qualified as Set+import Data.Text qualified as T+import Data.Traversable (mapM)++import Agda.Syntax.Literal+import Agda.Syntax.Position+import Agda.Syntax.Common+import Agda.Syntax.Common.Aspect qualified as Asp+import Agda.Syntax.Concrete.Name qualified as C+import Agda.Syntax.Concrete (FieldAssignment'(..), TacticAttribute'(..))+import Agda.Syntax.Info as Info+import Agda.Syntax.Abstract as A hiding (Binder)+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Abstract.Pattern+import Agda.Syntax.Abstract.Pretty+import Agda.Syntax.Abstract.UsedNames+import Agda.Syntax.Internal as I+import Agda.Syntax.Internal.Pattern as I+import Agda.Syntax.Scope.Base (inverseScopeLookupName)++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce+import {-# SOURCE #-} Agda.TypeChecking.Records+import Agda.TypeChecking.CompiledClause (CompiledClauses'(Fail))+import Agda.TypeChecking.DisplayForm+import Agda.TypeChecking.Level+import {-# SOURCE #-} Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Free+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.SyntacticEquality+import Agda.TypeChecking.Telescope+import {-# SOURCE #-} Agda.TypeChecking.Records++import Agda.Interaction.Options++import Agda.Utils.Either+import Agda.Utils.Function (applyUnless)+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|))+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Maybe.Strict qualified as Strict+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Permutation+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.SmallSet (SmallSet)+import Agda.Utils.SmallSet qualified as SmallSet+import Agda.Utils.Tuple++import Agda.Utils.Impossible+++-- | Like @reify@ but instantiates blocking metas, useful for reporting.+reifyUnblocked :: Reify i => i -> TCM (ReifiesTo i)+reifyUnblocked t = locallyTCState stInstantiateBlocking (const True) $ reify t+++-- Composition of reified applications ------------------------------------+--UNUSED Liang-Ting 2019-07-16+---- | Drops hidden arguments unless --show-implicit.+--napps :: Expr -> [NamedArg Expr] -> TCM Expr+--napps e = nelims e . map I.Apply++{-# SPECIALIZE apps :: Expr -> [Arg Expr] -> TCM Expr #-}+-- | Drops hidden arguments unless --show-implicit.+apps :: MonadReify m => Expr -> [Arg Expr] -> m Expr+apps e = elims e . map' I.Apply++-- Composition of reified eliminations ------------------------------------++{-# SPECIALIZE nelims :: Expr -> [I.Elim' (Named_ Expr)] -> TCM Expr #-}+-- | Drops hidden arguments unless --show-implicit.+nelims :: MonadReify m => Expr -> [I.Elim' (Named_ Expr)] -> m Expr+nelims e [] = return e+nelims e (I.IApply x y r : es) =+ nelims (A.App defaultAppInfo_ e $ defaultArg r) es+nelims e (I.Apply arg : es) = do+ arg <- reify arg -- This replaces the arg by _ if irrelevant+ dontShowImp <- not <$> showImplicitArguments+ let+ drop+ | ConversionFail <- argInfoOrigin (argInfo arg) = False+ | notVisible arg = dontShowImp+ | otherwise = False+ hd | drop = e+ | otherwise = A.App defaultAppInfo_ e arg+ nelims hd es+nelims e (I.Proj ProjPrefix d : es) = nelimsProjPrefix e d es+nelims e (I.Proj o d : es) | isSelf e = nelims (A.Proj ProjPrefix $ unambiguous d) es+ | otherwise =+ nelims (A.App defaultAppInfo_ e (defaultNamedArg $ A.Proj o $ unambiguous d)) es++{-# SPECIALIZE nelimsProjPrefix :: Expr -> QName -> [I.Elim' (Named_ Expr)] -> TCM Expr #-}+nelimsProjPrefix :: MonadReify m => Expr -> QName -> [I.Elim' (Named_ Expr)] -> m Expr+nelimsProjPrefix e d es =+ nelims (A.App defaultAppInfo_ (A.Proj ProjPrefix $ unambiguous d) $ defaultNamedArg e) es++-- | If we are referencing the record from inside the record definition, we don't insert an+-- | A.App+isSelf :: Expr -> Bool+isSelf = \case+ A.Var n -> nameIsRecordName n+ _ -> False++{-# SPECIALIZE elims :: Expr -> [I.Elim' Expr] -> TCM Expr #-}+-- | Drops hidden arguments unless --show-implicit.+elims :: MonadReify m => Expr -> [I.Elim' Expr] -> m Expr+elims e = nelims e . map' (fmap unnamed)++-- Omitting information ---------------------------------------------------++noExprInfo :: ExprInfo+noExprInfo = ExprRange noRange++-- Conditional reification to omit terms that are not shown --------------++{-# INLINE reifyWhenE #-}+reifyWhenE :: (Reify i, MonadReify m, Underscore (ReifiesTo i)) => Bool -> i -> m (ReifiesTo i)+reifyWhenE True i = reify i+reifyWhenE False t = return underscore++-- Reification ------------------------------------------------------------++type MonadReify m =+ ( PureTCM m+ , MonadInteractionPoints m+ , MonadFresh NameId m+ )++class Reify i where+ type ReifiesTo i++ reify :: MonadReify m => i -> m (ReifiesTo i)++ -- @reifyWhen False@ should produce an 'underscore'.+ -- This function serves to reify hidden/irrelevant things.+ reifyWhen :: MonadReify m => Bool -> i -> m (ReifiesTo i)+ reifyWhen _ = reify++instance Reify Bool where+ type ReifiesTo Bool = Bool+ reify = return++instance Reify Char where+ type ReifiesTo Char = Char+ reify = return++instance Reify Name where+ type ReifiesTo Name = Name+ reify = return++instance Reify Expr where+ type ReifiesTo Expr = Expr++ reifyWhen = reifyWhenE+ reify = return++instance Reify MetaId where+ type ReifiesTo MetaId = Expr++ reifyWhen = reifyWhenE+ reify x = do+ b <- viewTC ePrintMetasBare+ mvar <- lookupLocalMeta x+ let mi = mvInfo mvar+ let mi' = Info.MetaInfo+ { metaRange = getRange $ miClosRange mi+ , metaScope = clScope $ miClosRange mi+ , metaNumber = if b then Nothing else Just x+ , metaNameSuggestion = if b then "" else miNameSuggestion mi+ , metaKind = metaInstantiationToMetaKind (mvInstantiation mvar)+ }+ underscore = return $ A.Underscore mi'+ -- If we are printing a term that will be pasted into the user+ -- source, we turn all unsolved (non-interaction) metas into+ -- interaction points+ isInteractionMeta x >>= \case+ Nothing | b -> do+ ii <- registerInteractionPoint False noRange Nothing+ connectInteractionPoint ii x+ return $ A.QuestionMark mi' ii+ Just ii | b -> underscore+ Nothing -> underscore+ Just ii -> return $ A.QuestionMark mi' ii+{-# SPECIALIZE reify :: MetaId -> TCM (ReifiesTo MetaId) #-}++instance Reify DisplayTerm where+ type ReifiesTo DisplayTerm = Expr++ reifyWhen = reifyWhenE+ reify = \case+ DTerm' v es -> elims ==<< (reifyTerm False v, reify es)+ DDot' v es -> elims ==<< (reify v, reify es)+ DCon c ci vs -> recOrCon (conName c) ci =<< reify vs+ DDef f es -> elims (A.Def f) =<< reify es+ DWithApp u us es0 -> do+ (e, es) <- reify (u, us)+ elims (A.WithApp noExprInfo e es) =<< reify es0+{-# SPECIALIZE reify :: DisplayTerm -> TCM (ReifiesTo DisplayTerm) #-}++{-# SPECIALIZE reifyDisplayForm :: QName -> I.Elims -> TCM A.Expr -> TCM A.Expr #-}+-- | @reifyDisplayForm f vs fallback@+-- tries to rewrite @f vs@ with a display form for @f@.+-- If successful, reifies the resulting display term,+-- otherwise, does @fallback@.+reifyDisplayForm :: MonadReify m => QName -> I.Elims -> m A.Expr -> m A.Expr+reifyDisplayForm f es fallback =+ ifNotM displayFormsEnabled fallback $ {- else -}+ caseMaybeM (displayForm f es) fallback reify++{-# SPECIALIZE reifyDisplayFormP :: QName -> A.Patterns -> A.Patterns -> TCM (QName, A.Patterns) #-}+-- | @reifyDisplayFormP@ tries to recursively+-- rewrite a lhs with a display form.+--+-- Note: we are not necessarily in the empty context upon entry!+reifyDisplayFormP ::+ forall m.+ MonadReify m+ => QName -- ^ LHS head symbol+ -> A.Patterns -- ^ Patterns to be taken into account to find display form.+ -> A.Patterns -- ^ Remaining trailing patterns ("with patterns").+ -> m (QName, A.Patterns) -- ^ New head symbol and new patterns.+reifyDisplayFormP f ps wps = do+ let fallback = return (f, ps ++! wps)+ ifNotM displayFormsEnabled fallback $ {- else -} do+ -- Try to rewrite @f 0 1 2 ... |ps|-1@ to a dt.+ -- Andreas, 2014-06-11 Issue 1177:+ -- I thought we need to add the placeholders for ps to the context,+ -- because otherwise displayForm will not raise the display term+ -- and we will have variable clashes.+ -- But apparently, it has no influence...+ -- Ulf, can you add an explanation?+ md <- -- addContext (replicate (length ps) "x") $+ displayForm f $ zipWith' (\ p i -> I.Apply $ p $> I.var i) ps [0..]+ reportSLn "reify.display" 95 $+ "display form of " ++! prettyShow f ++! " " ++! show ps ++! " " ++! show wps ++! ":\n " ++! show md+ case md of+ Just d | okDisplayForm d -> do+ -- In the display term @d@, @var i@ should be a placeholder+ -- for the @i@th pattern of @ps@.+ -- Andreas, 2014-06-11:+ -- Are we sure that @d@ did not use @var i@ otherwise?+ (f', ps', wps') <- displayLHS ps d+ reportSDoc "reify.display" 70 $ do+ doc <- prettyA $ SpineLHS empty f' (ps' ++! wps' ++! wps)+ return $ vcat+ [ "rewritten lhs to"+ , " lhs' = " <+> doc+ ]+ reifyDisplayFormP f' ps' (wps' ++! wps)+ _ -> do+ reportSLn "reify.display" 70 $ "display form absent or not valid as lhs"+ fallback+ where+ -- Andreas, 2015-05-03: Ulf, please comment on what+ -- is the idea behind okDisplayForm.+ -- Ulf, 2016-04-15: okDisplayForm should return True if the display form+ -- can serve as a valid left-hand side. That means checking that it is a+ -- defined name applied to valid lhs eliminators (projections or+ -- applications to constructor patterns).+ okDisplayForm :: DisplayTerm -> Bool+ okDisplayForm = \case+ DWithApp d ds es ->+ okDisplayForm d && all okDisplayTerm ds && all okToDropE es+ -- Andreas, 2016-05-03, issue #1950.+ -- We might drop trailing hidden trivial (=variable) patterns.+ DTerm' (I.Def f es') es -> all okElim es' && all okElim es+ DDef f es -> all okDElim es+ DDot'{} -> False+ DCon{} -> False+ DTerm'{} -> False++ okDisplayTerm :: DisplayTerm -> Bool+ okDisplayTerm = \case+ DTerm' v es -> null es && okTerm v+ DDot'{} -> True+ DCon{} -> True+ DDef{} -> False+ DWithApp{} -> False++ okDElim :: Elim' DisplayTerm -> Bool+ okDElim (I.IApply x y r) = okDisplayTerm r+ okDElim (I.Apply v) = okDisplayTerm $ unArg v+ okDElim I.Proj{} = True++ okToDropE :: Elim' Term -> Bool+ okToDropE (I.Apply v) = okToDrop v+ okToDropE I.Proj{} = False+ okToDropE (I.IApply x y r) = False++ okToDrop :: Arg I.Term -> Bool+ okToDrop arg = notVisible arg && case unArg arg of+ I.Var _ [] -> True+ I.DontCare{} -> True -- no matching on irrelevant things. __IMPOSSIBLE__ anyway?+ I.Level{} -> True -- no matching on levels. __IMPOSSIBLE__ anyway?+ _ -> False++ okArg :: Arg I.Term -> Bool+ okArg = okTerm . unArg++ okElim :: Elim' I.Term -> Bool+ okElim (I.IApply x y r) = okTerm r+ okElim (I.Apply a) = okArg a+ okElim I.Proj{} = True++ okTerm :: I.Term -> Bool+ okTerm (I.Var _ []) = True+ okTerm (I.Con c ci vs) = all okElim vs+ okTerm (I.Def x []) = isNoName $ qnameToConcrete x -- Handling wildcards in display forms+ okTerm _ = False++ -- Flatten a dt into (parentName, parentElims, withArgs).+ flattenWith :: DisplayTerm -> (QName, [I.Elim' DisplayTerm], [I.Elim' DisplayTerm])+ flattenWith (DWithApp d ds1 es2) =+ let (f, es, ds0) = flattenWith d+ in (f, es, ds0 ++! map' (I.Apply . defaultArg) (List1.toList ds1) ++! map' (fmap DTerm) es2)+ flattenWith (DDef f es) = (f, es, []) -- .^ hacky, but we should only hit this when printing debug info+ flattenWith (DTerm' (I.Def f es') es) = (f, map' (fmap DTerm) $ es' ++! es, [])+ flattenWith _ = __IMPOSSIBLE__++ displayLHS+ :: A.Patterns -- Patterns to substituted into display term.+ -> DisplayTerm -- Display term.+ -> m (QName, A.Patterns, A.Patterns) -- New head, patterns, with-patterns.+ displayLHS ps d = do+ let (f, vs, es) = flattenWith d+ ps <- mapM elimToPat vs+ wps <- mapM (updateNamedArg (A.WithP empty) <.> elimToPat) es+ return (f, ps, wps)+ where+ argToPat :: Arg DisplayTerm -> m (NamedArg A.Pattern)+ argToPat arg = traverse termToPat arg++ elimToPat :: I.Elim' DisplayTerm -> m (NamedArg A.Pattern)+ elimToPat (I.IApply _ _ r) = argToPat (Arg defaultArgInfo r)+ elimToPat (I.Apply arg) = argToPat arg+ elimToPat (I.Proj o d) = return $! defaultNamedArg $ A.ProjP patNoRange o $ unambiguous d++ -- Substitute variables in display term by patterns.+ termToPat :: DisplayTerm -> m (Named_ A.Pattern)++ -- Main action HERE:+ termToPat (DTerm (I.Var n [])) =+ return $! unArg $ fromMaybe __IMPOSSIBLE__ $ ps !!! n++ termToPat (DCon c ci vs) = fmap unnamed <$> tryRecPFromConP =<< do+ A.ConP (ConPatInfo ci patNoRange ConPatEager) (unambiguous (conName c)) <$> mapM argToPat vs++ termToPat (DTerm' (I.Con c ci vs) es) = fmap unnamed <$> tryRecPFromConP =<< do+ A.ConP (ConPatInfo ci patNoRange ConPatEager) (unambiguous (conName c)) <$>+ mapM (elimToPat . fmap DTerm) (vs ++! es)++ termToPat (DTerm (I.Def _ [])) = return $ unnamed $ A.WildP patNoRange+ termToPat (DDef _ []) = return $ unnamed $ A.WildP patNoRange++ termToPat (DTerm (I.Lit l)) = return $ unnamed $ A.LitP patNoRange l++ termToPat (DDot' v es) =+ unnamed . A.DotP patNoRange <$> do elims ==<< (termToExpr v, reify es)++ termToPat v =+ unnamed . A.DotP patNoRange <$> reify v++ len = length ps++ argsToExpr :: I.Args -> m [Arg A.Expr]+ argsToExpr = mapM (traverse termToExpr)++ -- TODO: restructure this to avoid having to repeat the code for reify+ termToExpr :: Term -> m A.Expr+ termToExpr v = do+ reportSLn "reify.display" 60 $ "termToExpr " ++! show v+ -- After unSpine, a Proj elimination is __IMPOSSIBLE__!+ case unSpine v of+ I.Con c ci es -> do+ let vs = fromMaybe __IMPOSSIBLE__ $ mapM isApplyElim es+ apps (A.Con (unambiguous (conName c))) =<< argsToExpr vs+ I.Def f es -> do+ let vs = fromMaybe __IMPOSSIBLE__ $ mapM isApplyElim es+ apps (A.Def f) =<< argsToExpr vs+ I.Var n es -> do+ let vs = fromMaybe __IMPOSSIBLE__ $ mapM isApplyElim es+ -- Andreas, 2014-06-11 Issue 1177+ -- due to β-normalization in substitution,+ -- even the pattern variables @n < len@ can be+ -- applied to some args @vs@.+ e <- if n < len+ then return $! patternToExpr $ namedArg $ indexWithDefault __IMPOSSIBLE__ ps n+ else reify (I.var (n - len))+ apps e =<< argsToExpr vs+ _ -> return underscore++instance Reify Literal where+ type ReifiesTo Literal = Expr++ reifyWhen = reifyWhenE+ reify l = return $ A.Lit empty l; {-# INLINE reify #-}++instance Reify Term where+ type ReifiesTo Term = Expr++ reifyWhen = reifyWhenE+ reify v = reifyTerm True v; {-# INLINE reify #-}++{-# SPECIALIZE reifyPathPConstAsPath :: QName -> Elims -> TCM (QName, Elims) #-}+reifyPathPConstAsPath :: MonadReify m => QName -> Elims -> m (QName, Elims)+reifyPathPConstAsPath x es@[I.Apply l, I.Apply t, I.Apply lhs, I.Apply rhs] = do+ reportSLn "reify.def" 100 $ "reifying def path " ++! show (x,es)+ mpath <- getBuiltinName' builtinPath+ mpathp <- getBuiltinName' builtinPathP+ let fallback = return (x,es)+ case (,) <$> mpath <*> mpathp of+ Just (path,pathp) | x == pathp -> do+ let a = case unArg t of+ I.Lam _ (NoAbs _ b) -> Just b+ I.Lam _ (Abs _ b)+ | not $ 0 `freeIn` b -> Just (strengthen impossible b)+ _ -> Nothing+ case a of+ Just a -> return (path, [I.Apply l, I.Apply (setHiding Hidden $ defaultArg a), I.Apply lhs, I.Apply rhs])+ Nothing -> fallback+ _ -> fallback+reifyPathPConstAsPath x es = return (x,es)++{-# SPECIALIZE tryReifyAsLetBinding :: Term -> TCM Expr -> TCM Expr #-}+-- | Check if the term matches an existing let-binding, in that case use the corresponding variable,+-- otherwise reify using the continuation.+tryReifyAsLetBinding :: MonadReify m => Term -> m Expr -> m Expr+tryReifyAsLetBinding v fallback = ifM (not <$> viewTC eFoldLetBindings) fallback $ do+ letBindings <- do+ binds <- Map.toAscList <$> viewTC eLetBindings+ opened <- forM binds $ \ (name, open) -> (,name) <$> getOpen open+ return [ (body, name) | (LetBinding _isAxiom UserWritten body _, name) <- opened, not $ isNoName name ] -- Only fold user-written lets+ matchingBindings <- filterM (\t -> checkSyntacticEquality v (fst t) (\_ _ -> return True) (\_ _ -> return False)) letBindings+ case matchingBindings of+ (_, name) : _ -> return $ A.Var name+ [] -> fallback++{-# SPECIALIZE reifyTerm :: Bool -> Term -> TCM Expr #-}+reifyTerm ::+ forall m. MonadReify m+ => Bool -- ^ Try to expand away anonymous definitions?+ -> Term+ -> m Expr+reifyTerm expandAnonDefs0 v0 = tryReifyAsLetBinding v0 $ do+ -- Jesper 2018-11-02: If 'PrintMetasBare', drop all meta eliminations.+ metasBare <- viewTC ePrintMetasBare+ reportS "reify.term" 80 $ "reifyTerm v0 = " <+> pretty v0+ v <- instantiate v0 >>= \case+ I.MetaV x _ | metasBare -> return $ I.MetaV x []+ v -> return v+ reportS "reify.term" 80 $ "reifyTerm v = " <+> pretty v+ -- Ulf 2014-07-10: Don't expand anonymous when display forms are disabled+ -- (i.e. when we don't care about nice printing)+ expandAnonDefs <- return expandAnonDefs0 `and2M` displayFormsEnabled++ -- Andreas, 2016-07-21 if --postfix-projections+ -- then we print system-generated projections as postfix, else prefix.+ havePfp <- optPostfixProjections <$> pragmaOptions++ -- Amy, 2024-01-07: postfix and system projections should still be+ -- turned into head symbols *if* they have display forms attached.+ hasDisplay <- liftReduce $ unKleisli hasDisplayForms+ let+ prefixize :: ProjOrigin -> QName -> Bool+ prefixize orig name = or+ [ if havePfp then orig == ProjPrefix else orig /= ProjPostfix+ , isOperator name+ -- Andreas, 2024-06-13, issue #7318:+ -- print e.g. G .|_| as | G |+ , hasDisplay name+ ]+ reportS "reify.term" 80 $ "reifyTerm (unSpine v) = " <+> pretty (unSpine' prefixize v)++ case unSpine' prefixize v of+ -- Hack to print generalized field projections with nicer names. Should+ -- only show up in errors. Check the spined form!+ _ | I.Var n (I.Proj _ p : es) <- v,+ Just name <- getGeneralizedFieldName p -> do+ let fakeName = (qnameName p) {nameConcrete = C.simpleName name} -- TODO: infix names!?+ elims (A.Var fakeName) =<< reify es+ I.Var n es -> do+ x <- fromMaybeM (freshName_ $ "@" ++! show n) $ nameOfBV' n+ elims (A.Var x) =<< reify es+ I.Def x es -> do+ reportS "reify.def" 80 $ "reifying def" <+> pretty x+ (x, es) <- reifyPathPConstAsPath x es+ reifyDisplayForm x es $ reifyDef expandAnonDefs x es++ I.Con c ci es -> do++ -- If the origin is a record expression, print a record expression.+ if ci == ConORec then recordExpression Nothing else do+ isRecordConstructor x >>= \case+ -- If it is a generated constructor, print a record expression.+ Just (r, def) | not (_recNamedCon def) -> recordExpression $ Just (r, def)++ -- Otherwise, print a constructor application.+ _ -> constructorApplication+ where+ x = conName c++ recordExpression mrdef = do+ (r, def) <- maybe (fromMaybe __IMPOSSIBLE__ <$> isRecordConstructor x) pure mrdef+ showImp <- showImplicitArguments+ let keep (a, v) = showImp || ConversionFail == argInfoOrigin (argInfo v) || visible a+ A.Rec empty noExprInfo+ . map' (Left . uncurry FieldAssignment . first unDom . second unArg)+ . filter' keep+ . zip' (recordFieldNames def)+ <$> reify (fromMaybe __IMPOSSIBLE__ $ allApplyElims es)++ constructorApplication = reifyDisplayForm x es $ do+ def <- getConstInfo x+ let Constructor {conPars = np} = theDef def+ -- if we are the the module that defines constructor x+ -- then we have to drop at least the n module parameters+ n <- getDefFreeVars x+ -- the number of parameters is greater (if the data decl has+ -- extra parameters) or equal (if not) to n+ when (n > np) __IMPOSSIBLE__+ let h = A.Con (unambiguous x)+ if null es+ then return h+ else do+ es <- reify $ fromMaybe __IMPOSSIBLE__ $ allApplyElims es+ -- Andreas, 2012-04-20: do not reify parameter arguments of constructor+ -- if the first regular constructor argument is hidden+ -- we turn it into a named argument, in order to avoid confusion+ -- with the parameter arguments which can be supplied in abstract syntax+ --+ -- Andreas, 2012-09-17: this does not remove all sources of confusion,+ -- since parameters could have the same name as regular arguments+ -- (see for example the parameter {i} to Data.Star.Star, which is also+ -- the first argument to the cons).+ -- @data Star {i}{I : Set i} ... where cons : {i : I} ...@+ if np == 0+ then apps h es+ else do+ -- Get name of first argument from type of constructor.+ -- Here, we need the reducing version of @telView@+ -- because target of constructor could be a definition+ -- expanding into a function type. See test/succeed/NameFirstIfHidden.agda.+ TelV tel _ <- telView (defType def)+ let (pars, rest) = splitAt np $ telToList tel+ case rest of+ -- Andreas, 2012-09-18+ -- If the first regular constructor argument is hidden,+ -- we keep the parameters to avoid confusion.+ ((view dInfo -> info) : _) | notVisible info -> do+ let us = for (drop n pars) $ \(view dInfo -> ai) ->+ -- setRelevance Relevant $+ hideOrKeepInstance $ Arg ai underscore+ apps h $ us ++! es -- Note: unless --show-implicit, @apps@ will drop @us@.+ -- otherwise, we drop all parameters+ _ -> apps h es++-- I.Lam info b | isAbsurdBody b -> return $ A. AbsurdLam noExprInfo $ getHiding info+ I.Lam info b -> do+ (x,e) <- reify b+ -- #4160: Hacky solution: if --show-implicit, treat all lambdas as user-written. This will+ -- prevent them from being dropped by AbstractToConcrete (where we don't have easy access to+ -- the --show-implicit flag.+ info <- ifM showImplicitArguments (return $! setOrigin UserWritten info) (return info)+ return $! A.Lam exprNoRange (mkDomainFree $ unnamedArg info $ mkBinder_ x) e+ -- Andreas, 2011-04-07 we do not need relevance information at internal Lambda+ I.Lit l -> reify l+ I.Level l -> reify l+ I.Pi a b -> case b of+ _ | isIrrelevant a, domIsFinite a -> mkPartial (unEl (unDom a)) b $ mkPi b =<< reify a+ NoAbs _ b'+ | visible a -> uncurry (A.Fun $ noExprInfo) <$> reify (a, b')+ -- Andreas, 2013-11-11 Hidden/Instance I.Pi must be A.Pi+ -- since (a) the syntax {A} -> B or {{A}} -> B is not legal+ -- and (b) the name of the binder might matter.+ -- See issue 951 (a) and 952 (b).+ | otherwise -> mkPi b =<< reify a+ b -> mkPi b =<< do+ ifM (domainFree a (absBody b))+ {- then -} (pure $ Arg (domInfo a) underscore)+ {- else -} (reify a)+ where+ mkPartial :: Term -> Abs I.Type -> m Expr -> m Expr+ mkPartial (I.Def io [I.Apply fm]) body cont = do+ ion <- getBuiltinName' builtinIsOne+ case reAbs body of+ _ | Just io /= ion -> cont+ NoAbs _ b' -> do+ pn <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinPartial+ hd <- reify (I.Def pn [])+ apps hd =<< traverse reify [ fm, defaultArg (unEl b') ]+ Abs nm b' -> do+ pn <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinPartialP+ hd <- reify (I.Def pn [])+ apps hd =<< traverse reify+ [ fm, defaultArg (I.Lam (setRelevance irrelevant defaultArgInfo) (Abs nm (unEl b'))) ]+ mkPartial _ _ fallback = fallback++ mkPi b (Arg info a') = ifM (skipGeneralizedParameter info) (snd <$> reify b) $ do+ tac <- TacticAttribute <$> do traverse (Ranged noRange <.> reify) $ domTactic a+ (x, b) <- reify b+ let xs = singleton $ Arg info $ Named (domName a) $ mkBinder_ x+ return $ A.Pi noExprInfo+ (singleton $ TBind noRange (TypedBindingInfo tac (domIsFinite a)) xs a')+ b+ -- We can omit the domain type if it doesn't have any free variables+ -- and it's mentioned in the target type.+ domainFree a b = do+ df <- viewTC ePrintDomainFreePi+ return $! df && freeIn 0 b && closed a++ skipGeneralizedParameter :: ArgInfo -> m Bool+ skipGeneralizedParameter info = (not <$> showGeneralizedArguments) <&> (&& (argInfoOrigin info == Generalization))++ I.Sort s -> reify s+ I.MetaV x es -> do+ x' <- reify x++ es' <- reify es++ mv <- lookupLocalMeta x+ (msub1,meta_tel,msub2) <- do+ local_chkpt <- viewTC eCurrentCheckpoint+ (chkpt, tel, msub2) <- enterClosure mv $ \ _ ->+ (,,) <$> viewTC eCurrentCheckpoint+ <*> getContextTelescope+ <*> viewTC (eCheckpoints . key local_chkpt)+ (,,) <$> viewTC (eCheckpoints . key chkpt) <*> pure tel <*> pure msub2++ opt_show_ids <- showIdentitySubstitutions+ let+ addNames [] es = map' (fmap unnamed) es+ addNames _ [] = []+ addNames xs (I.Proj{} : _) = __IMPOSSIBLE__+ addNames xs (I.IApply x y r : es) =+ -- Needs to be I.Apply so it can have an Origin field.+ addNames xs (I.Apply (defaultArg r) : es)+ addNames (x:xs) (I.Apply arg : es) =+ I.Apply (Named (Just x) <$> (setOrigin Substitution arg)) : addNames xs es++ p = mvPermutation mv+ applyPerm p vs = permute (takeP (size vs) p) vs++ names = map' (WithOrigin Inserted . unranged) $ p `applyPerm` teleNames meta_tel+ named_es' = addNames names es'++ dropIdentitySubs sub_local2G sub_tel2G =+ let+ args_G = applySubst sub_tel2G $ p `applyPerm` (teleArgs meta_tel :: [Arg Term])+ es_G = sub_local2G `applySubst` es+ sameVar x (I.Apply y) = isJust xv && xv == deBruijnView (unArg y)+ where+ xv = deBruijnView $ unArg x+ sameVar _ _ = False+ dropArg = take' (size names) $ zipWith' sameVar args_G es_G+ doDrop (b : xs) (e : es) = (if b then id else (e :)) $ doDrop xs es+ doDrop [] es = es+ doDrop _ [] = []+ in doDrop dropArg $ named_es'++ simpl_named_es' | opt_show_ids = named_es'+ | Just sub_mtel2local <- msub1 = dropIdentitySubs IdS sub_mtel2local+ | Just sub_local2mtel <- msub2 = dropIdentitySubs sub_local2mtel IdS+ | otherwise = named_es'++ nelims x' simpl_named_es'++ I.DontCare v -> do+ showIrr <- optShowIrrelevant <$> pragmaOptions+ if | showIrr -> reifyTerm expandAnonDefs v+ | otherwise -> return underscore++ I.Dummy s es -> reifyDummy s es+ where+ reifyDummy kind es =+ case kind of+ I.DummyBrave h -> elims' (reify h)+ I.DummyNamed s -> elims (A.Lit empty $ LitString (T.pack s)) =<< reify es+ where+ elims' a = do { h <- a ; es <- reify es ; elims h es }+ asp o = empty { Asp.otherAspects = Set.singleton o }++ -- Andreas, 2012-10-20 expand a copy if not in scope+ -- to improve error messages.+ -- Don't do this if we have just expanded into a display form,+ -- otherwise we loop!+ reifyDef :: Bool -> QName -> I.Elims -> m Expr+ reifyDef True x es =+ ifM (not . null . inverseScopeLookupName x <$> getScope) (reifyDef' x es) $ do+ r <- reduceDefCopy x es+ case r of+ YesReduction _ v -> do+ reportS "reify.anon" 60+ [ "reduction on defined ident. in anonymous module"+ , "x = " ++! prettyShow x+ , "v = " ++! show v+ ]+ reify v+ NoReduction () -> do+ reportS "reify.anon" 60+ [ "no reduction on defined ident. in anonymous module"+ , "x = " ++! prettyShow x+ , "es = " ++! show es+ ]+ reifyDef' x es+ reifyDef _ x es = reifyDef' x es++ discontiguous :: I.Elims -> Bool+ discontiguous [] = False+ discontiguous (I.IApply{}:es) = discontiguous es+ discontiguous (I.Proj{}:es) = discontiguous es+ discontiguous (I.Apply (Arg info _):es) =+ (notVisible info && ConversionFail == argInfoOrigin info) || discontiguous es++ reifyDef' :: QName -> I.Elims -> m Expr+ reifyDef' x es = do+ reportSLn "reify.def" 60 $ "reifying call to " ++! prettyShow x+ -- We should drop this many arguments from the local context.+ n <- getDefFreeVars x+ reportSLn "reify.def" 70 $ "freeVars for " ++! prettyShow x ++! " = " ++! show n+ -- If the definition is not (yet) in the signature,+ -- we just do the obvious.+ showImp <- showImplicitArguments+ let fallback _ = elims (A.Def x) =<< reify (drop n es)+ caseEitherM (getConstInfo' x) fallback $ \ defn -> do+ let def = theDef defn++ -- Check if we have an absurd lambda.+ case def of+ Function{ funCompiled = Just Fail{}, funClauses = [cl] }+ | isAbsurdLambdaName x -> do+ -- get hiding info from last pattern, which should be ()+ let (ps, p) = fromMaybe __IMPOSSIBLE__ $ initLast $ namedClausePats cl+ let h = getHiding p+ n = length ps -- drop all args before the absurd one+ absLam = A.AbsurdLam exprNoRange h+ if | n > length es -> do -- We don't have all arguments before the absurd one!+ let name (I.VarP _ x) = patVarNameToString $ dbPatVarName x+ name _ = __IMPOSSIBLE__ -- only variables before absurd pattern+ vars = map' (getArgInfo &&& name . namedArg) $ drop (length es) ps+ lam (i, s) = do+ x <- freshName_ s+ return $! A.Lam exprNoRange (A.mkDomainFree $ unnamedArg i $ A.mkBinder_ x)+ foldr ($) absLam <$> mapM lam vars+ | otherwise -> elims absLam =<< reify (drop n es)++ -- Otherwise (no absurd lambda):+ _ -> do++ -- Andrea(s), 2016-07-06+ -- Extended lambdas are not considered to be projection like,+ -- as they are mutually recursive with their parent.+ -- Thus we do not have to consider padding them.++ -- Check whether we have an extended lambda and display forms are on.+ df <- displayFormsEnabled++ -- #3004: give up if we have to print a pattern lambda inside its own body!+ alreadyPrinting <- viewTC ePrintingPatternLambdas++ extLam <- case def of+ Function{ funExtLam = Just{}, funProjection = Right{} } -> __IMPOSSIBLE__+ Function{ funExtLam = Just (ExtLamInfo m b sys) } ->+ Just . (,Strict.toLazy sys) . size <$> lookupSection m+ _ -> return Nothing++ -- Amy, 2023-04-12: Don't reify clauses generated by the cubical+ -- coverage checker when printing an extended lambda. We can+ -- identify these clauses by looking for patterns headed by DefP+ -- (either transpX or hcomp associated with a data type).+ --+ -- Since these are always automatically derived, printing them+ -- is noise, and shows up even in non-cubical modules, as long+ -- as an imported extended lambda is defined cubical-compatibly.+ let insClause = hasDefP . namedClausePats+ case extLam of+ Just (pars, sys) | df, x `notElem` alreadyPrinting ->+ locallyTC ePrintingPatternLambdas (x :) $+ reifyExtLam x (defArgInfo defn) pars sys+ (filter (not . insClause) (defClauses defn)) es++ -- Otherwise (ordinary function call):+ _ -> do+ (pad, nes :: [Elim' (Named_ Term)]) <- case def of++ Function{ funProjection = Right Projection{ projIndex = np } } | np > 0 -> do+ reportSLn "reify.def" 70 $ " def. is a projection with projIndex = " ++! show np++ -- This is tricky:+ -- * getDefFreeVars x tells us how many arguments+ -- are part of the local context+ -- * some of those arguments might have been dropped+ -- due to projection likeness+ -- * when showImplicits is on we'd like to see the dropped+ -- projection arguments++ TelV tel _ <- telViewUpTo np (defType defn)+ let (as, rest) = splitAt (np - 1) $ telToList tel+ dom = headWithDefault __IMPOSSIBLE__ rest++ -- These are the dropped projection arguments+ scope <- getScope+ let underscore = A.Underscore $ Info.emptyMetaInfo { metaScope = scope }+ let pad :: [NamedArg Expr]+ pad = for as $ \ d -> let ai = d ^. dInfo; x = fst (unDom d) in+ Arg ai $ Named (Just $ WithOrigin Inserted $ unranged x) underscore+ -- TODO #3353 Origin from Dom?++ -- Now pad' ++! es' = drop n (pad ++! es)+ let pad' = drop n pad+ es' = drop (max 0 (n - size pad)) es+ -- Andreas, 2012-04-21: get rid of hidden underscores {_} and {{_}}+ -- Keep non-hidden arguments of the padding.+ --+ -- Andreas, 2016-12-20, issue #2348:+ -- Let @padTail@ be the list of arguments of the padding+ -- (*) after the last visible argument of the padding, and+ -- (*) with the same visibility as the first regular argument.+ -- If @padTail@ is not empty, we need to+ -- print the first regular argument with name.+ -- We further have to print all elements of @padTail@+ -- which have the same name and visibility of the+ -- first regular argument.+ showImp <- showImplicitArguments++ -- Get the visible arguments of the padding and the rest+ -- after the last visible argument.+ let (padVisNamed, padRest) = filterAndRest visible pad'++ -- Remove the names from the visible arguments.+ let padVis = map' (fmap $ unnamed . namedThing) padVisNamed++ -- Keep only the rest with the same visibility of @dom@...+ let padTail = filter (sameHiding dom) padRest++ -- ... and even the same name.+ let padSame = filter ((Just (fst $ unDom dom) ==) . bareNameOf) padTail++ return $! if null padTail || not showImp+ then (padVis , map' (fmap unnamed) es')+ else (padVis ++! padSame, nameFirstIfHidden dom es')++ -- If the conversion checker asked us to show an implicit+ -- argument that would otherwise be hidden, it might need to+ -- be named.+ _ | not showImp && discontiguous es ->+ runMaybeT (nameElims False (I.Def x []) (defType defn) (drop n es)) >>= \case+ Just xs -> pure ([], xs)+ Nothing -> pure ([], map' (fmap unnamed) $ drop n es)++ -- Otherwise, we need no padding.+ _ -> return ([], map' (fmap unnamed) $ drop n es)++ reportS "reify.def" 100 $ vcat+ [ " pad =" <+> pshow pad+ , " nes =" <+> pshow nes+ ]+ let hd0 | isProperProjection def = A.Proj ProjPrefix $ unambiguous x+ | otherwise = A.Def x+ let hd = List.foldl' (A.App defaultAppInfo_) hd0 pad+ nelims hd =<< reify nes++ -- Name any 'ConversionFail' arguments that are in the wrong position in the spine.+ nameElims :: Bool -> I.Term -> I.Type -> I.Elims -> MaybeT m [Elim' (Named_ Term)]+ nameElims _ _ _ [] = pure []+ nameElims needs acc ty (I.IApply _ _ tm:as) = nameElims needs acc ty (I.Apply (defaultArg tm):as)+ nameElims needs acc ty (elim@(I.Apply (Arg info tm)):as) =+ ifNotPiOrPathType ty (\_ -> mzero) \dom cod -> do+ let+ forced = notVisible info && (ConversionFail == argInfoOrigin info)+ arg = I.Apply if forced && needs+ then Arg info (Named (Just $ WithOrigin Inserted $ unranged $ absName cod) tm)+ else Arg info (unnamed tm)+ (arg:) <$> nameElims+ (if visible info then False else not forced)+ (acc `applyE` [elim]) (cod `lazyAbsApp` tm) as+ nameElims _ tm ty (I.Proj o n:as) = do+ ty <- reduce ty+ projectTyped tm ty o n >>= \case+ Nothing -> mzero+ Just (_, tm, ty) -> (I.Proj o n:) <$> nameElims False tm ty as++ -- Andreas, 2016-07-06 Issue #2047++ -- With parameter refinement, the "parameter" patterns of an extended+ -- lambda can now be different from variable patterns. If we just drop+ -- them (plus the associated arguments to the extended lambda), we produce+ -- something++ -- i) that violates internal invariants. In particular, the permutation+ -- dbPatPerm from the patterns to the telescope can no longer be+ -- computed. (And in fact, dropping from the start of the telescope is+ -- just plainly unsound then.)++ -- ii) prints the wrong thing (old fix for #2047)++ -- What we do now, is more sound, although not entirely satisfying:+ -- When the "parameter" patterns of an external lambdas are not variable+ -- patterns, we fall back to printing the internal function created for the+ -- extended lambda, instead trying to construct the nice syntax.++ reifyExtLam+ :: QName -> ArgInfo -> Int -> Maybe System -> [I.Clause]+ -> I.Elims -> m Expr+ reifyExtLam x ai npars msys cls es = do+ reportS "reify.def" 10 $ "reifying extended lambda" <+> pretty x+ reportS "reify.def" 50 $ nest 2 $ vcat+ [ "npars =" <+> pretty npars+ , "es =" <+> fsep (map' (prettyPrec 10) es)+ , "def =" <+> vcat (map' pretty cls) ]+ -- As extended lambda clauses live in the top level, we add the whole+ -- section telescope to the number of parameters.+ let (pares, rest) = splitAt npars es+ let pars = fromMaybe __IMPOSSIBLE__ $ allApplyElims pares++ -- Since we applying the clauses to the parameters,+ -- we do not need to drop their initial "parameter" patterns+ -- (this is taken care of by @apply@).+ cls <- caseMaybe msys+ (mapM (reify . NamedClause x False . (`apply` pars)) cls)+ (reify . QNamed x . (`apply` pars))+ let cx = nameConcrete $ qnameName x+ dInfo = mkDefInfo cx noFixity' PublicAccess ConcreteDef+ (getRange x)+ erased = case getQuantity ai of+ Quantity0 o -> Erased o+ Quantityω o -> NotErased o+ Quantity1 o -> __IMPOSSIBLE__+ lam = case cls of+ [] -> A.AbsurdLam exprNoRange NotHidden+ (cl:cls) -> A.ExtendedLam exprNoRange dInfo erased x (cl :| cls)+ elims lam =<< reify rest++-- | @nameFirstIfHidden (x:a) ({e} es) = {x = e} es@+nameFirstIfHidden :: Dom (ArgName, t) -> [Elim' a] -> [Elim' (Named_ a)]+nameFirstIfHidden dom (I.Apply (Arg info e) : es) | notVisible info =+ I.Apply (Arg info (Named (Just $ WithOrigin Inserted $ unranged $ fst $ unDom dom) e)) :+ map' (fmap unnamed) es+nameFirstIfHidden _ es =+ map' (fmap unnamed) es++instance Reify i => Reify (Named n i) where+ type ReifiesTo (Named n i) = Named n (ReifiesTo i)++ reify = traverse reify+ reifyWhen b = traverse (reifyWhen b)++-- | Skip reification of implicit and irrelevant args if option is off.+instance Reify i => Reify (Arg i) where+ type ReifiesTo (Arg i) = Arg (ReifiesTo i)++ reify (Arg info i) = Arg info <$> (flip reifyWhen i =<< condition) where+ condition+ | ConversionFail <- argInfoOrigin info = pure True+ | otherwise = (return (argInfoHiding info /= Hidden) `or2M` showImplicitArguments)+ `and2M` (return (not $ isIrrelevant info) `or2M` showIrrelevantArguments)+ reifyWhen b i = traverse (reifyWhen b) i+{-# SPECIALIZE reify :: Reify i => Arg i -> TCM (ReifiesTo (Arg i)) #-}++-- instance Reify Elim Expr where+-- reifyWhen = reifyWhenE+-- reify = \case+-- I.IApply x y r -> appl "iapply" <$> reify (defaultArg r :: Arg Term)+-- I.Apply v -> appl "apply" <$> reify v+-- I.Proj f -> appl "proj" <$> reify ((defaultArg $ I.Def f []) :: Arg Term)+-- where+-- appl :: String -> Arg Expr -> Expr+-- appl s v = A.App exprInfo (A.Lit empty (LitString s)) $ fmap unnamed v++data NamedClause = NamedClause QName Bool I.Clause+ -- ^ Also tracks whether module parameters should be dropped from the patterns.++-- The Monoid instance for Data.Map doesn't require that the values are a+-- monoid.+newtype MonoidMap k v = MonoidMap { _unMonoidMap :: Map.Map k v }++instance (Ord k, Monoid v) => Semigroup (MonoidMap k v) where+ MonoidMap m1 <> MonoidMap m2 = MonoidMap (Map.unionWith mappend m1 m2)++instance (Ord k, Monoid v) => Monoid (MonoidMap k v) where+ mempty = MonoidMap Map.empty+ mappend = (<>)++-- | Removes argument names. Preserves names present in the source.+removeNameUnlessUserWritten :: (LensNamed a, LensOrigin (NameOf a)) => a -> a+removeNameUnlessUserWritten a+ | (getOrigin <$> getNameOf a) == Just UserWritten = a+ | otherwise = setNameOf Nothing a++{-# SPECIALIZE stripImplicits :: Set Name -> A.Patterns -> A.Patterns -> TCM A.Patterns #-}+-- | Removes implicit arguments that are not needed, that is, that don't bind+-- any variables that are actually used and doesn't do pattern matching.+-- Doesn't strip any arguments that were written explicitly by the user.+stripImplicits :: MonadReify m+ => Set Name -- ^ Variables to always include (occurs on RHS of clause)+ -> A.Patterns -> A.Patterns -> m A.Patterns+stripImplicits toKeep params ps = do+ -- if --show-implicit we don't need the names+ ifM showImplicitArguments (return $! map' (fmap removeNameUnlessUserWritten) ps) $ do+ reportS "reify.implicit" 100 $ vcat+ [ "stripping implicits"+ , nest 2 $ "ps =" <+> pshow ps+ ]+ let ps' = blankDots $ strip ps+ reportS "reify.implicit" 100 $ vcat+ [ nest 2 $ "ps' =" <+> pshow ps'+ ]+ return ps'+ where+ -- Replace variables in dot patterns by an underscore _ if they are hidden+ -- in the pattern. This is slightly nicer than making the implicts explicit.+ blankDots ps = blank (varsBoundIn $ params ++! ps) ps++ strip ps = stripArgs True ps+ where+ stripArgs _ [] = []+ stripArgs fixedPos (a : as)+ -- A hidden non-UserWritten variable is removed if not needed for+ -- correct position of the following hidden arguments.+ | canStrip a =+ if all canStrip $ takeWhile isUnnamedHidden as+ then stripArgs False as+ else goWild+ -- Other arguments are kept.+ | otherwise = stripName fixedPos (stripArg a) : stripArgs True as+ where+ a' = setNamedArg a $ A.WildP $ Info.PatRange $ getRange a+ goWild = stripName fixedPos a' : stripArgs True as++ stripName True = fmap removeNameUnlessUserWritten+ stripName False = id++ -- TODO: vars appearing in EqualPs shouldn't be stripped.+ canStrip a = and+ [ notVisible a+ , getOrigin a `notElem` [ UserWritten , CaseSplit ]+ , (getOrigin <$> getNameOf a) /= Just UserWritten+ , varOrDot (namedArg a)+ , not $ mustKeepVar (namedArg a)+ ]++ mustKeepVar (A.VarP (A.BindName x)) = Set.member x toKeep+ mustKeepVar _ = False++ isUnnamedHidden x = notVisible x && isNothing (getNameOf x) && isNothing (isProjP x)++ stripArg a = fmap (fmap stripPat) a++ stripPat = \case+ p@(A.VarP _) -> p+ A.ConP i c ps -> A.ConP i c $ stripArgs True ps+ p@A.ProjP{} -> p+ p@(A.DefP _ _ _) -> p+ p@(A.DotP _ _e) -> p+ p@(A.WildP _) -> p+ p@(A.AbsurdP _) -> p+ p@(A.LitP _ _) -> p+ A.AsP i x p -> A.AsP i x $ stripPat p+ A.PatternSynP _ _ _ -> __IMPOSSIBLE__+ A.RecP kwr i fs -> A.RecP kwr i $ map' (fmap stripPat) fs -- TODO Andreas: is this right?+ p@A.EqualP{} -> p -- EqualP cannot be blanked.+ A.WithP i p -> A.WithP i $ stripPat p -- TODO #2822: right?++ varOrDot A.VarP{} = True+ varOrDot A.WildP{} = True+ varOrDot A.DotP{} = True+ varOrDot (A.ConP cpi _ ps) | conPatOrigin cpi == ConOSystem+ = conPatLazy cpi == ConPatLazy || all (varOrDot . namedArg) ps+ varOrDot _ = False++{-# SPECIALIZE blankNotInScope :: BlankVars a => a -> TCM a #-}+{-# SPECIALIZE blankNotInScope :: Expr -> TCM Expr #-}+-- | @blankNotInScope e@ replaces variables in expression @e@ with @_@+-- if they are currently not in scope.+blankNotInScope :: (MonadTCEnv m, MonadDebug m, BlankVars a) => a -> m a+blankNotInScope e = do+ ctxNames <- getContextNames+ letNames <- map' fst <$> getLetBindings+ let names = Set.fromList . filter ((== C.InScope) . C.isInScope) $ ctxNames ++! letNames+ reportS "reify.blank" 80 $ "names in scope for blanking:" <+> pretty names+ return $! blank names e+++-- | @blank bound e@ replaces all variables in expression @e@ that are not in @bound@ by+-- an underscore @_@. It is used for printing dot patterns: we don't want to+-- make implicit variables explicit, so we blank them out in the dot patterns+-- instead (this is fine since dot patterns can be inferred anyway).++class BlankVars a where+ blank :: Set Name -> a -> a++ default blank :: (Functor f, BlankVars b, f b ~ a) => Set Name -> a -> a+ blank = fmap . blank++instance BlankVars a => BlankVars (Arg a)+instance BlankVars a => BlankVars (Named s a)+instance BlankVars a => BlankVars [a]+instance BlankVars a => BlankVars (List1 a)+instance BlankVars a => BlankVars (FieldAssignment' a)+-- instance BlankVars a => BlankVars (A.Pattern' a) -- see case EqualP !++instance (BlankVars a, BlankVars b) => BlankVars (a, b) where+ blank bound (x, y) = (blank bound x, blank bound y)++instance (BlankVars a, BlankVars b, BlankVars c) => BlankVars (a, b, c) where+ blank bound (x, y, z) = (blank bound x, blank bound y, blank bound z)++instance (BlankVars a, BlankVars b) => BlankVars (Either a b) where+ blank bound (Left x) = Left $ blank bound x+ blank bound (Right y) = Right $ blank bound y++instance BlankVars A.ProblemEq where+ blank bound = id++instance BlankVars A.Clause where+ blank bound (A.Clause lhs strippedPats rhs wh ca)+ | null wh =+ A.Clause (blank bound' lhs)+ (blank bound' strippedPats)+ (blank bound' rhs) noWhereDecls ca+ | otherwise = __IMPOSSIBLE__+ where bound' = varsBoundIn lhs `Set.union` bound++instance BlankVars A.LHS where+ blank bound (A.LHS i core) = A.LHS i $ blank bound core++instance BlankVars A.LHSCore where+ blank bound (A.LHSHead f ps) = A.LHSHead f $ blank bound ps+ blank bound (A.LHSProj p b ps) = uncurry (A.LHSProj p) $ blank bound (b, ps)+ blank bound (A.LHSWith h wps ps) = uncurry (uncurry A.LHSWith) $ blank bound ((h, wps), ps)++instance BlankVars A.Pattern where+ blank bound p = case p of+ A.VarP _ -> p -- do not blank pattern vars+ A.ConP c i ps -> A.ConP c i $ blank bound ps+ A.ProjP{} -> p+ A.DefP i f ps -> A.DefP i f $ blank bound ps+ A.DotP i e -> A.DotP i $ blank bound e+ A.WildP _ -> p+ A.AbsurdP _ -> p+ A.LitP _ _ -> p+ A.AsP i n p -> A.AsP i n $ blank bound p+ A.PatternSynP _ _ _ -> __IMPOSSIBLE__+ A.RecP kwr i fs -> A.RecP kwr i $ blank bound fs+ A.EqualP{} -> p+ A.WithP i p -> A.WithP i (blank bound p)++instance BlankVars A.Expr where+ blank bound e = case e of+ A.ScopedExpr i e -> A.ScopedExpr i $ blank bound e+ A.Var x -> if x `Set.member` bound then e+ else A.Underscore emptyMetaInfo -- Here is the action!+ A.Def' _ _ -> e+ A.Proj{} -> e+ A.Con _ -> e+ A.Lit _ _ -> e+ A.QuestionMark{} -> e+ A.Underscore _ -> e+ A.Dot i e -> A.Dot i $ blank bound e+ A.App i e1 e2 -> uncurry (A.App i) $ blank bound (e1, e2)+ A.WithApp i e es -> uncurry (A.WithApp i) $ blank bound (e, es)+ A.Lam i b e -> let bound' = varsBoundIn b `Set.union` bound+ in A.Lam i (blank bound b) (blank bound' e)+ A.AbsurdLam _ _ -> e+ A.ExtendedLam i d e f cs -> A.ExtendedLam i d e f $ blank bound cs+ A.Pi i tel e -> let bound' = varsBoundIn tel `Set.union` bound+ in uncurry (A.Pi i) $ blank bound' (tel, e)+ A.Generalized {} -> __IMPOSSIBLE__+ A.Fun i a b -> uncurry (A.Fun i) $ blank bound (a, b)+ A.Let _ _ _ -> __IMPOSSIBLE__+ A.Rec kwr i es -> A.Rec kwr i $ blank bound es+ A.RecUpdate kwr i e es -> uncurry (A.RecUpdate kwr i) $ blank bound (e, es)+ A.Quote {} -> __IMPOSSIBLE__+ A.QuoteTerm {} -> __IMPOSSIBLE__+ A.Unquote {} -> __IMPOSSIBLE__+ A.DontCare v -> A.DontCare $ blank bound v+ A.PatternSyn {} -> e+ A.Macro {} -> e+ A.Highlighted q e -> A.Highlighted q $ blank bound e+ A.Qualified q e -> A.Qualified q $ blank bound e++instance BlankVars A.ModuleName where+ blank bound = id++instance BlankVars RHS where+ blank bound (RHS e mc) = RHS (blank bound e) mc+ blank bound AbsurdRHS = AbsurdRHS+ blank bound (WithRHS _ es clauses) = __IMPOSSIBLE__ -- NZ+ blank bound (RewriteRHS xes spats rhs _) = __IMPOSSIBLE__ -- NZ++instance BlankVars A.LamBinding where+ blank bound b@A.DomainFree{} = b+ blank bound (A.DomainFull bs) = A.DomainFull $ blank bound bs++instance BlankVars TypedBinding where+ blank bound (TBind r t n e) = TBind r t n $ blank bound e+ blank bound (TLet _ _) = __IMPOSSIBLE__ -- Since the internal syntax has no let bindings left+++-- | Collect the binders in some abstract syntax lhs.++class Binder a where+ varsBoundIn :: a -> Set Name++ default varsBoundIn :: (Foldable f, Binder b, f b ~ a) => a -> Set Name+ varsBoundIn = foldMap varsBoundIn++instance Binder A.LHS where+ varsBoundIn (A.LHS _ core) = varsBoundIn core++instance Binder A.LHSCore where+ varsBoundIn (A.LHSHead _ ps) = varsBoundIn ps+ varsBoundIn (A.LHSProj _ b ps) = varsBoundIn (b, ps)+ varsBoundIn (A.LHSWith h wps ps) = varsBoundIn ((h, wps), ps)++instance Binder A.Pattern where+ varsBoundIn = foldAPattern $ \case+ A.VarP x -> varsBoundIn x+ A.AsP _ x _ -> empty -- Not x because of #2414 (?)+ A.ConP _ _ _ -> empty+ A.ProjP{} -> empty+ A.DefP _ _ _ -> empty+ A.WildP{} -> empty+ A.DotP{} -> empty+ A.AbsurdP{} -> empty+ A.LitP{} -> empty+ A.PatternSynP _ _ _ -> empty+ A.RecP _ _ _ -> empty+ A.EqualP{} -> empty+ A.WithP _ _ -> empty++instance Binder a => Binder (A.Binder' a) where+ varsBoundIn (A.Binder p _ n) = varsBoundIn (p, n)++instance Binder A.LamBinding where+ varsBoundIn (A.DomainFree _ x) = varsBoundIn x+ varsBoundIn (A.DomainFull b) = varsBoundIn b++instance Binder TypedBinding where+ varsBoundIn (TBind _ _ xs _) = varsBoundIn xs+ varsBoundIn (TLet _ bs) = varsBoundIn bs++instance Binder BindName where+ varsBoundIn x = singleton (unBind x)++instance Binder A.LetBinding where+ varsBoundIn (LetBind _ _ x _ _) = varsBoundIn x+ varsBoundIn (LetAxiom _ _ x _) = varsBoundIn x+ varsBoundIn (LetPatBind _ _ p _)= varsBoundIn p+ varsBoundIn LetApply{} = empty+ varsBoundIn LetOpen{} = empty++instance Binder a => Binder (FieldAssignment' a)+instance Binder a => Binder (Arg a)+instance Binder a => Binder (Named x a)+instance Binder a => Binder [a]+instance Binder a => Binder (List1 a)+instance Binder a => Binder (Maybe a)++instance (Binder a, Binder b) => Binder (a, b) where+ varsBoundIn (x, y) = varsBoundIn x `Set.union` varsBoundIn y++{-# SPECIALIZE reifyPatterns :: [NamedArg I.DeBruijnPattern] -> TCM [NamedArg A.Pattern] #-}+-- | Assumes that pattern variables have been added to the context already.+-- Picks pattern variable names from context.+reifyPatterns :: MonadReify m => [NamedArg I.DeBruijnPattern] -> m [NamedArg A.Pattern]+reifyPatterns = mapM $ (stripNameFromExplicit . stripHidingFromPostfixProj) <.>+ traverse (traverse reifyPat)+ where+ -- #4399 strip also empty names+ stripNameFromExplicit :: NamedArg p -> NamedArg p+ stripNameFromExplicit a+ | visible a || maybe True (liftA2 (||) null isNoName) (bareNameOf a) =+ fmap (unnamed . namedThing) a+ | otherwise = a++ stripHidingFromPostfixProj :: IsProjP p => NamedArg p -> NamedArg p+ stripHidingFromPostfixProj a = case isProjP a of+ Just (o, _) | o /= ProjPrefix -> setHiding NotHidden a+ _ -> a++ reifyPat :: MonadReify m => I.DeBruijnPattern -> m A.Pattern+ reifyPat p = do+ reportS "reify.pat" 80 $ "reifying pattern" <+> pretty p+ keepVars <- optKeepPatternVariables <$> pragmaOptions+ case p of+ -- Possibly expanded literal pattern (see #4215)+ p | Just (PatternInfo PatOLit asB) <- patternInfo p -> do+ reduce (I.patternToTerm p) >>= \case+ I.Lit l -> addAsBindings asB $ return $ A.LitP empty l+ _ -> __IMPOSSIBLE__+ I.VarP i x -> addAsBindings (patAsNames i) $ case patOrigin i of+ o@PatODot -> reifyDotP keepVars o $ var $ dbPatVarIndex x+ PatOWild -> return $ A.WildP patNoRange+ PatOAbsurd -> return $ A.AbsurdP patNoRange+ _ -> reifyVarP x+ I.DotP i v -> addAsBindings (patAsNames i) $ case patOrigin i of+ PatOWild -> return $ A.WildP patNoRange+ PatOAbsurd -> return $ A.AbsurdP patNoRange+ -- If Agda turned a user variable @x@ into @.x@, print it back as @x@.+ o@(PatOVar x) | I.Var i [] <- v -> do+ x' <- nameOfBV i+ if nameConcrete x == nameConcrete x' then+ return $! A.VarP $ mkBindName x'+ else+ reifyDotP keepVars o v+ o -> reifyDotP keepVars o v+ I.LitP i l -> addAsBindings (patAsNames (litPInfo i)) $ return $ A.LitP empty l+ I.ProjP o d -> return $! A.ProjP patNoRange o $ unambiguous d+ I.ConP c cpi ps | conPRecord cpi -> addAsBindings (patAsNames $ conPInfo cpi) $+ case patOrigin (conPInfo cpi) of+ PatOWild -> return $ A.WildP patNoRange+ PatOAbsurd -> return $ A.AbsurdP patNoRange+ PatOVar x | keepVars -> return $ A.VarP $ mkBindName x+ _ -> reifyConP c cpi ps+ I.ConP c cpi ps -> addAsBindings (patAsNames $ conPInfo cpi) $ reifyConP c cpi ps+ I.DefP i f ps -> addAsBindings (patAsNames i) $ case patOrigin i of+ PatOWild -> return $ A.WildP patNoRange+ PatOAbsurd -> return $ A.AbsurdP patNoRange+ PatOVar x | keepVars -> return $ A.VarP $ mkBindName x+ _ -> A.DefP patNoRange (unambiguous f) <$> reifyPatterns ps+ I.IApplyP i _ _ x -> addAsBindings (patAsNames i) $ case patOrigin i of+ o@PatODot -> reifyDotP keepVars o $ var $ dbPatVarIndex x+ PatOWild -> return $ A.WildP patNoRange+ PatOAbsurd -> return $ A.AbsurdP patNoRange+ _ -> reifyVarP x++ reifyVarP :: MonadReify m => DBPatVar -> m A.Pattern+ reifyVarP x = do+ n <- nameOfBV $ dbPatVarIndex x+ let y = dbPatVarName x+ if | y == "_" -> return $ A.VarP $ mkBindName n+ -- Andreas, 2017-09-03: TODO for #2580+ -- Patterns @VarP "()"@ should have been replaced by @AbsurdP@, but the+ -- case splitter still produces them.+ | prettyShow (nameConcrete n) == "()" -> return $! A.VarP (mkBindName n)+ -- Andreas, 2017-09-03, issue #2729+ -- Restore original pattern name. AbstractToConcrete picks unique names.+ | otherwise -> return $! A.VarP $+ mkBindName n { nameConcrete = C.simpleName y }++ reifyDotP :: MonadReify m => Bool -> PatOrigin -> Term -> m A.Pattern+ reifyDotP keepVars o v = do+ if | PatOVar x <- o , keepVars -> return $! A.VarP $ mkBindName x+ | PatOSplitArg x <- o , keepVars -> A.VarP . mkBindName <$> freshName noRange x+ | otherwise -> A.DotP patNoRange <$> reify v++ reifyConP :: MonadReify m+ => ConHead -> ConPatternInfo -> [NamedArg DeBruijnPattern]+ -> m A.Pattern+ reifyConP c cpi ps = do+ tryRecPFromConP =<< do A.ConP ci (unambiguous (conName c)) <$> reifyPatterns ps+ where+ ci = ConPatInfo origin patNoRange lazy+ lazy | conPLazy cpi = ConPatLazy+ | otherwise = ConPatEager+ origin = fromConPatternInfo cpi++ addAsBindings :: Functor m => [A.Name] -> m A.Pattern -> m A.Pattern+ addAsBindings xs p = foldr (fmap . AsP patNoRange . mkBindName) p xs++{-# SPECIALIZE reifyRecordFields :: SmallSet Origin -> RecordData -> (NamedArg A.Pattern -> A.Pattern) -> [NamedArg A.Pattern] -> TCM [FieldAssignment' A.Pattern] #-}+{-# SPECIALIZE reifyRecordFields :: SmallSet Origin -> RecordData -> (Arg Expr -> Expr) -> [Arg Expr] -> TCM [FieldAssignment' Expr] #-}+-- | Pair the fields of a record type with the arguments of its constructor,+-- producing the field assignments of a record pattern or record expression.+--+-- Andreas, 2025-09-29, issue #8787:+-- Invisible (hidden and instance) fields are dropped unless @--show-implicit@ is on.+-- This conforms the printing of records to the printing of applications+-- of a record constructor (see 'stripImplicits' and 'nelims').+reifyRecordFields :: (MonadReify m, LensOrigin a)+ => SmallSet Origin -- ^ Set of origins that make us keep an invisible field anyway.+ -> RecordData -- ^ Definition of the record type, supplying the field names.+ -> (a -> e) -- ^ How to extract the content of a constructor argument.+ -> [a] -- ^ The arguments of the record constructor.+ -> m [FieldAssignment' e]+reifyRecordFields keepOrigins def content args = do+ let fs = recordFieldNames def+ unless (length fs == length args) __IMPOSSIBLE__+ showImp <- showImplicitArguments+ let keep (f, a) = visible f || getOrigin a `SmallSet.member` keepOrigins+ return $! map' (\ (f, a) -> FieldAssignment (unDom f) (content a))+ $ applyUnless showImp (filter' keep)+ $ zip' fs args++{-# SPECIALIZE tryRecPFromConP :: A.Pattern -> TCM A.Pattern #-}+-- | If the record constructor is generated or the user wrote a record pattern,+-- turn constructor pattern into record pattern.+-- Otherwise, keep constructor pattern.+tryRecPFromConP :: MonadReify m => A.Pattern -> m A.Pattern+tryRecPFromConP p = do+ let fallback = return p+ case p of+ A.ConP ci c ps -> do+ reportS "reify.pat" 60 $ "tryRecPFromConP" <+> pretty c+ caseMaybeM (isRecordConstructor $ headAmbQ c) fallback $ \ (r, def) -> do+ -- If the record constructor is generated or the user wrote a record pattern,+ -- print record pattern.+ -- Otherwise, print constructor pattern.+ if _recNamedCon def && conPatOrigin ci /= ConORec then fallback else+ -- Andreas, 2025-09-29, issue #8787: Keep the invisible fields+ -- the user wrote, just like 'stripImplicits' does for constructor patterns.+ A.RecP empty ci <$> reifyRecordFields recordPatternKeeperOrigins def namedArg ps+ _ -> __IMPOSSIBLE__++-- | 'Origin' values (e.g. 'UserWritten') that indicate an implicit record field+-- should be kept during printing of a record pattern.+recordPatternKeeperOrigins :: SmallSet Origin+recordPatternKeeperOrigins = SmallSet.fromList [ UserWritten, CaseSplit ]++-- | 'Origin' values (e.g. 'ConversionFail') that indicate an implicit record field+-- should be kept during printing of a record expression.+recordExpressionKeeperOrigins :: SmallSet Origin+recordExpressionKeeperOrigins = SmallSet.fromList [ ConversionFail ]++{-# SPECIALIZE recOrCon :: QName -> ConOrigin -> [Arg Expr] -> TCM A.Expr #-}+-- | If the record constructor is generated or the user wrote a record expression,+-- turn constructor expression into record expression.+-- Otherwise, keep constructor expression.+recOrCon :: MonadReify m => QName -> ConOrigin -> [Arg Expr] -> m A.Expr+recOrCon c co es = do+ reportS "reify.expr" 60 $ "recOrCon" <+> pretty c+ caseMaybeM (isRecordConstructor c) fallback $ \ (r, def) -> do+ -- If the record constructor is generated or the user wrote a record expression,+ -- print record expression.+ -- Otherwise, print constructor expression.+ if _recNamedCon def && co /= ConORec then fallback else+ -- Andreas, 2025-09-29, issue #8787: Keep the invisible fields+ -- the conversion checker insists on, just like 'nelims' does for applications.+ A.Rec empty empty . map' Left <$> reifyRecordFields recordExpressionKeeperOrigins def unArg es+ where+ fallback = apps (A.Con (unambiguous c)) es++instance Reify (QNamed I.Clause) where+ type ReifiesTo (QNamed I.Clause) = A.Clause++ reify (QNamed f cl) = reify (NamedClause f True cl); {-# INLINE reify #-}++instance Reify NamedClause where+ type ReifiesTo NamedClause = A.Clause++ reify (NamedClause f toDrop cl) = addContext (clauseTel cl) $ do+ reportS "reify.clause" 60 $ vcat+ [ "reifying NamedClause"+ , " f =" <+> pretty f+ , " toDrop =" <+> pshow toDrop+ , " cl =" <+> pretty cl+ ]++ let clBody = clauseBody cl+ rhsVars = freeVarList clBody++ rhsBody <- traverse reify clBody+ rhsVarNames <- mapM nameOfBV' rhsVars+ let rhsUsedNames = maybe mempty allUsedNames rhsBody+ rhsUsedVars = [i | (i, Just n) <- zip' rhsVars rhsVarNames, n `Set.member` rhsUsedNames]++ reportS "reify.clause" 60 $ "RHS:" <+> pretty clBody+ reportS "reify.clause" 60 $ "variables occurring on RHS:" <+> pretty rhsVars+ <+> "variable names:" <+> pretty rhsVarNames+ <+> parens (maybe "no clause body" (const "there was a clause body") clBody)+ reportS "reify.clause" 60 $ "names occurring on RHS" <+> pretty (Set.toList rhsUsedNames)++ let ell = clauseEllipsis cl+ ps <- reifyPatterns $ namedClausePats cl+ lhs <- uncurry (SpineLHS $ empty { lhsEllipsis = ell }) <$> reifyDisplayFormP f ps []+ -- Unless @toDrop@ we have already dropped the module patterns from the clauses+ -- (e.g. for extended lambdas). We still get here with toDrop = True and+ -- pattern lambdas when doing make-case, so take care to drop the right+ -- number of parameters.+ (params , lhs) <- if not toDrop then return ([] , lhs) else do+ nfv <- getDefModule f >>= \case+ Left _ -> return 0+ Right m -> size <$> lookupSection m+ return $! splitParams nfv lhs+ lhs <- stripImps rhsUsedNames params lhs+ let rhs = caseMaybe rhsBody AbsurdRHS $ \ e -> RHS e Nothing+ result = A.Clause (spineToLhs lhs) [] rhs A.noWhereDecls (I.clauseCatchall cl)+ return result+ where+ splitParams n (SpineLHS i f ps) =+ let (params , pats) = splitAt n ps+ in (params , SpineLHS i f pats)+ stripImps :: MonadReify m => Set Name -> [NamedArg A.Pattern] -> SpineLHS -> m SpineLHS+ stripImps rhsUsedNames params (SpineLHS i f ps) = SpineLHS i f <$> stripImplicits rhsUsedNames params ps+{-# SPECIALIZE reify :: NamedClause -> TCM (ReifiesTo NamedClause) #-}++instance Reify (QNamed System) where+ type ReifiesTo (QNamed System) = [A.Clause]++ reify (QNamed f (System tel sys)) = addContext tel $ do+ reportS "reify.system" 40 $ show tel : map' show sys+ view <- intervalView'+ unview <- intervalUnview'+ sys <- flip filterM sys $ \ (phi,t) -> do+ forallM phi $ \ (u,b) -> do+ u <- reduce u+ return $! case (view u, b) of+ (IZero, True) -> False+ (IOne, False) -> False+ _ -> True+ forM sys $ \ (alpha,u) -> do+ ps <- reifyPatterns $ teleNamedArgs tel+ ps <- List1.ifNull alpha (pure ps) {-else-} \ alpha -> do+ ep <- fmap (A.EqualP patNoRange) . forM alpha $ \ (phi,b) -> do+ let+ d True = unview IOne+ d False = unview IZero+ reify (phi, d b)+ pure $ ps ++! [defaultNamedArg ep]++ lhs <- SpineLHS empty f <$> stripImplicits mempty [] ps+ rhs <- reify u <&> (`RHS` Nothing)+ return $! A.Clause (spineToLhs lhs) [] rhs A.noWhereDecls empty+{-# SPECIALIZE reify :: QNamed System -> TCM (ReifiesTo (QNamed System)) #-}++instance Reify I.Type where+ type ReifiesTo I.Type = A.Type++ reifyWhen = reifyWhenE; {-# INLINE reifyWhen #-}+ reify (I.El _ t) = reify t; {-# INLINE reify #-}++instance Reify Sort where+ type ReifiesTo Sort = Expr++ reifyWhen = reifyWhenE++ reify s = do+ s <- instantiateFull s+ SortKit{ nameOfUniv } <- infallibleSortKit+ case s of+ I.Univ u (I.ClosedLevel 0) -> return $! A.Def' (nameOfUniv USmall u) A.NoSuffix+ I.Univ u (I.ClosedLevel n) -> return $! A.Def' (nameOfUniv USmall u) (A.Suffix n)+ I.Univ u a -> do+ a <- reify a+ return $! A.App defaultAppInfo_ (A.Def $ nameOfUniv USmall u) (defaultNamedArg a)+ I.Inf u 0 -> return $! A.Def' (nameOfUniv ULarge u) A.NoSuffix+ I.Inf u n -> return $! A.Def' (nameOfUniv ULarge u) (A.Suffix n)+ I.SizeUniv -> do+ sizeU <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinSizeUniv+ return $! A.Def sizeU+ I.LockUniv -> do+ lockU <- fromMaybe __IMPOSSIBLE__ <$> getName' builtinLockUniv+ return $! A.Def lockU+ I.LevelUniv -> do+ levelU <- fromMaybe __IMPOSSIBLE__ <$> getName' builtinLevelUniv+ return $! A.Def levelU+ I.IntervalUniv -> do+ intervalU <- fromMaybe __IMPOSSIBLE__ <$> getName' builtinIntervalUniv+ return $! A.Def intervalU+ I.PiSort c a s1 s2 -> do+ pis <- freshName_ ("piSort" :: String) -- TODO: hack+ (e1,e2) <- reify (s1, I.Lam defaultArgInfo $ fmap Sort s2)+ let app x y = A.App defaultAppInfo_ x (defaultNamedArg y)+ return $! A.Var pis `app` e1 `app` e2+ I.FunSort s1 s2 -> do+ funs <- freshName_ ("funSort" :: String) -- TODO: hack+ (e1,e2) <- reify (s1 , s2)+ let app x y = A.App defaultAppInfo_ x (defaultNamedArg y)+ return $! A.Var funs `app` e1 `app` e2+ I.UnivSort s -> do+ univs <- freshName_ ("univSort" :: String) -- TODO: hack+ e <- reify s+ return $! A.App defaultAppInfo_ (A.Var univs) $ defaultNamedArg e+ I.MetaS x es -> reify $ I.MetaV x es+ I.DefS d es -> reify $ I.Def d es+ I.DummyS s -> return $! A.Lit empty $ LitString $ T.pack s+{-# SPECIALIZE reify :: Sort -> TCM (ReifiesTo Sort) #-}++instance Reify Level where+ type ReifiesTo Level = Expr++ reifyWhen = reifyWhenE+ reify l = ifM haveLevels (reify =<< reallyUnLevelView l) $ {-else-} do+ -- Andreas, 2017-09-18, issue #2754+ -- While type checking the level builtins, they are not+ -- available for debug printing. Thus, print some garbage instead.+ name <- freshName_ (".#Lacking_Level_Builtins#" :: String)+ return $! A.Var name+{-# SPECIALIZE reify :: Level -> TCM (ReifiesTo Level) #-}++instance (Free i, Reify i) => Reify (Abs i) where+ type ReifiesTo (Abs i) = (Name, ReifiesTo i)++ reify (NoAbs x v) = freshName_ x >>= \name -> (name,) <$> reify v+ reify (Abs s v) = do++ -- If the bound variable is free in the body, then the name "_" is+ -- replaced by "z".+ s <- return $! if isUnderscore s && 0 `freeIn` v then "z" else s++ x <- C.setNotInScope <$> freshName_ s+ e <- addContext x -- type doesn't matter+ $ reify v+ return (x,e)+{-# SPECIALIZE reify :: (Free i, Reify i) -> Abs i -> TCM (ReifiesTo (Abs i)) #-}++instance Reify I.Telescope where+ type ReifiesTo I.Telescope = A.Telescope++ reify EmptyTel = return []+ reify (ExtendTel arg tel) = do+ Arg info e <- reify arg+ (x, bs) <- reify tel+ let r = getRange e+ name = domName arg+ tac <- TacticAttribute <$> do traverse (Ranged noRange <.> reify) $ domTactic arg+ let xs = singleton $ Arg info $ Named name $ A.mkBinder_ x+ return $! TBind r (TypedBindingInfo tac (domIsFinite arg)) xs e : bs+{-# SPECIALIZE reify :: I.Telescope -> TCM (ReifiesTo I.Telescope) #-}++instance Reify i => Reify (Dom i) where+ type ReifiesTo (Dom i) = Arg (ReifiesTo i)++ reify d = Arg (d ^. dInfo) <$> reify (unDom d)+ {-# INLINE reify #-}++instance Reify Context where+ type ReifiesTo Context = [A.TypedBinding]++ reify = reify . contextToTel++instance Reify ContextEntry where+ type ReifiesTo ContextEntry = A.TypedBinding++ reify (CtxVar x a) = do+ Arg info (y,t) <- reify $ (x,) <$> a+ let r = getRange x+ name = domName a+ xs = singleton $ Arg info $ Named name $ A.mkBinder_ y+ tac <- TacticAttribute <$> do traverse (Ranged noRange <.> reify) $ domTactic a+ return $! TBind r (TypedBindingInfo tac (domIsFinite a)) xs t++instance Reify i => Reify (I.Elim' i) where+ type ReifiesTo (I.Elim' i) = I.Elim' (ReifiesTo i)++ reify = traverse reify+ reifyWhen b = traverse (reifyWhen b)++instance Reify i => Reify [i] where+ type ReifiesTo [i] = [ReifiesTo i]++ reify = traverse reify+ reifyWhen b = traverse (reifyWhen b)++instance Reify i => Reify (List1 i) where+ type ReifiesTo (List1 i) = List1 (ReifiesTo i)++ reify = traverse reify+ reifyWhen b = traverse (reifyWhen b)++instance (Reify i1, Reify i2) => Reify (i1, i2) where+ type ReifiesTo (i1, i2) = (ReifiesTo i1, ReifiesTo i2)+ reify (x,y) = (,) <$> reify x <*> reify y++instance (Reify i1, Reify i2, Reify i3) => Reify (i1,i2,i3) where+ type ReifiesTo (i1, i2, i3) = (ReifiesTo i1, ReifiesTo i2, ReifiesTo i3)+ reify (x,y,z) = (,,) <$> reify x <*> reify y <*> reify z++instance (Reify i1, Reify i2, Reify i3, Reify i4) => Reify (i1,i2,i3,i4) where+ type ReifiesTo (i1, i2, i3, i4) = (ReifiesTo i1, ReifiesTo i2, ReifiesTo i3, ReifiesTo i4)+ reify (x,y,z,w) = (,,,) <$> reify x <*> reify y <*> reify z <*> reify w
@@ -0,0 +1,307 @@+{-# OPTIONS_GHC -fwarn-missing-signatures #-}++module Agda.Syntax.Translation.ReflectedToAbstract where++import Control.Monad ( foldM )+import Control.Monad.Except ( MonadError )+import Control.Monad.Reader ( MonadReader(..), asks, reader, runReaderT )++import Data.Maybe+import Data.Set (Set)+import Data.Set qualified as Set+import Data.Text (Text)+import Data.Text qualified as Text++import Agda.Syntax.Literal+import Agda.Syntax.Position+import Agda.Syntax.Info+import Agda.Syntax.Common+import Agda.Syntax.Abstract+ ( Name, QName, QNamed(QNamed)+ , isNoName, nameConcrete, nextName, qualify, unambiguous+ )+import Agda.Syntax.Abstract qualified as A+import Agda.Syntax.Abstract.Pattern+import Agda.Syntax.Reflected as R+import Agda.Syntax.Internal (Dom,Dom'(..), pattern Dom, dIsFinite, dInfo)+import Agda.Interaction.Options (optUseUnicode, UnicodeOrAscii(..))+import Agda.TypeChecking.Monad as M hiding (MetaInfo)+import Agda.Syntax.Scope.Monad (getCurrentModule)++import Agda.Utils.Impossible+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|))+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty+import Agda.Utils.Functor+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.Tuple ( (***) )++type Vars = [(Name,R.Type)]++type MonadReflectedToAbstract m =+ ( MonadReader Vars m+ , MonadFresh NameId m+ , MonadError TCErr m+ , MonadTCEnv m+ , ReadTCState m+ , HasOptions m+ , HasBuiltins m+ , HasConstInfo m+ )++-- | Adds a new unique name to the current context.+-- NOTE: See @chooseName@ in @Agda.Syntax.Translation.AbstractToConcrete@ for similar logic.+-- NOTE: See @freshConcreteName@ in @Agda.Syntax.Scope.Monad@ also for similar logic.+withName :: MonadReflectedToAbstract m => String -> (Name -> m a) -> m a+withName s = withVar s R.Unknown++withVar :: MonadReflectedToAbstract m => String -> R.Type -> (Name -> m a) -> m a+withVar s t f = do+ name <- freshName_ s+ ctx <- asks $ map $ nameConcrete . fst+ glyphMode <- optUseUnicode <$> M.pragmaOptions+ let freshNameMode = case glyphMode of+ UnicodeOk -> A.UnicodeSubscript+ AsciiOnly -> A.AsciiCounter+ let name' = headWithDefault __IMPOSSIBLE__ $ filter (notTaken ctx) $ iterate (nextName freshNameMode) name+ local ((name,t):) $ f name'+ where+ notTaken xs x = isNoName x || nameConcrete x `notElem` xs++withNames :: MonadReflectedToAbstract m => [String] -> ([Name] -> m a) -> m a+withNames = withVars . map (,R.Unknown)++withVars :: MonadReflectedToAbstract m => [(String, R.Type)] -> ([Name] -> m a) -> m a+withVars ss f = case ss of+ [] -> f []+ ((s,t):ss) -> withVar s t $ \n -> withVars ss $ \ns -> f (n:ns)++-- | Returns the name and type of the variable with the given de Bruijn index.+askVar :: MonadReflectedToAbstract m => Int -> m (Maybe (Name,R.Type))+askVar i = reader (!!! i)++askName :: MonadReflectedToAbstract m => Int -> m (Maybe Name)+askName i = fmap fst <$> askVar i++class ToAbstract r where+ type AbsOfRef r+ toAbstract :: MonadReflectedToAbstract m => r -> m (AbsOfRef r)++ default toAbstract+ :: (Traversable t, ToAbstract s, t s ~ r, t (AbsOfRef s) ~ (AbsOfRef r))+ => MonadReflectedToAbstract m => r -> m (AbsOfRef r)+ toAbstract = traverse toAbstract++-- | Translate reflected syntax to abstract, using the names from the current typechecking context.+toAbstract_ ::+ (ToAbstract r+ , MonadFresh NameId m+ , MonadError TCErr m+ , ReadTCState m+ , HasBuiltins m+ , HasConstInfo m+ ) => r -> m (AbsOfRef r)+toAbstract_ = withShowAllArguments . toAbstractWithoutImplicit++-- | Drop implicit arguments unless --show-implicit is on.+toAbstractWithoutImplicit ::+ (ToAbstract r+ , MonadFresh NameId m+ , MonadError TCErr m+ , ReadTCState m+ , HasBuiltins m+ , HasConstInfo m+ ) => r -> m (AbsOfRef r)+toAbstractWithoutImplicit x = do+ xs <- killRange <$> getContextNames'+ let ctx = map (,R.Unknown) xs+ runReaderT (toAbstract x) ctx++instance ToAbstract r => ToAbstract (Named name r) where+ type AbsOfRef (Named name r) = Named name (AbsOfRef r)++instance ToAbstract r => ToAbstract (Arg r) where+ type AbsOfRef (Arg r) = NamedArg (AbsOfRef r)+ toAbstract (Arg i x) = Arg i <$> toAbstract (unnamed x)++instance ToAbstract r => ToAbstract [Arg r] where+ type AbsOfRef [Arg r] = [NamedArg (AbsOfRef r)]++-- instance ToAbstract r A.Expr => ToAbstract (Dom r, Name) (A.TypedBinding) where+instance (ToAbstract r, AbsOfRef r ~ A.Expr) => ToAbstract (Dom r, Name) where+ type AbsOfRef (Dom r, Name) = A.TypedBinding+ toAbstract (d, name) = do+ dom <- toAbstract (unDom d)+ -- TODO(Amy): Anyone know why this discards the tactic? It was like+ -- that when I got here!+ return $ A.TBind noRange+ (A.TypedBindingInfo empty (d ^. dIsFinite))+ (singleton $ unnamedArg (d ^. dInfo) $ A.mkBinder_ name)+ dom++instance ToAbstract (A.Expr, Elim) where+ type AbsOfRef (A.Expr, Elim) = A.Expr+ toAbstract (f, Apply arg) = do+ arg <- toAbstract arg+ showImp <- showImplicitArguments+ return $ if showImp || visible arg+ then A.App (setOrigin Reflected defaultAppInfo_) f arg+ else f++instance ToAbstract (A.Expr, Elims) where+ type AbsOfRef (A.Expr, Elims) = A.Expr+ toAbstract (f, elims) = foldM (curry toAbstract) f elims++instance ToAbstract r => ToAbstract (R.Abs r) where+ type AbsOfRef (R.Abs r) = (AbsOfRef r, Name)+ toAbstract (Abs s x) = withName s' $ \name -> (,name) <$> toAbstract x+ where s' = if (isNoName s) then "z" else s -- TODO: only do this when var is free++instance ToAbstract Literal where+ type AbsOfRef Literal = A.Expr+ toAbstract l = return $ A.Lit empty l++instance ToAbstract Term where+ type AbsOfRef Term = A.Expr+ toAbstract = \case+ R.Var i es -> do+ name <- mkVarName i+ toAbstract (A.Var name, es)+ R.Con c es -> toAbstract (A.Con (unambiguous $ killRange c), es)+ R.Def f es -> do+ af <- mkDef (killRange f)+ toAbstract (af, es)+ R.Lam h t -> do+ (e, name) <- toAbstract t+ let info = setHiding h $ setOrigin Reflected defaultArgInfo+ return $ A.Lam exprNoRange (A.mkDomainFree $ unnamedArg info $ A.mkBinder_ name) e+ R.ExtLam cs es -> do+ name <- freshName_ extendedLambdaName+ m <- getCurrentModule+ let qname = qualify m name+ cname = nameConcrete name+ defInfo = mkDefInfo cname noFixity' PublicAccess ConcreteDef noRange+ cs <- toAbstract $ fmap (QNamed qname) cs+ toAbstract+ (A.ExtendedLam exprNoRange defInfo defaultErased qname cs, es)+ R.Pi a b -> do+ (b, name) <- toAbstract b+ a <- toAbstract (a, name)+ return $ A.Pi exprNoRange (singleton a) b+ R.Sort s -> toAbstract s+ R.Lit l -> toAbstract l+ R.Meta x es -> do+ info <- mkMetaInfo+ let info' = info{ metaNumber = Just x }+ toAbstract (A.Underscore info', es)+ R.Unknown -> A.Underscore <$> mkMetaInfo++mkMetaInfo :: ReadTCState m => m MetaInfo+mkMetaInfo = do+ scope <- getScope+ return $ emptyMetaInfo { metaScope = scope }++mkDef :: HasConstInfo m => QName -> m A.Expr+mkDef f = getConstInfo f <&> theDef <&> \case++ Constructor{}+ -> A.Con $ unambiguous f++ Function{ funProjection = Right Projection{ projProper = Just{} } }+ -> A.Proj ProjSystem $ unambiguous f++ d@Function{} | isMacro d+ -> A.Macro f++ _ -> A.Def f++mkApp :: A.Expr -> A.Expr -> A.Expr+mkApp e1 e2 = A.App (setOrigin Reflected defaultAppInfo_) e1 $ defaultNamedArg e2+++mkVar :: MonadReflectedToAbstract m => Int -> m (Name, R.Type)+mkVar i = ifJustM (askVar i) return $ do+ cxt <- getContextTelescope+ names <- asks $ drop (size cxt) . reverse . map fst+ withShowAllArguments' False $ typeError $ DeBruijnIndexOutOfScope i cxt names++mkVarName :: MonadReflectedToAbstract m => Int -> m Name+mkVarName i = fst <$> mkVar i+++instance ToAbstract Sort where+ type AbsOfRef Sort = A.Expr+ toAbstract s = do+ setName <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinSet+ propName <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinProp+ infName <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinSetOmega+ case s of+ SetS x -> mkApp (A.Def setName) <$> toAbstract x+ LitS x -> return $ A.Def' setName $ A.Suffix x+ PropS x -> mkApp (A.Def propName) <$> toAbstract x+ PropLitS x -> return $ A.Def' propName $ A.Suffix x+ InfS x -> return $ A.Def' infName $ A.Suffix x+ UnknownS -> mkApp (A.Def setName) . A.Underscore <$> mkMetaInfo++instance ToAbstract R.Pattern where+ type AbsOfRef R.Pattern = A.Pattern+ toAbstract pat = case pat of+ R.ConP c args -> do+ args <- toAbstract args+ return $ A.ConP (ConPatInfo ConOCon patNoRange ConPatEager) (unambiguous $ killRange c) args+ R.DotP t -> A.DotP patNoRange <$> toAbstract t+ R.VarP i -> do+ (x, _t) <- mkVar i+ return $ A.VarP $ A.mkBindName x+ R.LitP l -> return $ A.LitP patNoRange l+ R.AbsurdP _i -> return $ A.AbsurdP patNoRange+ R.ProjP d -> return $ A.ProjP patNoRange ProjSystem $ unambiguous $ killRange d++instance ToAbstract (QNamed R.Clause) where+ type AbsOfRef (QNamed R.Clause) = A.Clause++ toAbstract (QNamed name (R.Clause tel pats rhs)) = withVars (map (Text.unpack *** unArg) tel) $ \_ -> do+ checkClauseTelescopeBindings tel pats+ pats <- toAbstract pats+ rhs <- toAbstract rhs+ let lhs = spineToLhs $ A.SpineLHS empty name pats+ return $ A.Clause lhs [] (A.RHS rhs Nothing) A.noWhereDecls empty+ toAbstract (QNamed name (R.AbsurdClause tel pats)) = withVars (map (Text.unpack *** unArg) tel) $ \_ -> do+ checkClauseTelescopeBindings tel pats+ pats <- toAbstract pats+ let lhs = spineToLhs $ A.SpineLHS empty name pats+ return $ A.Clause lhs [] A.AbsurdRHS A.noWhereDecls empty++instance ToAbstract [QNamed R.Clause] where+ type AbsOfRef [QNamed R.Clause] = [A.Clause]+ toAbstract = traverse toAbstract++instance ToAbstract (List1 (QNamed R.Clause)) where+ type AbsOfRef (List1 (QNamed R.Clause)) = List1 A.Clause+ toAbstract = traverse toAbstract++-- | Check that all variables in the telescope are bound in the left-hand side. Since we check the+-- telescope by attaching type annotations to the pattern variables there needs to be somewhere to+-- put the annotation. Also, since the lhs is where the variables are actually bound, missing a+-- binding for a variable that's used later in the telescope causes unbound variable panic+-- (see #5044).+checkClauseTelescopeBindings :: MonadReflectedToAbstract m => [(Text, Arg R.Type)] -> [Arg R.Pattern] -> m ()+checkClauseTelescopeBindings tel pats =+ case reverse [ x | ((x, _), i) <- zip (reverse tel) [0..], not $ Set.member i bs ] of+ [] -> return ()+ x:xs -> typeError $ MissingBindingsForTelescopeVariables (x :| xs)+ where+ bs = boundVars pats++ boundVars = Set.unions . map (bound . unArg)+ bound (R.VarP i) = Set.singleton i+ bound (R.ConP _ ps) = boundVars ps+ bound R.DotP{} = Set.empty+ bound R.LitP{} = Set.empty+ bound (R.AbsurdP i) = Set.singleton i+ bound R.ProjP{} = Set.empty
@@ -0,0 +1,355 @@+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wunused-matches #-}++{-# LANGUAGE PatternSynonyms #-}++-- | The treeless syntax is intended to be used as input for the compiler backends.+-- It is more low-level than Internal syntax and is not used for type checking.+--+-- Some of the features of treeless syntax are:+-- - case expressions instead of case trees+-- - no instantiated datatypes / constructors+module Agda.Syntax.Treeless+ ( module Agda.Syntax.Abstract.Name+ , module Agda.Syntax.Treeless+ ) where++import Control.DeepSeq++import Data.Word++import GHC.Generics (Generic)++import Agda.Syntax.Position+import Agda.Syntax.Internal (TermSize(..))+import Agda.Syntax.Literal+import Agda.Syntax.Common+import Agda.Syntax.Abstract.Name++import Agda.Utils.Tuple (first, second)++data Compiled = Compiled+ { cTreeless :: TTerm+ , cArgUsage :: Maybe [ArgUsage]+ -- ^ 'Nothing' if treeless usage analysis has not run yet.+ }+ deriving (Show, Eq, Ord, Generic)++-- | Usage status of function arguments in treeless code.+data ArgUsage+ = ArgUsed+ | ArgUnused+ deriving (Show, Eq, Ord, Generic)++-- | Strictness.+data Strictness+ = NonStrict+ | Strict+ deriving (Show, Eq, Ord, Generic)++-- | The treeless compiler can behave differently depending on the target+-- language evaluation strategy. For instance, more aggressive erasure for+-- lazy targets.+data EvaluationStrategy+ = LazyEvaluation !Strictness+ -- ^ Lazy evaluation. If the argument is 'Strict', then+ -- applications of inductive (or non-recursive) constructors are+ -- strict.+ | EagerEvaluation+ -- ^ Strict evaluation.+ deriving (Show, Eq, Ord, Generic)++-- | The default strictness.++defaultStrictness :: EvaluationStrategy -> Strictness+defaultStrictness EagerEvaluation = Strict+defaultStrictness (LazyEvaluation _) = NonStrict++-- | The default strictness for constructors of the given kind.++defaultConstructorStrictness ::+ EvaluationStrategy -> Induction -> Strictness+defaultConstructorStrictness _ CoInductive = NonStrict+defaultConstructorStrictness EagerEvaluation Inductive = Strict+defaultConstructorStrictness (LazyEvaluation s) Inductive = s++type Args = [TTerm]++-- this currently assumes that TApp is translated in a lazy/cbn fashion.+-- The AST should also support strict translation.+--+-- | Treeless Term. All local variables are using de Bruijn indices.+data TTerm = TVar Int+ | TPrim TPrim+ | TDef QName+ | TApp TTerm Args+ | TLam TTerm+ | TLit Literal+ | TCon QName+ | TLet Strictness TTerm TTerm+ -- ^ Introduces a new (non-recursive) local binding. It can+ -- be strict or non-strict. Non-strict bindings should not+ -- be made more strict, this could lead to crashes. Sharing+ -- may happen, but is optional. It is also perfectly valid+ -- to just inline the bound term in the body.+ | TCase Int CaseInfo TTerm [TAlt]+ -- ^ Case scrutinee (always variable), case type, default value, alternatives+ -- First, all TACon alternatives are tried; then all TAGuard alternatives+ -- in top to bottom order.+ -- TACon alternatives must not overlap.+ | TUnit -- used for levels right now+ | TSort+ | TErased+ | TCoerce TTerm -- ^ Used by the GHC backend+ | TError TError+ -- ^ A runtime error, something bad has happened.+ deriving (Show, Eq, Ord, Generic)++-- | Compiler-related primitives. This are NOT the same thing as primitives+-- in Agda's surface or internal syntax!+-- Some of the primitives have a suffix indicating which type of arguments they take,+-- using the following naming convention:+-- Char | Type+-- C | Character+-- F | Float+-- I | Integer+-- Q | QName+-- S | String+data TPrim+ = PAdd | PAdd64+ | PSub | PSub64+ | PMul | PMul64+ | PQuot | PQuot64+ | PRem | PRem64+ | PGeq+ | PLt | PLt64+ | PEqI | PEq64+ | PEqF+ | PEqS+ | PEqC+ | PEqQ+ | PIf+ | PSeq+ | PITo64 | P64ToI+ deriving (Show, Eq, Ord, Generic)++isPrimEq :: TPrim -> Bool+isPrimEq p = p `elem` [PEqI, PEqF, PEqS, PEqC, PEqQ, PEq64]++-- | Strip leading coercions and indicate whether there were some.+coerceView :: TTerm -> (Bool, TTerm)+coerceView = \case+ TCoerce t -> (True,) $ snd $ coerceView t+ t -> (False, t)++mkTApp :: TTerm -> Args -> TTerm+mkTApp x [] = x+mkTApp (TApp x as) bs = TApp x (as ++ bs)+mkTApp x as = TApp x as++tAppView :: TTerm -> (TTerm, [TTerm])+tAppView = \case+ TApp a bs -> second (++ bs) $ tAppView a+ t -> (t, [])++-- | Expose the format @coerce f args@.+--+-- We fuse coercions, even if interleaving with applications.+-- We assume that coercion is powerful enough to satisfy+-- @+-- coerce (coerce f a) b = coerce f a b+-- @+coerceAppView :: TTerm -> ((Bool, TTerm), [TTerm])+coerceAppView = \case+ TCoerce t -> first ((True,) . snd) $ coerceAppView t+ TApp a bs -> second (++ bs) $ coerceAppView a+ t -> ((False, t), [])++tLetView :: TTerm -> ([(Strictness, TTerm)], TTerm)+tLetView (TLet s e b) = first ((s, e) :) $ tLetView b+tLetView e = ([], e)++tLamView :: TTerm -> (Int, TTerm)+tLamView = go 0+ where go n (TLam b) = go (n + 1) b+ go n t = (n, t)++mkTLam :: Int -> TTerm -> TTerm+mkTLam n b = foldr ($) b $ replicate n TLam++-- | Introduces a new binding+mkLet :: Strictness -> TTerm -> TTerm -> TTerm+mkLet = TLet++tInt :: Integer -> TTerm+tInt = TLit . LitNat++intView :: TTerm -> Maybe Integer+intView (TLit (LitNat x)) = Just x+intView _ = Nothing++word64View :: TTerm -> Maybe Word64+word64View (TLit (LitWord64 x)) = Just x+word64View _ = Nothing++tPlusK :: Integer -> TTerm -> TTerm+tPlusK 0 n = n+tPlusK k n | k < 0 = tOp PSub n (tInt (-k))+tPlusK k n = tOp PAdd (tInt k) n++-- -(k + n)+tNegPlusK :: Integer -> TTerm -> TTerm+tNegPlusK k n = tOp PSub (tInt (-k)) n++plusKView :: TTerm -> Maybe (Integer, TTerm)+plusKView (TApp (TPrim PAdd) [k, n]) | Just k <- intView k = Just (k, n)+plusKView (TApp (TPrim PSub) [n, k]) | Just k <- intView k = Just (-k, n)+plusKView _ = Nothing++negPlusKView :: TTerm -> Maybe (Integer, TTerm)+negPlusKView (TApp (TPrim PSub) [k, n]) | Just k <- intView k = Just (-k, n)+negPlusKView _ = Nothing++tOp :: TPrim -> TTerm -> TTerm -> TTerm+tOp op a b = TPOp op a b++pattern TPOp :: TPrim -> TTerm -> TTerm -> TTerm+pattern TPOp op a b = TApp (TPrim op) [a, b]++pattern TPFn :: TPrim -> TTerm -> TTerm+pattern TPFn op a = TApp (TPrim op) [a]++tUnreachable :: TTerm+tUnreachable = TError TUnreachable++tIfThenElse :: TTerm -> TTerm -> TTerm -> TTerm+tIfThenElse c i e = TApp (TPrim PIf) [c, i, e]++data CaseType+ = CTData QName+ -- Case on datatype.+ | CTNat+ | CTInt+ | CTChar+ | CTString+ | CTFloat+ | CTQName+ deriving (Show, Eq, Ord, Generic)++data CaseInfo = CaseInfo+ { caseLazy :: Bool+ , caseInduction :: !Induction+ -- ^ Is the matched type inductive (or non-recursive), or is it+ -- coinductive?+ , caseErased :: Erased+ -- ^ Is this a match on an erased argument?+ , caseType :: CaseType }+ deriving (Show, Eq, Ord, Generic)++data TAlt+ = TACon { aCon :: QName, aArity :: Int, aBody :: TTerm }+ -- ^ Matches on the given constructor. If the match succeeds,+ -- the pattern variables are prepended to the current environment+ -- (pushes all existing variables aArity steps further away)+ | TAGuard { aGuard :: TTerm, aBody :: TTerm }+ -- ^ Binds no variables+ --+ -- The guard must only use the variable that the case expression+ -- matches on.+ | TALit { aLit :: Literal, aBody:: TTerm }+ deriving (Show, Eq, Ord, Generic)++data TError+ = TUnreachable+ -- ^ Code which is unreachable. E.g. absurd branches or missing case defaults.+ -- Runtime behaviour of unreachable code is undefined, but preferably+ -- the program will exit with an error message. The compiler is free+ -- to assume that this code is unreachable and to remove it.+ | TMeta String+ -- ^ Code which could not be obtained because of a hole in the program.+ -- This should throw a runtime error.+ -- The string gives some information about the meta variable that got compiled.+ deriving (Show, Eq, Ord, Generic)+++class Unreachable a where+ -- | Checks if the given expression is unreachable or not.+ isUnreachable :: a -> Bool++instance Unreachable TAlt where+ isUnreachable = isUnreachable . aBody++instance Unreachable TTerm where+ isUnreachable (TError TUnreachable{}) = True+ isUnreachable (TLet _ _ b) = isUnreachable b+ isUnreachable _ = False++instance KillRange Compiled where+ killRange c = c -- bogus, but not used anyway+++-- * Utilities for ArgUsage+---------------------------------------------------------------------------++-- | @filterUsed used args@ drops those @args@ which are labelled+-- @ArgUnused@ in list @used@.+--+-- Specification:+--+-- @+-- filterUsed used args = [ a | (a, ArgUsed) <- zip args $ used ++ repeat ArgUsed ]+-- @+--+-- Examples:+--+-- @+-- filterUsed [] == id+-- filterUsed (repeat ArgUsed) == id+-- filterUsed (repeat ArgUnused) == const []+-- @+filterUsed :: [ArgUsage] -> [a] -> [a]+filterUsed = curry $ \case+ ([], args) -> args+ (_ , []) -> []+ (ArgUsed : used, a : args) -> a : filterUsed used args+ (ArgUnused : used, _ : args) -> filterUsed used args++-- TermSize instances+------------------------------------------------------------------------++instance TermSize TTerm where+ tsize = \case+ TVar _ -> 1+ TPrim _ -> 1+ TDef _ -> 1+ TLit _ -> 1+ TCon _ -> 1+ TUnit -> 1+ TSort -> 1+ TErased -> 1+ TError _ -> 1+ TApp t ts -> tsize t + tsize ts+ TLam t -> 1 + tsize t+ TLet _ t1 t2 -> 1 + tsize t1 + tsize t2+ TCase _ _ t bs -> 1 + tsize t + tsize bs+ TCoerce t -> 1 + tsize t++instance TermSize TAlt where+ tsize = \case+ TACon _ _ t -> tsize t+ TAGuard t1 t2 -> tsize t1 + tsize t2+ TALit _ t -> tsize t++-- NFData instances+---------------------------------------------------------------------------++instance NFData Compiled+instance NFData ArgUsage+instance NFData Strictness+instance NFData EvaluationStrategy+instance NFData TTerm+instance NFData TPrim+instance NFData CaseType+instance NFData CaseInfo+instance NFData TAlt+instance NFData TError
@@ -1,5 +1,7 @@-{-# LANGUAGE CPP, ImplicitParams #-}+{-# OPTIONS_GHC -Wunused-imports #-} +{-# LANGUAGE ImplicitParams #-}+ -- | Call graphs and related concepts, more or less as defined in -- \"A Predicative Analysis of Structural Recursion\" by -- Andreas Abel and Thorsten Altenkirch.@@ -7,395 +9,76 @@ -- Originally copied from Agda1 sources. module Agda.Termination.CallGraph- ( -- * Structural orderings- Order(Mat), decr- , (.*.)- , supremum, infimum- , decreasing, le, lt, unknown, orderMat- -- * Call matrices- , Index- , CallMatrix(..)+ ( -- * Calls+ Node+ , Call, source, target, callMatrixSet+ , mkCall, mkCall' -- exported for the sake of testing, otherwise we use 'insert' , (>*<)- , callMatrixInvariant- -- * Calls- , Call(..)- , callInvariant -- * Call graphs- , CallGraph- , callGraphInvariant+ , CallGraph(..)+ , loops+ , targetNodes , fromList , toList- , empty , union , insert- , complete- -- , showBehaviour -- RETIRED- , prettyBehaviour- -- * Tests- , Agda.Termination.CallGraph.tests+ , complete, completionStep+ -- , strengthenLoopDiagonals -- bad heuristics, see https://github.com/agda/agda/pull/8184#issuecomment-3487147737+ -- , prettyBehaviour ) where -import Agda.Utils.QuickCheck-import Agda.Utils.Function-import Agda.Utils.List hiding (tests)-import Agda.Utils.Pretty hiding (empty)-import Agda.Utils.TestHelpers-import Agda.Termination.SparseMatrix as Matrix hiding (tests)-import Agda.Termination.Semiring (HasZero(..),SemiRing,Semiring)-import qualified Agda.Termination.Semiring as Semiring-import Data.Set (Set)-import qualified Data.Set as Set-import Data.Map (Map, (!))-import qualified Data.Map as Map-import Data.List hiding (union, insert)-import Data.Monoid-import Data.Array (elems)-import Data.Function--#include "../undefined.h"-import Agda.Utils.Impossible----------------------------------------------------------------------------- Structural orderings---- | In the paper referred to above, there is an order R with--- @'Unknown' '<=' 'Le' '<=' 'Lt'@.------ This is generalized to @'Unknown' '<=' 'Decr k'@ where--- @Decr 1@ replaces @Lt@ and @Decr 0@ replaces @Le@.--- A negative decrease means an increase. The generalization--- allows the termination checker to record an increase by 1 which--- can be compensated by a following decrease by 2 which results in--- an overall decrease.------ However, the termination checker of the paper itself terminates because--- there are only finitely many different call-matrices. To maintain--- termination of the terminator we set a @cutoff@ point which determines--- how high the termination checker can count. This value should be--- set by a global or file-wise option.------ See 'Call' for more information.------ TODO: document orders which are call-matrices themselves.-data Order- = Decr Int | Unknown | Mat (Matrix Integer Order)- deriving (Eq,Ord)--instance Show Order where- show (Decr k) = show (- k)- show Unknown = "."- show (Mat m) = "Mat " ++ show m--instance HasZero Order where- zeroElement = Unknown---- | Smart constructor for @Decr k :: Order@ which cuts off too big values.------ Possible values for @k@: @- ?cutoff '<=' k '<=' ?cutoff + 1@.----decr :: (?cutoff :: Int) => Int -> Order-decr k | k < - ?cutoff = Unknown- | k > ?cutoff = Decr (?cutoff + 1)- | otherwise = Decr k---- | Smart constructor for matrix shaped orders, avoiding empty and singleton matrices.-orderMat :: Matrix Integer Order -> Order-orderMat m | Matrix.isEmpty m = Decr 0 -- 0x0 Matrix = neutral element- | otherwise = case isSingleton m of- Just o -> o -- 1x1 Matrix- Nothing -> Mat m -- nxn Matrix--isOrder :: (?cutoff :: Int) => Order -> Bool-isOrder (Decr k) = k >= - ?cutoff && k <= ?cutoff + 1-isOrder Unknown = True-isOrder (Mat m) = False -- TODO: extend to matrices--prop_decr :: (?cutoff :: Int) => Int -> Bool-prop_decr = isOrder . decr---- | @le@, @lt@, @decreasing@, @unknown@: for backwards compatibility, and for external use.-le :: Order-le = Decr 0--lt :: Order-lt = Decr 1--unknown :: Order-unknown = Unknown--decreasing :: Order -> Bool-decreasing (Decr k) | k > 0 = True-decreasing _ = False--instance Pretty Order where- pretty (Decr 0) = text "="- pretty (Decr k) = text $ show k- pretty Unknown = text "?"- pretty (Mat m) = text "Mat" <+> pretty m----instance Ord Order where--- max = maxO--{- instances cannot have implicit arguments?! GHC manual says:--7.8.3.1. Implicit-parameter type constraints--You can't have an implicit parameter in the context of a class or instance declaration. For example, both these declarations are illegal:-- class (?x::Int) => C a where ...- instance (?x::a) => Foo [a] where ...--Reason: exactly which implicit parameter you pick up depends on-exactly where you invoke a function. But the ``invocation'' of-instance declarations is done behind the scenes by the compiler, so-it's hard to figure out exactly where it is done. Easiest thing is to-outlaw the offending types.--instance (?cutoff :: Int) => Arbitrary Order where- arbitrary = frequency- [(20, return Unknown)- ,(80, elements [- ?cutoff .. ?cutoff + 1] >>= Decr)- ] -- no embedded matrices generated for now.--}-instance Arbitrary Order where- arbitrary = frequency- [(30, return Unknown)- ,(70, elements [0,1] >>= return . Decr)- ] -- no embedded matrices generated for now.--instance CoArbitrary Order where- coarbitrary (Decr k) = variant 0- coarbitrary Unknown = variant 1- coarbitrary (Mat m) = variant 2---- | Multiplication of 'Order's. (Corresponds to sequential--- composition.)---- I think this funny pattern matching is because overlapping patterns--- are producing a warning and thus an error (strict compilation settings)-(.*.) :: (?cutoff :: Int) => Order -> Order -> Order-Unknown .*. _ = Unknown-(Mat m) .*. Unknown = Unknown-(Decr k) .*. Unknown = Unknown-(Decr k) .*. (Decr l) = decr (k + l)-(Decr 0) .*. (Mat m) = Mat m-(Decr k) .*. (Mat m) = (Decr k) .*. (collapse m)-(Mat m1) .*. (Mat m2) = if (okM m1 m2) then- Mat $ mul orderSemiring m1 m2- else- (collapse m1) .*. (collapse m2)-(Mat m) .*. (Decr 0) = Mat m-(Mat m) .*. (Decr k) = (collapse m) .*. (Decr k)--{- collapse m--We assume that m codes a permutation: each row has at most one column-that is not Un.--To collapse a matrix into a single value, we take the best value of-each column and multiply them. That means if one column is all Un,-i.e., no argument relates to that parameter, than the collapsed value-is also Un.--This makes order multiplication associative.---}-collapse :: (?cutoff :: Int) => Matrix Integer Order -> Order-collapse m = case (toLists (Matrix.transpose m)) of- [] -> __IMPOSSIBLE__ -- This can never happen if order matrices are generated by the smart constructor- m' -> foldl1 (.*.) $ map (foldl1 maxO) m'--{- OLD CODE, does not give associative matrix multiplication:-collapse :: (?cutoff :: Int) => Matrix Integer Order -> Order-collapse m = foldl (.*.) le (Data.Array.elems $ diagonal m)--}--okM :: Matrix Integer Order -> Matrix Integer Order -> Bool-okM m1 m2 = (rows $ size m2) == (cols $ size m1)---- | The supremum of a (possibly empty) list of 'Order's.--supremum :: (?cutoff :: Int) => [Order] -> Order-supremum = foldr maxO Unknown--maxO :: (?cutoff :: Int) => Order -> Order -> Order-maxO o1 o2 = case (o1,o2) of- (Decr k, Decr l) -> Decr (max k l) -- cut off not needed- (Unknown,_) -> o2- (_,Unknown) -> o1- (Mat m1, Mat m2) -> Mat (Matrix.add maxO m1 m2)- (Mat m,_) -> maxO (collapse m) o2- (_,Mat m) -> maxO o1 (collapse m)---- | @('Order', 'max', '.*.')@ forms a semiring, with 'Unknown' as--- zero and 'Le' as one.---- | The infimum of a (non empty) list of 'Order's.--infimum :: (?cutoff :: Int) => [Order] -> Order-infimum (o:l) = foldl minO o l-infimum [] = __IMPOSSIBLE__--minO :: (?cutoff :: Int) => Order -> Order -> Order-minO o1 o2 = case (o1,o2) of- (Unknown,_) -> Unknown- (_,Unknown) -> Unknown- (Decr k, Decr l) -> decr (min k l)- (Mat m1, Mat m2) -> if (size m1 == size m2) then- Mat $ Matrix.intersectWith minO m1 m2- else- minO (collapse m1) (collapse m2)- (Mat m1,_) -> minO (collapse m1) o2- (_,Mat m2) -> minO o1 (collapse m2)---{- Cannot have implicit arguments in instances. Too bad!--instance Monoid Order where- mempty = Unknown- mappend = maxO--instance (cutoff :: Int) => SemiRing Order where- multiply = (.*.)--}--orderSemiring :: (?cutoff :: Int) => Semiring Order-orderSemiring =- Semiring.Semiring { Semiring.add = maxO- , Semiring.mul = (.*.)- , Semiring.zero = Unknown--- , Semiring.one = Le- }--prop_orderSemiring :: (?cutoff :: Int) => Order -> Order -> Order -> Bool-prop_orderSemiring = Semiring.semiringInvariant orderSemiring----------------------------------------------------------------------------- Call matrices---- | Call matrix indices.--type Index = Integer---- | Call matrices. Note the call matrix invariant--- ('callMatrixInvariant').--newtype CallMatrix = CallMatrix { mat :: Matrix Index Order }- deriving (Eq, Ord, Show)--instance Arbitrary CallMatrix where- arbitrary = do- sz <- arbitrary- callMatrix sz--instance CoArbitrary CallMatrix where- coarbitrary (CallMatrix m) = coarbitrary m--prop_Arbitrary_CallMatrix = callMatrixInvariant---- | Generates a call matrix of the given size.--callMatrix :: Size Index -> Gen CallMatrix-callMatrix sz = do- m <- matrixUsingRowGen sz rowGen- return $ CallMatrix { mat = m }- where- rowGen :: Index -> Gen [Order]- rowGen 0 = return []- rowGen n = do- x <- arbitrary- i <- choose (0, n - 1)- return $ genericReplicate i Unknown ++ [x] ++- genericReplicate (n - 1 - i) Unknown+import Prelude hiding (null) -prop_callMatrix sz =- forAll (callMatrix sz) $ \cm ->- callMatrixInvariant cm- &&- size (mat cm) == sz+import Data.List qualified as List+import Data.Set (Set) --- | In a call matrix at most one element per row may be different--- from 'Unknown'.+import Agda.Syntax.Common.Pretty -callMatrixInvariant :: CallMatrix -> Bool-callMatrixInvariant cm =- matrixInvariant m &&- all ((<= 1) . length . filter (/= Unknown)) (toLists m)- where m = mat cm+import Agda.Termination.CallMatrix (CallMatrix, CallMatrixAug(..), CMSet(..), CallComb(..)) -- , mapCMSet, mapCallMatrixAug, mapCallMatrix)+import Agda.Termination.CallMatrix qualified as CMSet+import Agda.Termination.CutOff+-- import Agda.Termination.Order ( makeIncreaseInfinite )+-- import Agda.Termination.SparseMatrix ( mapDiagonalNonZeros ) --- | Call matrix multiplication.------ Precondition: see 'Matrix.mul'.+import Agda.Utils.Favorites (Favorites)+import Agda.Utils.Favorites qualified as Fav+import Agda.Utils.Graph.AdjacencyMap.Unidirectional (Edge(..),Graph(..))+import Agda.Utils.Graph.AdjacencyMap.Unidirectional qualified as Graph -(<*>) :: (?cutoff :: Int) => CallMatrix -> CallMatrix -> CallMatrix-cm1 <*> cm2 =- CallMatrix { mat = mul orderSemiring (mat cm1) (mat cm2) }+import Agda.Utils.Function -prop_cmMul sz =- forAll natural $ \c2 ->- forAll (callMatrix sz) $ \cm1 ->- forAll (callMatrix $ Size { rows = cols sz, cols = c2 }) $ \cm2 ->- callMatrixInvariant (cm1 <*> cm2)+import Agda.Utils.Null+import Agda.Utils.PartialOrd+import Agda.Utils.Singleton+import Agda.Utils.Tuple ------------------------------------------------------------------------ -- Calls --- | This datatype encodes information about a single recursive--- function application. The columns of the call matrix stand for--- 'source' function arguments (patterns); the first argument has--- index 0, the second 1, and so on. The rows of the matrix stand for--- 'target' function arguments. Element @(i, j)@ in the matrix should--- be computed as follows:------ * 'Lt' (less than) if the @j@-th argument to the 'target'--- function is structurally strictly smaller than the @i@-th--- pattern.------ * 'Le' (less than or equal) if the @j@-th argument to the--- 'target' function is structurally smaller than the @i@-th--- pattern.------ * 'Unknown' otherwise.+-- | Call graph nodes. ----- The structural ordering used is defined in the paper referred to--- above.--data Call =- Call { source :: Index -- ^ The function making the call.- , target :: Index -- ^ The function being called.- , cm :: CallMatrix -- ^ The call matrix describing the call.- }- deriving (Eq, Ord, Show)--instance Arbitrary Call where- arbitrary = do- [s, t] <- vectorOf 2 arbitrary- cm <- arbitrary- return (Call { source = s, target = t, cm = cm })+-- Machine integer 'Int' is sufficient, since we cannot index more than+-- we have addresses on our machine. -instance CoArbitrary Call where- coarbitrary (Call s t cm) =- coarbitrary s . coarbitrary t . coarbitrary cm+type Node = Int -prop_Arbitrary_Call :: Call -> Bool-prop_Arbitrary_Call = callInvariant+-- | Calls are edges in the call graph.+-- It can be labelled with several call matrices if there+-- are several pathes from one function to another. --- | 'Call' invariant.+type Call cinfo = Edge Node (CMSet cinfo) -callInvariant :: Call -> Bool-callInvariant = callMatrixInvariant . cm+callMatrixSet :: Call cinfo -> CMSet cinfo+callMatrixSet = label --- | 'Call' combination.------ Precondition: see '<*>'; furthermore the 'source' of the first--- argument should be equal to the 'target' of the second one.+-- | Make a call with a single matrix.+mkCall :: Node -> Node -> CallMatrix -> cinfo -> Call cinfo+mkCall s t m cinfo = Edge s t $ singleton $ CallMatrixAug m cinfo -(>*<) :: (?cutoff :: Int) => Call -> Call -> Call-c1 >*< c2 =- Call { source = source c2- , target = target c1- , cm = cm c1 <*> cm c2- }+-- @mkCall'@ is only used in our Internal tests.+-- | Make a call with empty @cinfo@.+mkCall' :: Monoid cinfo => Node -> Node -> CallMatrix -> Call cinfo+mkCall' s t m = mkCall s t m mempty ------------------------------------------------------------------------ -- Call graphs@@ -405,215 +88,182 @@ -- meta information for different calls can be combined when the calls -- are combined. -newtype CallGraph meta = CallGraph { cg :: Map Call meta }- deriving (Eq, Show)+newtype CallGraph cinfo = CallGraph { theCallGraph :: Graph Node (CMSet cinfo) }+ deriving (Show) --- | 'CallGraph' invariant.+mapCallGraph :: (Graph Node (CMSet cinfo) -> Graph Node (CMSet cinfo)) -> CallGraph cinfo -> CallGraph cinfo+mapCallGraph f (CallGraph g) = CallGraph (f g) -callGraphInvariant :: CallGraph meta -> Bool-callGraphInvariant = all (callInvariant . fst) . toList+-- | Returns all nodes with self-loops. +loops :: CallGraph cinfo -> [(Node, CMSet cinfo)]+loops = Graph.loops . theCallGraph++-- | Returns all the nodes with incoming edges. Somewhat expensive. @O(e)@.++targetNodes :: CallGraph cinfo -> Set Node+targetNodes = Graph.targetNodes . theCallGraph+ -- | Converts a call graph to a list of calls with associated meta--- information.+-- information. -toList :: CallGraph meta -> [(Call, meta)]-toList = Map.toList . cg+toList :: CallGraph cinfo -> [Call cinfo]+toList = Graph.edges . theCallGraph -- | Converts a list of calls with associated meta information to a--- call graph.--fromList :: Monoid meta => [(Call, meta)] -> CallGraph meta-fromList = CallGraph . Map.fromListWith mappend+-- call graph. --- | Creates an empty call graph.+fromListCG :: [Call cinfo] -> CallGraph cinfo+fromListCG = CallGraph . Graph.fromEdgesWith CMSet.union -empty :: CallGraph meta-empty = CallGraph Map.empty+-- | 'null' checks whether the call graph is completely disconnected.+instance Null (CallGraph cinfo) where+ empty = CallGraph Graph.empty+ null = List.all (null . label) . toList -- | Takes the union of two call graphs. -union :: Monoid meta- => CallGraph meta -> CallGraph meta -> CallGraph meta-union cs1 cs2 = CallGraph $ (Map.unionWith mappend `on` cg) cs1 cs2+union :: CallGraph cinfo -> CallGraph cinfo -> CallGraph cinfo+union (CallGraph cs1) (CallGraph cs2) = CallGraph $+ Graph.unionWith CMSet.union cs1 cs2 --- | Inserts a call into a call graph.+-- | 'CallGraph' is a monoid under 'union'. -insert :: Monoid meta- => Call -> meta -> CallGraph meta -> CallGraph meta-insert c m = CallGraph . Map.insertWith mappend c m . cg+instance Semigroup (CallGraph cinfo) where+ (<>) = union --- | Generates a call graph.+instance Monoid (CallGraph cinfo) where+ mempty = empty+ mappend = (<>) -callGraph :: (Monoid meta, Arbitrary meta) => Gen (CallGraph meta)-callGraph = do- indices <- fmap nub arbitrary- n <- natural- let noMatrices | null indices = 0- | otherwise = n `min` 3 -- Not too many.- fmap fromList $ vectorOf noMatrices (matGen indices)- where- matGen indices = do- [s, t] <- vectorOf 2 (elements indices)- [c, r] <- vectorOf 2 (choose (0, 2)) -- Not too large.- m <- callMatrix (Size { rows = r, cols = c })- callId <- arbitrary- return (Call { source = s, target = t, cm = m }, callId)+instance Singleton (Call cinfo) (CallGraph cinfo) where+ singleton = fromList . singleton -prop_callGraph =- forAll (callGraph :: Gen (CallGraph [Integer])) $ \cs ->- callGraphInvariant cs+instance Collection (Call cinfo) (CallGraph cinfo) where+ fromList = fromListCG --- | Call graph combination. (Application of '>*<' to all pairs @(c1,--- c2)@ for which @'source' c1 = 'target' c2@.)------ Precondition: see '<*>'.+-- | Inserts a call into a call graph. -combine- :: (Monoid meta, ?cutoff :: Int) => CallGraph meta -> CallGraph meta -> CallGraph meta-combine s1 s2 = fromList $- [ (c1 >*< c2, m1 `mappend` m2)- | (c1, m1) <- toList s1, (c2, m2) <- toList s2- , source c1 == target c2- ]+insert :: Node -> Node -> CallMatrix -> cinfo+ -> CallGraph cinfo -> CallGraph cinfo+insert s t cm cinfo = CallGraph . Graph.insertEdgeWith CMSet.union e . theCallGraph+ where e = mkCall s t cm cinfo --- | @'complete' cs@ completes the call graph @cs@. A call graph is--- complete if it contains all indirect calls; if @f -> g@ and @g ->--- h@ are present in the graph, then @f -> h@ should also be present. -complete :: (?cutoff :: Int) => Monoid meta => CallGraph meta -> CallGraph meta-complete cs = complete' safeCS- where- safeCS = ensureCompletePrecondition cs+-- * Combination of a new thing with an old thing+-- returning a really new things and updated old things. - complete' cs | cs' .==. cs = cs- | otherwise = complete' cs'- where- cs' = cs `union` combine cs safeCS- (.==.) = ((==) `on` (Map.keys . cg))+type CombineNewOldT a = a -> a -> (a, a) -prop_complete :: (?cutoff :: Int) => Property-prop_complete =- forAll (callGraph :: Gen (CallGraph [Integer])) $ \cs ->- isComplete (complete cs)+class CombineNewOld a where+ combineNewOld :: CombineNewOldT a --- | Returns 'True' iff the call graph is complete.+instance PartialOrd a => CombineNewOld (Favorites a) where+ combineNewOld new old = (new', Fav.unionCompared (new', old'))+ where (new', old') = Fav.compareFavorites new old -isComplete :: (Ord meta, Monoid meta, ?cutoff :: Int) => CallGraph meta -> Bool-isComplete s = all (`Map.member` cg s) combinations- where- calls = toList s- combinations =- [ c2 >*< c1 | (c1, _) <- calls, (c2, _) <- calls- , target c1 == source c2 ]+deriving instance CombineNewOld (CMSet cinfo) --- | Checks whether every 'Index' used in the call graph corresponds--- to a fixed number of arguments (i.e. rows\/columns).+instance (Monoid a, CombineNewOld a, Ord n) => CombineNewOld (Graph n a) where+ combineNewOld new old = Graph.unzip $ Graph.unionWith comb new' old'+ where+ new' = (,mempty) <$> new+ old' = (mempty,) <$> old+ comb (new1,old1) (new2,old2) -- TODO: ensure old1 is null+ = first (new2 `mappend`) $ combineNewOld new1 old2+ -- -- | old1 == mempty = first (new2 `mappend`) $ combineNewOld new1 old2+ -- -- | otherwise = __IMPOSSIBLE__ -completePrecondition :: CallGraph meta -> Bool-completePrecondition cs =- all (allEqual . map snd) $- groupOn fst $- concat [ [(source c, cols $ size' c), (target c, rows $ size' c)]- | (c, _) <- toList cs]- where- size' = size . mat . cm+ -- Filter unlabelled edges from the resulting new graph.+ -- filt = Graph.filterEdges (not . null) --- | Returns a call graph padded with 'Unknown's in such a way that--- 'completePrecondition' is satisfied.+-- | Call graph combination.+--+-- Application of '>*<' to all pairs @(c1,c2)@+-- for which @'source' c1 = 'target' c2@.) -ensureCompletePrecondition- :: Monoid meta => CallGraph meta -> CallGraph meta-ensureCompletePrecondition cs =- CallGraph $ Map.mapKeysWith mappend pad $ cg cs- where- -- The maximum number of arguments detected for every index.- noArgs :: Map Index Integer- noArgs = foldr (\c m -> insert (source c) (cols' c) $- insert (target c) (rows' c) m)- Map.empty- (map fst $ toList cs)- where insert = Map.insertWith max+-- GHC supports implicit-parameter constraints in instance declarations+-- only from 7.4. To maintain compatibility with 7.2, we skip this instance:+-- Andreas, 2025-10-29, not allowed in GHC 9.12:+-- https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/implicit_parameters.html#implicit-parameter-type-constraints+-- KEEP:+-- instance (Monoid cinfo, ?cutoff :: CutOff) => CombineNewOld (CallGraph cinfo) where+-- combineNewOld (CallGraph new) (CallGraph old) = CallGraph *** CallGraph $ combineNewOld comb old+-- -- combined calls:+-- where comb = Graph.composeWith (>*<) CMSet.union new old - pad c = c { cm = CallMatrix { mat = padRows $ padCols $ mat $ cm c } }+-- Non-overloaded version:+combineNewOldCallGraph :: forall cinfo. (Monoid cinfo, ?cutoff :: CutOff) => CombineNewOldT (CallGraph cinfo)+combineNewOldCallGraph (CallGraph new) (CallGraph old) = CallGraph *** CallGraph $ combineNewOld comb old+ -- combined calls: where- padCols = iterate' ((noArgs ! source c) - cols' c)- (addColumn Unknown)+ comb :: Graph Node (CMSet cinfo)+ comb = -- strengthenLoopDiagonals' $ -- bad heuristics, see https://github.com/agda/agda/pull/8184#issuecomment-3487147737+ Graph.composeWith (>*<) CMSet.union new old - padRows = iterate' ((noArgs ! target c) - rows' c)- (addRow Unknown)+-- Andreas, 2025-11-04+-- bad heuristics, see https://github.com/agda/agda/pull/8184#issuecomment-3487147737+-- -- | Any increase in the diagonal of a loop can be strengthened to infinite increase+-- -- since we can iterate loops indefinitely.+-- strengthenLoopDiagonals' :: Graph Node (CMSet cinfo) -> Graph Node (CMSet cinfo)+-- strengthenLoopDiagonals' =+-- Graph.mapLoops $ mapCMSet $ fmap $ mapCallMatrixAug $ mapCallMatrix $+-- mapDiagonalNonZeros makeIncreaseInfinite - cols' = cols . size'- rows' = rows . size'- size' = size . mat . cm+-- -- | Any increase in the diagonal of a loop can be strengthened to infinite increase+-- -- since we can iterate loops indefinitely.+-- strengthenLoopDiagonals :: CallGraph cinfo -> CallGraph cinfo+-- strengthenLoopDiagonals = mapCallGraph $ strengthenLoopDiagonals' -prop_ensureCompletePrecondition =- forAll (callGraph :: Gen (CallGraph [Integer])) $ \cs ->- let cs' = ensureCompletePrecondition cs in- completePrecondition cs'- &&- all callInvariant (map fst $ toList cs')- &&- and [ or [ new .==. old | (old, _) <- toList cs ]- | (new, _) <- toList cs' ]- where- c1 .==. c2 = all (all (uncurry (==)))- ((zipZip `on` (toLists . mat . cm)) c1 c2)+-- | Call graph comparison.+-- A graph @cs'@ is ``worse'' than @cs@ if it has a new edge (call)+-- or a call got worse, which means that one of its elements+-- that was better or equal to 'Le' moved a step towards 'Un'.+--+-- A call graph is complete if combining it with itself does not make it+-- any worse. This is sound because of monotonicity: By combining a graph+-- with itself, it can only get worse, but if it does not get worse after+-- one such step, it gets never any worse. - -- zipZip discards the new elements.- zipZip :: [[a]] -> [[b]] -> [[(a, b)]]- zipZip xs ys = map (uncurry zip) $ zip xs ys+-- | @'complete' cs@ completes the call graph @cs@. A call graph is+-- complete if it contains all indirect calls; if @f -> g@ and @g ->+-- h@ are present in the graph, then @f -> h@ should also be present. --- | Displays the recursion behaviour corresponding to a call graph.+complete :: (Monoid cinfo, ?cutoff :: CutOff) => CallGraph cinfo -> CallGraph cinfo+complete cs = repeatWhile (first (not . null) . completionStep cs) cs -{- RETIRED CODE-showBehaviour :: Show meta => CallGraph meta -> String-showBehaviour = concatMap showCall . toList- where- showCall (c, meta) | source c /= target c = ""- | otherwise = unlines- [ "Function: " ++ show (source c)- , "Behaviour: " ++ show (elems $ diagonal $ mat $ cm c)- , "Meta info: " ++ show meta- ]--}+completionStep :: (Monoid cinfo, ?cutoff :: CutOff)+ => CallGraph cinfo+ -- ^ The original call graph.+ -> CallGraph cinfo+ -- ^ The current completion.+ -> (CallGraph cinfo, CallGraph cinfo)+completionStep gOrig gThis = combineNewOldCallGraph gOrig gThis -instance Show meta => Pretty (CallGraph meta) where- pretty = vcat . map prettyCall . toList- where- prettyCall (c, meta) = align 20- [ ("Source:", text $ show $ source c)- , ("Target:", text $ show $ target c)- , ("Matrix:", pretty (mat $ cm c))- , ("Meta info:", text $ show meta)- ]+------------------------------------------------------------------------+-- * Printing+------------------------------------------------------------------------ -- | Displays the recursion behaviour corresponding to a call graph. -prettyBehaviour :: Show meta => CallGraph meta -> Doc-prettyBehaviour = vcat . map prettyCall . filter (toSelf . fst) . toList- where- toSelf c = source c == target c+instance Pretty cinfo => Pretty (CallGraph cinfo) where+ pretty = vcat . map prettyCall . toList+ where+ prettyCall e = if null (callMatrixSet e) then empty else align 20 $+ [ ("Source:", text $ show $ source e)+ , ("Target:", text $ show $ target e)+ , ("Matrix:", pretty $ callMatrixSet e)+ ] - prettyCall (c, meta) = vcat $ map text- [ "Function: " ++ show (source c)- , "Behaviour: " ++ show (elems $ diagonal $ mat $ cm c)- , "Meta info: " ++ show meta- ]+-- -- | Displays the recursion behaviour corresponding to a call graph. ---------------------------------------------------------------------------- All tests+-- prettyBehaviour :: Show cinfo => CallGraph cinfo -> Doc+-- prettyBehaviour = vcat . map prettyCall . filter toSelf . toList+-- where+-- toSelf c = source c == target c -tests :: IO Bool-tests = runTests "Agda.Termination.CallGraph"- [ quickCheck' callMatrixInvariant- , quickCheck' prop_decr- , quickCheck' prop_orderSemiring- , quickCheck' prop_Arbitrary_CallMatrix- , quickCheck' prop_callMatrix- , quickCheck' prop_cmMul- , quickCheck' prop_Arbitrary_Call- , quickCheck' prop_callGraph- , quickCheck' prop_complete- , quickCheck' prop_ensureCompletePrecondition- ]- where ?cutoff = 2+-- prettyCall e = vcat $ map text+-- [ "Function: " ++ show (source e)+-- -- , "Behaviour: " ++ show (diagonal $ mat $ cm c) -- TODO+-- -- , "Meta info: " ++ show cinfo+-- ]
@@ -0,0 +1,218 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE ImplicitParams #-}++module Agda.Termination.CallMatrix where++-- module Agda.Termination.CallMatrix+-- ( CallMatrix'(..), CallMatrix+-- , callMatrix+-- , CallComb(..)+-- , tests+-- ) where+++import Agda.Termination.CutOff+import Agda.Termination.Order as Order+import Agda.Termination.SparseMatrix as Matrix+import Agda.Termination.Semiring (HasZero(..))++import Agda.Utils.Favorites (Favorites)+import qualified Agda.Utils.Favorites as Fav++import Agda.Utils.Null+import Agda.Utils.PartialOrd+import Agda.Syntax.Common.Pretty+import Agda.Utils.Singleton++------------------------------------------------------------------------+-- * Call matrices+------------------------------------------------------------------------++-- | Call matrix indices = function argument indices.+--+-- Machine integer 'Int' is sufficient, since we cannot index more arguments+-- than we have addresses on our machine.++type ArgumentIndex = Int++-- | Call matrices.+--+-- A call matrix for a call @f --> g@ has dimensions @ar(g) × ar(f)@.+--+-- Each column corresponds to one formal argument of caller @f@.+-- Each row corresponds to one argument in the call to @g@.+--+-- In the presence of dot patterns, a call argument can be related+-- to /several/ different formal arguments of @f@.+--+-- See e.g. @test/succeed/DotPatternTermination.agda@:+--+-- @+-- data D : Nat -> Set where+-- cz : D zero+-- c1 : forall n -> D n -> D (suc n)+-- c2 : forall n -> D n -> D n+--+-- f : forall n -> D n -> Nat+-- f .zero cz = zero+-- f .(suc n) (c1 n d) = f n (c2 n d)+-- f n (c2 .n d) = f n d+-- @+--+-- Call matrices (without guardedness) are+--+-- @+-- -1 -1 n < suc n and n < c1 n d+-- ? = c2 n d <= c1 n d+--+-- = -1 n <= n and n < c2 n d+-- ? -1 d < c2 n d+-- @+--+-- Here is a part of the original documentation for call matrices+-- (kept for historical reasons):+--+-- This datatype encodes information about a single recursive+-- function application. The columns of the call matrix stand for+-- 'source' function arguments (patterns). The rows of the matrix stand for+-- 'target' function arguments. Element @(i, j)@ in the matrix should+-- be computed as follows:+--+-- * 'Order.lt' (less than) if the @j@-th argument to the 'target'+-- function is structurally strictly smaller than the @i@-th+-- pattern.+--+-- * 'Order.le' (less than or equal) if the @j@-th argument to the+-- 'target' function is structurally smaller than the @i@-th+-- pattern.+--+-- * 'Order.unknown' otherwise.+++newtype CallMatrix' a = CallMatrix { mat :: Matrix ArgumentIndex a }+ deriving (Eq, Ord, Show, Functor, Foldable, Traversable, PartialOrd)++type CallMatrix = CallMatrix' Order++deriving instance NotWorse CallMatrix++instance HasZero a => Diagonal (CallMatrix' a) a where+ diagonal = diagonal . mat++mapCallMatrix :: (Matrix ArgumentIndex a -> Matrix ArgumentIndex a) -> CallMatrix' a -> CallMatrix' a+mapCallMatrix f (CallMatrix m) = CallMatrix (f m)++-- | Call matrix multiplication and call combination.++class CallComb a where+ (>*<) :: (?cutoff :: CutOff) => a -> a -> a++-- | Call matrix multiplication.+--+-- @f --(m1)--> g --(m2)--> h@ is combined to @f --(m2 `mul` m1)--> h@+--+-- Note the reversed order of multiplication:+-- The matrix @c1@ of the second call @g-->h@ in the sequence+-- @f-->g-->h@ is multiplied with the matrix @c2@ of the first call.+--+-- Preconditions:+-- @m1@ has dimensions @ar(g) × ar(f)@.+-- @m2@ has dimensions @ar(h) × ar(g)@.+--+-- Postcondition:+-- @m1 >*< m2@ has dimensions @ar(h) × ar(f)@.++instance CallComb CallMatrix where+ CallMatrix m1 >*< CallMatrix m2 = CallMatrix $ mul orderSemiring m2 m1++{- UNUSED, BUT DON'T REMOVE!+-- | Call matrix addition = minimum = pick worst information.+addCallMatrices :: (?cutoff :: CutOff) => CallMatrix -> CallMatrix -> CallMatrix+addCallMatrices cm1 cm2 = CallMatrix $+ add (Semiring.add orderSemiring) (mat cm1) (mat cm2)+-}++------------------------------------------------------------------------+-- * Call matrix augmented with path information.+------------------------------------------------------------------------++-- | Call matrix augmented with path information.++data CallMatrixAug cinfo = CallMatrixAug+ { augCallMatrix :: CallMatrix -- ^ The matrix of the (composed call).+ , augCallInfo :: cinfo -- ^ Meta info, like call path.+ }+ deriving (Eq, Show)++instance Diagonal (CallMatrixAug cinfo) Order where+ diagonal = diagonal . augCallMatrix++instance PartialOrd (CallMatrixAug cinfo) where+ comparable m m' = comparable (augCallMatrix m) (augCallMatrix m')++instance NotWorse (CallMatrixAug cinfo) where+ c1 `notWorse` c2 = augCallMatrix c1 `notWorse` augCallMatrix c2++-- | Augmented call matrix multiplication.++instance Monoid cinfo => CallComb (CallMatrixAug cinfo) where+ CallMatrixAug m1 p1 >*< CallMatrixAug m2 p2 =+ CallMatrixAug (m1 >*< m2) (mappend p1 p2)++-- | Non-augmented call matrix.++noAug :: Monoid cinfo => CallMatrix -> CallMatrixAug cinfo+noAug m = CallMatrixAug m mempty++mapCallMatrixAug :: (CallMatrix -> CallMatrix) -> CallMatrixAug cinfo -> CallMatrixAug cinfo+mapCallMatrixAug f (CallMatrixAug m i) = CallMatrixAug (f m) i++------------------------------------------------------------------------+-- * Sets of incomparable call matrices augmented with path information.+------------------------------------------------------------------------++-- | Sets of incomparable call matrices augmented with path information.+-- Use overloaded 'null', 'empty', 'singleton', 'mappend'.+newtype CMSet cinfo = CMSet { cmSet :: Favorites (CallMatrixAug cinfo) }+ deriving ( Show, Semigroup, Monoid, Null, Singleton (CallMatrixAug cinfo) )++mapCMSet :: (Favorites (CallMatrixAug cinfo) -> Favorites (CallMatrixAug cinfo))+ -> CMSet cinfo -> CMSet cinfo+mapCMSet f (CMSet s) = CMSet (f s)++-- | Call matrix set product is the Cartesian product.++instance Monoid cinfo => CallComb (CMSet cinfo) where+ CMSet as >*< CMSet bs = CMSet $ Fav.fromList $+ [ a >*< b | a <- Fav.toList as, b <- Fav.toList bs ]++-- | Insert into a call matrix set.++insert :: CallMatrixAug cinfo -> CMSet cinfo -> CMSet cinfo+insert a (CMSet as) = CMSet $ Fav.insert a as++-- | Union two call matrix sets.++union :: CMSet cinfo -> CMSet cinfo -> CMSet cinfo+union = mappend+-- union (CMSet as) (CMSet bs) = CMSet $ Fav.union as bs++-- | Convert into a list of augmented call matrices.++toList :: CMSet cinfo -> [CallMatrixAug cinfo]+toList (CMSet as) = Fav.toList as++------------------------------------------------------------------------+-- * Printing+------------------------------------------------------------------------++instance Pretty CallMatrix where+ pretty (CallMatrix m) = pretty m++instance Pretty cinfo => Pretty (CallMatrixAug cinfo) where+ pretty (CallMatrixAug m cinfo) = pretty cinfo $$ pretty m++instance Pretty cinfo => Pretty (CMSet cinfo) where+ pretty = vcat . punctuate newLine . map pretty . toList+ where newLine = "\n"
@@ -0,0 +1,51 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Defines 'CutOff' type which is used in "Agda.Interaction.Options".+-- This module's purpose is to eliminate the dependency of+-- "Agda.TypeChecking.Monad.Base" on the termination checker and+-- everything it imports.++module Agda.Termination.CutOff+ ( CutOff(CutOff, DontCutOff)+ , defaultCutOff+ ) where++import Control.DeepSeq++import Agda.Utils.Impossible (__IMPOSSIBLE__)++-- | Cut off structural order comparison at some depth in termination checker?++data CutOff+ = CutOff !Int -- ^ @c >= 0@ means: record decrease up to including @c+1@.+ | DontCutOff+ deriving (Eq, Ord)++-- | Numeric literals and addition for 'CutOff'.++instance Num CutOff where+ fromInteger n+ | n >= 0 = CutOff (fromInteger n)+ | otherwise = __IMPOSSIBLE__++ DontCutOff + _ = DontCutOff+ _ + DontCutOff = DontCutOff+ CutOff m + CutOff n = CutOff (m + n)++ _ * _ = __IMPOSSIBLE__+ abs _ = __IMPOSSIBLE__+ signum _ = __IMPOSSIBLE__+ negate _ = __IMPOSSIBLE__++instance Show CutOff where+ show (CutOff k) = show k+ show DontCutOff = "∞"++instance NFData CutOff where+ rnf (CutOff _) = ()+ rnf DontCutOff = ()++-- | The default termination depth.++defaultCutOff :: CutOff+defaultCutOff = CutOff 2 -- termination-depth=3
@@ -1,238 +0,0 @@--- | Lexicographic order search, more or less as defined in--- \"A Predicative Analysis of Structural Recursion\" by--- Andreas Abel and Thorsten Altenkirch.--module Agda.Termination.Lexicographic- ( LexOrder- , RecBehaviour(..)- , Column- , recBehaviourInvariant- , fromDiagonals- , lexOrder- , Agda.Termination.Lexicographic.tests- ) where--import Agda.Utils.QuickCheck-import Agda.Termination.Matrix (Size (..))-import qualified Agda.Termination.Matrix as M-import Agda.Utils.Either-import Agda.Utils.List-import Agda.Utils.TestHelpers-import Agda.Termination.CallGraph-import Control.Arrow-import Data.List-import Data.Map (Map, (!))-import qualified Data.Map as Map-import Data.Array (Array, Ix)-import qualified Data.Array as Array-import Data.Set (Set)-import qualified Data.Set as Set---- | A lexicographic ordering for the recursion behaviour of a--- given function is a permutation of the argument indices which can--- be used to show that the function terminates. See the paper--- referred to above for more details.--type LexOrder arg = [arg]---- | A recursion behaviour expresses how a certain function calls--- itself (transitively). For every argument position there is a value--- ('Column') describing how the function calls itself for that--- particular argument. See also 'recBehaviourInvariant'.--data RecBehaviour arg call =- RB { columns :: Map arg (Column call)- , calls :: Set call- -- ^ The indices to the columns.- , size :: Size Integer- }- deriving Show---- | A column expresses how the size of a certain argument changes in--- the various recursive calls a function makes to itself--- (transitively).--type Column call = Map call Order---- | 'RecBehaviour' invariant: the size must match the real size of--- the recursion behaviour, and all columns must have the same--- indices.--recBehaviourInvariant :: Eq call => RecBehaviour arg call -> Bool-recBehaviourInvariant rb =- genericLength (Map.elems $ columns rb) == cols (size rb)- &&- all (== rows (size rb))- (map (genericLength . Map.elems) $ Map.elems $ columns rb)- &&- allEqual (calls rb : (map Map.keysSet $ Map.elems $ columns rb))---- Generates a recursion behaviour.--instance (Arbitrary call, Arbitrary arg, Ord arg, Ord call)- => Arbitrary (RecBehaviour call arg) where- arbitrary = do- calls <- fmap nub $ listOf arbitrary- args <- fmap nub $ listOf arbitrary- let rows = genericLength calls- cols = genericLength args- sz = Size { rows = rows, cols = cols }- colGen = do- col <- vectorOf (fromIntegral rows) arbitrary- return $ Map.fromList (zip calls col)- cols <- fmap (zip args) $ vectorOf (fromIntegral cols) colGen- return $ RB { columns = Map.fromList cols- , calls = Set.fromList calls- , size = sz }--instance (CoArbitrary call, CoArbitrary arg) => CoArbitrary (RecBehaviour call arg) where- coarbitrary (RB c cs s) =- coarbitrary (map (id *** Map.toList) $ Map.toList c) .- coarbitrary (Set.toList cs) .- coarbitrary s--prop_recBehaviour_Arbitrary :: RecBehaviour Integer Integer -> Bool-prop_recBehaviour_Arbitrary = recBehaviourInvariant---- | Checks whether there are any calls left in the recursion--- behaviour.--noCallsLeft :: RecBehaviour arg call -> Bool-noCallsLeft rb = rows (size rb) == 0---- | Constructs a recursion behaviour from a list of matrix diagonals--- (\"rows\"). Note that the @call@ indices do not need to be--- distinct, since they are paired up with unique 'Integer's.------ Precondition: all arrays should have the same bounds.--fromDiagonals :: (Ord call, Ix arg)- => [(call, Array arg Order)] -> RecBehaviour arg (Integer, call)-fromDiagonals [] = RB { columns = Map.fromList []- , calls = Set.empty- , size = Size 0 0 }-fromDiagonals rows = RB { columns = Map.fromList $ zip args cols- , calls = Set.fromList calls- , size = Size { rows = genericLength rows- , cols = genericLength cols }- }- where- calls = zip [1 ..] $ map fst rows- cols = map Map.fromList $ map (zip calls) $ transpose $- map (Array.elems . snd) rows- args = Array.range $ Array.bounds $ snd $ head rows--prop_fromDiagonals m =- forAll (vectorOf (fromIntegral $ rows $ M.size m) arbitrary) $ \calls ->- let oss = zip calls $- map (Array.listArray (1, cols $ M.size m)) $- M.toLists m- rb = fromDiagonals oss :: RecBehaviour Integer (Integer, Bool)- in- recBehaviourInvariant rb- &&- if rows (M.size m) == 0 then- rows (size rb) == 0- else- size rb == M.size m---- | Checks if this \"column\" is well-behaved (all calls decreasing,--- at least one strictly decreasing).--okColumn :: Column call -> Bool-okColumn col = any decreasing col' && all (/= unknown) col'- where col' = Map.elems col---- | @'newBehaviour' n rb@ computes a new recursion behaviour from--- @rb@ by removing all \"rows\" (calls) for which the @n@-th element--- is 'decreasing', and also completely removing the @n@-th column.------ Precondition: there has to be an @n@-th column.--newBehaviour :: (Ord arg, Ord call)- => arg -> RecBehaviour arg call -> RecBehaviour arg call-newBehaviour n rb =- RB { columns = Map.map remove $ Map.delete n $ columns rb- , calls = Set.difference (calls rb)- (Set.fromList indicesToRemove)- , size = Size { rows = rows (size rb) -- genericLength indicesToRemove- , cols = cols (size rb) - 1 }- }- where- Just colN = Map.lookup n $ columns rb- indicesToRemove = map fst $ filter (decreasing . snd) $ Map.toList colN- remove colJ = foldr Map.delete colJ indicesToRemove--prop_newBehaviour :: RecBehaviour Integer Integer -> Property-prop_newBehaviour rb =- not (cols (size rb) == 0) ==>- forAll (elements $ Map.keys $ columns rb) $ \n ->- recBehaviourInvariant (newBehaviour n rb)---- | @'correctLexOrder' rs ps@ checks that the permutation @ps@ really--- induces a lexicographic ordering which shows that the function--- represented by the recursion behaviour @rs@ terminates.--correctLexOrder :: (Ord arg, Ord call)- => RecBehaviour arg call -> LexOrder arg -> Bool-correctLexOrder rb [] = noCallsLeft rb-correctLexOrder rb (p0 : ps) =- okColumn (columns rb ! p0) && correctLexOrder (newBehaviour p0 rb) ps---- | Tries to compute a lexicographic ordering for the given recursion--- behaviour. This algorithm should be complete.------ If no lexicographic ordering can be found, then two sets are--- returned:------ * A set of argument positions which are not properly decreasing, and------ * the calls where these problems show up.--lexOrder :: (Ord arg, Ord call) =>- RecBehaviour arg call -> Either (Set arg, Set call) (LexOrder arg)-lexOrder rb | noCallsLeft rb = Right []- | otherwise = case okColumns of- [] -> Left (Map.keysSet $ columns rb, calls rb)- (n : _) -> case lexOrder (newBehaviour n rb) of- Left err -> Left err- Right ps -> Right $ n : ps- where- okColumns = map fst $ filter snd $- map (id *** okColumn) $- Map.toList $ columns rb--prop_lexOrder :: RecBehaviour Integer Integer -> Property-prop_lexOrder rb =- let mPerm = lexOrder rb- Right perm = mPerm- in- isRight mPerm ==>- classify (cols (size rb) >= 2) "interesting" $- correctLexOrder rb perm--prop_lexOrder_noArgs =- forAll positive $ \n ->- isLeft (lexOrder $ rb n)- where rb :: Integer -> RecBehaviour Integer Integer- rb n = RB { columns = Map.empty- , calls = Set.fromList [1 .. n]- , size = Size { rows = n, cols = 0 }- }----------------------------------------------------------------------------- All tests--tests :: IO Bool-tests = runTests "Agda.Termination.Lexicographic"- [ quickCheck' prop_recBehaviour_Arbitrary- , quickCheck' prop_fromDiagonals- , quickCheck' prop_newBehaviour- , quickCheckWith' stdArgs{ maxSuccess = 50- , maxDiscard = 200- , maxSize = 20- }- prop_lexOrder- , quickCheck' prop_lexOrder_noArgs- ]
@@ -1,339 +0,0 @@--- | Naive implementation of simple matrix library.---- Originally copied from Agda1 sources.--module Agda.Termination.Matrix- ( -- * Basic data types- Matrix- , matrixInvariant- , Size(..)- , sizeInvariant- , MIx (..)- , mIxInvariant- -- * Generating and creating matrices- , fromLists- , fromIndexList- , toLists- , Agda.Termination.Matrix.zipWith- , matrix- , matrixUsingRowGen- -- * Combining and querying matrices- , size- , square- , isEmpty- , add- , mul- , diagonal- -- * Modifying matrices- , addRow- , addColumn- -- * Tests- , Agda.Termination.Matrix.tests- ) where--import Data.Array-import Data.List as List-import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers-import Agda.Termination.Semiring (Semiring,SemiRing)-import qualified Agda.Termination.Semiring as Semiring----------------------------------------------------------------------------- Basic data types---- | This matrix type is used for tests.--type TM = Matrix Integer Integer---- | Size of a matrix.--data Size i = Size { rows :: i, cols :: i }- deriving (Eq, Show)--sizeInvariant :: (Ord i, Num i) => Size i -> Bool-sizeInvariant sz = rows sz >= 0 && cols sz >= 0--instance (Arbitrary i, Integral i) => Arbitrary (Size i) where- arbitrary = do- r <- natural- c <- natural- return $ Size { rows = fromInteger r, cols = fromInteger c }--instance CoArbitrary i => CoArbitrary (Size i) where- coarbitrary (Size rs cs) = coarbitrary rs . coarbitrary cs--prop_Arbitrary_Size :: Size Integer -> Bool-prop_Arbitrary_Size = sizeInvariant---- | Converts a size to a set of bounds suitable for use with--- the matrices in this module.--toBounds :: Num i => Size i -> (MIx i, MIx i)-toBounds sz = (MIx { row = 1, col = 1 }, MIx { row = rows sz, col = cols sz })---- | Type of matrix indices (row, column).--data MIx i = MIx { row, col :: i }- deriving (Eq, Show, Ix, Ord)--instance (Arbitrary i, Integral i) => Arbitrary (MIx i) where- arbitrary = do- r <- positive- c <- positive- return $ MIx { row = r, col = c }--instance CoArbitrary i => CoArbitrary (MIx i) where- coarbitrary (MIx r c) = coarbitrary r . coarbitrary c---- | No nonpositive indices are allowed.--mIxInvariant :: (Ord i, Num i) => MIx i -> Bool-mIxInvariant i = row i >= 1 && col i >= 1--prop_Arbitrary_MIx :: MIx Integer -> Bool-prop_Arbitrary_MIx = mIxInvariant---- | Type of matrices, parameterised on the type of values.--newtype Matrix i b = M { unM :: Array (MIx i) b }- deriving (Eq, Ord)--matrixInvariant :: (Num i, Ix i) => Matrix i b -> Bool-matrixInvariant m =- fst (bounds $ unM m) == MIx 1 1- &&- sizeInvariant (size m)--instance (Ix i, Num i, Enum i, Show i, Show b) => Show (Matrix i b) where- showsPrec _ m =- showString "Agda.Termination.Matrix.fromLists " . shows (size m) .- showString " " . shows (toLists m)--instance (Arbitrary i, Num i, Integral i, Ix i, Arbitrary b)- => Arbitrary (Matrix i b) where- arbitrary = matrix =<< arbitrary--instance (Ix i, Num i, Enum i, CoArbitrary b) => CoArbitrary (Matrix i b) where- coarbitrary m = coarbitrary (toLists m)--prop_Arbitrary_Matrix :: TM -> Bool-prop_Arbitrary_Matrix = matrixInvariant----------------------------------------------------------------------------- Generating and creating matrices---- | Generates a matrix of the given size, using the given generator--- to generate the rows.--matrixUsingRowGen :: (Arbitrary i, Integral i, Ix i, Arbitrary b)- => Size i- -> (i -> Gen [b])- -- ^ The generator is parameterised on the size of the row.- -> Gen (Matrix i b)-matrixUsingRowGen sz rowGen = do- rows <- vectorOf (fromIntegral $ rows sz) (rowGen $ cols sz)- return $ fromLists sz rows---- | Generates a matrix of the given size.--matrix :: (Arbitrary i, Integral i, Ix i, Arbitrary b)- => Size i -> Gen (Matrix i b)-matrix sz = matrixUsingRowGen sz (\n -> vectorOf (fromIntegral n) arbitrary)--prop_matrix sz = forAll (matrix sz :: Gen TM) $ \m ->- matrixInvariant m &&- size m == sz---- | Constructs a matrix from a list of (index, value)-pairs.--fromIndexList :: (Num i, Ix i) => Size i -> [(MIx i, b)] -> Matrix i b-fromIndexList sz = M . array (toBounds sz)--prop_fromIndexList :: TM -> Bool-prop_fromIndexList m = matrixInvariant m' && m' == m- where vs = assocs $ unM m- m' = fromIndexList (size m) vs---- | @'fromLists' sz rs@ constructs a matrix from a list of lists of--- values (a list of rows).------ Precondition: @'length' rs '==' 'rows' sz '&&' 'all' (('==' 'cols' sz) . 'length') rs@.--fromLists :: (Num i, Ix i) => Size i -> [[b]] -> Matrix i b-fromLists sz bs = fromIndexList sz $ zip (range $ toBounds sz) (concat bs)---- | Converts a matrix to a list of row lists.--toLists :: (Ix i, Num i, Enum i) => Matrix i b -> [[b]]-toLists m = [ [unM m ! MIx { row = r, col = c }- | c <- [1 .. cols sz] ] | r <- [1 .. rows sz] ]- where sz = size m--prop_fromLists_toLists :: TM -> Bool-prop_fromLists_toLists m = fromLists (size m) (toLists m) == m----------------------------------------------------------------------------- Combining and querying matrices---- | The size of a matrix.--size :: Ix i => Matrix i b -> Size i-size m = Size { rows = row b, cols = col b }- where (_, b) = bounds $ unM m--prop_size :: TM -> Bool-prop_size m = sizeInvariant (size m)--prop_size_fromIndexList :: Size Int -> Bool-prop_size_fromIndexList sz =- size (fromIndexList sz ([] :: [(MIx Int, Integer)])) == sz---- | 'True' iff the matrix is square.--square :: Ix i => Matrix i b -> Bool-square m = rows (size m) == cols (size m)---- | Returns 'True' iff the matrix is empty.--isEmpty :: (Num i, Ix i) => Matrix i b -> Bool-isEmpty m = rows sz <= 0 || cols sz <= 0- where sz = size m---- | @'add' (+) m1 m2@ adds @m1@ and @m2@. Uses @(+)@ to add values.------ Precondition: @'size' m1 == 'size' m2@.--add :: (Ix i, Num i)- => (a -> b -> c) -> Matrix i a -> Matrix i b -> Matrix i c-add (+) m1 m2 =- fromIndexList (size m1)- [ (i, (unM m1 ! i) + (unM m2 ! i))- | i <- range $ toBounds $ size m1 ]--prop_add sz =- forAll (three (matrix sz :: Gen TM)) $ \(m1, m2, m3) ->- let m' = add (+) m1 m2 in- associative (add (+)) m1 m2 m3 &&- commutative (add (+)) m1 m2 &&- matrixInvariant m' &&- size m' == size m1---- | @'mul' m1 m2@ multiplies @m1@ and @m2@. Uses the operations of--- the semiring to perform the multiplication.------ Precondition: @'cols' ('size' m1) == rows ('size' m2)@.---mul :: (Enum i, Num i, Ix i)- => Semiring a -> Matrix i a -> Matrix i a -> Matrix i a-mul semiring m1 m2 =- fromIndexList sz' [ (ix, res)- | r <- [1 .. rows $ size m1]- , c <- [1 .. cols $ size m2]- , let ix = MIx { row = r, col = c }- , let res = mulRowCol r c- ]- where- sz' = Size { rows = rows $ size m1, cols = cols $ size m2 }-- mulRowCol r c =- foldl' (Semiring.add semiring) (Semiring.zero semiring)- [ (Semiring.mul semiring)- (unM m1 ! MIx { row = r, col = i })- (unM m2 ! MIx { row = i, col = c })- | i <- [1 .. cols (size m1)]]--prop_mul sz =- sized $ \n -> resize (n `div` 2) $- forAll (two natural) $ \(c2, c3) ->- forAll (matrix sz :: Gen TM) $ \m1 ->- forAll (matrix (Size { rows = cols sz, cols = c2 })) $ \m2 ->- forAll (matrix (Size { rows = c2, cols = c3 })) $ \m3 ->- let m' = mult m1 m2 in- associative mult m1 m2 m3 &&- matrixInvariant m' &&- size m' == Size { rows = rows sz, cols = c2 }- where mult = mul Semiring.integerSemiring---- | @'diagonal' m@ extracts the diagonal of @m@.------ Precondition: @'square' m@.--diagonal :: (Enum i, Num i, Ix i) => Matrix i b -> Array i b-diagonal m = listArray (1, rows sz) [ unM m ! MIx {row = i, col = i}- | i <- [1 .. rows sz] ]- where sz = size m--prop_diagonal =- forAll natural $ \n ->- forAll (matrix (Size n n) :: Gen TM) $ \m ->- bounds (diagonal m) == (1, n)----------------------------------------------------------------------------- Modifying matrices---- | @'addColumn' x m@ adds a new column to @m@, after the columns--- already existing in the matrix. All elements in the new column get--- set to @x@.--addColumn :: (Ix i, Num i, Enum i) => b -> Matrix i b -> Matrix i b-addColumn x m = fromLists sz . addCol' . toLists $ m- where- sz = (size m) { cols = cols (size m) + 1 }- addCol' = map (++ [x])--prop_addColumn :: Integer -> TM -> Bool-prop_addColumn x m =- matrixInvariant m'- &&- map init (toLists m') == toLists m- where- m' = addColumn x m---- | @'addRow' x m@ adds a new row to @m@, after the rows already--- existing in the matrix. All elements in the new row get set to @x@.--addRow :: (Ix i, Integral i) => b -> Matrix i b -> Matrix i b-addRow x m = fromLists sz . addRow' . toLists $ m- where- sz = (size m) { rows = rows (size m) + 1 }- addRow' = (++ [genericReplicate (cols (size m)) x])--prop_addRow :: Integer -> TM -> Bool-prop_addRow x m =- matrixInvariant m'- &&- init (toLists m') == toLists m- where- m' = addRow x m----------------------------------------------------------------------------- Zipping (assumes non-empty matrices)--zipWith :: (a -> b -> c) ->- Matrix Integer a -> Matrix Integer b -> Matrix Integer c-zipWith f m1 m2- = fromLists (Size { rows = toInteger $ length ll,- cols = toInteger $ length (head ll) }) ll- where ll = List.zipWith (List.zipWith f) (toLists m1) (toLists m2)------------------------------------------------------------------------------ All tests--tests :: IO Bool-tests = runTests "Agda.Termination.Matrix"- [ quickCheck' prop_Arbitrary_Size- , quickCheck' prop_Arbitrary_Matrix- , quickCheck' prop_Arbitrary_MIx- , quickCheck' prop_fromIndexList- , quickCheck' prop_matrix- , quickCheck' prop_size- , quickCheck' prop_size_fromIndexList- , quickCheck' prop_fromLists_toLists- , quickCheck' prop_add- , quickCheck' prop_mul- , quickCheck' prop_diagonal- , quickCheck' prop_addColumn- , quickCheck' prop_addRow- ]
@@ -0,0 +1,705 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | The monad for the termination checker.+--+-- The termination monad @TerM@ is an extension of+-- the type checking monad 'TCM' by an environment+-- with information needed by the termination checker.++module Agda.Termination.Monad where++import Prelude hiding (null, zip, zipWith)++import Control.Monad.IO.Class ( MonadIO(..) )+import Control.Monad.Except ( MonadError(..) )++import Data.IntMap.Strict ( IntMap )+import Data.IntMap.Strict qualified as IntMap+import Data.Map.Strict ( Map )+import Data.Map.Strict qualified as Map+import Data.Set ( Set )+import Data.Set qualified as Set++import Agda.Interaction.Options ( optTerminationDepth )++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty ( Pretty, prettyShow )+import Agda.Syntax.Common.Pretty qualified as P+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern ( PatternLike(foldrPattern) )+import Agda.Syntax.Literal ( Literal(LitString) )++import Agda.Termination.CallMatrix ( CallMatrix, CallMatrix'(CallMatrix), CallMatrixAug(CallMatrixAug), CMSet )+import Agda.Termination.CallMatrix qualified as CallMatrix+import Agda.Termination.CallGraph ( CallGraph, callMatrixSet )+import Agda.Termination.CallGraph qualified as CallGraph+import Agda.Termination.CutOff ( CutOff, defaultCutOff )+import Agda.Termination.Order ( Order, le, unknown )+import Agda.Termination.RecCheck ( MutualNames, anyDefs )++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Monad.Benchmark+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Records+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute++import Agda.Utils.Benchmark as B+import Agda.Utils.BinTree ( BinTree )+import Agda.Utils.BinTree qualified as BinTree+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.ListInf ( ListInf )+import Agda.Utils.ListInf qualified as ListInf+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Monoid+import Agda.Utils.Null+import Agda.Utils.Singleton+import Agda.Utils.VarSet ( VarSet )+import Agda.Utils.VarSet qualified as VarSet+import Agda.Utils.Zip () -- for zip, zipWith instance+import Agda.Utils.StrictReader++import Agda.Utils.Impossible++-- | The target of the function we are checking.++data Target+ = TargetDef QName+ -- ^ The target of recursion is a @record@, @data@, or unreducible @Def@.+ | TargetRecord+ -- ^ We are termination-checking a record.+ | TargetOther+ -- ^ None of the above two or unknown.+ deriving (Eq, Show)++-- | The current guardedness level.++type Guarded = Order++-- | The termination environment.++data TerEnv = TerEnv++ -- First part: options, configuration.++ { terSizeSuc :: !(Maybe QName)+ -- ^ The name of size successor, if any.+ , terSharp :: !(Maybe QName)+ -- ^ The name of the delay constructor (sharp), if any.+ , terCutOff :: !CutOff+ -- ^ Depth at which to cut off the structural order.++ -- Second part: accumulated info during descent into decls./term.++ , terCurrent :: QName+ -- ^ The name of the function we are currently checking.+ , terMutual :: MutualNames+ -- ^ The names of the functions in the mutual block we are checking.+ -- This includes the internally generated functions+ -- (with, extendedlambda, coinduction).+ , terUserNames :: Set QName+ -- ^ The list of name actually appearing in the file (abstract syntax).+ -- Excludes the internally generated functions.+ , terHaveInlinedWith :: !Bool+ -- ^ Does the actual clause result from with-inlining?+ -- (If yes, it may be ill-typed.)+ , terTarget :: !Target+ -- ^ Target type of the function we are currently termination checking.+ -- Only the constructors of 'Target' are considered guarding.+ , terMaskArgs :: !(ListInf Bool)+ -- ^ Only consider the 'notMasked' 'False' arguments for establishing termination.+ -- See issue #1023.+ , terMaskResult :: !Bool+ -- ^ Only consider guardedness if 'False' (not masked).+ , _terSizeDepth :: Int -- lazy by intention!+ -- ^ How many @SIZELT@ relations do we have in the context+ -- (= clause telescope). Used to approximate termination+ -- for metas in call args.+ , terPatterns :: MaskedDeBruijnPatterns+ -- ^ The patterns of the clause we are checking.+ , terPatternsRaise :: !Int+ -- ^ Number of additional binders we have gone under+ -- (and consequently need to raise the patterns to compare to terms).+ -- Updated during call graph extraction, hence strict.+ , terGuarded :: !Guarded+ -- ^ The current guardedness status. Changes as we go deeper into the term.+ -- Updated during call graph extraction, hence strict.+ , terUseSizeLt :: !Bool+ -- ^ When extracting usable size variables during construction of the call+ -- matrix, can we take the variable for use with SIZELT constraints from the context?+ -- Yes, if we are under an inductive constructor.+ -- No, if we are under a record constructor.+ -- (See issue #1015).+ , terUsableVars :: !VarSet+ -- ^ Pattern variables that can be compared to argument variables using SIZELT.+ , terProjectedNameToNode :: !(Map (QName, [QName]) CallGraph.Node)+ -- ^ Map from (name, [projection]) to call-graph node.+ -- (See issue #8596 for why projected names merit distinct nodes).+ , terNodeToName :: !(IntMap QName)+ -- ^ Map from call-graph node back to function names.+ , terNameToProjections :: !(Map QName [[QName]])+ -- ^ Map from function names to the list of all available projection paths.+ , terProjectedNameToMaskArgs :: !(Map (QName, [QName]) (ListInf Bool))+ -- ^ Precomputed argument mask per @(name, [projection])@ pair, if @--without-K@.+ }++-- | An empty termination environment.+--+-- Values are set to a safe default meaning that with these+-- initial values the termination checker will not miss+-- termination errors it would have seen with better settings+-- of these values.+--+-- Values that do not have a safe default are set to+-- @__IMPOSSIBLE__@.++defaultTerEnv :: TerEnv+defaultTerEnv = TerEnv+ { terSizeSuc = Nothing+ , terSharp = Nothing+ , terCutOff = defaultCutOff+ , terUserNames = __IMPOSSIBLE__ -- needs to be set!+ , terMutual = __IMPOSSIBLE__ -- needs to be set!+ , terCurrent = __IMPOSSIBLE__ -- needs to be set!+ , terHaveInlinedWith = False+ , terTarget = TargetOther+ , terMaskArgs = ListInf.repeat False -- use all arguments (mask none)+ , terMaskResult = False -- use result (do not mask)+ , _terSizeDepth = __IMPOSSIBLE__ -- needs to be set!+ , terPatterns = __IMPOSSIBLE__ -- needs to be set!+ , terPatternsRaise = 0+ , terGuarded = le -- not initially guarded+ , terUseSizeLt = False -- initially, not under data constructor+ , terUsableVars = empty+ , terProjectedNameToNode = Map.empty+ , terNodeToName = IntMap.empty+ , terNameToProjections = Map.empty+ , terProjectedNameToMaskArgs = Map.empty+ }++-- | Termination monad service class.++class (Functor m, Monad m) => MonadTer m where+ terAsk :: m TerEnv+ terLocal :: (TerEnv -> TerEnv) -> m a -> m a++ terAsks :: (TerEnv -> a) -> m a+ terAsks f = f <$> terAsk++-- | Termination monad.++newtype TerM a = TerM { terM :: ReaderT TerEnv TCM a }+ deriving ( Functor+ , Applicative+ , Monad+ , MonadError TCErr+ , MonadStatistics+ , HasOptions+ , HasBuiltins+ , MonadDebug+ , MonadFileId+ , HasConstInfo+ , MonadIO+ , MonadTCEnv+ , MonadTCState+ , MonadTCM+ , ReadTCState+ , MonadReduce+ , MonadAddContext+ , PureTCM+ )++-- This could be derived automatically, but the derived type family becomes `BenchPhase (ReaderT TerEnv TCM)` which+-- is *fine* but triggers complaints that the "type family application is no smaller than the instance head, why not+-- nuke everything with UndecidableInstances".+instance MonadBench TerM where+ type BenchPhase TerM = Phase+ getBenchmark = TerM $ B.getBenchmark+ putBenchmark = TerM . B.putBenchmark+ modifyBenchmark = TerM . B.modifyBenchmark+ finally (TerM m) (TerM f) = TerM $ (B.finally m f)++instance MonadTer TerM where+ terAsk = TerM $ ask+ terLocal f = TerM . local f . terM++-- | Generic run method for termination monad.+runTer :: TerEnv -> TerM a -> TCM a+runTer tenv (TerM m) = runReaderT m tenv++-- | Run TerM computation in default environment (created from options).++runTerDefault :: TerM a -> TCM a+runTerDefault cont = do++ -- Assemble then initial configuration of the termination environment.++ cutoff <- optTerminationDepth <$> pragmaOptions++ -- Get the name of size suc (if sized types are enabled)+ suc <- sizeSucName++ -- The name of sharp (if available).+ sharp <- fmap nameOfSharp <$> coinductionKit++ let tenv = defaultTerEnv+ { terSizeSuc = suc+ , terSharp = sharp+ , terCutOff = cutoff+ }++ runTer tenv cont++-- -- * Termination monad is a 'MonadTCM'.++-- instance MonadError TCErr TerM where+-- throwError = liftTCM . throwError+-- catchError m handler = TerM $ ReaderT $ \ tenv -> do+-- runTer tenv m `catchError` (\ err -> runTer tenv $ handler err)++instance Semigroup m => Semigroup (TerM m) where+ (<>) = liftA2 (<>)++instance (Monoid m) => Monoid (TerM m) where+ mempty = pure mempty+ mappend = (<>)+ mconcat = mconcat <.> sequence++-- * Modifiers and accessors for the termination environment in the monad.++terGetSizeSuc :: TerM (Maybe QName)+terGetSizeSuc = terAsks terSizeSuc++terGetCurrent :: TerM QName+terGetCurrent = terAsks terCurrent++terSetCurrent :: QName -> TerM a -> TerM a+terSetCurrent q = terLocal $ \ e -> e { terCurrent = q }++terGetSharp :: TerM (Maybe QName)+terGetSharp = terAsks terSharp++terGetCutOff :: TerM CutOff+terGetCutOff = terAsks terCutOff++terGetMutual :: TerM MutualNames+terGetMutual = terAsks terMutual++terGetUserNames :: TerM (Set QName)+terGetUserNames = terAsks terUserNames++terGetTarget :: TerM Target+terGetTarget = terAsks terTarget++terSetTarget :: Target -> TerM a -> TerM a+terSetTarget t = terLocal $ \ e -> e { terTarget = t }++terGetHaveInlinedWith :: TerM Bool+terGetHaveInlinedWith = terAsks terHaveInlinedWith++terSetHaveInlinedWith :: TerM a -> TerM a+terSetHaveInlinedWith = terLocal $ \ e -> e { terHaveInlinedWith = True }++terGetMaskArgs :: TerM (ListInf Bool)+terGetMaskArgs = terAsks terMaskArgs++terSetMaskArgs :: ListInf Bool -> TerM a -> TerM a+terSetMaskArgs b = terLocal $ \ e -> e { terMaskArgs = b }++terGetMaskResult :: TerM Bool+terGetMaskResult = terAsks terMaskResult++terSetMaskResult :: Bool -> TerM a -> TerM a+terSetMaskResult b = terLocal $ \ e -> e { terMaskResult = b }++terGetPatterns :: TerM (MaskedDeBruijnPatterns)+terGetPatterns = do+ n <- terAsks terPatternsRaise+ mps <- terAsks terPatterns+ return $ if n == 0 then mps else map' (fmap (raise n)) mps++terSetPatterns :: MaskedDeBruijnPatterns -> TerM a -> TerM a+terSetPatterns ps = terLocal $ \ e -> e { terPatterns = ps }++terRaise :: TerM a -> TerM a+terRaise = terLocal $ \ e -> e { terPatternsRaise = terPatternsRaise e + 1 }++terGetGuarded :: TerM Guarded+terGetGuarded = terAsks terGuarded++terModifyGuarded :: (Order -> Order) -> TerM a -> TerM a+terModifyGuarded f = terLocal $ \ e -> e { terGuarded = f $ terGuarded e }++terSetGuarded :: Order -> TerM a -> TerM a+terSetGuarded = terModifyGuarded . const++terUnguarded :: TerM a -> TerM a+terUnguarded = terSetGuarded unknown++-- | Lens for '_terSizeDepth'.++terSizeDepth :: Lens' TerEnv Int+terSizeDepth f e = f (_terSizeDepth e) <&> \ i -> e { _terSizeDepth = i }++-- | Lens for 'terUsableVars'.++terGetUsableVars :: TerM VarSet+terGetUsableVars = terAsks terUsableVars++terModifyUsableVars :: (VarSet -> VarSet) -> TerM a -> TerM a+terModifyUsableVars f = terLocal $ \ e -> e { terUsableVars = f $ terUsableVars e }++terSetUsableVars :: VarSet -> TerM a -> TerM a+terSetUsableVars = terModifyUsableVars . const++terGetProjectedNameToNode :: TerM (Map (QName, [QName]) CallGraph.Node)+terGetProjectedNameToNode = terAsks terProjectedNameToNode++terSetProjectedNameToNode :: Map (QName, [QName]) CallGraph.Node -> TerM a -> TerM a+terSetProjectedNameToNode fwd = terLocal $ \ e -> e { terProjectedNameToNode = fwd }++terGetNodeToName :: TerM (IntMap QName)+terGetNodeToName = terAsks terNodeToName++terSetNodeToName :: IntMap QName -> TerM a -> TerM a+terSetNodeToName bwd = terLocal $ \ e -> e { terNodeToName = bwd }++terGetNameToProjections :: TerM (Map QName [[QName]])+terGetNameToProjections = terAsks terNameToProjections++terSetNameToProjections :: Map QName [[QName]] -> TerM a -> TerM a+terSetNameToProjections modes = terLocal $ \ e -> e { terNameToProjections = modes }++terGetProjectedNameToMaskArgs :: TerM (Map (QName, [QName]) (ListInf Bool))+terGetProjectedNameToMaskArgs = terAsks terProjectedNameToMaskArgs++terSetProjectedNameToMaskArgs :: Map (QName, [QName]) (ListInf Bool) -> TerM a -> TerM a+terSetProjectedNameToMaskArgs m = terLocal $ \ e -> e { terProjectedNameToMaskArgs = m }++-- | Lens for 'terUseSizeLt'.++terGetUseSizeLt :: TerM Bool+terGetUseSizeLt = terAsks terUseSizeLt++terModifyUseSizeLt :: (Bool -> Bool) -> TerM a -> TerM a+terModifyUseSizeLt f = terLocal $ \ e -> e { terUseSizeLt = f $ terUseSizeLt e }++terSetUseSizeLt :: Bool -> TerM a -> TerM a+terSetUseSizeLt = terModifyUseSizeLt . const++-- | Compute usable vars from patterns and run subcomputation.+withUsableVars :: UsableSizeVars a => a -> TerM b -> TerM b+withUsableVars pats m = do+ vars <- usableSizeVars pats+ reportSLn "term.size" 70 $ "usableSizeVars = " ++! show vars+ reportSDoc "term.size" 20 $ if null vars then "no usuable size vars" else+ "the size variables amoung these variables are usable: " <+>+ sep (map' (prettyTCM . var) $ VarSet.toAscList vars)+ terSetUsableVars vars $ m++-- | Set 'terUseSizeLt' when going under constructor @c@.+conUseSizeLt :: QName -> TerM a -> TerM a+conUseSizeLt c m = do+ ifM (liftTCM $ isEtaOrCoinductiveRecordConstructor c) -- Non-eta inductive records are the same as datatypes+ (terSetUseSizeLt False m)+ (terSetUseSizeLt True m)++-- | Set 'terUseSizeLt' for arguments following projection @q@.+-- We disregard j<i after a non-coinductive projection.+-- However, the projection need not be recursive (Issue 1470).+projUseSizeLt :: QName -> TerM a -> TerM a+projUseSizeLt q m = do+ co <- isCoinductiveProjection False q+ reportSLn "term.size" 20 $ applyUnless co ("not " ++!) $+ "using SIZELT vars after projection " ++! prettyShow q+ terSetUseSizeLt co m++-- | For termination checking purposes flat should not be considered a+-- projection. That is, it flat doesn't preserve either structural order+-- or guardedness like other projections do.+-- Andreas, 2012-06-09: the same applies to projections of recursive records.+isProjectionButNotCoinductive :: MonadTCM tcm => QName -> tcm Bool+isProjectionButNotCoinductive qn = liftTCM $ do+ b <- isProjectionButNotCoinductive' qn+ reportSDoc "term.proj" 60 $ do+ "identifier" <+> prettyTCM qn <+> do+ text $+ if b then "is an inductive projection"+ else "is either not a projection or coinductive"+ return b+ where+ isProjectionButNotCoinductive' qn = do+ flat <- fmap nameOfFlat <$> coinductionKit+ if Just qn == flat+ then return False+ else do+ mp <- isProjection qn+ case mp of+ Just Projection{ projProper = Just{}, projFromType = t }+ -> isInductiveRecord (unArg t)+ _ -> return False++-- | Is the given elimination anything but a coinductive projection?+elimNotCoinductive :: MonadTCM tcm => Elim' t -> tcm Bool+elimNotCoinductive e = case isProjElim e of+ Nothing -> return True+ Just (_o, x) -> isProjectionButNotCoinductive x++-- | Check whether a projection belongs to a coinductive record+-- and is actually recursive.+-- E.g.+-- @+-- isCoinductiveProjection (Stream.head) = return False+--+-- isCoinductiveProjection (Stream.tail) = return True+-- @+isCoinductiveProjection :: MonadTCM tcm => Bool -> QName -> tcm Bool+isCoinductiveProjection mustBeRecursive q = liftTCM $ do+ reportSLn "term.guardedness" 40 $ "checking isCoinductiveProjection " ++! prettyShow q+ flat <- fmap nameOfFlat <$> coinductionKit+ -- yes for ♭+ if Just q == flat then return True else do+ pdef <- getConstInfo q+ case isProjection_ (theDef pdef) of+ Just Projection{ projProper = Just{}, projFromType = Arg _ r, projIndex = n } ->+ caseMaybeM (isRecord r) __IMPOSSIBLE__ $ \ rdef -> do+ -- no for inductive or non-recursive record+ if _recInduction rdef /= Just CoInductive then return False else do+ reportSLn "term.guardedness" 40 $ prettyShow q ++! " is coinductive; record type is " ++! prettyShow r+ if not mustBeRecursive then return True else do+ reportSLn "term.guardedness" 40 $ prettyShow q ++! " must be recursive"+ if notSafeRecRecursive rdef then return False else do+ reportSLn "term.guardedness" 40 $ prettyShow q ++! " has been declared recursive, doing actual check now..."+ -- TODO: the following test for recursiveness of a projection should be cached.+ -- E.g., it could be stored in the @Projection@ component.+ -- Now check if type of field mentions mutually recursive symbol.+ -- Get the type of the field by dropping record parameters and record argument.+ let TelV tel core = telView' (defType pdef)+ (pars, tel') = splitAt' n $ telToList tel+ mut = fromMaybe __IMPOSSIBLE__ $ _recMutual rdef+ -- Check if any recursive symbols appear in the record type.+ -- Q (2014-07-01): Should we normalize the type?+ -- A (2017-01-13): Yes, since we also normalize during positivity check?+ -- See issue #1899.+ reportSDoc "term.guardedness" 40 $ inTopContext $ sep+ [ "looking for recursive occurrences of"+ , sep (map' prettyTCM mut)+ , "in"+ , addContext pars $ prettyTCM (telFromList tel')+ , "and"+ , addContext tel $ prettyTCM core+ ]+ when (null mut) __IMPOSSIBLE__+ names <- anyDefs (Set.fromList mut) (map' (snd . unDom) tel', core)+ reportSDoc "term.guardedness" 40 $+ "found" <+> if null names then "none" else sep (map' prettyTCM $ Set.toList names)+ return $ not $ null names+ _ -> do+ reportSLn "term.guardedness" 40 $ prettyShow q ++! " is not a proper projection"+ return False+ where+ -- Andreas, 2018-02-24, issue #2975, example:+ -- @+ -- record R : Set where+ -- coinductive+ -- field force : R++ -- r : R+ -- force r = r+ -- @+ -- The termination checker expects the positivity checker to have run on the+ -- record declaration R to know whether R is recursive.+ -- However, here, because the awkward processing of record declarations (see #434),+ -- that has not happened. To avoid crashing (as in Agda 2.5.3),+ -- we rather give the possibly wrong answer here,+ -- restoring the behavior of Agda 2.5.2. TODO: fix record declaration checking.+ notSafeRecRecursive :: RecordData -> Bool+ notSafeRecRecursive = maybe True null . _recMutual+ -- @_recMutual@ should be something (@Just (_:_)@) to be safe++-- * De Bruijn pattern stuff+---------------------------------------------------------------------------++-- | How long is the path to the deepest atomic pattern?+patternDepth :: forall a. Pattern' a -> Int+patternDepth = getMaxNat . foldrPattern depth where+ depth :: Pattern' a -> MaxNat -> MaxNat+ depth ConP{} = succ -- add 1 to the maximum of the depth of the subpatterns+ depth _ = id -- atomic pattern (leaf) has depth 0++-- | A dummy pattern used to mask a pattern that cannot be used+-- for structural descent.++unusedVar :: DeBruijnPattern+unusedVar = litP (LitString "term.unused.pat.var")++-- | Extract variables from 'DeBruijnPattern's that could witness a decrease+-- via a SIZELT constraint.+--+-- These variables must be under an inductive constructor (with no record+-- constructor in the way), or after a coinductive projection (with no+-- inductive one in the way).++class UsableSizeVars a where+ usableSizeVars :: a -> TerM VarSet++instance UsableSizeVars DeBruijnPattern where+ usableSizeVars = foldrPattern $ \case+ VarP _ x -> const $ ifM terGetUseSizeLt (return $ singleton $ dbPatVarIndex x) $+ {-else-} return mempty+ ConP c _ _ -> conUseSizeLt $ conName c+ LitP{} -> none+ DotP{} -> none+ ProjP{} -> none+ IApplyP{} -> none+ DefP{} -> none+ where none _ = return mempty++instance UsableSizeVars [DeBruijnPattern] where+ usableSizeVars ps =+ case ps of+ [] -> return mempty+ (ProjP _ q : ps) -> projUseSizeLt q $ usableSizeVars ps+ (p : ps) -> mappend <$> usableSizeVars p <*> usableSizeVars ps++instance UsableSizeVars (Masked DeBruijnPattern) where+ usableSizeVars (Masked m p) = (`foldrPattern` p) $ \case+ VarP _ x -> const $ ifM terGetUseSizeLt (return $ singleton $ dbPatVarIndex x) $+ {-else-} return mempty+ ConP c _ _ -> if m then none else conUseSizeLt $ conName c+ LitP{} -> none+ DotP{} -> none+ ProjP{} -> none+ IApplyP{} -> none+ DefP{} -> none+ where none _ = return mempty++instance UsableSizeVars MaskedDeBruijnPatterns where+ usableSizeVars ps =+ case ps of+ [] -> return mempty+ (Masked _ (ProjP _ q) : ps) -> projUseSizeLt q $ usableSizeVars ps+ (p : ps) -> mappend <$> usableSizeVars p <*> usableSizeVars ps++-- * Masked patterns+---------------------------------------------------------------------------++-- Masked patterns are not eligible for structural descent, only for size descent.+-- See issue #1023.++type MaskedDeBruijnPatterns = [Masked DeBruijnPattern]++data Masked a = Masked+ { getMask :: Bool -- ^ True if thing not eligible for structural descent.+ , getMasked :: a -- ^ Thing.+ } deriving (Eq, Ord, Show, Functor, Foldable, Traversable)++masked :: a -> Masked a+masked = Masked True++notMasked :: a -> Masked a+notMasked = Masked False++instance Decoration Masked where+ traverseF f (Masked m a) = Masked m <$> f a++-- | Print masked things in double parentheses.+instance PrettyTCM a => PrettyTCM (Masked a) where+ prettyTCM (Masked m a) = applyWhen m (parens . parens) $ prettyTCM a++-- * Call paths+---------------------------------------------------------------------------++-- | Call paths.+--+-- The call information is stored as free monoid over 'CallInfo',+-- giving us constant-time concatenation.+-- Once the information is complete, it can be converted to a non-empty list.+-- (This should only be done once, as this operation is linear-time.)++data CallPath = CallPath+ { callPathStart :: QName+ , callPathSteps :: BinTree CallInfo+ }+ deriving (Show)++-- | The calls making up the call path.++callInfos :: CallPath -> [CallInfo]+callInfos (CallPath _ cs) = BinTree.toList cs++instance Semigroup CallPath where+ CallPath start steps <> CallPath _ steps' = CallPath start (steps <> steps')++instance Monoid CallPath where+ mempty = CallPath empty mempty++-- | Only show intermediate nodes. (Drop last 'CallInfo').+instance Pretty CallPath where+ pretty cis0 = case callInfos cis0 of+ [] -> empty+ ci1:cis1 -> case init1 ci1 cis1 of+ [] -> empty+ cis2 -> P.hsep (map' (("-->" P.<+>) . P.pretty) cis2) P.<+> "-->"++-- * Size depth estimation+---------------------------------------------------------------------------++-- | A very crude way of estimating the @SIZELT@ chains+-- @i > j > k@ in context. Returns 3 in this case.+-- Overapproximates.+class TerSetSizeDepth b where+ terSetSizeDepth :: b -> TerM a -> TerM a++instance TerSetSizeDepth Telescope where+ terSetSizeDepth = terSetSizeDepth . telToList++-- TODO: more precise analysis, constructing a tree+-- of relations between size variables.+instance TerSetSizeDepth ListTel where+ terSetSizeDepth doms cont = do+ n <- liftTCM $ sum <$> do+ forM doms $ \ dom -> do+ -- Andreas, 2022-03-12, TODO:+ -- use ifBlocked? Shouldn't blocked types be treated like metas?+ a <- reduce $ snd $ unDom dom+ ifM (isJust <$> isSizeType a) (return 1) {- else -} $+ case unEl a of+ MetaV{} -> return 1+ _ -> return 0+ terLocal (set terSizeDepth n) cont++-- * PrettyTCM+---------------------------------------------------------------------------+--+-- This mostly duplicates the 'Pretty' instances,+-- but we use 'PrettyTCM' for the 'QName' in the 'CallPath'.++-- This conflicts with an existing instance in TypeChecking.Pretty+-- -- | We only print the name of the callee, omitting the actual call term.+-- instance PrettyTCM CallInfo where+-- prettyTCM (CallInfo target _term) = prettyTCM target++-- | Show all nodes.+instance PrettyTCM CallPath where+ prettyTCM cp = hsep $+ prettyTCM (callPathStart cp) :+ map' (\ (CallInfo g _) -> "-->" <+> prettyTCM g) (callInfos cp)++instance PrettyTCM CallMatrix where+ prettyTCM (CallMatrix m) = pretty m++instance PrettyTCM cinfo => PrettyTCM (CallMatrixAug cinfo) where+ prettyTCM (CallMatrixAug m cinfo) = prettyTCM cinfo $$ (nest 4 $ prettyTCM m)++instance PrettyTCM cinfo => PrettyTCM (CMSet cinfo) where+ prettyTCM = vcat . punctuate "\n" . map' prettyTCM . CallMatrix.toList++instance PrettyTCM cinfo => PrettyTCM (CallGraph.Call cinfo) where+ prettyTCM = prettyTCM . callMatrixSet++instance PrettyTCM cinfo => PrettyTCM (CallGraph cinfo) where+ prettyTCM = vcat . map' prettyTCM . CallGraph.toList
@@ -0,0 +1,327 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE ImplicitParams #-}++-- | An Abstract domain of relative sizes, i.e., differences+-- between size of formal function parameter and function argument+-- in recursive call; used in the termination checker.++module Agda.Termination.Order+ ( -- * Structural orderings+ Order(..), decr+ , increase, decrease, setUsability+ , makeIncreaseInfinite+ , (.*.)+ , supremum, infimum+ , orderSemiring+ , le, lt, unknown, orderMat, collapseO+ , nonIncreasing, decreasing, isDecr+ , NotWorse(..)+ , isOrder+ ) where++import qualified Data.Foldable as Fold+import qualified Data.List as List++import Agda.Termination.CutOff+import Agda.Termination.SparseMatrix as Matrix+import Agda.Termination.Semiring (HasZero(..), Semiring)+import qualified Agda.Termination.Semiring as Semiring++import Agda.Utils.PartialOrd+import Agda.Syntax.Common.Pretty++import Agda.Utils.Impossible++------------------------------------------------------------------------+-- Structural orderings++-- | In the paper referred to above, there is an order R with+-- @'Unknown' '<=' 'Le' '<=' 'Lt'@.+--+-- This is generalized to @'Unknown' '<=' 'Decr k'@ where+-- @Decr 1@ replaces @Lt@ and @Decr 0@ replaces @Le@.+-- A negative decrease means an increase. The generalization+-- allows the termination checker to record an increase by 1 which+-- can be compensated by a following decrease by 2 which results in+-- an overall decrease.+--+-- However, the termination checker of the paper itself terminates because+-- there are only finitely many different call-matrices. To maintain+-- termination of the terminator we set a @cutoff@ point which determines+-- how high the termination checker can count. This value should be+-- set by a global or file-wise option.+--+-- See 'Call' for more information.+--+-- TODO: document orders which are call-matrices themselves.+data Order+ = Decr !Bool {-# UNPACK #-} !Int+ -- ^ Decrease of callee argument wrt. caller parameter.+ --+ -- The @Bool@ indicates whether the decrease (if any) is usable.+ -- In any chain, there needs to be one usable decrease.+ -- Unusable decreases come from SIZELT constraints which are+ -- not in inductive pattern match or a coinductive copattern match.+ -- See issue #2331.+ --+ -- UPDATE: Andreas, 2017-07-26:+ -- Feature #2331 is unsound due to size quantification in terms.+ -- While the infrastructure for usable/unusable decrease remains in+ -- place, no unusable decreases are generated by TermCheck.+ | Unknown+ -- ^ No relation, infinite increase, or increase beyond termination depth.+ | Mat {-# UNPACK #-} !(Matrix Int Order)+ -- ^ Matrix-shaped order, currently UNUSED.+ deriving (Eq, Ord, Show)++-- instance Show Order where+-- show (Decr u k) = if u then show (- k) else "(" ++ show (-k) ++ ")"+-- show Unknown = "."+-- show (Mat m) = "Mat " ++ show m++instance HasZero Order where+ zeroElement = Unknown++-- | Information order: 'Unknown' is least information.+-- The more we decrease, the more information we have.+--+-- When having comparable call-matrices, we keep the lesser one.+-- Call graph completion works toward losing the good calls,+-- tending towards Unknown (the least information).+instance PartialOrd Order where+ comparable o o' = case (o, o') of+ (Unknown, Unknown) -> POEQ+ (Unknown, _ ) -> POLT+ (_ , Unknown) -> POGT+ (Decr u k, Decr u' l) -> comparableBool u u' `orPO` comparableOrd k l+ -- Matrix-shaped orders are no longer supported+ (Mat{} , _ ) -> __IMPOSSIBLE__+ (_ , Mat{} ) -> __IMPOSSIBLE__+ where+ comparableBool = curry $ \case+ (False, True) -> POLT+ (True, False) -> POGT+ _ -> POEQ++-- | A partial order, aimed at deciding whether a call graph gets+-- worse during the completion.+--+class NotWorse a where+ notWorse :: a -> a -> Bool++-- | It does not get worse then ``increase''.+-- If we are still decreasing, it can get worse: less decreasing.+instance NotWorse Order where+ o `notWorse` Unknown = True -- we are unboundedly increasing+ Unknown `notWorse` Decr _ k = k < 0 -- we are increasing+ Decr u l `notWorse` Decr u' k = k < 0 -- we are increasing or+ || l >= k && (u || not u') -- we are decreasing, but not less, and not less usable+ -- Matrix-shaped orders are no longer supported+ Mat m `notWorse` o = __IMPOSSIBLE__+ o `notWorse` Mat m = __IMPOSSIBLE__+{-+ Mat m `notWorse` Mat n = m `notWorse` n -- matrices are compared pointwise+ o `notWorse` Mat n = o `notWorse` collapse n -- or collapsed (sound?)+ Mat m `notWorse` o = collapse m `notWorse` o+-}++-- | We assume the matrices have the same dimension.+instance (Ord i, HasZero o, NotWorse o) => NotWorse (Matrix i o) where+ m `notWorse` n+ | size m /= size n = __IMPOSSIBLE__+ | otherwise = Fold.and $ zipMatrices onlym onlyn both trivial m n+ where+ -- If an element is only in @m@, then its 'Unknown' in @n@+ -- so it gotten better at best, in any case, not worse.+ onlym o = True -- @== o `notWorse` Unknown@+ onlyn o = zeroElement `notWorse` o+ both = notWorse+ trivial = id -- @True@ counts as zero as it is neutral for @and@++-- | Raw increase which does not cut off.+increase :: Int -> Order -> Order+increase i = \case+ Unknown -> Unknown+ Decr u k -> Decr u $ k - i -- TODO: should we set u to False if k - i < 0 ?+ Mat m -> Mat $ fmap (increase i) m++-- | Raw decrease which does not cut off.+decrease :: Int -> Order -> Order+decrease i o = increase (-i) o++setUsability :: Bool -> Order -> Order+setUsability u o = case o of+ Decr _ k -> Decr u k+ Unknown -> o+ Mat{} -> o++-- | Turn any increase into infinite increase ('Unknown').++makeIncreaseInfinite :: Order -> Order+makeIncreaseInfinite = \case+ Decr u k | k < 0 -> Unknown+ o -> o++-- | Smart constructor for @Decr k :: Order@ which cuts off too big values.+--+-- Possible values for @k@: @- ?cutoff '<=' k '<=' ?cutoff + 1@.++decr :: (?cutoff :: CutOff) => Bool -> Int -> Order+decr u k = case ?cutoff of+ CutOff c | k < -c -> Unknown+ | k > c -> Decr u $ c + 1+ _ -> Decr u k++-- | Smart constructor for matrix shaped orders, avoiding empty and singleton matrices.+orderMat :: Matrix Int Order -> Order+orderMat m+ | Matrix.isEmpty m = le -- 0x0 Matrix = neutral element+ | Just o <- isSingleton m = o -- 1x1 Matrix+ | otherwise = Mat m -- nxn Matrix++withinCutOff :: (?cutoff :: CutOff) => Int -> Bool+withinCutOff k = case ?cutoff of+ DontCutOff -> True+ CutOff c -> k >= -c && k <= c + 1++isOrder :: (?cutoff :: CutOff) => Order -> Bool+isOrder (Decr _ k) = withinCutOff k+isOrder Unknown = True+isOrder (Mat m) = False -- TODO: extend to matrices++-- | @le@, @lt@, @decreasing@, @unknown@: for backwards compatibility, and for external use.+le :: Order+le = Decr False 0++-- | Usable decrease.+lt :: Order+lt = Decr True 1++unknown :: Order+unknown = Unknown++nonIncreasing :: Order -> Bool+nonIncreasing (Decr _ k) = k >= 0+nonIncreasing _ = False++-- | Decreasing and usable?+decreasing :: Order -> Bool+decreasing (Decr u k) = u && k > 0+decreasing _ = False++-- | Matrix-shaped order is decreasing if any diagonal element is decreasing.+isDecr :: Order -> Bool+isDecr (Mat m) = any isDecr $ diagonal m+isDecr o = decreasing o++instance Pretty Order where+ pretty (Decr u 0) = "="+ pretty (Decr u k) = mparens (not u) $ text $ show (negate k)+ pretty Unknown = "?"+ pretty (Mat m) = "Mat" <+> pretty m+++-- | Multiplication of 'Order's.+-- (Corresponds to sequential composition.)++-- I think this funny pattern matching is because overlapping patterns+-- are producing a warning and thus an error (strict compilation settings)+(.*.) :: (?cutoff :: CutOff) => Order -> Order -> Order+Unknown .*. _ = Unknown+(Mat m) .*. Unknown = Unknown+(Decr _ k) .*. Unknown = Unknown+(Decr u k) .*. (Decr u' l) = decr (u || u') (k + l) -- if one is usable, so is the composition+(Decr _ 0) .*. (Mat m) = Mat m+(Decr u k) .*. (Mat m) = (Decr u k) .*. (collapse m)+(Mat m1) .*. (Mat m2)+ | okM m1 m2 = Mat $ mul orderSemiring m1 m2+ | otherwise = (collapse m1) .*. (collapse m2)+(Mat m) .*. (Decr _ 0) = Mat m+(Mat m) .*. (Decr u k) = (collapse m) .*. (Decr u k)++-- | collapse @m@+--+-- We assume that @m@ codes a permutation: each row has at most one column+-- that is not @Unknown@.+--+-- To collapse a matrix into a single value, we take the best value of+-- each column and multiply them. That means if one column is all @Unknown@,+-- i.e., no argument relates to that parameter, then the collapsed value+-- is also @Unknown@.+--+-- This makes order multiplication associative.++collapse :: (?cutoff :: CutOff) => Matrix Int Order -> Order+collapse m = case toLists $ Matrix.transpose m of+ [] -> __IMPOSSIBLE__ -- This can never happen if order matrices are generated by the smart constructor+ m' -> foldl1 (.*.) $ map (foldl1 maxO) m'++collapseO :: (?cutoff :: CutOff) => Order -> Order+collapseO (Mat m) = collapse m+collapseO o = o++-- | Can two matrices be multplied together?+okM :: Matrix Int Order -> Matrix Int Order -> Bool+okM m1 m2 = rows (size m2) == cols (size m1)++-- | The supremum of a (possibly empty) list of 'Order's.+-- More information (i.e., more decrease) is bigger.+-- 'Unknown' is no information, thus, smallest.+supremum :: (?cutoff :: CutOff) => [Order] -> Order+supremum = foldr maxO Unknown++-- | @('Order', 'maxO', '.*.')@ forms a semiring,+-- with 'Unknown' as zero and 'Le' as one.++maxO :: (?cutoff :: CutOff) => Order -> Order -> Order+maxO o1 o2 = case (o1,o2) of+ -- NOTE: strictly speaking the maximum does not exists+ -- which is better, an unusable decrease by 2 or a usable decrease by 1?+ -- We give the usable information priority if it is a decrease.+ (Decr False _, Decr True l) | l > 0 -> o2+ (Decr True k, Decr False _) | k > 0 -> o1+ (Decr u k, Decr u' l) -> if l > k then o2 else o1+ (Unknown, _) -> o2+ (_, Unknown) -> o1+ (Mat m1, Mat m2) -> Mat (Matrix.add maxO m1 m2)+ (Mat m, _) -> maxO (collapse m) o2+ (_, Mat m) -> maxO o1 (collapse m)++-- | The infimum of a (non empty) list of 'Order's.+-- Gets the worst information.+-- 'Unknown' is the least element, thus, dominant.+infimum :: (?cutoff :: CutOff) => [Order] -> Order+infimum (o:l) = List.foldl' minO o l+infimum [] = __IMPOSSIBLE__++-- | Pick the worst information.+minO :: (?cutoff :: CutOff) => Order -> Order -> Order+minO o1 o2 = case (o1,o2) of+ (Unknown, _) -> Unknown+ (_, Unknown) -> Unknown+ -- different usability:+ -- We pick the unusable one if it is not a decrease or+ -- decreases not more than the usable one.+ (Decr False k, Decr True l) -> if k <= 0 || k <= l then o1 else o2+ (Decr True k, Decr False l) -> if l <= 0 || l <= k then o2 else o1+ -- same usability:+ (Decr u k, Decr _ l) -> Decr u (min k l)+ (Mat m1, Mat m2)+ | size m1 == size m2 -> Mat $ Matrix.intersectWith minO m1 m2+ | otherwise -> minO (collapse m1) (collapse m2)+ (Mat m1, _) -> minO (collapse m1) o2+ (_, Mat m2) -> minO o1 (collapse m2)+++-- | We use a record for semiring instead of a type class+-- since implicit arguments cannot occur in instance constraints,+-- like @instance (?cutoff :: Int) => SemiRing Order@.++orderSemiring :: (?cutoff :: CutOff) => Semiring Order+orderSemiring = Semiring.Semiring+ { Semiring.add = maxO+ , Semiring.mul = (.*.)+ , Semiring.zero = Unknown+ -- , Semiring.one = Le+ }
@@ -0,0 +1,182 @@+{-# OPTIONS_GHC -Wunused-imports #-}+-- {-# OPTIONS_GHC -ddump-simpl -dsuppress-all -dno-suppress-type-signatures -ddump-to-file -dno-typeable-binds #-}++{- | Checking for recursion:++ - We detect truly (co)recursive definitions by computing the+ dependency graph and checking for cycles.++ - This is inexpensive and let us skip the termination check+ when there's no (co)recursion++ Original contribution by Andrea Vezzosi (sanzhiyan).+ This implementation by Andreas.+-}+++module Agda.Termination.RecCheck+ ( MutualNames+ , recursive+ , anyDefs+ )+ where++import Control.Monad (forM)+import Data.Foldable+import Data.Graph+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import qualified Data.Map as Map+import qualified Data.Map.Strict as MapS+import Data.Maybe+import Data.Set (Set)+import qualified Data.Set as Set++import Agda.Syntax.Internal+import Agda.Syntax.Internal.Defs+import Agda.Syntax.Common.Pretty (prettyShow)++import Agda.TypeChecking.Monad+import Agda.TypeChecking.CompiledClause++import Agda.Utils.List+import Agda.Utils.Impossible+import Agda.Utils.StrictFlipEndo++-- | The mutual block we are checking.+--+-- The functions are numbered according to their order of appearance+-- in this set.++type MutualNames = Set QName++-- | We compute for each clause the set of potentially recursive names.+type NamesPerClause = IntMap (Set QName)++-- | Given a list of formally mutually recursive functions,+-- check for actual recursive calls in the bodies of these functions.+-- Returns the actually recursive functions as strongly connected components.+--+-- As a side effect, update the 'clauseRecursive' field in the+-- clauses belonging to the given functions.+recursive :: Set QName -> TCM [MutualNames]+recursive names = do+ let names' = toList names+ -- For each function, get names per clause and total.+ (perClauses, nss) <- unzip <$> mapM (recDef names) names'+ -- Create graph suitable for stronglyConnComp.+ -- Nodes are identical to node keys.+ let graph = zipWith' (\ x ns -> (x, x, Set.toList ns)) names' nss+ let sccs = stronglyConnComp graph+ let nonRec = mapMaybe (\case AcyclicSCC x -> Just x+ _ -> Nothing)+ sccs+ let recs = mapMaybe (\case CyclicSCC xs -> Just (Set.fromList xs)+ _ -> Nothing)+ sccs++ reportSLn "rec.graph" 60 $ show graph++ -- Mark all non-recursive functions and their clauses as such.+ mapM_ markNonRecursive nonRec++ -- Mark individual clauses of recursive functions:+ --------------------------------------------------+ -- Map names to clause numbers to sets of mentioned names.+ let clMap = Map.fromListWith __IMPOSSIBLE__ $ zip' names' perClauses+ -- Walk through SCCs.+ forM_ recs $ \ scc -> do+ -- Does a set of names have an overlap with the current scc?+ let overlap s = any (`Set.member` s) scc+ -- Walk through members of SCC.+ forM_ scc $ \ x -> do+ -- Get the NamesPerClause for the current function x.+ let perClause = Map.findWithDefault __IMPOSSIBLE__ x clMap+ -- A clause is recursive if its calls overlap with its scc.+ let recClause i = overlap $ IntMap.findWithDefault __IMPOSSIBLE__ i perClause+ markRecursive recClause x++ -- Return recursive SCCs.+ return recs++-- | Mark a function as terminating and all its clauses as non-recursive.+markNonRecursive :: QName -> TCM ()+markNonRecursive q = modifySignature $ updateDefinition q $ updateTheDef $ \case+ def@Function{} -> def+ { funTerminates = Just True+ , funClauses = map' (\ cl -> cl { clauseRecursive = NotRecursive }) $ funClauses def+ , funCompiled = fmap (mapDone \ done -> done{ ccClauseRecursive = NotRecursive }) $ funCompiled def+ }+ def@Record{} -> def+ { recTerminates = Just True+ }+ def -> def++-- | Mark all clauses of a function as recursive or non-recursive.+markRecursive+ :: (Int -> Bool) -- ^ Which clauses are recursive?+ -> QName -> TCM ()+markRecursive f q = modifySignature $ updateDefinition q $ updateTheDef $ \case+ def@Function{} -> def+ { funClauses = zipWith' (\ i cl -> cl { clauseRecursive = decideRecursive (f i) }) [0..] $ funClauses def+ , funCompiled = fmap (mapDone \ done@CCDone{ ccClauseNumber = i } -> done{ ccClauseRecursive = decideRecursive (f i) }) $ funCompiled def+ }+ def -> def++-- | @recDef names name@ returns all definitions from @names@+-- that are used in the type and body of @name@.+recDef :: Set QName -> QName -> TCM (NamesPerClause, Set QName)+recDef include name = do+ -- Retrieve definition+ def <- getConstInfo name++ -- Get names in type+ ns1 <- anyDefs include (defType def)++ -- Get names in body+ (perClause, ns2) <- case theDef def of++ Function{ funClauses = cls } -> do+ perClause <- do+ forM (zip [0..] cls) $ \ (i, cl) ->+ (i,) <$> anyDefs include cl+ return (IntMap.fromList perClause, mconcat $ map snd perClause)++ Datatype{ dataClause = Just v } -> do+ ns <- anyDefs include v+ return (IntMap.singleton 0 ns, ns)++ Record{ recClause, recTel } -> do+ ns1 <- anyDefs include recClause+ ns2 <- anyDefs include recTel+ let ns = ns1 `mappend` ns2+ return (IntMap.singleton 0 ns, ns)++ _ -> return (mempty, mempty)++ reportS "rec.graph" 20+ [ "recDef " ++ prettyShow name+ , " names in the type: " ++ prettyShow ns1+ , " names in the def: " ++ prettyShow ns2+ ]+ return (perClause, ns1 `mappend` ns2)++{-# INLINE anyDefs #-}+-- | @anysDef names a@ returns all definitions from @names@+-- that are used in @a@.+anyDefs :: GetDefs a => Set QName -> a -> TCM (Set QName)+anyDefs include a = do+ -- Prepare function to lookup metas outside of TCM+ st <- useR stSolvedMetaStore+ let lookup x = inst . mvInstantiation <$> MapS.lookup x st+ -- we collect only those used definitions that are in @names@+ emb d = Endo \s -> if Set.member d include then Set.insert d s+ else s+ -- get all the Defs that are in names+ return $! getDefs lookup emb a `appEndo` mempty+ where+ -- TODO: Is it bad to ignore the lambdas?+ inst (InstV i) = instBody i+ inst OpenMeta{} = __IMPOSSIBLE__+ inst BlockedConst{} = __IMPOSSIBLE__+ inst PostponedTypeCheckingProblem{} = __IMPOSSIBLE__
@@ -1,29 +1,17 @@--- {-# LANGUAGE UndecidableInstances #-}+{-# OPTIONS_GHC -Wunused-imports #-} -- | Semirings. module Agda.Termination.Semiring- ( HasZero(..), SemiRing(..)+ ( HasZero(..) , Semiring(..)- , semiringInvariant , integerSemiring+ , intSemiring , boolSemiring- , Agda.Termination.Semiring.tests ) where -import Data.Monoid -import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers -{- | SemiRing type class. Additive monoid with multiplication operation.-Inherit addition and zero from Monoid. -}--class (Eq a, Monoid a) => SemiRing a where--- isZero :: a -> Bool- multiply :: a -> a -> a-- -- | @HasZero@ is needed for sparse matrices, to tell which is the element -- that does not have to be stored. -- It is a cut-down version of @SemiRing@ which is definable@@ -33,33 +21,13 @@ -- | Semirings. -data Semiring a- = Semiring { add :: a -> a -> a -- ^ Addition.- , mul :: a -> a -> a -- ^ Multiplication.- , zero :: a -- ^ Zero.--- The one is never used in matrix multiplication--- , one :: a -- ^ One.- }---- | Semiring invariant.---- I think it's OK to use the same x, y, z triple for all the--- properties below.--semiringInvariant :: (Arbitrary a, Eq a, Show a)- => Semiring a- -> a -> a -> a -> Bool-semiringInvariant (Semiring { add = (+), mul = (*)- , zero = zero --, one = one- }) = \x y z ->- associative (+) x y z &&- identity zero (+) x &&- commutative (+) x y &&- associative (*) x y z &&--- identity one (*) x &&- leftDistributive (*) (+) x y z &&- rightDistributive (*) (+) x y z &&- isZero zero (*) x+data Semiring a = Semiring+ { add :: a -> a -> a -- ^ Addition.+ , mul :: a -> a -> a -- ^ Multiplication.+ , zero :: a -- ^ Zero.+ -- The one is never used in matrix multiplication+ -- , one :: a -- ^ One.+ } ------------------------------------------------------------------------ -- Specific semirings@@ -69,32 +37,19 @@ instance HasZero Integer where zeroElement = 0 -instance Monoid Integer where- mempty = 0- mappend = (+)--instance SemiRing Integer where- multiply = (*)-- integerSemiring :: Semiring Integer integerSemiring = Semiring { add = (+), mul = (*), zero = 0 } -- , one = 1 } -prop_integerSemiring = semiringInvariant integerSemiring+-- | The standard semiring on 'Int's. +instance HasZero Int where+ zeroElement = 0++intSemiring :: Semiring Int+intSemiring = Semiring { add = (+), mul = (*), zero = 0 } -- , one = 1 }+ -- | The standard semiring on 'Bool's. boolSemiring :: Semiring Bool boolSemiring = Semiring { add = (||), mul = (&&), zero = False } --, one = True }--prop_boolSemiring = semiringInvariant boolSemiring----------------------------------------------------------------------------- All tests--tests :: IO Bool-tests = runTests "Agda.Termination.Semiring"- [ quickCheck' prop_integerSemiring- , quickCheck' prop_boolSemiring- ]
@@ -1,306 +1,367 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} {- | Sparse matrices. We assume the matrices to be very sparse, so we just implement them as sorted association lists. +Most operations are linear in the number of non-zero elements.++An exception is transposition, which needs to sort the association+list again; it has the complexity of sorting: @n log n@ where @n@ is+the number of non-zero elements.++Another exception is matrix multiplication, of course.+ -} module Agda.Termination.SparseMatrix ( -- * Basic data types- Matrix- , matrixInvariant+ Matrix(Matrix)+ , unM+ -- , matrixInvariant -- Moved to the internal test-suite , Size(..)- , sizeInvariant , MIx (..)- , mIxInvariant -- * Generating and creating matrices , fromLists , fromIndexList , toLists -- , Agda.Termination.Matrix.zipWith- , matrix- , matrixUsingRowGen+ -- , matrix -- Moved to the internal test-suite -- * Combining and querying matrices , size , square , isEmpty , isSingleton- , add, intersectWith+ , zipMatrices+ , add+ , intersectWith+ , interAssocWith+ , mapNonZeros, mapDiagonalNonZeros , mul , transpose- , diagonal+ , Diagonal(..)+ , toSparseRows+ , supSize+ , zipAssocWith -- * Modifying matrices , addRow , addColumn- -- * Tests- , Agda.Termination.SparseMatrix.tests ) where import Data.Array+import Data.Function (on) import qualified Data.List as List-import Agda.Utils.Pretty hiding (isEmpty)-import Data.Monoid-import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers-import Agda.Termination.Semiring (HasZero(..), SemiRing, Semiring)-import qualified Agda.Termination.Semiring as Semiring+import Data.Maybe -#include "../undefined.h"-import Agda.Utils.Impossible ---------------------------------------------------------------------------- Basic data types+import qualified Data.Foldable as Fold --- | This matrix type is used for tests.+import qualified Text.PrettyPrint.Boxes as Boxes -type TM = Matrix Integer Integer+import Agda.Termination.Semiring (HasZero(..), Semiring)+import qualified Agda.Termination.Semiring as Semiring --- | Size of a matrix. -data Size i = Size { rows :: i, cols :: i }- deriving (Eq, Ord, Show)--sizeInvariant :: (Ord i, Num i) => Size i -> Bool-sizeInvariant sz = rows sz >= 0 && cols sz >= 0+import Agda.Utils.List+import Agda.Utils.Maybe -instance (Arbitrary i, Integral i) => Arbitrary (Size i) where- arbitrary = do- r <- natural- c <- natural- return $ Size { rows = fromInteger r, cols = fromInteger c }+import Agda.Utils.PartialOrd+import Agda.Syntax.Common.Pretty hiding (isEmpty)+import Agda.Utils.Tuple -instance CoArbitrary i => CoArbitrary (Size i) where- coarbitrary (Size rs cs) = coarbitrary rs . coarbitrary cs+import Agda.Utils.Impossible+import Agda.Utils.Function (applyWhen) -prop_Arbitrary_Size :: Size Integer -> Bool-prop_Arbitrary_Size = sizeInvariant+------------------------------------------------------------------------+-- * Basic data types+------------------------------------------------------------------------ --- | Converts a size to a set of bounds suitable for use with--- the matrices in this module.+-- | Size of a matrix. -toBounds :: Num i => Size i -> (MIx i, MIx i)-toBounds sz = (MIx { row = 1, col = 1 }, MIx { row = rows sz, col = cols sz })+data Size i = Size+ { rows :: i -- ^ Number of rows, @>= 0@.+ , cols :: i -- ^ Number of columns, @>= 0@.+ }+ deriving (Eq, Ord, Show) -- | Type of matrix indices (row, column). -data MIx i = MIx { row, col :: i }- deriving (Eq, Show, Ix, Ord)--instance (Arbitrary i, Integral i) => Arbitrary (MIx i) where- arbitrary = do- r <- positive- c <- positive- return $ MIx { row = r, col = c }--instance CoArbitrary i => CoArbitrary (MIx i) where- coarbitrary (MIx r c) = coarbitrary r . coarbitrary c---- | No nonpositive indices are allowed.--mIxInvariant :: (Ord i, Num i) => MIx i -> Bool-mIxInvariant i = row i >= 1 && col i >= 1+data MIx i = MIx+ { row :: i -- ^ Row index, @1 <= row <= rows@.+ , col :: i -- ^ Column index @1 <= col <= cols@.+ }+ deriving (Eq, Ord, Show, Ix) -prop_Arbitrary_MIx :: MIx Integer -> Bool-prop_Arbitrary_MIx = mIxInvariant+-- UNUSED Liang-Ting Chen 2019-07-15+---- | Convert a 'Size' to a set of bounds suitable for use with+---- the matrices in this module.+--+--toBounds :: Num i => Size i -> (MIx i, MIx i)+--toBounds sz = (MIx { row = 1, col = 1 }, MIx { row = rows sz, col = cols sz }) -- | Type of matrices, parameterised on the type of values.--data Matrix i b = M { size :: Size i, unM :: [(MIx i, b)] }- deriving (Eq, Ord)+--+-- Sparse matrices are implemented as an ordered association list,+-- mapping coordinates to values. -matrixInvariant :: (Num i, Ix i) => Matrix i b -> Bool-matrixInvariant m = all (\ (MIx i j, b) -> 1 <= i && i <= rows sz- && 1 <= j && j <= cols sz) (unM m)- && strictlySorted (MIx 0 0) (unM m)- && sizeInvariant sz- where sz = size m+data Matrix i b = Matrix+ { size :: Size i -- ^ Dimensions of the matrix.+ , unM :: [(MIx i, b)] -- ^ Association of indices to values.+ }+ deriving (Eq, Ord, Functor, Foldable, Traversable) --- matrix indices are lexicographically sorted with no duplicates--- Ord MIx should be the lexicographic one already (Haskell report)+------------------------------------------------------------------------+-- * Operations and query on matrix size.+------------------------------------------------------------------------ -strictlySorted :: (Ord i) => i -> [(i, b)] -> Bool-strictlySorted i [] = True-strictlySorted i ((i', b) : l) = i < i' && strictlySorted i' l-{--strictlySorted (MIx i j) [] = True-strictlySorted (MIx i j) ((MIx i' j', b) : l) =- (i < i' || i == i' && j < j' ) && strictlySorted (MIx i' j') b--}+-- | 'True' iff the matrix is square. -instance (Ord i, Integral i, Enum i, Show i, Show b, HasZero b) => Show (Matrix i b) where- showsPrec _ m =- showString "Agda.Termination.Matrix.fromLists " . shows (size m) .- showString " " . shows (toLists m)+square :: Ix i => Matrix i b -> Bool+square m = rows (size m) == cols (size m) -instance (Show i, Integral i, HasZero b, Pretty b) =>- Pretty (Matrix i b) where- pretty = vcat . map (hsep . map pretty) . toLists+-- | Returns 'True' iff the matrix is empty. -instance (Arbitrary i, Num i, Integral i, Arbitrary b, HasZero b)- => Arbitrary (Matrix i b) where- arbitrary = matrix =<< arbitrary+isEmpty :: (Num i, Ix i) => Matrix i b -> Bool+isEmpty m = rows sz <= 0 || cols sz <= 0+ where sz = size m -instance (Show i, Ord i, Integral i, Enum i, CoArbitrary b, HasZero b) => CoArbitrary (Matrix i b) where- coarbitrary m = coarbitrary (toLists m)+-- | Compute the matrix size of the union of two matrices. +supSize :: Ord i => Matrix i a -> Matrix i b -> Size i+supSize (Matrix (Size r1 c1) _) (Matrix (Size r2 c2) _) =+ Size (max r1 r2) (max c1 c2) -prop_Arbitrary_Matrix :: TM -> Bool-prop_Arbitrary_Matrix = matrixInvariant+-- | Compute the matrix size of the intersection of two matrices. +infSize :: Ord i => Matrix i a -> Matrix i b -> Size i+infSize (Matrix (Size r1 c1) _) (Matrix (Size r2 c2) _) =+ Size (min r1 r2) (min c1 c2) --------------------------------------------------------------------------- Generating and creating matrices---- | Generates a matrix of the given size, using the given generator--- to generate the rows.--matrixUsingRowGen :: (Arbitrary i, Integral i, Arbitrary b, HasZero b)- => Size i- -> (i -> Gen [b])- -- ^ The generator is parameterised on the size of the row.- -> Gen (Matrix i b)-matrixUsingRowGen sz rowGen = do- rows <- vectorOf (fromIntegral $ rows sz) (rowGen $ cols sz)- return $ fromLists sz rows---- | Generates a matrix of the given size.--matrix :: (Arbitrary i, Integral i, Arbitrary b, HasZero b)- => Size i -> Gen (Matrix i b)-matrix sz = matrixUsingRowGen sz (\n -> vectorOf (fromIntegral n) arbitrary)--prop_matrix sz = forAll (matrix sz :: Gen TM) $ \m ->--- matrixInvariant m &&- size m == sz---- | Constructs a matrix from a list of (index, value)-pairs.+-- * Creating matrices and converting to lists.+------------------------------------------------------------------------ --- compareElt = (\ (i,_) (j,_) -> compare i j)--- normalize = filter (\ (i,b) -> b /= zeroElement)+-- | Constructs a matrix from a list of @(index, value)@-pairs.+-- @O(n)@ where @n@ is size of the list.+--+-- Precondition: indices are unique. fromIndexList :: (Ord i, HasZero b) => Size i -> [(MIx i, b)] -> Matrix i b-fromIndexList sz = M sz . List.sortBy (\ (i,_) (j,_) -> compare i j) . filter (\ (i,b) -> b /= zeroElement)--prop_fromIndexList :: TM -> Bool-prop_fromIndexList m = matrixInvariant m' && m' == m- where vs = unM m- m' = fromIndexList (size m) vs+fromIndexList sz = Matrix sz+ . List.sortBy (compare `on` fst)+ . filter ((zeroElement /=) . snd) -- | @'fromLists' sz rs@ constructs a matrix from a list of lists of--- values (a list of rows).+-- values (a list of rows).+-- @O(size)@ where @size = rows × cols@. ----- Precondition: @'length' rs '==' 'rows' sz '&&' 'all' (('==' 'cols' sz) . 'length') rs@.+-- Precondition:+-- @'length' rs '==' 'rows' sz@ and+-- @'all' (('cols' sz '==') . 'length') rs@. fromLists :: (Ord i, Num i, Enum i, HasZero b) => Size i -> [[b]] -> Matrix i b fromLists sz bs = fromIndexList sz $ zip ([ MIx i j | i <- [1..rows sz] , j <- [1..cols sz]]) (concat bs) --- | Converts a sparse matrix to a sparse list of rows+-- | Converts a sparse matrix to a sparse list of rows.+-- @O(n)@ where @n@ is the number of non-zero entries of the matrix.+--+-- Only non-empty rows are generated.+-- -toSparseRows :: (Eq i, Num i, Enum i) => Matrix i b -> [(i,[(i,b)])]-toSparseRows m = aux 1 [] (unM m)- where aux i' [] [] = []+toSparseRows :: (Eq i) => Matrix i b -> [(i,[(i,b)])]+toSparseRows (Matrix _ []) = []+toSparseRows (Matrix _ ((MIx i j, b) : m)) = aux i [(j,b)] m+ where aux i' [] [] = [] aux i' row [] = [(i', reverse row)] aux i' row ((MIx i j, b) : m)- | i' == i = aux i' ((j,b):row) m- | otherwise = (i', reverse row) : aux i [(j,b)] m+ | i' == i = aux i' ((j,b):row) m+ | otherwise = (i', reverse row) : aux i [(j,b)] m --- sparse vectors cannot have two entries in one column-blowUpSparseVec :: (Show i, Ord i, Num i, Enum i) => b -> i -> [(i,b)] -> [b]+-- | Turn a sparse vector into a vector by inserting a fixed element+-- at the missing positions.+-- @O(size)@ where @size@ is the dimension of the vector.++blowUpSparseVec :: (Integral i) => b -> i -> [(i,b)] -> [b] blowUpSparseVec zero n l = aux 1 l- where aux i [] | i > n = []- | otherwise = zero : aux (i+1) []- aux i ((j,b):l) | i <= n && j == i = b : aux (succ i) l- aux i ((j,b):l) | i <= n && j >= i = zero : aux (succ i) ((j,b):l)- aux i l = error $ "blowUpSparseVec (n = " ++ show n ++ ") aux i=" ++ show i ++ " j=" ++ show (fst (head l)) ++ " length l = " ++ show (length l)--- __IMPOSSIBLE__+ where aux i [] = List.genericReplicate (n + 1 - i) zero+ aux i l@((j,b):l')+ | i > j || i > n = __IMPOSSIBLE__+ | i == j = b : aux (i + 1) l'+ | otherwise = zero : aux (i + 1) l +-- UNUSED Liang-Ting Chen 2019-07-15+---- Older implementation without replicate.+--blowUpSparseVec' :: (Ord i, Num i, Enum i) => b -> i -> [(i,b)] -> [b]+--blowUpSparseVec' zero n l = aux 1 l+-- where aux i [] | i > n = []+-- | otherwise = zero : aux (i+1) []+-- aux i ((j,b):l) | i <= n && j == i = b : aux (succ i) l+-- aux i ((j,b):l) | i <= n && j >= i = zero : aux (succ i) ((j,b):l)+-- aux i l = __IMPOSSIBLE__+-- -- error $ "blowUpSparseVec (n = " ++ show n ++ ") aux i=" ++ show i ++ " j=" ++ show (fst (head l)) ++ " length l = " ++ show (length l)+-- -- | Converts a matrix to a list of row lists.--toLists :: (Show i, Ord i, Integral i, Enum i, HasZero b) => Matrix i b -> [[b]]-toLists m = blowUpSparseVec emptyRow (rows sz) $- map (\ (i,r) -> (i, blowUpSparseVec zeroElement (cols sz) r)) $ toSparseRows m--- [ [ maybe zeroElement id $ lookup (MIx { row = r, col = c }) (unM m)--- | c <- [1 .. cols sz] ] | r <- [1 .. rows sz] ]- where sz = size m- emptyRow = take (fromIntegral (cols sz)) $ repeat zeroElement+-- @O(size)@ where @size = rows × cols@. -prop_fromLists_toLists :: TM -> Bool-prop_fromLists_toLists m = fromLists (size m) (toLists m) == m+toLists :: (Integral i, HasZero b) => Matrix i b -> [[b]]+toLists m@(Matrix size@(Size nrows ncols) _) =+ blowUpSparseVec emptyRow nrows $+ map (second (blowUpSparseVec zeroElement ncols)) $ toSparseRows m+ where+ emptyRow = List.genericReplicate ncols zeroElement --------------------------------------------------------------------------- Combining and querying matrices+-- * Combining and querying matrices+------------------------------------------------------------------------ --- | The size of a matrix.+-- | Returns 'Just b' iff it is a 1x1 matrix with just one entry 'b'.+-- @O(1)@. -{--size :: Ix i => Matrix i b -> Size i-size m = Size { rows = row b, cols = col b }- where (_, b) = bounds $ unM m--}+isSingleton :: (Eq i, Num i, HasZero b) => Matrix i b -> Maybe b+isSingleton (Matrix (Size 1 1) [(_,b)]) = Just b+isSingleton (Matrix (Size 1 1) [] ) = Just zeroElement+isSingleton (Matrix (Size 1 1) _ ) = __IMPOSSIBLE__+isSingleton _ = Nothing -prop_size :: TM -> Bool-prop_size m = sizeInvariant (size m)+-- | @'diagonal' m@ extracts the diagonal of @m@.+--+-- For non-square matrices, the length of the diagonal is+-- the minimum of the dimensions of the matrix. +class Diagonal m e | m -> e where+ diagonal :: m -> [e] -prop_size_fromIndexList :: Size Int -> Bool-prop_size_fromIndexList sz =- size (fromIndexList sz ([] :: [(MIx Int, Integer)])) == sz+-- | Diagonal of sparse matrix.+--+-- @O(n)@ where @n@ is the number of non-zero elements in the matrix. --- | 'True' iff the matrix is square.+instance (Integral i, HasZero b) => Diagonal (Matrix i b) b where+ diagonal (Matrix (Size r c) m) =+ blowUpSparseVec zeroElement (min r c) $+ mapMaybe (\ (MIx i j, b) -> if i == j then Just (i, b) else Nothing) m -square :: Ix i => Matrix i b -> Bool-square m = rows (size m) == cols (size m)+-- | Apply the given function to the non-zero diagonal elements of a matrix.+--+-- @O(n)@ where @n@ is the number of non-zero elements in the matrix. --- | Returns 'True' iff the matrix is empty.+mapDiagonalNonZeros :: (Integral i, HasZero a) => (a -> a) -> Matrix i a -> Matrix i a+mapDiagonalNonZeros f = mapNonZeros \ r c -> applyWhen (r == c) f -isEmpty :: (Num i, Ix i) => Matrix i b -> Bool-isEmpty m = rows sz <= 0 || cols sz <= 0- where sz = size m+-- | Transposable things. --- | Returns 'Just b' iff it is a 1x1 matrix with just one entry 'b'.+class Transpose a where+ transpose :: a -> a -isSingleton :: (Num i, Ix i) => Matrix i b -> Maybe b-isSingleton m = if (rows sz == 1 || cols sz == 1) then- case unM m of- [(_,b)] -> Just b- _ -> __IMPOSSIBLE__- else Nothing- where sz = size m+-- | Size of transposed matrix. --- | Transposition-transposeSize (Size { rows = n, cols = m }) = Size { rows = m, cols = n }-transpose m = M { size = transposeSize (size m)- , unM = List.sortBy (\ (i,a) (j,b) -> compare i j) $- map (\(MIx i j, b) -> (MIx j i, b)) $ unM m }+instance Transpose (Size i) where+ transpose (Size n m) = Size m n --- | @'add' (+) m1 m2@ adds @m1@ and @m2@. Uses @(+)@ to add values.+-- | Transposing coordinates.++instance Transpose (MIx i) where+ transpose (MIx i j) = MIx j i++-- | Matrix transposition. ----- Precondition: @'size' m1 == 'size' m2@.+-- @O(n log n)@ where @n@ is the number of non-zero elements in the matrix. -add :: (Ord i) => (a -> a -> a) -> Matrix i a -> Matrix i a -> Matrix i a-add plus m1 m2 = M (size m1) $ mergeAssocWith plus (unM m1) (unM m2)+instance Ord i => Transpose (Matrix i b) where+ transpose (Matrix size m) =+ Matrix (transpose size) $+ List.sortBy (compare `on` fst) $+ map (first transpose) m --- | assoc list union-mergeAssocWith :: (Ord i) => (a -> a -> a) -> [(i,a)] -> [(i,a)] -> [(i,a)]-mergeAssocWith f [] m = m-mergeAssocWith f l [] = l-mergeAssocWith f l@((i,a):l') m@((j,b):m')- | i < j = (i,a) : mergeAssocWith f l' m- | i > j = (j,b) : mergeAssocWith f l m'- | otherwise = (i, f a b) : mergeAssocWith f l' m'+-- | Apply the given function to all non-zero elements.+--+-- @O(n)@ where @n@ is the number of non-zero elements in the matrix. +mapNonZeros :: forall i a b. HasZero b => (i -> i -> a -> b) -> Matrix i a -> Matrix i b+mapNonZeros f (Matrix size m) = Matrix size $ mapMaybe f' m+ where+ f' :: (MIx i, a) -> Maybe (MIx i, b)+ f' (i@(MIx r c), a) = if b == zeroElement then Nothing else Just (i, b)+ where+ b = f r c a++-- | General pointwise combination function for association lists.+-- @O(n1 + n2)@ where @ni@ is the number of non-zero element in matrix @i@.+--+-- In @zipAssocWith fs gs f g h l l'@,+--+-- @fs@ is possibly more efficient version of+-- @'mapMaybe' (\ (i, a) -> (i,) <$> f a)@, and same for @gs@ and @g@.++zipAssocWith :: (Ord i)+ => ([(i,a)] -> [(i,c)]) -- ^ Only left map remaining.+ -> ([(i,b)] -> [(i,c)]) -- ^ Only right map remaining.+ -> (a -> Maybe c) -- ^ Element only present in left map.+ -> (b -> Maybe c) -- ^ Element only present in right map.+ -> (a -> b -> Maybe c) -- ^ Element present in both maps.+ -> [(i,a)] -> [(i,b)] -> [(i,c)]+zipAssocWith fs gs f g h = merge+ where+ merge m1 [] = mapMaybe (\ (i, a) -> (i,) <$> f a) m1+ merge [] m2 = mapMaybe (\ (i, b) -> (i,) <$> g b) m2+ merge m1@((i,a):m1') m2@((j,b):m2') =+ case compare i j of+ LT -> mcons ((i,) <$> f a) $ merge m1' m2+ GT -> mcons ((j,) <$> g b) $ merge m1 m2'+ EQ -> mcons ((i,) <$> h a b) $ merge m1' m2'++-- | Instance of 'zipAssocWith' which keeps longer assoc lists.+-- @O(n1 + n2)@.++unionAssocWith :: (Ord i)+ => (a -> Maybe c) -- ^ Element only present in left map.+ -> (b -> Maybe c) -- ^ Element only present in right map.+ -> (a -> b -> Maybe c) -- ^ Element present in both maps.+ -> [(i,a)] -> [(i,b)] -> [(i,c)]+unionAssocWith f g h = zipAssocWith (map_ f) (map_ g) f g h+ where+ map_ f = mapMaybe (\ (i, a) -> (i,) <$> f a)++-- | General pointwise combination function for sparse matrices.+-- @O(n1 + n2)@.++zipMatrices :: forall a b c i . (Ord i)+ => (a -> c) -- ^ Element only present in left matrix.+ -> (b -> c) -- ^ Element only present in right matrix.+ -> (a -> b -> c) -- ^ Element present in both matrices.+ -> (c -> Bool) -- ^ Result counts as zero?+ -> Matrix i a -> Matrix i b -> Matrix i c+zipMatrices f g h zero m1 m2 = Matrix (supSize m1 m2) $+ unionAssocWith (drop0 . f) (drop0 . g) (\ a -> drop0 . h a) (unM m1) (unM m2)+ where+ drop0 = filterMaybe (not . zero)++-- | @'add' (+) m1 m2@ adds @m1@ and @m2@, using @(+)@ to add values.+-- @O(n1 + n2)@.+--+-- Returns a matrix of size @'supSize' m1 m2@.++add :: (Ord i, HasZero a) => (a -> a -> a) -> Matrix i a -> Matrix i a -> Matrix i a+add plus = zipMatrices id id plus (== zeroElement)+ -- | @'intersectWith' f m1 m2@ build the pointwise conjunction @m1@ and @m2@. -- Uses @f@ to combine non-zero values.+-- @O(n1 + n2)@. ----- Precondition: @'size' m1 == 'size' m2@.+-- Returns a matrix of size @infSize m1 m2@. intersectWith :: (Ord i) => (a -> a -> a) -> Matrix i a -> Matrix i a -> Matrix i a-intersectWith f m1 m2 = M (size m1) $ interAssocWith f (unM m1) (unM m2)+intersectWith f m1 m2 = Matrix (infSize m1 m2) $ interAssocWith f (unM m1) (unM m2) --- | assoc list intersection+-- | Association list intersection.+-- @O(n1 + n2)@.+--+-- @interAssocWith f l l' = { (i, f a b) | (i,a) ∈ l and (i,b) ∈ l' }@+--+-- Used to combine sparse matrices, it might introduce zero elements+-- if @f@ can return zero for non-zero arguments.+ interAssocWith :: (Ord i) => (a -> a -> a) -> [(i,a)] -> [(i,a)] -> [(i,a)] interAssocWith f [] m = [] interAssocWith f l [] = []@@ -309,61 +370,57 @@ | i > j = interAssocWith f l m' | otherwise = (i, f a b) : interAssocWith f l' m' -prop_add sz =- forAll (three (matrix sz :: Gen TM)) $ \(m1, m2, m3) ->- let m' = add (+) m1 m2 in- associative (add (+)) m1 m2 m3 &&- commutative (add (+)) m1 m2 &&- matrixInvariant m' &&- size m' == size m1---- | @'mul' semiring m1 m2@ multiplies @m1@ and @m2@. Uses the--- operations of the semiring @semiring@ to perform the--- multiplication.+-- | @'mul' semiring m1 m2@ multiplies matrices @m1@ and @m2@.+-- Uses the operations of the semiring @semiring@ to perform the+-- multiplication. ----- Precondition: @'cols' ('size' m1) == rows ('size' m2)@.--{- mul A B works as follows:-* turn A into a list of sparse rows and the transposed B as well-* form the crossproduct using the inner vector product to compute els-* the inner vector product is summing up- after intersecting with the muliplication op of the semiring--}+-- @O(n1 + n2 log n2 + Σ(i <= r1) Σ(j <= c2) d(i,j))@ where+-- @r1@ is the number of non-empty rows in @m1@ and+-- @c2@ is the number of non-empty columns in @m2@ and+-- @d(i,j)@ is the bigger one of the following two quantifies:+-- the length of sparse row @i@ in @m1@ and+-- the length of sparse column @j@ in @m2@.+--+-- Given dimensions @m1 : r1 × c1@ and @m2 : r2 × c2@,+-- a matrix of size @r1 × c2@ is returned.+-- It is not necessary that @c1 == r2@, the matrices are implicitly+-- patched with zeros to match up for multiplication.+-- For sparse matrices, this patching is a no-op. -mul :: (Enum i, Num i, Ix i, Eq a)+mul :: (Ix i, Eq a) => Semiring a -> Matrix i a -> Matrix i a -> Matrix i a-mul semiring m1 m2 = M (Size { rows = rows (size m1), cols = cols (size m2) }) $- filter (\ (i,b) -> b /= Semiring.zero semiring) $- [ (MIx i j, foldl (Semiring.add semiring) (Semiring.zero semiring) $- map snd $ interAssocWith (Semiring.mul semiring) v w)+mul semiring m1 m2 = Matrix (Size { rows = rows (size m1), cols = cols (size m2) }) $+ [ (MIx i j, b) | (i,v) <- toSparseRows m1- , (j,w) <- toSparseRows $ transpose m2 ]--prop_mul sz =- sized $ \n -> resize (n `div` 2) $- forAll (two natural) $ \(c2, c3) ->- forAll (matrix sz :: Gen TM) $ \m1 ->- forAll (matrix (Size { rows = cols sz, cols = c2 })) $ \m2 ->- forAll (matrix (Size { rows = c2, cols = c3 })) $ \m3 ->- let m' = mult m1 m2 in- associative mult m1 m2 m3 &&- matrixInvariant m' &&- size m' == Size { rows = rows sz, cols = c2 }- where mult = mul Semiring.integerSemiring---- | @'diagonal' m@ extracts the diagonal of @m@.------ Precondition: @'square' m@.--diagonal :: (Show i, Enum i, Num i, Ix i, HasZero b) => Matrix i b -> Array i b-diagonal m = listArray (1, rows sz) $ blowUpSparseVec zeroElement (rows sz) $- map (\ ((MIx i j),b) -> (i,b)) $ filter (\ ((MIx i j),b) -> i==j) (unM m)- where sz = size m+ , (j,w) <- toSparseRows $ transpose m2+ , let b = inner v w+ , b /= zero+ ]+ where+ zero = Semiring.zero semiring+ plus = Semiring.add semiring+ times = Semiring.mul semiring+ inner v w = List.foldl' plus zero $+ map snd $ interAssocWith times v w -prop_diagonal =- forAll natural $ \n ->- forAll (matrix (Size n n) :: Gen TM) $ \m ->- bounds (diagonal m) == (1, n)+-- | Pointwise comparison.+-- Only matrices with the same dimension are comparable.+instance (Ord i, PartialOrd a) => PartialOrd (Matrix i a) where+ comparable m n+ | size m /= size n = POAny+ | otherwise = Fold.fold $+ zipMatrices onlym onlyn both trivial m n+ where+ -- If an element is only in @m@, then its 'Unknown' in @n@+ -- so it gotten better at best, in any case, not worse.+ onlym o = POGT+ -- If an element is only in @n@, then its 'Unknown' in @m@+ -- so we have strictly less information.+ onlyn o = POLT+ both = comparable+ -- The zero element of the result sparse matrix is the+ -- neutral element of the monoid.+ trivial = (== mempty) ------------------------------------------------------------------------ -- Modifying matrices@@ -376,14 +433,6 @@ addColumn x m | x == zeroElement = m { size = (size m) { cols = cols (size m) + 1 }} | otherwise = __IMPOSSIBLE__ -prop_addColumn :: TM -> Bool-prop_addColumn m =- matrixInvariant m'- &&- map init (toLists m') == toLists m- where- m' = addColumn zeroElement m- -- | @'addRow' x m@ adds a new row to @m@, after the rows already -- existing in the matrix. All elements in the new row get set to @x@. @@ -391,42 +440,31 @@ addRow x m | x == zeroElement = m { size = (size m) { rows = rows (size m) + 1 }} | otherwise = __IMPOSSIBLE__ -prop_addRow :: TM -> Bool-prop_addRow m =- matrixInvariant m'- &&- init (toLists m') == toLists m- where- m' = addRow zeroElement m- --------------------------------------------------------------------------- Zipping (assumes non-empty matrices)--{- use mergeAssocList or interAssocList instead-zipWith :: (a -> b -> c) ->- Matrix Integer a -> Matrix Integer b -> Matrix Integer c-zipWith f m1 m2- = fromLists (Size { rows = toInteger $ length ll,- cols = toInteger $ length (head ll) }) ll- where ll = List.zipWith (List.zipWith f) (toLists m1) (toLists m2)--}-+-- * Printing --------------------------------------------------------------------------- All tests -tests :: IO Bool-tests = runTests "Agda.Termination.Matrix"- [ quickCheck' prop_Arbitrary_Size- , quickCheck' prop_Arbitrary_Matrix- , quickCheck' prop_Arbitrary_MIx- , quickCheck' prop_fromIndexList- , quickCheck' prop_matrix- , quickCheck' prop_size- , quickCheck' prop_size_fromIndexList- , quickCheck' prop_fromLists_toLists- , quickCheck' prop_add- , quickCheck' prop_mul- , quickCheck' prop_diagonal- , quickCheck' prop_addColumn- , quickCheck' prop_addRow- ]+instance (Integral i, HasZero b, Show i, Show b) => Show (Matrix i b) where+ showsPrec _ m =+ showString "Agda.Termination.SparseMatrix.fromLists " . shows (size m) .+ showString " " . shows (toLists m)++instance (Integral i, HasZero b, Pretty b) =>+ Pretty (Matrix i b) where+-- pretty = vcat . map (hsep . map pretty) . toLists+ pretty = vcat+ . map text+ . lines+ . Boxes.render+ . Boxes.hsep 1 Boxes.right+ . map ( Boxes.vcat Boxes.right+ . map ( Boxes.alignHoriz Boxes.right 4+ . Boxes.text . render . pretty+ )+ )+ . toLists+ . transpose+-- ADAPTED FROM:+-- http://www.tedreed.info/programming/2012/06/02/how-to-use-textprettyprintboxes/+-- print_table :: [[String]] -> IO ()+-- print_table rows = printBox $ hsep 2 left (map (vcat left . map text) (transpose rows))
@@ -1,807 +1,1602 @@-{-# LANGUAGE CPP, PatternGuards, ImplicitParams #-}--{- Checking for Structural recursion- Authors: Andreas Abel, Nils Anders Danielsson, Ulf Norell,- Karl Mehltretter and others- Created: 2007-05-28- Source : TypeCheck.Rules.Decl- -}--module Agda.Termination.TermCheck- ( termDecls- , Result, DeBruijnPat- ) where--import Control.Applicative-import Control.Monad.Error-import Data.List as List-import qualified Data.Map as Map-import Data.Map (Map)-import qualified Data.Maybe as Maybe-import qualified Data.Set as Set-import Data.Set (Set)--import qualified Agda.Syntax.Abstract as A-import Agda.Syntax.Internal-import qualified Agda.Syntax.Info as Info-import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Literal (Literal(LitString))--import Agda.Termination.CallGraph as Term-import qualified Agda.Termination.SparseMatrix as Term-import qualified Agda.Termination.Termination as Term--import Agda.TypeChecking.Monad-import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Reduce (reduce, normalise, instantiate, instantiateFull)-import Agda.TypeChecking.Records (isRecordConstructor)-import Agda.TypeChecking.Rules.Builtin.Coinduction-import Agda.TypeChecking.Rules.Term (isType_)-import Agda.TypeChecking.Substitute (abstract,raise,substs)-import Agda.TypeChecking.Telescope-import Agda.TypeChecking.EtaContract-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Monad.Signature (isProjection)-import Agda.TypeChecking.Primitive (constructorForm)-import Agda.TypeChecking.Level (reallyUnLevelView)-import Agda.TypeChecking.Substitute--import qualified Agda.Interaction.Highlighting.Range as R-import Agda.Interaction.Options--import Agda.Utils.Size-import Agda.Utils.Monad (thread, (<$>), ifM)--#include "../undefined.h"-import Agda.Utils.Impossible--type Calls = Term.CallGraph (Set CallInfo)-type MutualNames = [QName]---- | The result of termination checking a module.--type Result = [TerminationError]---- | Termination check a sequence of declarations.-termDecls :: [A.Declaration] -> TCM Result-termDecls ds = fmap concat $ mapM termDecl ds---- | Termination check a single declaration.-termDecl :: A.Declaration -> TCM Result-termDecl (A.ScopedDecl scope ds) = do- setScope scope- termDecls ds-termDecl d = case d of- A.Axiom {} -> return []- A.Field {} -> return []- A.Primitive {} -> return []- A.Mutual _ ds- | [A.RecSig{}, A.RecDef _ r _ _ _ rds] <- unscopeDefs ds- -> do- let m = mnameFromList $ qnameToList r- setScopeFromDefs ds- termSection m rds- A.Mutual i ds -> termMutual i ds- A.Section _ x _ ds -> termSection x ds- A.Apply {} -> return []- A.Import {} -> return []- A.Pragma {} -> return []- A.Open {} -> return []- -- open is just an artifact from the concrete syntax- A.ScopedDecl{} -> __IMPOSSIBLE__- -- taken care of above- -- These should all be wrapped in mutual blocks- A.FunDef{} -> __IMPOSSIBLE__- A.DataSig{} -> __IMPOSSIBLE__- A.DataDef{} -> __IMPOSSIBLE__- A.RecSig{} -> __IMPOSSIBLE__- A.RecDef{} -> __IMPOSSIBLE__- where- setScopeFromDefs = mapM_ setScopeFromDef- setScopeFromDef (A.ScopedDecl scope d) = setScope scope- setScopeFromDef _ = return ()-- unscopeDefs = concatMap unscopeDef-- unscopeDef (A.ScopedDecl _ ds) = unscopeDefs ds- unscopeDef d = [d]--collectCalls :: (a -> TCM Calls) -> [a] -> TCM Calls-collectCalls f [] = return Term.empty-collectCalls f (a : as) = do c1 <- f a- c2 <- collectCalls f as- return (c1 `Term.union` c2)---- | Termination check a bunch of mutually inductive recursive definitions.-termMutual :: Info.DeclInfo -> [A.Declaration] -> TCM Result-termMutual i ds = if names == [] then return [] else- do -- get list of sets of mutually defined names from the TCM- -- this includes local and auxiliary functions introduced- -- during type-checking-- cutoff <- optTerminationDepth <$> pragmaOptions- let ?cutoff = cutoff-- reportSLn "term.top" 10 $ "Termination checking " ++ show names ++- " with cutoff=" ++ show cutoff ++ "..."- mutualBlock <- findMutualBlock (head names)- let allNames = Set.elems mutualBlock-- -- collect all recursive calls in the block- let collect use = collectCalls (termDef use allNames) allNames-- -- Get the name of size suc (if sized types are enabled)- suc <- sizeSuc-- -- The name of sharp (if available).- sharp <- fmap nameOfSharp <$> coinductionKit-- guardingTypeConstructors <-- optGuardingTypeConstructors <$> pragmaOptions-- -- first try to termination check ignoring the dot patterns- let conf = DBPConf- { useDotPatterns = False- , guardingTypeConstructors = guardingTypeConstructors- , withSizeSuc = suc- , sharp = sharp- }- calls1 <- collect conf{ useDotPatterns = False }- reportS "term.lex" 20 $ unlines- [ "Calls (no dot patterns): " ++ show calls1- ]- reportSDoc "term.behaviours" 20 $ vcat- [ text "Recursion behaviours (no dot patterns):"- , nest 2 $ return $ Term.prettyBehaviour (Term.complete calls1)- ]- reportSDoc "term.matrices" 30 $ vcat- [ text "Call matrices (no dot patterns):"- , nest 2 $ pretty $ Term.complete calls1- ]- r <- do let r = Term.terminates calls1- case r of- Right _ -> return r- Left _ -> do- -- Try again, but include the dot patterns this time.- calls2 <- collect conf{ useDotPatterns = True }- reportS "term.lex" 20 $ unlines- [ "Calls (dot patterns): " ++ show calls2- ]- reportSDoc "term.behaviours" 20 $ vcat- [ text "Recursion behaviours (dot patterns):"- , nest 2 $ return $- Term.prettyBehaviour (Term.complete calls2)- ]- reportSDoc "term.matrices" 30 $ vcat- [ text "Call matrices (dot patterns):"- , nest 2 $ pretty $ Term.complete calls2- ]- return $ Term.terminates calls2- case r of- Left calls -> do- return [TerminationError- { termErrFunctions = names- -- TODO: This could be changed to allNames.- , termErrCalls = Set.toList calls- }- ]- Right _ -> do- reportSLn "term.warn.yes" 2- (show (names) ++ " does termination check")- return []- where- getName (A.FunDef i x cs) = [x]- getName (A.RecDef _ _ _ _ _ ds) = concatMap getName ds- getName (A.Mutual _ ds) = concatMap getName ds- getName (A.Section _ _ _ ds) = concatMap getName ds- getName (A.ScopedDecl _ ds) = concatMap getName ds- getName _ = []-- -- the mutual names mentioned in the abstract syntax- names = concatMap getName ds-- concat' :: Ord a => [Set a] -> [a]- concat' = Set.toList . Set.unions---- | Termination check a module.-termSection :: ModuleName -> [A.Declaration] -> TCM Result-termSection x ds = do- tel <- lookupSection x- reportSDoc "term.section" 10 $- sep [ text "termination checking section"- , prettyTCM x- , prettyTCM tel- ]- withCurrentModule x $ addCtxTel tel $ termDecls ds----- | Termination check a definition by pattern matching.-termDef :: DBPConf -> MutualNames -> QName -> TCM Calls-termDef use names name = do- -- Retrieve definition- def <- getConstInfo name- -- returns a TC.Monad.Base.Definition-- reportSDoc "term.def.fun" 5 $- sep [ text "termination checking body of" <+> prettyTCM name- , nest 2 $ text ":" <+> (prettyTCM $ defType def)- ]- case (theDef def) of- Function{ funClauses = cls } ->- collectCalls (termClause use names name) cls- _ -> return Term.empty----- | Termination check clauses-{- Precondition: Each clause headed by the same number of patterns-- For instance-- f x (cons y nil) = g x y-- Clause- [VarP "x", ConP "List.cons" [VarP "y", ConP "List.nil" []]]- Bind (Abs { absName = "x"- , absBody = Bind (Abs { absName = "y"- , absBody = Def "g" [ Var 1 []- , Var 0 []]})})-- Outline:- - create "De Bruijn pattern"- - collect recursive calls- - going under a binder, lift de Bruijn pattern- - compare arguments of recursive call to pattern---}--data DeBruijnPat = VarDBP Nat -- de Bruijn Index- | ConDBP QName [DeBruijnPat]- -- ^ The name refers to either an ordinary- -- constructor or the successor function on sized- -- types.- | LitDBP Literal--instance PrettyTCM DeBruijnPat where- prettyTCM (VarDBP i) = text $ show i- prettyTCM (ConDBP c ps) = parens (prettyTCM c <+> hsep (map prettyTCM ps))- prettyTCM (LitDBP l) = prettyTCM l--unusedVar :: DeBruijnPat-unusedVar = LitDBP (LitString noRange "term.unused.pat.var")--adjIndexDBP :: (Nat -> Nat) -> DeBruijnPat -> DeBruijnPat-adjIndexDBP f (VarDBP i) = VarDBP (f i)-adjIndexDBP f (ConDBP c args) = ConDBP c (map (adjIndexDBP f) args)-adjIndexDBP f (LitDBP l) = LitDBP l--{- | liftDeBruijnPat p n-- increases each de Bruijn index in p by n.- Needed when going under a binder during analysis of a term.--}--liftDBP :: DeBruijnPat -> DeBruijnPat-liftDBP = adjIndexDBP (1+)--{- | Configuration parameters to termination checker.--}-data DBPConf = DBPConf { useDotPatterns :: Bool- , guardingTypeConstructors :: Bool- -- ^ Do we assume that record and data type- -- constructors preserve guardedness?- , withSizeSuc :: Maybe QName- , sharp :: Maybe QName- -- ^ The name of the sharp constructor, if- -- any.- }--{- | Convert a term (from a dot pattern) to a DeBruijn pattern.--}--termToDBP :: DBPConf -> Term -> TCM DeBruijnPat-termToDBP conf t- | not $ useDotPatterns conf = return $ unusedVar- | otherwise = do- t <- stripProjections =<< constructorForm t- case t of- Var i [] -> return $ VarDBP i- Con c args -> ConDBP c <$> mapM (termToDBP conf . unArg) args- Def s [arg]- | Just s == withSizeSuc conf -> ConDBP s . (:[]) <$> termToDBP conf (unArg arg)- Lit l -> return $ LitDBP l- _ -> return unusedVar---- | Removes coconstructors from a deBruijn pattern.-stripCoConstructors :: DBPConf -> DeBruijnPat -> TCM DeBruijnPat-stripCoConstructors conf p = case p of- VarDBP _ -> return p- LitDBP _ -> return p- ConDBP c args -> do- ind <- if withSizeSuc conf == Just c then- return Inductive- else- whatInduction c- case ind of- Inductive -> ConDBP c <$> mapM (stripCoConstructors conf) args- CoInductive -> return unusedVar--{- | stripBind i p b = Just (i', dbp, b')-- converts a pattern into a de Bruijn pattern-- i is the next free de Bruijn level before consumption of p- i' is the next free de Bruijn level after consumption of p-- if the clause has no body (b = NoBody), Nothing is returned---}-stripBind :: DBPConf -> Nat -> Pattern -> ClauseBody -> TCM (Maybe (Nat, DeBruijnPat, ClauseBody))-stripBind _ _ _ NoBody = return Nothing-stripBind conf i (VarP x) (Bind b) = return $ Just (i - 1, VarDBP i, absBody b)-stripBind conf i (VarP x) (Body b) = __IMPOSSIBLE__-stripBind conf i (DotP t) (Bind b) = do- t <- termToDBP conf t- return $ Just (i - 1, t, absBody b)-stripBind conf i (DotP _) (Body b) = __IMPOSSIBLE__-stripBind conf i (LitP l) b = return $ Just (i, LitDBP l, b)-stripBind conf i (ConP c _ args) b = do- r <- stripBinds conf i (map unArg args) b- case r of- Just (i', dbps, b') -> return $ Just (i', ConDBP c dbps, b')- _ -> return Nothing--{- | stripBinds i ps b = Just (i', dbps, b')-- i is the next free de Bruijn level before consumption of ps- i' is the next free de Bruijn level after consumption of ps--}-stripBinds :: DBPConf -> Nat -> [Pattern] -> ClauseBody -> TCM (Maybe (Nat, [DeBruijnPat], ClauseBody))-stripBinds use i [] b = return $ Just (i, [], b)-stripBinds use i (p:ps) b = do- r1 <- stripBind use i p b- case r1 of- Just (i1, dbp, b1) -> do- r2 <- stripBinds use i1 ps b1- case r2 of- Just (i2, dbps, b2) -> return $ Just (i2, dbp:dbps, b2)- Nothing -> return Nothing- Nothing -> return Nothing---- | Extract recursive calls from one clause.-termClause :: DBPConf -> MutualNames -> QName -> Clause -> TCM Calls-termClause use names name (Clause { clauseTel = tel- , clausePerm = perm- , clausePats = argPats'- , clauseBody = body }) =- addCtxTel tel $ do- argPats' <- normalise argPats'- -- The termination checker doesn't know about reordered telescopes- let argPats = substs (renamingR perm) argPats'- dbs <- stripBinds use (nVars - 1) (map unArg argPats) body- case dbs of- Nothing -> return Term.empty- Just (-1, dbpats, Body t) -> do- dbpats <- mapM (stripCoConstructors use) dbpats- termTerm use names name dbpats t- -- note: convert dB levels into dB indices- Just (n, dbpats, Body t) -> internalError $ "termClause: misscalculated number of vars: guess=" ++ show nVars ++ ", real=" ++ show (nVars - 1 - n)- Just (n, dbpats, b) -> internalError $ "termClause: not a Body" -- ++ show b- where- nVars = boundVars body- boundVars (Bind b) = 1 + boundVars (absBody b)- boundVars NoBody = 0- boundVars (Body _) = 0---- | Extract recursive calls from a term.-termTerm :: DBPConf -> MutualNames -> QName -> [DeBruijnPat] -> Term -> TCM Calls-termTerm conf names f pats0 t0 = do- cutoff <- optTerminationDepth <$> pragmaOptions- let ?cutoff = cutoff- do- reportSDoc "term.check.clause" 6- (sep [ text "termination checking clause of" <+> prettyTCM f- , nest 2 $ text "lhs:" <+> hsep (map prettyTCM pats0)- , nest 2 $ text "rhs:" <+> prettyTCM t0- ])- loop pats0 Term.le t0- where- Just fInd = toInteger <$> List.elemIndex f names-- -- sorts can contain arb. terms of type Nat,- -- so look for recursive calls also- -- in sorts. Ideally, Sort would not be its own datatype but just- -- a subgrammar of Term, then we would not need this boilerplate.- loopSort :: (?cutoff :: Int) => [DeBruijnPat] -> Sort -> TCM Calls- loopSort pats s = do- case s of- Type (Max []) -> return Term.empty- Type (Max [ClosedLevel _]) -> return Term.empty- Type t -> loop pats Term.unknown (Level t)- Prop -> return Term.empty- Inf -> return Term.empty- DLub s1 (NoAbs x s2) -> Term.union <$> loopSort pats s1 <*> loopSort pats s2- DLub s1 (Abs x s2) -> liftM2 Term.union- (loopSort pats s1)- (addCtxString x __IMPOSSIBLE__ $ loopSort (map liftDBP pats) s2)-- loopType :: (?cutoff :: Int) => [DeBruijnPat] -> Order -> Type -> TCM Calls- loopType pats guarded (El s t) = liftM2 Term.union- (loopSort pats s)- (loop pats guarded t)-- loop- :: (?cutoff :: Int)- => [DeBruijnPat] -- ^ Parameters of calling function as patterns.- -> Order -- ^ Guardedness status of @Term@.- -> Term -- ^ Part of function body from which calls are to be extracted.- -> TCM Calls- loop pats guarded t = do- t <- instantiate t -- instantiate top-level MetaVar- suc <- sizeSuc-- -- Handles constructor applications.- let constructor- :: QName- -- ^ Constructor name.- -> Induction- -- ^ Should the constructor be treated as- -- inductive or coinductive?- -> [(Arg Term, Bool)]- -- ^ All the arguments, and for every- -- argument a boolean which is 'True' iff the- -- argument should be viewed as preserving- -- guardedness.- -> TCM Calls- constructor c ind args = collectCalls loopArg args- where- loopArg (arg , preserves) = do- loop pats g' (unArg arg)- where g' = case (preserves, ind) of- (True, Inductive) -> guarded- (True, CoInductive) -> Term.lt .*. guarded- (False, _) -> Term.unknown-- -- Handles function applications @g args0@.- function :: QName -> [Arg Term] -> TCM Calls- function g args0 = do- let args1 = map unArg args0- args2 <- mapM instantiateFull args1-- -- We have to reduce constructors in case they're reexported.- let reduceCon (Con c vs) = (`apply` vs) <$> reduce (Con c []) -- make sure we don't reduce the arguments- reduceCon t = return t- args2 <- mapM reduceCon args2- args <- mapM etaContract args2-- -- If the function is a projection, then preserve guardedness- -- for its principal argument.- isProj <- isProjection g- let unguards = repeat Term.unknown- let guards = maybe unguards -- not a proj. ==> unguarded- (\ _ -> guarded : unguards)- -- proj. => preserve g. of princ. arg. (counting starts with 1)- isProj- -- collect calls in the arguments of this call- calls <- collectCalls (uncurry (loop pats)) (zip guards args)- -- calls <- collectCalls (loop pats Term.unknown) args--- reportSDoc "term.found.call" 20- (sep [ text "found call from" <+> prettyTCM f- , nest 2 $ text "to" <+> prettyTCM g- ])-- -- insert this call into the call list- case List.elemIndex g names of-- -- call leads outside the mutual block and can be ignored- Nothing -> return calls-- -- call is to one of the mutally recursive functions- Just gInd' -> do-- matrix <- compareArgs suc pats args- let (nrows, ncols, matrix') = addGuardedness guarded- (genericLength args) -- number of rows- (genericLength pats) -- number of cols- matrix--- reportSDoc "term.kept.call" 5- (sep [ text "kept call from" <+> prettyTCM f- <+> hsep (map prettyTCM pats)- , nest 2 $ text "to" <+> prettyTCM g <+>- hsep (map (parens . prettyTCM) args)- , nest 2 $ text ("call matrix (with guardedness): " ++ show matrix')- ])-- doc <- prettyTCM (Def g args0)- return- (Term.insert- (Term.Call { Term.source = fInd- , Term.target = toInteger gInd'- , Term.cm = makeCM ncols nrows matrix'- })- (Set.singleton- (CallInfo { callInfoRange = getRange g- , callInfoCall = show doc- }))- calls)--- case t of-- -- Constructed value.- Con c args- | Just c == sharp conf ->- constructor c CoInductive $ zip args (repeat True)- | otherwise ->- constructor c Inductive $ zip args (repeat True)-- Def g args0- | guardingTypeConstructors conf -> do- gDef <- theDef <$> getConstInfo g- case gDef of- Datatype {dataArgOccurrences = occs} -> con occs- Record {recArgOccurrences = occs} -> con occs- _ -> fun- | otherwise -> fun- where- -- Data or record type constructor.- con occs =- constructor g Inductive $ -- guardedness preserving- -- constructor g CoInductive $ -- guarding! (Andreas, 2011-04-10) -- does not work, might lead to infinite unfolding in eq. checking (Ripley!)- zip args0 (map preserves occs ++ repeat False)- where- preserves Positive = True- preserves Negative = False- preserves Unused = True-- -- Call to defined function.- fun = function g args0-- -- Abstraction. Preserves guardedness.- Lam h (Abs x t) -> addCtxString x (Arg { argHiding = h- , argRelevance = __IMPOSSIBLE__- , unArg = __IMPOSSIBLE__- }) $- loop (map liftDBP pats) guarded t- Lam h (NoAbs _ t) -> loop pats guarded t-- -- Neutral term. Destroys guardedness.- Var i args -> collectCalls (loop pats Term.unknown) (map unArg args)-- -- Dependent function space.- Pi a (Abs x b) ->- do g1 <- loopType pats Term.unknown (unArg a)- g2 <- addCtxString x a $- loopType (map liftDBP pats) piArgumentGuarded b- return $ g1 `Term.union` g2-- -- Non-dependent function space.- Pi a (NoAbs _ b) ->- do g1 <- loopType pats Term.unknown (unArg a)- g2 <- loopType pats piArgumentGuarded b- return $ g1 `Term.union` g2-- -- Literal.- Lit l -> return Term.empty-- -- Sort.- Sort s -> loopSort pats s-- -- Unsolved metas are not considered termination problems, there- -- will be a warning for them anyway.- MetaV x args -> return Term.empty-- -- Erased and not-yet-erased proof.- DontCare t -> loop pats guarded t-- -- Level.- Level l -> loop pats guarded =<< reallyUnLevelView l-- where- -- Should function and Π type constructors be treated as- -- preserving guardedness in their right arguments?- piArgumentGuarded =- if guardingTypeConstructors conf then- guarded -- preserving guardedness- -- Term.lt -- guarding! (Andreas, 2011-04-10) -- SEE ABOVE- else- Term.unknown--{- | compareArgs suc pats ts-- compare a list of de Bruijn patterns (=parameters) @pats@- with a list of arguments @ts@ and create a call maxtrix- with |ts| rows and |pats| columns.-- If sized types are enabled, @suc@ is the name of the size successor.- -}-compareArgs :: (?cutoff :: Int) => Maybe QName -> [DeBruijnPat] -> [Term] -> TCM [[Term.Order]]-compareArgs suc pats ts = mapM (\t -> mapM (compareTerm suc t) pats) ts---- | 'makeCM' turns the result of 'compareArgs' into a proper call matrix-makeCM :: Index -> Index -> [[Term.Order]] -> Term.CallMatrix-makeCM ncols nrows matrix = Term.CallMatrix $- Term.fromLists (Term.Size { Term.rows = nrows- , Term.cols = ncols- })- matrix--{- To turn off guardedness, restore this code.--- | 'addGuardedness' does nothing.-addGuardedness :: Integral n => Order -> n -> n -> [[Term.Order]] -> (n, n, [[Term.Order]])-addGuardedness g nrows ncols m = (nrows, ncols, m)--}---- | 'addGuardedness' adds guardedness flag in the upper left corner (0,0).-addGuardedness :: Integral n => Order -> n -> n -> [[Term.Order]] -> (n, n, [[Term.Order]])-addGuardedness g nrows ncols m =- (nrows + 1, ncols + 1,- (g : genericReplicate ncols Term.unknown) : map (Term.unknown :) m)---- | Stripping off a record constructor is not counted as decrease, in--- contrast to a data constructor.-decreaseFromConstructor :: QName -> TCM Order-decreaseFromConstructor c = do- isRC <- isRecordConstructor c- return $ if isRC then Term.le else Term.lt--increaseFromConstructor :: (?cutoff :: Int) => QName -> TCM Order-increaseFromConstructor c = do- isRC <- isRecordConstructor c- return $ if isRC then Term.le else Term.decr (-1)--{--increaseFromConstructor c = negateOrder <$> decreaseFromConstructor c- where negateOrder (Decr k) = Decr (- k)- negateOrder _ = __IMPOSSIBLE__--}---- | Compute the sub patterns of a 'DeBruijnPat'.-subPatterns :: DeBruijnPat -> [DeBruijnPat]-subPatterns p = case p of- VarDBP _ -> []- ConDBP c ps -> ps ++ concatMap subPatterns ps- LitDBP _ -> []--compareTerm :: (?cutoff :: Int) => Maybe QName -> Term -> DeBruijnPat -> TCM Term.Order-compareTerm suc t p = do- t <- stripAllProjections t- compareTerm' suc t p--{--compareTerm t p = Term.supremum $ compareTerm' t p : map cmp (subPatterns p)- where- cmp p' = (Term..*.) Term.lt (compareTerm' t p')--}---- | Remove projections until a term is no longer a projection.--- Also, remove 'DontCare's.-stripProjections :: Term -> TCM Term-stripProjections (DontCare t) = stripProjections t-stripProjections t@(Def qn ts@(~(r : _))) = do- isProj <- isProjection qn- case isProj of- Just{} | not (null ts) -> stripProjections $ unArg r- _ -> return t-stripProjections t = return t---- | Remove all projections from an algebraic term (not going under binders).-class StripAllProjections a where- stripAllProjections :: a -> TCM a--instance StripAllProjections a => StripAllProjections (Arg a) where- stripAllProjections (Arg h r a) = Arg h r <$> stripAllProjections a--instance StripAllProjections a => StripAllProjections [a] where- stripAllProjections = mapM stripAllProjections--instance StripAllProjections Term where- stripAllProjections t = do- t <- stripProjections t- case t of- Con c ts -> Con c <$> stripAllProjections ts- Def d ts -> Def d <$> stripAllProjections ts- _ -> return t--{---- | Remove all projections from an algebraic term (not going under binders).-stripAllProjections :: Term -> TCM Term-stripAllProjections t = do- t <- stripProjections t- case t of- Con c ts -> Con c <$> mapM stripAllProjections ts- Def d ts -> Def d <$> mapM stripAllProjections ts- _ -> return t--}---- | compareTerm t dbpat--- Precondition: top meta variable resolved-compareTerm' :: (?cutoff :: Int) => Maybe QName -> Term -> DeBruijnPat -> TCM Term.Order-compareTerm' _ (Var i _) p = compareVar i p-compareTerm' suc (DontCare t) p = compareTerm' suc t p-compareTerm' _ (Lit l) (LitDBP l')- | l == l' = return Term.le- | otherwise = return Term.unknown-compareTerm' suc (Lit l) p = do- t <- constructorForm (Lit l)- case t of- Lit _ -> return Term.unknown- _ -> compareTerm' suc t p--- Andreas, 2011-04-19 give subterm priority over matrix order-compareTerm' _ t@Con{} (ConDBP c ps)- | any (isSubTerm t) ps = decreaseFromConstructor c-compareTerm' suc (Con c ts) (ConDBP c' ps)- | c == c' = compareConArgs suc ts ps-compareTerm' suc (Def s ts) (ConDBP s' ps)- | s == s' && Just s == suc = compareConArgs suc ts ps--- new cases for counting constructors / projections--- register also increase-compareTerm' suc (Def s ts) p | Just s == suc = do- os <- mapM (\ t -> compareTerm' suc (unArg t) p) ts- return $ decr (-1) .*. infimum os-{- Andreas 2011-07-07 Projections are now being removed in a preprocess--- projections are size preserving-compareTerm' suc (Def qn ts) p = do- isProj <- isProjection qn- case isProj of- -- strip off projection (n is the number of the record argument, counting starts with 1)- Just n | length ts >= n && n >= 1 ->- compareTerm' suc (unArg (ts !! (n - 1))) p- -- not a projection or underapplied:- _ -> return Term.unknown--}-compareTerm' suc (Con c ts) p = do- os <- mapM (\ t -> compareTerm' suc (unArg t) p) ts- oc <- increaseFromConstructor c- return $ if (null os) then Term.unknown else oc .*. infimum os-compareTerm' suc t p | isSubTerm t p = return Term.le-compareTerm' _ _ _ = return Term.unknown---- TODO: isSubTerm should compute a size difference (Term.Order)-isSubTerm :: Term -> DeBruijnPat -> Bool-isSubTerm t p = equal t p || properSubTerm t p- where- equal (Con c ts) (ConDBP c' ps) =- and $ (c == c')- : (length ts == length ps)- : zipWith equal (map unArg ts) ps- equal (Var i []) (VarDBP j) = i == j- equal (Lit l) (LitDBP l') = l == l'- equal _ _ = False-- properSubTerm t (ConDBP _ ps) = any (isSubTerm t) ps- properSubTerm _ _ = False--compareConArgs :: (?cutoff :: Int) => Maybe QName -> Args -> [DeBruijnPat] -> TCM Term.Order-compareConArgs suc ts ps =- -- we may assume |ps| >= |ts|, otherwise c ps would be of functional type- -- which is impossible- case (length ts, length ps) of- (0,0) -> return Term.le -- c <= c- (0,1) -> return Term.unknown -- c not<= c x- (1,0) -> __IMPOSSIBLE__- (1,1) -> compareTerm' suc (unArg (head ts)) (head ps)- (_,_) -> do -- build "call matrix"- m <- mapM (\t -> mapM (compareTerm' suc (unArg t)) ps) ts- let m2 = makeCM (genericLength ps) (genericLength ts) m- return $ Term.orderMat (Term.mat m2)-{---- if null ts then Term.Le--- else Term.infimum (zipWith compareTerm' (map unArg ts) ps)- foldl (Term..*.) Term.Le (zipWith compareTerm' (map unArg ts) ps)- -- corresponds to taking the size, not the height- -- allows examples like (x, y) < (Succ x, y)--}--compareVar :: (?cutoff :: Int) => Nat -> DeBruijnPat -> TCM Term.Order-compareVar i (VarDBP j) = return $ if i == j then Term.le else Term.unknown-compareVar i (LitDBP _) = return $ Term.unknown-compareVar i (ConDBP c ps) = do- os <- mapM (compareVar i) ps- let o = Term.supremum os- oc <- decreaseFromConstructor c- return $ (Term..*.) oc o++{-# LANGUAGE ImplicitParams #-}+{-# LANGUAGE NondecreasingIndentation #-}++{- Checking for Structural recursion+ Authors: Andreas Abel, Nils Anders Danielsson, Ulf Norell,+ Karl Mehltretter and others+ Created: 2007-05-28+ Source : TypeCheck.Rules.Decl+ -}++module Agda.Termination.TermCheck+ ( termDecl+ , termMutual+ , Result+ ) where++import Prelude hiding ( null, zip, zipWith )++import Control.Applicative ( liftA2 )+import Control.Monad ( (<=<), filterM, forM, forM_, zipWithM )+import Data.Foldable (toList)+import qualified Data.IntMap.Strict as IntMap+import qualified Data.List as List+import qualified Data.Map.Strict as Map+import Data.Monoid hiding ((<>))+import Data.Set (Set)+import qualified Data.Set as Set++import qualified Agda.Syntax.Abstract as A+import Agda.Syntax.Internal as I+import Agda.Syntax.Internal.Pattern as I+import Agda.Syntax.Internal.Generic+import qualified Agda.Syntax.Info as Info+import Agda.Syntax.Position+import Agda.Syntax.Common+import Agda.Syntax.Translation.InternalToAbstract (NamedClause(..))++import Agda.Termination.CutOff+import Agda.Termination.Monad+import Agda.Termination.CallGraph hiding (toList)+import Agda.Termination.CallGraph qualified as CallGraph+import Agda.Termination.CallMatrix hiding (toList)+import Agda.Termination.Order as Order+import Agda.Termination.SparseMatrix qualified as Matrix+import Agda.Termination.Termination (Terminates(..), GuardednessHelps(..), idempotentEndos, terminatesFilter, terminationCounterexample)+import Agda.Termination.RecCheck++import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Functions+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Forcing+import Agda.TypeChecking.Records -- (isRecordConstructor, isInductiveRecord)+import Agda.TypeChecking.Reduce (reduce, normalise, instantiate, instantiateFull, appDefE0)+import Agda.TypeChecking.SizedTypes+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope++import qualified Agda.Benchmarking as Benchmark+import Agda.TypeChecking.Monad.Benchmark (billTo, billPureTo)++import Agda.Interaction.Options++import Agda.Utils.Either+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.ListInf ( pattern (:<) )+import Agda.Utils.ListInf qualified as ListInf+import Agda.Utils.Maybe+import Agda.Utils.Monad -- (mapM', forM', ifM, or2M, and2M)+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Utils.Singleton+import Agda.Utils.Size+-- import Agda.Utils.SmallSet (SmallSet)+import qualified Agda.Utils.SmallSet as SmallSet+import qualified Agda.Utils.VarSet as VarSet+import Agda.Utils.Zip++import Agda.Utils.Impossible++-- | Call graph with call info for composed calls.++type Calls = CallGraph CallPath++-- | The result of termination checking a module.+-- Must be a 'Monoid' and have 'Singleton'.++type Result = [TerminationError]++-- | Entry point: Termination check a single declaration.+--+-- Precondition: 'envMutualBlock' must be set correctly.++termDecl :: A.Declaration -> TCM Result+termDecl d = inTopContext $ termDecl' d+++-- | Termination check a single declaration+-- (without necessarily ignoring @abstract@).++termDecl' :: A.Declaration -> TCM Result+termDecl' = \case+ A.Axiom {} -> return mempty+ A.Field {} -> return mempty+ A.Primitive {} -> return mempty+ A.Mutual _ ds -> termMutual $ getNames ds+ A.Section _ _ _ _ ds -> foldMap termDecl' ds+ -- section structure can be ignored as we are termination checking+ -- definitions lifted to the top-level+ A.Apply {} -> return mempty+ A.Import {} -> return mempty+ A.Pragma {} -> return mempty+ A.Open {} -> return mempty+ A.PatternSynDef {} -> return mempty+ A.UnfoldingDecl{} -> return mempty+ A.Generalize {} -> return mempty+ -- open, pattern synonym and generalize defs are just artifacts from the concrete syntax+ A.ScopedDecl scope ds -> {- withScope_ scope $ -} foldMap termDecl' ds+ -- scope is irrelevant as we are termination checking Syntax.Internal+ A.RecSig{} -> return mempty+ A.RecDef _ x _ _ _ _ _ _ ds -> termMutual [x] <> foldMap termDecl' ds+ -- Andreas, 2022-10-23, issue #5823+ -- Also check record types for termination.+ -- They are unfolded during construction of unique inhabitants of eta-records.+ -- These should all be wrapped in mutual blocks:+ A.FunDef{} -> __IMPOSSIBLE__+ A.DataSig{} -> __IMPOSSIBLE__+ A.DataDef{} -> __IMPOSSIBLE__+ A.UnquoteDecl{} -> __IMPOSSIBLE__+ A.UnquoteDef{} -> __IMPOSSIBLE__+ A.UnquoteData{} -> __IMPOSSIBLE__+ where+ -- The mutual names mentioned in the abstract syntax+ -- for symbols that need to be termination-checked.+ getNames :: Foldable t => t A.Declaration -> [QName]+ getNames = foldMap getName+ getName (A.FunDef i x cs) = [x]+ getName (A.RecDef _ x _ _ _ _ _ _ ds) = x : getNames ds+ getName (A.Mutual _ ds) = getNames ds+ getName (A.Section _ _ _ _ ds) = getNames ds+ getName (A.ScopedDecl _ ds) = getNames ds+ getName (A.UnquoteDecl _ _ xs _) = xs+ getName (A.UnquoteDef _ xs _) = xs+ getName _ = []+++-- | Entry point: Termination check the current mutual block.++termMutual+ :: [QName]+ -- ^ The function names defined in this block on top-level.+ -- (For error-reporting only.)+ -> TCM Result+termMutual names0 = ifNotM (optTerminationCheck <$> pragmaOptions) (return mempty) $ {-else-}+ inTopContext $ do++ -- Get set of mutually defined names from the TCM.+ -- This includes local and auxiliary functions introduced+ -- during type-checking.+ mid <- fromMaybe __IMPOSSIBLE__ <$> viewTC eMutualBlock+ mutualBlock <- lookupMutualBlock mid+ let allNames = Set.filter (not . isAbsurdLambdaName) $+ mutualNames mutualBlock+ names = if null names0 then allNames else Set.fromList names0+ i = mutualInfo mutualBlock++ -- We set the range to avoid panics when printing error messages.+ setCurrentRange i $ do++ -- The following debug statement is part of a test case for Issue+ -- #3590.+ reportSLn "term.mutual.id" 40 $+ "Termination checking mutual block " ++ prettyShow mid+ reportSLn "term.mutual" 10 $ "Termination checking " ++ prettyShow allNames++ -- NO_TERMINATION_CHECK+ if (Info.mutualTerminationCheck i `elem` [ NoTerminationCheck, Terminating ]) then do+ reportSLn "term.warn.yes" 10 $ "Skipping termination check for " ++ prettyShow names+ forM_ allNames $ \ q -> setTerminates q $ Just True -- considered terminating!+ return mempty+ -- NON_TERMINATING+ else if (Info.mutualTerminationCheck i == NonTerminating) then do+ reportSLn "term.warn.yes" 10 $ "Considering as non-terminating: " ++ prettyShow names+ forM_ allNames $ \ q -> setTerminates q $ Just False+ return mempty+ else do+ sccs <- do+ -- Andreas, 2016-10-01 issue #2231+ -- Recursivity checker has to see through abstract definitions!+ ignoreAbstractMode $ do+ billTo [Benchmark.Termination, Benchmark.RecCheck] $ recursive allNames+ -- -- Andreas, 2017-03-24, use positivity info to skip non-recursive functions+ -- skip = ignoreAbstractMode $ forallM allNames $ \ x -> do+ -- null <$> getMutual x+ -- PROBLEMS with test/Succeed/AbstractCoinduction.agda++ -- Trivially terminating (non-recursive)?+ when (null sccs) $+ reportSLn "term.warn.yes" 10 $ "Trivially terminating: " ++ prettyShow names++ -- Actual termination checking needed: go through SCCs.+ concat <$> do+ forM sccs $ \ allNames -> do++ -- Andreas, 2025-05-31, AIM XL, re issue #7906:+ -- Clear previous information about termination to avoid loops in the termination checker.+ forM_ allNames $ \ q -> setTerminates q Nothing++ -- Set the mutual names in the termination environment.+ let namesSCC = Set.filter (`Set.member` allNames) names+ let setNames e = e+ { terMutual = allNames+ , terUserNames = namesSCC+ }+ -- Pre-compute the copattern projection lists and assign node ids, per issue #8596.+ (projectedNameToNode, nodeToName, nameToProjections, projectedNameToMaskArgs) <- buildNodeAndProjectionMaps allNames+ let runTerm cont = runTerDefault $ do+ cutoff <- terGetCutOff+ reportSLn "term.top" 10 $ "Termination checking " ++ prettyShow namesSCC +++ " with cutoff=" ++ show cutoff ++ "..."+ terSetProjectedNameToNode projectedNameToNode $+ terSetNodeToName nodeToName $+ terSetNameToProjections nameToProjections $+ terSetProjectedNameToMaskArgs projectedNameToMaskArgs $+ terLocal setNames cont++ -- New check currently only makes a difference for copatterns and record types.+ -- Since it is slow, only invoke it if+ -- any of the definitions uses copatterns or is a record type.+ ifM (existsM allNames $ \ q -> usesCopatterns q `or2M` (isJust <$> isRecord q))+ -- Then: New check, one after another.+ (runTerm $ forM' allNames $ termFunction)+ -- Else: Old check, all at once.+ (runTerm $ termMutual')++-- | Run the termination checker.+runTerminationCheck ::+ Maybe QName+ -> TerM Calls+ -> TerM (Terminates CallPath)+runTerminationCheck mname collect = do+ -- Use full precision when extracting calls+ let ?cutoff = DontCutOff+ calls <- collect++ nodeToName <- terGetNodeToName+ let filt :: Node -> Bool+ filt = case mname of+ Nothing -> const True+ Just f -> \ n -> IntMap.lookup n nodeToName == Just f++ useGuardedness <- liftTCM guardednessOption+ maxcutoff <- terGetCutOff+ -- Iteratively increase cutoff up to its maximal value.+ let+ loop :: CutOff+ -> Maybe (GuardednessHelps, CallPath)+ -> TerM (Terminates CallPath)+ loop cutoff currentResult = do+ let ?cutoff = cutoff+ reportCalls cutoff filt calls+ r <- billToTerGraph $ terminatesFilter useGuardedness filt calls+ case r of+ Terminates -> return Terminates+ TerminatesNot gh cinfo -> do+ let result = bestResult currentResult (gh, cinfo)+ if cutoff >= maxcutoff then return $ uncurry TerminatesNot result+ else loop (cutoff + 1) (Just result)+ loop 0 Nothing+ where+ bestResult :: Maybe (GuardednessHelps, CallPath) -> (GuardednessHelps, CallPath) -> (GuardednessHelps, CallPath)+ bestResult Nothing r = r+ bestResult (Just (GuardednessHelpsNot, _)) r@(GuardednessHelpsYes, _) = r+ bestResult (Just r0) _ = r0++-- | @termMutual'@ checks all names of the current mutual block,+-- henceforth called @allNames@, for termination.+--+-- @allNames@ is taken from 'Internal' syntax, it contains also+-- the definitions created by the type checker (e.g., with-functions).++termMutual' :: TerM Result+termMutual' = do++ -- collect all recursive calls in the block+ allNames <- terGetMutual+ let collect :: TerM Calls+ collect = forM' allNames termDef++ r <- runTerminationCheck Nothing collect++ -- @names@ is taken from the 'Abstract' syntax, so it contains only+ -- the names the user has declared. This is for error reporting.+ names <- terGetUserNames+ case r of++ TerminatesNot guardednessHelps calls -> do+ mapM_ (`setTerminates` Just False) allNames+ return $ singleton $ terminationError names calls guardednessHelps++ Terminates -> do+ liftTCM $ reportSLn "term.warn.yes" 2 $+ prettyShow (names) ++ " does termination check"+ mapM_ (`setTerminates` Just True) allNames+ return mempty++-- | Smart constructor for 'TerminationError'.+-- Removes 'termErrFunctions' that are not mentioned in 'termErrCalls'.+terminationError :: Set QName -> CallPath -> GuardednessHelps -> TerminationError+terminationError names calls guardednessHelps = TerminationError names' calls' guardednessHelps+ where+ calls' = callInfos calls+ mentioned = map' callInfoTarget calls'+ names' = filter (hasElem mentioned) $ toList names++billToTerGraph :: a -> TerM a+billToTerGraph a = liftTCM $ billPureTo [Benchmark.Termination, Benchmark.Graph] a++-- | @reportCalls@ for debug printing.+--+-- Replays the call graph completion for debugging.++reportCalls :: CutOff -> (Node -> Bool) -> Calls -> TerM ()+reportCalls cutoff filt calls = do+ useGuardedness <- liftTCM guardednessOption+ let ?cutoff = cutoff++ -- We work in TCM exclusively.+ liftTCM $ do++ reportS "term.lex" 20+ [ "Termination depth: " ++ show cutoff+ , "Calls: " ++ prettyShow calls+ ]++ -- Print the whole completion phase.+ verboseS "term.matrices" 40 $ do+ let header s = unlines+ [ replicate n '='+ , replicate k '=' ++ s ++ replicate k' '='+ , replicate n '='+ ]+ where n = 70+ r = n - length s+ k = r `div` 2+ k' = r - k+ let report s cs = reportSDoc "term.matrices" 40 $ vcat+ [ text $ header s+ , nest 2 $ prettyTCM cs+ ]+ cs0 = calls+ step cs = do+ let (new, cs') = completionStep cs0 cs+ report " New call matrices " new+ case terminationCounterexample useGuardedness filt new of+ Terminates | not (null new) -> return $ Right cs'+ _ -> return $ Left ()+ -- return $ if null new then Left () else Right cs'+ report (" Initial call matrices (cutoff: " ++ show cutoff ++ ") ") cs0+ trampolineM step cs0++ -- Print the result of completion.+ let calls' = CallGraph.complete calls+ idems = idempotentEndos calls'+ -- TODO+ -- reportSDoc "term.behaviours" 20 $ vcat+ -- [ text $ "Recursion behaviours (" ++ no ++ "dot patterns):"+ -- , nest 2 $ return $ Term.prettyBehaviour calls'+ -- ]+ reportSDoc "term.matrices" 30 $ vcat+ [ text $ "Idempotent call matrices:\n"+ , nest 2 $ vcat $ punctuate "\n" $ map' prettyTCM idems+ ]+ -- reportSDoc "term.matrices" 30 $ vcat+ -- [ text $ "Other call matrices (" ++ no ++ "dot patterns):"+ -- , nest 2 $ pretty $ CallGraph.fromList others+ -- ]+ return ()++-- | @termFunction name@ checks @name@ for termination.+-- If it passes the termination check it is marked as "terminates" in the signature.++termFunction :: QName -> TerM Result+termFunction name = inConcreteOrAbstractMode name $ \ def -> do++ -- Retrieve the target type of the function to check.+ -- #4256: Don't use typeOfConst (which instantiates type with module params), since termination+ -- checking is running in the empty context, but with the current module unchanged.+ target <- case theDef def of+ -- We are termination-checking a record (calls to record will not be guarding):+ Record{} -> return TargetRecord+ -- We are termination-checking a definition:+ _ -> typeEndsInDef (defType def) <&> \case+ Just d -> TargetDef d+ Nothing -> TargetOther+ reportTarget target+ terSetTarget target $ do++ -- Collect the recursive calls in the block which (transitively)+ -- involve @name@,+ -- taking the target of @name@ into account for computing guardedness.++ let+ collect :: TerM Calls+ collect = -- strengthenLoopDiagonals <$> do -- bad heuristics, see https://github.com/agda/agda/pull/8184#issuecomment-3487147737+ (`trampolineM` (Set.singleton name, mempty, mempty)) $ \ (todo, done, calls) -> do+ if null todo then return $ Left calls else do+ -- Extract calls originating from functions in @todo@.+ new <- forM' todo termDef+ -- call-graph nodes correspond to @(name, [projection])@ pairs, so we+ -- need to do a step of processing to translate node numbers into the+ -- corresponding function name (see #8596).+ nodeToName <- terGetNodeToName+ let newNames = Set.fromList+ [ q | n <- Set.toList (CallGraph.targetNodes new)+ , Just q <- [IntMap.lookup n nodeToName]+ ]+ -- Mark those functions as processed and add the calls to the result.+ let done' = done `mappend` todo+ calls' = new `mappend` calls+ -- Compute the new todo list:+ todo' = newNames Set.\\ done'+ -- Jump the trampoline.+ return $ Right (todo', done', calls')++ r <- runTerminationCheck (Just name) collect++ names <- terGetUserNames+ case r of++ TerminatesNot guardednessHelps callpaths -> do+ let calls = callInfos callpaths+ -- Mark as non-terminating.+ setTerminates name $ Just False++ -- Functions must be terminating, records types need not...+ case theDef def of++ -- Records need not terminate, so we just put the error on the debug log.+ Record{} -> do+ reportSDoc "term.warn.no" 10 $ vcat $+ hsep [ "Record type", prettyTCM name, "does not termination check.", "Problematic calls:" ] :+ map' (nest 2 . prettyTCM) (List.sortOn getRange calls)+ mempty++ -- Functions must terminate, so we report the error.+ _ -> do+ let err = TerminationError [name | name `elem` names] calls guardednessHelps+ return $ singleton err++ Terminates -> do+ reportSLn "term.warn.yes" 2 $+ prettyShow name ++ " does termination check"+ setTerminates name $ Just True+ return mempty+ where+ reportTarget :: MonadDebug m => Target -> m ()+ reportTarget tgt = reportSLn "term.target" 20 $ (" " ++) $+ case tgt of+ TargetRecord -> "termination checking a record type"+ TargetDef q -> unwords [ "target type ends in", prettyShow q ]+ TargetOther -> "target type not recognized"++-- | To process the target type.+typeEndsInDef :: MonadTCM tcm => Type -> tcm (Maybe QName)+typeEndsInDef t = liftTCM $ do+ TelV _ core <- telViewPath t+ case unEl core of+ Def d vs -> return $ Just d+ _ -> return Nothing++-- | Termination check a definition by pattern matching.+--+-- TODO: Refactor!+-- As this function may be called twice,+-- once disregarding dot patterns,+-- the second time regarding dot patterns,+-- it is better if we separated bare call extraction+-- from computing the change in structural order.+-- Only the latter depends on the choice whether we+-- consider dot patterns or not.+termDef :: QName -> TerM Calls+termDef name = terSetCurrent name $ inConcreteOrAbstractMode name \ def -> do+ -- strengthenLoopDiagonals <$> do -- bad heuristics, see https://github.com/agda/agda/pull/8184#issuecomment-3487147737++ -- Skip calls to record types unless we are checking a record type in the first place.+ let isRecord_ = case theDef def of { Record{} -> True; _ -> False }+ let notTargetRecord = terGetTarget <&> \case+ TargetRecord -> False+ _ -> True+ ifM (pure isRecord_ `and2M` notTargetRecord) mempty {-else-} $ do++ -- Retrieve definition+ let t = defType def++ liftTCM $ reportSDoc "term.def.fun" 5 $+ sep [ "termination checking type of" <+> prettyTCM name+ , nest 2 $ ":" <+> prettyTCM t+ ]++ termType t `mappend` do++ liftTCM $ reportSDoc "term.def.fun" 5 $+ sep [ "termination checking body of" <+> prettyTCM name+ , nest 2 $ ":" <+> prettyTCM t+ ]++ -- If --without-K, we disregard all arguments (and result)+ -- which are not of data or record type.++ withoutKEnabled <- liftTCM withoutKOption+ applyWhen withoutKEnabled (setResultMask t) $ do++ -- If the result should be disregarded, set all calls to unguarded.+ applyWhenM terGetMaskResult terUnguarded $ do++ case theDef def of+ Function{ funClauses = cls } -> forM' cls $ \ cl -> do+ if hasDefP (namedClausePats cl) -- generated hcomp clause, should be safe.+ -- TODO find proper strategy.+ then return empty+ else termClause cl++ -- @record R pars : Set where field tel@+ -- is treated like function @R pars = tel@.+ Record{ recPars, recTel } -> termRecTel recPars recTel++ _ -> return empty++-- | Extract "calls" to the field types from a record constructor telescope.+-- Does not extract from the parameters, but treats these as the "pattern variables"+-- (the lhs of the "function").+termRecTel :: Nat -> Telescope -> TerM Calls+termRecTel npars tel = do+ -- Set up the record parameters like function parameters.+ let (pars, fields) = splitAt' npars $ telToList tel+ addContext pars $ do+ ps <- mkPats npars+ terSetPatterns ps $ terSetSizeDepth pars $ do+ -- Treat the record fields like the body of a function.+ extract $ telFromList fields+ where+ -- create n variable patterns+ mkPats n = map' mkPat <$> getContextVars+ mkPat (i, x) = notMasked $ VarP defaultPatternInfo $ DBPatVar (prettyShow x) i++-- | Collect calls in type signature @f : (x1:A1)...(xn:An) -> B@.+-- It is treated as if there were the additional function clauses.+-- @@+-- f = A1+-- f x1 = A2+-- f x1 x2 = A3+-- ...+-- f x1 ... xn = B+-- @@++termType :: Type -> TerM Calls+termType = return mempty+-- termType = loop 0 -- Andreas, 2019-04-10 deactivate for backwards-compatibility in 2.6.0 #1556+ where+ loop n t = do+ ps <- mkPats n+ reportSDoc "term.type" 60 $ vcat+ [ text $ "termType " ++ show n ++ " with " ++ show (length ps) ++ " patterns"+ , nest 2 $ "looking at type " <+> prettyTCM t+ ]+ tel <- getContextTelescope -- Andreas, 2018-11-15, issue #3394, forgotten initialization of terSizeDepth+ terSetPatterns ps $ terSetSizeDepth tel $ do+ ifNotPiType t {-then-} extract {-else-} $ \ dom absB -> do+ extract dom `mappend` underAbstractionAbs dom absB (loop $! n + 1)++ -- create n variable patterns+ mkPats n = map' mkPat <$> getContextVars+ mkPat (i, x) = notMasked $ VarP defaultPatternInfo $ DBPatVar (prettyShow x) i++-- | Mask the result for termination checking according to type of function.+-- (Masking for arguments is handled per-clause in 'termClause'.)++setResultMask :: Type -> TerM a -> TerM a+setResultMask t cont = do+ d <- liftTCM $ do+ TelV tel core <- telViewPath t+ d <- addContext tel $ isNothing <.> isDataOrRecord . unEl $ core+ when d $+ reportSLn "term.mask" 20 $ "result type is not data or record type, ignoring guardedness for --without-K"+ return d+ terSetMaskResult d cont++-- | Precompute the argument masks for a @(name, [projection])@ pair. Strips+-- and classifies the leading Π-arguments (which occupy the argument-pattern+-- slots reached before the next projection), then follows the next projection+-- in @path@ into its field type and recurses.++argumentMasksForPath :: Type -> [QName] -> TCM (ListInf.ListInf Bool)+argumentMasksForPath t path = do+ TelV tel core <- telViewPath t+ ds <- checkArgumentTypes tel+ case path of+ [] -> return (ListInf.pad ds True)+ (d : path') -> addContext tel $ reduce core >>= getDefType d >>= \case+ Just projTy -> reduce projTy >>= \case+ El _ (Pi dom b) -> underAbstraction dom b $ \ft -> do+ -- Projection patterns occupy one slot in the clause pattern list, but+ -- should always be considered unmasked. Hence the @False@:+ rest <- argumentMasksForPath ft path'+ return $ ListInf.append ds (False :< rest)+ _ -> return (ListInf.pad ds True)+ Nothing -> return (ListInf.pad ds True)+ where+ checkArgumentTypes :: Telescope -> TCM [Bool]+ checkArgumentTypes EmptyTel = return []+ checkArgumentTypes (ExtendTel dom atel) = do+ TelV tel2 t <- telViewPath $ unDom dom+ d <- addContext tel2 $+ (isNothing <$> isDataOrRecord (unEl t)) `or2M` (isJust <$> isSizeType t)+ when d $+ reportSDoc "term.mask" 20 $ do+ "argument type "+ <+> prettyTCM t+ <+> " is not data or record type, ignoring structural descent for --without-K"+ underAbstraction dom atel $ \tel -> (d:) <$> checkArgumentTypes tel++-- | Is the current target type among the given ones?++targetElem :: [QName] -> TerM Bool+targetElem ds = terGetTarget <&> \case+ TargetDef d -> d `elem` ds+ TargetRecord -> False+ TargetOther -> False++-- | Convert a term (from a dot pattern) to a pattern for the purposes of the termination checker.+--+-- @SIZESUC@ is treated as a constructor.++class TermToPattern a b where+ termToPattern :: a -> TerM b++-- UNUSED default instances (Andreas, 2026-08-29):+ -- default termToPattern :: (TermToPattern a' b', Traversable f, a ~ f a', b ~ f b') => a -> TerM b+ -- termToPattern = traverse termToPattern++-- instance TermToPattern a b => TermToPattern [a] [b] where+-- instance TermToPattern a b => TermToPattern (Arg a) (Arg b) where+-- instance TermToPattern a b => TermToPattern (Named c a) (Named c b) where++instance TermToPattern Term DeBruijnPattern where+ termToPattern t = do+ t <- constructorForm =<< reduce t+ let+ -- Andrea: 22/04/2020.+ -- With cubical we will always have a clause where the dot+ -- patterns are instead replaced with a variable, so they+ -- cannot be relied on for termination.+ -- See issue #4606 for a counterexample involving HITs.+ --+ -- Without the presence of HITs I conjecture that dot patterns+ -- could be turned into actual splits, because no-confusion+ -- would make the other cases impossible, so I do not disable+ -- this for --without-K entirely.+ --+ -- Szumi, 2025-03-11:+ -- Instead of completely turning off dot-pattern termination for cubical,+ -- it should be enough to only ignore constructors of HITs in dot patterns.+ -- This way, the issues #5953 and #4725 are also avoided.+ ifNotConsOfHIT :: ConHead -> TerM DeBruijnPattern -> TerM DeBruijnPattern+ ifNotConsOfHIT c = ifM (consOfHIT (conName c)) fallback+ -- Andreas, 2025-11-20, issue #8212+ -- Reduce constructor to their original form+ -- as this also happens in the call arguments.+ fallback :: TerM DeBruijnPattern+ fallback = dotP <$> do reduceCon t+ case t of+ -- Constructors.+ Con c _ args -> ifNotConsOfHIT c $+ ConP c noConPatternInfo . map' (fmap unnamed) <$> mapM argToPattern (mustAllApplyElims args)+ Def s [Apply arg] -> do+ suc <- terGetSizeSuc+ if Just s == suc then ConP (ConHead s IsData Inductive NotHIT []) noConPatternInfo . singleton . fmap unnamed <$> argToPattern arg+ else fallback+ -- Leaves.+ -- Any (not coinductively) projected variable becomes a variable pattern.+ Var i es -> case mapM isProjElim es of+ Just oxs -> foldMap (All <.> isProjectionButNotCoinductive . snd) oxs >>= \case+ All True -> varP . (`DBPatVar` i) . prettyShow <$> nameOfBV i+ _ -> fallback+ _ -> fallback+ Lit l -> return $ litP l+ Dummy s _ -> __IMPOSSIBLE_VERBOSE__ (show s)+ Def{} -> fallback+ Lam{} -> fallback+ Pi{} -> fallback+ Sort{} -> fallback+ Level{} -> fallback+ MetaV{} -> fallback+ -- Andreas, 2026-08-27, going under DontCare causes issue #8699.+ -- See test/Fail/Issue8699Prop.+ DontCare{} -> fallback++-- | Convert an argument into a pattern, but don't descent into irrelevant (sub)terms.+-- (See issue #8699).+argToPattern :: Arg Term -> TerM (Arg DeBruijnPattern)+argToPattern arg+ -- Andreas, 2026-08-29: irrelevant parts of dot patterns do not provide evidence for termination+ -- since their specific form is not forced (by matches on other patterns) but arbitrary.+ | isIrrelevant arg = return $ fmap dotP arg+ | otherwise = traverse termToPattern arg+++-- | Masks all non-data/record type patterns if --without-K.+-- See issue #1023.+maskNonDataArgs :: [DeBruijnPattern] -> TerM [Masked DeBruijnPattern]+maskNonDataArgs ps = zipWith mask ps <$> terGetMaskArgs+ where+ mask p@ProjP{} _ = Masked False p+ mask p d = Masked d p++-- | Drop elements of the list which correspond to arguments forced by+-- the constructor with the given QName.+mapForcedArguments :: QName -> [a] -> (IsForced -> a -> Maybe b) -> TerM [b]+mapForcedArguments c xs k = do+ forcedArgs <- getForcedArgs c+ let go xs (p:ps) = do+ let (f, xs') = nextIsForced xs+ case k f p of+ Just b -> b:go xs' ps+ Nothing -> go xs' ps+ go _ [] = []+ pure $ go forcedArgs xs++-- | Extract recursive calls from one clause.+termClause :: Clause -> TerM Calls+termClause clause = do+ Clause{ clauseTel = tel, namedClausePats = ps, clauseBody = body } <- snd <$> etaExpandClause clause+ liftTCM $ reportSDoc "term.check.clause" 25 $ vcat+ [ "termClause"+ , nest 2 $ "tel =" <+> prettyTCM tel+ , nest 2 $ "ps =" <+> do addContext tel $ prettyTCMPatternList ps+ ]+ maskArgs <- do+ f <- terGetCurrent+ path <- liftTCM $ mapM getOriginalProjection $+ mapMaybe (fmap (headAmbQ . snd) . isProjP . namedArg) ps+ modeMasks <- terGetProjectedNameToMaskArgs+ case Map.lookup (f, path) modeMasks of+ Just m -> return m+ Nothing -> terGetMaskArgs -- --with-K: map is empty; fallback is "mask nothing"+ terSetMaskArgs maskArgs $ forM' body $ \ v -> addContext tel $ do+ -- TODO: combine the following two traversals, avoid full normalisation.+ -- Parse dot patterns as patterns as far as possible.+ ps <- postTraversePatternM parseDotP ps+ -- Blank out coconstructors.+ ps <- preTraversePatternM stripCoCon ps+ -- Mask non-data arguments.+ mdbpats <- maskNonDataArgs $ map' namedArg ps+ terSetPatterns mdbpats $ do+ terSetSizeDepth tel $ do+ reportBody v+ extract v++ where+ parseDotP :: DeBruijnPattern -> TerM DeBruijnPattern+ parseDotP = \case+ DotP o t -> termToPattern t+ p -> return p+ stripCoCon :: DeBruijnPattern -> TerM DeBruijnPattern+ stripCoCon = \case+ ConP (ConHead c _ CoInductive _ _) _ _ -> return unusedVar+ p -> return p+ reportBody :: Term -> TerM ()+ reportBody v = verboseS "term.check.clause" 6 $ do+ f <- terGetCurrent+ pats <- terGetPatterns+ liftTCM $ reportSDoc "term.check.clause" 6 $ do+ sep [ text ("termination checking clause of")+ <+> prettyTCM f+ , nest 2 $ "lhs:" <+> sep (map' prettyTCM pats)+ , nest 2 $ "rhs:" <+> prettyTCM v+ ]+++-- | Extract recursive calls from expressions.+class ExtractCalls a where+ extract :: a -> TerM Calls++instance ExtractCalls a => ExtractCalls (Abs a) where+ extract (NoAbs _ a) = extract a+ extract (Abs x a) = addContext x $ terRaise $ extract a++instance ExtractCalls a => ExtractCalls (Arg a) where+ extract = extract . unArg++instance ExtractCalls a => ExtractCalls (Dom a) where+ extract = extract . unDom++instance ExtractCalls a => ExtractCalls (Elim' a) where+ extract Proj{} = return empty+ extract (Apply a) = extract $ unArg a+ extract (IApply x y a) = extract (x,(y,a)) -- TODO Andrea: conservative++instance ExtractCalls a => ExtractCalls [a] where+ extract = mapM' extract++instance (ExtractCalls a, ExtractCalls b) => ExtractCalls (a,b) where+ extract (a, b) = CallGraph.union <$> extract a <*> extract b++instance (ExtractCalls a, ExtractCalls b, ExtractCalls c) => ExtractCalls (a,b,c) where+ extract (a, b, c) = extract (a, (b, c))++-- | Sorts can contain arbitrary terms of type @Level@,+-- so look for recursive calls also in sorts.+-- Ideally, 'Sort' would not be its own datatype but just+-- a subgrammar of 'Term', then we would not need this boilerplate.++instance ExtractCalls Sort where+ extract s = do+ liftTCM $ do+ reportSDoc "term.sort" 20 $+ "extracting calls from sort" <+> prettyTCM s+ reportSDoc "term.sort" 50 $+ text ("s = " ++ show s)+ case s of+ Inf _ _ -> return empty+ SizeUniv -> return empty+ LockUniv -> return empty+ LevelUniv -> return empty+ IntervalUniv -> return empty+ Univ _ t -> terUnguarded $ extract t -- no guarded levels+ -- We ignore calls in the blocked dependency check (these will vanish+ -- after the 'PiSort' reduces)+ PiSort _c a s1 s2 -> extract (a, s1, s2)+ FunSort s1 s2 -> extract (s1, s2)+ UnivSort s -> extract s+ MetaS x es -> return empty+ DefS d es -> return empty+ DummyS{} -> return empty++-- | Extract recursive calls from a type.++instance ExtractCalls Type where+ extract (El s t) = extract (s, t)++instance ExtractCalls a => ExtractCalls (Tele a) where+ extract = \case+ EmptyTel -> mempty+ ExtendTel a tel -> extract a <> extract tel++-- | Extract recursive calls from a constructor application.++constructor+ :: QName+ -- ^ Constructor name.+ -> Induction+ -- ^ Should the constructor be treated as inductive or coinductive?+ -> [(Arg Term, Bool)]+ -- ^ All the arguments,+ -- and for every argument a boolean which is 'True' iff the+ -- argument should be viewed as preserving guardedness.+ -> TerM Calls+constructor c ind args = do+ cutoff <- terGetCutOff+ let ?cutoff = cutoff+ forM' args $ \ (arg, preserves) -> do+ let g' = case (preserves, ind) of+ (True, Inductive) -> id+ (True, CoInductive) -> (Order.lt .*.)+ (False, _) -> const Order.unknown+ terModifyGuarded g' $ extract arg++-- | Handles function applications @g es@.++function :: QName -> Elims -> TerM Calls+function g es0 = do++ f <- terGetCurrent+ names <- terGetMutual+ guarded <- terGetGuarded++ -- let gArgs = Def g es0+ liftTCM $ reportSDoc "term.function" 30 $+ "termination checking function call " <+> prettyTCM (Def g es0)++ -- First, look for calls in the arguments of the call gArgs.++ -- If the function is a projection but not for a coinductive record,+ -- then preserve guardedness for its principal argument.+ isProj <- isProjectionButNotCoinductive g+ let unguards = ListInf.repeat Order.unknown+ let guards = applyWhen isProj (guarded :<) unguards+ -- Collect calls in the arguments of this call.+ let args = map' unArg $ argsFromElims es0+ calls <- forM' (zip guards args) $ \ (guard, a) -> do+ terSetGuarded guard $ extract a++ -- Then, consider call gArgs itself.++ liftTCM $ reportSDoc "term.found.call" 20 $+ sep [ "found call from" <+> prettyTCM f+ , nest 2 $ "to" <+> prettyTCM g+ ]++ -- insert this call into the call list+ case Set.lookupIndex g names of++ -- call leads outside the mutual block and can be ignored+ Nothing -> return calls++ -- call is to one of the mutally recursive functions/record+ Just{} -> do+ cutoff <- terGetCutOff+ let ?cutoff = cutoff++ -- Andreas, 2017-02-14, issue #2458:+ -- If we have inlined with-functions, we could be illtyped,+ -- hence, do not reduce anything.+ -- Andreas, 2017-06-20 issue #2613:+ -- We still need to reduce constructors, even when with-inlining happened.+ es <- -- ifM terGetHaveInlinedWith (return es0) {-else-} $+ liftTCM $ forM es0 $+ -- 2017-09-09, re issue #2732+ -- The eta-contraction that was here does not seem necessary to make structural order+ -- comparison not having to worry about eta.+ -- Maybe we thought an eta redex could come from a meta instantiation.+ -- However, eta-contraction is already performed by instantiateFull.+ -- See test/Succeed/Issue2732-termination.agda.+ traverse reduceCon <=< instantiateFull++ -- 2017-05-16, issue #2403: Argument normalization is too expensive,+ -- even if we only expand non-recursive functions.+ -- Argument normalization TURNED OFF.+ -- liftTCM $ billTo [Benchmark.Termination, Benchmark.Reduce] $ do+ -- -- Andreas, 2017-01-13, issue #2403, normalize arguments for the structural ordering.+ -- -- Andreas, 2017-03-25, issue #2495, restrict this to non-recursive functions+ -- -- otherwise, the termination checking may run forever.+ -- reportSLn "term.reduce" 90 $ "normalizing call arguments"+ -- modifyAllowedReductions (List.\\ [UnconfirmedReductions,RecursiveReductions]) $+ -- forM es0 $ \ e -> do+ -- reportSDoc "term.reduce" 95 $ "normalizing " <+> prettyTCM e+ -- etaContract =<< normalise e++ -- Compute the call matrix.++ -- Andreas, 2014-03-26 only 6% of termination time for library test+ -- spent on call matrix generation+ (nrows, ncols, matrix) <- billTo [Benchmark.Termination, Benchmark.Compare] $+ compareArgs es++ -- Andreas, 2022-03-21, #5823:+ -- If we are "calling" a record type we are guarded unless the origin+ -- of the termination analysis is itself a record.+ -- This is because we usually do not "unfold" record types into their+ -- field telescope. We only do so when trying to construct the+ -- unique inhabitant of record type (singleton analysis).+ -- In the latter case, a call to a record type is not guarding.+ guarded' <- isRecord g >>= \case+ Just{} -> terGetTarget >>= \case+ TargetRecord+ -> return guarded+ _ -> return (guarded .*. Order.lt)+ -- guarding when we call a record and not termination checking a record+ Nothing+ -- only a delayed definition can be guarded+ | Order.decreasing guarded+ -> return Order.le+ | otherwise+ -> return guarded+ liftTCM $ reportSLn "term.guardedness" 20 $+ "composing with guardedness " ++ prettyShow guarded +++ " counting as " ++ prettyShow guarded'+ let matrix' = composeGuardedness guarded' matrix++ -- Andreas, 2013-04-26 FORBIDDINGLY expensive!+ -- This PrettyTCM QName cost 50% of the termination time for std-lib!!+ -- gPretty <-liftTCM $ billTo [Benchmark.Termination, Benchmark.Level] $+ -- render <$> prettyTCM g++ -- Andreas, 2013-05-19 as pointed out by Andrea Vezzosi,+ -- printing the call eagerly is forbiddingly expensive.+ -- So we build a closure such that we can print the call+ -- whenever we really need to.+ -- This saves 30s (12%) on the std-lib!+ -- Andreas, 2015-01-21 Issue 1410: Go to the module where g is defined+ -- otherwise its free variables with be prepended to the call+ -- in the error message.+ doc <- liftTCM $ withCurrentModule (qnameModule g) $ buildClosure $+ Def g $ List.dropWhileEnd ((Inserted ==) . getOrigin) es0+ -- Andreas, 2018-07-22, issue #3136+ -- Dropping only inserted arguments at the end, since+ -- dropping arguments in the middle might make the printer crash.+ -- Def g $ filter ((/= Inserted) . getOrigin) es0+ -- Andreas, 2017-01-05, issue #2376+ -- Remove arguments inserted by etaExpandClause.++ -- Issue #8596: stratify the call-graph nodes by copattern projection+ -- list. The source node is the caller's (name, [projection]) tuple;+ -- the target fans out to every real callee mode this call can reach+ -- (those whose projection path is prefix-comparable to the call's).+ srcNode <- projNode f =<< clauseProjPath+ tgtNodes <- callTargetNodes g es0+ let cm = makeCM ncols nrows matrix'+ info = CallPath { callPathStart = f, callPathSteps = singleton $+ CallInfo+ { callInfoTarget = g+ , callInfoCall = doc+ }}+ verboseS "term.kept.call" 5 $ do+ pats <- terGetPatterns+ reportSDoc "term.kept.call" 5 $ vcat+ [ "kept call from" <+> text (prettyShow f) <+> hsep (map' prettyTCM pats)+ , nest 2 $ "to" <+> text (prettyShow g) <+>+ hsep (map' (parens . prettyTCM) args)+ , nest 2 $ "call matrix (with guardedness): "+ , nest 2 $ pretty cm+ ]+ return $ List.foldl' (\ cs t -> CallGraph.insert srcNode t cm info cs) calls tgtNodes++-- | The canonical leading copattern projection path of the clause currently+-- being checked.+clauseProjPath :: TerM [QName]+clauseProjPath = do+ pats <- terGetPatterns+ mapM getOriginalProjection $+ mapMaybe (fmap (headAmbQ . snd) . isProjP . getMasked) pats++-- | Look up the call-graph node for a @(function, projection path)@ pair.+-- The pair must have been registered by 'buildNodeAndProjectionMaps'.+projNode :: QName -> [QName] -> TerM Node+projNode f path = fromMaybe __IMPOSSIBLE__ . Map.lookup (f, path) <$> terGetProjectedNameToNode++-- | Pre-compute the copattern-mode node maps for a mutual SCC.+--+-- For each function in the SCC we collect the canonical leading copattern+-- projection path of every clause, deduplicate, and assign a fresh 'Node'+-- integer to each @(function, [projection])@ pair. The resulting maps+-- are stored in 'TerEnv' before call extraction begins. The reverse map+-- is split into an @IntMap QName@ and a @Map QName [[QName]]@ because+-- 'termFunction' walks per-function, and thus only needs the names.+buildNodeAndProjectionMaps+ :: Set QName+ -> TCM ( Map.Map (QName, [QName]) Node+ , IntMap.IntMap QName+ , Map.Map QName [[QName]]+ , Map.Map (QName, [QName]) (ListInf.ListInf Bool)+ )+buildNodeAndProjectionMaps allNames = do+ withoutK <- withoutKOption+ pairs <- forM (Set.toList allNames) $ \ g -> do+ def <- ignoreAbstractMode (getConstInfo g)+ ms <- forM (defClauses def) $ \ cl ->+ mapM getOriginalProjection $+ mapMaybe (fmap (headAmbQ . snd) . isProjP . namedArg) $ namedClausePats cl+ return (g, defType def, List.nub ms)+ let projectionsOf (g, _, ps) = if null ps then [(g, [])] else map (g,) ps+ allProjectionLists = concatMap projectionsOf pairs+ projectedNameToNode = Map.fromList $ zip allProjectionLists [0..]+ nodeToName = IntMap.fromList $ zip [0..] $ map fst allProjectionLists+ nameToProjections = Map.fromList [ (g, if null ms then [[]] else ms) | (g, _, ms) <- pairs ]+ projectedNameToMaskArgs <- if withoutK+ then do+ let typeOf = Map.fromList [ (g, t) | (g, t, _) <- pairs ]+ Map.fromList <$> forM allProjectionLists (\ (g, path) ->+ -- Andreas, 2026-08-21, issue #8674:+ -- Compute the masks in the abstract/opaque mode of @g@,+ -- otherwise abstract data types are invisible here (they look like axioms)+ -- and their arguments get masked, destroying structural descent.+ ((g, path),) <$> inConcreteOrAbstractMode g \ _def ->+ argumentMasksForPath (typeOf Map.! g) path)+ else return Map.empty+ return (projectedNameToNode, nodeToName, nameToProjections, projectedNameToMaskArgs)++-- | Two projection paths are comparable if one is a prefix of the other.+comparableProjPath :: [QName] -> [QName] -> Bool+comparableProjPath xs ys = xs `List.isPrefixOf` ys || ys `List.isPrefixOf` xs++-- | The callee nodes that a recursive call should connect to. It is not as easy+-- as just looking up the node corresponding to a name, because in the case of+-- definitions by copatterns, a call to @x .foo@ also counts as routing through+-- @x .foo .bar@, for the purpose of termination checking. So the call must be+-- "fanned out" to every callee with a comparable projection list.+callTargetNodes :: QName -> Elims -> TerM [Node]+callTargetNodes g es = do+ givenProjList <- mapM getOriginalProjection [ d | Proj _ d <- es ]+ knownProjLists <- Map.findWithDefault [[]] g <$> terGetNameToProjections+ let comparable = filter (comparableProjPath givenProjList) knownProjLists+ leaves+ | null comparable = knownProjLists -- incomparable: conservatively connect to all+ | otherwise = comparable+ unless (leaves == [givenProjList]) $+ reportSLn "term.copattern.modes" 30 $ unwords+ [ "call to", prettyShow g+ , "at projection path", show (map prettyShow givenProjList)+ , "connects to modes", show (map (map prettyShow) leaves)+ ]+ mapM (projNode g) leaves++-- We have to reduce constructors in case they're reexported.+-- Andreas, Issue 1530: constructors have to be reduced deep inside terms,+-- thus, we need to use traverseTermM.+reduceCon :: MonadTCM tcm => Term -> tcm Term+reduceCon = liftTCM . traverseTermM \case+ Con c ci vs -> (`applyE` vs) <$> reduce (Con c ci []) -- make sure we don't reduce the arguments+ t -> return t+++-- | Try to get rid of a function call targeting the current SCC+-- using a non-recursive clause.+--+-- This can help copattern definitions of dependent records.+tryReduceNonRecursiveClause+ :: QName -- ^ Function+ -> Elims -- ^ Arguments+ -> (Term -> TerM Calls) -- ^ Continue here if we managed to reduce.+ -> TerM Calls -- ^ Otherwise, continue here.+ -> TerM Calls+tryReduceNonRecursiveClause g es continue fallback = do+ -- Andreas, 2020-02-06, re: issue #906+ let v0 = Def g es+ reportSDoc "term.reduce" 40 $ "Trying to reduce away call: " <+> prettyTCM v0++ -- First, make sure the function is in the current SCC.+ ifM (notElem g <$> terGetMutual) fallback {-else-} $ do+ reportSLn "term.reduce" 40 $ "This call is in the current SCC!"++ def <- getConstInfo g+ -- -- Then, collect its clauses.+ -- cls <- defClauses <$> getConstInfo g+ -- reportSLn "term.reduce" 40 $ unwords [ "Function has", show (length cls), "clauses"]+ -- reportSDoc "term.reduce" 80 $ vcat $ map (prettyTCM . NamedClause g True) cls+ -- reportSLn "term.reduce" 80 . ("allowed reductions = " ++) . show . SmallSet.elems+ -- =<< asksTC envAllowedReductions++ -- Finally, try to reduce with the non-recursive clauses (and no rewrite rules).+ r <- liftTCM $+ modifyAllowedReductions (SmallSet.delete UnconfirmedReductions) $+ runReduceM $ appDefE0 g def v0 [] (map' notReduced es)+ case r of+ NoReduction{} -> fallback+ YesReduction _ v -> do+ reportSDoc "term.reduce" 30 $ vcat+ [ "Termination checker: Successfully reduced away call:"+ , nest 2 $ prettyTCM v0+ ]+ verboseS "term.reduce" 5 $ tick "termination-checker-reduced-nonrecursive-call"+ continue v++-- | Extract recursive calls from a term.++instance ExtractCalls Term where+ extract t = do+ reportSDoc "term.check.term" 50 $ do+ "looking for calls in" <+> prettyTCM t++ -- Instantiate top-level MetaVar.+ instantiate t >>= \case++ -- Constructed value.+ Con ConHead{conName = c, conDataRecord = dataOrRec} _ es -> do+ let args = mustAllApplyElims es+ -- A constructor preserves the guardedness of all its arguments.+ -- Andreas, 2022-09-19, issue #6108:+ -- A higher constructor does not. So check if there is an @IApply@ amoung @es@.+ let noIApply = all isProperApplyElim es+ let argsg = map' (,noIApply) args++ -- If we encounter a coinductive record constructor+ -- in a type mutual with the current target+ -- then we count it as guarding.+ let inductive = return Inductive -- not guarding, but preserving+ coinductive = return CoInductive -- guarding+ -- ♯ is guarding+ ind <- ifM ((Just c ==) <$> terGetSharp) coinductive $ {-else-} do+ -- data constructors are not guarding+ if dataOrRec == IsData then inductive else do+ -- abstract constructors are not guarding+ caseMaybeM (isRecordConstructor c) inductive $ \ (q, def) -> do+ reportSLn "term.check.term" 50 $ "constructor " ++ prettyShow c ++ " has record type " ++ prettyShow q+ -- inductive record constructors are not guarding+ if _recInduction def /= Just CoInductive then inductive else do+ -- coinductive constructors unrelated to the mutually+ -- constructed inhabitants of coinductive types are not guarding+ ifM (targetElem . fromMaybe __IMPOSSIBLE__ $ _recMutual def)+ {-then-} coinductive+ {-else-} inductive+ constructor c ind argsg++ -- Function, data, or record type.+ Def g es -> tryReduceNonRecursiveClause g es extract $ function g es++ -- Abstraction. Preserves guardedness.+ Lam h b -> extract b++ -- Neutral term. Destroys guardedness.+ Var i es -> terUnguarded $ extract es++ -- Dependent function space.+ Pi a (Abs x b) ->+ CallGraph.union <$>+ extract a <*> do+ a <- maskSizeLt a -- OR: just do not add a to the context!+ addContext (x, a) $ terRaise $ extract b++ -- Non-dependent function space.+ Pi a (NoAbs _ b) ->+ CallGraph.union <$> extract a <*> extract b++ -- Literal.+ Lit l -> return empty++ -- Sort.+ Sort s -> extract s++ -- Unsolved metas are not considered termination problems, there+ -- will be a warning for them anyway.+ MetaV x args -> return empty++ -- Erased and not-yet-erased proof.+ DontCare t -> extract t++ -- Level.+ Level l -> -- billTo [Benchmark.Termination, Benchmark.Level] $ do+ -- Andreas, 2014-03-26 Benchmark discontinued, < 0.3% spent on levels.+ extract l++ -- Dummy.+ Dummy{} -> return empty++-- | Extract recursive calls from level expressions.++instance ExtractCalls Level where+ extract (Max n as) = extract as++instance ExtractCalls PlusLevel where+ extract (Plus n l) = extract l++-- | Rewrite type @tel -> Size< u@ to @tel -> Size@.+maskSizeLt :: MonadTCM tcm => Dom Type -> tcm (Dom Type)+maskSizeLt !dom = liftTCM $ do+ let a = unDom dom+ (msize, msizelt) <- getBuiltinSize+ case (msize, msizelt) of+ (_ , Nothing) -> return dom+ (Nothing, _) -> __IMPOSSIBLE__+ (Just size, Just sizelt) -> do+ TelV tel c <- telView a+ case a of+ El s (Def d [v]) | d == sizelt -> return $+ abstract tel (El s $ Def size []) <$ dom+ _ -> return dom++{- | @compareArgs es@++ Compare the list of de Bruijn patterns (=parameters) @pats@+ with a list of arguments @es@ and create a call maxtrix+ with |es| rows and |pats| columns.++ The guardedness is the number of projection patterns in @pats@+ minus the number of projections in @es@.+ -}+compareArgs :: [Elim] -> TerM (Int, Int, [[Order]])+compareArgs es = do+ pats <- terGetPatterns+ liftTCM $ reportSDoc "term.compareArgs" 90 $ vcat+ [ text $ "comparing " ++ show (length es) ++ " args to " ++ show (length pats) ++ " patterns"+ ]+ -- apats <- annotatePatsWithUseSizeLt pats+ -- reportSDoc "term.compare" 20 $+ -- "annotated patterns = " <+> sep (map prettyTCM apats)+ -- matrix <- forM es $ \ e -> forM apats $ \ (b, p) -> terSetUseSizeLt b $ compareElim e p+ matrix <- withUsableVars pats $ forM es $ \ e -> forM pats $ \ p -> compareElim e p++ -- Count the number of coinductive projection(pattern)s in caller and callee.+ -- Only recursive coinductive projections are eligible (Issue 1209).+ projsCaller <- length <$> do+ filterM (isCoinductiveProjection True) $ mapMaybe (fmap (headAmbQ . snd) . isProjP . getMasked) pats+ projsCallee <- length <$> do+ filterM (isCoinductiveProjection True) $ mapMaybe (fmap snd . isProjElim) es+ cutoff <- terGetCutOff+ let ?cutoff = cutoff+ let guardedness = decr True $ projsCaller - projsCallee+ liftTCM $ reportSDoc "term.guardedness" 30 $ sep+ [ "compareArgs:"+ , nest 2 $ text $ "projsCaller = " ++ prettyShow projsCaller+ , nest 2 $ text $ "projsCallee = " ++ prettyShow projsCallee+ , nest 2 $ text $ "guardedness of call: " ++ prettyShow guardedness+ ]+ return $ addGuardedness guardedness (size es, size pats, matrix)++-- | Traverse patterns from left to right.+-- When we come to a projection pattern,+-- switch usage of SIZELT constraints:+-- on, if coinductive,+-- off, if inductive.+--+-- UNUSED+--annotatePatsWithUseSizeLt :: [DeBruijnPattern] -> TerM [(Bool,DeBruijnPattern)]+--annotatePatsWithUseSizeLt = loop where+-- loop [] = return []+-- loop (p@(ProjP _ q) : pats) = ((False,p) :) <$> do projUseSizeLt q $ loop pats+-- loop (p : pats) = (\ b ps -> (b,p) : ps) <$> terGetUseSizeLt <*> loop pats+++-- | @compareElim e dbpat@++compareElim :: Elim -> Masked DeBruijnPattern -> TerM Order+compareElim e p = do+ liftTCM $ do+ reportSDoc "term.compare" 30 $ sep+ [ "compareElim"+ , nest 2 $ "e = " <> prettyTCM e+ , nest 2 $ "p = " <> prettyTCM p+ ]+ reportSDoc "term.compare" 50 $ sep+ [ nest 2 $ text $ "e = " ++ show e+ , nest 2 $ text $ "p = " ++ show p+ ]+ case (e, getMasked p) of+ (Proj _ d, ProjP _ d') -> do+ d <- getOriginalProjection d+ d' <- getOriginalProjection d'+ o <- compareProj d d'+ reportSDoc "term.compare" 30 $ sep+ [ text $ "comparing callee projection " ++ prettyShow d+ , text $ "against caller projection " ++ prettyShow d'+ , text $ "yields order " ++ prettyShow o+ ]+ return o+ (Proj{}, _) -> return Order.unknown+ (Apply{}, ProjP{}) -> return Order.unknown+ (Apply arg, _) -> compareTerm (unArg arg) p+ -- TODO Andrea: making sense?+ (IApply{}, ProjP{}) -> return Order.unknown+ (IApply _ _ arg, _) -> compareTerm arg p++-- | In dependent records, the types of later fields may depend on the+-- values of earlier fields. Thus when defining an inhabitant of a+-- dependent record type such as Σ by copattern matching,+-- a recursive call eliminated by an earlier projection (proj₁) might+-- occur in the definition at a later projection (proj₂).+-- Thus, earlier projections are considered "smaller" when+-- comparing copattern spines. This is an ok approximation+-- of the actual dependency order.+-- See issues 906, 942.+compareProj :: MonadTCM tcm => QName -> QName -> tcm Order+compareProj d d'+ | d == d' = return Order.le+ | otherwise = liftTCM $ do+ -- different projections+ mr <- getRecordOfField d+ mr' <- getRecordOfField d'+ case (mr, mr') of+ (Just r, Just r') | r == r' -> do+ -- of same record+ def <- theDef <$> getConstInfo r+ case def of+ Record{ recFields = fs } -> do+ fs <- return $ map' unDom fs+ case (List.find (d ==) fs, List.find (d' ==) fs) of+ (Just i, Just i')+ -- earlier field is smaller+ | i < i' -> return Order.lt+ | i == i' -> do+ __IMPOSSIBLE__+ | otherwise -> return Order.unknown+ _ -> __IMPOSSIBLE__+ _ -> __IMPOSSIBLE__+ _ -> return Order.unknown++-- | 'makeCM' turns the result of 'compareArgs' into a proper call matrix+makeCM :: Int -> Int -> [[Order]] -> CallMatrix+makeCM ncols nrows matrix = CallMatrix $+ Matrix.fromLists (Matrix.Size nrows ncols) matrix++-- | 'addGuardedness' adds guardedness flag in the upper left corner+-- (0,0).+addGuardedness :: Order -> (Int, Int, [[Order]]) -> (Int, Int, [[Order]])+addGuardedness o (nrows, ncols, m) =+ (nrows + 1, ncols + 1,+ (o : replicate ncols Order.unknown) : map' (Order.unknown :) m)++-- | Compose something with the upper-left corner of a call matrix+composeGuardedness :: (?cutoff :: CutOff) => Order -> [[Order]] -> [[Order]]+composeGuardedness o ((corner : row) : rows) = ((o .*. corner) : row) : rows+composeGuardedness _ _ = __IMPOSSIBLE__++-- | Stripping off a record constructor is not counted as decrease, in+-- contrast to a data constructor.+-- A record constructor increases/decreases by 0, a data constructor by 1.+offsetFromConstructor :: HasConstInfo tcm => QName -> tcm Int+offsetFromConstructor c =+ ifM (isEtaOrCoinductiveRecordConstructor c) (return 0) (return 1)++compareTerm :: Term -> Masked DeBruijnPattern -> TerM Order+compareTerm t p = do+-- reportSDoc "term.compare" 25 $+-- " comparing term " <+> prettyTCM t <+>+-- " to pattern " <+> prettyTCM p+ o <- compareTerm' t =<< traverse reduceConPattern p+ liftTCM $ reportSDoc "term.compare" 25 $+ " comparing term " <+> prettyTCM t <+>+ " to pattern " <+> prettyTCM p <+>+ text (" results in " ++ prettyShow o)+ return o++-- | Normalize outermost constructor name in a pattern.++{-# SPECIALIZE reduceConPattern :: DeBruijnPattern -> TerM DeBruijnPattern #-}+reduceConPattern :: MonadTCM tcm => DeBruijnPattern -> tcm DeBruijnPattern+reduceConPattern = \case+ ConP c i ps -> fromRightM (\ err -> return c) (liftTCM $ getConForm $ conName c) <&> \ c' ->+ ConP c' i ps+ p -> return p++-- | @compareTerm' t dbpat@+--+-- Precondition: 'reduceConPattern' has been applied to the pattern.++compareTerm' :: Term -> Masked DeBruijnPattern -> TerM Order+compareTerm' v mp@(Masked m p) = do+ suc <- terGetSizeSuc+ cutoff <- terGetCutOff+ let ?cutoff = cutoff+ -- v <- liftTCM (instantiate v) -- call extraction already instantiates metas in call arguments+ let fallback = return $ subTerm v p+ case (v, p) of++ -- Andreas, 2013-11-20 do not drop projections,+ -- in any case not coinductive ones!:+ -- Andreas, 2025-11-05 we may drop all eliminations that are not coinductive projections.+ (Var i es, _) -> foldMap (All <.> elimNotCoinductive) es >>= \case+ All True -> compareVar i mp+ _ -> fallback++ (DontCare t, _) ->+ compareTerm' t mp++ -- Andreas, 2014-09-22, issue 1281:+ -- For metas, termination checking should be optimistic.+ -- If there is any instance of the meta making termination+ -- checking succeed, then we should not fail.+ -- Thus, we assume the meta will be instantiated with the+ -- deepest variable in @p@.+ -- For sized types, the depth is maximally+ -- the number of SIZELT hypotheses one can have in a context.+ (MetaV{}, p) -> Order.decr True . max (if m then 0 else patternDepth p) . pred <$>+ terAsks _terSizeDepth++ -- Successor on both sides cancel each other.+ -- We ignore the mask for sizes.+ (Def s [Apply t], ConP s' _ [p]) | s == conName s' && Just s == suc ->+ compareTerm' (unArg t) . notMasked =<< reduceConPattern (namedArg p)++ -- Register also size increase.+ (Def s [Apply t], p) | Just s == suc ->+ -- Andreas, 2012-10-19 do not cut off here+ increase 1 <$> compareTerm' (unArg t) mp++ -- In all cases that do not concern sizes,+ -- we cannot continue if pattern is masked.++ _ | m -> return Order.unknown++ (Lit l, LitP _ l')+ | l == l' -> return Order.le+ | otherwise -> return Order.unknown++ (Lit l, _) -> do+ v <- liftTCM $ constructorForm v+ case v of+ Lit{} -> return Order.unknown+ v -> compareTerm' v mp++ -- Andreas, 2011-04-19 give subterm priority over matrix order++ (Con{}, ConP c _ ps) | any (isSubTerm v . namedArg) ps ->+ decr True <$> offsetFromConstructor (conName c)++ (Con c _ es, ConP c' _ ps) | conName c == conName c'->+ let ts = mustAllApplyElims es in+ compareConArgs ts ps++ (Con _ _ [], _) -> return Order.le++ -- new case for counting constructors / projections+ -- register also increase+ (Con c _ es, _) -> do+ let ts = mustAllApplyElims es+ increase <$> offsetFromConstructor (conName c)+ <*> (infimum <$> mapM (\ t -> compareTerm' (unArg t) mp) ts)++ _ -> fallback++-- | @subTerm@ computes a size difference (Order)+subTerm :: (?cutoff :: CutOff) => Term -> DeBruijnPattern -> Order+subTerm t p = if equal t p then Order.le else properSubTerm t p+ where+ equal (Con c _ es) (ConP c' _ ps) =+ let ts = mustAllApplyElims es in+ and $ (conName c == conName c')+ : (length ts == length ps)+ : zipWith' (\ t p -> equal (unArg t) (namedArg p)) ts ps+ equal (Var i []) (VarP _ x) = i == dbPatVarIndex x+ equal (Lit l) (LitP _ l') = l == l'+ -- Terms.+ -- Checking for identity here is very fragile.+ -- However, we cannot do much more, as we are not allowed to normalize t.+ -- (It might diverge, and we are just in the process of termination checking.)+ equal t (DotP _ t') = t == t'+ equal _ _ = False++ properSubTerm t (ConP _ _ ps) =+ setUsability True $ decrease 1 $ supremum $ map' (subTerm t . namedArg) ps+ properSubTerm _ _ = Order.unknown++isSubTerm :: (?cutoff :: CutOff) => Term -> DeBruijnPattern -> Bool+isSubTerm t p = nonIncreasing $ subTerm t p++compareConArgs :: Args -> [NamedArg DeBruijnPattern] -> TerM Order+compareConArgs ts ps = do+ cutoff <- terGetCutOff+ let ?cutoff = cutoff+ case compare (length ts) (length ps) of++ -- We may assume |ps| >= |ts|, otherwise c ps would be of functional type+ -- which is impossible.+ GT -> __IMPOSSIBLE__++ -- Andreas, 2022-08-31, issue #6059: doing anything smarter than+ -- @unknown@ here can lead to non-termination.+ LT -> return Order.unknown++ EQ -> List.foldl' (Order..*.) Order.le <$>+ zipWithM compareTerm' (map' unArg ts) (map' (notMasked . namedArg) ps)+ -- corresponds to taking the size, not the height+ -- allows examples like (x, y) < (Succ x, y)+{- version which does an "order matrix"+ -- Andreas, 2013-02-18 disabled because it is unclear+ -- how to scale idempotency test to matrix-shaped orders (need thinking/researcH)+ -- Trigges issue 787.+ (_,_) -> do -- build "call matrix"+ m <- mapM (\t -> mapM (compareTerm' suc (unArg t)) ps) ts+ let m2 = makeCM (length ps) (length ts) m+ return $ Order.orderMat (Order.mat m2)+-}+{- version which takes height+-- if null ts then Order.Le+-- else Order.infimum (zipWith compareTerm' (map' unArg ts) ps)+-}++compareVar :: Nat -> Masked DeBruijnPattern -> TerM Order+compareVar i (Masked m p) = do+ suc <- terGetSizeSuc+ cutoff <- terGetCutOff+ let ?cutoff = cutoff+ let no = return Order.unknown+ case p of+ ProjP{} -> no+ IApplyP _ _ _ x -> compareVarVar i (Masked m x)+ LitP{} -> no+ DotP{} -> no+ VarP _ x -> compareVarVar i (Masked m x)++ ConP s _ [p] | Just (conName s) == suc ->+ setUsability True . decrease 1 <$> compareVar i (notMasked $ namedArg p)++ ConP c pi ps -> if m then no else setUsability True <$> do+ let+ dropit Forced _ = Nothing+ dropit NotForced x = Just x+ ps <- ifM (optForcedArgumentRecursion <$> pragmaOptions)+ {- then -} (pure ps)+ {- else -} (mapForcedArguments (conName c) ps dropit)+ decrease <$> offsetFromConstructor (conName c)+ <*> (Order.supremum <$> mapM (compareVar i . notMasked . namedArg) ps)+ DefP _ c ps -> if m then no else setUsability True <$> do+ decrease <$> offsetFromConstructor c+ <*> (Order.supremum <$> mapM (compareVar i . notMasked . namedArg) ps)+ -- This should be fine for c == hcomp++-- | Compare two variables.+--+-- The first variable comes from a term, the second from a pattern.+compareVarVar :: Nat -> Masked DBPatVar -> TerM Order+compareVarVar i (Masked m x@(DBPatVar _ j))+ | i == j = if not m then return Order.le else liftTCM $+ -- If j is a size, we ignore the mask.+ ifM (isJust <$> do isSizeType =<< reduce =<< typeOfBV j)+ {- then -} (return Order.le)+ {- else -} (return Order.unknown)+ | otherwise = do+ -- record usability of variable+ u <- (i `VarSet.member`) <$> terGetUsableVars+ -- Andreas, 2017-07-26, issue #2331.+ -- The usability logic is refuted by bounded size quantification in terms.+ -- Thus, it is switched off (the infrastructure remains in place for now).+ if not u then return Order.unknown else do+ -- Only if usable:+ res <- isBounded i+ case res of+ BoundedNo -> return Order.unknown+ BoundedLt v -> setUsability u . decrease 1 <$> compareTerm' v (Masked m $ varP x)
@@ -1,3 +1,5 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ {-# LANGUAGE ImplicitParams #-} -- | Termination checker, based on@@ -8,42 +10,50 @@ -- Chin Soon Lee, Neil Jones, and Amir Ben-Amram (POPL'01). module Agda.Termination.Termination- ( terminates- , Agda.Termination.Termination.tests+ ( Terminates(..)+ , GuardednessHelps(..)+ , terminates+ , terminatesFilter+ , terminationCounterexample+ , idempotentEndos ) where -import Agda.Termination.Lexicographic+import Prelude hiding ((&&), not, null)++import Control.DeepSeq (NFData)+import GHC.Generics (Generic)++import Agda.Termination.CutOff import Agda.Termination.CallGraph+import Agda.Termination.CallMatrix hiding (toList)+import qualified Agda.Termination.CallMatrix as CMSet+import Agda.Termination.Order import Agda.Termination.SparseMatrix-import Agda.Utils.Either-import Agda.Utils.TestHelpers-import Control.Arrow-import Agda.Utils.QuickCheck-import qualified Data.Set as Set-import qualified Data.Array as Array-import Data.Set (Set)-import qualified Data.Set as Set-import Data.Map (Map)-import qualified Data.Map as Map-import Data.Monoid-import Data.Array (Array) --- | TODO: This comment seems to be partly out of date.------ @'terminates' cs@ checks if the functions represented by @cs@+import Agda.Utils.Boolean+import Agda.Utils.Null+import Agda.Utils.Three++-- | Would termination go through with guardedness?+data GuardednessHelps+ = GuardednessHelpsYes -- ^ Guardedness would provide termination evidence.+ | GuardednessHelpsNot -- ^ Guardedness does not help with termination.+ deriving (Eq, Show, Generic, Enum, Bounded)++-- | Result of running the termination checker.+data Terminates cinfo+ = Terminates+ -- ^ Termination proved without considering guardedness.+ | TerminatesNot GuardednessHelps cinfo+ -- ^ Termination could not be proven,+ -- witnessed by the supplied problematic call path.+ -- Guardedness could help, though.+++-- | @'terminates' cs@ checks if the functions represented by @cs@ -- terminate. The call graph @cs@ should have one entry ('Call') per -- recursive function application. ----- @'Right' perms@ is returned if the functions are size-change terminating.------ If termination can not be established, then @'Left' problems@ is--- returned instead. Here @problems@ contains an--- indication of why termination cannot be established. See 'lexOrder'--- for further details.------ Note that this function assumes that all data types are strictly--- positive.--- -- The termination criterion is taken from Jones et al. -- In the completed call graph, each idempotent call-matrix -- from a function to itself must have a decreasing argument.@@ -51,212 +61,84 @@ -- -- This criterion is strictly more liberal than searching for a -- lexicographic order (and easier to implement, but harder to justify).--terminates :: (Ord meta, Monoid meta, ?cutoff :: Int) => CallGraph meta -> Either meta ()-terminates cs = let ccs = complete cs- in- checkIdems $ toList ccs--checkIdems :: (Ord meta, Monoid meta, ?cutoff :: Int) => [(Call,meta)] -> Either meta ()-checkIdems [] = Right ()-checkIdems ((c,m):xs) = if (checkIdem c) then checkIdems xs else Left m--{- Convention (see TermCheck):- Guardedness flag is in position (0,0) of the matrix,- it is always present even if the functions are all recursive.- The examples below do not include the guardedness flag, though.- -}--checkIdem :: (?cutoff :: Int) => Call -> Bool-checkIdem c = let- b = target c == source c- idem = (c >*< c) == c- diag = Array.elems $ diagonal (mat (cm c))- hasDecr = any isDecr $ diag- in- (not b) || (not idem) || hasDecr---- | Matrix is decreasing if any diagonal element is decreasing.--isDecr :: Order -> Bool-isDecr (Mat m) = any isDecr $ Array.elems $ diagonal m-isDecr o = decreasing o----------------------------------------------------------------------------- Some examples---- | The call graph instantiation used by the examples below.--type CG = CallGraph (Set Integer)---- | Constructs a call graph suitable for use with the 'R' monoid.--buildCallGraph :: [Call] -> CG-buildCallGraph = fromList . flip zip (map Set.singleton [1 ..])---- | The example from the JFP'02 paper.--example1 :: CG-example1 = buildCallGraph [c1, c2, c3]- where- flat = 1- aux = 2- c1 = Call { source = flat, target = aux- , cm = CallMatrix $ fromLists (Size 2 1) [[lt], [lt]]- }- c2 = Call { source = aux, target = aux- , cm = CallMatrix $ fromLists (Size 2 2) [ [lt, unknown]- , [unknown, le]]- }- c3 = Call { source = aux, target = flat- , cm = CallMatrix $ fromLists (Size 1 2) [[unknown, le]]- }--prop_terminates_example1 :: (?cutoff :: Int) => Bool-prop_terminates_example1 = isRight $ terminates example1---- | An example which is now handled by this algorithm: argument--- swapping addition. ----- @S x + y = S (y + x)@------ @Z + y = y@--example2 :: CG-example2 = buildCallGraph [c]- where- plus = 1- c = Call { source = plus, target = plus- , cm = CallMatrix $ fromLists (Size 2 2) [ [unknown, le]- , [lt, unknown] ]- }--prop_terminates_example2 :: (?cutoff :: Int) => Bool-prop_terminates_example2 = isRight $ terminates example2---- | A related example which is anyway handled: argument swapping addition--- using two alternating functions.------ @S x + y = S (y +' x)@------ @Z + y = y@------ @S x +' y = S (y + x)@------ @Z +' y = y@+-- 'terminates' does not use guardedness, 'terminatesFilter' is more general.+terminates :: (Monoid cinfo, ?cutoff :: CutOff) => CallGraph cinfo -> Terminates cinfo+terminates = terminatesFilter False $ const True -example3 :: CG-example3 = buildCallGraph [c plus plus', c plus' plus]+-- | While no counterexample to termination is found,+-- complete the given call graph step-by-step.+terminatesFilter :: forall cinfo. (Monoid cinfo, ?cutoff :: CutOff)+ => Bool -- ^ Use guardedness?+ -> (Node -> Bool) -- ^ Only consider calls whose source and target satisfy this predicate.+ -> CallGraph cinfo -- ^ Callgraph augmented with @cinfo@.+ -> Terminates cinfo -- ^ A bad call path of type @cinfo@, if termination could not be proven.+terminatesFilter useGuardedness f cs0 = loop (cs0, cs0) where- plus = 1- plus' = 2- c f g = Call { source = f, target = g- , cm = CallMatrix $ fromLists (Size 2 2) [ [unknown, le]- , [lt, unknown] ]- }--prop_terminates_example3 :: (?cutoff :: Int) => Bool-prop_terminates_example3 = isRight $ terminates example3---- | A contrived example.------ @f (S x) y = f (S x) y + g x y@------ @f Z y = y@------ @g x y = f x y@------ TODO: This example checks that the meta information is reported properly--- when an error is encountered.+ loop :: (CallGraph cinfo, CallGraph cinfo) -> Terminates cinfo+ loop (new, cs)+ -- If we have no new calls, the call graph is complete,+ -- and we have not found a counterexample.+ | null new = Terminates+ -- Otherwise the new calls might contain a counterexample.+ | otherwise = case terminationCounterexample useGuardedness f new of+ -- If we have a counterexample already, we can stop the search for one.+ result@TerminatesNot{} -> result+ -- Otherwise, we continue to complete the call-graph one step and look again.+ Terminates -> loop $ completionStep cs0 cs -example4 :: CG-example4 = buildCallGraph [c1, c2, c3]+-- | Does the given callgraph contain a counterexample to termination?+terminationCounterexample :: (?cutoff :: CutOff)+ => Bool -- ^ Use guardedness?+ -> (Node -> Bool) -- ^ Only consider calls whose source and target satisfy this predicate.+ -> CallGraph cinfo -- ^ Callgraph augmented with @cinfo@.+ -> Terminates cinfo -- ^ A bad call path of type @cinfo@, if termination could not be proven.+terminationCounterexample useGuardedness f cs+ | cm:_ <- bad = TerminatesNot GuardednessHelpsNot $ augCallInfo cm+ | cm:_ <- needGuardedness+ , not useGuardedness = TerminatesNot GuardednessHelpsYes $ augCallInfo cm+ | otherwise = Terminates where- f = 1- g = 2- c1 = Call { source = f, target = f- , cm = CallMatrix $ fromLists (Size 2 2) [ [le, unknown]- , [unknown, le] ]- }- c2 = Call { source = f, target = g- , cm = CallMatrix $ fromLists (Size 2 2) [ [lt, unknown]- , [unknown, le] ]- }- c3 = Call { source = g, target = f- , cm = CallMatrix $ fromLists (Size 2 2) [ [le, unknown]- , [unknown, le] ]- }--prop_terminates_example4 :: (?cutoff :: Int) => Bool-prop_terminates_example4 = isLeft $ terminates example4+ -- Every idempotent call must have decrease in the diagonal.+ (_good, needGuardedness, bad) = partitionEithers3 $ map hasDecr idems+ idems = idempotentEndosFilter f cs+ hasDecr cm = case diagonal cm of+ g : xs+ | any isDecr xs -> In1 () -- Evidence found without guardedness.+ | isDecr g -> In2 cm -- Evidence found in guardedness.+ | otherwise -> In3 cm -- No evidence found.+ [] -> In3 cm -- No information means no evidence for termination. --- | This should terminate.------ @f (S x) (S y) = g x (S y) + f (S (S x)) y@------ @g (S x) (S y) = f (S x) (S y) + g x (S y)@+-- | Get all idempotent call-matrixes of loops in the call graph that match the given node-filter.+idempotentEndosFilter :: (?cutoff :: CutOff) => (Node -> Bool) -> CallGraph cinfo -> [CallMatrixAug cinfo]+idempotentEndosFilter f = filter idempotent . concatMap (CMSet.toList . snd) . filter (f . fst) . loops -example5 :: CG-example5 = buildCallGraph [c1, c2, c3, c4]- where- f = 1- g = 2- c1 = Call { source = f, target = g- , cm = CallMatrix $ fromLists (Size 2 2) [ [lt, unknown]- , [unknown, le] ]- }- c2 = Call { source = f, target = f- , cm = CallMatrix $ fromLists (Size 2 2) [ [unknown, unknown]- , [unknown, lt] ]- }- c3 = Call { source = g, target = f- , cm = CallMatrix $ fromLists (Size 2 2) [ [le, unknown]- , [unknown, le] ]- }- c4 = Call { source = g, target = g- , cm = CallMatrix $ fromLists (Size 2 2) [ [lt, unknown]- , [unknown, le] ]- }+-- | Get all idempotent call-matrixes of loops in the call graph.+idempotentEndos :: (?cutoff :: CutOff) => CallGraph cinfo -> [CallMatrixAug cinfo]+idempotentEndos = idempotentEndosFilter $ const True -prop_terminates_example5 :: (?cutoff :: Int) => Bool-prop_terminates_example5 = isRight $ terminates example5+-- | A call @c@ is idempotent if it is an endo (@'source' == 'target'@)+-- of order 1.+-- (Endo-calls of higher orders are e.g. argument permutations).+-- We can test idempotency by self-composition.+-- Self-composition @c >*< c@ should not make any parameter-argument relation+-- worse.+idempotent :: (?cutoff :: CutOff) => CallMatrixAug cinfo -> Bool+idempotent (CallMatrixAug m _) = (m >*< m) `notWorse` m --- | Another example which should fail.------ @f (S x) = f x + f (S x)@------ @f x = f x@------ TODO: This example checks that the meta information is reported properly--- when an error is encountered.+-- Instances -example6 :: CG-example6 = buildCallGraph [c1, c2, c3]- where- f = 1- c1 = Call { source = f, target = f- , cm = CallMatrix $ fromLists (Size 1 1) [ [lt] ]- }- c2 = Call { source = f, target = f- , cm = CallMatrix $ fromLists (Size 1 1) [ [le] ]- }- c3 = Call { source = f, target = f- , cm = CallMatrix $ fromLists (Size 1 1) [ [le] ]- }+instance Null GuardednessHelps where+ empty = GuardednessHelpsNot -prop_terminates_example6 :: (?cutoff :: Int) => Bool-prop_terminates_example6 = isLeft $ terminates example6+instance Boolean GuardednessHelps where+ fromBool = \case+ True -> GuardednessHelpsYes+ False -> GuardednessHelpsNot ---------------------------------------------------------------------------- All tests+instance IsBool GuardednessHelps where+ toBool = \case+ GuardednessHelpsYes -> True+ GuardednessHelpsNot -> False -tests :: IO Bool-tests = runTests "Agda.Termination.Termination"- [ quickCheck' prop_terminates_example1- , quickCheck' prop_terminates_example2- , quickCheck' prop_terminates_example3- , quickCheck' prop_terminates_example4- , quickCheck' prop_terminates_example5- , quickCheck' prop_terminates_example6- ]- where ?cutoff = 0 -- all these examples are with just lt,le,unknown+instance NFData GuardednessHelps
@@ -1,48 +0,0 @@---- | Responsible for running all internal tests.-module Agda.Tests (testSuite) where--import Agda.Utils.TestHelpers--import Agda.Compiler.MAlonzo.Encode as CompEnco (tests)-import Agda.Interaction.Highlighting.Emacs as InteEmac (tests)-import Agda.Interaction.Highlighting.Generate as InteGene (tests)-import Agda.Interaction.Highlighting.Precise as IntePrec (tests)-import Agda.Interaction.Highlighting.Range as InteRang (tests)-import Agda.Interaction.Options as InteOpti (tests)-import Agda.Syntax.Parser.Parser as SyntPars (tests)-import Agda.Syntax.Position as SyntPosi (tests)-import Agda.Termination.Termination as TermTerm (tests)-import Agda.Termination.CallGraph as TermCall (tests)-import Agda.Termination.Lexicographic as TermLex (tests)-import Agda.Termination.Matrix as TermMatrix (tests)-import Agda.Termination.Semiring as TermRing (tests)-import Agda.Termination.SparseMatrix as TermSparse (tests)-import Agda.TypeChecking.Tests as TypeChck (tests)-import Agda.Utils.Either as UtilEith (tests)-import Agda.Utils.FileName as UtilFile (tests)-import Agda.Utils.List as UtilList (tests)-import Agda.Utils.Warshall as UtilWarsh (tests)--testSuite :: IO Bool-testSuite = runTests "QuickCheck test suite:"- [ CompEnco.tests- , InteEmac.tests- , InteGene.tests- , IntePrec.tests- , InteRang.tests- , InteOpti.tests- , SyntPars.tests- , SyntPosi.tests- , TermTerm.tests- , TermCall.tests- , TermLex.tests- , TermMatrix.tests- , TermRing.tests- , TermSparse.tests- , TypeChck.tests- , UtilEith.tests- , UtilFile.tests- , UtilList.tests- , UtilWarsh.tests- ]
@@ -0,0 +1,9 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TheTypeChecker+ ( checkDecls, checkDecl, checkDeclCached+ , inferExpr, checkExpr+ ) where++import Agda.TypeChecking.Rules.Decl+import Agda.TypeChecking.Rules.Term
@@ -1,13 +0,0 @@--module Agda.TypeChecker- ( checkDecls, checkDecl- , inferExpr, checkExpr- ) where--import Agda.TypeChecking.Rules.Builtin as Rules-import Agda.TypeChecking.Rules.Data as Rules-import Agda.TypeChecking.Rules.Decl as Rules-import Agda.TypeChecking.Rules.Def as Rules-import Agda.TypeChecking.Rules.LHS as Rules-import Agda.TypeChecking.Rules.Record as Rules-import Agda.TypeChecking.Rules.Term as Rules
@@ -1,83 +1,405 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} -- | Functions for abstracting terms over other terms.+ module Agda.TypeChecking.Abstract where +import Prelude hiding ( null )++import Control.Monad+import Control.Monad.Except++import Data.Function ( on )+import qualified Data.HashMap.Strict as HMap+ import Agda.Syntax.Common+import Agda.Syntax.Position ( Range ) import Agda.Syntax.Internal++import Agda.TypeChecking.Free ( freeIn )+import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.Monad import Agda.TypeChecking.Substitute-import Data.Function+import Agda.TypeChecking.CheckInternal+import Agda.TypeChecking.Conversion+import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Primitive ( getRefl )+import Agda.TypeChecking.Sort+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Warnings ( warning ) -#include "../undefined.h"+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.Null+ import Agda.Utils.Impossible -piAbstractTerm :: Term -> Type -> Type -> Type-piAbstractTerm v a b = fun a (abstractTerm v b)+-- | @abstractType r a v b[v] = b@ where @v : a@.+abstractType ::+ Range -- ^ Range of the @rewrite@ expression, if any, otherwise empty.+ -> Type -- ^ Type of the term to abstract.+ -> Term -- ^ Term to abstract.+ -> Type -- ^ Type to abstract in.+ -> TCM Type -- ^ Type with hole (de Bruijn index 0) for the abstracted term.+abstractType r a v (El s b) = do++ c <- El (absTerm 0 v s) <$> abstractTerm a v (sort s) b+ unless (null r || 0 `freeIn` c) do+ -- Andreas, 2025-07-03, issue #7973+ -- If with abstraction did not abstract anything, warn the user.+ setCurrentRange r $ warning RewritesNothing+ return c++-- | @piAbstractTerm NotHidden v a b[v] = (w : a) -> b[w]@+-- @piAbstractTerm Hidden v a b[v] = {w : a} -> b[w]@+piAbstractTerm :: ArgInfo -> Term -> Type -> Type -> TCM Type+piAbstractTerm info v a b = do+ fun <- mkPi (setArgInfo info $ defaultDom ("w", a)) <$> abstractType empty a v b+ reportSDoc "tc.abstract" 50 $+ sep [ "piAbstract" <+> sep [ prettyTCM v <+> ":", nest 2 $ prettyTCM a ]+ , nest 2 $ "from" <+> prettyTCM b+ , nest 2 $ "-->" <+> prettyTCM fun ]+ reportSDoc "tc.abstract" 70 $+ sep [ "piAbstract" <+> sep [ (text . show) v <+> ":", nest 2 $ (text . show) a ]+ , nest 2 $ "from" <+> (text . show) b+ , nest 2 $ "-->" <+> (text . show) fun ]+ return fun++-- | @piAbstract (v, a) b[v] = (w : a) -> b[w]@+--+-- For the inspect idiom, it does something special:+-- @piAbstract (v, a) b[v, refl v] = (w : a) (w' : Eq a w v) -> b[w, w']+-- (Not all @refl v@ subterms are abstracted: see caveat below.)+--+-- For @rewrite@, it does something special:+-- @piAbstract (prf, Eq a v v') b[v,prf] = (w : a) (w' : Eq a w v') -> b[w, w']@++piAbstract :: Arg (Term, EqualityView) -> Type -> TCM Type+piAbstract (Arg info (v, OtherType a)) b = piAbstractTerm info v a b+piAbstract (Arg info (v, IdiomType a)) b = do+ refl <- getRefl+ eq <- addContext ("w" :: String, defaultDom a) $ do+ -- manufacture the type @w ≡ v@+ eqName <- primEqualityName+ eqTy <- defType <$> getConstInfo eqName+ -- E.g. @eqTy = eqTel → Set a@ where @eqTel = {a : Level} {A : Set a} (x y : A)@.+ TelV eqTel _ <- telView eqTy+ tel <- newTelMeta (telFromList $ dropEnd 3 $ telToList eqTel)+ let !eq = Def eqName $! map' Apply $! map' (setHiding Hidden) tel+ -- we write `v ≡ w` because this equality is typically used to+ -- get `v` to unfold to whatever pattern was used to refine `w`+ -- in a with-clause.+ -- If we were to write `w ≡ v`, we would often need to take the+ -- symmetric of the proof we get to make use of `rewrite`.+ ++! [ setHiding Hidden $ defaultArg $ raise 1 $ unEl a+ , defaultArg (raise 1 v)+ , defaultArg (var 0)+ ]+ -- Since the result of this function will be type-checked in+ -- `withFunctionType`, we can be a little lazy here and put+ -- a meta for the sort.+ sort <- newSortMeta+ return $ El sort eq++ -- ncf, 2026-01-12: we abstract over v as w first, then over @refl w@+ -- at type @v ≡ w@ so that we only replace those @refl v@ subterms of+ -- the original term that become ill-typed after abstracting v.+ b <- abstractType empty a v b+ b <- addContext ("w" :: String, defaultDom a) $+ abstractType empty eq (refl (defaultArg (var 0))) b++ pure $ mkPi (setHiding (getHiding info) $ defaultDom ("w", a))+ $ mkPi (setHiding NotHidden $ defaultDom ("eq", eq))+ $ b+piAbstract (Arg info (prf, EqualityViewType eqt@(EqualityTypeData r _ _ _ (Arg _ a) v _))) b = do+ s <- sortOf a+ let prfTy :: Type+ prfTy = equalityUnview eqt+ vTy = El s a+ -- Andreas, 2025-07-03, issue #7973+ -- We alert the user when the lhs of the equality proof could not be abstracted+ -- but not when the equality proof itself could not be abstracted.+ -- Only the former means that the rewrite did not fire.+ b <- abstractType empty prfTy prf b -- @empty@ means do not warn+ b <- addContext ("w" :: String, defaultDom prfTy) $+ -- Passing range @r@ here means warn if abstraction failed to abstract anything.+ abstractType r (raise 1 vTy) (unArg $ raise 1 v) b+ return . funType "lhs" vTy . funType "equality" eqTy' . swap01 $ b where- fun a b = El s $ Pi (Arg NotHidden Relevant a) $ mkAbs "w" b- where s = (sLub `on` getSort) a b+ funType str a = mkPi $ setArgInfo info $ defaultDom (str, a)+ -- Abstract the lhs (@a@) of the equality only.+ eqt1 :: EqualityTypeData+ eqt1 = raise 1 eqt+ eqTy' :: Type+ eqTy' = equalityUnview $ eqt1{ _eqtLhs = _eqtLhs eqt1 $> var 0 } -class AbstractTerm a where- -- | @subst u . abstractTerm u == id@- abstractTerm :: Term -> a -> a -instance AbstractTerm Term where- abstractTerm u v = case v of- v | u == v -> Var 0 []- Var i vs -> Var (i + 1) $ absT vs- Lam h b -> Lam h $ absT b- Def c vs -> Def c $ absT vs- Con c vs -> Con c $ absT vs- Pi a b -> uncurry Pi $ absT (a, b)- Lit l -> Lit l- Level l -> Level $ absT l- Sort s -> Sort $ absT s- MetaV m vs -> MetaV m $ absT vs- DontCare mv -> DontCare $ absT mv- where- absT x = abstractTerm u x+-- | @isPrefixOf u v = Just es@ if @v == u `applyE` es@.+class IsPrefixOf a where+ isPrefixOf :: a -> a -> Maybe Elims -instance AbstractTerm Type where- abstractTerm u (El s v) = El (abstractTerm u s) (abstractTerm u v)+instance IsPrefixOf Elims where+ isPrefixOf us vs = do+ (vs1, vs2) <- splitExactlyAt (length us) vs+ guard $ equalSy us vs1+ return vs2 -instance AbstractTerm Sort where- abstractTerm u s = case s of- Type n -> Type $ absS n- Prop -> Prop- Inf -> Inf- DLub s1 s2 -> DLub (absS s1) (absS s2)- where absS x = abstractTerm u x+instance IsPrefixOf Args where+ isPrefixOf us vs = do+ (vs1, vs2) <- splitExactlyAt (length us) vs+ guard $ equalSy us vs1+ return $! map' Apply vs2 -instance AbstractTerm Level where- abstractTerm u (Max as) = Max $ abstractTerm u as+instance IsPrefixOf Term where+ isPrefixOf u v =+ case (u, v) of+ (Var i us, Var j vs) | i == j -> us `isPrefixOf` vs+ (Def f us, Def g vs) | f == g -> us `isPrefixOf` vs+ (Con c _ us, Con d _ vs) | c == d -> us `isPrefixOf` vs+ (MetaV x us, MetaV y vs) | x == y -> us `isPrefixOf` vs+ (u, v) -> guard (equalSy u v) >> return [] -instance AbstractTerm PlusLevel where- abstractTerm u l@ClosedLevel{} = l- abstractTerm u (Plus n l) = Plus n $ abstractTerm u l+-- Type-based abstraction. Needed if @u@ is a constructor application (#745, fix of #5833).+-- Note that @a@ is the type of the new variable, not necessarily the+-- type of @u@: this allows the inspect idiom to abstract over ill-typed+-- subterms of the form @refl w : w ≡ v@ created by abstracting over @v@+-- (see 'piAbstract').+abstractTerm :: Type -> Term -> Type -> Term -> TCM Term+abstractTerm a u@Con{} b v = do+ reportSDoc "tc.abstract" 50 $+ sep [ "Abstracting"+ , nest 2 $ sep [ prettyTCM u <+> ":", nest 2 $ prettyTCM a ]+ , "over"+ , nest 2 $ sep [ prettyTCM v <+> ":", nest 2 $ prettyTCM b ] ]+ reportSDoc "tc.abstract" 70 $+ sep [ "Abstracting"+ , nest 2 $ sep [ (text . show) u <+> ":", nest 2 $ (text . show) a ]+ , "over"+ , nest 2 $ sep [ (text . show) v <+> ":", nest 2 $ (text . show) b ] ] -instance AbstractTerm LevelAtom where- abstractTerm u l = case l of- MetaLevel m vs -> MetaLevel m $ abstractTerm u vs- NeutralLevel v -> NeutralLevel $ abstractTerm u v- BlockedLevel _ v -> UnreducedLevel $ abstractTerm u v -- abstracting might remove the blockage- UnreducedLevel v -> UnreducedLevel $ abstractTerm u v+ hole <- qualify <$> currentModule <*> freshName_ ("hole" :: String)+ noMutualBlock $ addConstant' hole defaultArgInfo a defaultAxiom -instance AbstractTerm a => AbstractTerm (Arg a) where- abstractTerm = fmap . abstractTerm+ args <- map' Apply <$> getContextArgs+ let n = length args -instance AbstractTerm a => AbstractTerm [a] where- abstractTerm = fmap . abstractTerm+ let abstr b v = do+ m <- getContextSize+ let (a', u') = raise (m - n) (a, u)+ case u' `isPrefixOf` v of+ Nothing -> return v+ Just es -> do -- Check that the types match.+ s <- getTC+ do noConstraints $ equalType a' b+ putTC s+ return $! Def hole $! raise (m - n) args ++! es+ `catchError` \ _ -> do+ reportSDoc "tc.abstract.ill-typed" 50 $+ sep [ "Skipping ill-typed abstraction"+ , nest 2 $ sep [ prettyTCM v <+> ":", nest 2 $ prettyTCM b ] ]+ return v -instance AbstractTerm a => AbstractTerm (Maybe a) where- abstractTerm = fmap . abstractTerm+ -- #2763: This can fail if the user is with-abstracting incorrectly (for+ -- instance, abstracting over a first component of a sigma without also+ -- abstracting the second component). In this case we skip abstraction+ -- altogether and let the type check of the final with-function type produce+ -- the error message.+ res <- catchError_ (withFrozenMetas $ checkInternal' (defaultAction { preAction = abstr }) v CmpLeq b) $ \ err -> do+ reportSDoc "tc.abstract.ill-typed" 40 $+ "Skipping typed abstraction over ill-typed term" <?> (prettyTCM v <?> (":" <+> prettyTCM b))+ return v+ reportSDoc "tc.abstract" 50 $ "Resulting abstraction" <?> prettyTCM res+ modifySignature $ updateDefinitions $ HMap.delete hole+ return $ absTerm 0 (Def hole args) res -instance (Raise a, AbstractTerm a) => AbstractTerm (Abs a) where- abstractTerm u (NoAbs x v) = NoAbs x $ abstractTerm u v- abstractTerm u (Abs x v) = Abs x $ rename swap $ abstractTerm (raise 1 u) v+abstractTerm _ u _ v = return $ absTerm 0 u v -- Non-constructors can use untyped abstraction++class AbsTerm a where+ -- | @subst j u . absTerm j u == id@+ absTerm ::+ Nat -- ^ De Bruijn index that should be the placeholder for the abstracted term.+ -> Term -- ^ Term to abstract.+ -> a -- ^ Where to abstract.+ -> a -- ^ If the given de Bruijn index is free in the result, abstraction actually happened.++instance AbsTerm Term where+ absTerm j u v+ | Just es <- u `isPrefixOf` v = Var j $! absT es+ | otherwise =+ case v of+-- Andreas, 2013-10-20: the original impl. works only at base types+-- v | u == v -> Var j [] -- incomplete see succeed/WithOfFunctionType+ Var i vs -> (Var $! if i < j then i else i + 1) $! absT vs+ Lam h b -> Lam h $ absT b+ Def c vs -> Def c $! absT vs+ Con c ci vs -> Con c ci $! absT vs+ Pi a b -> uncurry Pi $ absT (a, b)+ Lit l -> Lit l+ Level l -> Level $ absT l+ Sort s -> Sort $ absT s+ MetaV m vs -> MetaV m $! absT vs+ DontCare mv -> DontCare $ absT mv+ Dummy s es -> Dummy s $ absT es+ where+ absT :: AbsTerm b => b -> b+ absT x = absTerm j u x++instance AbsTerm Type where+ absTerm j u (El s v) = El (absTerm j u s) (absTerm j u v)++instance AbsTerm Sort where+ absTerm j u = \case+ Univ u n -> Univ u $ absS n+ s@Inf{} -> s+ SizeUniv -> SizeUniv+ LockUniv -> LockUniv+ LevelUniv -> LevelUniv+ IntervalUniv -> IntervalUniv+ PiSort c a s1 s2 -> PiSort c (absS a) (absS s1) (absS s2)+ FunSort s1 s2 -> FunSort (absS s1) (absS s2)+ UnivSort s -> UnivSort $ absS s+ MetaS x es -> MetaS x $! absS es+ DefS d es -> DefS d $! absS es+ s@DummyS{} -> s where- swap 0 = 1- swap 1 = 0- swap i = i+ {-# INLINE absS #-}+ absS :: AbsTerm b => b -> b+ absS x = absTerm j u x -instance (AbstractTerm a, AbstractTerm b) => AbstractTerm (a, b) where- abstractTerm u (x, y) = (abstractTerm u x, abstractTerm u y)+instance AbsTerm Level where+ absTerm j u (Max n as) = Max n $ absTerm j u as++instance AbsTerm PlusLevel where+ absTerm j u (Plus n l) = Plus n $ absTerm j u l++instance AbsTerm a => AbsTerm (Elim' a) where+ absTerm j = fmap . absTerm j++instance AbsTerm a => AbsTerm (Arg a) where+ absTerm j = fmap . absTerm j++instance AbsTerm a => AbsTerm (Dom a) where+ absTerm j = fmap . absTerm j++instance AbsTerm a => AbsTerm [a] where+ absTerm j u as = map' (absTerm j u) as++instance AbsTerm a => AbsTerm (Maybe a) where+ absTerm j = fmap . absTerm j++instance (TermSubst a, AbsTerm a) => AbsTerm (Abs a) where+ absTerm j u (NoAbs x v) = NoAbs x $ absTerm j u v+ absTerm j u (Abs x v) = Abs x $ absTerm (j + 1) (raise 1 u) v++instance (AbsTerm a, AbsTerm b) => AbsTerm (a, b) where+ absTerm j u (x, y) = (absTerm j u x, absTerm j u y)++-- | This swaps @var 0@ and @var 1@.+swap01 :: TermSubst a => a -> a+swap01 = applySubst $ var 1 :# liftS 1 (raiseS 1)+++-- ** Equality of terms for the sake of with-abstraction.++-- The following could be parameterized by a record of flags+-- what parts of the syntax tree should be ignored.+-- For now, there is a fixed strategy.++class EqualSy a where+ equalSy :: a -> a -> Bool++instance EqualSy a => EqualSy [a] where+ equalSy [] [] = True+ equalSy (x:xs) (y:ys) = equalSy x y && equalSy xs ys+ equalSy _ _ = False++instance EqualSy Term where+ equalSy = curry $ \case+ (Var i vs, Var i' vs') -> i == i' && equalSy vs vs'+ (Con c _ es, Con c' _ es') -> c == c' && equalSy es es'+ (Def f es, Def f' es') -> f == f' && equalSy es es'+ (MetaV x es, MetaV x' es') -> x == x' && equalSy es es'+ (Lit l , Lit l' ) -> l == l'+ (Lam ai b, Lam ai' b') -> equalSy ai ai' && equalSy b b'+ (Level l , Level l' ) -> equalSy l l'+ (Sort s , Sort s' ) -> equalSy s s'+ (Pi a b , Pi a' b' ) -> equalSy a a' && equalSy b b'+ (DontCare _, DontCare _ ) -> True+ -- Irrelevant things are syntactically equal.+ (Dummy{} , _ ) -> __IMPOSSIBLE__+ (_ , Dummy{} ) -> __IMPOSSIBLE__+ _ -> False++instance EqualSy Level where+ equalSy (Max n vs) (Max n' vs') = n == n' && equalSy vs vs'++instance EqualSy PlusLevel where+ equalSy (Plus n v) (Plus n' v') = n == n' && equalSy v v'++instance EqualSy Sort where+ equalSy = curry $ \case+ (Univ u l , Univ u' l' ) -> u == u' && equalSy l l'+ (Inf u m , Inf u' n ) -> u == u' && m == n+ (SizeUniv , SizeUniv ) -> True+ (LevelUniv , LevelUniv ) -> True+ (PiSort a b c d, PiSort a' b' c' d') ->+ equalSy a a' && equalSy b b' && equalSy c c' && equalSy d d'+ (FunSort a b, FunSort a' b') -> equalSy a a' && equalSy b b'+ (UnivSort a, UnivSort a' ) -> equalSy a a'+ (MetaS x es, MetaS x' es') -> x == x' && equalSy es es'+ (DefS d es, DefS d' es') -> d == d' && equalSy es es'+ (DummyS{} , _ ) -> __IMPOSSIBLE__+ (_ , DummyS{} ) -> __IMPOSSIBLE__+ _ -> False++instance EqualSy a => EqualSy (BlockedDepCheck a) where+ equalSy = curry \case+ (CodomainSortOld s, CodomainSortOld s') -> equalSy s s'+ (CodomainSortSame, CodomainSortSame) -> True+ _ -> False++-- | Ignores sorts.+instance EqualSy Type where+ equalSy = equalSy `on` unEl++instance EqualSy a => EqualSy (Elim' a) where+ equalSy = curry $ \case+ (Proj _ f, Proj _ f') -> f == f'+ (Apply a, Apply a') -> equalSy a a'+ (IApply u v r, IApply u' v' r') ->+ equalSy u u'+ && equalSy v v'+ && equalSy r r'+ _ -> False++-- | Ignores 'absName'.+instance (Subst a, EqualSy a) => EqualSy (Abs a) where+ equalSy = curry $ \case+ (NoAbs _x b, NoAbs _x' b') -> equalSy b b'+ (Abs _ b , Abs _ b' ) -> equalSy b b'+ (a , a' ) -> equalSy (absBody a) (absBody a')++-- | Ignore origin and free variables.+instance EqualSy ArgInfo where+ equalSy (ArgInfo h m _o _fv a) (ArgInfo h' m' _o' _fv' a') =+ h == h' && m == m' && a == a'++-- | Ignore the tactic and rewrite.+instance EqualSy a => EqualSy (Dom a) where+ equalSy d@(Dom ai x f _tac _rew a) d'@(Dom ai' x' f' _tac' _rew' a') = and+ [ x == x'+ , f == f'+ , equalSy ai ai'+ , equalSy a a'+ ]++-- | Ignores irrelevant arguments and modality.+-- (And, of course, origin and free variables).+instance EqualSy a => EqualSy (Arg a) where+ equalSy (Arg (ArgInfo h m _o _fv a) v) (Arg (ArgInfo h' m' _o' _fv' a') v') =+ h == h' && (isIrrelevant m || isIrrelevant m' || equalSy v v')+ -- Andreas, 2017-10-04, issue #2775,+ -- ignore irrelevant arguments during with-abstraction.+ -- 2019-07-05, issue #3889, don't ignore quantity during caching+ -- this is why we let equalSy replace (==).
@@ -0,0 +1,425 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- Initially authored by Andreas, 2013-10-22.++-- | A bidirectional type checker for internal syntax.+--+-- Performs checking on unreduced terms.+-- With the exception that projection-like function applications+-- have to be reduced since they break bidirectionality.++module Agda.TypeChecking.CheckInternal+ ( checkType, infer, inferSpine+ , CheckInternal(..)+ , Action(..), defaultAction, eraseUnusedAction+ ) where++import Control.Monad++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Common.Pretty (prettyShow)++import Agda.TypeChecking.Conversion+import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Level+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.ProjectionLike (elimView, LoneProjectionLikeToLambda(..))+import Agda.TypeChecking.Records (shouldBeProjectible)+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Sort+import Agda.TypeChecking.Telescope++import Agda.Utils.Function (applyWhen, applyWhenM)+import Agda.Utils.Functor (($>))+import Agda.Utils.Maybe+import Agda.Utils.Size+import Agda.Utils.Tuple (fst3, snd3)++import Agda.Utils.Impossible++import Agda.Interaction.Options+import Agda.TypeChecking.Reduce (instantiate)++-- * Bidirectional rechecker++-- | Entry point for e.g. checking WithFunctionType.+checkType :: Type -> TCM ()+checkType t = catchConstraint (CheckType t) $ inferInternal t++-- | 'checkInternal' traverses the whole 'Term', and we can use this+-- traversal to modify the term.+data Action = Action+ { preAction :: Type -> Term -> TCM Term+ -- ^ Called on each subterm before the checker runs.+ , postAction :: Type -> Term -> TCM Term+ -- ^ Called on each subterm after the type checking.+ , modalityAction :: Modality -> Modality -> Modality+ -- ^ Called for each @ArgInfo@.+ -- The first 'Modality' is from the type,+ -- the second from the term.+ , elimViewAction :: Term -> TCM Term+ -- ^ Called for bringing projection-like funs in post-fix form+ }++-- | The default action is to not change the 'Term' at all.+defaultAction :: Action+defaultAction = Action+ { preAction = \ _ -> return+ , postAction = \ _ -> return+ , modalityAction = \ _ -> id+ , elimViewAction = elimView LoneProjectionLikeToLambda+ }++eraseUnusedAction :: Action+eraseUnusedAction = defaultAction { postAction = eraseUnused }+ where+ eraseUnused :: Type -> Term -> TCM Term+ eraseUnused t = \case+ Def f es -> do+ pols <- getPolarity f+ return $ Def f $ eraseIfNonvariant pols es+ v -> return v++ eraseIfNonvariant :: [Polarity] -> Elims -> Elims+ eraseIfNonvariant [] es = es+ eraseIfNonvariant pols [] = []+ eraseIfNonvariant (Nonvariant : pols) (e : es) = (fmap dontCare e) : eraseIfNonvariant pols es+ eraseIfNonvariant (_ : pols) (e : es) = e : eraseIfNonvariant pols es++class CheckInternal a where+ checkInternal' :: Action -> a -> Comparison -> TypeOf a -> TCM a++ checkInternal :: a -> Comparison -> TypeOf a -> TCM ()+ checkInternal v cmp t = void $ checkInternal' defaultAction v cmp t++ inferInternal' :: (TypeOf a ~ ()) => Action -> a -> TCM a+ inferInternal' act v = checkInternal' act v CmpEq ()++ inferInternal :: (TypeOf a ~ ()) => a -> TCM ()+ inferInternal v = checkInternal v CmpEq ()+++instance CheckInternal Type where+ checkInternal' action (El s t) cmp _ = do+ reportSDoc "tc.check.internal" 20 $ sep+ [ "checking internal type "+ , nest 2 $ sep [ prettyTCM t <+> ":"+ , nest 2 $ prettyTCM s ]+ ]+ t' <- checkInternal' action t cmp (sort s)+ -- Nathaniel, 2026-10-25: We used to reinfer the sort and check against it+ -- here, but @checkInternal'@ for @Term@ should already check the sort, so+ -- this was redundant+ --+ -- s' <- sortOf t'+ -- reportSDoc "tc.check.internal" 30 $+ -- "checking if sort" <+> prettyTCM s' <+>+ -- "of" <+> prettyTCM t' <+>+ -- "fits in given sort" <+> prettyTCM s+ -- compareSort cmp s' s+ return (El s t')++instance CheckInternal Term where+ checkInternal' :: Action -> Term -> Comparison -> Type -> TCM Term+ checkInternal' action v cmp t = verboseBracket "tc.check.internal" 20 "" $ do++ -- Debug print+ verboseS "tc.check.internal" 20 do+ reportSDoc "tc.check.internal" 20 $ sep+ [ "checking internal "+ , nest 2 $ sep [ prettyTCM v <+> ":"+ , nest 2 $ prettyTCM t ] ]+ reportSDoc "tc.check.internal" 60 $ sep+ [ "checking internal with DB indices"+ , nest 2 $ sep [ pretty v <+> ":"+ , nest 2 $ pretty t ] ]+ ctx <- getContextTelescope+ unless (null ctx) $ reportSDoc "tc.check.internal" 30 $ sep+ [ "In context"+ , nest 2 $ sep [ prettyTCM ctx ] ]++ -- Bring projection-like funs in post-fix form,+ -- (even lone ones by default).+ v <- elimViewAction action =<< preAction action t v+ postAction action t =<< case v of+ Var i es -> do+ d <- domOfBV i+ n <- nameOfBV i++ -- Lucas, 23-11-2022:+ -- For now we only check if pure modalities are respected.+ -- In the future we SHOULD also be doing the same checks for every modality, as in Rules/Applications.hs+ -- (commented below)+ -- but this will break stuff that is allowed right now++ reportSDoc "tc.check.internal" 30 $ fsep+ [ "variable" , prettyTCM (var i) , "has type" , prettyTCM (unDom d)+ , "and modality", pretty (getModality d)+ ]++ unless (usableCohesion d) $+ typeError $ VariableIsOfUnusableCohesion n (getCohesion d)++ unless (usablePolarity d) $+ typeError $ VariableIsOfUnusablePolarity n (getModalPolarity d)++ checkSpine action (unDom d) (Var i) es cmp t+ Def f es -> do -- f is not projection(-like)!+ -- There is no "implicitely applied module telescope" at this stage, so no+ -- need to check it for modal errors, everything is covered by the+ -- variable rule!+ a <- defType <$> getConstInfo f+ checkSpine action a (Def f) es cmp t+ MetaV x es -> do -- we assume meta instantiations to be well-typed+ a <- metaType x+ reportSDoc "tc.check.internal" 30 $ "metavariable" <+> prettyTCM x <+> "has type" <+> prettyTCM a+ checkSpine action a (MetaV x) es cmp t+ Con c ci vs -> do+ -- We need to fully apply the constructor to make getConType work!+ fullyApplyCon c vs t $ \ _d _dt _pars a vs' tel t -> do+ checkSpine action a (Con c ci) vs' cmp t >>= \case+ Con c ci vs2 ->+ -- Strip away the extra arguments+ return $ applySubst (strengthenS impossible (size tel))+ $ Con c ci $ take (length vs) vs2+ _ -> __IMPOSSIBLE__+ Lit l -> do+ lt <- litType l+ compareType cmp lt t+ return $ Lit l+ Lam ai vb -> do+ (a, b) <- shouldBePiOrPath t+ ai <- checkArgInfo action ai $ domInfo a+ let name = suggests [ Suggestion vb , Suggestion b ]+ addContext (name, a) $ do+ Lam ai . Abs (absName vb) <$> checkInternal' action (absBody vb) cmp (absBody b)+ Pi a b -> do+ s <- shouldBeSort t+ reportSDoc "tc.check.internal" 30 $ "pi type should have sort" <+> prettyTCM s+ when (s == SizeUniv) $ typeError $ FunctionTypeInSizeUniv v+ experimental <- optExperimentalIrrelevance <$> pragmaOptions+ let sa = getSort a+ sb = getSort (unAbs b)+ mkDom v = El sa v <$ a+ mkRng v = fmap (v <$) b+ -- Preserve NoAbs+ goInside = case b of+ Abs{} -> addContext $ (absName b,) $+ inverseApplyPolarity (withStandardLock UnusedPolarity) $+ applyWhen experimental (mapRelevance irrelevantToShapeIrrelevant) a+ NoAbs{} -> id+ a <- applyWhenM (optPolarity <$> pragmaOptions) (applyPolarityToContext negativePolarity) $+ mkDom <$> checkInternal' action (unEl $ unDom a) CmpLeq (sort sa)+ v' <- goInside $ Pi a . mkRng <$> checkInternal' action (unEl $ unAbs b) CmpLeq (sort sb)+ s' <- sortOf v -- Issue #6205: do not use v' since it might not be valid syntax+ reportSDoc "tc.check.internal" 30 $+ "checking if sort" <+> prettyTCM s' <+>+ "of pi type" <+> prettyTCM v <+>+ "fits in given sort" <+> prettyTCM s+ -- Pi types do not contain enough information to reconstruct their+ -- sort uniquely. Specifically, the pi might have originally been+ -- level-dependent and so ended up in Setω, but now that level+ -- dependency has vanished (in an ideal world we would track the+ -- fact the pi is level dependent in the pi type itself, but+ -- we do not live in an ideal world).+ -- Therefore, the double checker needs to check pi sorts in a relaxed.+ -- way. For simplicity, we over-approximate this by using 'CmpLeq'.+ compareSort CmpLeq s' s+ return v'+ Sort s -> do+ reportSDoc "tc.check.internal" 30 $ "checking sort" <+> prettyTCM s+ s <- inferInternal' action s+ s' <- inferUnivSort s+ s'' <- shouldBeSort t+ reportSDoc "tc.check.internal" 30 $+ "checking if sort" <+> prettyTCM s' <+>+ "of universe type" <+> prettyTCM v <+>+ "fits in" <+> prettyTCM t+ compareSort cmp s' s''+ return $ Sort s+ Level l -> do+ l <- inferInternal' action l+ lt <- levelType'+ compareType cmp lt t+ return $ Level l+ DontCare v -> DontCare <$> checkInternal' action v cmp t+ -- Jesper, 2023-02-23: these can appear because of eta-expansion of+ -- records with irrelevant fields+ Dummy s _ -> return v -- __IMPOSSIBLE_VERBOSE__ s++-- | @checkArgInfo actual expected@.+--+-- The @expected@ 'ArgInfo' comes from the type.+-- The @actual@ 'ArgInfo' comes from the term and can be updated+-- by an action.+checkArgInfo :: Action -> ArgInfo -> ArgInfo -> TCM ArgInfo+checkArgInfo action ai ai' = do+ checkHiding (getHiding ai) (getHiding ai')+ mod <- checkModality action (getModality ai) (getModality ai')+ return $ setModality mod ai++checkHiding :: Hiding -> Hiding -> TCM ()+checkHiding h h' = unless (sameHiding h h') $ typeError $ HidingMismatch h h'++-- | @checkRelevance action term type@.+--+-- The @term@ 'Relevance' can be updated by the @action@.+checkModality :: Action -> Modality -> Modality -> TCM Modality+checkModality action mod mod' = do+ let (r,r') = (getRelevance mod, getRelevance mod')+ (q,q') = (getQuantity mod, getQuantity mod')+ unless (sameModality mod mod') $ typeError $ if+ | not (sameRelevance r r') -> RelevanceMismatch r r'+ | not (sameQuantity q q') -> QuantityMismatch q q'+ | otherwise -> __IMPOSSIBLE__ -- add more cases when adding new modalities+ return $ modalityAction action mod' mod -- Argument order for actions: @type@ @term@++-- | Infer type of a neutral term.+infer :: Term -> TCM Type+infer u = do+ reportSDoc "tc.check.internal" 20 $ "CheckInternal.infer" <+> prettyTCM u+ case u of+ Var i es -> do+ a <- typeOfBV i+ fst3 <$> inferSpine defaultAction a (Var i) es+ Def f es -> do+ whenJustM (isRelevantProjection f) $ \_ -> nonInferable+ a <- defType <$> getConstInfo f+ fst3 <$> inferSpine defaultAction a (Def f) es+ MetaV x es -> do -- we assume meta instantiations to be well-typed+ a <- metaType x+ fst3 <$> inferSpine defaultAction a (MetaV x) es+ _ -> nonInferable+ where+ nonInferable :: MonadDebug m => m a+ nonInferable = __IMPOSSIBLE_VERBOSE__ $ unlines+ [ "CheckInternal.infer: non-inferable term:"+ , " " ++ prettyShow u+ ]++instance CheckInternal Elims where+ checkInternal' action es cmp (t , hd) = snd3 <$> inferSpine action t hd es++-- | @inferSpine action t hd es@ checks that spine @es@ eliminates+-- value @hd []@ of type @t@ and returns the remaining type+-- (target of elimination), the transformed eliminations, and the+-- transformed term.+--+-- The transformed term is /not/ simply @hd@ applied to the transformed+-- eliminations: 'elimViewAction' brings prefix applications of+-- projection-like functions into post-fix form, and that has to be undone+-- when rebuilding the term, or we hand back a term in a representation+-- the conversion checker cannot relate to the original one+-- (issues #8336 and #8771).+inferSpine :: Action -> Type -> (Elims -> Term) -> Elims -> TCM (Type, Elims, Term)+inferSpine action t hd es = loop t hd id hd es+ where+ loop t hd accEs accTm = \case+ [] -> return (t , accEs [] , accTm [])+ (e : es) -> do+ let self = hd []+ reportSDoc "tc.check.internal" 30 $ sep+ [ "inferring spine: "+ , "type t = " <+> prettyTCM t+ , "self = " <+> prettyTCM self+ , "eliminated by e = " <+> prettyTCM e+ ]+ case e of+ IApply x y r -> do+ (a, b) <- shouldBePath t+ r' <- checkInternal' action r CmpLeq (unDom a)+ izero <- primIZero+ ione <- primIOne+ x' <- checkInternal' action x CmpLeq (b `absApp` izero)+ y' <- checkInternal' action y CmpLeq (b `absApp` ione)+ let e' = IApply x' y' r'+ loop (b `absApp` r) (hd . (e:)) (accEs . (e':)) (accTm . (e':)) es+ Apply (Arg ai v) -> do+ (a, b) <- shouldBePi t+ ai <- checkArgInfo action ai $ domInfo a+ v' <- applyDomToContext a $ checkInternal' action v CmpLeq $ unDom a+ let e' = Apply (Arg ai v')+ loop (b `absApp` v) (hd . (e:)) (accEs . (e':)) (accTm . (e':)) es+ -- case: projection or projection-like+ Proj o f -> do+ t' <- shouldBeProjectible self t o f+ -- Jesper, issue #8336: turn projection-like functions back into Defs.+ -- Andreas, issue #8771: this has to happen for the transformed term+ -- as well, not just for @hd@, or the two get out of sync.+ proj <- fromMaybe __IMPOSSIBLE__ <$> isProjection f+ let applyProj :: (Elims -> Term) -> (Elims -> Term)+ applyProj h+ | isProperProjection_ proj = h . (e:)+ | otherwise = Def f . (Apply (projFromType proj $> h []) :)+ loop t' (applyProj hd) (accEs . (e:)) (applyProj accTm) es++checkSpine ::+ Action+ -> Type -- ^ Type of the head @self@.+ -> (Elims -> Term) -- ^ The head @hd@.+ -> Elims -- ^ The eliminations @es@.+ -> Comparison -- ^ Check (@CmpLeq@) or infer (@CmpEq@) the final type.+ -> Type -- ^ Expected type of the application @self es@.+ -> TCM Term -- ^ The application after modification by the @Action@.+checkSpine action a hd es cmp t = do+ reportSDoc "tc.check.internal" 20 $ sep+ [ "checking spine "+ , nest 2 $ sep [ parens (sep [ prettyTCM (hd []) <+> ":"+ , nest 2 $ prettyTCM a ])+ , nest 4 $ prettyTCM es <+> ":"+ , nest 2 $ prettyTCM t ] ]+ (t' , _es' , v') <- inferSpine action a hd es+ reportSDoc "tc.check.internal" 30 $ sep+ [ "checking if "+ , prettyTCM t'+ , "is a subtype of"+ , prettyTCM t+ ]+ reportSDoc "tc.check.internal" 70 $ sep+ [ "checking if (raw)"+ , pretty =<< instantiate t'+ , "is a subtype of (raw)"+ , pretty =<< instantiate t+ ]+ coerceSize cmp (hd es) t' t+ return v'++instance CheckInternal Sort where+ checkInternal' action s cmp _ = case s of+ Univ u l -> Univ u <$> inferInternal' action l+ Inf u n -> return $ Inf u n+ SizeUniv -> return SizeUniv+ LockUniv -> return LockUniv+ LevelUniv -> return LevelUniv+ IntervalUniv -> return IntervalUniv+ PiSort c dom s1 s2 -> do+ let a = unDom dom+ s1' <- inferInternal' action s1+ a' <- checkInternal' action a CmpLeq $ sort s1'+ let dom' = dom $> a'+ s2' <- mapAbstraction (El s1' <$> dom') (inferInternal' action) s2+ return $ PiSort c dom' s1' s2'+ FunSort s1 s2 -> do+ s1' <- inferInternal' action s1+ s2' <- inferInternal' action s2+ return $ FunSort s1' s2'+ UnivSort s -> UnivSort <$> inferInternal' action s+ MetaS x es -> do -- we assume sort meta instantiations to be well-formed+ a <- metaType x+ MetaS x <$> checkInternal' action es cmp (a , Sort . MetaS x)+ DefS d es -> do+ a <- defType <$> getConstInfo d+ DefS d <$> checkInternal' action es cmp (a , Sort . DefS d)+ DummyS s -> __IMPOSSIBLE_VERBOSE__ s++instance CheckInternal Level where+ checkInternal' action (Max n ls) _ _ = Max n <$> mapM (inferInternal' action) ls++instance CheckInternal PlusLevel where+ checkInternal' action (Plus k l) _ _ = Plus k <$> checkLevelAtom l+ where+ checkLevelAtom l = do+ lvl <- levelType'+ checkInternal' action l CmpLeq lvl
@@ -0,0 +1,35 @@++{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE KindSignatures #-}++module Agda.TypeChecking.CheckInternal where++import Agda.Syntax.Internal+import Agda.TypeChecking.Monad++data Action++defaultAction :: Action+eraseUnusedAction :: Action++class CheckInternal a where+ checkInternal' :: Action -> a -> Comparison -> TypeOf a -> TCM a++ checkInternal :: a -> Comparison -> TypeOf a -> TCM ()+ checkInternal v cmp t = void $ checkInternal' defaultAction v cmp t++ inferInternal' :: (TypeOf a ~ ()) => Action -> a -> TCM a+ inferInternal' act v = checkInternal' act v CmpEq ()++ inferInternal :: (TypeOf a ~ ()) => a -> TCM ()+ inferInternal v = checkInternal v CmpEq ()++instance CheckInternal Term+instance CheckInternal Type+instance CheckInternal Sort+instance CheckInternal Level+instance CheckInternal Elims++checkType :: Type -> TCM ()+infer :: Term -> TCM Type
@@ -1,69 +1,272 @@-{-# LANGUAGE TypeOperators, CPP, DeriveDataTypeable, DeriveFunctor #-}+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Case trees.+--+-- After coverage checking, pattern matching is translated+-- to case trees, i.e., a tree of successive case splits+-- on one variable at a time.+ module Agda.TypeChecking.CompiledClause where +import Prelude hiding (null)++import Control.DeepSeq+ import qualified Data.Map as Map import Data.Map (Map)-import Data.Monoid-import Data.Generics+import Data.Semigroup (Any(..)) +import GHC.Generics (Generic)+ import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Internal.Generic import Agda.Syntax.Literal-import Agda.Utils.Pretty+import Agda.Syntax.Position -type key :-> value = Map key value+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty -data Case c = Branches { conBranches :: QName :-> c- , litBranches :: Literal :-> c- , catchAllBranch :: Maybe c- }- deriving (Typeable, Data, Functor)+import Agda.Utils.Impossible -data CompiledClauses- = Case Int (Case CompiledClauses)+-- | The number of a 'Clause' (starting with 0) in the clause list of a 'FunctionData'.+type ClauseNumber = Int++data WithArity c = WithArity { arity :: Int, content :: c }+ deriving (Functor, Foldable, Traversable, Show, Generic)++-- | Branches in a case tree.++data Case c = Branches+ { projPatterns :: !Bool+ -- ^ We are constructing a record here (copatterns).+ -- 'conBranches' lists projections.+ , conBranches :: !(Map QName (WithArity c))+ -- ^ Map from constructor (or projection) names to their arity+ -- and the case subtree. (Projections have arity 0.)+ , etaBranch :: !(Maybe (ConHead, WithArity c))+ -- ^ Eta-expand with the given (eta record) constructor. If this is+ -- present, there should not be any conBranches or litBranches.+ , litBranches :: !(Map Literal c)+ -- ^ Map from literal to case subtree.+ , catchallBranch :: !(Maybe c)+ -- ^ (Possibly additional) catch-all clause.+ , fallThrough :: !(Maybe Bool)+ -- ^ (if True) In case of non-canonical argument use catchallBranch.+ , lazyMatch :: !Bool+ -- ^ Lazy pattern match. Requires single (non-copattern) branch with no lit+ -- branches and no catch-all.+ }+ deriving (Functor, Foldable, Traversable, Show, Generic)++type CompiledClauses = CompiledClauses' Term++-- | Case tree with bodies.++data CompiledClauses' a+ = Case !(Arg Int) !(Case (CompiledClauses' a)) -- ^ @Case n bs@ stands for a match on the @n@-th argument -- (counting from zero) with @bs@ as the case branches.- | Done [Arg String] Term- -- ^ @Done xs b@ stands for the body @b@ where the @xs@ contains hiding- -- and name suggestions for the free variables. This is needed to build- -- lambdas on the right hand side for partial applications which can- -- still reduce.- | Fail- -- ^ Absurd case.- deriving (Typeable, Data)+ -- If the @n@-th argument is a projection, we have only 'conBranches'+ -- with arity 0.+ | Done_ !(CCDone a)+ | Fail ![Arg ArgName]+ -- ^ Absurd case. Add the free variables here as well so we can build correct+ -- number of lambdas for strict backends. (#4280)+ deriving (Functor, Traversable, Foldable, Show, Generic) -litCase l x = Branches Map.empty (Map.singleton l x) Nothing-conCase c x = Branches (Map.singleton c x) Map.empty Nothing-catchAll x = Branches Map.empty Map.empty (Just x)+{-# COMPLETE Case, Done, Fail #-} -instance Monoid m => Monoid (Case m) where- mempty = Branches Map.empty Map.empty Nothing- mappend (Branches cs ls m)- (Branches cs' ls' m') =- Branches (Map.unionWith mappend cs cs')- (Map.unionWith mappend ls ls')- (mappend m m')+-- | Data stored in 'Done' nodes of the case tree.+-- @CCDone no mr xs b@ stands for the body @b@ where the @xs@ contains hiding+-- and name suggestions for the free variables. This is needed to build+-- lambdas on the right hand side for partial applications which can+-- still reduce.+-- The @no@ is the number of the original 'Clause' this case tree leaf comes from.+-- @mr@ tells whether this body contains calls to the mutually recursive functions.+data CCDone a = CCDone+ { ccClauseNumber :: !ClauseNumber+ , ccClauseRecursive :: !ClauseRecursive+ , ccBoundVars :: ![Arg ArgName]+ , ccBody :: a+ }+ deriving (Functor, Traversable, Foldable, Show, Generic) -instance Pretty a => Show (Case a) where- show = show . pretty-instance Show CompiledClauses where- show = show . pretty+pattern Done :: ClauseNumber -> ClauseRecursive -> [Arg ArgName] -> a -> CompiledClauses' a+pattern Done no mr xs b = Done_ (CCDone no mr xs b) +litCase :: Literal -> c -> Case c+litCase l x = Branches False Map.empty Nothing (Map.singleton l x) Nothing (Just False) False++conCase :: QName -> Bool -> WithArity c -> Case c+conCase c b x = Branches False (Map.singleton c x) Nothing Map.empty Nothing (Just b) False++etaCase :: ConHead -> WithArity c -> Case c+etaCase c x = Branches False Map.empty (Just (c, x)) Map.empty Nothing (Just False) True++projCase :: QName -> c -> Case c+projCase c x = Branches True (Map.singleton c $ WithArity 0 x) Nothing Map.empty Nothing (Just False) False++catchall :: c -> Case c+catchall x = Branches False Map.empty Nothing Map.empty (Just x) (Just True) False++-- | Check that the requirements on lazy matching (single inductive case) are+-- met, and set lazy to False otherwise.+checkLazyMatch :: Case c -> Case c+checkLazyMatch b = b { lazyMatch = lazyMatch b && requirements }+ where+ requirements = and+ [ null (catchallBranch b)+ , Map.size (conBranches b) <= 1+ , null (litBranches b)+ , not $ projPatterns b ]++-- | Check whether a case tree has a catch-all clause.+hasCatchall :: CompiledClauses -> Bool+hasCatchall = getAny . loop+ where+ loop cc = case cc of+ Fail{} -> mempty+ Done{} -> mempty+ Case _ br -> maybe (foldMap loop br) (const $ Any True) $ catchallBranch br++-- | Check whether a case tree has any projection patterns+hasProjectionPatterns :: CompiledClauses -> Bool+hasProjectionPatterns = getAny . loop+ where+ loop cc = case cc of+ Fail{} -> mempty+ Done{} -> mempty+ Case _ br -> Any (projPatterns br) <> foldMap loop br++---------------------------------------------------------------------------+-- * Traversing the 'Done' leaves++class MapDone f where+ mapDone :: (CCDone a -> CCDone b) -> f a -> f b++-- instance MapDone CCDone where+-- mapDone = id++instance MapDone CompiledClauses' where+ mapDone f = \case+ Case n bs -> Case n $ fmap (mapDone f) bs+ Done_ done -> Done_ $ f done+ Fail xs -> Fail xs++---------------------------------------------------------------------------+-- Collection instances++instance Semigroup c => Semigroup (WithArity c) where+ WithArity n1 c1 <> WithArity n2 c2+ | n1 == n2 = WithArity n1 (c1 <> c2)+ | otherwise = __IMPOSSIBLE__ -- arity must match!++instance (Monoid c) => Monoid (WithArity c) where+ mempty = WithArity __IMPOSSIBLE__ mempty+ mappend = (<>)++instance Semigroup m => Semigroup (Case m) where+ Branches cop cs eta ls m b lazy <> Branches cop' cs' eta' ls' m' b' lazy' = checkLazyMatch $+ Branches (cop || cop') -- for @projCase <> mempty@+ (Map.unionWith (<>) cs cs')+ (unionEta eta eta')+ (Map.unionWith (<>) ls ls')+ (m <> m')+ (combine b b')+ (lazy && lazy')+ where+ combine Nothing b' = b+ combine b Nothing = b+ combine (Just b) (Just b') = Just $ b && b'++ unionEta Nothing b = b+ unionEta b Nothing = b+ unionEta Just{} Just{} = __IMPOSSIBLE__++instance (Monoid m) => Monoid (Case m) where+ mempty = empty+ mappend = (<>)++instance Null (Case m) where+ empty = Branches False Map.empty Nothing Map.empty Nothing Nothing True+ null (Branches _cop cs eta ls mcatch _b _lazy) = null cs && null eta && null ls && null mcatch++---------------------------------------------------------------------------+-- Pretty instances++instance Pretty a => Pretty (WithArity a) where+ pretty = pretty . content+ instance Pretty a => Pretty (Case a) where- prettyPrec p (Branches cs ls m) =- mparens (p > 0) $ vcat $- pr cs ++ pr ls ++ prC m+ prettyPrec p (Branches _cop cs eta ls m b lazy) =+ mparens (p > 0) $ prLazy lazy <+> vcat (prettyMap_ cs ++ prEta eta ++ prettyMap_ ls ++ prC m) where+ prLazy True = "~"+ prLazy False = empty prC Nothing = []- prC (Just x) = [text "_ ->" <+> pretty x]- pr m = [ sep [ text (show x ++ " ->")- , nest 2 $ pretty v ]- | (x, v) <- Map.toList m ]+ prC (Just x) = ["_ ->" <+> pretty x]+ prEta Nothing = []+ prEta (Just (c, cc)) = [("eta" <+> pretty c <+> "->") <?> pretty cc] -instance Pretty CompiledClauses where- pretty (Done hs t) = text ("done" ++ show hs) <+> text (show t)- pretty Fail = text "fail"- pretty (Case n bs) =- sep [ text ("case " ++ show n ++ " of")+prettyMap_ :: (Pretty k, Pretty v) => Map k v -> [Doc]+prettyMap_ = map prettyAssign . Map.toList++instance Pretty a => Pretty (CompiledClauses' a) where+ pretty (Done_ done) = pretty done+ pretty Fail{} = "fail"+ pretty (Case n bs) | projPatterns bs =+ sep [ "record" , nest 2 $ pretty bs ]+ pretty (Case n bs) =+ text ("case " ++ prettyShow n ++ " of") <?> pretty bs++instance Pretty a => Pretty (CCDone a) where+ pretty (CCDone no mr xs t) = ("done" <+> (pretty no <> pretty mr <> ":") <+> pretty xs) <?> prettyPrec 10 t++---------------------------------------------------------------------------+-- KillRange instances++instance KillRange c => KillRange (WithArity c) where+ killRange = fmap killRange++instance KillRange c => KillRange (Case c) where+ killRange (Branches cop con eta lit all b lazy) = Branches cop+ (killRangeMap con)+ (killRange eta)+ (killRangeMap lit)+ (killRange all)+ b lazy++instance KillRange CompiledClauses where+ killRange (Case i br) = killRangeN Case i br+ killRange (Done no mr xs v) = killRangeN Done no mr xs v+ killRange (Fail xs) = killRangeN Fail xs++---------------------------------------------------------------------------+-- TermLike instances++instance TermLike a => TermLike (WithArity a) where+ traverseTermM = traverse . traverseTermM+ foldTerm = foldMap . foldTerm++instance TermLike a => TermLike (Case a) where+ traverseTermM = traverse . traverseTermM+ foldTerm = foldMap . foldTerm++instance TermLike a => TermLike (CompiledClauses' a) where+ traverseTermM = traverse . traverseTermM+ foldTerm = foldMap . foldTerm++instance TermLike a => TermLike (CCDone a) where+ traverseTermM = traverse . traverseTermM+ foldTerm = foldMap . foldTerm++---------------------------------------------------------------------------+-- NFData instances++instance NFData c => NFData (WithArity c)+instance NFData a => NFData (Case a)+instance NFData a => NFData (CompiledClauses' a)+instance NFData a => NFData (CCDone a)
@@ -1,124 +1,444 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-}+ module Agda.TypeChecking.CompiledClause.Compile where -import Data.Monoid+import Prelude hiding (null)++import Control.Applicative+import Control.Monad+import Control.Monad.Trans.Identity++import Data.Maybe+import Data.List (partition) import qualified Data.Map as Map-import Data.List (genericReplicate, nubBy)-import Data.Function import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Coverage+import Agda.TypeChecking.Coverage.SplitTree import Agda.TypeChecking.Monad import Agda.TypeChecking.RecordPatterns import Agda.TypeChecking.Substitute import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Free.Precompute+import Agda.TypeChecking.Reduce++import Agda.Utils.Functor+import Agda.Utils.Maybe import Agda.Utils.List+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Utils.Size+import Agda.Utils.Update import Agda.Utils.Impossible-#include "../../undefined.h" +data RunRecordPatternTranslation = RunRecordPatternTranslation | DontRunRecordPatternTranslation+ deriving (Eq)++compileClauses' :: QName -> RunRecordPatternTranslation -> [Clause] -> Maybe SplitTree -> TCM CompiledClauses+compileClauses' q recpat cs mSplitTree = do++ -- Throw away the unreachable clauses (#2723).+ let notUnreachable = (Just True /=) . clauseUnreachable+ cs <- map' unBruijn <$> normaliseProjP (filter (notUnreachable . snd) $ zip' [0..] cs)++ let translate | recpat == RunRecordPatternTranslation = runIdentityT . translateCompiledClauses q+ | otherwise = return++ translate $ caseMaybe mSplitTree (compile cs) $ \splitTree ->+ compileWithSplitTree splitTree cs++-- | Process function clauses into case tree.+-- This involves:+-- 1. Coverage checking, generating a split tree.+-- 2. Translation of lhs record patterns into rhs uses of projection.+-- Update the split tree.+-- 3. Generating a case tree from the split tree.+-- Phases 1. and 2. are skipped if @Nothing@. compileClauses ::- Bool -- ^ Translate record patterns?- -> [Clause] -> TCM CompiledClauses-compileClauses translate cs = do- cs <- if translate then- mapM translateRecordPatterns cs- else- return cs- return $ compile [(clausePats c, clauseBody c) | c <- cs]+ Maybe (QName, Type) -- ^ Translate record patterns and coverage check with given type?+ -> [Clause]+ -> TCM (Maybe SplitTree, Bool, CompiledClauses)+ -- ^ The 'Bool' indicates whether we turned a record expression into a copattern match.+compileClauses mt cs = do+ -- Construct clauses with pattern variables bound in left-to-right order.+ -- Discard de Bruijn indices in patterns.+ case mt of+ Nothing -> (Nothing,False,) . compile . map' unBruijn . zip' [0..] <$> normaliseProjP cs+ Just (q, t) -> do+ splitTree <- coverageCheck q t cs -type Cl = ([Arg Pattern], ClauseBody)+ reportSDoc "tc.cc.tree" 20 $ vcat+ [ "split tree of " <+> prettyTCM q <+> " from coverage check "+ , return $ P.pretty splitTree+ ]++ -- The coverage checker might have added some clauses (#2288)!+ -- Throw away the unreachable clauses (#2723).+ let notUnreachable = (Just True /=) . clauseUnreachable+ cs <- normaliseProjP =<< instantiateFull =<< filter (notUnreachable . snd) . zip' [0..] . defClauses <$> getConstInfo q++ let cls = map' unBruijn cs++ reportSDoc "tc.cc" 30 $ sep $ do+ ("clauses patterns of " <+> prettyTCM q <+> " before compilation") : do+ map' (prettyTCM . map' unArg . clPats) cls+ reportSDoc "tc.cc" 50 $+ "clauses of " <+> prettyTCM q <+> " before compilation" <?> pretty cs++ let cc = compileWithSplitTree splitTree cls+ reportSDoc "tc.cc" 20 $ sep+ [ "compiled clauses of " <+> prettyTCM q <+> " (still containing record splits)"+ , nest 2 $ return $ P.pretty cc+ ]++ (cc, becameCopatternLHS) <- runChangeT $ translateCompiledClauses q cc++ reportSDoc "tc.cc" 12 $ sep+ [ "compiled clauses of " <+> prettyTCM q+ , nest 2 $ return $ P.pretty cc+ ]+ return (Just splitTree, becameCopatternLHS, fmap precomputeFreeVars_ cc)++-- | Stripped-down version of 'Agda.Syntax.Internal.Clause'+-- used in clause compiler.+data Cl = Cl+ { clNumber :: ClauseNumber+ -- ^ Which original 'Clause' did this clause come from?+ , clRecursive :: ClauseRecursive+ -- ^ Does the clause body contain calls to the mutually recursive functions?+ , clPats :: ![Arg Pattern]+ -- ^ Pattern variables are considered in left-to-right order.+ , clBody :: Maybe Term+ } deriving (Show)++instance P.Pretty Cl where+ pretty (Cl no mr ps b) = (P.pretty no <> ":") P.<+> P.prettyList ps P.<+> "->" P.<+> maybe "_|_" P.pretty b+ type Cls = [Cl] -compile :: Cls -> CompiledClauses-compile cs = case nextSplit cs of- Just n -> Case n $ fmap compile $ splitOn n cs- Nothing -> case map getBody cs of- -- It's possible to get more than one clause here due to- -- catch-all expansion.- Just t : _ -> Done (map (fmap name) $ fst $ head cs) t- Nothing : _ -> Fail- [] -> __IMPOSSIBLE__+-- | Strip down a clause. Don't forget to apply the substitution to the dot+-- patterns!+unBruijn :: (ClauseNumber, Clause) -> Cl+unBruijn (no, c) = Cl no+ (clauseRecursive c)+ (applySubst sub $ (map' . fmap) (fmap dbPatVarName . namedThing) $ namedClausePats c)+ (applySubst sub $ clauseBody c) where- name (VarP x) = x- name (DotP _) = "_"- name ConP{} = __IMPOSSIBLE__- name LitP{} = __IMPOSSIBLE__- getBody (_, b) = body b- body (Bind b) = body (absBody b)- body (Body t) = Just t- body NoBody = Nothing+ sub = renamingR $ fromMaybe __IMPOSSIBLE__ (clausePerm c) -nextSplit :: Cls -> Maybe Int-nextSplit [] = __IMPOSSIBLE__-nextSplit ((ps, _):_) = mhead [ n | (a, n) <- zip ps [0..], isPat (unArg a) ]+compileWithSplitTree :: SplitTree -> Cls -> CompiledClauses+compileWithSplitTree t cs = case t of+ SplitAt i lz ts -> Case i $ compiles lz ts $ splitOn (natSize ts == 1) (unArg i) cs+ -- if there is just one case, we force expansion of catch-alls+ -- this is needed to generate a sound tree on which we can+ -- collapse record pattern splits+ SplittingDone n -> compile cs+ -- after end of split tree, continue with left-to-right strategy where- isPat VarP{} = False- isPat DotP{} = False- isPat ConP{} = True- isPat LitP{} = True+ compiles :: LazySplit -> SplitTrees -> Case Cls -> Case CompiledClauses+ compiles lz ts br@Branches{ projPatterns = cop+ , conBranches = cons+ , etaBranch = Nothing+ , litBranches = lits+ , fallThrough = fT+ , catchallBranch = catchall+ , lazyMatch = lazy }+ = br{ conBranches = updCons cons+ , etaBranch = Nothing+ , litBranches = updLits lits+ , fallThrough = fT+ , catchallBranch = updCatchall catchall+ , lazyMatch = lazy || lz == LazySplit+ }+ where+ updCons = Map.mapWithKey $ \ c cl ->+ caseMaybe (lookup (SplitCon c) ts) compile compileWithSplitTree <$> cl+ -- When the split tree is finished, we continue with @compile@.+ updLits = Map.mapWithKey $ \ l cl ->+ caseMaybe (lookup (SplitLit l) ts) compile compileWithSplitTree cl+ updCatchall = fmap $ caseMaybe (lookup SplitCatchall ts) compile compileWithSplitTree+ compiles _ _ Branches{etaBranch = Just{}} = __IMPOSSIBLE__ -- we haven't inserted eta matches yet -splitOn :: Int -> Cls -> Case Cls-splitOn n cs = mconcat $ map (fmap (:[]) . splitC n) $ expandCatchAlls n cs+compile :: Cls -> CompiledClauses+compile [] = Fail []+compile (c:cs) = case nextSplit c cs of+ Just (isRecP, n) -> Case n $ compile <$> splitOn isRecP (unArg n) (c:cs)+ Nothing ->+ -- It's possible to get more than one clause here due to catch-all expansion.+ case body of+ Just t -> Done no mr xs t+ Nothing -> Fail xs+ where+ -- If there are more than one clauses, take the first one.+ Cl no mr ps body = c+ xs = map' (fmap name) ps+ name (VarP _ x) = x+ name (DotP _ _) = underscore+ name (ConP _ cpi _) | conPLazy cpi = underscore+ -- Issue #8626: forcing analysis can create lazy split, which appears+ -- as lazy `ConP` patterns instead of `DotP` patterns.+ name ConP{} = __IMPOSSIBLE__+ name DefP{} = __IMPOSSIBLE__+ name LitP{} = __IMPOSSIBLE__+ name ProjP{} = __IMPOSSIBLE__+ name (IApplyP _ _ _ x) = x +-- | Get the index of the next argument we need to split on.+-- This the number of the first pattern that does a (non-lazy) match in the first clause.+-- Or the first lazy match where all clauses agree on the constructor, if there are no+-- non-lazy matches.+nextSplit :: Cl -> Cls -> Maybe (Bool, Arg Int)+nextSplit (Cl _ _ ps _) cs = findSplit nonLazy ps <|> findSplit allAgree ps+ where+ nonLazy _ (ConP _ cpi _) = not $ conPLazy cpi+ nonLazy _ _ = True++ findSplit okPat ps = listToMaybe (catMaybes $+ zipWith' (\ (Arg ai p) n -> (, Arg ai n) <$> properSplit p <* guard (okPat n p)) ps [0..])++ allAgree i (ConP c _ _) = all ((== Just (conName c)) . getCon . map' unArg . drop i . clPats) cs+ allAgree _ _ = False++ getCon (ConP c _ _ : _) = Just $ conName c+ getCon _ = Nothing++-- | Is is not a variable pattern?+-- And if yes, is it a record pattern and/or a fallThrough one?+properSplit :: Pattern' a -> Maybe Bool+properSplit (ConP _ cpi _) = Just ((conPRecord cpi && patOrigin (conPInfo cpi) == PatORec) || conPFallThrough cpi)+properSplit DefP{} = Just False+properSplit LitP{} = Just False+properSplit ProjP{} = Just False+properSplit IApplyP{} = Nothing+properSplit VarP{} = Nothing+properSplit DotP{} = Nothing++-- | Is this a variable pattern?+--+-- Maintain invariant: @isVar = isNothing . properSplit@!+isVar :: Pattern' a -> Bool+isVar IApplyP{} = True+isVar VarP{} = True+isVar DotP{} = True+isVar ConP{} = False+isVar DefP{} = False+isVar LitP{} = False+isVar ProjP{} = False++-- | @splitOn single n cs@ will force expansion of catch-alls+-- if @single@.+splitOn :: Bool -> Int -> Cls -> Case Cls+splitOn single n cs = mconcat $ map' (fmap (:[]) . splitC n) $+ -- (\ cs -> trace ("splitting on " ++! show n ++! " after expandCatchalls " ++! show single ++! ": " ++! prettyShow (P.prettyList cs)) cs) $+ expandCatchalls single n cs+ splitC :: Int -> Cl -> Case Cl-splitC n (ps, b) = case unArg p of- ConP c _ qs -> conCase c (ps0 ++ qs ++ ps1, b)- LitP l -> litCase l (ps0 ++ ps1, b)- _ -> catchAll (ps, b)+splitC n (Cl no mr ps b) = caseMaybe mp fallback $ \case+ ProjP _ d -> projCase d $ Cl no mr (ps0 ++! ps1) b+ IApplyP{} -> fallback+ ConP c i qs -> (conCase (conName c) (conPFallThrough i) $ WithArity (length qs) $+ Cl no mr (ps0 ++! map' (fmap namedThing) qs ++! ps1) b) { lazyMatch = conPLazy i }+ DefP o q qs -> (conCase q False $ WithArity (length qs) $+ Cl no mr (ps0 ++! map' (fmap namedThing) qs ++! ps1) b) { lazyMatch = False }+ LitP _ l -> litCase l $ Cl no mr (ps0 ++! ps1) b+ VarP{} -> fallback+ DotP{} -> fallback where- (ps0, p, ps1) = extractNthElement' n ps+ (ps0, rest) = splitAt n ps+ mp = unArg <$> listToMaybe rest+ ps1 = drop 1 rest+ fallback = catchall $ Cl no mr ps b --- Expand catch-alls that appear before actual matches.-expandCatchAlls :: Int -> Cls -> Cls-expandCatchAlls n cs = case cs of- _ | all (isCatchAll . nth . fst) cs -> cs- (ps, b) : cs | not (isCatchAll (nth ps)) -> (ps, b) : expandCatchAlls n cs- | otherwise -> map (expand ps b) expansions ++ (ps, b) : expandCatchAlls n cs- _ -> __IMPOSSIBLE__+-- | Expand catch-alls that appear before actual matches.+--+-- Example:+--+-- @+-- true y+-- x false+-- false y+-- @+--+-- will expand the catch-all @x@ to @false@.+--+-- Catch-alls need also to be expanded if+-- they come before/after a record pattern, otherwise we get into+-- trouble when we want to eliminate splits on records later.+--+-- Another example (see Issue 1650):+-- @+-- f (x, (y, z)) true = a+-- f _ false = b+-- @+-- Split tree:+-- @+-- 0 (first argument of f)+-- \- 1 (second component of the pair)+-- \- 3 (last argument of f)+-- \-- true -> a+-- \- false -> b+-- @+-- We would like to get the following case tree:+-- @+-- case 0 of+-- _,_ -> case 1 of+-- _,_ -> case 3 of true -> a; false -> b+-- _ -> case 3 of true -> a; false -> b+-- _ -> case 3 of true -> a; false -> b+-- @+--+-- Example from issue #2168:+-- @+-- f x false = a+-- f false = \ _ -> b+-- f x true = c+-- @+-- case tree:+-- @+-- f x y = case y of+-- true -> case x of+-- true -> c+-- false -> b+-- false -> a+-- @+--+-- Example from issue #3628:+-- @+-- f i j k (i = i0)(k = i1) = base+-- f i j k (j = i1) = base+-- @+-- case tree:+-- @+-- f i j k o = case i of+-- i0 -> case k of+-- i1 -> base+-- _ -> case j of+-- i1 -> base+-- _ -> case j of+-- i1 -> base+-- @+expandCatchalls :: Bool -> Int -> Cls -> Cls+expandCatchalls single n cs =+ case cs of+ _ -- Andreas, 2013-03-22+ -- if there is a single case (such as for record splits)+ -- we force expansion+ | single -> doExpand =<< cs++ -- If all clauses have a variable at the nth argument, expansion+ -- would have no effect+ | all (isCatchallNth . clPats) cs -> cs++ c@(Cl _ _ ps b) : cs+ -- If the head clause does not have a catch-all pattern for the+ -- nth argument, we can keep it at the head and do no expansion+ | not (isCatchallNth ps) -> c : expandCatchalls False n cs++ -- If there's a DefP clause for this argument later on, then it+ -- should take priority over catch-all clauses, so we rotate them+ -- out of the way.+ -- DefP clauses are always inserted by the system and should+ -- "defeat" user-written inexact patterns.+ | (defps@(_:_), rest) <- partition isDefPNth (c:cs)+ -> defps ++! expandCatchalls False n rest++ -- If the head clause *does* have an irrefutable pattern for the+ -- nth argument, and there's nothing more important after, then we+ -- duplicate the subsequent overlapping clauses with c's RHS+ -- instead.+ | otherwise -> map' (expand c) expansions ++! c : expandCatchalls False n cs+ _ -> __IMPOSSIBLE__ where- isCatchAll (Arg _ _ ConP{}) = False- isCatchAll (Arg _ _ LitP{}) = False- isCatchAll _ = True- nth qs = p- where (_, p, _) = extractNthElement' n qs+ -- In case there is only one branch in the split tree, we expand all+ -- catch-alls for this position+ -- The @expansions@ are collected from all the clauses @cs@ then.+ -- Note: @expansions@ could be empty, so we keep the orignal clause.+ doExpand c@(Cl _ _ ps _)+ | exCatchallNth ps = map' (expand c) expansions ++! [c]+ | otherwise = [c] - classify (LitP l) = Left l- classify (ConP c _ _) = Right c+ -- True if nth pattern is variable or there are less than n patterns.+ isCatchallNth ps = all (isVar . unArg) $ take 1 $ drop n ps++ -- True if nth pattern exists and is variable.+ exCatchallNth ps = any (isVar . unArg) $ take 1 $ drop n ps++ classify (LitP _ l) = Left l+ classify (ConP c _ _) = Right (Left c)+ classify (DefP _ q _) = Right (Right q) classify _ = __IMPOSSIBLE__ + isDefPNth cl = case unArg <$> listToMaybe (drop n (clPats cl)) of+ Just DefP{} -> True+ _ -> False+ -- All non-catch-all patterns following this one (at position n). -- These are the cases the wildcard needs to be expanded into.- expansions = nubBy ((==) `on` classify)- . map unArg- . filter (not . isCatchAll)- . map (nth . fst) $ cs+ expansions = nubOn (classify . unArg . snd)+ . mapMaybe (notVarNth . clPats)+ $ cs+ notVarNth+ :: [Arg Pattern]+ -> Maybe ([Arg Pattern] -- First @n@ patterns.+ , Arg Pattern) -- @n+1@st pattern, not a variable+ notVarNth ps = do+ let (ps1, ps2) = splitAt n ps+ p <- listToMaybe ps2+ guard $ not $ isVar $ unArg p+ return (ps1, p) - expand ps b q =- case q of- ConP c _ qs' -> (ps0 ++ [defaultArg $ ConP c Nothing (genericReplicate m $ defaultArg $ VarP "_")] ++ ps1,- substBody n' m (Con c (map var [m - 1, m - 2..0])) b)- where m = fromIntegral $ length qs'- LitP l -> (ps0 ++ [defaultArg $ LitP l] ++ ps1, substBody n' 0 (Lit l) b)+ expand cl (qs, q) =+ case unArg q of+ ConP c mt qs' -> Cl no mr (ps0 ++! [q $> ConP c mt conPArgs] ++! ps1)+ (substBody n' m (Con c ci (map' Apply conArgs)) b)+ where+ ci = fromConPatternInfo mt+ m = length qs'+ -- replace all direct subpatterns of q by _+ -- TODO Andrea: might need these to sometimes be IApply?+ conPArgs = map' (fmap ($> varP "_")) qs'+ conArgs = zipWith' (\ q' i -> q' $> var i) qs' $ downFrom m+ LitP i l -> Cl no mr (ps0 ++! [q $> LitP i l] ++! ps1) (substBody n' 0 (Lit l) b)+ DefP o d qs' -> Cl no mr (ps0 ++! [q $> DefP o d conPArgs] ++! ps1)+ (substBody n' m (Def d (map' Apply conArgs)) b)+ where+ m = length qs'+ -- replace all direct subpatterns of q by _+ conPArgs = map' (fmap ($> varP "_")) qs'+ conArgs = zipWith' (\ q' i -> q' $> var i) qs' $ downFrom m _ -> __IMPOSSIBLE__ where- (ps0, _, ps1) = extractNthElement' n ps+ -- Andreas, 2016-09-19 issue #2168+ -- Due to varying function arity, some clauses might be eta-contracted.+ -- Thus, we eta-expand them.+ Cl no mr ps b = ensureNPatterns (n + 1) (map' getArgInfo $ qs ++! [q]) cl+ -- The following pattern match cannot fail (by construction of @ps@).+ (ps0, _:ps1) = splitAt n ps - n' = countVars ps0- countVars = sum . map (count . unArg)- count VarP{} = 1- count (ConP _ _ ps) = countVars ps- count DotP{} = 1 -- dot patterns are treated as variables in the clauses- count _ = 0+ -- Andreas, 2026-05-01, issue #7629.+ -- Catch-all expansion substitutes into clause bodies, so it must count+ -- every binder to the right of the expanded pattern, including IApply+ -- variables.+ n' = countPatternVars ps1 - var x = defaultArg $ Var x []+-- | Make sure (by eta-expansion) that clause has arity at least @n@+-- where @n@ is also the length of the provided list.+ensureNPatterns :: Int -> [ArgInfo] -> Cl -> Cl+ensureNPatterns n ais0 cl@(Cl no mr ps b)+ | m <= 0 = cl+ | otherwise = Cl no mr (ps ++! ps') (raise m b `apply` args)+ where+ k = length ps+ ais = drop k ais0+ -- m = Number of arguments to add+ m = n - k+ ps' = for ais $ \ ai -> Arg ai $ varP "_"+ args = zipWith' (\ i ai -> Arg ai $ var i) (downFrom m) ais -substBody :: Int -> Integer -> Term -> ClauseBody -> ClauseBody-substBody _ _ _ NoBody = NoBody-substBody 0 m v b = case b of- Bind b -> foldr (.) id (genericReplicate m (Bind . Abs "_")) $ subst v (absBody $ raise m b)- _ -> __IMPOSSIBLE__-substBody n m v b = case b of- Bind b -> Bind $ fmap (substBody (n - 1) m v) b- _ -> __IMPOSSIBLE__+substBody :: Subst a => Int -> Int -> SubstArg a -> a -> a+substBody n m v = applySubst $ liftS n $ v :# raiseS m++instance PrecomputeFreeVars a => PrecomputeFreeVars (CompiledClauses' a) where
@@ -1,7 +1,10 @@+{-# OPTIONS_GHC -Wunused-imports #-}+ module Agda.TypeChecking.CompiledClause.Compile where import Agda.Syntax.Internal import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Coverage.SplitTree import Agda.TypeChecking.Monad.Base -compileClauses :: Bool -> [Clause] -> TCM CompiledClauses+compileClauses :: Maybe (QName, Type) -> [Clause] -> TCM (Maybe SplitTree, Bool, CompiledClauses)
@@ -1,85 +1,218 @@-{-# LANGUAGE CPP, PatternGuards #-}+{-# OPTIONS_GHC -Wunused-imports #-}+ module Agda.TypeChecking.CompiledClause.Match where -import Control.Applicative import qualified Data.Map as Map-import Data.Traversable-import Data.List import Agda.Syntax.Internal import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty (prettyShow)+ import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.Monad-import Agda.TypeChecking.Substitute import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Primitive+import Agda.TypeChecking.Substitute import Agda.Utils.List+import Agda.Utils.Maybe+import Agda.Utils.Monad+import qualified Agda.Utils.SmallSet as SmallSet import Agda.Utils.Impossible-#include "../../undefined.h" -matchCompiled :: CompiledClauses -> MaybeReducedArgs -> TCM (Reduced (Blocked Args) Term)-matchCompiled c args = match c args id []+matchCompiled :: CompiledClauses -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Args) Term)+matchCompiled c args = do+ r <- matchCompiledE c $ map' (fmap Apply) args+ case r of+ YesReduction simpl v -> return $ YesReduction simpl v+ NoReduction bes -> return $ NoReduction $ fmap (map' mustApplyElim) bes -type Stack = [(CompiledClauses, MaybeReducedArgs, Args -> Args)]+-- | @matchCompiledE c es@ takes a function given by case tree @c@ and+-- and a spine @es@ and tries to apply the function to @es@.+matchCompiledE :: CompiledClauses -> MaybeReducedElims -> ReduceM (Reduced (Blocked Elims) Term)+matchCompiledE c args = match' [(c, args, id)] +-- | A stack entry is a triple consisting of+-- 1. the part of the case tree to continue matching,+-- 2. the current argument vector, and+-- 3. a patch function taking the current argument vector back+-- to the original argument vector.+type Frame = (CompiledClauses, MaybeReducedElims, Elims -> Elims)+type Stack = [Frame]+++-- | @match'@ tries to solve the matching problems on the @Stack@.+-- In each iteration, the top problem is removed and handled.+--+-- If the top problem was a @Done@, we succeed.+--+-- If the top problem was a @Case n@ and the @n@th argument of the problem+-- is not a constructor or literal, we are stuck, thus, fail.+--+-- If we have a branch for the constructor/literal, we put it on the stack+-- to continue.+-- If we do not have a branch, we fall through to the next problem, which+-- should be the corresponding catch-all branch.+--+-- An empty stack is an exception that can come only from an incomplete+-- function definition.+ -- TODO: literal/constructor pattern conflict (for Nat) -match :: CompiledClauses -> MaybeReducedArgs -> (Args -> Args) -> Stack -> TCM (Reduced (Blocked Args) Term)-match Fail args patch stack = return $ NoReduction $ NotBlocked (patch $ map ignoreReduced args)-match (Done xs t) args _ _- | m < n = return $ YesReduction $ substs (reverse $ toTm args)- $ foldr lam t (drop m xs)- | otherwise = return $ YesReduction $ substs (reverse $ toTm args0) t `apply` map ignoreReduced args1- where- n = length xs- m = length args- toTm = map (unArg . ignoreReduced)- (args0, args1) = splitAt n args- lam x t = Lam (argHiding x) (Abs (unArg x) t)-match (Case n bs) args patch stack =- case genericSplitAt n args of- (_, []) -> return $ NoReduction $ NotBlocked $ patch $ map ignoreReduced args- (args0, MaybeRed red (Arg h r v0) : args1) -> do- w <- case red of- Reduced b -> return $ fmap (const v0) b- NotReduced ->- unfoldCorecursion =<< instantiate v0- cv <- constructorForm $ ignoreBlocking w- let v = ignoreBlocking w- args' = args0 ++ [MaybeRed red $ Arg h r v] ++ args1- stack' = maybe [] (\c -> [(c, args', patch)]) (catchAllBranch bs)- ++ stack- patchLit args = patch (args0 ++ [Arg h r v] ++ args1)- where (args0, args1) = splitAt n args- patchCon c m args = patch (args0 ++ [Arg h r $ Con c vs] ++ args1)- where (args0, args1') = splitAt n args- (vs, args1) = splitAt m args1'- case w of- Blocked x _ -> return $ NoReduction $ Blocked x (patch $ map ignoreReduced args')- NotBlocked (MetaV x _) -> return $ NoReduction $ Blocked x (patch $ map ignoreReduced args')- NotBlocked (Lit l) -> case Map.lookup l (litBranches bs) of- Nothing -> match' stack''- Just cc -> match cc (args0 ++ args1) patchLit stack''- where- stack'' = (++ stack') $ case cv of- Con c vs -> case Map.lookup c (conBranches bs) of- Nothing -> []- Just cc -> [(cc, args0 ++ map (MaybeRed red) vs ++ args1, patchCon c (length vs))]- _ -> []- NotBlocked (Con c vs) -> case Map.lookup c (conBranches bs) of- Nothing -> match' stack'- Just cc -> match cc (args0 ++ map (MaybeRed red) vs ++ args1)- (patchCon c (length vs)) stack'- NotBlocked _ -> return $ NoReduction $ NotBlocked (patch $ map ignoreReduced args')+match' :: Stack -> ReduceM (Reduced (Blocked Elims) Term)+match' ((c, es, patch) : stack) = do+ let no blocking es = return $! NoReduction $! blocking $! patch $! map'' ignoreReduced es+ yes t = flip YesReduction t <$!> viewTC eSimplification -match' :: Stack -> TCM (Reduced (Blocked Args) Term)-match' ((c, args, patch):stack) = match c args patch stack-match' [] = typeError $ GenericError "Incomplete pattern matching"+ -- TODO: make this local to Done+ allowedReductions <- viewTC eAllowedReductions+ fun <- fromMaybe __IMPOSSIBLE__ <$> viewTC eAppDef+ def <- getConstInfo fun -unfoldCorecursion v = case v of- -- Andreas, 2011-10-03 removing DontCare here allow matching on irrelevant things- DontCare v -> unfoldCorecursion v- Def f args -> unfoldDefinition True unfoldCorecursion (Def f []) f args- _ -> reduceB v+ do++ case c of++ -- impossible case+ Fail{} -> no (NotBlocked AbsurdMatch) es++ -- done matching+ Done _no mr xs t+ | couldBeRecursive mr+ , defTerminationUnconfirmed def+ , UnconfirmedReductions `SmallSet.notMember` allowedReductions -> do+ reportSLn "tc.reduce.recursive" 80 $ "Aborting reduction of " <> prettyShow fun+ no (NotBlocked ReallyNotBlocked) es+ -- if the function was partially applied, return a lambda+ | m < n -> yes $ applySubst (toSubst es) $ foldr lam t (drop m xs)+ -- otherwise, just apply instantiation to body+ -- apply the result to any extra arguments+ | otherwise -> yes $ applySubst (toSubst es0) t `applyE` map'' ignoreReduced es1+ where+ n = length xs+ m = length es+ -- at least the first @n@ elims must be @Apply@s, so we can+ -- turn them into a subsitution+ toSubst = parallelS . reverse . map'' (unArg . fromMaybe __IMPOSSIBLE__ . isApplyElim . ignoreReduced)+ (es0, es1) = splitAt' n es+ lam x t = Lam (argInfo x) (Abs (unArg x) t)++ -- splitting on an eta-record constructor+ Case (Arg _ n) Branches{etaBranch = Just (c, cc), catchallBranch = ca} ->+ case splitAt' n es of+ (_, []) -> no (NotBlocked Underapplied) es+ (es0, MaybeRed _ e@(Apply (Arg _ v0)) : es1) ->+ let projs = map'' (\(Arg ai f) -> MaybeRed NotReduced $ Apply $ Arg ai $ relToDontCare ai $ v0 `applyE` [Proj ProjSystem f])+ fs+ catchallFrame stack = maybe stack (\c -> (c, es, patch) : stack) ca in+ match' $ (content cc, es0 ++! projs ++! es1, patchEta) : catchallFrame stack+ where+ fs = conFields c+ patchEta es = patch (es0 ++! e : es1)+ where (es0, es') = splitAt' n es+ (_, es1) = splitAt' (length fs) es'+ _ -> __IMPOSSIBLE__++ -- splitting on the @n@th elimination+ Case (Arg _ n) bs -> do+ case splitAt' n es of+ -- if the @n@th elimination is not supplied, no match+ (_, []) -> no (NotBlocked Underapplied) es+ -- if the @n@th elimination is @e0@+ (es0, MaybeRed red e0 : es1) -> do+ -- get the reduced form of @e0@+ eb :: Blocked Elim <- do+ case red of+ Reduced b -> return $! e0 <$ b+ NotReduced -> unfoldCorecursionE e0+ let e = ignoreBlocking eb+ -- replace the @n@th argument by its reduced form+ es' = es0 ++! MaybeRed (Reduced $ () <$ eb) e : es1+ -- if a catch-all clause exists, put it on the stack+ catchallFrame stack = maybe stack (\c -> (c, es', patch) : stack) (catchallBranch bs)+ -- If our argument is @Lit l@, we push @litFrame l@ onto the stack.+ litFrame l stack =+ case Map.lookup l (litBranches bs) of+ Nothing -> stack+ Just cc -> (cc, es0 ++! es1, patchLit) : stack+ -- If our argument (or its constructor form) is @Con c ci vs@+ -- we push @conFrame c vs@ onto the stack.+ conFrame c ci vs stack = conFrame' (conName c) (Con c ci) vs stack+ conFrame' q f vs stack =+ case Map.lookup q (conBranches bs) of+ Nothing -> stack+ Just cc -> ( content cc+ , es0 ++! map' (MaybeRed NotReduced) vs ++! es1+ , patchCon f (length vs)+ ) : stack+ -- If our argument is @Proj p@, we push @projFrame p@ onto the stack.+ projFrame p stack =+ case Map.lookup p (conBranches bs) of+ Nothing -> stack+ Just cc -> (content cc, es0 ++! es1, patchLit) : stack+ -- The new patch function restores the @n@th argument to @v@:+ -- In case we matched a literal, just put @v@ back.+ patchLit es = patch (es0 ++! e : es1)+ where (es0, es1) = splitAt' n es+ -- In case we matched constructor @c@ with @m@ arguments,+ -- contract these @m@ arguments @vs@ to @Con c ci vs@.+-- patchCon c ci m es = patch (es0 ++! [Con c ci vs <$ e] ++! es2)+ patchCon f m es = patch (es0 ++! (f vs <$ e) : es2)+ where (es0, rest) = splitAt' n es+ (es1, es2) = splitAt' m rest+ vs = es1+ -- zo <- do+ -- mi <- getBuiltinName' builtinIZero+ -- mo <- getBuiltinName' builtinIOne+ -- return $ Set.fromList $ catMaybes [mi,mo]++ fallThrough <- return $ Just True == fallThrough bs && isJust (catchallBranch bs)++ let+ isCon b =+ case ignoreBlocking b of+ Apply a | c@Con{} <- unArg a -> Just c+ _ -> Nothing+ -- Now do the matching on the @n@ths argument:+ case eb of+ -- In case of a literal, try also its constructor form+ NotBlocked _ (Apply (Arg info v@(Lit l))) -> performedSimplification $ do+ cv <- constructorForm v+ let cFrame stack = case cv of+ Con c ci vs -> conFrame c ci vs stack+ _ -> stack+ match' $ litFrame l $ cFrame $ catchallFrame stack++ NotBlocked _ (Apply (Arg info v@(Def q vs))) | Just{} <- Map.lookup q (conBranches bs) -> performedSimplification $ do+ match' $ conFrame' q (Def q) vs $ catchallFrame $ stack++ -- In case of a constructor, push the conFrame+ b | Just (Con c ci vs) <- isCon b -> performedSimplification $+ match' $ conFrame c ci vs $ catchallFrame $ stack++ -- In case of a projection, push the projFrame+ NotBlocked _ (Proj _ p) -> performedSimplification $+ match' $ projFrame p $ stack -- catchallFrame $ stack+ -- Issue #1986: no catch-all for copattern matching!++ _ | fallThrough -> match' $ catchallFrame $ stack++ Blocked x _ -> no (Blocked x) es'++ -- Otherwise, we are stuck. If we were stuck before,+ -- we keep the old reason, otherwise we give reason StuckOn here.+ NotBlocked blocked e -> no (NotBlocked $ stuckOn e blocked) es'+++-- If we reach the empty stack, then pattern matching was incomplete+match' [] = {- new line here since __IMPOSSIBLE__ does not like the ' in match' -}+ caseMaybeM (viewTC eAppDef) __IMPOSSIBLE__ $ \ f -> do+ pds <- getPartialDefs+ if f `elem` pds+ then return (NoReduction $ NotBlocked (MissingClauses f) [])+ else do+ ifM anyRewritingOption+ {-then-} (return (NoReduction $ NotBlocked ReallyNotBlocked [])) -- See #5396+ {-else-} $ traceSLn "impossible" 10+ ("Incomplete pattern matching when applying " ++! prettyShow f)+ __IMPOSSIBLE__
@@ -1,9 +1,11 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.TypeChecking.CompiledClause.Match where -import Agda.Syntax.Common+-- import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.CompiledClause -matchCompiled :: CompiledClauses -> MaybeReducedArgs -> TCM (Reduced (Blocked Args) Term)+matchCompiled :: CompiledClauses -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Args) Term)+matchCompiledE :: CompiledClauses -> MaybeReducedElims -> ReduceM (Reduced (Blocked [Elim]) Term)
@@ -1,89 +1,201 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE NondecreasingIndentation #-}+ module Agda.TypeChecking.Constraints where -import System.IO+import Prelude hiding (null) -import Control.Monad.State-import Control.Monad.Reader-import Control.Monad.Error-import Control.Applicative-import Data.Map as Map-import Data.List as List-import Data.Set as Set+import qualified Data.List as List+import qualified Data.Set as Set import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty ( prettyShow ) import Agda.Syntax.Internal-import Agda.Syntax.Scope.Base+ import Agda.TypeChecking.Monad-import Agda.TypeChecking.Errors+import Agda.TypeChecking.InstanceArguments import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute import Agda.TypeChecking.LevelConstraints-import Agda.TypeChecking.MetaVars.Mention+import Agda.TypeChecking.SizedTypes+import Agda.TypeChecking.Sort+import Agda.TypeChecking.Warnings -import {-# SOURCE #-} Agda.TypeChecking.Rules.Term (checkExpr)+import Agda.TypeChecking.Irrelevance+import {-# SOURCE #-} Agda.TypeChecking.Rules.Application+import {-# SOURCE #-} Agda.TypeChecking.Rules.Data ( checkDataSort )+import {-# SOURCE #-} Agda.TypeChecking.Rules.Def+import {-# SOURCE #-} Agda.TypeChecking.Rules.Term import {-# SOURCE #-} Agda.TypeChecking.Conversion import {-# SOURCE #-} Agda.TypeChecking.MetaVars import {-# SOURCE #-} Agda.TypeChecking.Empty-import {-# SOURCE #-} Agda.TypeChecking.UniversePolymorphism-import Agda.TypeChecking.Free+import {-# SOURCE #-} Agda.TypeChecking.Lock+import {-# SOURCE #-} Agda.TypeChecking.CheckInternal ( checkType )+import {-# SOURCE #-} Agda.TypeChecking.Rewriting -import Agda.Utils.Fresh+import Agda.Utils.CallStack ( withCurrentCallStack )+import Agda.Utils.List+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe import Agda.Utils.Monad+import Agda.Utils.Null (unlessNullM)+import qualified Agda.Interaction.Options.ProfileOptions as Profile+import Agda.Utils.Singleton -#include "../undefined.h" import Agda.Utils.Impossible+import Agda.Utils.Function (applyUnless) --- | Catches pattern violation errors and adds a constraint.----catchConstraint :: Constraint -> TCM () -> TCM ()-catchConstraint c v = liftTCM $- catchError_ v $ \err ->- case errError err of- -- Not putting s (which should really be the what's already there) makes things go- -- a lot slower (+20% total time on standard library). How is that possible??- -- The problem is most likely that there are internal catchErrors which forgets the- -- state. catchError should preserve the state on pattern violations.- PatternErr s -> put s >> addConstraint c- _ -> throwError err+instance MonadConstraint TCM where+ addConstraint u c = ifImpureConv (addConstraintTCM u c) $ patternViolation u+ addAwakeConstraint u c = ifImpureConv (addAwakeConstraint' u c) $ patternViolation u -addConstraint :: Constraint -> TCM ()-addConstraint c = do- pids <- asks envActiveProblems- reportSDoc "tc.constr.add" 20 $ hsep- [ text "adding constraint"- , text (show pids)- , prettyTCM c ]- -- Need to reduce to reveal possibly blocking metas- c <- reduce =<< instantiateFull c- c' <- simpl c- if (c /= c')- then do- reportSDoc "tc.constr.add" 20 $ text " simplified:" <+> prettyTCM c'- solveConstraint_ c'- else addConstraint' c'+ solveConstraint c = ifImpureConv (solveConstraintTCM c) $+ patternViolation alwaysUnblock -- TODO: does this happen?++ solveSomeAwakeConstraints s f = ifImpureConv (solveSomeAwakeConstraintsTCM s f) $ return ()++ {-# INLINE wakeConstraints #-}+ wakeConstraints w = ifImpureConv (wakeConstraintsTCM w) $ return ()++ {-# INLINE stealConstraints #-}+ stealConstraints w = ifImpureConv (stealConstraintsTCM w) $ return ()++ {-# INLINE modifyConstraints #-}+ modifyConstraints f g = ifImpureConv+ (modifyTC (mapAwakeConstraints f . mapSleepingConstraints g))+ (patternViolation alwaysUnblock) -- TODO: does this happen?+++addConstraintTCM :: Blocker -> Constraint -> TCM ()+addConstraintTCM unblock c = do+ pids <- viewTC eActiveProblems+ reportSDoc "tc.constr.add" 20 $ hsep+ [ "adding constraint"+ , prettyTCM . PConstr pids unblock =<< buildClosure c+ , "unblocker: " , prettyTCM unblock+ ]+ -- Jesper, 2022-10-22: We should never block on a meta that is+ -- already solved.+ forM_ (allBlockingMetas unblock) $ \ m ->+ whenM (isInstantiatedMeta m) $ do+ reportSDoc "tc.constr.add" 5 $ "Attempted to block on solved meta" <+> prettyTCM m+ __IMPOSSIBLE__+ -- Need to reduce to reveal possibly blocking metas+ c <- reduce =<< instantiateFull c+ caseMaybeM (simpl c) {-no-} (addConstraint' unblock c) $ {-yes-} \ cs -> do+ reportSDoc "tc.constr.add" 20 $ " simplified:" <+> prettyList (map prettyTCM cs)+ mapM_ solveConstraint_ cs+ -- The added constraint can cause instance constraints to be solved,+ -- but only the constraints which aren’t blocked on an uninstantiated meta.+ unless (isInstanceConstraint c) $+ wakeConstraints' isWakeableInstanceConstraint where- simpl :: Constraint -> TCM Constraint- simpl c = do- n <- genericLength <$> getContext- let isLvl LevelCmp{} = True- isLvl _ = False- cs <- getAllConstraints- lvls <- instantiateFull $ List.filter (isLvl . clValue . theConstraint) cs- when (not $ List.null lvls) $ reportSDoc "tc.constr.add" 40 $ text " simplifying using" <+> prettyTCM lvls- return $ simplifyLevelConstraint n c lvls+ isWakeableInstanceConstraint :: ProblemConstraint -> WakeUp+ isWakeableInstanceConstraint c =+ case clValue $ theConstraint c of+ FindInstance{}+ | constraintUnblocker c == alwaysUnblock -> WakeUp+ _ -> DontWakeUp Nothing --- | Don't allow the argument to produce any constraints.-noConstraints :: TCM a -> TCM a-noConstraints problem = liftTCM $ do+ isLvl LevelCmp{} = True+ isLvl _ = False++ -- Try to simplify a level constraint+ simpl :: Constraint -> TCM (Maybe [Constraint])+ simpl c+ | isLvl c = do+ -- Get all level constraints.+ lvlcs <- instantiateFull =<< do+ List.filter (isLvl . clValue) . map theConstraint <$> getAllConstraints+ List1.ifNull lvlcs (return Nothing) $ {-else-} \ lvlcs -> do+ reportSDoc "tc.constr.lvl" 40 $ vcat+ [ "simplifying level constraint" <+> prettyTCM c+ , nest 2 $ hang "using" 2 $ prettyTCM lvlcs+ ]+ -- Try to simplify @c@ using the other constraints.+ return $ simplifyLevelConstraint c $ fmap clValue lvlcs+ | otherwise = return Nothing++{-# INLINE wakeConstraintsTCM #-}+wakeConstraintsTCM :: (ProblemConstraint-> WakeUp) -> TCM ()+wakeConstraintsTCM wake = do+ tc <- getTC+ let c = tc ^. stSleepingConstraints+ let (wakeup, sleepin) = partitionEithers' $ map' checkWakeUp c+ reportSLn "tc.constr.wake" 50 $+ "waking up " ++ show (List.map (Set.toList . constraintProblems) wakeup) ++ "\n" +++ " still sleeping: " ++ show (List.map (Set.toList . constraintProblems) sleepin)+ putTC $!+ mapAwakeConstraints (++! wakeup) $ -- TODO: quadratic append!!+ mapSleepingConstraints (const sleepin) tc+ where+ checkWakeUp c = case wake c of+ WakeUp -> Left c+ DontWakeUp Nothing -> Right c+ DontWakeUp (Just u) -> Right c{ constraintUnblocker = u }++-- | Add all constraints belonging to the given problem to the current problem(s).+stealConstraintsTCM :: ProblemId -> TCM ()+stealConstraintsTCM pid = do+ current <- viewTC eActiveProblems+ reportSLn "tc.constr.steal" 50 $ "problem " ++ show (Set.toList current) ++ " is stealing problem " ++ show pid ++ "'s constraints!"+ -- Add current to any constraint in pid.+ let rename pc@(PConstr pids u c) | Set.member pid pids = PConstr (Set.union current pids) u c+ | otherwise = pc+ -- We should never steal from an active problem.+ whenM (Set.member pid <$> viewTC eActiveProblems) __IMPOSSIBLE__+ modifyTC $ mapAwakeConstraints (map' rename)+ . mapSleepingConstraints (map' rename)++{-# SPECIALIZE noConstraints :: TCM a -> TCM a #-}+-- | Error out with @'NonFatalErrors' 'UnsolvedConstraints'@+-- if the computation produced blocking constraints.+--+-- WARNING: this does not mean that the given computation cannot+-- constrain the solution space further.+-- It can well do so, by solving metas.+noConstraints+ :: (MonadConstraint m, MonadWarning m, MonadFresh ProblemId m)+ => m a -> m a+noConstraints = noConstraints' False++-- | As 'noConstraints' but also fail for non-blocking constraints.+reallyNoConstraints+ :: (MonadConstraint m, MonadWarning m, MonadFresh ProblemId m)+ => m a -> m a+reallyNoConstraints = noConstraints' True++-- | Error out with @'NonFatalErrors' 'UnsolvedConstraints'@+-- when given computation produced constraints ('True') or blocking constraints ('False').+noConstraints' ::+ (MonadConstraint m, MonadWarning m, MonadFresh ProblemId m)+ => Bool -> m a -> m a+noConstraints' includingNonBlocking problem = do (pid, x) <- newProblem problem- cs <- getConstraintsForProblem pid- unless (List.null cs) $ typeError $ UnsolvedConstraints cs+ -- Consider only blocking constraints unless @includingNonBlocking@.+ let isBlocking = isBlockingConstraint . clValue . theConstraint+ cs <- applyUnless includingNonBlocking (List.filter isBlocking) <$> getConstraintsForProblem pid+ List1.unlessNull cs \ cs -> do+ withCurrentCallStack \ loc -> do+ w <- warning'_ loc $ UnsolvedConstraints cs+ typeError' loc $ NonFatalErrors $ singleton w return x +-- | Run a computation that should succeeds without constraining+-- the solution space, i.e., not add any information about meta-variables.+nonConstraining ::+ ( MonadConstraint m+ , MonadFresh ProblemId m+ , MonadWarning m+ ) => m a -> m a+nonConstraining = dontAssignMetas . noConstraints++{-# INLINE newProblem #-} -- | Create a fresh problem for the given action.-newProblem :: TCM a -> TCM (ProblemId, a)+newProblem+ :: (MonadFresh ProblemId m, MonadConstraint m)+ => m a -> m (ProblemId, a) newProblem action = do pid <- fresh -- Don't get distracted by other constraints while working on the problem@@ -92,9 +204,25 @@ solveAwakeConstraints return (pid, x) -newProblem_ :: TCM () -> TCM ProblemId+{-# INLINE newProblem_ #-}+newProblem_+ :: (MonadFresh ProblemId m, MonadConstraint m)+ => m a -> m ProblemId newProblem_ action = fst <$> newProblem action +{-# INLINE newProblemDontWake_ #-}+-- | Create a fresh problem for the given action. Don't wake problems after the action finishes.+newProblemDontWake_+ :: (MonadFresh ProblemId m, MonadConstraint m)+ => m a -> m ProblemId+newProblemDontWake_ action = do+ pid <- fresh+ -- Don't get distracted by other constraints while working on the problem+ _ <- nowSolvingConstraints $+ verboseBracket "tc.constr.solve" 50 ("working on problem " ++ show pid) $+ localTC (over eActiveProblems (Set.insert pid)) action+ pure pid+ ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b ifNoConstraints check ifNo ifCs = do (pid, x) <- newProblem check@@ -103,12 +231,12 @@ ifNoConstraints_ :: TCM () -> TCM a -> (ProblemId -> TCM a) -> TCM a ifNoConstraints_ check ifNo ifCs = ifNoConstraints check (const ifNo) (\pid _ -> ifCs pid) --- | @guardConstraint cs c@ tries to solve constraints @cs@ first.--- If successful, it moves on to solve @c@, otherwise it returns--- a @Guarded c cs@.+-- | @guardConstraint c blocker@ tries to solve @blocker@ first.+-- If successful without constraints, it moves on to solve @c@, otherwise it+-- adds a @c@ to the constraint pool, blocked by the problem generated by @blocker@. guardConstraint :: Constraint -> TCM () -> TCM () guardConstraint c blocker =- ifNoConstraints_ blocker (solveConstraint_ c) (addConstraint . Guarded c)+ ifNoConstraints_ blocker (solveConstraint c) (\ pid -> addConstraint (unblockOnProblem pid) c) whenConstraints :: TCM () -> TCM () -> TCM () whenConstraints action handler =@@ -116,153 +244,146 @@ stealConstraints pid handler +{-# SPECIALIZE wakeupConstraints :: MetaId -> TCM () #-} -- | Wake up the constraints depending on the given meta.-wakeupConstraints :: MetaId -> TCM ()+wakeupConstraints :: MonadMetaSolver m => MetaId -> m () wakeupConstraints x = do- wakeConstraints (mentionsMeta x)+ wakeConstraints' (wakeIfBlockedOnMeta x . constraintUnblocker) solveAwakeConstraints --- | Wake up all constraints.+-- | Wake up all constraints not blocked on a problem. wakeupConstraints_ :: TCM () wakeupConstraints_ = do- wakeConstraints (const True)+ wakeConstraints' (wakeup . constraintUnblocker) solveAwakeConstraints+ where+ wakeup u | Set.null $ allBlockingProblems u = WakeUp+ | otherwise = DontWakeUp Nothing -solveAwakeConstraints :: TCM ()-solveAwakeConstraints = do- verboseS "profile.constraints" 10 $ liftTCM $ tickMax "max-open-constraints" . genericLength =<< getAllConstraints- unlessM isSolvingConstraints $ nowSolvingConstraints solve+-- | Solve awake constraints matching the predicate. If the second argument is+-- True solve constraints even if already 'isSolvingConstraints'.+solveSomeAwakeConstraintsTCM :: (ProblemConstraint -> Bool) -> Bool -> TCM ()+solveSomeAwakeConstraintsTCM solveThis force = do+ whenProfile Profile.Constraints $ liftTCM $ tickMax "max-open-constraints" . List.genericLength =<< getAllConstraints+ whenM ((force ||) . not <$> isSolvingConstraints) $ nowSolvingConstraints $ do+ -- solveSizeConstraints -- Andreas, 2012-09-27 attacks size constrs too early+ -- Ulf, 2016-12-06: Don't inherit problems here! Stored constraints+ -- already contain all their dependencies.+ locallyTC eActiveProblems (const Set.empty) solve where solve = do- reportSDoc "tc.constr.solve" 10 $ hsep [ text "Solving awake constraints."- , text . show . length =<< getAwakeConstraints- , text "remaining." ]- mc <- takeAwakeConstraint- flip (maybe $ return ()) mc $ \c -> do+ verboseS "tc.constr.solve" 10 do+ unlessNullM getAwakeConstraints \ cs ->+ reportSDoc "tc.constr.solve" 10 $ hsep+ [ "Solving awake constraints.", text . show $ length cs, "remaining."]+ whenJustM (takeAwakeConstraint' solveThis) \ c -> do withConstraint solveConstraint c solve -solveConstraint :: Constraint -> TCM ()-solveConstraint c = do- verboseS "profile.constraints" 10 $ liftTCM $ tick "attempted-constraints"+solveConstraintTCM :: Constraint -> TCM ()+solveConstraintTCM c = do+ whenProfile Profile.Constraints $ liftTCM $ tick "attempted-constraints" verboseBracket "tc.constr.solve" 20 "solving constraint" $ do- pids <- asks envActiveProblems- reportSDoc "tc.constr.solve" 20 $ text (show pids) <+> prettyTCM c+ pids <- viewTC eActiveProblems+ reportSDoc "tc.constr.solve.constr" 20 $ text (show $ Set.toList pids) <+> prettyTCM c solveConstraint_ c -solveConstraint_ (ValueCmp cmp a u v) = compareTerm cmp a u v-solveConstraint_ (ElimCmp cmp a e u v) = compareElims cmp a e u v-solveConstraint_ (TypeCmp cmp a b) = compareType cmp a b-solveConstraint_ (TelCmp a b cmp tela telb) = compareTel a b cmp tela telb+solveConstraint_ :: Constraint -> TCM ()+solveConstraint_ (ValueCmp cmp a u v) = compareAs cmp a u v+solveConstraint_ (ValueCmpOnFace cmp p a u v) = compareTermOnFace cmp p a u v+solveConstraint_ (ElimCmp cmp fs a e u v) = compareElims cmp fs a e u v solveConstraint_ (SortCmp cmp s1 s2) = compareSort cmp s1 s2 solveConstraint_ (LevelCmp cmp a b) = compareLevel cmp a b-solveConstraint_ c0@(Guarded c pid) = do- ifM (isProblemSolved pid) (solveConstraint_ c)- (addConstraint c0)-solveConstraint_ (IsEmpty t) = isEmptyType t-solveConstraint_ (UnBlock m) =- ifM (isFrozen m) (addConstraint $ UnBlock m) $ do- inst <- mvInstantiation <$> lookupMeta m- reportSDoc "tc.constr.unblock" 15 $ text ("unblocking a metavar yields the constraint: " ++ show inst)+solveConstraint_ (IsEmpty r t) = ensureEmptyType r t+solveConstraint_ (CheckSizeLtSat t) = checkSizeLtSat t+solveConstraint_ (UnquoteTactic tac hole goal) = unquoteTactic tac hole goal+solveConstraint_ (UnBlock m) = -- alwaysUnblock since these have their own unblocking logic (for now)+ ifM (isFrozen m `or2M` (not <$> viewTC eAssignMetas)) (do+ reportSDoc "tc.constr.unblock" 15 $ hsep ["not unblocking", prettyTCM m, "because",+ ifM (isFrozen m) "it's frozen" "meta assignments are turned off"]+ addConstraint alwaysUnblock $ UnBlock m) $ do+ inst <- lookupMetaInstantiation m+ reportSDoc "tc.constr.unblock" 65 $ "unblocking a metavar yields the constraint:" <+> pretty inst case inst of BlockedConst t -> do reportSDoc "tc.constr.blocked" 15 $- text ("blocked const " ++ show m ++ " :=") <+> prettyTCM t- assignTerm m t- PostponedTypeCheckingProblem cl -> enterClosure cl $ \(e, t, unblock) -> do- b <- liftTCM unblock- if not b- then addConstraint $ UnBlock m- else do- tel <- getContextTelescope- v <- liftTCM $ checkExpr e t- assignTerm m $ teleLam tel v+ text ("blocked const " ++ prettyShow m ++ " :=") <+> prettyTCM t+ assignTerm m [] t+ PostponedTypeCheckingProblem cl -> enterClosure cl $ \prob -> do+ tel <- getContextTelescope+ v <- liftTCM $ checkTypeCheckingProblem prob+ assignTerm m (telToArgs tel) v -- Andreas, 2009-02-09, the following were IMPOSSIBLE cases -- somehow they pop up in the context of sized types -- -- already solved metavariables: should only happen for size -- metas (not sure why it does, Andreas?)- InstV{} -> return ()- InstS{} -> return ()- -- Open (whatever that means)- Open -> __IMPOSSIBLE__- OpenIFS -> __IMPOSSIBLE__-solveConstraint_ (FindInScope m) =- ifM (isFrozen m) (addConstraint $ FindInScope m) $ do- reportSDoc "tc.constr.findInScope" 15 $ text ("findInScope constraint: " ++ show m)- mv <- lookupMeta m- let j = mvJudgement mv- case j of- IsSort{} -> __IMPOSSIBLE__- HasType _ tj -> do- ctx <- getContextVars- ctxArgs <- getContextArgs- t <- normalise $ tj `piApply` ctxArgs- reportSLn "tc.constr.findInScope" 15 $ "findInScope t: " ++ show t- let candsP1 = [(term, t) | (term, t, Instance) <- ctx]- let candsP2 = [(term, t) | (term, t, h) <- ctx, h /= Instance]- let scopeInfo = getMetaScope mv- let ns = everythingInScope scopeInfo- let nsList = Map.toList $ nsNames ns- -- try all abstract names in scope (even ones that you can't refer to- -- unambiguously)- let candsP3Names = nsList >>= snd- candsP3Types <- mapM (typeOfConst . anameName) candsP3Names- candsP3FV <- mapM (freeVarsToApply . anameName) candsP3Names- let candsP3 = [(Def (anameName an) vs, t) |- (an, t, vs) <- zip3 candsP3Names candsP3Types candsP3FV]- let cands = [candsP1, candsP2, candsP3]- cands <- mapM (filterM (uncurry $ checkCandidateForMeta m t )) cands- let iterCands :: [(Int, [(Term, Type)])] -> TCM ()- iterCands [] = do reportSDoc "tc.constr.findInScope" 15 $ text "not a single candidate found..."- typeError $ IFSNoCandidateInScope t- iterCands ((p, []) : cs) = do reportSDoc "tc.constr.findInScope" 15 $ text $- "no candidates found at p=" ++ show p ++ ", trying next p..."- iterCands cs- iterCands ((p, [(term, t')]):_) =- do reportSDoc "tc.constr.findInScope" 15 $ text (- "one candidate at p=" ++ show p ++ " found for type '") <+>- prettyTCM t <+> text "': '" <+> prettyTCM term <+>- text "', of type '" <+> prettyTCM t' <+> text "'."- leqType t t'- assignV m ctxArgs term- iterCands ((p, cs):_) = do reportSDoc "tc.constr.findInScope" 15 $- text ("still more than one candidate at p=" ++ show p ++ ": ") <+>- prettyTCM (List.map fst cs)- addConstraint $ FindInScope m- iterCands [(1,concat cands)]- where- getContextVars :: TCM [(Term, Type, Hiding)]- getContextVars = do- ctx <- getContext- let ids = [0.. fromIntegral (length ctx) - 1] :: [Nat]- types <- mapM typeOfBV ids- return $ [ (Var i [], t, h) | (Arg h _ _, i, t) <- zip3 ctx [0..] types ]- checkCandidateForMeta :: MetaId -> Type -> Term -> Type -> TCM Bool- checkCandidateForMeta m t term t' =- liftTCM $ flip catchError (\err -> return False) $ do- reportSLn "tc.constr.findInScope" 20 $ "checkCandidateForMeta\n t: " ++ show t ++ "\n t':" ++ show t' ++ "\n term: " ++ show term ++ "."- localState $ do- -- domi: we assume that nothing below performs direct IO (except- -- for logging and such, I guess)- leqType t t'- tel <- getContextTelescope- assignTerm m (teleLam tel term)- -- make a pass over constraints, to detect cases where some are made- -- unsolvable by the assignment, but don't do this for FindInScope's- -- to prevent loops. We currently also ignore UnBlock constraints- -- to be on the safe side.- wakeConstraints (isSimpleConstraint . clValue . theConstraint)- solveAwakeConstraints- return True- isSimpleConstraint :: Constraint -> Bool- isSimpleConstraint FindInScope{} = False- isSimpleConstraint UnBlock{} = False- isSimpleConstraint _ = True+ -- Andreas, 2017-07-11:+ -- I think this is because the size solver instantiates+ -- some metas with infinity but does not clean up the UnBlock constraints.+ -- See also issue #2637.+ -- Ulf, 2018-04-30: The size solver shouldn't touch blocked terms! They have+ -- a twin meta that it's safe to solve.+ InstV{} -> __IMPOSSIBLE__+ OpenMeta{} -> __IMPOSSIBLE__+solveConstraint_ (FindInstance _ m cands) = findInstance m cands+solveConstraint_ (ResolveInstanceHead kwr q) = resolveInstanceHead kwr q+solveConstraint_ (CheckFunDef i q cs _err) = withoutCache $+ -- re #3498: checking a fundef would normally be cached, but here it's+ -- happening out of order so it would only corrupt the caching log.+ checkFunDef i q cs+solveConstraint_ (CheckLockedVars a b c d) = checkLockedVars a b c d+solveConstraint_ (HasBiggerSort a) = hasBiggerSort a+solveConstraint_ (HasPTSRule a b) = hasPTSRule a b+solveConstraint_ (CheckDataSort q s) = checkDataSort q s+solveConstraint_ (CheckMetaInst m) = checkMetaInst m+solveConstraint_ (CheckType t) = checkType t+solveConstraint_ (UsableAtModality cc ms mod t) = usableAtModality' ms cc mod t+solveConstraint_ (RewConstraint eq) = checkRewConstraint eq -localState :: MonadState s m => m a -> m a-localState m = do- s <- get- x <- m- put s- return x+checkTypeCheckingProblem :: TypeCheckingProblem -> TCM Term+checkTypeCheckingProblem = \case+ CheckExpr cmp e t -> checkExpr' cmp e t+ CheckArgs cmp eh hd args t0 t1 k -> checkArguments cmp eh hd args t0 t1 k+ CheckProjAppToKnownPrincipalArg cmp e o ds hd args t k v0 pt patm ->+ checkProjAppToKnownPrincipalArg cmp e o ds hd args t k v0 pt patm+ CheckLambda cmp args body target -> checkPostponedLambda cmp args body target+ DoQuoteTerm cmp et t -> doQuoteTerm cmp et t+ DisambiguateConstructor bcd k -> disambiguateConstructor' bcd k++debugConstraints :: TCM ()+debugConstraints = verboseS "tc.constr" 50 $ do+ awake <- useTC stAwakeConstraints+ sleeping <- useTC stSleepingConstraints+ reportSDoc "tc.constr" 50 $ vcat+ [ "Current constraints"+ , nest 2 $ vcat [ "awake " <+> vcat (map prettyTCM awake)+ , "asleep" <+> vcat (map prettyTCM sleeping) ] ]++-- Update the blocker after some instantiation or pruning might have happened.+updateBlocker :: (PureTCM m) => Blocker -> m Blocker+updateBlocker = instantiate++{-# INLINE addAndUnblocker #-}+addAndUnblocker :: (PureTCM m, MonadBlock m) => Blocker -> m a -> m a+addAndUnblocker u+ | u == alwaysUnblock = id+ | otherwise = catchPatternErr $ \ u' -> do+ u <- updateBlocker u+ patternViolation (unblockOnBoth u u')++{-# INLINE addOrUnblocker #-}+addOrUnblocker :: (PureTCM m, MonadBlock m) => Blocker -> m a -> m a+addOrUnblocker u+ | u == neverUnblock = id+ | otherwise = catchPatternErr $ \ u' -> do+ u <- updateBlocker u+ patternViolation (unblockOnEither u u')++-- Reduce a term and call the continuation. If the continuation is+-- blocked, the whole call is blocked either on what blocked the reduction+-- or on what blocked the continuation (using `blockedOnEither`).+withReduced+ :: (Reduce a, IsMeta a, PureTCM m, MonadBlock m)+ => a -> (a -> m b) -> m b+withReduced a cont = ifBlocked a (\b a' -> addOrUnblocker b $ cont a') (\_ a' -> cont a')
@@ -0,0 +1,17 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.Constraints where++import Agda.Syntax.Internal (ProblemId)+import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Monad.Constraints (MonadConstraint)+import Agda.TypeChecking.Warnings (MonadWarning)++instance MonadConstraint TCM where++noConstraints :: (MonadConstraint m, MonadWarning m, MonadFresh ProblemId m)+ => m a -> m a+ifNoConstraints_ :: TCM () -> TCM a -> (ProblemId -> TCM a) -> TCM a+ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b+guardConstraint :: Constraint -> TCM () -> TCM ()+debugConstraints :: TCM ()
@@ -1,782 +1,2389 @@-{-# LANGUAGE CPP, PatternGuards #-}--module Agda.TypeChecking.Conversion where--import Control.Applicative-import Control.Monad-import Control.Monad.State-import Control.Monad.Error-import Data.Traversable hiding (mapM, sequence)-import Data.List hiding (sort)-import qualified Data.List as List--import Agda.Syntax.Literal-import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.TypeChecking.Monad-import Agda.TypeChecking.MetaVars-import Agda.TypeChecking.MetaVars.Occurs (killArgs,PruneResult(..))-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Constraints-import Agda.TypeChecking.Errors-import Agda.TypeChecking.Primitive (constructorForm)-import Agda.TypeChecking.Free-import Agda.TypeChecking.Records-import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Injectivity-import Agda.TypeChecking.SizedTypes-import Agda.TypeChecking.Monad.Builtin-import Agda.TypeChecking.Level-import Agda.TypeChecking.Irrelevance-import Agda.TypeChecking.EtaContract-import Agda.TypeChecking.Eliminators--- import Agda.TypeChecking.UniversePolymorphism--import Agda.Utils.Monad--import Agda.TypeChecking.Monad.Debug--#include "../undefined.h"-import Agda.Utils.Impossible--mlevel :: TCM (Maybe Term)-mlevel = liftTCM $ (Just <$> primLevel) `catchError` \_ -> return Nothing--nextPolarity [] = (Invariant, [])-nextPolarity (p : ps) = (p, ps)---- | Check if to lists of arguments are the same (and all variables).--- Precondition: the lists have the same length.-sameVars :: Args -> Args -> Bool-sameVars xs ys = and $ zipWith same xs ys- where- same (Arg _ _ (Var n [])) (Arg _ _ (Var m [])) = n == m- same _ _ = False---- | @intersectVars us vs@ checks whether all relevant elements in @us@ and @vs@--- are variables, and if yes, returns a prune list which says @True@ for--- arguments which are different and can be pruned.-intersectVars :: Args -> Args -> Maybe [Bool]-intersectVars = zipWithM areVars where- -- ignore irrelevant args- areVars u v | argRelevance u == Irrelevant = Just False -- do not prune- areVars (Arg _ _ (Var n [])) (Arg _ _ (Var m [])) = Just $ n /= m -- prune different vars- areVars _ _ = Nothing--equalTerm :: Type -> Term -> Term -> TCM ()-equalTerm = compareTerm CmpEq--equalAtom :: Type -> Term -> Term -> TCM ()-equalAtom = compareAtom CmpEq--equalType :: Type -> Type -> TCM ()-equalType = compareType CmpEq---- | Type directed equality on values.----compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()- -- If one term is a meta, try to instantiate right away. This avoids unnecessary unfolding.-compareTerm cmp a u v = liftTCM $ do- (u, v) <- instantiate (u, v)- reportSDoc "tc.conv.term" 10 $ sep [ text "compareTerm"- , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v- , nest 2 $ text ":" <+> prettyTCM a ]- let fallback = compareTerm' cmp a u v- case (u, v) of- (u@(MetaV x us), v@(MetaV y vs))- | x /= y -> solve1 `orelse` solve2 `orelse` compareTerm' cmp a u v- | otherwise -> fallback- where- (solve1, solve2) | x > y = (assign x us v, assign y vs u)- | otherwise = (assign y vs u, assign x us v)- (u@(MetaV x us), v) -> assign x us v `orelse` fallback- (u, v@(MetaV y vs)) -> assign y vs u `orelse` fallback- _ -> fallback- where- assign x us v = do- reportSDoc "tc.conv.term" 20 $ sep [ text "attempting shortcut"- , nest 2 $ prettyTCM (MetaV x us) <+> text ":=" <+> prettyTCM v ]- ifM (isInstantiatedMeta x) patternViolation (assignV x us v)- -- Should be ok with catchError_ but catchError is much safer since we don't- -- rethrow errors.- m `orelse` h = m `catchError` \err -> case errError err of- PatternErr s -> put s >> h- _ -> h--compareTerm' :: Comparison -> Type -> Term -> Term -> TCM ()-compareTerm' cmp a m n =- verboseBracket "tc.conv.term" 20 "compareTerm" $ do- a' <- reduce a- catchConstraint (ValueCmp cmp a' m n) $ do- reportSDoc "tc.conv.term" 30 $ fsep- [ text "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, text ":", prettyTCM a' ]- proofIrr <- proofIrrelevance- isSize <- isSizeType a'- s <- reduce $ getSort a'- mlvl <- mlevel- case s of- Prop | proofIrr -> return ()- _ | isSize -> compareSizes cmp m n- _ -> case unEl a' of- a | Just a == mlvl -> do- a <- levelView m- b <- levelView n- equalLevel a b- Pi a _ -> equalFun (a,a') m n- Lam _ _ -> __IMPOSSIBLE__- Def r ps -> do- isrec <- isEtaRecord r- if isrec- then do- m <- reduceB m- n <- reduceB n- case (m, n) of- _ | isMeta m || isMeta n ->- compareAtom cmp a' (ignoreBlocking m) (ignoreBlocking n)-- _ | isNeutral m && isNeutral n -> do- -- Andreas 2011-03-23: (fixing issue 396)- -- if we are dealing with a singleton record,- -- we can succeed immediately- isSing <- isSingletonRecordModuloRelevance r ps- case isSing of- Right True -> return ()- -- do not eta-expand if comparing two neutrals- _ -> compareAtom cmp a' (ignoreBlocking m) (ignoreBlocking n)- _ -> do- (tel, m') <- etaExpandRecord r ps $ ignoreBlocking m- (_ , n') <- etaExpandRecord r ps $ ignoreBlocking n- -- No subtyping on record terms- c <- getRecordConstructor r- compareArgs [] (telePi_ tel $ sort Prop) (Con c []) m' n'-- else compareAtom cmp a' m n- _ -> compareAtom cmp a' m n- where--- Andreas, 2010-10-11: allowing neutrals to be blocked things does not seem--- to change Agda's behavior--- isNeutral Blocked{} = False- isNeutral (NotBlocked Con{}) = False- isNeutral _ = True- isMeta (NotBlocked MetaV{}) = True- isMeta _ = False-- equalFun (a,t) m n = do- name <- freshName_ (suggest $ unEl t)- addCtx name a $ compareTerm cmp t' m' n'- where- p = fmap (const $ Var 0 []) a- (m',n') = raise 1 (m,n) `apply` [p]- t' = raise 1 t `piApply` [p]- suggest (Pi _ b) = absName b- suggest _ = __IMPOSSIBLE__---- | @compareTel t1 t2 cmp tel1 tel1@ checks whether pointwise @tel1 `cmp` tel2@--- and complains that @t2 `cmp` t1@ failed if not.-compareTel :: Type -> Type ->- Comparison -> Telescope -> Telescope -> TCM ()-compareTel t1 t2 cmp tel1 tel2 =- verboseBracket "tc.conv.tel" 20 "compareTel" $- catchConstraint (TelCmp t1 t2 cmp tel1 tel2) $ case (tel1, tel2) of- (EmptyTel, EmptyTel) -> return ()- (EmptyTel, _) -> bad- (_, EmptyTel) -> bad- (ExtendTel arg1@(Arg h1 r1 a1) tel1, ExtendTel arg2@(Arg h2 r2 a2) tel2)- | h1 /= h2 -> bad- -- Andreas, 2011-09-11 do not test r1 == r2 because they could differ- -- e.g. one could be Forced and the other Relevant (see fail/UncurryMeta)- | otherwise -> do- let (tel1', tel2') = raise 1 (tel1, tel2)- arg = Var 0 []- name <- freshName_ (suggest (absName tel1) (absName tel2))- let checkArg = escapeContext 1 $ compareType cmp a1 a2- let c = TelCmp t1 t2 cmp (absApp tel1' arg) (absApp tel2' arg)- let r = max r1 r2 -- take "most irrelevant"- dependent = (r /= Irrelevant) && isBinderUsed tel2- addCtx name arg1 $- if dependent- then guardConstraint c checkArg- else checkArg >> solveConstraint_ c- where- suggest "_" y = y- suggest x _ = x- where- -- Andreas, 2011-05-10 better report message about types- bad = typeError $ UnequalTypes cmp t2 t1 -- switch t2 and t1 because of contravariance!--- bad = typeError $ UnequalTelescopes cmp tel1 tel2---- | Syntax directed equality on atomic values----compareAtom :: Comparison -> Type -> Term -> Term -> TCM ()-compareAtom cmp t m n =- verboseBracket "tc.conv.atom" 20 "compareAtom" $- -- if a PatternErr is thrown, rebuild constraint!- catchConstraint (ValueCmp cmp t m n) $ do- let unLevel (Level l) = reallyUnLevelView l- unLevel v = return v- -- constructorForm changes literal to constructors- -- Andreas: what happens if I cut out the eta expansion here?- -- Answer: Triggers issue 245, does not resolve 348- mb <- traverse unLevel =<< traverse constructorForm =<< etaExpandBlocked =<< reduceB m- nb <- traverse unLevel =<< traverse constructorForm =<< etaExpandBlocked =<< reduceB n-- let m = ignoreBlocking mb- n = ignoreBlocking nb-- postpone = addConstraint $ ValueCmp cmp t m n-- checkSyntacticEquality = do- n <- normalise n -- is this what we want?- m <- normalise m- if m == n- then return () -- Check syntactic equality for blocked terms- else postpone-- reportSDoc "tc.conv.atom" 30 $- text "compareAtom" <+> fsep [ prettyTCM mb <+> prettyTCM cmp- , prettyTCM nb- , text ":" <+> prettyTCM t ]- case (mb, nb) of- -- equate two metas x and y. if y is the younger meta,- -- try first y := x and then x := y- (NotBlocked (MetaV x xArgs), NotBlocked (MetaV y yArgs))- | x == y ->- case intersectVars xArgs yArgs of- -- all relevant arguments are variables- Just kills -> do- -- kills is a list with 'True' for each different var- killResult <- killArgs kills x- case killResult of- NothingToPrune -> return ()- PrunedEverything -> return ()- PrunedNothing -> postpone- PrunedSomething -> postpone- -- OLD CODE: if killedAll then return () else checkSyntacticEquality- -- not all relevant arguments are variables- Nothing -> checkSyntacticEquality -- Check syntactic equality on meta-variables- -- (same as for blocked terms)- | otherwise -> do- [p1, p2] <- mapM getMetaPriority [x,y]- -- instantiate later meta variables first- let (solve1, solve2)- | (p1,x) > (p2,y) = (l,r)- | otherwise = (r,l)- where l = assignV x xArgs n- r = assignV y yArgs m-- try m h = m `catchError_` \err -> case errError err of- PatternErr s -> put s >> h- _ -> throwError err-- -- First try the one with the highest priority. If that doesn't- -- work, try the low priority one.- try solve1 solve2-- -- one side a meta, the other an unblocked term- (NotBlocked (MetaV x xArgs), _) -> assignV x xArgs n- (_, NotBlocked (MetaV x xArgs)) -> assignV x xArgs m-- (Blocked{}, Blocked{}) -> checkSyntacticEquality- (Blocked{}, _) -> useInjectivity cmp t m n- (_,Blocked{}) -> useInjectivity cmp t m n- _ -> case (m, n) of- (Pi{}, Pi{}) -> equalFun m n-- (Sort s1, Sort s2) -> compareSort CmpEq s1 s2-- (Lit l1, Lit l2) | l1 == l2 -> return ()- (Var i iArgs, Var j jArgs) | i == j -> do- a <- typeOfBV i- -- Variables are invariant in their arguments- compareArgs [] a (Var i []) iArgs jArgs- (Def{}, Def{}) -> do- ev1 <- elimView m- ev2 <- elimView n- case (ev1, ev2) of- (VarElim x els1, VarElim y els2) | x == y -> cmpElim (typeOfBV x) (Var x []) els1 els2- (ConElim x els1, ConElim y els2) | x == y -> cmpElim (conType x t) (Con x []) els1 els2- (DefElim x els1, DefElim y els2) | x == y ->- cmpElim (defType <$> getConstInfo x) (Def x []) els1 els2- (MetaElim{}, _) -> __IMPOSSIBLE__ -- projections from metas should have been eta expanded- (_, MetaElim{}) -> __IMPOSSIBLE__- _ -> typeError $ UnequalTerms cmp m n t- where- polarities (Def x _) = getPolarity' cmp x- polarities _ = return []- cmpElim t v els1 els2 = do- a <- t- pol <- polarities v- reportSDoc "tc.conv.elim" 10 $- text "compareElim" <+> vcat- [ text "a =" <+> prettyTCM a- , text "v =" <+> prettyTCM v- , text "els1 =" <+> prettyTCM els1- , text "els2 =" <+> prettyTCM els2- ]- compareElims pol a v els1 els2- (Con x xArgs, Con y yArgs)- | x == y -> do- -- Get the type of the constructor instantiated to the datatype parameters.- a' <- conType x t- -- Constructors are invariant in their arguments- -- (could be covariant).- compareArgs [] a' (Con x []) xArgs yArgs- _ -> typeError $ UnequalTerms cmp m n t- where- conType c (El _ (Def d args)) = do- npars <- do- def <- theDef <$> getConstInfo d- return $ case def of Datatype{dataPars = n} -> n- Record{recPars = n} -> n- _ -> __IMPOSSIBLE__- a <- defType <$> getConstInfo c- return $ piApply a (genericTake npars args)- conType _ _ = __IMPOSSIBLE__-- equalFun t1@(Pi arg1@(Arg h1 r1 a1) _) t2@(Pi (Arg h2 r2 a2) _)- | h1 /= h2 = typeError $ UnequalHiding ty1 ty2- -- Andreas 2010-09-21 compare r1 and r2, but ignore forcing annotations!- | ignoreForced r1 /= ignoreForced r2 = typeError $ UnequalRelevance ty1 ty2- | otherwise = verboseBracket "tc.conv.fun" 15 "compare function types" $ do- reportSDoc "tc.conv.fun" 20 $ nest 2 $ vcat- [ text "t1 =" <+> prettyTCM t1- , text "t2 =" <+> prettyTCM t2 ]- let (ty1',ty2') = raise 1 (ty1,ty2)- arg = Arg h1 r1 (Var 0 [])- name <- freshName_ (suggest t1 t2)- let checkArg = escapeContext 1 $ compareType cmp a2 a1- c = TypeCmp cmp (piApply ty1' [arg]) (piApply ty2' [arg])-- -- We only need to require a1 == a2 if t2 is a dependent function type.- -- If it's non-dependent it doesn't matter what we add to the context.- let dependent = case t2 of- Pi _ b -> isBinderUsed b- _ -> __IMPOSSIBLE__- addCtx name arg1 $- if dependent- then guardConstraint c checkArg- else checkArg >> solveConstraint_ c- where- ty1 = El (getSort a1) t1 -- TODO: wrong (but it doesn't matter)- ty2 = El (getSort a2) t2- suggest t1 t2 = case concatMap name [t1,t2] of- [] -> "_"- x:_ -> x- where- name (Pi _ b) = filter (/= "_") [absName b]- name _ = __IMPOSSIBLE__- equalFun _ _ = __IMPOSSIBLE__---- | Type-directed equality on eliminator spines-compareElims :: [Polarity] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()-compareElims _ _ _ [] [] = return ()-compareElims _ _ _ [] (_:_) = __IMPOSSIBLE__-compareElims _ _ _ (_:_) [] = __IMPOSSIBLE__-compareElims _ _ _ (Apply{} : _) (Proj{} : _) = __IMPOSSIBLE__-compareElims _ _ _ (Proj{} : _) (Apply{} : _) = __IMPOSSIBLE__-compareElims pols0 a v els01@(Apply arg1 : els1) els02@(Apply arg2 : els2) =- verboseBracket "tc.conv.elim" 20 "compare Apply" $ do- reportSDoc "tc.conv.elim" 25 $ nest 2 $ vcat- [ text "a =" <+> prettyTCM a- , text "v =" <+> prettyTCM v- , text "els1 =" <+> prettyTCM els01- , text "els2 =" <+> prettyTCM els02- ]- let (pol, pols) = nextPolarity pols0- ab <- reduceB a- let a = ignoreBlocking ab- catchConstraint (ElimCmp pols0 a v els01 els02) $ do- case unEl <$> ab of- Blocked{} -> patternViolation- NotBlocked MetaV{} -> patternViolation- NotBlocked (Pi (Arg _ r b) _) -> do- let cmp x y = case pol of- Invariant -> compareTerm CmpEq b x y- Covariant -> compareTerm CmpLeq b x y- Contravariant -> compareTerm CmpLeq b y x- mlvl <- mlevel- let checkArg = case r of- Forced -> return ()- Irrelevant -> return () -- Andreas: ignore irr. func. args.- _ -> applyRelevanceToContext r $- cmp (unArg arg1) (unArg arg2)- dependent = case unEl a of- Pi (Arg _ _ (El _ lvl')) c -> 0 `freeInIgnoringSorts` absBody c- && Just lvl' /= mlvl- _ -> False-- theRest = ElimCmp pols (piApply a [arg1]) (apply v [arg1]) els1 els2-- if dependent- then guardConstraint theRest checkArg- else checkArg >> solveConstraint_ theRest-- _ -> __IMPOSSIBLE__-compareElims pols a v els01@(Proj f : els1) els02@(Proj f' : els2)- | f /= f' = typeError . GenericError . show =<< prettyTCM f <+> text "/=" <+> prettyTCM f'- | otherwise = do- a <- reduce a- case unEl a of- Def r us -> do- let (pol, _) = nextPolarity pols- ft <- defType <$> getConstInfo f- let arg = Arg NotHidden Relevant v -- TODO: not necessarily relevant?- let c = piApply ft (us ++ [arg])- (cmp, els1, els2) <- return $ case pol of- Invariant -> (CmpEq, els1, els2)- Covariant -> (CmpLeq, els1, els2)- Contravariant -> (CmpLeq, els2, els2)- pols' <- getPolarity' cmp f- compareElims pols' c (Def f [arg]) els1 els2- _ -> __IMPOSSIBLE__---- | Type-directed equality on argument lists----compareArgs :: [Polarity] -> Type -> Term -> Args -> Args -> TCM ()-compareArgs pol a v args1 args2 =- compareElims pol a v (map Apply args1) (map Apply args2)---- | Equality on Types-compareType :: Comparison -> Type -> Type -> TCM ()-compareType cmp ty1@(El s1 a1) ty2@(El s2 a2) =- verboseBracket "tc.conv.type" 20 "compareType" $- catchConstraint (TypeCmp cmp ty1 ty2) $ do- reportSDoc "tc.conv.type" 50 $ vcat- [ text "compareType" <+> sep [ prettyTCM ty1 <+> prettyTCM cmp- , prettyTCM ty2 ]- , hsep [ text " sorts:", prettyTCM s1, text " and ", prettyTCM s2 ]- ]--- Andreas, 2011-4-27 should not compare sorts, but currently this is needed--- for solving sort and level metas--- let cs1 = []- compareSort CmpEq s1 s2 `catchError` \err -> case errError err of- TypeError _ _ -> do- reportSDoc "tc.conv.type" 30 $ vcat- [ text "sort comparison failed"- , nest 2 $ vcat- [ text "s1 =" <+> prettyTCM s1- , text "s2 =" <+> prettyTCM s2- ]- ]- -- This error will probably be more informative- compareTerm cmp (sort s1) a1 a2- -- Throw the original error if the above doesn't- -- give an error (for instance, due to pending- -- constraints).- -- Or just ignore it... We run into this with irrelevant levels- -- which may show up in sort constraints, causing them to fail.- -- In any case it's not safe to ignore the error, for instance- -- a1 might be Set and a2 a meta of type Set, in which case we- -- really need the sort comparison to fail, instead of silently- -- instantiating the meta.- throwError err- _ -> throwError err- compareTerm cmp (sort s1) a1 a2- return ()--leqType :: Type -> Type -> TCM ()-leqType = compareType CmpLeq-------------------------------------------------------------------------------- * Sorts------------------------------------------------------------------------------compareSort :: Comparison -> Sort -> Sort -> TCM ()-compareSort CmpEq = equalSort-compareSort CmpLeq = equalSort---- | Check that the first sort is less or equal to the second.-leqSort :: Sort -> Sort -> TCM ()-leqSort s1 s2 =- ifM typeInType (return ()) $- catchConstraint (SortCmp CmpLeq s1 s2) $- do (s1,s2) <- reduce (s1,s2)- reportSDoc "tc.conv.sort" 30 $- sep [ text "leqSort"- , nest 2 $ fsep [ prettyTCM s1 <+> text "=<"- , prettyTCM s2 ]- ]- case (s1,s2) of-- (Type a, Type b) -> leqLevel a b-- (Prop , Prop ) -> return ()- (Type _ , Prop ) -> notLeq s1 s2-- (Prop , Type _ ) -> return ()-- (_ , Inf ) -> return ()- (Inf , _ ) -> equalSort s1 s2- (DLub{} , _ ) -> equalSort s1 s2- (_ , DLub{} ) -> equalSort s1 s2- where- notLeq s1 s2 = typeError $ NotLeqSort s1 s2--leqLevel :: Level -> Level -> TCM ()-leqLevel a b = liftTCM $ do- reportSDoc "tc.conv.nat" 30 $- text "compareLevel" <+>- sep [ prettyTCM a <+> text "=<"- , prettyTCM b ]- a <- reduce a- b <- reduce b- catchConstraint (LevelCmp CmpLeq a b) $ leqView a b- where- leqView a@(Max as) b@(Max bs) = do- reportSDoc "tc.conv.nat" 30 $- text "compareLevelView" <+>- sep [ text (show a) <+> text "=<"- , text (show b) ]- wrap $ case (as, bs) of-- -- same term- _ | as == bs -> ok-- -- 0 ≤ any- ([], _) -> ok-- -- as ≤ 0- (as, []) -> sequence_ [ equalLevel (Max [a]) (Max []) | a <- as ]-- -- as ≤ [b]- (as@(_:_:_), [b]) -> sequence_ [ leqView (Max [a]) (Max [b]) | a <- as ]-- -- reduce constants- (as, bs) | minN > 0 -> leqView (Max $ map (subtr minN) as) (Max $ map (subtr minN) bs)- where- ns = map constant as- ms = map constant bs- minN = minimum (ns ++ ms)-- -- remove subsumed- (as, bs)- | not $ null dups -> leqView (Max $ as \\ dups) (Max bs)- where- dups = [ a | a@(Plus m l) <- as, Just n <- [findN l], m <= n ]- findN a = case [ n | Plus n b <- bs, b == a ] of- [n] -> Just n- _ -> Nothing-- -- closed ≤ bs- ([ClosedLevel n], bs)- | n <= maximum (map constant bs) -> ok-- -- as ≤ neutral- (as, bs)- | neutralB && maxA > maxB -> notok- | neutralB && any (\a -> neutral a && not (isInB a)) as -> notok- | neutralB && neutralA -> maybeok $ all (\a -> constant a <= findN a) as- where- maxA = maximum $ map constant as- maxB = maximum $ map constant bs- neutralA = all neutral as- neutralB = all neutral bs- isInB a = elem (unneutral a) $ map unneutral bs- findN a = case [ n | b@(Plus n _) <- bs, unneutral b == unneutral a ] of- [n] -> n- _ -> __IMPOSSIBLE__-- -- [a] ≤ [neutral]- ([a@(Plus n _)], [b@(Plus m NeutralLevel{})])- | m == n -> equalLevel (Max [a]) (Max [b])-- -- anything else- _ -> postpone- where- ok = return ()- notok = typeError $ NotLeqSort (Type a) (Type b)- postpone = patternViolation-- wrap m = catchError m $ \e ->- case errError e of- TypeError{} -> notok- _ -> throwError e-- maybeok True = ok- maybeok False = notok-- neutral (Plus _ NeutralLevel{}) = True- neutral _ = False-- meta (Plus _ MetaLevel{}) = True- meta _ = False-- unneutral (Plus _ (NeutralLevel v)) = v- unneutral _ = __IMPOSSIBLE__-- constant (ClosedLevel n) = n- constant (Plus n _) = n-- subtr m (ClosedLevel n) = ClosedLevel (n - m)- subtr m (Plus n l) = Plus (n - m) l---- choice [] = patternViolation--- choice (m:ms) = noConstraints m `catchError` \_ -> choice ms--- case errError e of--- PatternErr{} -> choice ms--- _ -> throwError e--equalLevel :: Level -> Level -> TCM ()-equalLevel a b = do- a <- reduce a- b <- reduce b- reportSLn "tc.conv.level" 50 $ "equalLevel (" ++ show a ++ ") (" ++ show b ++ ")"- liftTCM $ catchConstraint (LevelCmp CmpEq a b) $- check a b- where- check a@(Max as) b@(Max bs) = do- reportSDoc "tc.conv.level" 40 $- sep [ text "equalLevel"- , vcat [ nest 2 $ sep [ prettyTCM a <+> text "=="- , prettyTCM b- ]- , nest 2 $ sep [ text (show (Max as)) <+> text "=="- , text (show (Max bs))- ]- ]- ]- let a === b = do- lvl <- getLvl- equalAtom lvl a b- as =!= bs = levelTm (Max as) === levelTm (Max bs)- as <- return $ closed0 as- bs <- return $ closed0 bs- case (as, bs) of- _ | List.sort as == List.sort bs -> ok- | any isBlocked (as ++ bs) -> do- lvl <- getLvl- liftTCM $ useInjectivity CmpEq lvl (Level a) (Level b)-- -- closed == closed- ([ClosedLevel n], [ClosedLevel m])- | n == m -> ok- | otherwise -> notok-- -- closed == neutral- ([ClosedLevel{}], _) | any isNeutral bs -> notok- (_, [ClosedLevel{}]) | any isNeutral as -> notok-- -- 0 == any- ([ClosedLevel 0], bs@(_:_:_)) -> sequence_ [ equalLevel (Max []) (Max [b]) | b <- bs ]- (as@(_:_:_), [ClosedLevel 0]) -> sequence_ [ equalLevel (Max [a]) (Max []) | a <- as ]-- -- Same meta- ([Plus n (MetaLevel x _)], [Plus m (MetaLevel y _)])- | n == m && x == y -> ok-- -- meta == any- ([Plus n (MetaLevel x as)], _)- | any (isThisMeta x) bs -> postpone- (_, [Plus n (MetaLevel x bs)])- | any (isThisMeta x) as -> postpone- ([Plus n (MetaLevel x as')], [Plus m (MetaLevel y bs')])- | (n, y) < (m, x) -> meta n x as' bs- | otherwise -> meta m y bs' as- ([Plus n (MetaLevel x as)], _) -> meta n x as bs- (_, [Plus n (MetaLevel x bs)]) -> meta n x bs as-- -- any other metas- _ | any isMeta (as ++ bs) -> postpone-- -- neutral/closed == neutral/closed- _ | all isNeutralOrClosed (as ++ bs) -> as =!= bs-- -- more cases?- _ -> postpone-- where- ok = return ()- notok = typeError $ UnequalSorts (Type a) (Type b)- postpone = do- reportSLn "tc.conv.level" 30 $ "postponing: " ++ show a ++ " == " ++ show b- patternViolation-- closed0 [] = [ClosedLevel 0]- closed0 as = as-- getLvl = El (mkType 0) <$> primLevel-- meta n x as bs = do- reportSLn "tc.meta.level" 50 $ "meta " ++ show as ++ " " ++ show bs- bs' <- mapM (subtr n) bs- assignV x as $ levelTm (Max bs')-- -- Make sure to give a sensible error message- wrap m = m `catchError` \err ->- case errError err of- TypeError{} -> notok- _ -> throwError err-- subtr n (ClosedLevel m)- | m >= n = return $ ClosedLevel (m - n)- | otherwise = notok- subtr n (Plus m a)- | m >= n = return $ Plus (m - n) a- subtr _ (Plus _ BlockedLevel{}) = postpone- subtr _ (Plus _ MetaLevel{}) = postpone- subtr _ (Plus _ NeutralLevel{}) = postpone- subtr _ (Plus _ UnreducedLevel{}) = __IMPOSSIBLE__-- isNeutral (Plus _ NeutralLevel{}) = True- isNeutral _ = False-- isClosed ClosedLevel{} = True- isClosed _ = False-- isNeutralOrClosed l = isClosed l || isNeutral l-- isBlocked (Plus _ BlockedLevel{}) = True- isBlocked _ = False-- isMeta (Plus _ MetaLevel{}) = True- isMeta _ = False-- isThisMeta x (Plus _ (MetaLevel y _)) = x == y- isThisMeta _ _ = False----- | Check that the first sort equal to the second.-equalSort :: Sort -> Sort -> TCM ()-equalSort s1 s2 =- ifM typeInType (return ()) $- catchConstraint (SortCmp CmpEq s1 s2) $ do- (s1,s2) <- reduce (s1,s2)- reportSDoc "tc.conv.sort" 30 $- sep [ text "equalSort"- , vcat [ nest 2 $ fsep [ prettyTCM s1 <+> text "=="- , prettyTCM s2 ]- , nest 2 $ fsep [ text (show s1) <+> text "=="- , text (show s2) ]- ]- ]- case (s1,s2) of-- (Type a , Type b ) -> equalLevel a b-- (Prop , Prop ) -> return ()- (Type _ , Prop ) -> notEq s1 s2- (Prop , Type _ ) -> notEq s1 s2-- (Inf , Inf ) -> return ()- (Inf , Type (Max as@(_:_))) -> mapM_ (isInf $ notEq s1 s2) as- (Type (Max as@(_:_)), Inf) -> mapM_ (isInf $ notEq s1 s2) as- (Inf , _ ) -> notEq s1 s2- (_ , Inf ) -> notEq s1 s2-- (DLub s1 s2, s0@(Type (Max []))) -> do- equalSort s1 s0- underAbstraction_ s2 $ \s2 -> equalSort s2 s0- (s0@(Type (Max [])), DLub s1 s2) -> do- equalSort s0 s1- underAbstraction_ s2 $ \s2 -> equalSort s0 s2- (DLub{} , _ ) -> addConstraint (SortCmp CmpEq s1 s2)- (_ , DLub{} ) -> addConstraint (SortCmp CmpEq s1 s2)- where- notEq s1 s2 = typeError $ UnequalSorts s1 s2-- isInf notok ClosedLevel{} = notok- isInf notok (Plus _ l) = case l of- MetaLevel x vs -> assignV x vs (Sort Inf)- NeutralLevel (Sort Inf) -> return ()- _ -> notok+{-# LANGUAGE CPP #-}+{-# LANGUAGE NondecreasingIndentation #-}+-- {-# OPTIONS_GHC -Wunused-imports #-}+-- {-# OPTIONS_GHC -ddump-simpl -dsuppress-all -dno-suppress-type-signatures -ddump-to-file -dno-typeable-binds #-}++{-# OPTIONS_GHC -fmax-pmcheck-models=390 #-} -- Andreas, 2023-05-12, limit determined by binary search++module Agda.TypeChecking.Conversion+ ( module Agda.TypeChecking.Conversion+ , failConversion+ )+ where++import Control.Monad.Except ( MonadError(..) )++import Data.Function (on)+import Data.IntMap (IntMap)++-- import qualified Data.List as List+import qualified Data.IntMap as IntMap+import qualified Data.Set as Set++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Internal.MetaVars+import Agda.Syntax.Translation.InternalToAbstract (reify)++import Agda.TypeChecking.Monad+import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.MetaVars.Occurs (killArgs,PruneResult(..),rigidVarsNotContainedIn)+import Agda.TypeChecking.Names+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import qualified Agda.TypeChecking.SyntacticEquality as SynEq+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Conversion.Pure (pureCompareAs, runPureConversion)+import Agda.TypeChecking.Forcing (isForced, nextIsForced)+import Agda.TypeChecking.Free+import Agda.TypeChecking.Free.Reduce (forceNonDepSort, IsFree (..))+import Agda.TypeChecking.Datatypes (getConType, getFullyAppliedConType)+import Agda.TypeChecking.Records+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Injectivity+import Agda.TypeChecking.Polarity+import Agda.TypeChecking.SizedTypes+import Agda.TypeChecking.Level+import Agda.TypeChecking.Implicit (implicitArgs)+import Agda.TypeChecking.Irrelevance+import Agda.TypeChecking.Primitive+import Agda.TypeChecking.ProjectionLike+import Agda.TypeChecking.Warnings (MonadWarning)+import Agda.TypeChecking.Conversion.Errors+import Agda.Interaction.Options++import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List+import Agda.Utils.List1 (List1, pattern (:|))+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Monad+import Agda.Utils.Maybe+import Agda.Utils.Permutation+import Agda.Syntax.Common.Pretty (prettyShow)+import qualified Agda.Interaction.Options.ProfileOptions as Profile+import Agda.Utils.BoolSet (BoolSet)+import qualified Agda.Utils.BoolSet as BoolSet+import Agda.Utils.Size+import Agda.Utils.Tuple+import Agda.Utils.Unsafe ( unsafeComparePointers )+import qualified Agda.Utils.VarSet as VarSet+import Agda.Utils.ExpandCase++import Agda.Utils.Impossible+++-- | Try whether a computation runs without errors or new constraints+-- (may create new metas, though).+-- Restores state upon failure.+tryConversion :: TCM () -> TCM Bool+tryConversion = isJust <.> tryConversion'++-- | Try whether a computation runs without errors or new constraints+-- (may create new metas, though).+-- Return 'Just' the result upon success.+-- Return 'Nothing' and restore state upon failure.+tryConversion' :: TCM a -> TCM (Maybe a)+tryConversion' m = tryMaybe $ noConstraints m++-- | Check if to lists of arguments are the same (and all variables).+-- Precondition: the lists have the same length.+sameVars :: Elims -> Elims -> Bool+sameVars xs ys = and $ zipWith same xs ys+ where+ same (Apply (Arg _ (Var n []))) (Apply (Arg _ (Var m []))) = n == m+ same _ _ = False++-- | @intersectVars us vs@ checks whether all relevant elements in @us@ and @vs@+-- are variables, and if yes, returns a prune list which says @True@ for+-- arguments which are different and can be pruned.+intersectVars :: Elims -> Elims -> Maybe [Bool]+intersectVars = zipWithM areVars where+ -- ignore irrelevant args+ areVars (Apply u) v | isIrrelevant u = Just False -- do not prune+ areVars (Apply (Arg _ (Var n []))) (Apply (Arg _ (Var m []))) = Just $ n /= m -- prune different vars+ areVars _ _ = Nothing++-- | @guardPointerEquality x y s m@ behaves as @m@ if @x@ and @y@ are equal as pointers,+-- or does nothing otherwise.+-- Use with care, see the documentation for 'unsafeComparePointers'+guardPointerEquality :: a -> a -> String -> TCM () -> TCM ()+guardPointerEquality u v profileSection action =+ if unsafeComparePointers u v+ then whenProfile Profile.Conversion $ tick profileSection+ else action++equalTerm :: Type -> Term -> Term -> TCM ()+equalTerm = compareTerm CmpEq++equalAtom :: CompareAs -> Term -> Term -> TCM ()+equalAtom = compareAtom CmpEq++equalType :: Type -> Type -> TCM ()+equalType = compareType CmpEq++{- Comparing in irrelevant context always succeeds.++ However, we might want to dig for solutions of irrelevant metas.++ To this end, we can just ignore errors during conversion checking.+ -}++-- convError :: MonadTCM tcm => TypeError -> tcm a+-- | Ignore errors in irrelevant context.+convError :: TypeError -> TCM ()+convError err =+ unlessM (isIrrelevant <$> viewTC eRelevance)+ (typeError err)+++-- | Type directed equality on values.+--+compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()+compareTerm !cmp !a !u !v = compareAs cmp (AsTermsOf a) u v+++-- | Type directed equality on terms or types.+compareAs :: Comparison -> CompareAs -> Term -> Term -> TCM ()+ -- If one term is a meta, try to instantiate right away. This avoids unnecessary unfolding.+ -- Andreas, 2012-02-14: This is UNSOUND for subtyping!+compareAs !cmp !a !u !v = do+ reportSDoc "tc.conv.term" 20 $ sep $+ [ "compareTerm"+ , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v+ , nest 2 $ prettyTCM a+ ]+ whenProfile Profile.Conversion $ tick "compare"++ -- OLD CODE, traverses the *full* terms u v at each step, even if they+ -- are different somewhere. Leads to infeasibility in issue 854.+ -- (u, v) <- instantiateFull (u, v)+ -- let equal = u == v++ -- Check syntactic equality. This actually saves us quite a bit of work.+ guardPointerEquality u v "pointer equality: terms" $ SynEq.checkSyntacticEquality u v+ (\_ _ -> whenProfile Profile.Conversion $ tick "compare equal") $+ \u v -> do+ reportSDoc "tc.conv.term" 15 $ sep $+ [ "compareTerm (not syntactically equal)"+ , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v+ , nest 2 $ prettyTCM a+ ]+ -- If we are at type Size, we cannot short-cut comparison+ -- against metas by assignment.+ -- Andreas, 2014-04-12: this looks incomplete.+ -- It seems to assume we are never comparing+ -- at function types into Size.+ let fallback = compareAs' cmp a u v+ unlessSubtyping :: TCM () -> TCM ()+ unlessSubtyping cont =+ if cmp == CmpEq then cont else do+ -- Andreas, 2014-04-12 do not short cut if type is blocked.+ ifBlocked a (\ _ _ -> fallback) {-else-} $ \ _ a -> do+ -- do not short circuit size comparison!+ caseMaybeM (isSizeType a) cont (\ _ -> fallback)++ dir = fromCmp cmp+ rid = flipCmp dir -- The reverse direction. Bad name, I know.+ case (u, v) of+ (MetaV x us, MetaV y vs)+ | x /= y -> unlessSubtyping $ solve1 `orelse` solve2 `orelse` fallback+ | otherwise -> fallback+ where+ (solve1, solve2) | x > y = (assign dir x us v, assign rid y vs u)+ | otherwise = (assign rid y vs u, assign dir x us v)+ (MetaV x us, _) -> unlessSubtyping $ assign dir x us v `orelse` fallback+ (_, MetaV y vs) -> unlessSubtyping $ assign rid y vs u `orelse` fallback+ (Def f es, Def f' es') | f == f' -> do+ def <- getConstInfo f+ opts <- pragmaOptions+ let shortcut = case theDef def of+ _ | optFirstOrder opts -> True+ d@Function{}+ | not $ optRequireUniqueMetaSolutions opts -> d ^. funFirstOrder+ _ -> False+ if not shortcut then fallback else unlessSubtyping $ do+ -- We do not shortcut projection-likes,+ -- Andreas, 2022-03-07, issue #5809:+ -- but irrelevant projections since they are applied to their parameters.+ -- Amy, 2023-01-04, issue #6415: and not+ -- prim^unglue/prim^unglueU either! removing the unglue from a+ -- transport/hcomp may cause an infinite loop.+ unglue <- getName' builtin_unglue+ unglueU <- getName' builtin_unglueU+ let+ notFirstOrder = isJust (isRelevantProjection_ def) || Just f == unglue || Just f == unglueU+ if notFirstOrder then fallback else do+ pol <- getPolarity' cmp f+ whenProfile Profile.Conversion $ tick "compare first-order shortcut"+ compareElims pol [] (defType def) (Def f []) es es' `orelse` fallback+ _ -> fallback+ where+ assign :: CompareDirection -> MetaId -> Elims -> Term -> TCM ()+ assign dir x es v = do+ -- Andreas, 2013-10-19 can only solve if no projections+ reportSDoc "tc.conv.term.shortcut" 20 $ sep+ [ "attempting shortcut"+ , nest 2 $ prettyTCM (MetaV x es) <+> ":=" <+> prettyTCM v+ ]+ whenM (isInstantiatedMeta x) (patternViolation alwaysUnblock) -- Already instantiated, retry right away+ whenProfile Profile.Conversion $ tick "compare meta shortcut"+ assignE dir x es v a $ compareAsDir dir a+ reportSDoc "tc.conv.term.shortcut" 50 $+ "shortcut successful" $$ nest 2 ("result:" <+> (pretty =<< instantiate (MetaV x es)))+ whenProfile Profile.Conversion $ tick "compare meta shortcut successful"+ -- Should be ok with catchError_ but catchError is much safer since we don't+ -- rethrow errors.+ orelse :: TCM () -> TCM () -> TCM ()+ orelse m h = catchError m (\_ -> h)++-- | Try to assign meta. If meta is projected, try to eta-expand+-- and run conversion check again.+assignE :: CompareDirection -> MetaId -> Elims -> Term -> CompareAs+ -> (Term -> Term -> TCM ()) -> TCM ()+assignE dir x es v a comp = do+ whenProfile Profile.Conversion $ tick "compare meta"+ case allApplyElims es of+ Just vs -> assignV dir x vs v a+ Nothing -> do+ reportSDoc "tc.conv.assign" 30 $ sep+ [ "assigning to projected meta "+ , prettyTCM x <+> sep (map' prettyTCM es) <+> text (":" ++ show dir) <+> prettyTCM v+ ]+ etaExpandMeta [Records] x+ res <- isInstantiatedMeta' x+ case res of+ Just u -> do+ reportSDoc "tc.conv.assign" 30 $ sep+ [ "seems like eta expansion instantiated meta "+ , prettyTCM x <+> text (":" ++ show dir) <+> prettyTCM u+ ]+ let w = u `applyE` es+ comp w v+ Nothing -> do+ reportSLn "tc.conv.assign" 30 "eta expansion did not instantiate meta"+ patternViolation $ unblockOnMeta x -- nothing happened, give up++compareAsDir :: CompareDirection -> CompareAs -> Term -> Term -> TCM ()+compareAsDir !dir !a = dirToCmp (`compareAs'` a) dir++compareAs' :: Comparison -> CompareAs -> Term -> Term -> TCM ()+compareAs' !cmp !tt !m !n = case tt of+ AsTermsOf a -> compareTerm' cmp a m n+ AsSizes -> compareSizes cmp m n+ AsTypes -> compareAtom cmp AsTypes m n++compareTerm' :: Comparison -> Type -> Term -> Term -> TCM ()+compareTerm' !cmp !a !m !n =+ verboseBracket "tc.conv.term" 20 "compareTerm" $ do+ (ba, a') <- reduceWithBlocker a+ (catchConstraint (ValueCmp cmp (AsTermsOf a') m n) :: TCM () -> TCM ()) $ blockOnError ba $ do+ reportSDoc "tc.conv.term" 30 $ fsep+ [ "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, ":", prettyTCM a' ]+ propIrr <- isPropEnabled+ isSize <- isJust <$> isSizeType a'+ (bs, s) <- reduceWithBlocker $ getSort a'+ mlvl <- getBuiltin' builtinLevel+ reportSDoc "tc.conv.term" 40 $ fsep+ [ "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, ":", prettyTCM a'+ , "at sort", prettyTCM s]+ reportSDoc "tc.conv.level" 60 $ nest 2 $ sep+ [ "a' =" <+> pretty a'+ , "mlvl =" <+> pretty mlvl+ , text $ "(Just (unEl a') == mlvl) = " ++ show (Just (unEl a') == mlvl)+ ]+ blockOnError bs $+ expand \ret -> case unEl a' of+ _ | propIrr+ , isProp s -> ret $ compareIrrelevant a' m n+ _ | isSize -> ret $ compareSizes cmp m n+ a | Just a == mlvl -> ret do+ a <- levelView m+ b <- levelView n+ nowConversionChecking cmp (Level a) (Level b) (AsTermsOf a') $+ equalLevel a b+ a@Pi{} -> ret $ equalFun s a m n+ Lam _ _ -> ret do+ reportSDoc "tc.conv.term.sort" 10 $ fsep+ [ "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, ":", prettyTCM a'+ , "at sort", prettyTCM s+ ]+ __IMPOSSIBLE__+ Def r es -> ret do+ isrec <- isEtaRecord r+ expand \ret -> if isrec+ then ret do+ whenProfile Profile.Conversion $ tick "compare at eta record"+ sig <- getSignature++ transp <- getPrimitiveName' builtinTrans+ hcomp <- getPrimitiveName' builtinHComp++ let+ ps = mustAllApplyElims es+ -- Andreas, 2010-10-11: allowing neutrals to be blocked things does not seem+ -- to change Agda's behavior+ -- isNeutral Blocked{} = False+ isNeutral (NotBlocked _ Con{}) = return False++ -- Andreas, 2013-09-18 / 2015-06-29: a Def by copatterns is+ -- not neutral if it is blocked (there can be missing projections+ -- to trigger a reduction.+ isNeutral (NotBlocked r (Def q _)) = do -- Andreas, 2014-12-06 optimize this using r !!+ not <$> usesCopatterns q -- a def by copattern can reduce if projected+ isNeutral (NotBlocked r (Var i _)) = do+ -- Local rewrite rules can also make a variable applications+ -- reduce if projected+ not <$> rewUsesCopatterns (RewVarHead i)+ isNeutral _ = return True++ -- Amy, 2024-01-29: Is this blocked application headed by one of the+ -- cubical primitives that behave as though they are copattern matching?+ isCubicalPrimHead (NotBlocked r (Def q _)) -- Amy, 2024-01-29: optimise this using r !!+ | Just q == transp || Just q == hcomp+ = Just q+ isCubicalPrimHead _ = Nothing++ isMeta b = case ignoreBlocking b of+ MetaV{} -> True+ _ -> False++ reportSDoc "tc.conv.term" 30 $ prettyTCM a <+> "is eta record type"+ m <- reduceB m+ mNeutral <- isNeutral m+ n <- reduceB n+ nNeutral <- isNeutral n++ let+ h1 = isCubicalPrimHead m+ h2 = isCubicalPrimHead n++ mCub = isJust (isCubicalPrimHead m)+ nCub = isJust (isCubicalPrimHead n)++ -- Amy, 2024-01-29 (fixing issue pointed out by Tom Jack):+ --+ -- Cubical primitives reduce to something awful, so we would like to skip comparing them (causes+ -- "timeout" in GroupPath).+ --+ -- We would also like to skip comparing a cubical primitive against something that is *small* and+ -- actually neutral (causes "timeout" in KleinBottle cohomology groups, comparing a 93KiB(!) transport+ -- against an application of set-truncation recursion to a metavariable)+ --+ -- The conditions for skipping eta expansion are thus:+ --+ -- (n) both are neutrals (which in this case also includes a "suspended"/copattern transp/hcomp); and+ --+ -- (c1) if both are headed by a cubical primitive, then they are the same primitive; or+ --+ -- (New! 2025-07-23:)+ -- (c2) if one side is a cubical primitive, then the other side must be actually *blocked*+ -- This prevents us from not noticing things like transport (λ i → Nat × Nat) x ≡ x+ -- (transport on Σ is "defined by copatterns" so both sides are "neutral",+ -- but the transport is a pair that contains x .fst and x .snd!)+ --+ -- So we will skip expanding transp A φ u0 = transp A' φ' u0', since it's definitionally injective;+ -- We will skip expanding transp A φ u0 = f ?, since it's wasted work; but we will not skip+ -- transp A φ u0 = hcomp u u0', since those must both compute if they are to be equal.+ cubSkipOk+ | mCub && nCub = h1 == h2+ | mCub, Blocked{} <- n = True+ | Blocked{} <- m, nCub = True+ | otherwise = mCub == nCub++ when (mCub || nCub) $+ reportSDoc "tc.conv.term.cubical" 30 $ vcat+ [ ("m (" <> prettyTCM mNeutral <> ", " <> prettyTCM mCub <> ", " <> prettyTCM h1 <> "):")+ , nest 2 (prettyTCM m)+ , ("n (" <> prettyTCM nNeutral <> ", " <> prettyTCM nCub <> ", " <> prettyTCM h2 <> "):")+ , nest 2 (prettyTCM n)+ , "at type"+ , nest 2 (prettyTCM a')+ , "same head:" <+> prettyTCM (h1 == h2)+ , "skipping:" <+> prettyTCM cubSkipOk+ ]++ if | isMeta m || isMeta n -> do+ whenProfile Profile.Conversion $ tick "compare at eta-record: meta"+ compareAtom cmp (AsTermsOf a') (ignoreBlocking m) (ignoreBlocking n)++ | mNeutral && nNeutral && cubSkipOk -> do+ whenProfile Profile.Conversion $ tick "compare at eta-record: both neutral"+ -- Andreas 2011-03-23: (fixing issue 396)+ -- if we are dealing with a singleton record,+ -- we can succeed immediately+ let profUnitEta = whenProfile Profile.Conversion $ tick "compare at eta-record: both neutral at unit"+ ifM (isSingletonRecordModuloRelevance r ps) profUnitEta $ do+ -- do not eta-expand if comparing two neutrals+ compareAtom cmp (AsTermsOf a') (ignoreBlocking m) (ignoreBlocking n)++ | otherwise -> do+ whenProfile Profile.Conversion $ tick "compare at eta-record: eta-expanding"+ mm' <- etaExpandRecord r ps $ ignoreBlocking m+ nn' <- etaExpandRecord r ps $ ignoreBlocking n+ case (mm', nn') of+ (Just (tel, m'), Just (_, n')) -> do+ -- No subtyping on record terms+ c <- getRecordConstructor r+ -- Record constructors are covariant (see test/succeed/CovariantConstructors).+ compareArgs (repeat $ polFromCmp cmp) []+ (telePi_ tel (raise (size tel) a'))+ (Con c ConOSystem [])+ m' n'+ -- Issue #8636: Eta-expansion may fail if a term is a+ -- constructor of a different (but possibly definitionally+ -- equal under unsolvable constraints) record type. In that+ -- case we fall back to atomic comparison, which will produce a+ -- proper conversion error rather than crashing.+ _ -> compareAtom cmp (AsTermsOf a') (ignoreBlocking m) (ignoreBlocking n)++ else ret do pathview <- pathView a'+ equalPath pathview a' m n+ _ -> ret $ compareAtom cmp (AsTermsOf a') m n+ where+ -- equality at function type (accounts for eta)+ equalFun :: Sort -> Term -> Term -> Term -> TCM ()+ equalFun s a@(Pi dom b) m n | domIsFinite dom = do+ !mp <- fmap getPrimName <$> getBuiltin' builtinIsOne+ let dom' = set dIsFinite False dom+ let asFn = El s (Pi dom' b)+ case unEl $ unDom dom of+ Def q [Apply phi]+ | Just q == mp -> compareTermOnFace cmp (unArg phi) asFn m n+ _ -> equalFun s (unEl asFn) m n++ equalFun _ (Pi dom@(view dInfo -> info) b) (Lam _ m) (Lam _ n) = do+ whenProfile Profile.Conversion $ tick "compare at function type"+ let name = suggests [ Suggestion b , Suggestion m , Suggestion n ]+ addConversionContext (ConvLam dom (void b) name)+ $ addContext (name, dom)+ $ compareTerm cmp (absBody b) (absBody m) (absBody n)++ equalFun _ (Pi dom@(view dInfo -> info) b) m n = do+ whenProfile Profile.Conversion $ tick "compare at function type"+ let+ (m', n') = let !v = var 0 in raise 1 (m,n) `apply` [Arg info v]+ name = suggests [ Suggestion b , Suggestion m , Suggestion n ]+ addConversionContext (ConvLam dom (void b) name)+ $ addContext (name, dom)+ $ compareTerm cmp (absBody b) m' n'++ equalFun _ _ _ _ = __IMPOSSIBLE__++ equalPath :: PathView -> Type -> Term -> Term -> TCM ()+ equalPath (PathType s _ l a x y) _ m n = do+ whenProfile Profile.Conversion $ tick "compare at path type"+ interval <- el primInterval+ let+ (m', n') = raise 1 (m, n) `applyE` [IApply (raise 1 $ unArg x) (raise 1 $ unArg y) (var 0)]+ name = "i" :: String+ addContext (name, defaultDom interval) $ cutConversionErrors $+ compareTerm cmp (El (raise 1 s) $ raise 1 (unArg a) `apply` [argN $ var 0]) m' n'+ equalPath OType{} a' m n = cmpDef a' m n++ cmpDef a'@(El s ty) m n = do+ mI <- getBuiltinName' builtinInterval+ mIsOne <- getBuiltinName' builtinIsOne+ mGlue <- getPrimitiveName' builtinGlue+ mHComp <- getPrimitiveName' builtinHComp+ mSub <- getBuiltinName' builtinSub+ mUnglueU <- getPrimitiveTerm' builtin_unglueU+ mSubIn <- getBuiltin' builtinSubIn+ case ty of+ Def q es | Just q == mIsOne -> return ()+ Def q es | Just q == mGlue, Just args@(l:_:a:phi:_) <- allApplyElims es -> do+ aty <- el' (pure $ unArg l) (pure $ unArg a)+ unglue <- prim_unglue+ let mkUnglue m = apply unglue $ (map' (setHiding Hidden) args) ++! [argN m]+ reportSDoc "conv.glue" 20 $ prettyTCM (aty,mkUnglue m,mkUnglue n)++ -- Amy, 2023-01-04: Here and in hcompu below we *used to*+ -- also compare whatever the glued terms would evaluate to+ -- on φ. This is very loopy (consider φ = f i or φ = i0:+ -- both generate empty substitutions so get us back to+ -- exactly the same conversion problem)!+ --+ -- But is there a reason to do this comparison? The+ -- answer, it turns out, is no!+ --+ -- Suppose you had+ -- Γ ⊢ x = glue [φ → t] xb : Glue T S+ -- Γ ⊢ y = glue [φ → s] yb : Glue T S+ -- Γ ⊢ xb = yb : T+ -- Is there a need to check whether Γ φ ⊢ t = s : S? No!+ -- That's because the typing rule for glue is something like+ -- glue φ : (s : PartialP φ S) (t : T [ φ → s ]) → Glue T S+ -- where the bracket notation stands for an "implicit+ -- Sub"-type, i.e. Γ, φ ⊢ t = s (definitionally)+ --+ -- So if we have a glued element, and we have xb = yb, we+ -- can be sure that+ -- Γ , φ ⊢ t = xb = yb = s+ --+ -- But what about the general case, where we're not+ -- looking at a literal glue? Well, eta for Glue+ -- means x = glue [φ → x] (unglue x), so the logic above+ -- still applies. On φ, for the reducts to agree, it's+ -- enough for the bases to agree.++ compareTerm cmp aty (mkUnglue m) (mkUnglue n)++ Def q es+ | Just q == mHComp, Just (sl:s:args@[phi,u,u0]) <- allApplyElims es+ , Sort (Type lvl) <- unArg s+ , Just unglueU <- mUnglueU, Just subIn <- mSubIn -> do+ let l = Level lvl+ ty <- el' (pure $ l) (pure $ unArg u0)+ let bA = subIn `apply` [sl,s,phi,u0]+ let mkUnglue m = apply unglueU $! [argH l] ++! map' (setHiding Hidden) [phi,u] ++! [argH bA,argN m]+ reportSDoc "conv.hcompU" 20 $ prettyTCM (ty,mkUnglue m,mkUnglue n)+ compareTerm cmp ty (mkUnglue m) (mkUnglue n)++ Def q es | Just q == mSub, Just args@(l:a:_) <- allApplyElims es -> do+ ty <- el' (pure $ unArg l) (pure $ unArg a)+ out <- primSubOut+ let mkOut m = apply out $! map' (setHiding Hidden) args ++! [argN m]+ compareTerm cmp ty (mkOut m) (mkOut n)++ Def q [] | Just q == mI -> compareInterval cmp a' m n+ _ -> compareAtom cmp (AsTermsOf a') m n++compareAtomDir :: CompareDirection -> CompareAs -> Term -> Term -> TCM ()+compareAtomDir dir a = dirToCmp (`compareAtom` a) dir++-- | Compute the head type of an elimination. For projection-like functions+-- this requires inferring the type of the principal argument.+computeElimHeadType :: QName -> Elims -> Elims -> TCM Type+computeElimHeadType f [] es' = computeDefType f es'+computeElimHeadType f es _ = computeDefType f es++-- | Compute the type of a rewrite rule head. For projection-like+-- functions, this requires inferring the type of the principal argument,+-- using the eliminations.+computeRewHeadType ::+ Int -- Size of the "rewrite rule telescope"+ -> RewriteHead -- Rewrite rule head we want to compute the type of+ -> Elims -- Eliminations+ -> Elims -- Alternative eliminations, used if the first is empty+ -> TCM Type+computeRewHeadType !telSize (RewDefHead f) !es !es' = computeElimHeadType f es es'+computeRewHeadType telSize (RewVarHead x) es es' = typeOfBV $ x + telSize++-- | Syntax directed equality on atomic values+--+compareAtom :: Comparison -> CompareAs -> Term -> Term -> TCM ()+compareAtom cmp t m n =+ verboseBracket "tc.conv.atom" 20 "compareAtom" $+ -- if a PatternErr is thrown, rebuild constraint!+ (catchConstraint (ValueCmp cmp t m n) :: TCM () -> TCM ()) $ do+ reportSLn "tc.conv.atom.size" 50 $ "compareAtom term size: " ++ show (termSize m, termSize n)+ reportSDoc "tc.conv.atom" 50 $+ "compareAtom" <+> fsep [ prettyTCM m <+> prettyTCM cmp+ , prettyTCM n+ , prettyTCM t+ ]+ whenProfile Profile.Conversion $ tick "compare by reduction"+ -- Are we currently defining mutual functions? Which?+ currentMutuals <-+ maybe (pure Set.empty) (mutualNames <.> lookupMutualBlock) =<< viewTC eMutualBlock++ -- Andreas: what happens if I cut out the eta expansion here?+ -- Answer: Triggers issue 245, does not resolve 348+ mb' <- etaExpandBlocked =<< reduceB m+ nb' <- etaExpandBlocked =<< reduceB n++ let blocker = unblockOnEither (getBlocker mb') (getBlocker nb')+ reportSLn "tc.conv.atom.size" 50 $ "term size after reduce: " ++ show (termSize $ ignoreBlocking mb', termSize $ ignoreBlocking nb')++ -- constructorForm changes literal to constructors+ -- only needed if the other side is not a literal+ (mb'', nb'') <- expand \ret -> case (ignoreBlocking mb', ignoreBlocking nb') of+ (Lit _, Lit _) -> ret $ return (mb', nb')+ _ -> ret $ (,) <$!> traverse constructorForm mb'+ <*!> traverse constructorForm nb'++ mb <- traverse unLevel mb''+ nb <- traverse unLevel nb''++ cmpBlocked <- viewTC eCompareBlocked++ let m = ignoreBlocking mb+ n = ignoreBlocking nb++ checkDefinitionalEquality = unlessM (pureCompareAs CmpEq t m n) notEqual++ notEqual = failConversion cmp m n t++ dir = fromCmp cmp+ rid = flipCmp dir -- The reverse direction. Bad name, I know.++ assign dir x es v = assignE dir x es v t $ compareAsDir dir t++ reportSDoc "tc.conv.atom" 30 $+ "compareAtom" <+> fsep [ prettyTCM mb <+> prettyTCM cmp+ , prettyTCM nb+ , prettyTCM t+ , prettyTCM blocker+ ]+ reportSDoc "tc.conv.atom" 80 $+ "compareAtom" <+> fsep [ pretty mb <+> prettyTCM cmp+ , pretty nb+ , ":" <+> pretty t ]+ expand \ret -> case (mb, nb) of+ -- equate two metas x and y. if y is the younger meta,+ -- try first y := x and then x := y+ _ | MetaV x xArgs <- ignoreBlocking mb, -- Can be either Blocked or NotBlocked depending on+ MetaV y yArgs <- ignoreBlocking nb -> -- envCompareBlocked check above.+ ret $ compareMetas cmp t x xArgs y yArgs++ -- one side a meta+ _ | MetaV x es <- ignoreBlocking mb -> ret $ assign dir x es n+ _ | MetaV x es <- ignoreBlocking nb -> ret $ assign rid x es m+ (Blocked{}, Blocked{}) | not cmpBlocked -> ret $ checkDefinitionalEquality+ (Blocked b _, _) | not cmpBlocked -> ret $ useInjectivity (fromCmp cmp) b t m n -- The blocked term goes first+ (_, Blocked b _) | not cmpBlocked -> ret $ useInjectivity (flipCmp $ fromCmp cmp) b t n m+ bs -> ret do+ blockOnError blocker $ do+ -- -- Andreas, 2013-10-20 put projection-like function+ -- -- into the spine, to make compareElims work.+ -- -- 'False' means: leave (Def f []) unchanged even for+ -- -- proj-like funs.+ -- m <- elimView False m+ -- n <- elimView False n+ -- Andreas, 2015-07-01, actually, don't put them into the spine.+ -- Polarity cannot be communicated properly if projection-like+ -- functions are post-fix.+ expand \ret -> case (m, n) of+ (Pi{}, Pi{}) -> ret $ equalFun m n++ (Sort s1, Sort s2) -> ret $+ ifM (optCumulativity <$> pragmaOptions)+ (compareSort cmp s1 s2)+ (equalSort s1 s2)++ (Lit l1, Lit l2) | l1 == l2 -> ret $ return ()+ (Var i es, Var i' es') | i == i' -> ret do+ a <- typeOfBV i+ -- Variables are invariant in their arguments+ compareElims [] [] a (var i) es es'++ -- The case of definition application:+ (Def f es, Def f' es') -> ret do++ -- 1. All absurd lambdas are equal.+ unlessM (bothAbsurd f f') $ do++ -- 2. If the heads are unequal, the only chance is subtyping between SIZE and SIZELT.+ if f /= f' then trySizeUniv cmp t m n f es f' es' else do++ -- 3. If the heads are equal:+ -- 3a. If there are no arguments, we are done.+ unless (null es && null es') $ do++ -- 3b. If some cubical magic kicks in, we are done.+ unlessM (compareEtaPrims f es es') $ do++ -- 3c. Oh no, we actually have to work and compare the eliminations!+ a <- computeElimHeadType f es es'+ -- The polarity vector of projection-like functions+ -- does not include the parameters.+ pol <- getPolarity' cmp f+ compareElims pol [] a (Def f []) es es'++ -- Due to eta-expansion, these constructors are fully applied.+ (Con x ci xArgs, Con y _ yArgs)+ | x == y -> ret do+ -- Get the type of the constructor instantiated to the datatype parameters.+ a' <- case t of+ AsTermsOf a -> conType x a+ AsSizes -> __IMPOSSIBLE__+ AsTypes -> __IMPOSSIBLE__+ forcedArgs <- getForcedArgs $ conName x+ -- Constructors are covariant in their arguments+ -- (see test/succeed/CovariantConstructors).+ compareElims (repeat $ polFromCmp cmp) forcedArgs a' (Con x ci []) xArgs yArgs+ _ -> ret notEqual+ where+ -- returns True in case we handled the comparison already.+ compareEtaPrims :: QName -> Elims -> Elims -> TCM Bool+ compareEtaPrims q es es' = do+ munglue <- getPrimitiveName' builtin_unglue+ munglueU <- getPrimitiveName' builtin_unglueU+ msubout <- getPrimitiveName' builtinSubOut+ case () of+ _ | Just q == munglue -> compareUnglueApp q es es'+ _ | Just q == munglueU -> compareUnglueUApp q es es'+ _ | Just q == msubout -> compareSubApp q es es'+ _ -> return False+ compareSubApp q es es' = do+ let (as,bs) = splitAt 5 es; (as',bs') = splitAt 5 es'+ case (allApplyElims as, allApplyElims as') of+ (Just [a,bA,phi,u,x], Just [a',bA',phi',u',x']) -> do+ tSub <- primSub+ -- Andrea, 28-07-16:+ -- comparing the types is most probably wasteful,+ -- since b and b' should be neutral terms, but it's a+ -- precondition for the compareAtom call to make+ -- sense.+ equalType (El (tmSSort $ unArg a) $! apply tSub $! (a :) $! map' (setHiding NotHidden) [bA,phi,u])+ (El (tmSSort $ unArg a) $! apply tSub $! (a :) $! map' (setHiding NotHidden) [bA',phi',u'])+ compareAtom cmp (AsTermsOf $ El (tmSSort $ unArg a) $! apply tSub $! (a :) $! map' (setHiding NotHidden) [bA,phi,u])+ (unArg x) (unArg x')+ () <- compareElims [] [] (El (tmSort (unArg a)) (unArg bA)) (Def q as) bs bs'+ return True+ _ -> return False+ compareUnglueApp q es es' = do+ let (as,bs) = splitAt' 7 es; (as',bs') = splitAt' 7 es'+ case (allApplyElims as, allApplyElims as') of+ (Just [la,lb,bA,phi,bT,e,b], Just [la',lb',bA',phi',bT',e',b']) -> do+ tGlue <- getPrimitiveTerm builtinGlue+ -- Andrea, 28-07-16:+ -- comparing the types is most probably wasteful,+ -- since b and b' should be neutral terms, but it's a+ -- precondition for the compareAtom call to make+ -- sense.+ -- equalType (El (tmSort (unArg lb)) $ apply tGlue $ [la,lb] ++ map (setHiding NotHidden) [bA,phi,bT,e])+ -- (El (tmSort (unArg lb')) $ apply tGlue $ [la',lb'] ++ map (setHiding NotHidden) [bA',phi',bT',e'])+ compareAtom cmp (AsTermsOf $ El (tmSort (unArg lb)) $ apply tGlue $! [la,lb] ++! map' (setHiding NotHidden) [bA,phi,bT,e])+ (unArg b) (unArg b')+ () <- compareElims [] [] (El (tmSort (unArg la)) (unArg bA)) (Def q as) bs bs'+ return True+ _ -> return False+ compareUnglueUApp :: QName -> Elims -> Elims -> TCM Bool+ compareUnglueUApp q es es' = do+ let (as,bs) = splitAt' 5 es; (as',bs') = splitAt' 5 es'+ case (allApplyElims as, allApplyElims as') of+ (Just [la,phi,bT,bAS,b], Just [la',phi',bT',bA',b']) -> do+ tHComp <- primHComp+ tLSuc <- primLevelSuc+ tSubOut <- primSubOut+ iz <- primIZero+ let lsuc t = tLSuc `apply` [argN t]+ s = tmSort $ unArg la+ sucla = lsuc <$> la+ bA <- runNamesT [] $ do+ la <- open . unArg $ la+ phi <- open . unArg $ phi+ bT <- open . unArg $ bT+ bAS <- open . unArg $ bAS+ (pure tSubOut <#> (pure tLSuc <@> la) <#> (Sort . tmSort <$> la) <#> phi <#> (bT <@> primIZero) <@> bAS)+ compareAtom cmp (AsTermsOf $ El (tmSort . unArg $ sucla) $ apply tHComp $ [sucla, argH (Sort s), phi] ++! [argH (unArg bT), argH bA])+ (unArg b) (unArg b')+ () <- compareElims [] [] (El s bA) (Def q as) bs bs'+ return True+ _ -> return False+ -- Andreas, 2013-05-15 due to new postponement strategy, type can now be blocked+ conType c t = do+ t <- abortIfBlocked t+ let impossible = do+ reportSDoc "impossible" 10 $+ "expected data/record type, found " <+> prettyTCM t+ reportSDoc "impossible" 70 $ nest 2 $ "raw =" <+> pretty t+ -- __IMPOSSIBLE__+ -- Andreas, 2013-10-20: in case termination checking fails+ -- we might get some unreduced types here.+ -- In issue 921, this happens during the final attempt+ -- to solve left-over constraints.+ -- Thus, instead of crashing, just give up gracefully.+ patternViolation neverUnblock+ maybe impossible (return . snd) =<< getFullyAppliedConType c t+ equalFun t1 t2 = expand \ret -> case (t1, t2) of+ (Pi dom1 b1, Pi dom2 b2) -> ret do+ verboseBracket "tc.conv.fun" 15 "compare function types" $ do+ reportSDoc "tc.conv.fun" 20 $ nest 2 $ vcat+ [ "t1 =" <+> prettyTCM t1+ , "t2 =" <+> prettyTCM t2+ ]+ compareDom cmp dom2 dom1 b1 b2 (failConversion cmp t1 t2 AsTypes) $+ compareType cmp (absBody b1) (absBody b2)+ _ -> __IMPOSSIBLE__++-- | Check whether @x xArgs `cmp` y yArgs@+compareMetas :: Comparison -> CompareAs -> MetaId -> Elims -> MetaId -> Elims -> TCM ()+compareMetas cmp t x xArgs y yArgs | x == y = blockOnError (unblockOnMeta x) $ do+ cmpBlocked <- viewTC eCompareBlocked+ let fallback = do+ -- Fallback: check definitional equality+ a <- metaType x+ runPureConversion (compareElims [] [] a (MetaV x []) xArgs yArgs)+ if | cmpBlocked -> do+ a <- metaType x+ compareElims [] [] a (MetaV x []) xArgs yArgs+ | otherwise -> case intersectVars xArgs yArgs of+ -- all relevant arguments are variables+ Just kills -> do+ -- kills is a list with 'True' for each different var+ killResult <- killArgs kills x+ case killResult of+ NothingToPrune -> pure ()+ PrunedEverything -> pure ()+ PrunedNothing -> fallback+ PrunedSomething -> fallback+ -- not all relevant arguments are variables+ Nothing -> fallback+compareMetas cmp t x xArgs y yArgs = do+ p1 <- getMetaPriority x+ p2 <- getMetaPriority y+ let dir = fromCmp cmp+ rid = flipCmp dir -- The reverse direction. Bad name, I know.+ retry = patternViolation alwaysUnblock+ -- First try the one with the highest priority. If that doesn't+ -- work, try the low priority one.+ let (solve1, solve2)+ | (p1, x) > (p2, y) = (l1, r2)+ | otherwise = (r1, l2)+ where l1 = assignE dir x xArgs (MetaV y yArgs) t $ \ _ _ -> retry+ r1 = assignE rid y yArgs (MetaV x xArgs) t $ \ _ _ -> retry+ -- Careful: the first attempt might prune the low+ -- priority meta! (Issue #2978)+ l2 = ifM (isInstantiatedMeta x) retry l1+ r2 = ifM (isInstantiatedMeta y) retry r1++ -- Unblock on both unblockers of solve1 and solve2+ catchPatternErr (`addOrUnblocker` solve2) solve1++-- | Check whether @a1 `cmp` a2@ and continue in context extended by @a1@.+compareDom ::+ Comparison -- ^ @cmp@ The comparison direction+ -> Dom Type -- ^ @a1@ The smaller domain.+ -> Dom Type -- ^ @a2@ The other domain.+ -> Abs Type -- ^ @b1@ The smaller codomain.+ -> Abs Type -- ^ @b2@ The bigger codomain.+ -> TCM () -- ^ Error continuation+ -> TCM () -- ^ Success continuation+ -> TCM ()+compareDom cmp0 dom1@(unDom -> a1) dom2@(unDom -> a2) b1 b2 err cont = do+ let i1 = dom1 ^. dInfo; i2 = dom2 ^. dInfo+ if | not $ sameHiding dom1 dom2 -> err+ | not $ (==) (getRelevance dom1) (getRelevance dom2) -> err+ | not $ sameQuantity (getQuantity dom1) (getQuantity dom2) -> err+ | not $ sameCohesion (getCohesion dom1) (getCohesion dom2) -> err+ | not $ samePolarity (getModalPolarity dom1) (getModalPolarity dom2) -> err+ | not $ domIsFinite dom1 == domIsFinite dom2 -> err+ -- We compare both rewrite annotations AND the actual rewDoms to properly+ -- handle the case where we have use a rewrite annotation outside of a+ -- module telescope and continued trying to typecheck+ | not $ getRewriteAnn dom1 == getRewriteAnn dom2+ && isJust (rewDom dom1) == isJust (rewDom dom2) -> err+ | otherwise -> do+ let r = max (getRelevance dom1) (getRelevance dom2)+ -- take "most irrelevant"+ dependent = not (isIrrelevant r) && isBinderUsed b2+ pid <- addConversionContext (\r -> ConvDom (r <$ dom1) b2 b1) $ newProblem_ $ compareType cmp0 a1 a2+ dom <- if dependent+ then (\ a -> dom1 {unDom = a}) <$> blockTypeOnProblem a1 pid+ else return dom1+ -- We only need to require a1 == a2 if b2 is dependent+ -- If it's non-dependent it doesn't matter what we add to the context.+ let name = suggests [ Suggestion b1 , Suggestion b2 ]+ addConversionContext (ConvCod dom name) $ addContext (name, dom) $ cont+ stealConstraints pid+ -- Andreas, 2013-05-15 Now, comparison of codomains is not+ -- blocked any more by getting stuck on domains.+ -- Only the domain type in context will be blocked.+ -- But see issue #1258.++-- | When comparing argument spines (in compareElims) where the first arguments+-- don't match, we keep going, substituting the anti-unification of the two+-- terms in the telescope. More precisely:+--+-- @@+-- (u = v : A)[pid] w = antiUnify pid A u v us = vs : Δ[w/x]+-- -------------------------------------------------------------+-- u us = v vs : (x : A) Δ+-- @@+--+-- The simplest case of anti-unification is to return a fresh metavariable+-- (created by blockTermOnProblem), but if there's shared structure between+-- the two terms we can expose that.+--+-- This is really a crutch that lets us get away with things that otherwise+-- would require heterogenous conversion checking. See for instance issue+-- #2384.+antiUnify :: ProblemId -> Type -> Term -> Term -> TCM Term+antiUnify pid a u v = do+ SynEq.checkSyntacticEquality u v (\u _ -> return u) $ \u v -> do+ (u, v) <- reduce (u, v)+ reportSDoc "tc.conv.antiUnify" 30 $ vcat+ [ "antiUnify"+ , "a =" <+> prettyTCM a+ , "u =" <+> prettyTCM u+ , "v =" <+> prettyTCM v+ ]+ case (u, v) of+ (Pi ua ub, Pi va vb) -> do+ wa0 <- antiUnifyType pid (unDom ua) (unDom va)+ let wa = wa0 <$ ua+ wb <- addContext wa $ antiUnifyType pid (absBody ub) (absBody vb)+ return $ Pi wa (mkAbs (absName ub) wb)+ (Lam i u, Lam _ v) ->+ reduce (unEl a) >>= \case+ Pi a b -> Lam i . (mkAbs (absName u)) <$> addContext a (antiUnify pid (absBody b) (absBody u) (absBody v))+ _ -> fallback+ (Var i us, Var j vs) | i == j -> maybeGiveUp $ do+ a <- typeOfBV i+ antiUnifyElims pid a (var i) us vs+ -- Andreas, 2017-07-27:+ -- It seems that nothing guarantees here that the constructors are fully+ -- applied!? Thus, @a@ could be a function type and we need the robust+ -- @getConType@ here.+ -- (Note that @patternViolation@ swallows exceptions coming from @getConType@+ -- thus, we would not see clearly if we used @getFullyAppliedConType@ instead.)+ (Con x ci us, Con y _ vs) | x == y -> maybeGiveUp $ do+ a <- maybe abort (return . snd) =<< getConType x a+ antiUnifyElims pid a (Con x ci []) us vs+ (Def f [], Def g []) | f == g -> return (Def f [])+ (Def f us, Def g vs) | f == g, length us == length vs -> maybeGiveUp $ do+ a <- computeElimHeadType f us vs+ antiUnifyElims pid a (Def f []) us vs+ _ -> fallback+ where+ maybeGiveUp = catchPatternErr $ \ _ -> fallback+ abort = patternViolation neverUnblock -- caught by maybeGiveUp+ fallback = blockTermOnProblem a u pid++antiUnifyArgs :: ProblemId -> Dom Type -> Arg Term -> Arg Term -> TCM (Arg Term)+antiUnifyArgs pid dom u v+ | not (sameModality (getModality u) (getModality v))+ = patternViolation neverUnblock+ | otherwise = applyModalityToContext u $+ ifM (isIrrelevantOrPropM dom)+ {-then-} (return u)+ {-else-} ((<$ u) <$> antiUnify pid (unDom dom) (unArg u) (unArg v))++antiUnifyType :: ProblemId -> Type -> Type -> TCM Type+antiUnifyType pid (El s a) (El _ b) = workOnTypes $ El s <$> antiUnify pid (sort s) a b++antiUnifyElims :: ProblemId -> Type -> Term -> Elims -> Elims -> TCM Term+antiUnifyElims pid a self [] [] = return self+antiUnifyElims pid a self (Proj o f : es1) (Proj _ g : es2) | f == g = do+ -- Andreas, 2026-09-05, issue #8532, projectTyped expects reduced type @a@.+ -- The reduce was already absent in the original feature commit a45f5ce (Agda 2.5.3).+ -- The bug was dormant for almost a decade.+ a <- reduce a+ res <- projectTyped self a o f+ case res of+ Just (_, self, a) -> antiUnifyElims pid a self es1 es2+ Nothing -> patternViolation neverUnblock -- can fail for projection like+antiUnifyElims pid a self (Apply u : es1) (Apply v : es2) = do+ reduce (unEl a) >>= \case+ Pi a b -> do+ w <- antiUnifyArgs pid a u v+ antiUnifyElims pid (b `lazyAbsApp` unArg w) (apply self [w]) es1 es2+ _ -> patternViolation neverUnblock+antiUnifyElims _ _ _ _ _ = patternViolation neverUnblock -- trigger maybeGiveUp in antiUnify++-- | @compareElims pols a v els1 els2@ performs type-directed equality on eliminator spines.+-- @t@ is the type of the head @v@.+--+-- Note: since TCM is lazy in return values from @(>>=)@, it is+-- important that compareElims in non-tail position be called as @() <-+-- compareElims pols a v e1 e2@ so that any internal invariants upheld+-- by returning @__IMPOSSIBLE__@ actually get checked.+compareElims :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()+compareElims !pols0 !fors0 !a !v !els01 !els02 =+ verboseBracket "tc.conv.elim" 20 "compareElims" $+ (catchConstraint (ElimCmp pols0 fors0 a v els01 els02) :: TCM () -> TCM ()) $ do+ let v1 = applyE v els01+ v2 = applyE v els02++ -- Andreas, issue #8126, hack: use 'AsTypes' to suppress type in error message.+ failure = failConversion CmpEq v1 v2 (AsTermsOf a)+ -- Andreas, 2013-03-15 since one of the spines is empty, @a@+ -- is the correct type here.+ unless (null els01) $ do+ reportSDoc "tc.conv.elim" 25 $ "compareElims" $$ do+ nest 2 $ vcat+ [ "a =" <+> prettyTCM a+ , "pols0 (truncated to 10) =" <+> hsep (map prettyTCM $ take 10 pols0)+ , "fors0 (truncated to 10) =" <+> hsep (map prettyTCM $ take 10 fors0)+ , "v =" <+> prettyTCM v+ , "els01 =" <+> prettyTCM els01+ , "els02 =" <+> prettyTCM els02+ ]+ case (els01, els02) of+ ([] , [] ) -> return ()+ ([] , Proj{}:_ ) -> failure -- not impossible, see issue 821+ (Proj{} : _, [] ) -> failure -- could be x.p =?= x for projection p+ ([] , Apply{} : _) -> failure -- not impossible, see issue 878+ (Apply{} : _, [] ) -> failure+ ([] , IApply{} : _) -> failure+ (IApply{} : _, [] ) -> failure+ (Apply{} : _, Proj{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True -- NB: popped up in issue 889+ (Proj{} : _, Apply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True -- but should be impossible (but again in issue 1467)+ (IApply{} : _, Proj{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True+ (Proj{} : _, IApply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True++ -- Mismatched IApply/Apply is possible: Cubical.Foundations.Prelude.compPathP, Issue3601+ -- Either keep comparing as functions or as paths depending on the type of the head.+ (e@(IApply _ _ r1) : els1, els2@(Apply r2:els2')) -> do+ a <- abortIfBlocked a+ va <- pathView a+ case va of+ OType t@(El _ Pi{}) -> compareElims pols0 fors0 t v (Apply (defaultArg r1):els1) els2+ PathType s path l bA x y -> do+ let (pol, pols) = nextPolarity pols0+ b <- primIntervalType+ compareWithPol pol (flip compareTerm b) r1 (unArg r2)+ codom <- el' (pure . unArg $ l) ((pure . unArg $ bA) <@> pure r1)+ compareElims pols [] codom (applyE v [e]) els1 els2'+ _ -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True++ (els1@(Apply r1:els1'), e@(IApply _ _ r2):els2) -> do+ a <- abortIfBlocked a+ va <- pathView a+ case va of+ OType t@(El _ Pi{}) -> compareElims pols0 fors0 t v els1 (Apply (defaultArg r2):els2)+ PathType s path l bA x y -> do+ let (pol, pols) = nextPolarity pols0+ b <- primIntervalType+ compareWithPol pol (flip compareTerm b) (unArg r1) r2+ codom <- el' (pure . unArg $ l) ((pure . unArg $ bA) <@> pure r2)+ compareElims pols [] codom (applyE v [e]) els1' els2+ _ -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True++ (e@(IApply x1 y1 r1) : els1, IApply x2 y2 r2 : els2) -> do+ reportSDoc "tc.conv.elim" 25 $ "compareElims IApply"+ -- Andrea: copying stuff from the Apply case..+ let (pol, pols) = nextPolarity pols0+ a <- abortIfBlocked a+ va <- pathView a+ reportSDoc "tc.conv.elim.iapply" 60 $ "compareElims IApply" $$ do+ nest 2 $ "va =" <+> text (show (isPathType va))+ case va of+ PathType s path l bA x y -> do+ b <- primIntervalType+ compareWithPol pol (flip compareTerm b)+ r1 r2+ -- TODO: compare (x1,x2) and (y1,y2) ?+ let r = r1 -- TODO Andrea: do blocking+ codom <- el' (pure . unArg $ l) ((pure . unArg $ bA) <@> pure r)+ compareElims pols [] codom -- Path non-dependent (codom `lazyAbsApp` unArg arg)+ (applyE v [e]) els1 els2+ -- We allow for functions (i : I) -> ... to also be heads of a IApply,+ -- because @etaContract@ can produce such terms+ OType t@(El _ Pi{}) -> compareElims pols0 fors0 t v (Apply (defaultArg r1) : els1) (Apply (defaultArg r2) : els2)++ OType t -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True++ -- András 2026-03-26: this is one of the hottest pieces of code in Agda, so it makes a lot of+ -- sense to do focused core optimization on it. We add an 'expand' to every branching to make+ -- sure that GHC doesn't compile them to closures.+ (Apply arg1 : els1, Apply arg2 : els2) ->+ (verboseBracket "tc.conv.elim" 20 "compare Apply" :: TCM () -> TCM ()) $ do+ reportSDoc "tc.conv.elim" 10 $ nest 2 $ vcat+ [ "a =" <+> prettyTCM a+ , "v =" <+> prettyTCM v+ , "arg1 =" <+> prettyTCM arg1+ , "arg2 =" <+> prettyTCM arg2+ ]+ reportSDoc "tc.conv.elim" 50 $ nest 2 $ vcat+ [ "raw:"+ , "a =" <+> pretty a+ , "v =" <+> pretty v+ , "arg1 =" <+> pretty arg1+ , "arg2 =" <+> pretty arg2+ ]+ let (pol, pols) = nextPolarity pols0+ (for, fors) = nextIsForced fors0+ a <- abortIfBlocked a+ reportSLn "tc.conv.elim" 40 $ "type is not blocked"+ case unEl a of+ (Pi dom@(unDom -> b) codom) -> do+ let info = dom ^. dInfo+ reportSLn "tc.conv.elim" 40 $ "type is a function type"++ dependent <- do+ -- András, 2026-04-03: skipping the freeInIgnoringSorts+ -- is faster, but it causes "cubical" to loop when lossy unification+ -- is on! TODO: figure out.+ let freeInCoDom (Abs _ c) = 0 `freeInIgnoringSorts` c -- True+ freeInCoDom _ = False++ expand \ret -> if freeInCoDom codom then ret do+ mlvl <- getBuiltin' BuiltinLevel+ -- Level-polymorphism (x : Level) -> ... does not count as dependency here+ -- NB: we could drop the free variable test and still be sound.+ -- It is a trade-off between the administrative effort of+ -- creating a blocking and traversing a term for free variables.+ -- Apparently, it is believed that checking free vars is cheaper.+ -- Andreas, 2013-05-15+ pure $! Just (unEl b) /= mlvl+ else ret do+ pure False++ expand \ret -> if dependent then ret do++ -- compare arg1 and arg2+ pid <- addConversionContext (\z -> ConvApply v codom (Arg info z) els1 els2) $+ newProblemDontWake_ $ applyModalityToContext info $+ expand \ret -> if isForced for then ret $+ reportSLn "tc.conv.elim" 40 $ "argument is forced"+ else ret $ expand \ret -> if isIrrelevant info then ret do+ reportSLn "tc.conv.elim" 40 $ "argument is irrelevant"+ compareIrrelevant b (unArg arg1) (unArg arg2)+ else ret do+ reportSLn "tc.conv.elim" 40 $ "argument has polarity " ++ show pol+ compareWithPol pol (flip compareTerm b) (unArg arg1) (unArg arg2)++ -- if comparison got stuck, block arg+ solved <- isProblemSolved'' pid+ reportSLn "tc.conv.elim" 40 $ "solved = " ++ show solved+ arg <- expand \ret -> if not solved then ret do+ applyModalityToContext info $ do+ reportSDoc "tc.conv.elims" 50 $ vcat $+ [ "Trying antiUnify:"+ , nest 2 $ "b =" <+> prettyTCM b+ , nest 2 $ "arg1 =" <+> prettyTCM arg1+ , nest 2 $ "arg2 =" <+> prettyTCM arg2+ ]+ arg <- (arg1 $>) <$> antiUnify pid b (unArg arg1) (unArg arg2)+ reportSDoc "tc.conv.elims" 50 $ hang "Anti-unification:" 2 (prettyTCM arg)+ reportSDoc "tc.conv.elims" 70 $ nest 2 $ "raw:" <+> pretty arg+ return arg+ else ret $ return arg1+ -- continue, possibly with blocked instantiation+ () <- compareElims pols fors (codom `lazyAbsApp` unArg arg) (apply v [arg]) els1 els2++ expand \ret -> if not solved then ret do+ -- any left over constraints of arg are associated to the comparison+ reportSLn "tc.conv.elim" 40 $ "stealing constraints from problem " ++ show pid+ stealConstraints pid+ {- Stealing solves this issue:++ Does not create enough blocked tc-problems,+ see test/fail/DontPrune.+ (There are remaining problems which do not show up as yellow.)+ Need to find a way to associate pid also to result of compareElims.+ -}+ else ret $ pure ()++ else ret do+ -- compare arg1 and arg2+ addConversionContext (\z -> ConvApply v codom (Arg info z) els1 els2) $+ applyModalityToContext info $+ expand \ret -> if isForced for then ret $+ reportSLn "tc.conv.elim" 40 $ "argument is forced"+ else ret $ expand \ret -> if isIrrelevant info then ret do+ reportSLn "tc.conv.elim" 40 $ "argument is irrelevant"+ compareIrrelevant b (unArg arg1) (unArg arg2)+ else ret do+ reportSLn "tc.conv.elim" 40 $ "argument has polarity " ++ show pol+ compareWithPol pol (flip compareTerm b) (unArg arg1) (unArg arg2)++ -- continue+ compareElims pols fors (codom `lazyAbsApp` unArg arg1) (apply v [arg1]) els1 els2++ a -> do+ reportSDoc "impossible" 10 $+ "unexpected type when comparing apply eliminations " <+> prettyTCM a+ reportSDoc "impossible" 50 $ "raw type:" <+> pretty a+ patternViolation (unblockOnAnyMetaIn a)+ -- Andreas, 2013-10-22+ -- in case of disabled reductions (due to failing termination check)+ -- we might get stuck, so do not crash, but fail gently.+ -- __IMPOSSIBLE__++ -- case: f == f' are projections+ (Proj o f : els1, Proj _ f' : els2)+ | f /= f' -> do+ -- Andreas, 2026-09-05, while working on #8532: projectTyped expects reduced type.+ a <- reduce a+ -- Andreas, 2025-10-06, issue #8126+ -- If we are dealing with generalizable variables rather than projections,+ -- do not throw a MismatchedProjectionsError, but rather a generic f != f' error.+ reportSDoc "tc.error.mismatchedProjections" 30 $ "type:" <+> prettyTCM a+ reportSDoc "tc.error.mismatchedProjections" 40 $ "type:" <+> pretty a+ reportSDoc "tc.error.mismatchedProjections" 30 $ "f = " <+> prettyTCM f+ reportSDoc "tc.error.mismatchedProjections" 40 $ "f = " <+> pretty f+ t1 <- projectTyped v a o f+ t2 <- projectTyped v a o f'+ case (,) <$> t1 <*> t2 of+ Just ((_, lhs, t1), (_, rhs, t2)) -> mismatchedProjections t1 lhs els1 t2 rhs els2+ Nothing -> typeError $ MismatchedProjectionsError f f'+ | otherwise -> do+ a <- abortIfBlocked a+ res <- projectTyped v a o f -- fails only if f is proj.like but parameters cannot be retrieved+ case res of+ Just (_, u, t) -> do+ -- Andreas, 2015-07-01:+ -- The arguments following the principal argument of a projection+ -- are invariant. (At least as long as we have no explicit polarity+ -- annotations.)+ compareElims [] [] t u els1 els2+ Nothing -> do+ reportSDoc "tc.conv.elims" 30 $ sep+ [ text $ "projection " ++ prettyShow f+ , text "applied to value " <+> prettyTCM v+ , text "of unexpected type " <+> prettyTCM a+ ]+ patternViolation (unblockOnAnyMetaIn a)++{-# NOINLINE compareIrrelevant #-}+-- | "Compare" two terms in irrelevant position. This always succeeds.+-- However, we can dig for solutions of irrelevant metas in the+-- terms we compare.+-- (Certainly not the systematic solution, that'd be proof search...)+compareIrrelevant :: Type -> Term -> Term -> TCM ()+{- 2012-04-02 DontCare no longer present+compareIrrelevant t (DontCare v) w = compareIrrelevant t v w+compareIrrelevant t v (DontCare w) = compareIrrelevant t v w+-}+compareIrrelevant !t !v0 !w0 = do+ let v = stripDontCare v0+ w = stripDontCare w0+ reportSDoc "tc.conv.irr" 20 $ vcat+ [ "compareIrrelevant"+ , nest 2 $ "v =" <+> prettyTCM v+ , nest 2 $ "w =" <+> prettyTCM w+ ]+ reportSDoc "tc.conv.irr" 50 $ vcat+ [ nest 2 $ "v =" <+> pretty v+ , nest 2 $ "w =" <+> pretty w+ ]+ whenProfile Profile.Conversion $ tick "compare irrelevant"+ try v w $ try w v $ return ()+ where+ try (MetaV x es) w fallback = do+ mi <- lookupMetaInstantiation x+ mm <- lookupMetaModality x+ let rel = getRelevance mm+ inst = case mi of+ InstV{} -> True+ _ -> False+ reportSDoc "tc.conv.irr" 20 $ vcat+ [ nest 2 $ text $ "rel = " ++ show rel+ , nest 2 $ "inst =" <+> pretty inst+ ]+ if not (isIrrelevant rel) || inst+ then fallback+ -- Andreas, 2016-08-08, issue #2131:+ -- Mining for solutions for irrelevant metas is not definite.+ -- Thus, in case of error, leave meta unsolved.+ else assignE DirEq x es w (AsTermsOf t) (compareIrrelevant t) `catchError` \ _ -> fallback+ -- the value of irrelevant or unused meta does not matter+ try v w fallback = fallback++{-# INLINE compareWithPol #-}+compareWithPol :: Polarity -> (Comparison -> a -> a -> TCM ()) -> a -> a -> TCM ()+compareWithPol Invariant cmp x y = cmp CmpEq x y+compareWithPol Covariant cmp x y = cmp CmpLeq x y+compareWithPol Contravariant cmp x y = cmp CmpLeq y x+compareWithPol Nonvariant cmp x y = return ()++polFromCmp :: Comparison -> Polarity+polFromCmp CmpLeq = Covariant+polFromCmp CmpEq = Invariant++-- | Type-directed equality on argument lists+--+compareArgs :: [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> TCM ()+compareArgs pol for a v args1 args2 =+ compareElims pol for a v (map' Apply args1) (map' Apply args2)++---------------------------------------------------------------------------+-- * Types+---------------------------------------------------------------------------++-- | Equality on Types+compareType :: Comparison -> Type -> Type -> TCM ()+compareType cmp ty1@(El s1 a1) ty2@(El s2 a2) =+ workOnTypes $+ verboseBracket "tc.conv.type" 20 "compareType" $ do+ reportSDoc "tc.conv.type" 50 $ vcat+ [ "compareType" <+> sep [ prettyTCM ty1 <+> prettyTCM cmp+ , prettyTCM ty2 ]+ , hsep [ " sorts:", prettyTCM s1, " and ", prettyTCM s2 ]+ ]+ compareAs cmp AsTypes a1 a2++leqType :: Type -> Type -> TCM ()+leqType = compareType CmpLeq++-- | @coerce v a b@ coerces @v : a@ to type @b@, returning a @v' : b@+-- with maybe extra hidden applications or hidden abstractions.+--+-- In principle, this function can host coercive subtyping, but+-- currently it only tries to fix problems with hidden function types.+--+coerce :: Comparison -> Term -> Type -> Type -> TCM Term+coerce !cmp !v !t1 !t2 = cutConversionErrors $ blockTerm t2 $ do+ verboseS "tc.conv.coerce" 10 $ do+ (a1,a2) <- reify (t1,t2)+ let dbglvl = 30+ reportSDoc "tc.conv.coerce" dbglvl $+ "coerce" <+> vcat+ [ "term v =" <+> prettyTCM v+ , "from type t1 =" <+> prettyTCM a1+ , "to type t2 =" <+> prettyTCM a2+ , "comparison =" <+> prettyTCM cmp+ ]+ reportSDoc "tc.conv.coerce" 70 $+ "coerce" <+> vcat+ [ "term v =" <+> pretty v+ , "from type t1 =" <+> pretty t1+ , "to type t2 =" <+> pretty t2+ , "comparison =" <+> pretty cmp+ ]+ -- v <$ do workOnTypes $ leqType t1 t2+ -- take off hidden/instance domains from t1 and t2+ TelV tel1 b1 <- telViewUpTo' (-1) notVisible t1+ TelV tel2 b2 <- telViewUpTo' (-1) notVisible t2+ let n = size tel1 - size tel2+ -- the crude solution would be+ -- v' = λ {tel2} → v {tel1}+ -- however, that may introduce unneccessary many function types+ -- If n > 0 and b2 is not blocked, it is safe to+ -- insert n many hidden args+ if n <= 0 then fallback else do+ ifBlocked b2 (\ _ _ -> fallback) $ \ _ _ -> do+ (args, t1') <- implicitArgs n notVisible t1+ let v' = v `apply` args+ v' <$ coerceSize cmp v' t1' t2+ where+ fallback = v <$ coerceSize cmp v t1 t2++-- | Account for situations like @k : (Size< j) <= (Size< k + 1)@+--+-- Actually, the semantics is+-- @(Size<= k) ∩ (Size< j) ⊆ rhs@+-- which gives a disjunctive constraint. Mmmh, looks like stuff+-- TODO.+--+-- For now, we do a cheap heuristics.+--+coerceSize :: Comparison -> Term -> Type -> Type -> TCM ()+coerceSize !cmp !v !t1 !t2 = verboseBracket "tc.conv.size.coerce" 45 "coerceSize" $+ workOnTypes $ do+ reportSDoc "tc.conv.size.coerce" 70 $+ "coerceSize" <+> vcat+ [ "term v =" <+> pretty v+ , "from type t1 =" <+> pretty t1+ , "to type t2 =" <+> pretty t2+ ]+ let fallback = compareType cmp t1 t2+ done = caseMaybeM (isSizeType =<< reduce t1) fallback $ \ _ -> return ()+ -- Andreas, 2015-07-22, Issue 1615:+ -- If t1 is a meta and t2 a type like Size< v2, we need to make sure we do not miss+ -- the constraint v < v2!+ caseMaybeM (isSizeType =<< reduce t2) fallback $ \ b2 -> do+ -- Andreas, 2017-01-20, issue #2329:+ -- If v is not a size suitable for the solver, like a neutral term,+ -- we can only rely on the type.+ mv <- sizeMaxView v+ if any (\case{ DOtherSize{} -> True; _ -> False }) mv then fallback else do+ -- Andreas, 2015-02-11 do not instantiate metas here (triggers issue 1203).+ unlessM (tryConversion $ dontAssignMetas $ compareType cmp t1 t2) $ do+ -- A (most probably weaker) alternative is to just check syn.eq.+ -- ifM (snd <$> checkSyntacticEquality t1 t2) (return v) $ {- else -} do+ reportSDoc "tc.conv.size.coerce" 20 $ "coercing to a size type"+ case b2 of+ -- @t2 = Size@. We are done!+ BoundedNo -> done+ -- @t2 = Size< v2@+ BoundedLt v2 -> do+ sv2 <- sizeView v2+ case sv2 of+ SizeInf -> done+ OtherSize{} -> do+ -- Andreas, 2014-06-16:+ -- Issue 1203: For now, just treat v < v2 as suc v <= v2+ -- TODO: Need proper < comparison+ vinc <- sizeSuc 1 v+ compareSizes CmpLeq vinc v2+ done+ -- @v2 = a2 + 1@: In this case, we can try @v <= a2@+ SizeSuc a2 -> do+ compareSizes CmpLeq v a2+ done -- to pass Issue 1136++---------------------------------------------------------------------------+-- * Sorts and levels+---------------------------------------------------------------------------++compareLevel :: Comparison -> Level -> Level -> TCM ()+compareLevel CmpLeq u v = leqLevel u v+compareLevel CmpEq u v = equalLevel u v++compareSort :: Comparison -> Sort -> Sort -> TCM ()+compareSort CmpEq = equalSort+compareSort CmpLeq = leqSort++-- | Check that the first sort is less or equal to the second.+--+-- We can put @SizeUniv@ below @Inf@, but otherwise, it is+-- unrelated to the other universes.+--+leqSort :: Sort -> Sort -> TCM ()+leqSort s1 s2 = do+ reportSDoc "tc.conv.sort" 30 $+ sep [ "leqSort"+ , nest 2 $ fsep [ prettyTCM s1 <+> "=<"+ , prettyTCM s2 ]+ ]+ reportSDoc "tc.conv.sort" 60 $+ sep [ "leqSort"+ , nest 2 $ fsep [ pretty s1 <+> "=<"+ , pretty s2 ]+ ]+ whenProfile Profile.Conversion $ tick "compare sorts"++ SynEq.checkSyntacticEquality s1 s2 (\_ _ -> return ()) $ \s1 s2 -> do++ s1b <- reduceB s1+ s2b <- reduceB s2++ let (s1,s2) = (ignoreBlocking s1b , ignoreBlocking s2b)+ blocker = unblockOnEither (getBlocker s1b) (getBlocker s2b)+ postpone = patternViolation blocker++ let postponeIfBlocked = catchPatternErr $ \blocker -> do+ if | blocker == neverUnblock -> typeError $ NotLeqSort s1 s2+ | otherwise -> do+ reportSDoc "tc.conv.sort" 30 $ vcat+ [ "Postponing constraint"+ , nest 2 $ fsep [ prettyTCM s1 <+> "=<"+ , prettyTCM s2 ]+ ]+ reportSDoc "tc.conv.sort" 60 $ vcat+ [ "Postponing constraint"+ , nest 2 $ fsep [ pretty s1 <+> "=<"+ , pretty s2 ]+ ]+ blocker <- updateBlocker blocker+ addConstraint blocker $ SortCmp CmpLeq s1 s2++ propEnabled <- isPropEnabled+ typeInTypeEnabled <- typeInType+ omegaInOmegaEnabled <- optOmegaInOmega <$> pragmaOptions+ let infInInf = typeInTypeEnabled || omegaInOmegaEnabled++ let fvsRHS = (`VarSet.member` freeVarSet s2)+ badRigid <- s1 `rigidVarsNotContainedIn` fvsRHS++ postponeIfBlocked $ case (s1, s2) of+ -- Andreas, 2018-09-03: crash on dummy sort+ (DummyS s, _) -> impossibleSort s+ (_, DummyS s) -> impossibleSort s++ -- The most basic rule: @Set l =< Set l'@ iff @l =< l'@+ -- Likewise for @Prop@+ -- Likewise for @SSet@+ -- @Prop l@ is below @Set l@+ -- @Set l@ is below @SSet l@+ -- @Prop l@ is below @SSet l@+ (Univ u a, Univ u' b) -> if u <= u' then leqLevel a b else no++ -- @Setωᵢ@ is above all small sorts+ (Inf u m , Inf u' n) -> answer $ u <= u' && (m <= n || infInInf)+ (Univ u _, Inf u' _) -> answer $ u <= u'+ (Inf u _, Univ u' _) -> answer $ u == u' && typeInTypeEnabled++ -- @LockUniv@, @LevelUniv@, @IntervalUniv@, @SizeUniv@, and @Prop0@ are bottom sorts.+ -- So is @Set0@ if @Prop@ is not enabled.+ (_ , LockUniv) -> equalSort s1 s2+ (_ , LevelUniv) -> equalSort s1 s2+ (_ , IntervalUniv) -> equalSort s1 s2+ (_ , SizeUniv) -> equalSort s1 s2+ (_ , Prop (ClosedLevel 0)) -> equalSort s1 s2+ (_ , Type (ClosedLevel 0))+ | not propEnabled -> equalSort s1 s2++ -- @SizeUniv@, @LockUniv@ and @LevelUniv@ are unrelated to any @Set l@ or @Prop l@+ (SizeUniv, Univ{} ) -> no+ (SizeUniv , Inf{} ) -> no+ (LockUniv, Univ{} ) -> no+ (LockUniv , Inf{} ) -> no+ (LevelUniv, Univ{} ) -> no+ (LevelUniv , Inf{} ) -> no++ -- @IntervalUniv@ is below @SSet l@, but not @Set l@ or @Prop l@+ (IntervalUniv, Type{}) -> no+ (IntervalUniv, Prop{}) -> no+ (IntervalUniv , Inf u _) -> answer $ univFibrancy u == IsStrict+ (IntervalUniv , SSet b) -> leqLevel (ClosedLevel 0) b++ -- If the first sort is a small sort that rigidly depends on a+ -- variable and the second sort does not mention this variable,+ -- the second sort must be at least @Setω@.+ (_ , _ ) | Right (SmallSort f) <- sizeOfSort s1 , badRigid -> leqSort (Inf f 0) s2++ -- PiSort, FunSort, UnivSort and MetaS might reduce once we instantiate+ -- more metas, so we postpone.+ (PiSort{}, _ ) -> postpone+ (_ , PiSort{}) -> postpone+ (FunSort{}, _ ) -> postpone+ (_ , FunSort{}) -> postpone+ (UnivSort{}, _ ) -> postpone+ (_ , UnivSort{}) -> postpone+ (MetaS{} , _ ) -> postpone+ (_ , MetaS{} ) -> postpone++ -- DefS are postulated sorts, so they do not reduce.+ (DefS{} , _ ) -> no+ (_ , DefS{}) -> no++ where+ no = patternViolation neverUnblock+ yes = return ()+ answer = \case+ True -> yes+ False -> no+ impossibleSort s = do+ reportS "impossible" 10+ [ "leqSort: found dummy sort with description:"+ , s+ ]+ __IMPOSSIBLE__++leqLevel :: Level -> Level -> TCM ()+leqLevel a b = catchConstraint (LevelCmp CmpLeq a b) $ do+ reportSDoc "tc.conv.level" 30 $+ "compareLevel" <+>+ sep [ prettyTCM a <+> "=<"+ , prettyTCM b ]+ whenProfile Profile.Conversion $ tick "compare levels"++ (a, b) <- normalise (a, b)+ SynEq.checkSyntacticEquality' a b+ (\_ _ ->+ reportSDoc "tc.conv.level" 60+ "checkSyntacticEquality returns True") $ \a b -> do+ reportSDoc "tc.conv.level" 60+ "checkSyntacticEquality returns False"++ let notok = unlessM typeInType $ typeError $ NotLeqSort (Type a) (Type b)+ postpone = patternViolation (unblockOnAnyMetaIn (a, b))++ wrap m = m `catchError` \case+ TypeError{} -> notok+ err -> throwError err++ cumulativity <- optCumulativity <$> pragmaOptions+ areWeComputingOverlap <- viewTC eConflComputingOverlap+ reportSDoc "tc.conv.level" 40 $+ "compareLevelView" <+>+ sep [ prettyList_ $ fmap (pretty . unSingleLevel) $ levelMaxView a+ , "=<"+ , prettyList_ $ fmap (pretty . unSingleLevel) $ levelMaxView b+ ]++ -- Extra reduce on level atoms, but should be cheap since they are already reduced.+ aB <- mapM reduceB a+ bB <- mapM reduceB b++ wrap $ case (levelMaxView aB, levelMaxView bB) of++ -- 0 ≤ any+ (SingleClosed 0 :| [] , _) -> return ()++ -- any ≤ 0+ (as , SingleClosed 0 :| []) ->+ forM_ as $ \ a' -> equalLevel (unSingleLevel $ fmap ignoreBlocking a') (ClosedLevel 0)++ -- closed ≤ closed+ (SingleClosed m :| [], SingleClosed n :| []) -> unless (m <= n) notok++ -- closed ≤ b+ (SingleClosed m :| [] , _)+ | m <= levelLowerBound b -> return ()++ -- as ≤ neutral/closed+ (as, bs)+ | all neutralOrClosed bs , levelLowerBound a > levelLowerBound b -> notok++ -- ⊔ as ≤ single+ (as@(_ :| _ : _), b :| []) ->+ forM_ as $ \ a' -> leqLevel (unSingleLevel $ ignoreBlocking <$> a')+ (unSingleLevel $ ignoreBlocking <$> b)++ -- reduce constants+ (as, bs)+ | let minN = min (fst $ levelPlusView a) (fst $ levelPlusView b)+ a' = fromMaybe __IMPOSSIBLE__ $ subLevel minN a+ b' = fromMaybe __IMPOSSIBLE__ $ subLevel minN b+ , minN > 0 -> leqLevel a' b'++ -- remove subsumed+ -- Andreas, 2014-04-07: This is ok if we do not go back to equalLevel+ (as, bs)+ | (subsumed@(_:_) , as') <- List1.partition (isSubsumed . fmap ignoreBlocking) as+ -> leqLevel (unSingleLevels $ (fmap . fmap) ignoreBlocking as') b+ where+ isSubsumed a = any (`subsumes` a) $ (fmap . fmap) ignoreBlocking bs++ subsumes :: SingleLevel -> SingleLevel -> Bool+ subsumes (SingleClosed m) (SingleClosed n) = m >= n+ subsumes (SinglePlus (Plus m _)) (SingleClosed n) = m >= n+ subsumes (SinglePlus (Plus m a)) (SinglePlus (Plus n b)) = a == b && m >= n+ subsumes _ _ = False++ -- as ≤ _l x₁ .. xₙ ⊔ bs+ -- We can solve _l := λ x₁ .. xₙ -> as ⊔ (_l' x₁ .. xₙ)+ -- (where _l' is a new metavariable)+ (as , bs)+ | cumulativity+ , not areWeComputingOverlap+ , Just (mb@(MetaV x es) , bs') <- singleMetaView $ (map' . fmap) ignoreBlocking (List1.toList bs)+ , null bs' || noMetas (Level a , unSingleLevels bs') -> do+ mv <- lookupLocalMeta x+ -- Jesper, 2019-10-13: abort if this is an interaction+ -- meta or a generalizable meta+ abort <- (isJust <$> isInteractionMeta x) `or2M`+ ((== YesGeneralizeVar) <$> isGeneralizableMeta x)+ if | abort -> postpone+ | otherwise -> do+ x' <- case mvJudgement mv of+ IsSort{} -> __IMPOSSIBLE__+ HasType _ cmp t -> do+ TelV tel t' <- telView t+ newMeta Instantiable (mvInfo mv) normalMetaPriority (idP $ size tel) $ HasType () cmp t+ reportSDoc "tc.conv.level" 20 $ fsep+ [ "attempting to solve" , prettyTCM (MetaV x es) , "to the maximum of"+ , prettyTCM (Level a) , "and the fresh meta" , prettyTCM (MetaV x' es)+ ]+ equalLevel (atomicLevel mb) $ levelLub a (atomicLevel $ MetaV x' es)+++ -- Andreas, 2016-09-28: This simplification loses the solution lzero.+ -- Thus, it is invalid.+ -- See test/Succeed/LevelMetaLeqNeutralLevel.agda.+ -- -- [a] ≤ [neutral]+ -- ([a@(Plus n _)], [b@(Plus m NeutralLevel{})])+ -- | m == n -> equalLevel' (Max [a]) (Max [b])+ -- -- Andreas, 2014-04-07: This call to equalLevel is ok even if we removed+ -- -- subsumed terms from the lhs.++ -- anything else+ _ | noMetas (a, b) -> notok+ | otherwise -> postpone+ where+ neutralOrClosed (SingleClosed _) = True+ neutralOrClosed (SinglePlus (Plus _ NotBlocked{})) = True+ neutralOrClosed _ = False++ -- Is there exactly one @MetaV@ in the list of single levels?+ singleMetaView :: [SingleLevel] -> Maybe (Term, [SingleLevel])+ singleMetaView (SinglePlus (Plus 0 l@(MetaV m es)) : ls)+ | all (not . isMetaLevel) ls = Just (l,ls)+ singleMetaView (l : ls)+ | not $ isMetaLevel l = second (l:) <$> singleMetaView ls+ singleMetaView _ = Nothing++ isMetaLevel :: SingleLevel -> Bool+ isMetaLevel (SinglePlus (Plus _ MetaV{})) = True+ isMetaLevel _ = False++equalLevel :: Level -> Level -> TCM ()+equalLevel a b = do+ reportSDoc "tc.conv.level" 50 $ sep [ "equalLevel", nest 2 $ parens $ pretty a, nest 2 $ parens $ pretty b ]+ whenProfile Profile.Conversion $ tick "compare levels"+ lvl <- levelType'+ -- Andreas, 2013-10-31 remove common terms (that don't contain metas!)+ -- THAT's actually UNSOUND when metas are instantiated, because+ -- max a b == max a c does not imply b == c+ -- as <- return $ Set.fromList $ closed0 as+ -- bs <- return $ Set.fromList $ closed0 bs+ -- let cs = Set.filter (not . hasMeta) $ Set.intersection as bs+ -- as <- return $ Set.toList $ as Set.\\ cs+ -- bs <- return $ Set.toList $ bs Set.\\ cs++ reportSDoc "tc.conv.level" 40 $+ sep [ "equalLevel"+ , vcat [ nest 2 $ sep [ prettyTCM a <+> "=="+ , prettyTCM b+ ]+ ]+ ]+ reportSDoc "tc.conv.level" 80 $ sep [ "equalLevel", nest 2 $ parens $ pretty a, nest 2 $ parens $ pretty b ]++ (a, b) <- normalise (a, b)++ -- Jesper, 2014-02-02 remove terms that certainly do not contribute+ -- to the maximum+ let (a', b') = removeSubsumed a b++ SynEq.checkSyntacticEquality' a' b'+ (\_ _ ->+ reportSDoc "tc.conv.level" 60+ "checkSyntacticEquality returns True") $ \a b -> do++ reportSDoc "tc.conv.level" 60 "checkSyntacticEquality returns False"++ let notok = unlessM typeInType notOk+ notOk = failConversion CmpEq (Level a') (Level b') (AsTermsOf lvl)+ postpone = do+ reportSDoc "tc.conv.level" 30 $ hang "postponing:" 2 $ hang (pretty a' <+> "==") 0 (pretty b')+ blocker <- unblockOnAnyMetaIn <$> instantiateFull (a', b')+ patternViolation blocker++ reportSDoc "tc.conv.level" 50 $+ sep [ "equalLevel (w/o subsumed)"+ , vcat [ nest 2 $ sep [ prettyTCM a' <+> "=="+ , prettyTCM b'+ ]+ ]+ ]++ let as = levelMaxView a'+ bs = levelMaxView b'+ reportSDoc "tc.conv.level" 50 $+ sep [ text "equalLevel"+ , vcat [ nest 2 $ sep [ prettyList_ $ fmap (prettyTCM . unSingleLevel) as+ , "=="+ , prettyList_ $ fmap (prettyTCM . unSingleLevel) bs+ ]+ ]+ ]++ reportSDoc "tc.conv.level" 80 $+ sep [ text "equalLevel"+ , vcat [ nest 2 $ sep [ prettyList_ $ fmap (pretty . unSingleLevel) as+ , "=="+ , prettyList_ $ fmap (pretty . unSingleLevel) bs+ ]+ ]+ ]++ -- Extra reduce on level atoms, but should be cheap since they are already reduced.+ as <- (mapM . mapM) reduceB as+ bs <- (mapM . mapM) reduceB bs++ catchConstraint (LevelCmp CmpEq a b) $ case (as, bs) of++ -- closed == closed+ (SingleClosed m :| [], SingleClosed n :| [])+ | m == n -> return ()+ | otherwise -> notok++ -- closed == neutral+ (SingleClosed m :| [] , bs) | any isNeutral bs -> notok+ (as , SingleClosed n :| []) | any isNeutral as -> notok++ -- closed == b+ (SingleClosed m :| [] , _) | m < levelLowerBound b -> notok+ (_ , SingleClosed n :| []) | n < levelLowerBound a -> notok++ -- 0 == a ⊔ b+ (SingleClosed 0 :| [] , bs@(_ :| _ : _)) ->+ forM_ bs $ \ b' -> equalLevel (ClosedLevel 0) (unSingleLevel $ ignoreBlocking <$> b')+ (as@(_ :| _ : _) , SingleClosed 0 :| []) ->+ forM_ as $ \ a' -> equalLevel (unSingleLevel $ ignoreBlocking <$> a') (ClosedLevel 0)++ -- meta == any+ (SinglePlus (Plus k a) :| [] , SinglePlus (Plus l b) :| [])+ -- there is only a potential choice when k == l+ | MetaV x as' <- ignoreBlocking a+ , MetaV y bs' <- ignoreBlocking b+ , k == l -> do+ compareMetas CmpEq (AsTermsOf lvl) x as' y bs'+ (SinglePlus (Plus k a) :| [] , _)+ | MetaV x as' <- ignoreBlocking a+ , Just b' <- subLevel k b -> meta x as' b'+ (_ , SinglePlus (Plus l b) :| [])+ | MetaV y bs' <- ignoreBlocking b+ , Just a' <- subLevel l a -> meta y bs' a'++ -- a' ⊔ b == b+ _ | Just a' <- levelMaxDiff a b+ , b /= ClosedLevel 0 -> leqLevel a' b++ -- a == b' ⊔ a+ _ | Just b' <- levelMaxDiff b a+ , a /= ClosedLevel 0 -> leqLevel b' a++ -- neutral/closed == neutral/closed+ (as , bs)+ | all isNeutralOrClosed (as <> bs)+ -- Andreas, 2013-10-31: There could be metas in neutral levels (see Issue 930).+ -- Should not we postpone there as well? Yes!+ , not (any hasMeta (as <> bs))+ , length as == length bs -> do+ reportSLn "tc.conv.level" 60 $ "equalLevel: all are neutral or closed"+ List1.zipWithM_ ((===) `on` levelTm . unSingleLevel . fmap ignoreBlocking) as bs++ -- more cases?+ _ | noMetas (a , b) -> notok+ | otherwise -> postpone++ where+ a === b = unlessM typeInType $ do+ lvl <- levelType'+ equalAtom (AsTermsOf lvl) a b++ -- perform assignment (MetaV x as) := b+ meta x as b = do+ reportSLn "tc.meta.level" 30 $ "Assigning meta level"+ reportSDoc "tc.meta.level" 50 $ "meta" <+> sep [prettyList $ map' pretty as, pretty b]+ lvl <- levelType'+ assignE DirEq x as (levelTm b) (AsTermsOf lvl) (===) -- fallback: check equality as atoms++ isNeutral (SinglePlus (Plus _ NotBlocked{})) = True+ isNeutral _ = False++ isNeutralOrClosed (SingleClosed _) = True+ isNeutralOrClosed (SinglePlus (Plus _ NotBlocked{})) = True+ isNeutralOrClosed _ = False++ hasMeta (SinglePlus (Plus _ Blocked{})) = True+ hasMeta (SinglePlus (Plus _ a)) = isJust $ firstMeta $ ignoreBlocking a+ hasMeta (SingleClosed _) = False++ removeSubsumed a b =+ let as = List1.toList $ levelMaxView a+ bs = List1.toList $ levelMaxView b+ a' = unSingleLevels $ filter (not . (`isStrictlySubsumedBy` bs)) as+ b' = unSingleLevels $ filter (not . (`isStrictlySubsumedBy` as)) bs+ in (a',b')++ x `isStrictlySubsumedBy` ys = any (`strictlySubsumes` x) ys++ SingleClosed m `strictlySubsumes` SingleClosed n = m > n+ SinglePlus (Plus m a) `strictlySubsumes` SingleClosed n = m > n+ SinglePlus (Plus m a) `strictlySubsumes` SinglePlus (Plus n b) = a == b && m > n+ _ `strictlySubsumes` _ = False+++-- | Check that the first sort equal to the second.+equalSort :: Sort -> Sort -> TCM ()+equalSort s1 s2 = do+ reportSDoc "tc.conv.sort" 30 $ sep+ [ "equalSort"+ , vcat [ nest 2 $ fsep [ prettyTCM s1 <+> "=="+ , prettyTCM s2 ]+ ]+ ]+ reportSDoc "tc.conv.sort" 60 $ sep+ [ "equalSort"+ , vcat [ nest 2 $ fsep [ pretty s1 <+> "=="+ , pretty s2 ]+ ]+ ]+ whenProfile Profile.Conversion $ tick "compare sorts"++ guardPointerEquality s1 s2 "pointer equality: sorts" $+ SynEq.checkSyntacticEquality s1 s2 (\_ _ -> return ()) $ \s1 s2 -> do++ s1b <- reduceB s1+ s2b <- reduceB s2++ let (s1,s2) = (ignoreBlocking s1b, ignoreBlocking s2b)+ blocker = unblockOnEither (getBlocker s1b) (getBlocker s2b)++ let postponeIfBlocked = catchPatternErr $ \blocker -> do+ if | blocker == neverUnblock -> failConversion CmpEq (Sort s1) (Sort s2) AsTypes+ | otherwise -> do+ reportSDoc "tc.conv.sort" 30 $ vcat+ [ "Postponing constraint"+ , nest 2 $ fsep [ prettyTCM s1 <+> "=="+ , prettyTCM s2 ]+ ]+ -- Andreas, 2023-12-21, recomputing the blocker fixes issue #7034.+ blocker <- updateBlocker blocker+ addConstraint blocker $ SortCmp CmpEq s1 s2++ propEnabled <- isPropEnabled+ typeInTypeEnabled <- typeInType+ omegaInOmegaEnabled <- optOmegaInOmega <$> pragmaOptions+ let infInInf = typeInTypeEnabled || omegaInOmegaEnabled++ postponeIfBlocked $ case (s1, s2) of++ -- Andreas, 2018-09-03: crash on dummy sort+ (DummyS s, _) -> impossibleSort s+ (_, DummyS s) -> impossibleSort s++ -- one side is a meta sort: try to instantiate+ -- In case both sides are meta sorts, instantiate the+ -- bigger (i.e. more recent) one.+ (MetaS x es , MetaS y es') -> compareMetas CmpEq AsTypes x es y es'+ (MetaS x es , _ ) -> meta x es s2+ (_ , MetaS x es ) -> meta x es s1++ -- diagonal cases for rigid sorts+ (Univ u a , Univ u' b ) | u == u' -> equalLevel a b `catchInequalLevel` no+ (SizeUniv , SizeUniv ) -> yes+ (LockUniv , LockUniv ) -> yes+ (LevelUniv , LevelUniv ) -> yes+ (IntervalUniv , IntervalUniv) -> yes+ (Inf u m , Inf u' n ) ->+ if u == u' && (m == n || infInInf) then yes else no++ -- if --type-in-type is enabled, Setωᵢ is equal to any Set ℓ (see #3439)+ (Univ u _ , Inf u' _ ) -> answer $ u == u' && typeInTypeEnabled+ (Inf u _ , Univ u' _ ) -> answer $ u == u' && typeInTypeEnabled++ -- equating @PiSort a b@ to another sort+ (s1 , PiSort a b c d) -> piSortEquals propEnabled s1 a b c d blocker+ (PiSort a b c d , s2) -> piSortEquals propEnabled s2 a b c d blocker++ -- equating @FunSort a b@ to another sort+ (s1 , FunSort a b) -> funSortEquals propEnabled s1 a b blocker+ (FunSort a b , s2) -> funSortEquals propEnabled s2 a b blocker++ -- equating @UnivSort s@ to another sort+ (s1 , UnivSort s2) -> univSortEquals propEnabled infInInf s1 s2 blocker+ (UnivSort s1 , s2 ) -> univSortEquals propEnabled infInInf s2 s1 blocker++ -- postulated sorts can only be equal if they have the same head+ (DefS d es , DefS d' es')+ | d == d' -> do+ pol <- getPolarity' CmpEq d+ a <- computeElimHeadType d es es'+ compareElims pol [] a (Def d []) es es'+ | otherwise -> no++ -- any other combinations of sorts are not equal+ (_ , _ ) -> no++ where+ yes = return ()+ no = patternViolation neverUnblock+ answer = \case+ True -> yes+ False -> no++ -- perform assignment (MetaS x es) := s+ meta :: MetaId -> [Elim' Term] -> Sort -> TCM ()+ meta x es s = do+ reportSLn "tc.meta.sort" 30 $ "Assigning meta sort"+ reportSDoc "tc.meta.sort" 50 $ "meta" <+> sep [pretty x, prettyList $ map' pretty es, pretty s]+ assignE DirEq x es (Sort s) AsTypes __IMPOSSIBLE__++ -- Sorts that contain exactly one other kind of sorts.+ invertibleSort :: Bool -> Univ -> Bool+ invertibleSort propEnabled = \case+ -- @SSetω(n+1)@ is the successor sort of exactly @SSetω(n)@.+ USSet -> True+ -- @Setω(n+1)@ is the successor sort of exactly @Setω(n)@ if we do not have @Prop@.+ UType -> not propEnabled+ -- @Prop@ sorts are not successor sorts.+ UProp -> False++ -- Equate a sort @s1@ to @univSort s2@+ -- Precondition: @s1@ and @univSort s2@ are already reduced.+ univSortEquals :: Bool -> Bool -> Sort -> Sort -> Blocker -> TCM ()+ univSortEquals propEnabled infInInf s1 s2 blocker = do+ reportSDoc "tc.conv.sort" 35 $ vcat+ [ "univSortEquals"+ , " s1 =" <+> prettyTCM s1+ , " s2 =" <+> prettyTCM s2+ ]+ let postpone = patternViolation blocker+ case s1 of+ -- @Prop l@, @SizeUniv@ and @LevelUniv@ are not successor sorts.+ Prop{} -> no+ Inf UProp _ -> no+ SizeUniv{} -> no+ LevelUniv{} -> no+ -- Neither are @LockUniv@ or @IntervalUniv@.+ LockUniv{} -> no+ IntervalUniv{} -> no++ -- @Set l1@ is the successor sort of either @Set l2@ or+ -- @Prop l2@ where @l1 == lsuc l2@.+ Type l1 -> do+ levelUnivEnabled <- optLevelUniverse <$> pragmaOptions+ guardedEnabled <- optGuarded <$> pragmaOptions+ -- @s2@ is definitely not @Inf n@ or @SizeUniv@+ if | Inf _ _n <- s2 -> __IMPOSSIBLE__+ | SizeUniv <- s2 -> __IMPOSSIBLE__+ -- The predecessor @s2@ is can also not be @SSet _@ or @IntervalUniv@+ | Univ USSet _ <- s2 -> __IMPOSSIBLE__+ | IntervalUniv <- s2 -> __IMPOSSIBLE__+ -- If @Prop@ is not used, then @s2@ must be of the form @Set l2@,+ -- except when l1 == 1, then it could also be @LockUniv@ or @LevelUniv@.+ | not (propEnabled || guardedEnabled || levelUnivEnabled) -> do+ l2 <- case subLevel 1 l1 of+ Just l2 -> return l2+ Nothing -> do+ l2 <- newLevelMeta+ equalLevel l1 (levelSuc l2)+ return l2+ equalSort (Type l2) s2+ -- Otherwise we postpone+ | otherwise -> postpone+ -- @SSetω(n+1)@ is the successor sort of exactly @SSetω(n)@.+ -- @SSetω@ is the successor sort of exactly @SSetω@ if+ -- --type-in-type or --omega-in-omega is enabled.+ -- The same is only true for @Setω(n+1)@ if @Propω...@ are disabled.+ -- @Setω@ is the successor sort of @Setω@ (type:type) or @SizeUniv@ (--sized-types).+ Inf u 0 -> do+ -- Compute the predecessor(s) of (S)Setω and return it if it is unique.+ sizedTypesEnabled <- sizedTypesOption+ -- guardedEnabled <- optGuarded <$> pragmaOptions+ case concat+ [ [ s1 | u /= UProp, infInInf ]+ , [ dummy | u == UType, infInInf, propEnabled, let dummy = Inf UProp 0 ]+ -- We enter a dummy into the solution set if --prop makes predecessor ambiguous.+ , [ SizeUniv | u == UType, sizedTypesEnabled ]+ -- , [ LockUniv | guardedEnabled ] -- LockUniv is actually in Set₁, not Setω+ ]+ of+ [ s ] -> equalSort s s2+ [] -> no+ _ -> postpone+ Inf u n | n > 0, invertibleSort propEnabled u ->+ equalSort (Inf u $ n - 1) s2++ -- Anything else: postpone+ _ -> postpone+++ -- Equate a sort @s@ to @piSort a s1 s2@+ -- Precondition: @s@ and @piSort a s1 s2@ are already reduced.+ piSortEquals ::+ Bool -> Sort -> BlockedDepCheck Sort -> Dom Term -> Sort -> Abs Sort+ -> Blocker -> TCM ()+ piSortEquals propEnabled s c a s1 NoAbs{} blocker = __IMPOSSIBLE__+ piSortEquals propEnabled s c a s1 s2Abs@(Abs x s2) blocker = do+ let adom = El s1 <$> a+ reportSDoc "tc.conv.sort" 35 $ vcat+ [ "piSortEquals"+ , " s =" <+> prettyTCM s+ , " a =" <+> prettyTCM adom+ , " s1 =" <+> prettyTCM s1+ , " s2 =" <+> addContext (x,adom) (prettyTCM s2)+ , " c =" <+> pretty c+ ]+ let postpone = patternViolation blocker+ -- If @s2@ is dependent, then @piSort a s1 s2@ computes to+ -- @Setωi@. Hence, if @s@ is small, then @s2@+ -- cannot be dependent.+ if | isSmallSort s -> do+ -- We force @s2@ to be non-dependent by unifying it with+ -- a fresh meta that does not depend on @x : a@+ s2M <- newSortMeta+ addContext (x , adom) $ equalSort s2 (raise 1 s2M)+ -- This forces @s2@ to be non-dependent, but @s2'@ might still be+ -- dependent!+ -- We therefore need to double check @s2'@ for dependency,+ -- and otherwise postpone+ case c of+ CodomainSortSame -> funSortEquals propEnabled s s1 s2M blocker+ CodomainSortOld s2Old -> liftReduce+ (inLargeEnoughContext s2Old $ forceNonDepSort s2Old) >>= \case+ (NotFree, _) -> funSortEquals propEnabled s s1 s2M blocker+ (MaybeFree _, _) -> postpone+ -- Otherwise: postpone+ | otherwise -> postpone++ -- Equate a sort @s@ to @funSort s1 s2@+ -- Precondition: @s@ and @funSort s1 s2@ are already reduced+ funSortEquals :: Bool -> Sort -> Sort -> Sort -> Blocker -> TCM ()+ funSortEquals propEnabled s0 s1 s2 blocker = do+ reportSDoc "tc.conv.sort" 35 $ vcat+ [ "funSortEquals"+ , " s0 =" <+> prettyTCM s0+ , " s1 =" <+> prettyTCM s1+ , " s2 =" <+> prettyTCM s2+ ]+ sizedTypesEnabled <- sizedTypesOption+ cubicalEnabled <- isJust <$> cubicalOption+ levelUnivEnabled <- optLevelUniverse <$> pragmaOptions+ let postpone = patternViolation blocker+ err :: TCM ()+ err = failConversion CmpEq (Sort s0) (Sort (FunSort s1 s2)) AsTypes+ case s0 of+ -- If @Setωᵢ == funSort s1 s2@, then either @s1@ or @s2@ must+ -- be @Setωᵢ@.++ Inf u n ->+ case (sizeOfSort s1, sizeOfSort s2) of++ -- Both sorts have to be <= n in size, and their fibrancy <= u+ (Right (SizeOfSort u' n'), _)+ | n' > n -> err+ | univFibrancy u' > univFibrancy u -> err+ (_, Right (SizeOfSort u' n'))+ | n' > n -> err+ | univFibrancy u' > univFibrancy u -> err+ -- Unless SSet, the kind of the funSort is the kind of the codomain+ | u /= USSet, u /= u' -> err++ -- One sort has to be at least the same size as n+ (Right (SizeOfSort u1 n1), Right (SizeOfSort u2 n2))+ | n1 < n, n2 < n -> err+ | u /= funUniv u1 u2 -> err++ -- If have the domain sort only+ (Right (SizeOfSort u' n'), _)+ | u' /= USSet, n' < n -> equalSort s0 s2+ | otherwise -> postpone++ -- If we just have the codomain sort+ (_, Right (SizeOfSort USSet n')) -> postpone+ (_, Right (SizeOfSort _ n'))+ | n' < n, u == USSet -> equalSort s1 s2+ | n' < n, not propEnabled,+ -- issue #6648: with --level-universe we have PTS rule (LevelUniv,Set,Setω)+ not levelUnivEnabled || n > 0 -> equalSort (Inf UType n) s1+ | otherwise -> postpone++ _ -> postpone++ -- If @Set l == funSort s1 s2@, then @s2@ must be of the+ -- form @Set l2@. @s1@ can be one of @Set l1@, @Prop l1@,+ -- @SizeUniv@, or @IUniv@.+ Type l -> do+ l2 <- forceUniv UType s2+ -- We must have @l2 =< l@, this might help us to solve+ -- more constraints (in particular when @l == 0@).+ leqLevel l2 l+ -- Jesper, 2022-10-22, #6211: the operations `forceUniv`+ -- and `leqLevel` above might have instantiated some+ -- metas, so we need to reduce s1 again to get an+ -- up-to-date Blocker.+ s1b <- reduceB s1+ let s1 = ignoreBlocking s1b+ blocker = getBlocker s1b+ -- Jesper, 2019-12-27: SizeUniv is disabled at the moment.+ if | {- sizedTypesEnabled || -} propEnabled || cubicalEnabled -> do+ funSortM' s1 (Type l2) >>= \case+ -- If the work we did makes the @funSort@ compute,+ -- continue working.+ Right s -> equalSort (Type l) s+ -- Otherwise: postpone+ Left{} -> patternViolation blocker+ -- If both Prop and sized types are disabled, only the+ -- case @s1 == Set l1@ remains.+ | otherwise -> do+ l1 <- forceUniv UType s1+ equalLevel l (levelLub l1 l2)++ -- If @Prop l == funSort s1 s2@, then @s2@ must be of the+ -- form @Prop l2@, and @s1@ can be one of @Set l1@, Prop+ -- l1@, or @SizeUniv@.+ Prop l -> do+ l2 <- forceUniv UProp s2+ leqLevel l2 l+ s1b <- reduceB s1+ let s1 = ignoreBlocking s1b+ blocker = getBlocker s1b+ funSortM' s1 (Prop l2) >>= \case+ -- If the work we did makes the @funSort@ compute,+ -- continue working.+ Right s -> equalSort (Prop l) s+ -- Otherwise: postpone+ Left b -> patternViolation (unblockOnEither blocker b)++ -- TODO: SSet l++ -- We have @SizeUniv == funSort s1 s2@ iff @s2 == SizeUniv@+ SizeUniv -> equalSort SizeUniv s2+ LevelUniv -> equalSort LevelUniv s2+ -- Anything else: postpone+ _ -> postpone++ forceUniv :: Univ -> Sort -> TCM Level+ forceUniv u = \case+ Univ u' l | u == u' -> return l+ s -> do+ l <- newLevelMeta+ equalSort s (Univ u l)+ return l++ impossibleSort s = do+ reportS "impossible" 10+ [ "equalSort: found dummy sort with description:"+ , s+ ]+ __IMPOSSIBLE__++ catchInequalLevel m fail = m `catchError` \case+ TypeError{} -> fail+ err -> throwError err+++forallFaceMaps :: Term -> (IntMap Bool -> Blocker -> Term -> TCM a)+ -> (IntMap Bool -> Substitution -> TCM a)+ -> TCM [a]+forallFaceMaps t kb k = do+ reportSDoc "conv.forall" 20 $+ fsep ["forallFaceMaps"+ , prettyTCM t+ ]+ as <- decomposeInterval t+ boolToI <- do+ io <- primIOne+ iz <- primIZero+ return (\b -> if b then io else iz)+ forM as $ \ (ms,ts) -> do+ ifBlockeds ts (kb ms) $ \ _ _ -> do+ let xs = map' (second boolToI) $ IntMap.toAscList ms+ cxt <- getContext+ reportSDoc "conv.forall" 20 $+ fsep ["substContextN"+ , prettyTCM cxt+ , prettyTCM xs+ ]+ (cxt',sigma) <- substContextN cxt xs+ resolved <- forM xs (\ (i,t) -> (,) <$> lookupBV i <*> return (applySubst sigma t))+ updateContext sigma (const cxt') $+ addBindings resolved $ do+ cl <- buildClosure ()+ tel <- getContextTelescope+ m <- currentModule+ sub <- getModuleParameterSub m+ reportSDoc "conv.forall" 30 $ vcat+ [ text (replicate 10 '-')+ , prettyTCM (view eCurrentModule $ clEnv cl)+ -- , prettyTCM (envLetBindings $ clEnv cl)+ , prettyTCM tel -- (toTelescope $ envContext $ clEnv cl)+ , prettyTCM sigma+ , prettyTCM m+ , prettyTCM sub+ ]+ cutConversionErrors $ k ms sigma+ where+ -- TODO Andrea: inefficient because we try to reduce the ts which we know are in whnf+ ifBlockeds ts blocked unblocked = do+ and <- getPrimitiveTerm PrimIMin+ io <- primIOne+ let t = foldr (\ x r -> and `apply` [argN x,argN r]) io ts+ ifBlocked t blocked unblocked+ addBindings [] m = m+ addBindings ((CtxVar nm dom@(unDom -> ty),t):bs) m =+ addLetBinding (dom ^. dInfo) Inserted nm t ty (addBindings bs m)++ substContextN :: Context -> [(Int,Term)] -> TCM (Context , Substitution)+ substContextN c [] = return (c, idS)+ substContextN c ((i,t):xs) = do+ (c', sigma) <- substContext i t c+ (c'', sigma') <- substContextN c' (map' (subtract 1 *** applySubst sigma) xs)+ return (c'', applySubst sigma' sigma)+++ -- assumes the term can be typed in the shorter telescope+ -- the terms we get from toFaceMaps are closed.+ substContext :: Int -> Term -> Context -> TCM (Context , Substitution)+ substContext i t CxEmpty = __IMPOSSIBLE__+ substContext i t (CxExtend x xs) | i == 0 = return $ (xs , singletonS 0 t)+ substContext i t (CxExtend x xs) | i > 0 = do+ reportSDoc "conv.forall" 20 $+ fsep ["substContext"+ , text (show (i-1))+ , prettyTCM t+ , prettyTCM xs+ ]+ (c,sigma) <- substContext (i-1) t xs+ let e = applySubst sigma x+ return (CxExtend e c, liftS 1 sigma)+ substContext i t (CxExtend x xs) = __IMPOSSIBLE__++compareInterval :: Comparison -> Type -> Term -> Term -> TCM ()+compareInterval cmp i t u = do+ reportSDoc "tc.conv.interval" 15 $+ sep [ "{ compareInterval" <+> prettyTCM t <+> "=" <+> prettyTCM u ]+ whenProfile Profile.Conversion $ tick "compare at interval type"+ tb <- reduceB t+ ub <- reduceB u+ let t = ignoreBlocking tb+ u = ignoreBlocking ub+ it <- decomposeInterval' t+ iu <- decomposeInterval' u+ case () of+ _ | isBlocked tb || isBlocked ub -> do+ -- in case of metas we wouldn't be able to make progress by how we deal with de morgan laws.+ -- (because the constraints generated by decomposition are sufficient but not necessary).+ -- but we could still prune/solve some metas by comparing the terms as atoms.+ -- also if blocked we won't find the terms conclusively unequal(?) so compareAtom+ -- won't report type errors when we should accept.+ interval <- primIntervalType+ compareAtom CmpEq (AsTermsOf interval) t u+ _ | otherwise -> do+ x <- leqInterval it iu+ y <- leqInterval iu it+ let final = isCanonical it && isCanonical iu+ if x && y then reportSDoc "tc.conv.interval" 15 $ "Ok! }" else+ if final then failConversion cmp t u (AsTermsOf i)+ else do+ reportSDoc "tc.conv.interval" 15 $ "Giving up! }"+ patternViolation (unblockOnAnyMetaIn (t, u))+ where+ isBlocked Blocked{} = True+ isBlocked NotBlocked{} = False+++type Conj = (IntMap BoolSet, [Term])++isCanonical :: [Conj] -> Bool+isCanonical = all (null . snd)++-- | leqInterval r q = r ≤ q in the I lattice.+-- (∨ r_i) ≤ (∨ q_j) iff ∀ i. ∃ j. r_i ≤ q_j+leqInterval :: [Conj] -> [Conj] -> TCM Bool+leqInterval r q =+ and <$> forM r (\ r_i ->+ or <$> forM q (\ q_j -> leqConj r_i q_j)) -- TODO shortcut++-- | leqConj r q = r ≤ q in the I lattice, when r and q are conjuctions.+-- ' (∧ r_i) ≤ (∧ q_j) iff+-- ' (∧ r_i) ∧ (∧ q_j) = (∧ r_i) iff+-- ' {r_i | i} ∪ {q_j | j} = {r_i | i} iff+-- ' {q_j | j} ⊆ {r_i | i}+leqConj :: Conj -> Conj -> TCM Bool+leqConj (rs, rst) (qs, qst) = do+ if IntMap.isSubmapOfBy BoolSet.isSubsetOf qs rs+ then do+ interval <-+ El IntervalUniv . fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinInterval+ -- we don't want to generate new constraints here because+ -- 1. in some situations the same constraint would get generated twice.+ -- 2. unless things are completely accepted we are going to+ -- throw patternViolation in compareInterval.+ let eqT t u = tryConversion (compareAtom CmpEq (AsTermsOf interval) t u)+ let listSubset ts us =+ and <$> forM ts (\t -> or <$> forM us (\u -> eqT t u)) -- TODO shortcut+ listSubset qst rst+ else+ return False++-- | equalTermOnFace φ A u v = _ , φ ⊢ u = v : A+equalTermOnFace :: Term -> Type -> Term -> Term -> TCM ()+equalTermOnFace = compareTermOnFace CmpEq++compareTermOnFace :: Comparison -> Term -> Type -> Term -> Term -> TCM ()+compareTermOnFace = compareTermOnFace' (const compareTerm)++compareTermOnFace' ::+ (Substitution -> Comparison -> Type -> Term -> Term -> TCM ())+ -> Comparison -> Term -> Type -> Term -> Term -> TCM ()+compareTermOnFace' k cmp phi ty u v = do+ reportSDoc "tc.conv.face" 40 $+ text "compareTermOnFace:" <+> pretty phi <+> "|-" <+> pretty u <+> "==" <+> pretty v <+> ":" <+> pretty ty+ whenProfile Profile.Conversion $ tick "compare at face type"++ phi <- reduce phi+ _ <- forallFaceMaps phi postponed $ \ faces alpha ->+ k alpha cmp (applySubst alpha ty) (applySubst alpha u) (applySubst alpha v)+ return ()+ where+ postponed ms blocker psi = do+ phi <- runNamesT [] $ do+ imin <- cl $ getPrimitiveTerm PrimIMin+ ineg <- cl $ getPrimitiveTerm PrimINeg+ psi <- open psi+ let phi = foldr (\ (i,b) r -> do i <- open (var i); pure imin <@> (if b then i else pure ineg <@> i) <@> r)+ psi (IntMap.toList ms) -- TODO Andrea: make a view?+ phi+ addConstraint blocker (ValueCmpOnFace cmp phi ty u v)++---------------------------------------------------------------------------+-- * Definitions+---------------------------------------------------------------------------++bothAbsurd :: QName -> QName -> TCM Bool+bothAbsurd f f'+ | isAbsurdLambdaName f, isAbsurdLambdaName f' = do+ -- Double check we are really dealing with absurd lambdas:+ -- Their functions should not have bodies.+ def <- getConstInfo f+ def' <- getConstInfo f'+ case (theDef def, theDef def') of+ (Function{ funClauses = [Clause{ clauseBody = Nothing }] },+ Function{ funClauses = [Clause{ clauseBody = Nothing }] }) -> return True+ _ -> return False+ | otherwise = return False
@@ -1,17 +1,24 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.TypeChecking.Conversion where import Agda.Syntax.Internal import Agda.TypeChecking.Monad -compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()-compareAtom :: Comparison -> Type -> Term -> Term -> TCM ()-compareArgs :: [Polarity] -> Type -> Term -> Args -> Args -> TCM ()-compareElims :: [Polarity] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()-compareType :: Comparison -> Type -> Type -> TCM ()-compareTel :: Type -> Type -> Comparison -> Telescope -> Telescope -> TCM ()-compareSort :: Comparison -> Sort -> Sort -> TCM ()-equalTerm :: Type -> Term -> Term -> TCM ()-equalType :: Type -> Type -> TCM ()-equalSort :: Sort -> Sort -> TCM ()-leqType :: Type -> Type -> TCM ()+compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()+compareAs :: Comparison -> CompareAs -> Term -> Term -> TCM ()+compareTermOnFace :: Comparison -> Term -> Type -> Term -> Term -> TCM ()+compareAtom :: Comparison -> CompareAs -> Term -> Term -> TCM ()+compareArgs :: [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> TCM ()+compareElims :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()+compareType :: Comparison -> Type -> Type -> TCM ()+compareSort :: Comparison -> Sort -> Sort -> TCM ()+compareLevel :: Comparison -> Level -> Level -> TCM ()+equalTerm :: Type -> Term -> Term -> TCM ()+equalTermOnFace :: Term -> Type -> Term -> Term -> TCM ()+equalType :: Type -> Type -> TCM ()+equalSort :: Sort -> Sort -> TCM ()+equalLevel :: Level -> Level -> TCM ()+leqType :: Type -> Type -> TCM ()+leqLevel :: Level -> Level -> TCM ()+leqSort :: Sort -> Sort -> TCM ()
@@ -0,0 +1,842 @@+-- | Implementation of conversion checking errors which can reify part+-- of the context leading to the actual failure as terms.+module Agda.TypeChecking.Conversion.Errors+ (+ -- * Public interface+ -- $convErrors+ failConversion, mismatchedProjections, addConversionContext,++ -- * Unreifiable recursive calls+ -- $stackSlice+ nowConversionChecking, cutConversionErrors++ -- * Types+ , ConversionError(..)+ , ConversionZipper(..)+ , ConversionErrorContext(..)+ , FailedCompareAs(..)+ )+ where++import Control.Monad.Error.Class+import Control.Monad.Trans.Maybe+import Control.Monad.Except+import Control.Applicative+import Control.DeepSeq+import Control.Monad++import GHC.Generics (Generic)++import qualified Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Internal+import Agda.Syntax.Fixity (Precedence(TopCtx))+import Agda.Syntax.Common++import Agda.TypeChecking.Monad.Constraints+import Agda.TypeChecking.Monad.Statistics+import Agda.TypeChecking.Monad.SizedTypes+import Agda.TypeChecking.Monad.Signature+import Agda.TypeChecking.Monad.MetaVars+import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Monad.Closure+import Agda.TypeChecking.Monad.Context+import Agda.TypeChecking.Monad.Debug+import Agda.TypeChecking.Monad.Pure+import Agda.TypeChecking.Monad.Base++import {-# SOURCE #-} Agda.TypeChecking.Errors+import Agda.TypeChecking.Conversion.Pure+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Warnings+import Agda.TypeChecking.Records+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce++import qualified Agda.Utils.Null as Null+import Agda.Utils.Impossible+import Agda.Utils.Functor+import Agda.Utils.Maybe+import Agda.Utils.Monad hiding (guard)+import Agda.Utils.Size++-- | The failing version of 'CompareAs'.+data FailedCompareAs+ = FailAsTermsOf Type Type+ -- ^ The conversion checker failed in a typed context.+ --+ -- While the conversion checker is homogeneous (so 'AsTermsOf' only+ -- stores a single type), a failing argument comparison early in the+ -- spine of a dependent function can cause the reconstructed+ -- "context" terms to be heterogeneous.+ | FailAsTypes+ -- ^ The conversion checker failed in a type-insensitive context.+ deriving (Show, Generic)++-- | A "zipper-like" representation of the edges between comparing a+-- normal form and comparing one of its immediate subterms in the+-- conversion checker's call graph.+data ConversionZipper+ -- | Thrown at the failing call.+ = ConvStop++ -- | A call to compare the body of a function-typed value.+ | ConvLam+ (Dom Type) -- ^ Argument type+ (Abs ()) -- ^ Simplified codomain+ ArgName -- ^ Name of the variable introduced for comparing the bodies+ ConversionZipper -- ^ Call stack suffix.++ -- | A call to compare the domain of a pair of pi types.+ | ConvDom+ (Dom ConversionZipper) -- ^ Information about the domain, and call stack suffix.+ (Abs Type) -- ^ Codomain of the left-hand side type.+ (Abs Type) -- ^ Codomain of the right-hand-side type.++ -- | A call to compare the codomain of a pair of pi types.+ | ConvCod+ (Dom Type) -- ^ The domain.+ ArgName -- ^ Name of the variable introduced for comparing the bodies+ ConversionZipper -- ^ Call stack suffix.++ -- | A call to compare an argument to a function.+ | ConvApply+ Term -- ^ The head term+ (Abs Type) -- ^ The codomain of the function type at the argument where conversion failed+ (Arg ConversionZipper) -- ^ Information about the argument, and call stack suffix.+ [Elim] -- ^ Remaining arguments from the LHS term that conversion checking could not get to.+ [Elim] -- ^ Remaining arguments from the RHS term that conversion checking could not get to.+ deriving (Show, Generic)++-- | Additional information regarding why two function types are distinct.+data WhyUnequalTypes+ = forall a. (NFData a, Verbalize a) => UnequalDomain a a+ -- ^ Their domains differ in relevance/modality/etc.+ | UnequalHiding Hiding Hiding+ -- ^ Their domains differ in hiding.++-- | Additional information as for why two terms which might print the+-- same are distinct.+--+-- Some constructors are duplicated so that the explanations can be+-- printed in the correct order.+data HeadMismatch+ -- | They are distinct extended lambdas.+ = HdmExtLam QName QName+ -- | They are distinct 'Pi' types.+ | HdmTypes WhyUnequalTypes+ -- | They are distinct variables.+ | HdmVars !Int !Int+ -- | They are the same variable, but their spines might be+ -- interesting.+ | HdmVarSpine !Int (Closure (Elims, Elims))++ | HdmVarDef -- ^ Variable-definition mismatch+ | HdmDefVar -- ^ Definition-variable mismatch+ | HdmVarCon -- ^ Variable-constructor mismatch+ | HdmConVar -- ^ Constructor-variable mismatch+ deriving (Show, Generic)++-- | Whether a 'ConversionZipper' generated nontrivial wrapper terms+-- when flattening the call stack of a t'ConversionError'.+--+-- Used to print error messages with correct grammar.+data HereOrThere+ = Here -- ^ It didn't.+ | There -- ^ It did.+ deriving (Show, Generic)++-- | Context for a conversion checking error.+data ConversionErrorContext+ = Floating ConversionZipper+ -- ^ It still makes sense to collect call stack information for this+ -- error.+ | Finished HereOrThere (Maybe HeadMismatch)+ -- ^ We can not, or do not want to, keep collecting call stack+ -- information for this error.+ -- Stores "crystallised" information about the actual failing+ -- comparison to use as context in error rendering.+ deriving (Show, Generic)++-- | A conversion checking failure.+--+-- A conversion checking error can be in two states (according to its+-- 'convErrCtx'): it is either 'Finished' or+-- 'Agda.TypeChecking.Conversion.Errors.Floating'.+--+-- A 'Finished' conversion-checking error packages a pair of unequal+-- terms, which are well-typed in the context that the error was raised+-- in, with sufficient information for printing an informative error+-- message. 'Finished' errors will not accumulate further call stack+-- information.+--+-- A 'Agda.TypeChecking.Conversion.Errors.Floating' conversion-checking+-- error is subject to be modified as the conversion checker's call+-- stack unwinds, by appending to its 'ConversionZipper'. Some frames in+-- a 'ConversionZipper' alter the context in which the terms+-- 'convErrLhs' and 'convErrRhs' should be interpreted. Floating errors+-- can be re-raised as 'Finished' errors using 'cutConversionErrors'.+-- This means that any code which catches those errors will have types+-- valid directly in the v'TypeError' closure, but no more context will+-- be accumulated for them.+data ConversionError = ConversionError+ { convErrCmp :: Comparison+ -- ^ Were we checking for equality or subtyping?+ , convErrTys :: FailedCompareAs+ -- ^ Were we comparing against a known type when conversion checking+ -- failed?+ , convErrLhs :: Term+ -- ^ The "LHS" of the comparison (if 'CmpLeq', the subtype).+ , convErrRhs :: Term+ -- ^ The "RHS" of the comparison (if 'CmpLeq', the supertype).+ , convErrCtx :: ConversionErrorContext+ -- ^ Call stack information about this error.+ }+ deriving (Show, Generic)++instance Show WhyUnequalTypes where+ show = const "<WhyUnequalTypes>"++instance NFData WhyUnequalTypes where+ rnf = \case+ UnequalDomain a b -> rnf (a, b)+ UnequalHiding a b -> rnf (a, b)++instance NFData ConversionErrorContext+instance NFData ConversionZipper+instance NFData ConversionError+instance NFData FailedCompareAs+instance NFData HeadMismatch+instance NFData HereOrThere++-- $convErrors+--+-- Conversion checking errors are initially thrown (by 'failConversion')+-- in the /floating/ state, which means they can accumulate information+-- on where they happened as the call stack unwinds. This information+-- will be presented to the user by wrapping the actual mismatched terms+-- in a skeleton of the term where the mismatch happened. These terms+-- had better not be nonsense! This requires that recursive calls within+-- the conversion checker cooperate with the reconstruction process,+-- using the functions in this module. Their use can be summarised as+-- follows:+--+-- * A recursive call to compare a subterm of a normal form should be+-- guarded by 'addConversionContext'.+-- * A recursive call to a domain-specific conversion checking function+-- which takes the input terms apart using a nontrivial view (e.g.,+-- 'Agda.TypeChecking.Conversion.equalLevel') should be guarded by+-- 'nowConversionChecking'.+-- * A recursive call under an application of a nontrivial substitution+-- to the context and terms under consideration should be guarded by+-- 'cutConversionErrors'.+-- * Recursive calls that preserve the definitional identities of the+-- terms under consideration do not need any special handling.+--+-- The goal of these rules is to allow for the user to pretend that+-- conversion checking works by normalising then checking for syntactic+-- equality: the reconstructed term should wrap the actual mismatch in+-- "hereditary neutrals (to the left)", i.e. everything that compared+-- equal on the way to the mismatched terms is normalised, but parts of+-- the term that are beyond the mismatch are left as-is (and, in the+-- future, will be presented "deemphasized").+--+-- /How much/ of the context to reify is a design parameter that can be+-- tuned. At the moment, we drop all 'ConvLam', 'ConvDom', 'ConvCod' and+-- __visible__ 'ConvApply' from the front of the zipper. Regardless, the+-- conversion checker must be set up as if the entire context will be+-- reified.++-- | Throw a floating t'ConversionError', given the arguments of+-- 'Agda.TypeChecking.Conversion.compareAs'.+failConversion+ :: (MonadTCError m, HasBuiltins m)+ => Comparison -- ^ Equality or subtyping?+ -> Term -- ^ See 'convErrLhs'+ -> Term -- ^ See 'convErrRhs'+ -> CompareAs -- ^ Will be converted to a 'FailedCompareAs'.+ -> m a+failConversion cmp l r cas = do+ as <- case cas of+ AsTypes -> pure FailAsTypes+ AsTermsOf t -> pure $ FailAsTermsOf t t+ AsSizes -> do+ t <- sizeType+ pure $ FailAsTermsOf t t++ typeError case (l, r) of+ (Sort MetaS{} , t ) -> ShouldBeASort $ El __IMPOSSIBLE__ t+ (s , Sort MetaS{} ) -> ShouldBeASort $ El __IMPOSSIBLE__ s+ (Sort DefS{} , t ) -> ShouldBeASort $ El __IMPOSSIBLE__ t+ (s , Sort DefS{} ) -> ShouldBeASort $ El __IMPOSSIBLE__ s+ _ -> ConversionError_ ConversionError+ { convErrTys = as+ , convErrRhs = r+ , convErrLhs = l+ , convErrCmp = cmp+ , convErrCtx = Floating ConvStop+ }+{-# SPECIALIZE NOINLINE failConversion :: Comparison -> Term -> Term -> CompareAs -> TCM a #-}++{-# INLINE addConversionContext #-}+-- | Add some call stack context to floating t'ConversionError's thrown+-- from the continuation.+--+-- This function should be placed on the __outside__ of 'addContext',+-- and the changes to the context should be reflected in the+-- 'ConversionZipper'.+addConversionContext+ :: (MonadTCError m)+ => (ConversionZipper -> ConversionZipper)+ -- ^ How to modify the zipper+ -> m a+ -- ^ Generally, a recursive call to the conversion checker+ -> m a+addConversionContext !ext !cont = cont `catchError` catchConversionContext ext++{-# SPECIALIZE NOINLINE catchConversionContext :: (ConversionZipper -> ConversionZipper) -> TCErr -> TCM a #-}+catchConversionContext :: MonadTCError m => (ConversionZipper -> ConversionZipper) -> TCErr -> m a+catchConversionContext !ext = \case+ TypeError loc st cl'@Closure{ clValue = ConversionError_ conv@ConversionError{ convErrCtx = Floating ctx } } -> do+ let+ !zip = ext ctx+ !old_c = view eCall $ clEnv cl'+ cl <- buildClosure $ ConversionError_ $! conv { convErrCtx = Floating zip }+ throwError $! TypeError loc st $! (cl {clEnv = (clEnv cl) & eCall .~ old_c})+ err -> throwError err++-- $stackSlice+--+-- The 'ConversionZipper' reflects recursive calls made to conversion+-- checking of the immediate subterms of a normal form, and it can+-- handle most cases of a recursive call happening in a weakening of the+-- current context as well. However, some conversion-checking functions+-- take the input values apart in nontrivial, type-specific ways before+-- eventually calling into "ordinary" term conversion checking again.+--+-- If a floating t'ConversionError' happens in one of these eventual+-- calls, the reified call stack will not have anything corresponding to+-- the value that got taken apart; this can result in the terms+-- presented to the user being ill-typed (see+-- @test/Fail/ConvErrCtxLevels@ for an example). These calls can be+-- handled in two ways, depending on whether or not preserving the+-- surrounding context is likely to be useful in an error message. Here+-- are examples of using each:+--+-- *+-- Calls to 'Agda.TypeChecking.Conversion.equalLevel' are likely to+-- happen while checking hidden arguments to a defined symbol (e.g.+-- a universe-polymorphic data type), which is a context worth+-- preserving for error messages: telling the user @l != l'@ is+-- significantly less useful than telling them @List {l} A != List+-- {l'} B@.+--+-- Therefore, the call to 'Agda.TypeChecking.Conversion.equalLevel'+-- in 'Agda.TypeChecking.Conversion.equalTerm'' is guarded by+-- 'nowConversionChecking'. If an error happens while+-- conversion-checking some levels, the mismatched terms will be+-- /replaced/ by the (normalised forms of) the entire levels that+-- were being compared.+--+-- *+-- On the other hand, conversion checking of partial elements+-- involves nontrivial modifications to the context, and, more+-- importantly, generally happens to terms which display quite+-- terribly /before/ these substitutions are applied, often+-- involving eta-expanded extended lambdas and the primitive+-- @primPOr@. Subjectively, it's less useful to say that conversion+-- checking failed for the hard-to-read system than it is to say+-- that it failed for a particular face.+--+-- For these reasons,+-- 'Agda.TypeChecking.Conversion.compareTermOnFace' (really,+-- 'Agda.TypeChecking.Conversion.forallFaceMaps') uses+-- 'cutConversionErrors' to turn any floating errors from+-- conversion-checking the faces into 'Finished' errors, which no+-- longer accumulate context. Whatever context was collected+-- /inside/ the face comparison will be preserved, but we will not+-- remember /that/ (or /where/) the partial elements were being+-- compared.++-- | Replaces any floating t'ConversionError's raised by the+-- continuation with the one generated (as per 'failConversion') from+-- the given arguments.+{-# INLINE nowConversionChecking #-}+nowConversionChecking ::+ forall m a. (MonadTCError m, HasBuiltins m)+ => Comparison -- ^ Equality or subtyping?+ -> Term -- ^ See 'convErrLhs'+ -> Term -- ^ See 'convErrRhs'+ -> CompareAs -- ^ Will be converted to a 'FailedCompareAs'.+ -> m a -- ^ Generally, a recursive call to a type-specific conversion checking function.+ -> m a+nowConversionChecking !cmp l r !cas !cont =+ cont `catchError` catchNowConversionChecking cmp l r cas++{-# SPECIALIZE NOINLINE catchNowConversionChecking ::+ Comparison -> Term -> Term -> CompareAs -> TCErr -> TCM a #-}+catchNowConversionChecking ::+ (MonadTCError m, HasBuiltins m)+ => Comparison -> Term -> Term -> CompareAs -> TCErr -> m a+catchNowConversionChecking cmp l r cas = \case+ TypeError loc st Closure{ clValue = err }+ | ConversionError_ ConversionError{ convErrCtx = Floating{} } <- err+ -> failConversion cmp l r cas+ err -> throwError err++-- | Freeze t'ConversionError's thrown by the continuation.+--+-- This function should be placed on the __inside__ of context updates.+{-# INLINE cutConversionErrors #-}+cutConversionErrors :: (MonadPretty m, MonadError TCErr m) => m a -> m a+cutConversionErrors cont = cont `catchError` catchCutConversionErrors+++{-# SPECIALIZE NOINLINE catchCutConversionErrors :: TCErr -> TCM a #-}+catchCutConversionErrors :: (MonadPretty m, MonadError TCErr m) => TCErr -> m a+catchCutConversionErrors = \case+ TypeError loc st cl@Closure{ clValue = ConversionError_ conv } -> enterClosure cl \_ ->+ flattenConversionError conv \conv@ConversionError{convErrLhs = lhs, convErrRhs = rhs} -> do+ cl <- buildClosure ()+ throwError $ TypeError loc st $ cl $> ConversionError_ conv+ err -> throwError err++-- | Intermediate type for storing the results of flattening a 'ConversionZipper'.+type ConversionProblem = (FailedCompareAs, Term, Term)++-- | @'eliminateLhsRhs' hd1 ty1 es1 hd2 ty2 es2@ generates a+-- @ConversionProblem@ between the mismatched terms @hd1@ and @hd2@,+-- which have the types @ty1@ and @ty2@ respectively.+--+-- If the types @ty1@ and @ty2@ respond to the given eliminations @es1@+-- and @es2@ respectively (which they should, since the inputs to+-- conversion checking are assumed to be well-typed), the mismatched+-- terms accumulate these, and the types are suitably refined.+--+-- Currently replaces large terms in the @es1@ by 'DontCare', as a HACK+-- to avoid the printing of big uncompared terms. In the future, this is+-- probably better handled in the reifier.+eliminateLhsRhs+ :: forall m. PureTCM m+ => Type -> Term -> Elims+ -> Type -> Term -> Elims+ -> m ConversionProblem+eliminateLhsRhs t1 v1 l_es t2 v2 r_es =+ let+ blank t+ | termSize t >= 15 = DontCare t+ | otherwise = t+ in+ fromMaybeT (FailAsTermsOf t1 t2, v1, v2) do+ t1 <- eliminateType mzero v1 t1 l_es+ t2 <- eliminateType mzero v2 t2 r_es+ pure+ ( FailAsTermsOf t1 t2+ , v1 `applyE` map (fmap blank) l_es+ , v2 `applyE` map (fmap blank) r_es+ )++-- | @'mismatchedProjections' t1 v1 e1 t2 v2 e2@ raises a floating+-- conversion-checking error (as per 'failConversion') indicating that+-- the terms @v1@ and @v2@ (which have type @t1@ and @t2@ respectively,+-- and are typically neutral) disagree on the last elimination in their+-- spines.+--+-- The further eliminations @e1@ and @e2@ are treated as "uncompared"+-- context for the error message.+{-# SPECIALIZE NOINLINE mismatchedProjections :: Type -> Term -> Elims -> Type -> Term -> Elims -> TCM a #-}+mismatchedProjections+ :: (MonadError TCErr m, PureTCM m)+ => Type -- ^ LHS type, @t1@+ -> Term -- ^ LHS term, @v1@; see 'convErrLhs'.+ -> Elims -- ^ Additional eliminations @e1@ present on the LHS beyond the failure of conversion checking+ -> Type -- ^ RHS type, @t2@+ -> Term -- ^ RHS term, @v2@; see 'convErrRhs'.+ -> Elims -- ^ Additional eliminations @e2@ present on the RHS beyond the failure of conversion checking+ -> m a+mismatchedProjections t1 v1 e1 t2 v2 e2 = do+ (tys, lhs, rhs) <- eliminateLhsRhs t1 v1 e1 t2 v2 e2+ typeError $ ConversionError_ $ ConversionError CmpEq tys lhs rhs (Floating ConvStop)++-- | Compute a 'HeadMismatch' explaining why two terms disagree, if+-- there is a possibility that they might be printed identically.+headMismatch :: forall m. (PureTCM m, MonadPlus m) => Term -> Term -> m HeadMismatch+headMismatch Var{} Def{} = pure HdmVarDef+headMismatch Def{} Var{} = pure HdmDefVar+headMismatch Var{} Con{} = pure HdmVarCon+headMismatch Con{} Var{} = pure HdmConVar+headMismatch (Var i xs) (Var j ys)+ | i == j = HdmVarSpine i <$> buildClosure (xs, ys)+headMismatch (Pi d1 _) (Pi d2 _) =+ let+ hint :: (a -> a -> b) -> (forall x y. Dom' x y -> a) -> (a -> a -> Bool) -> m b+ hint k g c = k (g d1) (g d2) <$ guard (not (c (g d1) (g d2)))+ in HdmTypes <$> asum+ [ hint UnequalDomain getRelevance sameRelevance+ , hint UnequalDomain getQuantity sameQuantity+ , hint UnequalDomain getModalPolarity samePolarity+ , hint UnequalDomain getCohesion sameCohesion+ , hint UnequalHiding getHiding sameHiding+ ]+headMismatch (Def i _) (Def j _)+ | isExtendedLambdaName i, isExtendedLambdaName j = pure $ HdmExtLam i j+headMismatch (Var i xs) (Var j ys) = pure $ HdmVars i j+headMismatch lhs rhs = do+ reportSDoc "tc.conv.ctx" 30 $ vcat+ [ "headMismatch no match"+ , " lhs:" <+> prettyTCM lhs+ , " rhs:" <+> prettyTCM rhs+ ]+ mzero++-- | Flatten a Floating conversion checking error into one that+-- presents interesting context around the failing terms.+--+-- The continuation is only invoked with 'Finished' t'ConversionError's.+flattenConversionError :: forall m z. PureTCM m => ConversionError -> (ConversionError -> m z) -> m z+flattenConversionError e@ConversionError{convErrCtx = Finished{}} cont = cont e+flattenConversionError (ConversionError cmp tys lhs rhs (Floating ctx)) cont =+ do+ reportSDoc "tc.conv.ctx" 30 $ vcat+ [ "unwinding conversion zipper:"+ , " env:" <+> (prettyTCM =<< getContextTelescope)+ , " tys:" <+> prettyTCM tys+ , " lhs:" <+> prettyTCM lhs+ , " rhs:" <+> prettyTCM rhs+ , " zip:" <+> prettyTCM ctx+ ]+ let+ k ht hdm (tys, lhs, rhs) = do+ reportSDoc "tc.conv.ctx" 30 $ vcat+ [ "conversion zipper unwound:"+ , " env:" <+> (prettyTCM =<< getContextTelescope)+ , " tys:" <+> prettyTCM tys+ , " lhs:" <+> prettyTCM lhs+ , " rhs:" <+> prettyTCM rhs+ , " hdm:" <+> text (show hdm)+ ]+ cont (ConversionError cmp tys lhs rhs (Finished ht hdm))+ seek k ctx+ where++ -- Actually apply the continuation. This is the innermost function in+ -- handling the ConversionProblem, so this is our opportunity to+ -- collect any headMismatch information that might get buried in+ -- backtrace terms.+ done :: forall z. (HereOrThere -> Maybe HeadMismatch -> ConversionProblem -> m z) -> m z+ done ok = do+ reportSDoc "tc.conv.ctx" 30 $ vcat+ [ "reached center of conversion zipper:"+ , " env:" <+> (prettyTCM =<< getContextTelescope)+ , " tys:" <+> prettyTCM tys+ , " lhs:" <+> pretty lhs+ , " rhs:" <+> pretty rhs+ ]+ hdm <- runMaybeT $ headMismatch lhs rhs+ ok Here hdm (tys, lhs, rhs)++ -- Discard an uninteresting prefix of call stack (anything that does+ -- not mention an implicit argument), moving any binders from the+ -- zipper to the context of the continuation.+ seek+ :: forall z. (HereOrThere -> Maybe HeadMismatch -> ConversionProblem -> m z)+ -> ConversionZipper+ -> m z+ seek ok zip = case zip of+ ConvStop -> done ok+ ConvApply hd ty (Arg info rest) l_es r_es+ | visible info -> seek ok rest+ | Con c o _ <- hd, IsRecord{} <- conDataRecord c -> seek ok rest+ ConvLam dom ty name rest -> addContext (name, dom) $ seek ok rest+ ConvCod dom name rest -> addContext (name, dom) $ seek ok rest+ ConvDom dom c1 c2 -> seek ok (unDom dom)+ _ -> reify zip (ok Here) ok++ -- Actually reifies a 'ConversionZipper' as a term around the conversion+ -- problem.+ -- This function takes both a success continuation (with three+ -- arguments) and a failing continuation, in case we had to give up on+ -- building the context term.+ reify+ :: forall z. ConversionZipper+ -> (Maybe HeadMismatch -> ConversionProblem -> m z)+ -> (HereOrThere -> Maybe HeadMismatch -> ConversionProblem -> m z)+ -> m z+ reify ctx err ok = case ctx of+ -- Empty call stack, nothing to do+ ConvStop -> done ok++ -- Going under binders.+ --+ -- These both function in the same way, though the lambda case seems+ -- much bigger because it has to update the expected types.+ --+ -- On the failure continuation, since we're not building a term+ -- wrapper to add any variables that are referred to by the+ -- mismatched terms, we have to move the binders into the context.+ --+ -- On the success continuation, the term binder is added, and (if+ -- possible) the comparison is updated for accuracy.+ ConvCod dom name rest -> reify rest (\hdm prob -> addContext (name, dom) $ err hdm prob)+ \_ hdm (_, lhs, rhs) -> ok There hdm+ ( FailAsTypes+ , Pi dom (mkAbs name (El __DUMMY_SORT__ lhs))+ , Pi dom (mkAbs name (El __DUMMY_SORT__ rhs))+ )++ ConvLam dom ty name rest -> reify rest+ (\hdm prob -> addContext (name, dom) $ err hdm prob)+ \ht hdm (cmp, lhs, rhs) -> ok There hdm+ ( case cmp of+ -- Ideally it would be provably impossible for a 'ConvLam'+ -- to be on the stack after an untyped comparison, but I+ -- can't be sure that this is actually the case.+ --+ -- If it does happen, it's safer to print a stupid-looking+ -- error (the types λ x → ... and λ x → ... are not equal)+ -- than it is to print an error with dummy terms.+ --+ -- And if someone complains about the error being stupid, we+ -- hopefully get a test case to fix it with.+ FailAsTypes -> FailAsTypes+ -- If we do have the expected types then we can just wrap+ -- them in Pi types.+ FailAsTermsOf a b -> FailAsTermsOf+ (El (piSort (unEl <$> dom) (getSort dom) (getSort a <$ ty)) (Pi dom (a <$ ty)))+ (El (piSort (unEl <$> dom) (getSort dom) (getSort b <$ ty)) (Pi dom (b <$ ty)))+ , Lam (domInfo dom) (mkAbs name lhs), Lam (domInfo dom) (mkAbs name rhs)+ )++ -- Entering the domain of a function type. Bolts the codomains onto+ -- the failing term. No context handling is needed.+ ConvDom dom c1 c2 -> reify (unDom dom) err \_ hdm (_, lhs, rhs) -> ok There hdm+ ( FailAsTypes+ , Pi (El __DUMMY_SORT__ lhs <$ dom) c1+ , Pi (El __DUMMY_SORT__ rhs <$ dom) c2+ )++ -- Entering an argument to a neutral.+ ConvApply hd ty (Arg info rest) l_es r_es -> reify rest err \_ hdm prob@(_, lhs', rhs') ->+ let info' = info { argInfoOrigin = ConversionFail } in case hd of++ -- If the argument is to an extended lambda, we give up on+ -- reifying this frame (and anything it would return to) since+ -- that generally makes the error messages *worse*.+ -- This is the purpose of passing the failing continuation+ -- around.+ Def nm as | isExtendedLambdaName nm -> do+ ~Function{ funExtLam = Just (ExtLamInfo m b sys) } <- theDef <$> getConstInfo nm+ bs <- lookupSection m+ reportSDoc "tc.conv.ctx" 30 $ vcat+ [ "conversion context has extended lambda" <+> pretty nm+ , "bs " <> parens (pretty (size bs)) <> colon <> " " <> pretty bs+ , "as " <> parens (pretty (size as)) <> colon <> " " <> pretty as+ ]+ err hdm prob++ -- Otherwise, we just build the function call. Note that the+ -- ArgInfo is updated so that the reifier will print the+ -- mismatched term in case it happens in an implicit argument.+ _ -> ok There hdm =<< eliminateLhsRhs+ (ty `absApp` lhs') (hd `apply` [Arg info' lhs']) l_es+ (ty `absApp` rhs') (hd `apply` [Arg info' rhs']) r_es++instance PrettyTCM FailedCompareAs where+ prettyTCM = \case+ FailAsTypes{} -> "(as types)"+ FailAsTermsOf a b -> prettyTCM a <+> comma <+> prettyTCM b++instance PrettyTCM ConversionZipper where+ prettyTCM = \case+ ConvStop -> "<>"+ ConvLam dom ret nm rest -> vcat+ [ "lam" <+> pretty nm <+> pretty dom+ , "ret: " <+> pretty ret+ , "rest:"+ , nest 2 (prettyTCM rest)+ ]+ ConvCod dom nm rest -> vcat+ [ "cod" <+> pretty nm <+> pretty dom+ , "rest:"+ , nest 2 (prettyTCM rest)+ ]+ ConvDom dom t1 t2 -> vcat+ [ "dom:" <+> pretty (() <$ dom)+ , "t1: " <+> pretty t1+ , "t2: " <+> pretty t2+ , "rest:"+ , nest 2 (prettyTCM (unDom dom))+ ]+ ConvApply hd ty (Arg info rest) lhs rhs -> vcat+ [ "apply" <+> pretty hd+ , "ty: " <+> pretty ty+ , "lhs: " <+> prettyTCM lhs+ , "rhs: " <+> prettyTCM rhs+ , "rest:"+ , nest 2 (prettyTCM rest)+ ]++instance PrettyTCM ConversionError where+ prettyTCM :: forall m. MonadPretty m => ConversionError -> m Doc+ prettyTCM err = flattenConversionError err \(ConversionError cmp tys lhs rhs ~(Finished ht hdm)) -> do+ (d1, d2, disamb) <- prettyInEqual ht hdm lhs rhs+ let+ disambs = nest 2 $ orEmpty (pure <$> disamb)+ what = hdm >>= \case+ HdmTypes x -> Just x+ _ -> Nothing+ case tys of+ FailAsTermsOf lhs_t rhs_t -> pureBlockOrEqualTypePureTCM lhs_t rhs_t >>= \case+ Right True -> vcat+ [ "The terms", nest 2 (pure d1)+ , "and", nest 2 (pure d2)+ , "are not equal at type " <> prettyTCM lhs_t <> orEmpty (comma <+> "because:" <$ disamb)+ , disambs+ ]+ _ -> vcat+ [ "The terms", nest 2 (pure d1 <+> colon <+> prettyTCM lhs_t)+ , "and", nest 2 (pure d2 <+> colon <+> prettyTCM rhs_t)+ , "are not equal" <> orEmpty (comma <+> "because:" <$ disamb)+ , disambs+ ]+ FailAsTypes | CmpEq <- cmp -> vcat+ [ "The" <+> case what of+ Just UnequalDomain{} -> "function types"+ Just UnequalHiding{} -> "function types"+ _ -> "types"+ , nest 2 (pure d1), "and", nest 2 (pure d2)+ , "are not equal" <> orEmpty (comma <+> "because:" <$ disamb)+ , disambs+ ]+ FailAsTypes | CmpLeq <- cmp -> vcat+ [ "The" <+> case what of+ Just UnequalDomain{} -> "function type"+ Just UnequalHiding{} -> "function type"+ _ -> "type"+ , nest 2 (pure d1), "is not a subtype of", nest 2 (pure d2)+ , orEmpty ("because:" <$ disamb)+ , disambs+ ]++-- | Pretty print a pair of distinct terms @t1@ and @t2@, producing a+-- disambiguator if the terms render the same with the ambient settings+-- but differently with display forms.+displayDisamb+ :: forall m. MonadPretty m+ => HereOrThere -- ^ For grammar+ -> Maybe (Int, Closure (Elims, Elims))+ -- ^ From a 'HeadMismatch', to indicate what projections' display+ -- forms caused the rerender (if any)+ -> Term -- ^ @t1@+ -> Term -- ^ @t2@+ -> m (Doc, Doc, Maybe Doc)+displayDisamb ht hdm t1 t2 = do+ d1 <- prettyTCMCtx TopCtx t1+ d2 <- prettyTCMCtx TopCtx t2+ let+ maybeProjs :: Elims -> Elims -> MaybeT m [m Doc]+ maybeProjs (Proj _ p:xs) (Proj _ p':ys) | p /= p' = do+ df <- hasDisplayForms p+ df' <- hasDisplayForms p'+ case (df, df') of+ (True, False) -> pure $ pwords "a display form for" <> [prettyTCM p, "has"]+ (False, True) -> pure $ pwords "a display form for" <> [prettyTCM p', "has"]+ (True, True) -> pure $ pwords "display forms for" <> [prettyTCM p, "and", prettyTCM p', "have"]+ (False, False) -> mzero+ maybeProjs (_:xs) (_:ys) = maybeProjs xs ys+ maybeProjs _ _ = mzero++ (d1, d2,) <$> runMaybeT do+ guard (P.render d1 == P.render d2)+ reportSDoc "tc.error.conv" 30 $ vcat+ [ "terms rendered the same"+ , " t1:" <+> pretty t1+ , " d1:" <+> pure d1+ , " t2:" <+> pretty t2+ , " d2:" <+> pure d2+ ]++ (d1, d2) <- locallyTC eDisplayFormsEnabled (const False) do+ (,) <$> prettyTCMCtx TopCtx t1 <*> prettyTCMCtx TopCtx t2+ guard (P.render d1 /= P.render d2)++ whatdf <- case hdm of+ Just (_, cl) -> enterClosure cl (lift . runMaybeT . uncurry maybeProjs) <&>+ fromMaybe (pwords "display forms have")+ Nothing -> pure $ pwords "display forms have"++ vcat+ [ fsep $ map lift whatdf <> pwords "caused" <> pwords case ht of+ Here -> "them"+ There -> "the mismatched terms"+ , nest 2 (pure d1), "and", nest 2 (pure d2)+ , "to render the same"+ ]+++-- | Print two terms that are supposedly unequal, additionally returning+-- an explanation (informed by the HeadMismatch) if they happened to+-- print to the same thing.+prettyInEqual+ :: MonadPretty m+ => HereOrThere -- ^ For grammar+ -> Maybe HeadMismatch -- ^ Collected disambiguator information+ -> Term -> Term -> m (Doc, Doc, Maybe Doc)+prettyInEqual ht hdm t1 t2+ -- If we don't know why they differ, or the mismatched terms are+ -- headed by the same variable, we defer to 'displayDisamb' which is+ -- capable of rendering the term without display forms to fish for an+ -- improvement in printing.+ | Nothing <- hdm = displayDisamb ht Nothing t1 t2+ | Just (HdmVarSpine i cl) <- hdm = displayDisamb ht (Just (i, cl)) t1 t2++ -- If they're distinct function types, we don't have to bother+ -- rerendering.+ | Just (HdmTypes x) <- hdm =+ let+ ecore = case x of+ UnequalDomain a b -> pwords "one has"+ <> [hlKeyword (text (verbalize a))]+ <> pwords "domain, while the other is"+ <> [hlKeyword (text (verbalize b)) <> "."]+ UnequalHiding a b -> pwords "one takes"+ <> [hlKeyword (text (verbalize (Indefinite a)))]+ <> pwords "argument, while the other takes"+ <> [hlKeyword (text (verbalize (Indefinite b))), "argument."]+ explain = case ht of+ Here -> fsep ecore+ There -> fsep $ pwords "the mismatched terms are function types;" <> ecore+ in (,,) <$> prettyTCMCtx TopCtx t1 <*> prettyTCMCtx TopCtx t2 <*> (Just <$> explain)++-- If it's some other class of mismatch, a rerender would probably not+-- improve things.+prettyInEqual ht (Just hdm) t1 t2 = do+ d1 <- prettyTCMCtx TopCtx t1+ d2 <- prettyTCMCtx TopCtx t2+ (d1, d2,) <$> runMaybeT do+ guard (P.render d1 == P.render d2)+ let+ mm = case ht of+ Here -> []+ There -> pwords "of the mismatched terms"+ case hdm of+ HdmExtLam a b -> vcat+ [ fsep $+ case ht of+ Here -> pure "they"+ There -> pwords "the mismatched terms"+ <> pwords "are distinct extended lambdas; "+ , fwords "one is defined at"+ , " " <+> pretty (nameBindingSite a)+ , fwords "and the other at"+ , " " <+> (pretty (nameBindingSite b) <> ",")+ , fwords "so they have different internal representations."+ ]++ HdmVarDef -> fsep $ pwords "one" <> mm <> pwords "is a variable, the other a definition"+ HdmVarCon -> fsep $ pwords "one" <> mm <> pwords "is a variable, the other a constructor"+ HdmDefVar -> fsep $ pwords "one" <> mm <> pwords "is a definition, the other a variable"+ HdmConVar -> fsep $ pwords "one" <> mm <> pwords "is a constructor, the other a variable"+ HdmVars i j -> fsep $+ pwords "one" <> mm <> pwords "has de Bruijn index "+ <> [pretty i <> comma] <> pwords "the other" <> [pretty j]
@@ -0,0 +1,7 @@+module Agda.TypeChecking.Conversion.Errors where++import Control.DeepSeq++data ConversionError+instance Show ConversionError+instance NFData ConversionError
@@ -0,0 +1,92 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.Conversion.Pure where++import Control.Monad.Except+import System.IO.Unsafe (unsafeDupablePerformIO)+import Agda.Syntax.Internal++import {-# SOURCE #-} Agda.TypeChecking.Conversion+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.Utils.IORef.Strict qualified as Strict+import Agda.Utils.Impossible++pureConversion ::+ TCM b -- ^ What to do on `neverUnblock`+ -> (Blocker -> TCM b) -- ^ What to do on other blockers.+ -> (a -> TCM b) -- ^ What to do with successful result.+ -> TCM a+ -> TCM b+pureConversion rigidblock flexblock nonblocked = \m ->+ localTC (set eCompareBlocked True . set ePureConversion True) $+ verboseBracket "tc.conv.pure" 40 "runPureConversion" $ do+ oldState <- getTC+ let debugResult msg =+ reportSDoc "tc.conv.pure" 40 $ "runPureConversion result: " <+> msg+ res <- (Right <$> m) `catchError` \case+ PatternErr block ->+ pure $ Left block++ -- András 2024-10-21: we treat this as a rigid blocker. Not sure why,+ -- but the old code did it like this.+ TypeError{} -> do+ debugResult "type error"+ pure $ Left neverUnblock++ GenericException{} -> __IMPOSSIBLE__+ IOException{} -> __IMPOSSIBLE__+ ParserError{} -> __IMPOSSIBLE__+ putTC oldState+ case res of+ Left block | block == neverUnblock -> do+ debugResult "stuck"+ rigidblock+ Left block -> do+ debugResult $ "blocked on" <+> prettyTCM block+ flexblock block+ Right a ->+ nonblocked a+{-# INLINE pureConversion #-}++-- | Run conversion without modifying constraint or meta state. A state+-- modification instead throws a pattern violation.+runPureConversion :: TCM a -> TCM a+runPureConversion =+ pureConversion (patternViolation neverUnblock) patternViolation pure++-- | Don't catch pattern violation.+pureEqualTerm :: Type -> Term -> Term -> TCM Bool+pureEqualTerm a u v =+ pureConversion (pure False) patternViolation (\_ -> pure True) (equalTerm a u v)++-- | Compare terms, catch and return pattern violation.+pureBlockOrEqualTerm :: Type -> Term -> Term -> TCM (Either Blocker Bool)+pureBlockOrEqualTerm a u v =+ pureConversion (pure $ Right False) (pure . Left) (\_ -> pure $ Right True) (equalTerm a u v)++{-# INLINE pureBlockOrEqualTermPureTCM #-}+pureBlockOrEqualTermPureTCM :: PureTCM m => Type -> Term -> Term -> m (Either Blocker Bool)+pureBlockOrEqualTermPureTCM a u v = do+ st <- getTCState+ e <- askTC+ pure $! unsafeDupablePerformIO $ do+ ref <- Strict.newIORef st+ unTCM (pureBlockOrEqualTerm a u v) ref e++pureBlockOrEqualType :: Type -> Type -> TCM (Either Blocker Bool)+pureBlockOrEqualType a b =+ pureConversion (pure $ Right False) (pure . Left) (\_ -> pure $ Right True) (equalType a b)++{-# INLINE pureBlockOrEqualTypePureTCM #-}+pureBlockOrEqualTypePureTCM :: PureTCM m => Type -> Type -> m (Either Blocker Bool)+pureBlockOrEqualTypePureTCM a a' = do+ st <- getTCState+ e <- askTC+ pure $! unsafeDupablePerformIO $ do+ ref <- Strict.newIORef st+ unTCM (pureBlockOrEqualType a a') ref e++pureCompareAs :: Comparison -> CompareAs -> Term -> Term -> TCM Bool+pureCompareAs cmp a u v =+ pureConversion (pure False) patternViolation (\_ -> pure True) (compareAs cmp a u v)
@@ -1,438 +1,1626 @@-{-# LANGUAGE CPP, FlexibleContexts #-}--module Agda.TypeChecking.Coverage where--import Control.Monad-import Control.Monad.Error-import Control.Applicative-import Data.List-import qualified Data.Set as Set-import Data.Set (Set)--import Agda.Syntax.Position-import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.Syntax.Internal.Pattern--import Agda.TypeChecking.Monad.Base-import Agda.TypeChecking.Monad.Trace-import Agda.TypeChecking.Monad.Signature-import Agda.TypeChecking.Monad.Options-import Agda.TypeChecking.Monad.Exception-import Agda.TypeChecking.Monad.Context--import Agda.TypeChecking.Rules.LHS.Unify-import Agda.TypeChecking.Rules.LHS.Instantiate-import Agda.TypeChecking.Rules.LHS-import qualified Agda.TypeChecking.Rules.LHS.Split as Split--import Agda.TypeChecking.Coverage.Match--import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Primitive (constructorForm)-import Agda.TypeChecking.Telescope-import Agda.TypeChecking.Irrelevance--import Agda.Interaction.Options--import Agda.Utils.Permutation-import Agda.Utils.Size-import Agda.Utils.Tuple-import Agda.Utils.Monad--#include "../undefined.h"-import Agda.Utils.Impossible--data SplitClause = SClause- { scTel :: Telescope -- ^ type of variables in scPats- , scPerm :: Permutation -- ^ how to get from the variables in the patterns to the telescope- , scPats :: [Arg Pattern]- , scSubst :: [Term] -- ^ substitution from scTel to old context- }--type Covering = [SplitClause]--data SplitError = NotADatatype Type -- ^ neither data type nor record- | IrrelevantDatatype Type -- ^ data type, but in irrelevant position- | CoinductiveDatatype Type -- ^ coinductive data type- | NoRecordConstructor Type -- ^ record type, but no constructor- | CantSplit QName Telescope Args Args [Term]- | GenericSplitError String- deriving (Show)--instance PrettyTCM SplitError where- prettyTCM err = case err of- NotADatatype t -> fsep $- pwords "Cannot pattern match on non-datatype" ++ [prettyTCM t]- IrrelevantDatatype t -> fsep $- pwords "Cannot pattern match on datatype" ++ [prettyTCM t] ++- pwords "since it is declared irrelevant"- CoinductiveDatatype t -> fsep $- pwords "Cannot pattern match on the coinductive type" ++ [prettyTCM t]- NoRecordConstructor t -> fsep $- pwords "Cannot pattern match on record" ++ [prettyTCM t] ++- pwords "because it has no constructor"- CantSplit c tel cIxs gIxs flex -> addCtxTel tel $ vcat- [ fsep $ pwords "Cannot decide whether there should be a case for the constructor" ++ [prettyTCM c <> text ","] ++- pwords "since the unification gets stuck on unifying the inferred indices"- , nest 2 $ prettyTCM cIxs- , fsep $ pwords "with the expected indices"- , nest 2 $ prettyTCM gIxs- ]- GenericSplitError s -> fsep $- pwords "Split failed:" ++ pwords s--instance Error SplitError where- noMsg = strMsg ""- strMsg = GenericSplitError--type CoverM = ExceptionT SplitError TCM--typeOfVar :: Telescope -> Nat -> Arg Type-typeOfVar tel n- | n >= len = __IMPOSSIBLE__- | otherwise = fmap snd -- throw away name, keep Arg Type- $ ts !! fromIntegral n- where- len = genericLength ts- ts = reverse $ telToList tel---- | Top-level function for checking pattern coverage.-checkCoverage :: QName -> TCM ()-checkCoverage f = do- d <- getConstInfo f- TelV gamma _ <- telView $ defType d- let defn = theDef d- case defn of- Function{ funProjection = proj, funClauses = cs@(_:_) } -> do- let n = genericLength $ clausePats $ head cs- np = maybe 0 snd proj- gamma' = telFromList $ genericTake n $ genericDrop np $ telToList gamma- xs = map (fmap $ const $ VarP "_") $ telToList gamma'- reportSDoc "tc.cover.top" 10 $ vcat- [ text "Coverage checking"- , nest 2 $ vcat $ map (text . show . clausePats) cs- ]- (used, pss) <- cover cs $ SClause gamma' (idP n) xs (idSub gamma')- whenM (optCompletenessCheck <$> pragmaOptions) $- case pss of- [] -> return ()- _ ->- setCurrentRange (getRange cs) $- typeError $ CoverageFailure f pss- case Set.toList $ Set.difference (Set.fromList [0..genericLength cs - 1]) used of- [] -> return ()- is -> do- let unreached = map ((cs !!) . fromIntegral) is- setCurrentRange (getRange unreached) $- typeError $ UnreachableClauses f (map clausePats unreached)- _ -> __IMPOSSIBLE__---- | Check that the list of clauses covers the given split clause.--- Returns the missing cases.-cover :: [Clause] -> SplitClause -> TCM (Set Nat, [[Arg Pattern]])-cover cs (SClause tel perm ps _) = do- reportSDoc "tc.cover.cover" 10 $ vcat- [ text "checking coverage of pattern:"- , nest 2 $ text "tel =" <+> prettyTCM tel- , nest 2 $ text "perm =" <+> text (show perm)- , nest 2 $ text "ps =" <+> text (show ps)- ]- case match cs ps perm of- Yes i -> do- reportSLn "tc.cover.cover" 10 $ "pattern covered by clause " ++ show i- -- Check if any earlier clauses could match with appropriate literals- let is = [ j | (j, c) <- zip [0..] (genericTake i cs), matchLits c ps perm ]- reportSLn "tc.cover.cover" 10 $ "literal matches: " ++ show is- return (Set.fromList (i : is), [])- No -> return (Set.empty, [ps])- Block x -> do- r <- split Inductive tel perm ps x- case r of- Left err -> case err of- CantSplit c tel us vs _ -> typeError $ CoverageCantSplitOn c tel us vs- NotADatatype a -> typeError $ CoverageCantSplitType a- IrrelevantDatatype a -> typeError $ CoverageCantSplitIrrelevantType a- CoinductiveDatatype a -> typeError $ CoverageCantSplitType a- NoRecordConstructor a -> typeError $ CoverageCantSplitType a- GenericSplitError s -> fail $ "failed to split: " ++ s- Right scs -> (Set.unions -*- concat) . unzip <$> mapM (cover cs) scs---- | Check that a type is a non-irrelevant datatype or a record with--- named constructor. Unless the 'Induction' argument is 'CoInductive'--- the data type must be inductive.-isDatatype :: (MonadTCM tcm, MonadException SplitError tcm) =>- Induction -> Arg Type ->- tcm (QName, [Arg Term], [Arg Term], [QName])-isDatatype ind at = do- let t = unArg at- t' <- liftTCM $ reduce t- case unEl t' of- Def d args -> do- def <- liftTCM $ theDef <$> getConstInfo d- splitOnIrrelevantDataAllowed <- liftTCM $ optExperimentalIrrelevance <$> pragmaOptions- case def of- Datatype{dataPars = np, dataCons = cs, dataInduction = i}- | i == CoInductive && ind /= CoInductive ->- throwException $ CoinductiveDatatype t- -- Andreas, 2011-10-03 allow some splitting on data (if only one constr. matches)- | argRelevance at == Irrelevant && not splitOnIrrelevantDataAllowed ->- throwException $ IrrelevantDatatype t- | otherwise -> do- let (ps, is) = genericSplitAt np args- return (d, ps, is, cs)- Record{recPars = np, recCon = c, recNamedCon = hasCon} ->- if hasCon then return (d, args, [], [c])- else throwException $ NoRecordConstructor t- _ -> throwException $ NotADatatype t- _ -> throwException $ NotADatatype t---- | @dtype == d pars ixs@-computeNeighbourhood :: Telescope -> Telescope -> Permutation -> QName -> Args -> Args -> Nat -> OneHolePatterns -> QName -> CoverM [SplitClause]-computeNeighbourhood delta1 delta2 perm d pars ixs hix hps con = do-- -- Get the type of the datatype- dtype <- liftTCM $ (`piApply` pars) . defType <$> getConstInfo d-- -- Get the real constructor name- Con con [] <- liftTCM $ constructorForm =<< normalise (Con con [])-- -- Get the type of the constructor- ctype <- liftTCM $ defType <$> getConstInfo con-- -- Lookup the type of the constructor at the given parameters- TelV gamma (El _ (Def _ cixs)) <- liftTCM $ telView (ctype `piApply` pars)-- debugInit con ctype pars ixs cixs delta1 delta2 gamma hps hix-- -- All variables are flexible- let flex = [0..size delta1 + size gamma - 1]-- -- Unify constructor target and given type (in Δ₁Γ)- let conIxs = drop (size pars) cixs- givenIxs = raise (size gamma) ixs-- r <- addCtxTel (delta1 `abstract` gamma) $- unifyIndices flex (raise (size gamma) dtype) conIxs givenIxs-- case r of- NoUnify _ _ _ -> do- debugNoUnify- return []- DontKnow _ -> do- debugCantSplit- throwException $ CantSplit con (delta1 `abstract` gamma) conIxs givenIxs- [ Var i [] | i <- flex ]- Unifies sub -> do- debugSubst "sub" sub-- -- Substitute the constructor for x in Δ₂: Δ₂' = Δ₂[conv/x]- let conv = Con con $ teleArgs gamma -- Θ Γ ⊢ conv (for any Θ)- delta2' = subst conv $ raiseFrom 1 (size gamma) delta2- debugTel "delta2'" delta2'-- -- Compute a substitution ρ : Δ₁ΓΔ₂' → Δ₁(x:D)Δ₂- let rho = [ Var i [] | i <- [0..size delta2' - 1] ]- ++ [ raise (size delta2') conv ]- ++ [ Var i [] | i <- [size delta2' + size gamma ..] ]-- -- Plug the hole with the constructor and apply ρ- -- TODO: Is it really correct to use Nothing here?- let conp = ConP con Nothing $ map (fmap VarP) $ teleArgNames gamma- ps = plugHole conp hps- ps' = substs rho ps -- Δ₁ΓΔ₂' ⊢ ps'- debugPlugged ps ps'-- -- Δ₁Γ ⊢ sub, we need something in Δ₁ΓΔ₂'- -- Also needs to be padded with Nothing's to have the right length.- let pad n xs x = xs ++ replicate (max 0 $ n - size xs) x- sub' = replicate (size delta2') Nothing ++- pad (size delta1 + size gamma) (raise (size delta2') sub) Nothing- debugSubst "sub'" sub'-- -- Θ = Δ₁ΓΔ₂'- let theta = delta1 `abstract` gamma `abstract` delta2'- debugTel "theta" theta-- -- Apply the unifying substitution to Θ- -- We get ρ' : Θ' -> Θ- -- π : Θ' -> Θ- (theta', iperm, rho', _) <- liftTCM $ instantiateTel sub' theta- debugTel "theta'" theta'- debugShow "iperm" iperm-- -- Compute final permutation- let perm' = expandP hix (size gamma) perm -- perm' : Θ -> Δ₁(x : D)Δ₂- rperm = iperm `composeP` perm'- debugShow "perm'" perm'- debugShow "rperm" rperm-- -- Compute the final patterns- let ps'' = instantiatePattern sub' perm' ps'- rps = substs rho' ps''-- -- Compute the final substitution- let rsub = substs rho' rho-- debugFinal theta' rperm rps-- return [SClause theta' rperm rps rsub]-- where- debugInit con ctype pars ixs cixs delta1 delta2 gamma hps hix =- liftTCM $ reportSDoc "tc.cover.split.con" 20 $ vcat- [ text "computeNeighbourhood"- , nest 2 $ vcat- [ text "con =" <+> prettyTCM con- , text "ctype =" <+> prettyTCM ctype- , text "hps =" <+> text (show hps)- , text "pars =" <+> prettyList (map prettyTCM pars)- , text "ixs =" <+> addCtxTel (delta1 `abstract` gamma) (prettyList (map prettyTCM ixs))- , text "cixs =" <+> prettyList (map prettyTCM cixs)- , text "delta1 =" <+> prettyTCM delta1- , text "delta2 =" <+> prettyTCM delta2- , text "gamma =" <+> prettyTCM gamma- , text "hix =" <+> text (show hix)- ]- ]-- debugNoUnify =- liftTCM $ reportSLn "tc.cover.split.con" 20 " Constructor impossible!"-- debugCantSplit =- liftTCM $ reportSLn "tc.cover.split.con" 20 " Bad split!"-- debugSubst s sub =- liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat- [ text (s ++ " =") <+> brackets (fsep $ punctuate comma $ map (maybe (text "_") prettyTCM) sub)- ]-- debugTel s tel =- liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat- [ text (s ++ " =") <+> prettyTCM tel- ]-- debugShow s x =- liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat- [ text (s ++ " =") <+> text (show x)- ]-- debugPlugged ps ps' =- liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat- [ text "ps =" <+> text (show ps)- , text "ps' =" <+> text (show ps')- ]-- debugFinal tel perm ps =- liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat- [ text "rtel =" <+> prettyTCM tel- , text "rperm =" <+> text (show perm)- , text "rps =" <+> text (show ps)- ]---- | split Δ x ps. Δ ⊢ ps, x ∈ Δ (deBruijn index)-splitClause :: Clause -> Nat -> TCM (Either SplitError Covering)-splitClause c x =- split Inductive (clauseTel c) (clausePerm c) (clausePats c) x--splitClauseWithAbs :: Clause -> Nat -> TCM (Either SplitError (Either SplitClause Covering))-splitClauseWithAbs c x =- split' Inductive (clauseTel c) (clausePerm c) (clausePats c) x--split :: Induction- -- ^ Coinductive constructors are allowed if this argument is- -- 'CoInductive'.- -> Telescope -> Permutation -> [Arg Pattern] -> Nat- -> TCM (Either SplitError Covering)-split ind tel perm ps x = do- r <- split' ind tel perm ps x- return $ case r of- Left err -> Left err- Right (Left _) -> Right []- Right (Right c) -> Right c--split' :: Induction- -- ^ Coinductive constructors are allowed if this argument is- -- 'CoInductive'.- -> Telescope -> Permutation -> [Arg Pattern] -> Nat- -> TCM (Either SplitError (Either SplitClause Covering))-split' ind tel perm ps x = liftTCM $ runExceptionT $ do-- debugInit tel perm x ps-- -- Split the telescope at the variable- (delta1, delta2) <- do- let (tel1, _ : tel2) = genericSplitAt (size tel - x - 1) $ telToList tel- return (telFromList tel1, telFromList tel2)-- -- Get the type of the variable- let t = typeOfVar tel x -- Δ₁ ⊢ t-- -- Compute the one hole context of the patterns at the variable- (hps, hix) <- do- let holes = reverse $ permute perm $ zip [0..] $ allHolesWithContents ps- unless (length holes == length (telToList tel)) $- fail "split: bad holes or tel"-- -- There is always a variable at the given hole.- let (hix, (VarP s, hps)) = holes !! fromIntegral x- debugHoleAndType delta1 delta2 s hps t-- return (hps, hix)-- -- Check that t is a datatype or a record- -- Andreas, 2010-09-21, isDatatype now directly throws an exception if it fails- (d, pars, ixs, cons) <- inContextOfT $ isDatatype ind t-- liftTCM $ whenM (optWithoutK <$> pragmaOptions) $- inContextOfT $ Split.wellFormedIndices pars ixs-- -- Compute the neighbourhoods for the constructors- ns <- concat <$> mapM (computeNeighbourhood delta1 delta2 perm d pars ixs hix hps) cons- case ns of- [] -> do- let absurd = VarP "()"- return $ Left $ SClause- { scTel = telFromList $ telToList delta1 ++- [fmap ((,) "()") t] ++ -- add name "()"- telToList delta2- , scPerm = perm- , scPats = plugHole absurd hps- , scSubst = [] -- not used anyway- }-- -- Andreas, 2011-10-03- -- if more than one constructor matches, we cannot be irrelevant- -- (this piece of code is unreachable if --experimental-irrelevance is off)- (_ : _ : _) | unusableRelevance (argRelevance t) ->- throwException $ IrrelevantDatatype (unArg t)-- _ -> return $ Right ns-- where-- inContextOfT :: MonadTCM tcm => tcm a -> tcm a- inContextOfT = escapeContext (fromIntegral x + 1)-- -- Debug printing- debugInit tel perm x ps =- liftTCM $ reportSDoc "tc.cover.top" 10 $ vcat- [ text "TypeChecking.Rules.LHS.Coverage.split': split"- , nest 2 $ vcat- [ text "tel =" <+> prettyTCM tel- , text "perm =" <+> text (show perm)- , text "x =" <+> text (show x)- , text "ps =" <+> text (show ps)- ]- ]-- debugHoleAndType delta1 delta2 s hps t =- liftTCM $ reportSDoc "tc.cover.top" 10 $ nest 2 $ vcat $- [ text "p =" <+> text s- , text "hps =" <+> text (show hps)- , text "delta1 =" <+> prettyTCM delta1- , text "delta2 =" <+> prettyTCM delta2- , text "t =" <+> inContextOfT (prettyTCM t)- ]+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE TypeApplications #-}++{-| Coverage checking, case splitting, and splitting for refine tactics.++ -}++module Agda.TypeChecking.Coverage+ ( SplitClause(..), clauseToSplitClause, insertTrailingArgs+ , Covering(..), splitClauses+ , coverageCheck+ , isCovered+ , splitClauseWithAbsurd+ , splitLast+ , splitResult+ , normaliseProjP+ ) where++import Prelude hiding (null, (!!)) -- do not use partial functions like !!++import Control.Monad.Except ( MonadError(..), ExceptT(..), runExceptT )+import Control.Monad.State ( State, evalState, state )++import Data.Bifunctor (second)+import Data.Either (partitionEithers)+import Data.Foldable (for_)+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet+import qualified Data.List as List+import Data.Map (Map)+import qualified Data.Map as Map+import qualified Data.Set as Set++import qualified Agda.Benchmarking as Bench++import Agda.Syntax.Common hiding (DataOrRecord)+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Syntax.Position+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern+import Agda.Syntax.Translation.InternalToAbstract (NamedClause(..))+import Agda.Syntax.Scope.Base (ScopeInfo(..))++import Agda.TypeChecking.Primitive hiding (Nat)+import Agda.TypeChecking.Monad+import qualified Agda.TypeChecking.Monad.Benchmark as Bench++import Agda.TypeChecking.Rules.LHS (DataOrRecord, checkSortOfSplitVar)+import Agda.TypeChecking.Rules.LHS.Problem (allFlexVars)+import Agda.TypeChecking.Rules.LHS.Unify+import Agda.TypeChecking.Rules.Term (unquoteTactic)++import Agda.TypeChecking.Coverage.Match+import Agda.TypeChecking.Coverage.SplitPattern+import Agda.TypeChecking.Coverage.SplitTree+import Agda.TypeChecking.Coverage.SplitClause+import Agda.TypeChecking.Coverage.Cubical++import Agda.TypeChecking.Conversion (tryConversion, equalType)+import Agda.TypeChecking.Datatypes (getConForm)+import {-# SOURCE #-} Agda.TypeChecking.Empty ( checkEmptyTel, isEmptyTel, isEmptyType )+import Agda.TypeChecking.Irrelevance+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Records+import Agda.TypeChecking.Sort+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.Warnings++import Agda.Interaction.Options++import Agda.Utils.Boolean ( toBool )+import Agda.Utils.Either+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.Lens+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Permutation+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.Tuple++import Agda.Utils.Impossible++type CoverM = ExceptT SplitError TCM++-- | Top-level function for checking pattern coverage.+--+-- Effects:+--+-- - Marks unreachable clauses as such in the signature.+--+-- - Adds missing instances clauses to the signature.+--+coverageCheck+ :: QName -- ^ Name @f@ of definition.+ -> Type -- ^ Absolute type (including the full parameter telescope).+ -> [Clause] -- ^ Clauses of @f@. These are the very clauses of @f@ in the signature.+ -> TCM SplitTree+coverageCheck f t cs = do+ reportSLn "tc.cover.top" 30 $ "entering coverageCheck for " ++! prettyShow f+ reportSDoc "tc.cover.top" 75 $ " of type (raw): " <+> (text . prettyShow) t+ reportSDoc "tc.cover.top" 45 $ " of type: " <+> prettyTCM t+ TelV gamma1 a <- telViewUpTo (-1) t+ reportSLn "tc.cover.top" 30 $ "coverageCheck: computed telView"++ reportSLn "tc.cover.top" 30 $ "coverageCheck: getting context and checkpoints"+ (gamma, checkpoints) <- addContext gamma1 $ do+ (,) <$> getContextTelescope <*> viewTC eCheckpoints++ let -- n = arity+ -- xs = variable patterns fitting gamma+ n = size gamma+ xs = map (setOrigin Inserted) $ teleNamedArgs gamma++ unsafeInTopContext $ do++ -- construct the initial split clause+ let sc = SClause gamma xs idS checkpoints $ Just $ defaultDom a++ reportSDoc "tc.cover.top" 10 $ do+ let prCl cl = addContext (clauseTel cl) $+ prettyTCMPatternList $ namedClausePats cl+ vcat+ [ text $ "Coverage checking " ++! prettyShow f ++! " with patterns:"+ , nest 2 $ vcat $ map' prCl cs+ ]++ -- used = actually used clauses for cover+ -- pss = non-covered cases+ CoverResult splitTree used pss qss noex <- cover YesInferMissing f cs sc++ -- Andreas, 2018-11-12, issue #378:+ -- some indices in @used@ and @noex@ point outside of @cs@,+ -- since missing hcomp clauses have been added during the course of @cover@.+ -- We simply delete theses indices from @noex@.+ noex <- return $ IntSet.filter (< length cs) noex++ reportSDoc "tc.cover.top" 10 $ vcat+ [ "cover computed!"+ , text $ "used clauses: " ++! show used+ , text $ "non-exact clauses: " ++! show (IntSet.toList noex)+ ]+ reportSDoc "tc.cover.splittree" 10 $ vcat+ [ "generated split tree for" <+> prettyTCM f+ , text $ prettyShow splitTree+ ]+ reportSDoc "tc.cover.covering" 10 $ vcat+ [ text $ "covering patterns for " ++! prettyShow f+ , nest 2 $ vcat $ map' (\ cl -> addContext (clauseTel cl) $ prettyTCMPatternList $ namedClausePats cl) qss+ ]++ -- Storing the covering clauses so that checkIApplyConfluence_ can+ -- find them later.+ -- Andreas, 2019-03-27, only needed when --cubical+ -- Jesper, 2022-10-18, also needed for some backends, so keep when flag says so+ opts <- pragmaOptions+ when (isJust (optCubical opts) || optKeepCoveringClauses opts) $+ modifySignature $ updateDefinition f $ updateTheDef $ updateCovering $ const qss+++ -- filter out the missing clauses that are absurd.+ pss <- ifNotM (optInferAbsurdClauses <$> pragmaOptions) (pure pss) {-else-} $+ flip filterM pss $ \(tel,ps) ->+ -- Andreas, 2019-04-13, issue #3692: when adding missing absurd+ -- clauses, also put the absurd pattern in.+ caseEitherM (checkEmptyTel noRange tel) (\ _ -> return True) $ \ l -> do+ -- Now, @l@ is the first type in @tel@ (counting from 0=leftmost)+ -- which is empty. Turn it into a de Bruijn index @i@.+ let i = size tel - 1 - l+ -- Build a substitution mapping this pattern variable to the absurd pattern.+ let sub = inplaceS i $ absurdP i+ -- ifNotM (isEmptyTel tel) (return True) $ do+ -- Jesper, 2018-11-28, Issue #3407: if the clause is absurd,+ -- add the appropriate absurd clause to the definition.+ let cl = Clause { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = tel+ , namedClausePats = applySubst sub ps+ , clauseBody = Nothing+ , clauseType = Nothing+ , clauseCatchall = YesCatchall empty -- absurd clauses are safe as catch-all+ , clauseRecursive = NotRecursive+ , clauseUnreachable = Just False+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }+ reportSDoc "tc.cover.missing" 20 $ inTopContext $ do+ sep [ "adding missing absurd clause"+ , nest 2 $ prettyTCM $ QNamed f cl+ ]+ reportSDoc "tc.cover.missing" 80 $ inTopContext $ vcat+ [ "l = " <+> pretty l+ , "i = " <+> pretty i+ , "cl = " <+> pretty (QNamed f cl)+ ]+ addClauses f $ singleton cl+ return False++ -- report a warning if there are uncovered cases,+ List1.unlessNull pss \ pss -> do+ stLocalPartialDefs `modifyTCLens` Set.insert f+ whenM ((YesCoverageCheck ==) <$> viewTC eCoverageCheck) $+ setCurrentRange cs $ warning $ CoverageIssue f pss++ -- Andreas, 2017-08-28, issue #2723:+ -- Mark clauses as reachable or unreachable in the signature.+ let cs1 = zip [0..] cs <&> \ (i, cl) -> cl+ { clauseUnreachable = Just $ i `IntSet.notMember` used+ }++ -- Replace the first clauses by @cs1@. There might be more+ -- added by @inferMissingClause@.+ modifyFunClauses f $ \ cs0 -> cs1 ++! drop (length cs1) cs0++ -- Warn if there are unreachable clauses and mark them as unreachable.+ List1.unlessNull (filter ((Just True ==) . clauseUnreachable) cs1) \ unreached -> do+ -- Warn about unreachable clauses.+ let ranges = fmap clauseFullRange unreached+ setCurrentRange ranges $ warning $ UnreachableClauses f ranges++ -- Partition clauses into exact and non-exact ones.+ let (noexclauses, exclauses) = partitionEithers $+ zipWith (\ i c -> if i `IntSet.member` noex then Left c else Right c) [0..] cs1++ -- Report a warning if there are clauses that are not preserved as+ -- definitional equalities and --exact-split is enabled+ -- and they are not labelled as CATCHALL.+ List1.unlessNull (filter (null . clauseCatchall) noexclauses) \ noexclauses -> do+ setCurrentRange (fmap clauseLHSRange noexclauses) $+ warning $ CoverageNoExactSplit f noexclauses++ -- Warn about unused CATCHALL pragmas.+ forM_ exclauses \ c ->+ case clauseCatchall c of+ YesCatchall r | not (null r)+ -> setCurrentRange r $ warning $ UselessPragma r $ "Superfluous CATCHALL pragma"+ _ -> pure ()++ return splitTree++-- | When checking whether a clause is already covered,+-- we do not want 'inferMissingClause' as a side effect.+data InferMissing+ = YesInferMissing -- ^ Infer missing instance and tactic clauses.+ | NoInferMissing -- ^ Don't.+ deriving (Eq, Show)++-- | Top-level function for eliminating redundant clauses in the interactive+-- case splitter+isCovered :: QName -> [Clause] -> SplitClause -> TCM Bool+isCovered f cs sc = do+ reportSDoc "tc.cover.isCovered" 20 $ vcat+ [ "isCovered"+ , nest 2 $ vcat $+ [ "f = " <+> prettyTCM f+ , "cs = " <+> vcat (map' (nest 2 . prettyTCM . NamedClause f True) cs)+ , "sc = " <+> prettyTCM sc+ ]+ ]+ -- Jesper, 2019-10: introduce trailing arguments (see #3828)+ (_ , sc') <- insertTrailingArgs True sc+ CoverResult { coverMissingClauses = missing } <- cover NoInferMissing f cs sc'+ return $ null missing+ -- Andreas, 2019-08-08 and 2020-02-11+ -- If there is an error (e.g. unification error), don't report it+ -- to the user. Rather, assume the clause is not already covered.+ `catchError` \ _ -> return False++-- | @cover infermissing f cs (SClause _ _ ps _) = return (CoverResult splitTree used missing covering noex)@.+-- checks that the list of clauses @cs@ covers the given split clause.+-- Returns the @splitTree@, the @used@ clauses, @missing@ cases, the @covering@ clauses,+-- and the non-exact clauses @noex@.+--+-- Effect: if 'YesInferMissing', adds missing instance clauses for @f@ to signature.+--+cover :: InferMissing -> QName -> [Clause] -> SplitClause ->+ TCM CoverResult+cover infermissing f cs sc@(SClause tel ps _ _ target) = updateRelevance $ do+ reportSDoc "tc.cover.cover" 10 $ inTopContext $ vcat+ [ "checking coverage of pattern:"+ , nest 2 $ prettyTCM sc+ , nest 2 $ "target sort =" <+> do addContext tel $ maybe (text "<none>") (prettyTCM . getSort . unDom) target+ ]+ reportSLn "tc.cover.cover" 80 $ "raw target =\n" ++! show target+ verboseS "tc.cover.matching" 20 $ do+ reportSLn "tc.cover.matching" 20 $ "clauses when matching:"+ forM_ cs $ \ c -> do+ let gamma = clauseTel c+ ps = namedClausePats c+ reportSDoc "tc.cover.matching" 20 $ addContext gamma $+ "ps :" <+> prettyTCM (fmap namedArg ps)++ match cs ps >>= \case+ Yes (i,mps) -> do+ reportSLn "tc.cover.cover" 10 $ "pattern covered by clause " ++! show i+ reportSDoc "tc.cover.cover" 20 $ text "with mps = " <+> do addContext tel $ pretty mps+ let cl0 = indexWithDefault __IMPOSSIBLE__ cs i+ -- Szumi, 2024-09-15, issue #7495: If the split clause has more+ -- patterns than the function clause, then the extra patterns need to+ -- be trivial for the clause to be exact+ let extra = drop (length $ namedClausePats cl0) ps+ exact <-+ and2M+ (forallM mps $ isTrivialPattern . snd)+ (forallM extra $ isTrivialPattern . namedArg)+ cl <- applyCl sc cl0 mps+ return $ CoverResult+ { coverSplitTree = SplittingDone (size tel)+ , coverUsedClauses = singleton i+ , coverMissingClauses = []+ , coverPatterns = [cl]+ , coverNoExactClauses = if exact then empty else singleton i+ }++ No -> do+ reportSLn "tc.cover" 20 $ "pattern is not covered"+ let infer dom = isInstance dom || isJust (domTactic dom)+ if infermissing == YesInferMissing && maybe False infer target+ then do+ -- Ulf, 2016-10-31: For now we only infer instance clauses. It would+ -- make sense to do it also for hidden, but since the value of a+ -- hidden clause is expected to be forced by later clauses, it's too+ -- late to add it now. If it was inferrable we would have gotten a+ -- type error before getting to this point.+ -- Ulf, 2019-11-21: Also @tactic clauses.+ cl <- inferMissingClause f sc+ return $ CoverResult (SplittingDone (size tel)) empty [] [cl] empty+ else do+ let ps' = fromSplitPatterns ps+ return $ CoverResult (SplittingDone (size tel)) empty [(tel, ps')] [] empty++ -- We need to split!+ -- If all clauses have an unsplit copattern, we try that first.+ Block res bs -> trySplitRes res (null bs) splitError $ do+ when (null bs) __IMPOSSIBLE__+ -- Otherwise, if there are variables to split, we try them+ -- in the order determined by a split strategy.+ reportSLn "tc.cover.strategy" 20 $ "blocking vars = " ++! prettyShow bs+ -- xs is a non-empty lists of blocking variables+ -- try splitting on one of them+ xs <- splitStrategy bs tel+ -- Andreas, 2017-10-08, issue #2594+ -- First, try to find split order for complete coverage.+ -- If this fails, try to at least carry out the splitting to the end.+ continue xs NoAllowPartialCover $ \ _err -> do+ continue xs YesAllowPartialCover $ \ err -> do+ splitError err+ where+ -- Andreas, 2019-08-07, issue #3966+ -- When we get a SplitError, tighten the error Range to the clauses+ -- that are still candidates for covering the SplitClause.+ splitError :: SplitError -> TCM a+ splitError = withRangeOfCandidateClauses . typeError . SplitError++ -- This repeats the matching, but since we are crashing anyway,+ -- the extra work just to compute a better Range does not matter.+ withRangeOfCandidateClauses :: TCM a -> TCM a+ withRangeOfCandidateClauses cont = do+ cands <- mapMaybe (uncurry notNo) . zip cs <$> mapM (matchClause ps) cs+ setCurrentRange cands cont+ where+ notNo :: Clause -> Match a -> Maybe Clause+ notNo c = \case+ Yes{} -> Just c+ Block{} -> Just c+ No{} -> Nothing++ -- Rename the variables in a telescope in accordance with their+ -- first appearance in the given NAPs. This is done to preserve+ -- variable names in IApplyConfluence error messages. Specifically,+ -- consider e.g.+ --+ -- data T : Set where+ -- x : T+ -- p : Path (Path T x x) refl refl+ -- f (p i j) = ...+ --+ -- When generating the covering clause corresponding to f's clause,+ -- the names we have in scope are i and i₁, since those are the+ -- names of both PathP binder arguments. (recall Path A x y = PathP (λ i → A) x y)+ -- So if we tried to print (Var 0 []) in the context of+ -- IApplyConfluence for that clause, what we see isn't j, it's i₁.+ --+ -- This function takes "name suggestions" from both variable+ -- patterns and IApply co/patterns, and replaces any existing names+ -- in the telescope by the name in that pattern.+ renTeleFromNap :: SplitClause -> Clause -> Telescope+ renTeleFromNap SClause{scTel = tel, scPats = sps} clause =+ telFromList $ evalState (traverse upd (telToList tel)) (size - offset)+ where+ ps = namedClausePats clause+ offset = 1 + length (fromSplitPatterns sps) - length ps+ -- Fold a single pattern into a map of name suggestions:+ -- In the running example above, we have+ -- f (p i@1 j@0)+ -- so the map that nameSuggest (p ...) returns is {0 → j, 1 → j}+ nameSuggest :: DeBruijnPattern -> IntMap ArgName+ nameSuggest ps = flip foldPattern ps $ \case+ VarP _ i | dbPatVarName i /= "_" ->+ IntMap.singleton (dbPatVarIndex i) (dbPatVarName i)+ IApplyP _ _ _ i | dbPatVarName i /= "_" ->+ IntMap.singleton (dbPatVarIndex i) (dbPatVarName i)+ _ -> mempty++ -- Suggestions from all patterns..+ suggestions = foldMap (nameSuggest . namedThing . unArg) ps++ -- The state will start counting from (length Γ - 1), which is+ -- the *highest* variable index, i.e. the index of the variable+ -- with level 0. Instead of doing a lot of de Bruijn arithmetic+ -- + recursion, traverse handles iteration and the State handles+ -- counting down.+ size = length (telToList tel)++ upd :: Dom (ArgName , Type) -> State Int (Dom (ArgName , Type))+ upd dom = state $ \s -> do+ case IntMap.lookup s suggestions of+ Just nm' ->+ let !dom' = set dName (Just (WithOrigin CaseSplit (unranged nm'))) $+ fmap (const ((nm' , snd (unDom dom)))) dom+ !s' = s - 1+ in (dom', s')+ Nothing -> (dom ,) $! s - 1++ applyCl :: SplitClause -> Clause -> [(Nat, SplitPattern)] -> TCM Clause+ applyCl sc@SClause{scTel = pretel, scPats = sps} cl mps+ | tel <- renTeleFromNap sc cl = addContext tel $ do+ let ps = namedClausePats cl+ reportSDoc "tc.cover.applyCl" 40 $ "applyCl"+ reportSDoc "tc.cover.applyCl" 40 $ "pretel =" <+> pretty pretel+ reportSDoc "tc.cover.applyCl" 40 $ "tel =" <+> pretty tel+ reportSDoc "tc.cover.applyCl" 40 $ "ps =" <+> pretty ps+ reportSDoc "tc.cover.applyCl" 40 $ "mps =" <+> pretty mps+ reportSDoc "tc.cover.applyCl" 40 $ "s =" <+> pretty s+ reportSDoc "tc.cover.applyCl" 40 $ "ps[s] =" <+> pretty (s `applySubst` ps)++ -- If a matching clause has fewer patterns than the split+ -- clause we ought to copy over the extra ones.+ -- e.g. if the user wrote:+ --+ -- bar : Bool -> Bool+ -- bar false = false+ -- bar = \ _ -> true+ --+ -- then for the second clause the @extra@ patterns will be @[true]@.++ let extra = drop (length ps) $ fromSplitPatterns sps+ n_extra = length extra++ reportSDoc "tc.cover.applyCl" 40 $ "extra =" <+> pretty extra++ -- When we add the extra patterns we also update the type+ -- and the body of the clause.++ mtv <- (traverse . traverse) (telViewUpToPath n_extra) $ clauseType cl+ let ty = (fmap . fmap) ((parallelS (reverse $ map' namedArg extra) `composeS` liftS n_extra s `applyPatSubst`) . theCore) mtv+ let body = (`applyE` patternsToElims extra) . (s `applyPatSubst`) <$> clauseBody cl+ let pats = (s `applySubst` ps) ++! extra++ reportSDoc "tc.cover.applyCl" 40 $ "new ty =" <+> pretty ty+ reportSDoc "tc.cover.applyCl" 40 $ "new pats =" <+> pretty pats+ reportSDoc "tc.cover.applyCl" 40 $ "new body =" <+> pretty body++ return $+ Clause { clauseLHSRange = clauseLHSRange cl+ , clauseFullRange = clauseFullRange cl+ , clauseTel = tel+ , namedClausePats = pats+ , clauseBody = body+ , clauseType = ty+ , clauseCatchall = clauseCatchall cl+ , clauseRecursive = clauseRecursive cl+ , clauseUnreachable = clauseUnreachable cl+ , clauseEllipsis = clauseEllipsis cl+ , clauseWhereModule = clauseWhereModule cl+ }+ where+ mps' =+ Map.fromList $+ map' (second (namedArg . fromSplitPattern . defaultNamedArg)) mps+ s = parallelS (for (case Map.lookupMax mps' of+ Nothing -> []+ Just (i, _) -> [0..i]) $ \ i ->+ fromMaybe (deBruijnVar i) (Map.lookup i mps'))++ updateRelevance :: TCM a -> TCM a+ updateRelevance cont =+ -- Don't do anything if there is no target type info.+ caseMaybe target cont $ \ b -> do+ -- TODO (2018-10-16): if proofs get erased in the compiler, also wake erased vars!+ applyDomToContext b cont++ continue+ :: [BlockingVar]+ -> AllowPartialCover+ -> (SplitError -> TCM CoverResult)+ -> TCM CoverResult+ continue xs allowPartialCover handle = do+ r <- altM1 (\ x -> fmap (,x) <$> split Inductive allowPartialCover sc x) xs+ case r of+ Left err -> handle err+ -- If we get the empty covering, we have reached an impossible case+ -- and are done.+ Right (Covering n [], _) ->+ do+ -- TODO Andrea: I guess an empty pattern is not part of the cover?+ let qs = []+ return $ CoverResult (SplittingDone (size tel)) empty [] qs empty+ Right (Covering n scs', x) -> do+ let scs = map' (\(t,(sc,i)) -> (t,sc)) scs'++ (results_trX, cs) <- createMissingIndexedClauses f n x sc scs' cs+ (scs, cs, results_hc) <- do+ let fallback = return (scs, cs, [])+ caseMaybeM (getPrimitiveName' builtinHComp) fallback $ \ comp -> do+ let isComp = \case+ SplitCon c -> comp == c+ _ -> False+ caseMaybe (List.find (isComp . fst) scs) fallback $ \ (sp, newSc) -> do+ (res,cs') <- createMissingHCompClause f n x sc newSc cs+ let scs2 = filter (not . isComp . fst) scs+ return (scs2,cs',res)++ results <- mapM (cover infermissing f cs . snd) scs+ let+ results_extra = results_hc ++! results_trX+ trees_extra = map' (second coverSplitTree) results_extra+ results' = results ++! map' snd results_extra+ -- Andreas, 2025-10-12: add trees_extra later because they would get lost+ -- by the zipWith that constructs trees' below.+ trees = map' coverSplitTree results -- missing ' is not a typo+ useds = map' coverUsedClauses results'+ psss = map' coverMissingClauses results'+ qsss = map' coverPatterns results'+ noex = map' coverNoExactClauses results'+ -- Jesper, 2016-03-10 We need to remember which variables were+ -- eta-expanded by the unifier in order to generate a correct split+ -- tree (see Issue 1872).+ addContext tel $ reportSDoc "tc.cover.split.lazy" 60 $ vcat+ [ "lazySplits"+ , nest 2 $ vcat+ [ "n = " <+> pretty n+ , "scs = " <+> prettyTCM scs+ , "ps = " <+> inTopContext (addContext tel $ prettyTCMPatternList $ fromSplitPatterns ps)+ ]+ ]+ trees' <- zipWithM (lazySplits (unArg n) ps) trees scs+ let tree = SplitAt n StrictSplit (trees' ++! trees_extra) -- TODO: Lazy?+ -- Andreas, 2025-10-12: Debug printing to clarify the trees_extra situation.+ reportSDoc "tc.cover.cubical" 30 $ vcat $+ "trees:" : map' pretty trees +++ "trees':" : map' pretty trees' +++ "trees_extra:" : map' pretty trees_extra +++ "coverSplitTree:" : pretty tree :+ "coverPatterns:" : map' prettyTCM (concat qsss)+ return $ CoverResult tree (IntSet.unions useds) (concat psss) (concat qsss) (IntSet.unions noex)++ -- Try to split result+ trySplitRes+ :: BlockedOnResult -- Are we blocked on the result?+ -> Bool -- Is this the last thing we try?+ -> (SplitError -> TCM CoverResult) -- Handler for 'SplitError'+ -> TCM CoverResult -- Continuation+ -> TCM CoverResult+ -- not blocked on result: try regular splits+ trySplitRes NotBlockedOnResult finalSplit splitError cont+ | finalSplit = __IMPOSSIBLE__ -- there must be *some* reason we are blocked+ | otherwise = cont+ -- blocked on arguments that are not yet introduced:++ -- we must split on a variable so that the target type becomes a pi type+ trySplitRes (BlockedOnApply IsApply) finalSplit splitError cont = do+ -- Andreas, 2021-12-31, issue #5712.+ -- If there is a tactic to solve the clause, we might not have inserted+ -- trailing args (due to #5358). Now we force it!+ (tel, sc') <- insertTrailingArgs True sc+ if null tel then+ if finalSplit then __IMPOSSIBLE__ -- already ruled out by lhs checker+ else cont+ else cover infermissing f cs sc'++ -- ...or it was an IApply pattern, so we might just need to introduce the variable now.+ trySplitRes (BlockedOnApply IsIApply) finalSplit splitError cont+ = do+ caseMaybeM (splitResultPath f sc) fallback $ (cover infermissing f cs . snd) <=< insertTrailingArgs False+ where+ fallback | finalSplit = __IMPOSSIBLE__ -- already ruled out by lhs checker?+ | otherwise = cont++ -- Andreas, 2025-10-25, issue #8139+ --+ -- - This was the old logic:+ --+ -- -- blocked on result but there are catchalls:+ -- -- try regular splits if there are any, or else throw an error,+ -- -- this is nicer than continuing and reporting unreachable clauses+ -- -- (see issue #2833)+ -- trySplitRes (BlockedOnProj True) finalSplit splitError cont+ -- | finalSplit = splitError CosplitCatchall+ -- | otherwise = cont+ --+ -- - The new logic allows copattern catchalls for the sake of further splitting+ -- but they are reported as unreachable.+ --+ -- blocked on result but there are catchalls:+ -- try regular splits if there are any+ trySplitRes (BlockedOnProj True) False splitError cont = cont+ -- all clauses have an unsplit copattern: try to split+ trySplitRes (BlockedOnProj _) finalSplit splitError cont = do+ reportSLn "tc.cover" 20 $ "blocked by projection pattern"+ -- forM is a monadic map over a Maybe here+ mcov <- splitResultRecord f sc+ case mcov of+ Left err+ | finalSplit -> splitError err+ | otherwise -> cont+ Right (Covering n scs) -> do+ -- If result splitting was successful, continue coverage checking.+ (projs, results) <- unzip <$> do+ mapM (traverseF $ cover infermissing f cs <=< (snd <.> insertTrailingArgs False)) (map' (\(t,(sc,i)) -> (t,sc)) scs)+ -- OR:+ -- forM scs $ \ (proj, sc') -> (proj,) <$> do+ -- cover f cs =<< do+ -- snd <$> fixTarget sc'+ let trees = map' coverSplitTree results+ useds = map' coverUsedClauses results+ psss = map' coverMissingClauses results+ qsss = map' coverPatterns results+ noex = map' coverNoExactClauses results+ tree = SplitAt n StrictSplit $ zip projs trees -- TODO: Lazy?+ return $ CoverResult tree (IntSet.unions useds) (concat psss) (concat qsss) (IntSet.unions noex)++ gatherLazySplits :: Int -> SplitClause+ -> [NamedArg SplitPattern] -> [NamedArg SplitPattern]+ gatherLazySplits n sc []+ | n >= 0 = __IMPOSSIBLE__ -- we should have encountered the main+ -- split by now already+ | otherwise = []+ gatherLazySplits n sc (p:ps) = case namedArg p of+ VarP _ x+ | n == 0 -> case p' of -- this is the main split+ VarP _ _ -> p : gatherLazySplits (-1) sc ps+ DotP _ _ -> __IMPOSSIBLE__+ ConP _ _ qs -> qs ++! gatherLazySplits (-1) sc ps+ LitP{} -> gatherLazySplits (-1) sc ps+ ProjP{} -> __IMPOSSIBLE__+ IApplyP{} -> __IMPOSSIBLE__+ DefP _ _ qs -> qs ++! gatherLazySplits (-1) sc ps -- __IMPOSSIBLE__ -- Andrea: maybe?+ | otherwise ->+ updateNamedArg (\ _ -> p') p : gatherLazySplits (n-1) sc ps+ where p' = lookupS (scSubst sc) $ splitPatVarIndex x+ IApplyP{} ->+ updateNamedArg (applySubst (scSubst sc)) p : gatherLazySplits (n-1) sc ps+ DotP _ _ -> p : gatherLazySplits (n-1) sc ps -- count dot patterns+ ConP _ _ qs -> gatherLazySplits n sc (qs ++! ps)+ DefP _ _ qs -> gatherLazySplits n sc (qs ++! ps)+ LitP{} -> gatherLazySplits n sc ps+ ProjP{} -> gatherLazySplits n sc ps++ addLazySplits :: Int -> [NamedArg SplitPattern] -> SplitTree -> SplitTree+ addLazySplits k [] t = t+ addLazySplits k (p:ps) t = case namedArg p of+ VarP _ _ -> addLazySplits (k + 1) ps t+ DotP _ _ -> addLazySplits (k + 1) ps t+ ConP c cpi qs ->+ -- Jesper, 2026-08-18, issue #8638: propagate erasure to subpatterns+ let qs' = map (mapQuantity $ composeQuantity $ getQuantity p) qs+ in SplitAt (p $> k) LazySplit [(SplitCon (conName c) , addLazySplits k (qs' ++! ps) t)]+ LitP{} -> __IMPOSSIBLE__+ ProjP{} -> __IMPOSSIBLE__+ DefP{} -> __IMPOSSIBLE__ -- Andrea: maybe?+ IApplyP{} -> addLazySplits (k + 1) ps t++ lazySplits :: Int -> [NamedArg SplitPattern]+ -> SplitTree -> (SplitTag, SplitClause) -> TCM (SplitTag, SplitTree)+ lazySplits n ps t (tag, sc) = do+ let splitsTodo = gatherLazySplits n sc ps+ reportSDoc "tc.cover.split.lazy" 60 $ "gatherLazySplits result: " <+> pretty splitsTodo+ return (tag, addLazySplits 0 splitsTodo t)+++-- | Append a instance clause to the clauses of a function.+inferMissingClause+ :: QName+ -- ^ Function name.+ -> SplitClause+ -- ^ Clause to add. Clause hiding (in 'clauseType') must be 'Instance'.+ -> TCM Clause+inferMissingClause f (SClause tel ps _ cps (Just t)) = setCurrentRange f $ do+ reportSDoc "tc.cover.infer" 20 $ addContext tel $ "Trying to infer right-hand side of type" <+> prettyTCM t+ rhs <-+ addContext tel+ $ locallyTC eCheckpoints (const cps)+ $ checkpoint IdS -- introduce a fresh checkpoint+ $ case getHiding t of+ _ | Just tac <- domTactic t -> do+ reportSDoc "tc.cover.infer" 40 $ vcat+ [ "@tactic rhs"+ , nest 2 $ "target =" <+> pretty t ]+ (_, v) <- newValueMeta DontRunMetaOccursCheck CmpLeq (unDom t)+ v <$ unquoteTactic tac v (unDom t)+ Instance{} -> snd <$> newInstanceMeta "" (unDom t)+ Hidden -> __IMPOSSIBLE__+ NotHidden -> __IMPOSSIBLE__+ let cl = Clause { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = tel+ , namedClausePats = fromSplitPatterns ps+ , clauseBody = Just rhs+ , clauseType = Just (argFromDom t)+ , clauseCatchall = empty+ , clauseRecursive = MaybeRecursive -- could be recursive+ , clauseUnreachable = Just False -- missing, thus, not unreachable+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }+ addClauses f $ singleton cl -- Important: add at the end.+ return cl+inferMissingClause _ (SClause _ _ _ _ Nothing) = __IMPOSSIBLE__++splitStrategy :: BlockingVars -> Telescope -> TCM BlockingVars+splitStrategy bs tel = return $ updateLast setBlockingVarOverlap xs+ -- Make sure we do not insists on precomputed coverage when+ -- we make our last try to split.+ -- Otherwise, we will not get a nice error message.+ where+ xs = strict ++! lazy+ (lazy, strict) = List.partition blockingVarLazy bs+{- KEEP!+-- Andreas, 2012-10-13+-- The following split strategy which prefers all-constructor columns+-- fails on test/fail/CoverStrategy+ xs = ys ++ zs+ (ys, zs) = partition allConstructors bs+ allConstructors :: BlockingVar -> Bool+ allConstructors = isJust . snd+-}+++-- | Check that a type is a non-irrelevant datatype or a record with+-- named constructor. Unless the 'Induction' argument is 'CoInductive'+-- the data type must be inductive.+isDatatype :: (MonadTCM tcm, MonadError SplitError tcm) =>+ Induction -> Dom Type ->+ tcm (DataOrRecord, QName, Sort, Args, Args, [QName], IsHIT)+isDatatype ind at = do+ let t = unDom at+ throw f = throwError . f =<< do liftTCM $ buildClosure t+ t' <- liftTCM $ reduce t+ mInterval <- liftTCM $ getBuiltinName' builtinInterval+ mIsOne <- liftTCM $ getBuiltinName' builtinIsOne+ case unEl t' of+ Def d [] | Just d == mInterval -> throw NotADatatype+ Def d [Apply phi] | Just d == mIsOne -> do+ xs <- liftTCM $ decomposeInterval =<< reduce (unArg phi)+ if null xs+ then return $ (IsData, d, mkSSet 0, [phi], [], [], NotHIT)+ else throw NotADatatype+ Def d es -> do+ let ~(Just args) = allApplyElims es+ def <- liftTCM $ getConstInfo d+ case theDef def of+ Datatype{dataSort = s, dataPars = np, dataCons = cs, dataHIT = hit}+ | otherwise -> do+ let (ps, is) = splitAt np args+ return (IsData, d, s, ps, is, cs, hit)+ Record{recPars = np, recConHead = con, recInduction = i, recEtaEquality'}+ | i == Just CoInductive && ind /= CoInductive ->+ throw CoinductiveDatatype+ | otherwise -> do+ s <- liftTCM $ shouldBeSort =<< defType def `piApplyM` args+ return (IsRecord InductionAndEta { recordInduction=i, recordEtaEquality=recEtaEquality' }, d, s, args, [], [conName con], NotHIT)+ _ -> throw NotADatatype+ _ -> throw NotADatatype++-- | Update the target type of the split clause after a case split.+fixTargetType+ :: Quantity -- ^ The quantity of the thing that is split.+ -> SplitTag -> SplitClause -> Dom Type -> TCM SplitClause+fixTargetType q tag sc@SClause{ scTel = sctel, scSubst = sigma } target = do+ reportSDoc "tc.cover.target" 20 $ sep+ [ "split clause telescope: " <+> prettyTCM sctel+ ]+ reportSDoc "tc.cover.target" 60 $ sep+ [ "substitution : " <+> prettyTCM sigma+ ]+ reportSDoc "tc.cover.target" 60 $ sep+ [ "target type before substitution:" <+> pretty target+ , " after substitution:" <+> pretty (applySplitPSubst sigma target)+ ]++ -- We update the target quantity to 0 for erased constructors, but+ -- not if the match is made in an erased position, or if the+ -- original constructor definition is not erased.+ updQuant <- do+ let erased = case q of+ Quantity0{} -> True+ Quantity1{} -> __IMPOSSIBLE__+ Quantityω{} -> False+ if erased then return id else case tag of+ SplitCon c -> do+ q <- getQuantity <$> getOriginalConstInfo c+ case q of+ Quantity0{} -> return $ mapQuantity (composeQuantity q)+ Quantity1{} -> return id+ Quantityω{} -> return id+ SplitLit{} -> return id+ SplitCatchall{} -> return id++ return $ sc { scTarget = Just $ updQuant $ applySplitPSubst sigma target }+++-- | Add more patterns to split clause if the target type is a function type.+-- Returns the domains of the function type (if any).+insertTrailingArgs+ :: Bool -- ^ Force insertion even when there is a 'domTactic'?+ -> SplitClause+ -> TCM (Telescope, SplitClause)+insertTrailingArgs force sc@SClause{ scTel = sctel, scPats = ps, scSubst = sigma, scCheckpoints = cps, scTarget = target } = do+ let fallback = return (empty, sc)+ caseMaybe target fallback $ \ a -> do+ if isJust (domTactic a) && not force then fallback else do+ (TelV tel b) <- addContext sctel $ telViewUpTo (-1) $ unDom a+ reportSDoc "tc.cover.target" 15 $ sep+ [ "target type telescope: " <+> do+ addContext sctel $ prettyTCM tel+ , "target type core : " <+> do+ addContext sctel $ addContext tel $ prettyTCM b+ ]+ let n = size tel+ -- Andreas, 2016-10-04 issue #2236+ -- Need to set origin to "Inserted" to avoid printing of hidden patterns.+ xs = map' (mapArgInfo hiddenInserted) $ teleNamedArgs tel+ -- Compute new split clause+ sctel' = telFromList $ telToList (raise n sctel) ++! telToList tel+ -- Dot patterns in @ps@ need to be raised! (Issue 1298)+ ps' = applySubst (raiseS n) ps ++! xs+ newTarget = Just $ (if not (null tel) then a & dTactic .~ Nothing else a) $> b+ sc' = SClause+ { scTel = sctel'+ , scPats = ps'+ , scSubst = wkS n $ sigma -- Should be wkS instead of liftS since+ -- variables are only added to new tel.+ , scCheckpoints = applySubst (raiseS n) cps+ , scTarget = newTarget+ }+ -- Separate debug printing to find cause of crash (Issue 1374)+ reportSDoc "tc.cover.target" 30 $ sep+ [ "new split clause telescope : " <+> prettyTCM sctel'+ ]+ reportSDoc "tc.cover.target" 30 $ sep+ [ "new split clause patterns : " <+> do+ addContext sctel' $ prettyTCMPatternList $ fromSplitPatterns ps'+ ]+ reportSDoc "tc.cover.target" 60 $ sep+ [ "new split clause substitution: " <+> prettyTCM (scSubst sc')+ ]+ reportSDoc "tc.cover.target" 30 $ sep+ [ "new split clause target : " <+> do+ addContext sctel' $ prettyTCM $ fromJust newTarget+ ]+ reportSDoc "tc.cover.target" 20 $ sep+ [ "new split clause"+ , prettyTCM sc'+ ]+ return $ if n == 0 then (empty, sc { scTarget = newTarget }) else (tel, sc')++-- Andreas, 2017-01-18, issue #819, set visible arguments to UserWritten.+-- Otherwise, they will be printed as _.+hiddenInserted :: ArgInfo -> ArgInfo+hiddenInserted ai+ | visible ai = setOrigin UserWritten ai+ | otherwise = setOrigin Inserted ai+++-- | Checks if a type in this sort supports hcomp.+-- currently all such types will have a Level.+-- precondition: Sort in whnf and not blocked.+hasHComp :: Sort -> Maybe Level+hasHComp (Type l) = Just l+hasHComp _ = Nothing+++computeHCompSplit :: Telescope -- ^ Telescope before split point.+ -> PatVarName -- ^ Name of pattern variable at split point.+ -> Telescope -- ^ Telescope after split point.+ -> QName -- ^ Name of datatype to split at.+ -> Args -- ^ Data type parameters.+ -> Args -- ^ Data type indices.+ -> Nat -- ^ Index of split variable.+ -> Telescope -- ^ Telescope for the patterns.+ -> [NamedArg SplitPattern] -- ^ Patterns before doing the split.+ -> Map CheckpointId Substitution -- ^ Current checkpoints+ -- -> QName -- ^ Constructor to fit into hole.+ -> CoverM (Maybe (SplitTag,SplitClause)) -- ^ New split clause if successful.+computeHCompSplit delta1 n delta2 d pars ixs hix tel ps cps = do+ withK <- not <$> cubicalCompatibleOption+ if withK then return Nothing else do+ -- Get the type of the datatype+ -- Δ1 ⊢ dtype+ dsort <- liftTCM $ (parallelS (reverse $ map' unArg pars) `applySubst`) . dataSort . theDef <$> getConstInfo d+ hCompName <- fromMaybe __IMPOSSIBLE__ <$> getPrimitiveName' builtinHComp+ theHCompT <- defType <$> getConstInfo hCompName++ -- TODO can dsort be blocked or not in whnf?+ caseMaybe (hasHComp dsort) (return Nothing) $ \ dlvl' -> do+ let+ dlvl = Level dlvl'+ dterm = Def d [] `apply` (pars ++! ixs)+ -- Δ1 ⊢ gamma+ TelV gamma _ <- lift $ telView (theHCompT `piApply` [setHiding Hidden $ defaultArg $ dlvl , defaultArg $ dterm])+ case (delta1 `abstract` gamma,IdS) of+ (delta1',rho0) -> do+-- debugSubst "rho0" rho0++ -- We have Δ₁' ⊢ ρ₀ : Δ₁Γ, so split it into the part for Δ₁ and the part for Γ+ let (rho1,rho2) = splitS (size gamma) $ toSplitPSubst rho0++ let defp = DefP defaultPatternInfo hCompName . map' (setOrigin Inserted) $ -- should there be a different Origin here?+ map' (fmap unnamed) [setHiding Hidden $ defaultArg $ applySubst rho1 $ DotP defaultPatternInfo $ dlvl+ ,setHiding Hidden $ defaultArg $ applySubst rho1 $ DotP defaultPatternInfo $ dterm]+ ++! applySubst rho2 (teleNamedArgs gamma) -- rho0?+ -- Compute final context and substitution+ let rho3 = consS defp rho1 -- Δ₁' ⊢ ρ₃ : Δ₁(x:D)+ delta2' = applySplitPSubst rho3 delta2 -- Δ₂' = Δ₂ρ₃+ delta' = delta1' `abstract` delta2' -- Δ' = Δ₁'Δ₂'+ rho = liftS (size delta2) rho3 -- Δ' ⊢ ρ : Δ₁(x:D)Δ₂++ -- debugTel "delta'" delta'+ -- debugSubst "rho" rho+ -- debugPs tel ps++ -- Apply the substitution+ let ps' = applySubst rho ps+ -- debugPlugged delta' ps'++ let cps' = applySplitPSubst rho cps++ return $ Just . (SplitCon hCompName,) $ SClause delta' ps' rho cps' Nothing -- target fixed later+++-- | @computeNeighbourhood delta1 delta2 d pars ixs hix tel ps con@+--+-- @+-- delta1 Telescope before split point+-- n Name of pattern variable at split point+-- delta2 Telescope after split point+-- d Name of datatype to split at+-- pars Data type parameters+-- ixs Data type indices+-- hix Index of split variable+-- tel Telescope for patterns ps+-- ps Patterns before doing the split+-- cps Current module parameter checkpoints+-- con Constructor to fit into hole+-- @+-- @dtype == d pars ixs@+computeNeighbourhood+ :: Telescope -- ^ Telescope before split point.+ -> PatVarName -- ^ Name of pattern variable at split point.+ -> Telescope -- ^ Telescope after split point.+ -> QName -- ^ Name of datatype to split at.+ -> Args -- ^ Data type parameters.+ -> Args -- ^ Data type indices.+ -> Nat -- ^ Index of split variable.+ -> Telescope -- ^ Telescope for the patterns.+ -> [NamedArg SplitPattern] -- ^ Patterns before doing the split.+ -> Map CheckpointId Substitution -- ^ Current checkpoints+ -> QName -- ^ Constructor to fit into hole.+ -> CoverM (Maybe (SplitClause, IInfo)) -- ^ New split clause if successful.+computeNeighbourhood delta1 n delta2 d pars ixs hix tel ps cps c = do++ -- Get the type of the datatype+ dtype <- liftTCM $ (`piApply` pars) . defType <$> getConstInfo d++ -- Get the real constructor name+ con <- liftTCM $ fromRight __IMPOSSIBLE__ <$> getConForm c+ con <- return $ con { conName = c } -- What if we restore the current name?+ -- Andreas, 2013-11-29 changes nothing!++ -- Get the type of the constructor+ ctype <- liftTCM $ defType <$> getConInfo con++ -- Lookup the type of the constructor at the given parameters+ (gamma0, cixs, boundary) <- do+ (TelV gamma0 (El _ d), boundary) <- liftTCM $ addContext delta1 $+ telViewPathBoundary (ctype `piApply` pars)+ let Def _ es = d+ Just cixs = allApplyElims es+ return (gamma0, cixs, boundary)++ let (_, dom : _) = splitAt (size tel - hix - 1) (telToList tel)+ info = dom ^. dInfo++ -- Andreas, 2012-02-25 preserve name suggestion for recursive arguments+ -- of constructor++ let preserve (x, t@(El _ (Def d' _))) | d == d' = (n, t)+ preserve (x, t) = (x, t)+ gamma = (fmap . mapModality) (composeModality (getModality info)) $ telFromList . map' (fmap preserve) . telToList $ gamma0+ delta1Gamma = delta1 `abstract` gamma++ debugInit con ctype d pars ixs cixs delta1 delta2 gamma tel ps hix++ cforced <- defForced <$> getConstInfo c+ -- Variables in Δ₁ are not forced, since the unifier takes care to not introduce forced+ -- variables.+ let forced = replicate (size delta1) NotForced ++! cforced+ flex = allFlexVars forced delta1Gamma -- All variables are flexible++ -- Unify constructor target and given type (in Δ₁Γ)+ let conIxs = drop (size pars) cixs+ givenIxs = raise (size gamma) ixs++ -- Andrea 2019-07-17 propagate the Cohesion to the equation telescope+ -- TODO: should we propagate the modality in general?+ -- See also LHS checking.+ dtype <- addContext delta1 $ do+ let updCoh = composeCohesion (getCohesion info)+ TelV dtel dt <- telView dtype+ return $ abstract (mapCohesion updCoh <$> dtel) dt+ dsort <- addContext delta1 $ reduce (getSort dtype)++ let withKIfStrict :: forall a. CoverM a -> CoverM a+ withKIfStrict = applyWhen (isStrictDataSort dsort) $ locallyTC eSplitOnStrict (const True)++ -- Should we attempt to compute a left inverse for this clause? When+ -- --cubical=compatible --flat-split is given, we don't generate a+ -- left inverse (at all). This means that, when the coverage checker+ -- gets to the clause this was in, it won't generate a (malformed!)+ -- transpX clause for @♭ matching.+ -- TODO(Amy): properly support transpX when @♭ stuff is in the+ -- context.+ let flatSplit = boolToMaybe (getCohesion info == Flat) SplitOnFlat++ r <- withKIfStrict $ lift $+ unifyIndices' flatSplit+ delta1Gamma+ flex+ (raise (size gamma) dtype)+ conIxs+ givenIxs++ TelV eqTel _ <- telView $ (raise (size gamma) dtype)++ let stuck b errs = do+ debugCantSplit+ throwError $ UnificationStuck b (conName con) (delta1 `abstract` gamma) conIxs givenIxs errs+++ case r of+ NoUnify {} -> debugNoUnify $> Nothing++ UnifyBlocked block -> stuck (Just block) []++ UnifyStuck errs -> stuck Nothing errs++ Unifies (delta1',rho0,eqs,getTauInv) -> do+ tauInv <- withKIfStrict $ lift getTauInv++ let unifyInfo | Type _ <- dsort -- only types of sort Type l have trX constructors:+ -- re #3733: update if we add transp for other sorts.+ , not $ null $ conIxs -- no point propagating this info if trivial?+ , Right (tau,leftInv) <- tauInv+ = TheInfo $ UE delta1Gamma delta1' eqTel (map' unArg conIxs) (map' unArg givenIxs) rho0 tau leftInv+ | otherwise+ = NoInfo++ case tauInv of+ Right{} -> return ()+ Left SplitOnStrict -> return ()+ Left x -> do+ whenM cubicalCompatibleOption $ do+ -- re #3733: TODO better error msg.+ lift $ warning . UnsupportedIndexedMatch =<< prettyTCM x++ debugSubst "rho0" rho0++ let rho0' = toSplitPSubst rho0++ -- We have Δ₁' ⊢ ρ₀ : Δ₁Γ, so split it into the part for Δ₁ and the part for Γ+ let (rho1,rho2) = splitS (size gamma) $ rho0'++ -- Andreas, 2015-05-01 I guess it is fine to use no @conPType@+ -- as the result of splitting is never used further down the pipeline.+ -- After splitting, Agda reloads the file.+ -- Andreas, 2017-09-03, issue #2729: remember that pattern was generated by case split.+ let cpi = noConPatternInfo{ conPInfo = PatternInfo PatOSplit [] , conPRecord = True }+ conp = ConP con cpi $ applySubst rho0' $+ map' (mapArgInfo hiddenInserted . fmap (fmap setSplitArgOrigin)) $+ telePatterns' (tele2NamedArgs gamma0) gamma boundary+ -- Andreas, 2016-09-08, issue #2166: use gamma0 for correct argument names++ -- Compute final context and substitution+ let rho3 = consS conp rho1 -- Δ₁' ⊢ ρ₃ : Δ₁(x:D)+ delta2' = applySplitPSubst rho3 delta2 -- Δ₂' = Δ₂ρ₃+ delta' = delta1' `abstract` delta2' -- Δ' = Δ₁'Δ₂'+ rho = liftS (size delta2) rho3 -- Δ' ⊢ ρ : Δ₁(x:D)Δ₂++ debugTel "delta'" delta'+ debugSubst "rho" rho+ debugPs tel ps++ -- Apply the substitution+ let ps' = applySubst rho ps+ debugPlugged delta' ps'++ let cps' = applySplitPSubst rho cps++ return $ Just . (,unifyInfo) $ SClause delta' ps' rho cps' Nothing -- target fixed later++ where+ setSplitArgOrigin :: SplitPattern -> SplitPattern+ setSplitArgOrigin (VarP i x) = VarP (i { patOrigin = PatOSplitArg (splitPatVarName x) }) x+ setSplitArgOrigin (IApplyP i u v x) = IApplyP (i { patOrigin = PatOSplitArg (splitPatVarName x)}) u v x+ setSplitArgOrigin p = p++ debugInit con ctype d pars ixs cixs delta1 delta2 gamma tel ps hix = liftTCM $ do+ reportSDoc "tc.cover.split.con" 20 $ vcat+ [ "computeNeighbourhood"+ , nest 2 $ vcat+ [ "context=" <+> (inTopContext . prettyTCM =<< getContextTelescope)+ , "con =" <+> prettyTCM con+ , "ctype =" <+> prettyTCM ctype+ , "ps =" <+> do inTopContext $ addContext tel $ prettyTCMPatternList $ fromSplitPatterns ps+ , "d =" <+> prettyTCM d+ , "pars =" <+> do prettyList $ map' prettyTCM pars+ , "ixs =" <+> do addContext delta1 $ prettyList $ map' prettyTCM ixs+ , "cixs =" <+> do addContext gamma $ prettyList $ map' prettyTCM cixs+ , "delta1 =" <+> do inTopContext $ prettyTCM delta1+ , "delta2 =" <+> do inTopContext $ addContext delta1 $ addContext n $ prettyTCM delta2+ , "gamma =" <+> do inTopContext $ addContext delta1 $ prettyTCM gamma+ , "tel =" <+> do inTopContext $ prettyTCM tel+ , "hix =" <+> text (show hix)+ ]+ ]+ reportSDoc "tc.cover.split.con" 70 $ vcat+ [ "computeNeighbourhood"+ , nest 2 $ vcat+ [ "context=" <+> (inTopContext . (text . show) =<< getContextTelescope)+ , "con =" <+> (text . show) con+ , "ctype =" <+> (text . show) ctype+ , "ps =" <+> (text . show) ps+ , "d =" <+> (text . show) d+ , "pars =" <+> (text . show) pars+ , "ixs =" <+> (text . show) ixs+ , "cixs =" <+> (text . show) cixs+ , "delta1 =" <+> (text . show) delta1+ , "delta2 =" <+> (text . show) delta2+ , "gamma =" <+> (text . show) gamma+ , "hix =" <+> text (show hix)+ ]+ ]++ debugNoUnify =+ liftTCM $ reportSLn "tc.cover.split.con" 20 " Constructor impossible!"++ debugCantSplit =+ liftTCM $ reportSLn "tc.cover.split.con" 20 " Bad split!"++ debugSubst s sub =+ liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+ [ text (s ++! " =") <+> prettyTCM sub+ ]++ debugTel s tel =+ liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+ [ text (s ++! " =") <+> prettyTCM tel+ ]++ debugPs tel ps =+ liftTCM $ reportSDoc "tc.cover.split.con" 20 $+ inTopContext $ addContext tel $ nest 2 $ vcat+ [ "ps =" <+> prettyTCMPatternList (fromSplitPatterns ps)+ ]++ debugPlugged delta' ps' = do+ liftTCM $ reportSDoc "tc.cover.split.con" 20 $+ inTopContext $ addContext delta' $ nest 2 $ vcat+ [ "ps' =" <+> do prettyTCMPatternList $ fromSplitPatterns ps'+ ]++-- | Introduce trailing pattern variables?+data InsertTrailing+ = DoInsertTrailing+ | DontInsertTrailing+ deriving (Eq, Show)++-- | Allow partial covering for split?+data AllowPartialCover+ = YesAllowPartialCover -- To try to coverage-check incomplete splits.+ | NoAllowPartialCover -- Default.+ deriving (Eq, Show)++-- | Entry point from @Interaction.MakeCase@.+splitClauseWithAbsurd :: SplitClause -> Nat -> TCM (Either SplitError (Either SplitClause Covering))+splitClauseWithAbsurd c x =+ split' CheckEmpty Inductive NoAllowPartialCover DontInsertTrailing c (BlockingVar x [] [] True False)+ -- Andreas, 2016-05-03, issue 1950:+ -- Do not introduce trailing pattern vars after split,+ -- because this does not work for with-clauses.++-- | Entry point from @TypeChecking.Empty@ and @Interaction.BasicOps@.+-- @splitLast CoInductive@ is used in the @refine@ tactics.++splitLast :: Induction -> Telescope -> [NamedArg DeBruijnPattern] -> TCM (Either SplitError Covering)+splitLast ind tel ps = split ind NoAllowPartialCover sc (BlockingVar 0 [] [] True False)+ where sc = SClause tel (toSplitPatterns ps) empty empty target+ -- TODO 2ltt: allows (Empty_fib -> Empty_strict) which is not conservative+ target = (Just $ defaultDom $ El (mkProp 0) $ __DUMMY_TERM_WITH__ "splitLastTarget")++-- | @split ind splitClause x = return res@+-- splits @splitClause@ at pattern var @x@ (de Bruijn index).+--+-- Possible results @res@ are:+--+-- 1. @Left err@:+-- Splitting failed.+--+-- 2. @Right covering@:+-- A covering set of split clauses, one for each valid constructor.+-- This could be the empty set (denoting an absurd clause).++split :: Induction+ -- ^ Coinductive constructors are allowed if this argument is+ -- 'CoInductive'.+ -> AllowPartialCover+ -- ^ Don't fail if computed 'Covering' does not cover all constructors.+ -> SplitClause+ -> BlockingVar+ -> TCM (Either SplitError Covering)+split ind allowPartialCover sc x =+ fmap blendInAbsurdClause <$> split' NoCheckEmpty ind allowPartialCover DoInsertTrailing sc x+ where+ n = lookupPatternVar sc $ blockingVarNo x+ blendInAbsurdClause :: Either SplitClause Covering -> Covering+ blendInAbsurdClause = fromRight (const $ Covering n [])++-- | Convert a de Bruijn index relative to the clause telescope to a de Bruijn+-- level. The result should be the argument position (counted from left,+-- starting with 0) to split at (dot patterns included!).+lookupPatternVar :: SplitClause -> Int -> Arg Nat+lookupPatternVar SClause{ scTel = tel, scPats = pats } x = arg $>+ if n < 0 then __IMPOSSIBLE__ else n+ where n = if k < 0+ then __IMPOSSIBLE__+ else fromMaybe __IMPOSSIBLE__ $ permPicks perm !!! k+ perm = fromMaybe __IMPOSSIBLE__ $ dbPatPerm $ fromSplitPatterns pats+ k = size tel - x - 1+ arg = indexWithDefault __IMPOSSIBLE__ (telVars (size tel) tel) k+++data CheckEmpty = CheckEmpty | NoCheckEmpty++-- | @split' ind pc ft splitClause x = return res@+-- splits @splitClause@ at pattern var @x@ (de Bruijn index).+--+-- Possible results @res@ are:+--+-- 1. @Left err@:+-- Splitting failed.+--+-- 2. @Right (Left splitClause')@:+-- Absurd clause (type of @x@ has 0 valid constructors).+--+-- 3. @Right (Right covering)@:+-- A covering set of split clauses, one for each valid constructor.++split' :: CheckEmpty+ -- ^ Use isEmptyType to check whether the type of the variable to+ -- split on is empty. This switch is necessary to break the cycle+ -- between split' and isEmptyType.+ -> Induction+ -- ^ Coinductive constructors are allowed if this argument is+ -- 'CoInductive'.+ -> AllowPartialCover+ -- ^ Don't fail if computed 'Covering' does not cover all constructors.+ -> InsertTrailing+ -- ^ If 'DoInsertTrailing', introduce new trailing variable patterns.+ -> SplitClause+ -> BlockingVar+ -> TCM (Either SplitError (Either SplitClause Covering))+split' checkEmpty ind allowPartialCover inserttrailing+ sc@(SClause tel ps _ cps target) (BlockingVar x pcons' plits overlap lazy) =+ liftTCM $ runExceptT $ do+ debugInit tel x ps cps++ -- Split the telescope at the variable+ -- t = type of the variable, Δ₁ ⊢ t+ (n, t, delta1, delta2) <- do+ let (tel1, dom : tel2) = splitAt (size tel - x - 1) $ telToList tel+ return (fst $ unDom dom, snd <$> dom, telFromList tel1, telFromList tel2)++ -- Compute the neighbourhoods for the constructors+ let computeNeighborhoods :: ExceptT SplitError TCM (DataOrRecord, Sort, Bool, Int, [(SplitTag, (SplitClause, IInfo))])+ computeNeighborhoods = do+ -- Check that t is a datatype or a record+ -- Andreas, 2010-09-21, isDatatype now directly throws an exception if it fails+ -- cons = constructors of this datatype+ (dr, d, s, pars, ixs, cons', isHIT) <- inContextOfT $ isDatatype ind t+ isFib <- fromRight (const False) <$> lift (isFibrant' t)+ cons <- case checkEmpty of+ CheckEmpty -> ifM (liftTCM $ inContextOfT $ isEmptyType t)+ (pure []) (pure cons')+ NoCheckEmpty -> pure cons'+ mns <- forM cons $ \ con -> fmap (SplitCon con,) <$>+ computeNeighbourhood delta1 n delta2 d pars ixs x tel ps cps con+ hcompsc <- if isFib && (isHIT == YesHIT || not (null ixs)) && not (null mns) && inserttrailing == DoInsertTrailing+ then computeHCompSplit delta1 n delta2 d pars ixs x tel ps cps+ else return Nothing+ let ns = catMaybes mns+ return ( dr+ , s+ , not (null ixs) -- Is "d" indexed?+ , length $ ns+ , ns ++! catMaybes ([fmap (fmap (,NoInfo)) hcompsc | not $ null $ ns])+ )++ computeLitNeighborhoods :: ExceptT SplitError TCM (DataOrRecord, Sort, Bool, Int, [(SplitTag, (SplitClause, IInfo))])+ computeLitNeighborhoods = do+ typeOk <- liftTCM $ do+ t' <- litType $ headWithDefault {-'-} __IMPOSSIBLE__ plits+ liftTCM $ dontAssignMetas $ tryConversion $ equalType (unDom t) t'+ unless typeOk $ throwError . NotADatatype =<< do liftTCM $ buildClosure (unDom t)+ ns <- forM plits $ \lit -> do+ let delta2' = subst 0 (Lit lit) delta2+ delta' = delta1 `abstract` delta2'+ rho = liftS x $ consS (litP lit) idS+ ps' = applySubst rho ps+ cps' = applySplitPSubst rho cps+ return (SplitLit lit , SClause delta' ps' rho cps' Nothing)+ ca <- do+ let delta' = tel -- telescope is unchanged for catchall branch+ varp = VarP (PatternInfo PatOSplit []) $ SplitPatVar+ { splitPatVarName = underscore+ , splitPatVarIndex = 0+ , splitExcludedLits = plits+ }+ rho = liftS x $ consS varp $ raiseS 1+ ps' = applySubst rho ps+ return (SplitCatchall , SClause delta' ps' rho cps Nothing)++ -- If Agda is changed so that the type of a literal can belong+ -- to an inductive family (with at least one index), then the+ -- following code should be changed (the constructor False+ -- stands for "not indexed").+ let ns' = map' ((fmap (,NoInfo))) $ ns ++! [ ca ]+ return (IsData, mkType 0, False, length ns', ns')++ -- numMatching is the number of proper constructors matching, excluding hcomp.+ -- for literals this considers the catchall clause as 1 extra constructor.+ (dr, s, isIndexed, numMatching, ns) <- if null pcons' && not (null plits)+ then computeLitNeighborhoods+ else computeNeighborhoods++ ns <- case target of+ Just a -> forM ns $ \ (con,(sc,info)) -> lift $ (con,) . (,info) <$>+ fixTargetType (getQuantity t) con sc a+ Nothing -> return ns++ ns <- case inserttrailing of+ DontInsertTrailing -> return ns+ DoInsertTrailing -> lift $ forM ns $ \(con,(sc,info)) ->+ (con,) . (,info) . snd <$> insertTrailingArgs False sc++ mHCompName <- getPrimitiveName' builtinHComp+ opts <- pragmaOptions+ builtin <- currentModuleIsBuiltinModuleWithSafePostulates+ let erasedMatches = optErasedMatches opts+ isRecordWithEta = case dr of+ IsData -> False+ IsRecord r ->+ case theEtaEquality (recordEtaEquality r) of+ YesEta{} -> True+ NoEta{} -> False++ erased <- hasQuantity0 <$> viewTC eQuantity+ reportSLn "tc.cover.split" 60 $ "We are in erased context = " ++! show erased+ reportSDoc "tc.cover.split" 60 $ vcat+ [ "Allowed erased matches:"+ , "* Empty: " <+> text (show (emEmpty erasedMatches))+ , "* Non-dependent:" <+> text (show (emNonDependent erasedMatches))+ , "* Restricted: " <+> text (show (emRestricted erasedMatches))+ , "* Unrestricted: " <+> text (show (emUnrestricted erasedMatches))+ ]+ let erasedError reason =+ throwError . ErasedDatatype reason =<<+ do liftTCM $ inContextOfT $ buildClosure (unDom t)++ case numMatching of+ -- Erased matches for empty types can be disallowed, but there is+ -- no check for such matches here: such a check can instead be+ -- found in Agda.TypeChecking.Rules.LHS.checkAbsurdPattern (see+ -- issue #8788).+ 0 -> do+ let absurdp = VarP (PatternInfo PatOAbsurd []) $ SplitPatVar underscore 0 []+ rho = liftS x $ consS absurdp $ raiseS 1+ ps' = applySubst rho ps+ return $ Left $ SClause+ { scTel = tel+ , scPats = ps'+ , scSubst = __IMPOSSIBLE__ -- not used+ , scCheckpoints = __IMPOSSIBLE__ -- not used+ , scTarget = Nothing+ }++ -- Andreas, 2018-10-17: If more than one constructor matches, we cannot erase.+ n | n > 1 && not erased && not (usableQuantity t) ->+ erasedError SeveralConstructors++ -- Exactly one constructor matches, the argument is erased, and+ -- run-time mode is active. This is disallowed (#4172) unless+ --+ -- ∗ the type is a (non-indexed) record type with η-equality, or+ --+ -- ∗ the type is non-indexed and erased matches are allowed for+ -- single-constructor, non-indexed data types, or+ --+ -- ∗ the type is indexed and erased matches are allowed for+ -- single-constructor, indexed data types, or+ --+ -- ∗ the type is indexed, []-cong is allowed, and the module+ -- currently being type-checked is a builtin module that allows+ -- safe postulates. (One could restrict this further to just the+ -- module @Agda.Builtin.Erased.Box-cong@.)+ --+ -- In the case where the type is indexed the error message only+ -- refers to @--erased-matches=unrestricted@ because+ -- @--erased-matches=restricted@ is only useful in builtin+ -- modules.+ 1 | not erased && not (usableQuantity t) &&+ not (not isIndexed && (isRecordWithEta ||+ emNonDependent erasedMatches) ||+ isIndexed && emUnrestricted erasedMatches ||+ isIndexed && emRestricted erasedMatches && builtin) ->+ erasedError $+ if isIndexed+ then ErasedMatchesDisabledDependent+ else ErasedMatchesDisabledNonDependent++ _ -> do++ -- Andreas, 2012-10-10 fail if precomputed constructor set does not cover+ -- all the data type constructors+ -- Andreas, 2017-10-08 ... unless partial covering is explicitly allowed.+ let ptags = map' (SplitCon . conName) pcons' ++! map' SplitLit plits+ -- clauses for hcomp will be automatically generated.+ let inferred_tags = maybe Set.empty (Set.singleton . SplitCon) mHCompName+ let all_tags = Set.fromList ptags `Set.union` inferred_tags++ when (allowPartialCover == NoAllowPartialCover && not overlap) $+ for_ ns $ \(tag, (sc, _)) -> do+ unless (tag `Set.member` all_tags) $ do+ isImpossibleClause <- isEmptyTel $ scTel sc+ unless isImpossibleClause $ do+ liftTCM $ reportSDoc "tc.cover" 10 $ vcat+ [ text "Missing case for" <+> prettyTCM tag+ , nest 2 $ prettyTCM sc+ ]+ throwError (GenericSplitError "precomputed set of constructors does not cover all cases")++ let t' = set lensSort s $ unDom t+ liftTCM $ inContextOfT $ checkSortOfSplitVar dr t' delta2 target+ return $ Right $ Covering (lookupPatternVar sc x) ns++ where+ inContextOfT, inContextOfDelta2 :: (MonadAddContext tcm) => tcm a -> tcm a+ inContextOfT = addContext tel . escapeContext impossible (x + 1)+ inContextOfDelta2 = addContext tel . escapeContext impossible x++ -- Debug printing+ debugInit tel x ps cps = liftTCM $ inTopContext $ do+ reportSDoc "tc.cover.top" 10 $ vcat+ [ "TypeChecking.Coverage.split': split"+ , nest 2 $ vcat+ [ "tel =" <+> prettyTCM tel+ , "x =" <+> prettyTCM x+ , "ps =" <+> do addContext tel $ prettyTCMPatternList $ fromSplitPatterns ps+ , "cps =" <+> prettyTCM cps+ ]+ ]+ reportSDoc "tc.cover.top" 60 $ vcat+ [ "TypeChecking.Coverage.split': split"+ , nest 2 $ vcat+ [ "tel =" <+> pretty tel+ , "x =" <+> pretty x+ , "ps =" <+> pretty ps+ , "cps =" <+> pretty cps+ ]+ ]++ debugHoleAndType delta1 delta2 s ps t =+ liftTCM $ reportSDoc "tc.cover.top" 10 $ nest 2 $ vcat $+ [ "p =" <+> text (patVarNameToString s)+ , "ps =" <+> prettyTCMPatternList ps+ , "delta1 =" <+> prettyTCM delta1+ , "delta2 =" <+> inContextOfDelta2 (prettyTCM delta2)+ , "t =" <+> inContextOfT (prettyTCM t)+ ]+++-- | splitResult for MakeCase, tries to introduce IApply or ProjP copatterns+splitResult :: QName -> SplitClause -> TCM (Either SplitError [SplitClause])+splitResult f sc = do+ caseMaybeM (splitResultPath f sc)+ ((fmap . fmap) splitClauses $ splitResultRecord f sc)+ (return . Right . (:[]))+++-- | Tries to split the result to introduce an IApply pattern.+splitResultPath :: QName -> SplitClause -> TCM (Maybe SplitClause)+splitResultPath f sc@(SClause tel ps _ _ target) = do+ caseMaybe target (return Nothing) $ \ t -> do+ caseMaybeM (isPath (unDom t)) (return Nothing) $ \ _ -> do+ (TelV i b, boundary) <- telViewUpToPathBoundary' 1 (unDom t)+ let tel' = abstract tel i+ rho = raiseS 1+ ps' = applySubst rho (scPats sc) ++! telePatterns i boundary+ cps' = applySubst rho (scCheckpoints sc)+ target' = Just $ b <$ t+ return . Just $ SClause tel' ps' idS cps' target'++-- | @splitResultRecord f sc = return res@+--+-- If the target type of @sc@ is a record type, a covering set of+-- split clauses is returned (@sc@ extended by all valid projection patterns),+-- otherwise @res == Left _@.+-- Note that the empty set of split clauses is returned if the record has no fields.+splitResultRecord :: QName -> SplitClause -> TCM (Either SplitError Covering)+splitResultRecord f sc@(SClause tel ps _ _ target) = do+ reportSDoc "tc.cover.split" 10 $ vcat+ [ "splitting result:"+ , nest 2 $ "f =" <+> prettyTCM f+ , nest 2 $ "target =" <+> addContext tel (maybe empty prettyTCM target)+ ]+ -- if we want to split projections, but have no target type, we give up+ let failure = return . Left+ caseMaybe target (failure CosplitNoTarget) $ \ t -> do+ (addContext tel $ isRecordType $ unDom t) >>= \case+ Nothing -> addContext tel $ do+ failure . CosplitNoRecordType =<< buildClosure (unDom t)+ Just (_r, vs, RecordData{ _recFields = fs }) -> do+ reportSDoc "tc.cover" 20 $ sep+ [ text $ "we are of record type _r = " ++! prettyShow _r+ , text "applied to parameters vs =" <+> addContext tel (prettyTCM vs)+ , text $ "and have fields fs = " ++! prettyShow fs+ ]+ -- Andreas, 2018-06-09, issue #2170, we always have irrelevant projections+ -- available on the lhs.+ -- -- Andreas, 2018-03-19, issue #2971, check that we have a "strong" record type,+ -- -- i.e., with all the projections. Otherwise, we may not split.+ -- ifNotM (strongRecord fs) (failure CosplitIrrelevantProjections) $ {-else-} do+ let es = patternsToElims $ fromSplitPatterns ps+ -- Note: module parameters are part of ps+ let self = defaultArg $ Def f [] `applyE` es+ pargs = vs ++! [self]+ fieldValues = for fs $ \ proj -> unArg self `applyE` [Proj ProjSystem (unDom proj)]+ reportSDoc "tc.cover" 20 $ addContext tel $ sep+ [ text "we are self =" <+> prettyTCM (unArg self)+ , text " field values =" <+> prettyTCM fieldValues+ ]+ let n = defaultArg $ permRange $ fromMaybe __IMPOSSIBLE__ $ dbPatPerm $ fromSplitPatterns ps+ -- Andreas & James, 2013-11-19 includes the dot patterns!+ -- See test/succeed/CopatternsAndDotPatterns.agda for a case with dot patterns+ -- and copatterns which fails for @n = size tel@ with a broken case tree.++ -- Andreas, 2016-07-22 read the style of projections from the user's lips+ projOrigin <- ifM (optPostfixProjections <$> pragmaOptions) (return ProjPostfix) (return ProjPrefix)+ Right . Covering n <$> do+ forM (zip fs $ List.inits fieldValues) $ \ (proj, prevFields) -> do+ -- compute the new target+ dType <- defType <$> do getConstInfo $ unDom proj -- WRONG: typeOfConst $ unArg proj+ let -- Substitution for parameters and previous fields. Needs to be applied to potential+ -- tactic in proj.+ fieldSub = reverse (map' unArg vs ++! prevFields) ++# EmptyS impossible+ proj' = applySubst fieldSub proj+ -- type of projection instantiated at self+ target' = Just $ proj' $> dType `piApply` pargs -- Always visible (#2287)+ projArg = fmap (Named Nothing . ProjP projOrigin) $ argFromDom $ setHiding NotHidden proj+ sc' = sc { scPats = scPats sc ++! [projArg]+ , scSubst = idS+ , scTarget = target'+ }+ reportSDoc "tc.cover.copattern" 40 $ vcat+ [ "fieldSub for" <+> prettyTCM (unDom proj)+ , nest 2 $ pretty fieldSub ]+ return (SplitCon (unDom proj), (sc', NoInfo))+ -- Andreas, 2018-06-09, issue #2170: splitting with irrelevant fields is always fine!+ -- where+ -- -- A record type is strong if it has all the projections.+ -- -- This is the case if --irrelevant-projections or no field is irrelevant.+ -- -- TODO: what about shape irrelevance?+ -- strongRecord :: [Arg QName] -> TCM Bool+ -- strongRecord fs = (optIrrelevantProjections <$> pragmaOptions) `or2M`+ -- (return $ not $ any isIrrelevant fs)+++-- * Boring instances++-- | For debugging only.+instance PrettyTCM SplitClause where+ prettyTCM (SClause tel pats sigma cps target) = sep+ [ "SplitClause"+ , nest 2 $ vcat+ [ "tel =" <+> prettyTCM tel+ , "pats =" <+> sep (map' (prettyTCM . namedArg) pats)+ , "subst =" <+> prettyTCM sigma+ , "checkpoints =" <+> prettyTCM cps+ , "target =" <+> do+ caseMaybe target empty $ \ t -> do+ addContext tel $ prettyTCM t+ -- Triggers crash (see Issue 1374).+ -- , "subst target = " <+> do+ -- caseMaybe target empty $ \ t -> do+ -- addContext tel $ prettyTCM $ applySubst sigma t+ ]+ ]
@@ -0,0 +1,1153 @@+{-# LANGUAGE NondecreasingIndentation #-}++module Agda.TypeChecking.Coverage.Cubical where++import Prelude hiding (null, (!!)) -- do not use partial functions like !!++import Control.Monad.Except ( runExceptT )++import qualified Data.Set as Set+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet++import Agda.Syntax.Common hiding (DataOrRecord)+import Agda.Syntax.Position+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern+import Agda.Syntax.Common.Pretty (prettyShow)++import Agda.TypeChecking.Constraints () -- instance MonadConstraint TCM+import Agda.TypeChecking.Coverage.Match+import Agda.TypeChecking.Coverage.SplitClause+import Agda.TypeChecking.Coverage.SplitPattern+import Agda.TypeChecking.Coverage.SplitTree+import Agda.TypeChecking.Datatypes (getDatatypeArgs)+import Agda.TypeChecking.Irrelevance+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Names+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Primitive hiding (Nat)+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Telescope.Path++import Agda.Utils.Either ( fromRight )+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.List1 ( pattern (:|) )+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Permutation+import Agda.Utils.Singleton+import Agda.Utils.Size++import Agda.Utils.Impossible+++createMissingIndexedClauses ::+ QName+ -> Arg Nat+ -> BlockingVar+ -> SplitClause+ -> [(SplitTag,(SplitClause,IInfo))]+ -> [Clause]+ -> TCM ([(SplitTag,CoverResult)],[Clause])+createMissingIndexedClauses f n x old_sc scs cs = do+ let infos = [(c,i) | (SplitCon c, (_,TheInfo i)) <- scs ]+ case scs of+ xs | info:_ <- infos -> do+ reportSDoc "tc.cover.indexed" 20 $ text "size (xs,infos):" <+> pretty (size xs,size infos)+ reportSDoc "tc.cover.indexed" 20 $ text "xs :" <+> pretty (map fst xs)++ unless (size xs == 1 + size infos) $+ reportSDoc "tc.cover.indexed" 20 $ text "missing some infos"+ -- Andrea: what to do when we only managed to build a unification proof for some of the constructors?+ Constructor{conData} <- theDef <$> getConstInfo (fst info)+ Datatype{dataPars = pars, dataIxs = nixs, dataTranspIx} <- theDef <$> getConstInfo conData+ hcomp <- fromMaybe __IMPOSSIBLE__ <$> getName' builtinHComp+ trX <- fromMaybe __IMPOSSIBLE__ <$> pure dataTranspIx+ trX_cl <- createMissingTrXTrXClause trX f n x old_sc+ hcomp_cl <- createMissingTrXHCompClause trX f n x old_sc+ (trees,cls) <- fmap unzip . forM infos $ \ (c,i) -> do+ cl <- createMissingTrXConClause trX f n x old_sc c i+ return $ ((SplitCon c , SplittingDone (size $ clauseTel cl)) , cl)+ let extra = [ (SplitCon trX, SplittingDone $ size $ clauseTel trX_cl)+ , (SplitCon hcomp, SplittingDone $ size $ clauseTel hcomp_cl)+ ]+ -- = [ (SplitCon trX, SplittingDone $ size $ clauseTel trX_cl) ]+ extraCl = [trX_cl, hcomp_cl]+ -- = [trX_cl]+ let clauses = cls ++ extraCl+ let tree = SplitAt (n <&> (+ (pars + nixs + 1))) StrictSplit $+ trees+ ++ extra+ res = CoverResult+ { coverSplitTree = tree+ , coverUsedClauses = let l = length cs in IntSet.fromAscList [l .. l + length clauses - 1]+ , coverMissingClauses = []+ , coverPatterns = clauses+ , coverNoExactClauses = IntSet.empty+ }+ reportSDoc "tc.cover.indexed" 20 $+ "tree:" <+> pretty tree+ addClauses f clauses+ return ([(SplitCon trX, res)], cs ++ clauses)+ xs | otherwise -> return ([], cs)++covFillTele :: QName -> Abs Telescope -> Term -> Args -> Term -> TCM [Term]+covFillTele func tel face d j = do+ ed_f <- liftTCM $ runExceptT $ trFillTel tel face d j+ case ed_f of+ Right d_f -> pure $ map unArg d_f+ Left failed_t -> typeError $ CannotGenerateTransportClause func failed_t++createMissingTrXTrXClause ::+ QName -- ^ trX+ -> QName -- ^ f defined+ -> Arg Nat+ -> BlockingVar+ -> SplitClause+ -> TCM Clause+createMissingTrXTrXClause q_trX f n x old_sc = do+ let+ old_tel = scTel old_sc+ old_ps = fromSplitPatterns $ scPats old_sc+ old_t = fromMaybe __IMPOSSIBLE__ $ scTarget old_sc++ reportSDoc "tc.cover.trx.trx" 20 $ "trX-trX clause for" <+> prettyTCM f+ reportSDoc "tc.cover.trx.trx" 20 $ nest 2 $ vcat $+ [ "old_tel:" <+> prettyTCM old_tel+ , "old_ps :" <+> addContext old_tel (prettyTCM $ patternsToElims old_ps)+ , "old_t :" <+> addContext old_tel (prettyTCM old_t)+ ]++ -- TODO: redo comments, the strategy changed.+ -- old_tel = Γ1, (x : D η v), Δ+ -- α = boundary(old_ps)+ -- Γ1, (x : D η v), Δ ⊢ f old_ps : old_t [ α ↦ (f old_ps)[α] ]++ -- α' = boundary(old_ps[x = pat])+ -- Γ1, φ : I, p : Path X(η) _ v, ψ : I, q : Path X(η) _ (p i0), x0 : D η (q i0) ⊢ pat := trX p φ (trX q ψ x0) : D η v++ -- Ξ = Γ1, φ : I, p : Path X(η) _ v, ψ : I, q : Path X(η) _ (p i0), x0 : D η (q i0), Δ[x = pat]++ -- Ξ ⊢ w1 := f old_ps[γ1,x = pat,δ] : old_t[γ1,x = pat,δ] -- the case we are defining. can only be used if specialized.++ -- Ξ ⊢ rhs : old_t[γ1,x = pat,δ] [ α' ↦ w1[α']+ -- , φ ↦ w1[φ = i1, p = refl]+ -- , ψ ↦ w1[ψ = i1, q = refl]+ -- ]+ -- Ξ ⊢ q2 := tr (i. Path X(η) (q i0) (p i)) φ q : Path X(η) (q i0) (p i1)+ -- Ξ ⊢ pat_rec[0] = pat : D η v+ -- Ξ ⊢ pat_rec[1] = trX q2 (φ ∧ ψ) x0 : D η v+ -- Ξ ⊢ pat-rec[i] := trX (\ j → p (i ∨ j)) (i ∨ φ) (trX (q2_f i) (ψ ∧ (φ ∨ ~ i)) t)++ -- Ξ ⊢ δ_f[1] = tr (i. Δ[γ1,x = pat_rec[i]]) (φ ∧ ψ) δ+ -- Ξ ⊢ w0 := f old_ps[γ1,x = pat_rec[1] ,δ_f[1]] : old_t[γ1,x = pat_rec[1],δ_f[1]]+ -- Ξ ⊢ rhs := tr (i. old_t[γ1,x = pat_rec[~i], δ_f[~i]]) (φ ∧ ψ) w0 -- TODO plus sides.++ interval <- elInf primInterval+ iz <- primIZero+ io <- primIOne+ tHComp <- primHComp+ tNeg <- primINeg+ let neg i = pure tNeg <@> i+ let min i j = cl primIMin <@> i <@> j+ let max i j = cl primIMax <@> i <@> j+ let+ old_tel = scTel old_sc+ old_ps' = AbsN (teleNames old_tel) $ fromSplitPatterns $ scPats old_sc+ old_ps = pure $ old_ps'+ old_ty = pure $ AbsN (teleNames old_tel) $ fromMaybe __IMPOSSIBLE__ $ scTarget old_sc+ -- old_tel = Γ(x: D η v)Δ+ -- Γ1, (x : D η v) ⊢ delta = (δ : Δ)+ (gamma1x,delta') = splitTelescopeAt (size old_tel - blockingVarNo x) old_tel+ delta = pure $ AbsN (teleNames gamma1x) $ delta'+ gamma1_size = (size gamma1x - 1)+ (gamma1,ExtendTel dType' _) = splitTelescopeAt gamma1_size gamma1x++ old_sides <- forM old_ps' $ \ ps -> do+ let vs = iApplyVars ps+ let tm = Def f $ patternsToElims ps+ xs <- forM vs $ \ v ->+ -- have to reduce these under the appropriate substitutions, otherwise non-normalizing(?)+ fmap (var v,) . reduce $ (inplaceS v iz `applySubst` tm, inplaceS v io `applySubst` tm)+ return $ concatMap (\(v,(l,r)) -> [(tNeg `apply` [argN v],l),(v,r)]) xs+ let+ gamma1ArgNames = teleArgNames gamma1+ deltaArgNames = teleArgNames delta'+ (params,xTel,dT) <- addContext gamma1 $ do+ Just (d, ps, _is) <- getDatatypeArgs . unDom =<< reduce dType'+ def <- getConstInfo d+ let dTy = defType def+ let Datatype{dataSort = s} = theDef def+ TelV tel _ <- telView dTy+ let params = AbsN (teleNames gamma1) ps+ xTel = AbsN (teleNames gamma1) (tel `apply` ps)++ dT <- runNamesT [] $ do+ s <- open $ AbsN (teleNames tel) s+ bindNArg (teleArgNames gamma1) $ \ g1 -> do+ bindNArg (teleArgNames $ unAbsN xTel) $ \ x -> do+ params <- pure params `applyN` (fmap unArg <$> g1)+ x <- sequence x+ s <- s `applyN` map (pure . unArg) (params ++ x)+ pure $ El s $ Def d [] `apply` (params ++ x)+ return $ (params, xTel,dT)++ let+ xTelI = pure $ expTelescope interval <$> xTel+ xTelIArgNames = teleArgNames (unAbsN xTel) -- same names++ -- Γ1, φ, p, ψ, q, x0 ⊢ pat := trX p φ (trX q ψ x0)+ let trX' = bindNArg gamma1ArgNames $ \ g1 -> do+ bindNArg ([defaultArg "phi"] ++ xTelIArgNames) $ \ phi_p -> do+ bindNArg [defaultArg "x0"] $ \ x0 -> do+ param_args <- fmap (map (setHiding Hidden . fmap (unnamed . dotP))) $+ pure params `applyN` (fmap unArg <$> g1)+ (phi, p) <- fromMaybe __IMPOSSIBLE__ . uncons <$> sequence phi_p+ x0 <- sequence x0+ pure $ DefP defaultPatternInfo q_trX $ param_args ++ p ++ [phi] ++ x0+ trX = (fmap . fmap . fmap) patternToTerm <$> trX'+ let pat' =+ bindN (map unArg gamma1ArgNames) $ \ g1 -> do+ bindN (map unArg $ ([defaultArg "phi"] ++ xTelIArgNames)) $ \ phi_p -> do+ bindN (map unArg $ ([defaultArg "psi"] ++ xTelIArgNames)) $ \ psi_q -> do+ bindN (map unArg $ [defaultArg "x0"]) $ \ x0 -> do+ -- (phi:p) <- sequence phi_p+ -- (psi:q) <- sequence psi_q+ -- x0 <- sequence x0+ let trX = trX' `applyN` g1+ trX `applyN` phi_p `applyN` [trX `applyN` psi_q `applyN` x0]+ -- pure $ trX $ p ++ [phi, defaultArg $ unnamed $ trX $ q ++ [psi] ++ x0]+ pat = (fmap . fmap . fmap . fmap) patternToTerm <$> pat'+ let deltaPat g1 phi p psi q x0 =+ delta `applyN` (g1 ++ [pat `applyN` g1 `applyN` (phi:p) `applyN` (psi:q) `applyN` [x0]])+ -- Ξ+ cTel <- runNamesT [] $+ abstractN (pure gamma1) $ \ g1 -> do+ abstractT "φ" (pure interval) $ \ phi -> do+ abstractN (xTelI `applyN` g1) $ \ p -> do+ abstractT "ψ" (pure interval) $ \ psi -> do+ abstractN (xTelI `applyN` g1) $ \ q -> do+ abstractT "x0" (pure dT `applyN` g1 `applyN` for q (\ f -> f <@> pure iz)) $ \ x0 -> do+ deltaPat g1 phi p psi q x0++ ps_ty_rhs <- runNamesT [] $ do+ bindN (map unArg gamma1ArgNames) $ \ g1 -> do+ bind "φ" $ \ phi -> do+ bindN (map unArg xTelIArgNames) $ \ p -> do+ bind "ψ" $ \ psi -> do+ bindN (map unArg xTelIArgNames) $ \ q -> do+ bind "x0" $ \ x0 -> do+ bindN (map unArg deltaArgNames) $ \ d -> do+ let+ ps :: NamesT TCM NAPs+ ps = old_ps `applyN` (g1+ ++ [pat' `applyN` g1 `applyN` (phi:p) `applyN` (psi:q) `applyN` [x0]]+ ++ d)++ rhsTy = old_ty `applyN` (g1+ ++ [pat `applyN` g1 `applyN` (phi:p) `applyN` (psi:q) `applyN` [x0]]+ ++ d)++ xTel <- (open =<<) $ pure xTel `applyN` g1+ q4_f <- (open =<<) $ bind "i" $ \ i -> lamTel $ bind "j" $ \ j -> do+ ty <- bind "i" $ \ _ -> xTel+ face <- max phi $ max (neg j) (neg i)+ base <- map defaultArg <$> appTel (sequence q) j+ u <- liftM2 (,) (max j psi) $ bind "h" $ \ h -> do+ appTel (sequence p) (min j (min h i))+ xs <- fromRight __IMPOSSIBLE__ <$> do lift $ runExceptT $ transpSysTel' False ty [u] face base+ pure $ map unArg xs+ -- Ξ ⊢ pat_rec[0] = pat : D η v+ -- Ξ ⊢ pat_rec[1] = trX q4 (φ ∧ ψ) x0 : D η v+ -- Ξ ⊢ pat-rec[i] := trX (\ j → p (i ∨ j)) (i ∨ φ) (trX (q4_f i) (ψ ∧ (φ ∨ ~ i)) t)+ pat_rec <- (open =<<) $ bind "i" $ \ i -> do+ p_conn <- (mapM open =<<) $ lamTel $ bind "i" $ \ j -> sequence p `appTel` max i j+ q4_f' <- (mapM open =<<) $ absApp <$> q4_f <*> i+ trX `applyN` g1 `applyN` (max i phi:p_conn)+ `applyN` [trX `applyN` g1 `applyN` (min psi (max phi (neg i)):q4_f') `applyN` [x0]]++ let mkBndry args = do+ args1 <- (mapM open =<<) $ (absApp <$> args <*> pure io)+ -- faces ought to be constant on "j"+ faces <- pure (fmap (map fst) old_sides) `applyN` args1+ us <- forM (mapM (map snd) old_sides) $ \ u -> do+ lam "j" $ \ j -> ilam "o" $ \ _ -> do+ args <- (mapM open =<<) $ (absApp <$> args <*> j)+ pure u `applyN` args+ forM (zip faces us) $ \ (phi,u) -> liftM2 (,) (open phi) (open u)+ let mkComp pr = bind "i" $ \ i -> do+ d_f <- (open =<<) $ bind "j" $ \ j -> do+ tel <- bind "j" $ \ j -> delta `applyN` (g1 ++ [pr `applyN` [i,j]])+ face <- min phi psi `max` (min i (max phi psi))+ j <- j+ d <- map defaultArg <$> sequence d+ lift $ covFillTele f tel face d j+ let args = bind "j" $ \ j -> do+ g1 <- sequence g1+ x <- pr `applyN` [i,neg j]+ ys <- absApp <$> d_f <*> neg j+ pure $ g1 ++ x:ys+ ty <- (open =<<) $ bind "j" $ \ j -> do+ args <- (mapM open =<<) $ absApp <$> args <*> j+ fmap unDom $ old_ty `applyN` args+ let face = max i (min phi psi)+ base <- (open =<<) $ do+ args' <- (mapM open =<<) $ absApp <$> args <*> pure iz+ fmap (Def f) $ (fmap patternsToElims <$> old_ps) `applyN` args'+ sys <- mkBndry args+ transpSys ty sys face base++ -- Ξ ⊢ δ_f[1] = tr (i. Δ[γ1,x = pat_rec[i]]) (φ ∧ ψ) δ+ -- Ξ ⊢ w0 := f old_ps[γ1,x = pat_rec[1] ,δ_f[1]] : old_t[γ1,x = pat_rec[1],δ_f[1]]+ -- Ξ ⊢ rhs := tr (i. old_t[γ1,x = pat_rec[~i], δ_f[~i]]) (φ ∧ ψ) w0 -- TODO plus sides.+ syspsi <- (open =<<) $ lam "i" $ \ i -> ilam "o" $ \ _ -> do+ c <- mkComp $ bindN ["i","j"] $ \ [i,j] -> do+ res <- bind "k" $ \ k -> do+ let phi_k = max phi (neg k)+ let p_k = for p $ \ p -> lam "h" $ \ h -> p <@> (min k h)+ data_ty <- pure dT `applyN` g1 `applyN` for p (\ p -> p <@> k)+ line1 <- trX `applyN` g1 `applyN` (phi_k:p_k) `applyN` [x0]++ line2 <- trX `applyN` g1+ `applyN` (max phi_k j : for p_k (\ p -> lam "h" $ \ h -> p <@> (max h j)))+ `applyN`+ [trX `applyN` g1+ `applyN` (max phi_k (neg j): for p_k (\ p -> lam "h" $ \ h -> p <@> (min h j)))+ `applyN` [x0]]+ pure (data_ty, [line1, line2])+ case res of+ Abs n (data_ty, [line1, line2]) -> do+ data_ty <- open $ Abs n data_ty+ line1 <- open $ Abs n line1+ line2 <- open $ Abs n line2+ let sys = [(neg i, lam "k" $ \ k -> ilam "o" $ \ _ -> absApp <$> line2 <*> k)+ ,(neg j `max` j `max` i `max` phi, lam "k" $ \ k -> ilam "o" $ \ _ -> absApp <$> line1 <*> k)+ ]+ transpSys data_ty sys (pure iz) x0+ _ -> __IMPOSSIBLE__+ absApp <$> pure c <*> i+ sysphi <- (open =<<) $ lam "i" $ \ i -> ilam "o" $ \ o -> do+ c <- mkComp $ bindN ["i","j"] $ \ _ij -> do+ trX `applyN` g1 `applyN` (psi:q) `applyN` [x0]+ absApp <$> pure c <*> i+ syse <- mkBndry $ bind "j" $ \ _ -> sequence $ g1 ++ [absApp <$> pat_rec <*> pure iz] ++ d+ let sys = syse ++ [(phi,sysphi)] ++ [(psi,syspsi)]+ w0 <- (open =<<) $ do+ let w = mkComp (bindN ["i","j"] $ \ [_i, j] -> absApp <$> pat_rec <*> j)+ absApp <$> w <*> pure iz+ let rhs = hcomp (unDom <$> rhsTy) sys w0+ (,,) <$> ps <*> rhsTy <*> rhs+ let (ps,ty,rhs) = unAbsN $ unAbs $ unAbsN $ unAbs $ unAbsN $ unAbs $ unAbsN $ ps_ty_rhs+ reportSDoc "tc.cover.trx.trx" 20 $ "trX-trX clause for" <+> prettyTCM f+ let c = Clause { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = cTel+ , namedClausePats = ps+ , clauseBody = Just rhs+ , clauseType = Just $ Arg (getArgInfo ty) (unDom ty)+ , clauseCatchall = empty+ , clauseRecursive = YesRecursive+ , clauseUnreachable = Just False+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }+ debugClause "tc.cover.trx.trx" c+ return $ c++createMissingTrXHCompClause ::+ QName+ -> QName+ -> Arg Nat+ -> BlockingVar+ -> SplitClause+ -> TCM Clause+createMissingTrXHCompClause q_trX f n x old_sc = do+ let+ old_tel = scTel old_sc+ old_ps = fromSplitPatterns $ scPats old_sc+ old_t = fromMaybe __IMPOSSIBLE__ $ scTarget old_sc++ reportSDoc "tc.cover.trx.hcomp" 20 $ "trX-hcomp clause for" <+> prettyTCM f+ reportSDoc "tc.cover.trx.hcomp" 20 $ nest 2 $ vcat $+ [ "old_tel:" <+> prettyTCM old_tel+ , "old_ps :" <+> addContext old_tel (prettyTCM $ patternsToElims old_ps)+ , "old_t :" <+> addContext old_tel (prettyTCM old_t)+ ]++ -- old_tel = Γ1, (x : D η v), Δ+ -- α = boundary(old_ps)+ -- Γ1, (x : D η v), Δ ⊢ f old_ps : old_t [ α ↦ (f old_ps)[α] ]++ -- α' = boundary(old_ps[x = pat])+ -- Γ1, φ : I, p : Path X(η) _ v, ψ : I, u : I -> [ψ] → D η (p i0), u0 : D η (p i0) ⊢ pat := trX p φ (hcomp ψ u u0) : D η v++ -- Ξ = Γ1, φ : I, p : Path X(η) _ v, ψ : I, u : ..., u0 : D η (p i0), Δ[x = pat]++ -- Ξ ⊢ w1 := f old_ps[γ1,x = pat,δ] : old_t[γ1,x = pat,δ] -- the case we are defining. can only be used if specialized.++ -- Ξ ⊢ rhs : old_t[γ1,x = pat,δ] [ α' ↦ w1[α']+ -- , φ ↦ w1[φ = i1, p = refl] = f old_ps[γ1,x = hcomp ψ u u0 ,δ]+ -- , ψ ↦ w1[ψ = i1] = f old_ps[γ1,x = trX p φ (u i1 _),δ]+ -- ]++ -- Ξ ⊢ q2 := tr (i. Path X(η) (q i0) (p i)) φ q : Path X(η) (q i0) (p i1)+ -- Ξ ⊢ pat_rec[0] = pat : D η v+ -- Ξ ⊢ pat_rec[1] = trX q2 (φ ∧ ψ) x0 : D η v+ -- Ξ ⊢ pat-rec[i] := trX (\ j → q (i ∨ j)) (i ∨ φ) (trX (q2_f i) (ψ ∧ (φ ∨ ~ i)) t)++ -- Ξ ⊢ δ_f[1] = tr (i. Δ[γ1,x = pat_rec[i]]) (φ ∧ ψ) δ : Δ[γ1,x = pat_rec[1]]+ -- Ξ ⊢ w0 := f old_ps[γ1,x = pat_rec[1] ,δ_f[1]] : old_t[γ1,x = pat_rec[1],δ_f[1]]+ -- Ξ ⊢ rhs := tr (i. old_t[γ1,x = pat_rec[~i], δ_f[~i]]) (φ ∧ ψ) w0 -- TODO plus sides.++ q_hcomp <- fromMaybe __IMPOSSIBLE__ <$> getName' builtinHComp+ let+ old_tel = scTel old_sc+ old_ps = fromSplitPatterns $ scPats old_sc+ old_t = fromMaybe __IMPOSSIBLE__ $ scTarget old_sc++ reportSDoc "tc.cover.trx.trx" 20 $ "trX-trX clause for" <+> prettyTCM f+ reportSDoc "tc.cover.trx.trx" 20 $ nest 2 $ vcat $+ [ "old_tel:" <+> prettyTCM old_tel+ , "old_ps :" <+> addContext old_tel (prettyTCM $ patternsToElims old_ps)+ , "old_t :" <+> addContext old_tel (prettyTCM old_t)+ ]++ -- TODO: redo comments, the strategy changed.+ -- old_tel = Γ1, (x : D η v), Δ+ -- α = boundary(old_ps)+ -- Γ1, (x : D η v), Δ ⊢ f old_ps : old_t [ α ↦ (f old_ps)[α] ]++ -- α' = boundary(old_ps[x = pat])+ -- Γ1, φ : I, p : Path X(η) _ v, ψ : I, q : Path X(η) _ (p i0), x0 : D η (q i0) ⊢ pat := trX p φ (trX q ψ x0) : D η v++ -- Ξ = Γ1, φ : I, p : Path X(η) _ v, ψ : I, q : Path X(η) _ (p i0), x0 : D η (q i0), Δ[x = pat]++ -- Ξ ⊢ w1 := f old_ps[γ1,x = pat,δ] : old_t[γ1,x = pat,δ] -- the case we are defining. can only be used if specialized.++ -- Ξ ⊢ rhs : old_t[γ1,x = pat,δ] [ α' ↦ w1[α']+ -- , φ ↦ w1[φ = i1, p = refl]+ -- , ψ ↦ w1[ψ = i1, q = refl]+ -- ]+ -- Ξ ⊢ q2 := tr (i. Path X(η) (q i0) (p i)) φ q : Path X(η) (q i0) (p i1)+ -- Ξ ⊢ pat_rec[0] = pat : D η v+ -- Ξ ⊢ pat_rec[1] = trX q2 (φ ∧ ψ) x0 : D η v+ -- Ξ ⊢ pat-rec[i] := trX (\ j → p (i ∨ j)) (i ∨ φ) (trX (q2_f i) (ψ ∧ (φ ∨ ~ i)) t)++ -- Ξ ⊢ δ_f[1] = tr (i. Δ[γ1,x = pat_rec[i]]) (φ ∧ ψ) δ+ -- Ξ ⊢ w0 := f old_ps[γ1,x = pat_rec[1] ,δ_f[1]] : old_t[γ1,x = pat_rec[1],δ_f[1]]+ -- Ξ ⊢ rhs := tr (i. old_t[γ1,x = pat_rec[~i], δ_f[~i]]) (φ ∧ ψ) w0 -- TODO plus sides.++ interval <- elInf primInterval+ iz <- primIZero+ io <- primIOne+ tHComp <- primHComp+ tNeg <- primINeg+ let neg i = pure tNeg <@> i+ let min i j = cl primIMin <@> i <@> j+ let max i j = cl primIMax <@> i <@> j+ let+ old_tel = scTel old_sc+ old_ps' = AbsN (teleNames old_tel) $ fromSplitPatterns $ scPats old_sc+ old_ps = pure $ old_ps'+ old_ty = pure $ AbsN (teleNames old_tel) $ fromMaybe __IMPOSSIBLE__ $ scTarget old_sc+ -- old_tel = Γ(x: D η v)Δ+ -- Γ1, (x : D η v) ⊢ delta = (δ : Δ)+ (gamma1x,delta') = splitTelescopeAt (size old_tel - blockingVarNo x) old_tel+ delta = pure $ AbsN (teleNames gamma1x) $ delta'+ gamma1_size = (size gamma1x - 1)+ (gamma1,ExtendTel dType' _) = splitTelescopeAt gamma1_size gamma1x++ old_sides <- forM old_ps' $ \ ps -> do+ let vs = iApplyVars ps+ let tm = Def f $ patternsToElims ps+ xs <- forM vs $ \ v ->+ -- have to reduce these under the appropriate substitutions, otherwise non-normalizing(?)+ fmap (var v,) . reduce $ (inplaceS v iz `applySubst` tm, inplaceS v io `applySubst` tm)+ return $ concatMap (\(v,(l,r)) -> [(tNeg `apply` [argN v],l),(v,r)]) xs+ let+ gamma1ArgNames = teleArgNames gamma1+ deltaArgNames = teleArgNames delta'+ (params,xTel,dT) <- addContext gamma1 $ do+ Just (d, ps, _is) <- getDatatypeArgs . unDom =<< reduce dType'+ def <- getConstInfo d+ let dTy = defType def+ let Datatype{dataSort = s} = theDef def+ TelV tel _ <- telView dTy+ let params = AbsN (teleNames gamma1) ps+ xTel = AbsN (teleNames gamma1) (tel `apply` ps)++ dT <- runNamesT [] $ do+ s <- open $ AbsN (teleNames tel) s+ bindNArg (teleArgNames gamma1) $ \ g1 -> do+ bindNArg (teleArgNames $ unAbsN xTel) $ \ x -> do+ params <- pure params `applyN` (fmap unArg <$> g1)+ x <- sequence x+ s <- s `applyN` map (pure . unArg) (params ++ x)+ pure $ El s $ Def d [] `apply` (params ++ x)+ return $ (params, xTel,dT)++ let+ xTelI = pure $ expTelescope interval <$> xTel+ xTelIArgNames = teleArgNames (unAbsN xTel) -- same names++ -- Γ1, φ, p, ψ, q, x0 ⊢ pat := trX p φ (trX q ψ x0)+ let trX' = bindNArg gamma1ArgNames $ \ g1 -> do+ bindNArg ([defaultArg "phi"] ++ xTelIArgNames) $ \ phi_p -> do+ bindNArg [defaultArg "x0"] $ \ x0 -> do+ param_args <- fmap (map (setHiding Hidden . fmap (unnamed . dotP))) $+ pure params `applyN` (fmap unArg <$> g1)+ (phi, p) <- fromMaybe __IMPOSSIBLE__ . uncons <$> sequence phi_p+ x0 <- sequence x0+ pure $ DefP defaultPatternInfo q_trX $ param_args ++ p ++ [phi] ++ x0+ trX = (fmap . fmap . fmap) patternToTerm <$> trX'+ let+ hcompD' g1 v =+ bindNArg [argH "psi",argN "u", argN "u0"] $ \ x0 -> do+ x0 <- sequence x0+ LEl l t <- fromMaybe __IMPOSSIBLE__ <.> toLType =<< do pure dT `applyN` g1 `applyN` v+ let ty = map (fmap (unnamed . dotP) . argH) [Level l,t]+ pure $ DefP defaultPatternInfo q_hcomp $ ty ++ x0+ hcompD <- runNamesT [] $+ bindN (map unArg $ gamma1ArgNames) $ \ g1 -> do+ bindN (teleNames $ unAbsN $ xTel) $ \ v -> do+ fmap patternToTerm <$> hcompD' g1 v+ let pat' =+ bindN (map unArg gamma1ArgNames) $ \ g1 -> do+ bindN1 (fmap unArg (defaultArg "phi" :| xTelIArgNames)) $ \ phi_p -> do+ bindN ["psi","u","u0"] $ \ x0 -> do+ let trX = trX' `applyN` g1+ let p0 = for (List1.tail phi_p) $ \ p -> p <@> pure iz+ trX `applyN` (List1.toList phi_p) `applyN` [hcompD' g1 p0 `applyN` x0]+ pat = (fmap . fmap . fmap) patternToTerm <$> pat'+ let deltaPat g1 phi p x0 =+ delta `applyN` (g1 ++ [pat `applyN` g1 `applyN` (phi:p) `applyN` x0])+ -- Ξ+ cTel <- runNamesT [] $+ abstractN (pure gamma1) $ \ g1 -> do+ abstractT "φ" (pure interval) $ \ phi -> do+ abstractN (xTelI `applyN` g1) $ \ p -> do+ let p0 = for p $ \ p -> p <@> pure iz+ let ty = pure dT `applyN` g1 `applyN` p0+ abstractT "ψ" (pure interval) $ \ psi -> do+ abstractT "u" (pure interval --> pPi' "o" psi (\ _ -> ty)) $ \ u -> do+ abstractT "u0" ty $ \ u0 -> do+ deltaPat g1 phi p [psi,u,u0]++ ps_ty_rhs <- runNamesT [] $ do+ bindN (map unArg gamma1ArgNames) $ \ g1 -> do+ bind "φ" $ \ phi -> do+ bindN (map unArg xTelIArgNames) $ \ p -> do+ bind "ψ" $ \ psi -> do+ bind "u" $ \ u -> do+ bind "u0" $ \ u0 -> do+ bindN (map unArg deltaArgNames) $ \ d -> do+ let+ x0 :: Vars TCM+ x0 = [psi,u,u0]+ ps :: NamesT TCM NAPs+ ps = old_ps `applyN` (g1+ ++ [pat' `applyN` g1 `applyN` (phi:p) `applyN` x0]+ ++ d)++ rhsTy = old_ty `applyN` (g1+ ++ [pat `applyN` g1 `applyN` (phi:p) `applyN` x0]+ ++ d)++ xTel <- (open =<<) $ pure xTel `applyN` g1+ -- Ξ ⊢ pat-rec[i] := trX .. (hfill ... (~ i))+ pat_rec <- (open =<<) $ bind "i" $ \ i -> do+ let tr x = trX `applyN` g1 `applyN` (phi:p) `applyN` [x]+ let p0 = for p $ \ p -> p <@> pure iz+ tr (hcomp (pure dT `applyN` g1 `applyN` p0)+ [(psi,lam "j" $ \ j -> u <@> (min j (neg i)))+ ,(i ,lam "j" $ \ _ -> ilam "o" $ \ _ -> u0)]+ u0)+ -- args : (i.old_tel) -> ...+ let mkBndry args = do+ args1 <- (mapM open =<<) $ (absApp <$> args <*> pure io)+ -- faces ought to be constant on "j"+ faces <- pure (fmap (map fst) old_sides) `applyN` args1+ us <- forM (mapM (map snd) old_sides) $ \ u -> do+ lam "j" $ \ j -> ilam "o" $ \ _ -> do+ args <- (mapM open =<<) $ (absApp <$> args <*> j)+ pure u `applyN` args+ forM (zip faces us) $ \ (phi,u) -> liftM2 (,) (open phi) (open u)+ rhs <- do+ d_f <- (open =<<) $ bind "j" $ \ j -> do+ tel <- bind "j" $ \ j -> delta `applyN` (g1 ++ [absApp <$> pat_rec <*> j])+ let face = iz+ j <- j+ d <- map defaultArg <$> sequence d+ lift $ covFillTele f tel face d j+ let args = bind "j" $ \ j -> do+ g1 <- sequence g1+ x <- absApp <$> pat_rec <*> neg j+ ys <- absApp <$> d_f <*> neg j+ pure $ g1 ++ x:ys+ ty <- (open =<<) $ bind "j" $ \ j -> do+ args <- (mapM open =<<) $ absApp <$> args <*> j+ fmap unDom $ old_ty `applyN` args+ let face = pure iz+ othersys <- (open =<<) $ lam "j" $ \ j -> ilam "o" $ \ _ -> do+ args' <- (mapM open =<<) $ absApp <$> args <*> j+ fmap (Def f) $ (fmap patternsToElims <$> old_ps) `applyN` args'+ sys <- mkBndry args+ let+ -- we could specialize all of sysphi/syspsi/base to compute+ -- away trX or the hcomp respectively, should lead to+ -- smaller/more efficient terms.+ --+ -- we could also ditch sysphi completely,+ -- as the computation rule for hcomp would achieve the same.+ sysphi = othersys+ syspsi = othersys+ base <- (open =<<) $ do+ args' <- (mapM open =<<) $ absApp <$> args <*> pure iz+ fmap (Def f) $ (fmap patternsToElims <$> old_ps) `applyN` args'+ transpSys ty ((phi,sysphi):(psi,syspsi):sys) face base+ (,,) <$> ps <*> rhsTy <*> pure rhs+ let (ps,ty,rhs) = unAbsN $ unAbs $ unAbs $ unAbs $ unAbsN $ unAbs $ unAbsN $ ps_ty_rhs+ reportSDoc "tc.cover.trx.hcomp" 20 $ "trX-hcomp clause for" <+> prettyTCM f+ let c = Clause { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = cTel+ , namedClausePats = ps+ , clauseBody = Just rhs+ , clauseType = Just $ Arg (getArgInfo ty) (unDom ty)+ , clauseCatchall = empty+ , clauseRecursive = YesRecursive+ , clauseUnreachable = Just False+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }+ debugClause "tc.cover.trx.hcomp" c+ return c++createMissingTrXConClause ::+ QName -- trX+ -> QName -- f defined+ -> Arg Nat+ -> BlockingVar+ -> SplitClause+ -> QName -- constructor name+ -> UnifyEquiv+ -> TCM Clause+createMissingTrXConClause q_trX f n x old_sc c (UE gamma gamma' xTel u v rho tau leftInv) = do+ reportSDoc "tc.cover.trxcon" 20 $ "trX-con clause for" <+> prettyTCM f <+> "with con" <+> prettyTCM c+ reportSDoc "tc.cover.trxcon" 20 $ nest 2 $ vcat $+ [ "gamma" <+> prettyTCM gamma+ , "gamma'" <+> prettyTCM gamma'+ , "xTel" <+> addContext gamma (prettyTCM xTel)+ , "u" <+> addContext gamma (prettyTCM u)+ , "v" <+> addContext gamma (prettyTCM v)+ , "rho" <+> addContext gamma' (prettyTCM rho)+ , "tau" <+> pretty tau+ ]++ Constructor{conSrcCon = chead} <- theDef <$> getConstInfo c++ -- = TheInfo $ UE delta1' eqTel (map unArg conIxs) (map unArg givenIxs) rho0 tau leftInv++ -- η : Params_D ⊢ c : (a : Args(η)) → D η (ξ(η,a))++ -- scTel old_sc = Γ1, (x : D η v), Δ+ -- Γ1, (x : D η v), Δ ⊢ f old_ps : old_t [α(γ1,x,δ) ↦ e(γ1,x,δ)]++ -- Γ = Γ1, a : Args(η)+ -- Γ ⊢ u = ξ(η,a)+ -- Γ ⊢ c a : D η u++ -- Γ' ⊢ ρ : Γ++ -- Γ' ⊢ u[ρ] = v[ρ] : X(η)[ρ]++ -- Γ' ⊢ c a[ρ] : (D η v)[ρ]++ -- Γ' ⊢ ρx := ρ,x = c a[ρ] : Γ,(x : D η v)++ -- Γ',Δ[ρx] ⊢ old_t[ρx]+ -- Γ',Δ[ρx] ⊢ f old_ps[ρx] : old_t[ρx] [α[ρx] ↦ e[γ1,x,δ][ρx]]++ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ τ : Γ'++ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ [ρx][τ] = [ρ[τ], x = c a[ρ[τ]]] : Γ,(x : D η v)++ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ leftInv : ρ[τ],i1,refl ≡ idS : Γ,(φ : I),(p : Path X(η) u v)++ -- Γ,(φ : I),(p : Path X(η) u v)| (i : I) ⊢ leftInv i : Γ,(φ : I),(p : Path X(η) u v)++ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ leftInv i0 = ρ[τ],i1,refl : Γ,(φ : I),(p : Path X(η) u v)+ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ leftInv i1 = γ ,φ ,p : Γ,(φ : I),(p : Path X(η) u v)+ -- leftInv[φ = i1][i] = idS++ -- Γ,(φ : I),(p : Path X(η) u v),Δ[ρx][τ] ⊢ τ' = liftS |Δ[ρx]| τ : Γ',Δ[ρx]++ -- Γ,(φ : I),(p : Path X(η) u v),Δ[ρx][τ] ⊢+ -- w := f old_ps[γ1[ρ[τ]],x = c a[ρ[τ]],δ] : old_t[ρx][τ'] = old_t[γ1[ρ[τ]],x = c a[ρ[τ]],δ]++ -- Γ,(φ : I),(p : Path X(η) u v),Δ[ρx][τ], α(γ1,x,δ)[ρx][τ'] ⊢ w = e(γ1,x,δ)[ρx][τ']++ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ pat := trX p φ (c a) : D η v+++ -- Ξ := Γ,(φ : I),(p : Path X(η) u v),(δ : Δ[x = pat])++ -- Ξ ⊢ δ_f[1] = trTel (i. Δ[γ1[leftInv (~ i)], pat[leftInv (~i)]]) φ δ : Δ[ρ[τ], x = c a[ρ[τ]]]++ -- Ξ ⊢ w[δ_f[1]] : old_t[γ1[ρ[τ]],x = c a[ρ[τ]],δ_f[1]]+ -- Ξ, α(γ1,x,δ)[ρx][τ'][δ = δ_f[1]] ⊢ w[δ_f[1]] = e(γ1,x,δ)[ρx][τ'][δ_f[1]]++ -- Ξ, α(γ1[ρ[τ]],c a[ρ[τ]],δ_f[1]) ⊢ w[δ_f[1]] = e(γ1[ρ[τ]],c a[ρ[τ]],δ_f[1])++ -- Recap:+ -- Γ1, (x : D η v), Δ ⊢ f old_ps : old_t [α(γ1,x,δ) ↦ e(γ1,x,δ)]+ -- Ξ := Γ,(φ : I),(p : Path X(η) u v),(δ : Δ[x = pat])+ -- Ξ ⊢ δ_f[1] := trTel (i. Δ[γ1[leftInv (~ i)], pat[leftInv (~i)]]) φ δ : Δ[ρ[τ], x = c a[ρ[τ]]]+ -- Γ,(φ : I),(p : Path X(η) u v),Δ[ρx][τ] ⊢+ -- w := f old_ps[γ1[ρ[τ]],x = c a[ρ[τ]],δ] : old_t[ρx][τ'] = old_t[γ1[ρ[τ]],x = c a[ρ[τ]],δ]+ -- Γ,(φ : I),(p : Path X(η) u v) ⊢ pat := trX p φ (c a) : D η v+++ -- Ξ ⊢ ?rhs : old_t[γ1,x = pat,δ] [α(γ1,pat,δ) ↦ e(γ1,pat,δ)+ -- ,φ ↦ w+ -- ]++ -- ?rhs := transp (i. old_t[γ1[leftInv i],x = pat[leftInv i], δ_f[~i]]) φ (w[δ_f[1]])++ -- we shall consider α(γ1,pat,δ) = α(γ1[ρ[τ]],c a[ρ[τ]],δ_f[1])+ -- also rather than (p : Path X(η) u v) we'll have (p : I -> X(η)), same as the type of trX.++ iz <- primIZero+ interval <- elInf primInterval+ let+ old_tel = scTel old_sc+ old_ps = pure $ AbsN (teleNames old_tel) $ fromSplitPatterns $ scPats old_sc+ old_ty = pure $ AbsN (teleNames old_tel) $ fromMaybe __IMPOSSIBLE__ $ scTarget old_sc+ -- old_tel = Γ(x: D η v)Δ+ -- Γ1, (x : D η v) ⊢ delta = (δ : Δ)+ (gamma1x,delta') = splitTelescopeAt (size old_tel - blockingVarNo x) old_tel+ let+ gammaArgNames = teleArgNames gamma+ deltaArgNames = teleArgNames delta'+ let+ xTelI = pure $ AbsN (teleNames gamma) $ expTelescope interval xTel+ delta = pure $ AbsN (teleNames gamma1x) $ delta'+ gamma1_size = (size gamma1x - 1)+ (gamma1,ExtendTel dType' _) = splitTelescopeAt gamma1_size gamma1x+ params <- addContext gamma1 $ do+ Just (_d, ps, _is) <- getDatatypeArgs . unDom =<< reduce dType'+ return $ AbsN (teleNames gamma1) ps+ -- Γ, φ , p ⊢ pat := trX p φ (c a)+ let pat' =+ bindNArg gammaArgNames $ \ g1_args -> do+ bindNArg ([defaultArg "phi"] ++ teleArgNames xTel) $ \ phi_p -> do+ let (g1,args) = splitAt gamma1_size g1_args+ (phi, p) <- fromMaybe __IMPOSSIBLE__ . uncons <$> sequence phi_p+ args <- sequence args+ let cargs = defaultArg $ unnamed $ ConP chead noConPatternInfo args+ -- Amy (2022-11-06): Set the parameters to quantity-0.+ param_args <- fmap (map (setQuantity (Quantity0 Q0Inferred) . setHiding Hidden . fmap (unnamed . dotP))) $+ pure params `applyN` take gamma1_size (fmap unArg <$> g1_args)+ pure $ DefP defaultPatternInfo q_trX $ param_args ++ p ++ [phi,cargs]+ pat = (fmap . fmap) patternToTerm <$> pat'+ pat_left' = (fmap . fmap) (Abs "i" . (applySubst leftInv)) <$> pat+ g1_left' = bindN (map unArg gammaArgNames) $ \ g1_args -> do+ bindN (map unArg $ [defaultArg "phi"] ++ teleArgNames xTel) $ \ phi_p -> do+ g1 <- sequence $ take gamma1_size g1_args :: NamesT TCM [Term]+ pure $ Abs "i" (applySubst leftInv g1)++ gamma <- return $ pure gamma+ let deltaPat g1_args phi p =+ delta `applyN` (take gamma1_size g1_args ++ [pat `applyN` g1_args `applyN` (phi:p)])+ let neg i = cl primINeg <@> i+ -- Ξ+ cTel <- runNamesT [] $+ abstractN gamma $ \ g1_args -> do+ abstractT "φ" (pure interval) $ \ phi -> do+ abstractN (xTelI `applyN` g1_args) $ \ p -> do+ deltaPat g1_args phi p+ ps_ty_rhs <- runNamesT [] $ do+ bindN (map unArg gammaArgNames) $ \ g1_args -> do+ bind "phi" $ \ phi -> do+ bindN (teleNames xTel) $ \ p -> do+ bindN (map unArg $ deltaArgNames) $ \ d -> do+ let+ g1_left = g1_left' `applyN` g1_args `applyN` (phi:p)+ pat_left = pat_left' `applyN` g1_args `applyN` (phi:p)+ g1 :: Vars TCM+ g1 = take gamma1_size g1_args++ args :: Vars TCM+ args = drop gamma1_size g1_args++ ps :: NamesT TCM NAPs+ ps = old_ps `applyN` (g1 ++ [pat' `applyN` g1_args `applyN` (phi:p)] ++ d)++ rhsTy = old_ty `applyN` (g1 ++ [pat `applyN` g1_args `applyN` (phi:p)] ++ d)++ -- (i. Δ[γ1[leftInv (~ i)], pat[leftInv (~i)]])+ delta_f <- (open =<<) $ bind "i" $ \ i -> do+ let ni = neg i+ dargs <- (mapM open =<<) $ do+ xs <- absApp <$> g1_left <*> ni+ y <- absApp <$> pat_left <*> ni+ return $ xs ++ [y]+ delta `applyN` dargs++ -- trFillTel (i. Δ[γ1[leftInv (~ i)], pat[leftInv (~i)]]) φ δ+ d_f <- (open =<<) $ bind "i" $ \ i -> do+ delta_f <- delta_f+ phi <- phi+ d <- map defaultArg <$> sequence d+ i <- i+ lift $ covFillTele f delta_f phi d i++ -- w = Def f (old_ps[g1_left[i],pat_left[i],d_f[~ i]])+ w <- (open =<<) $ bind "i" $ \ i -> do+ psargs <- (mapM open =<<) $ do+ xs <- absApp <$> g1_left <*> i+ y <- absApp <$> pat_left <*> i+ zs <- absApp <$> d_f <*> neg i+ return $ xs ++ [y] ++ zs+ ps <- (fmap patternsToElims <$> old_ps) `applyN` psargs+ pure $ Def f ps+++ -- (i. old_t[γ1[leftInv i],x = pat[leftInv i], δ_f[~i]])+ ty <- (open =<<) $ bind "i" $ \ i -> do+ tyargs <- (mapM open =<<) $ do+ xs <- absApp <$> g1_left <*> i+ y <- absApp <$> pat_left <*> i+ zs <- absApp <$> d_f <*> neg i+ return $ xs ++ [y] ++ zs+ fmap unDom $ old_ty `applyN` tyargs++ sys <- do+ sides <- do+ neg <- primINeg+ io <- primIOne+ vs <- iApplyVars <$> ps+ tm <- w+ xs <- forM vs $ \ v ->+ -- have to reduce these under the appropriate substitutions, otherwise non-normalizing(?)+ fmap (var v,) . reduce $ (inplaceS v iz `applySubst` tm, inplaceS v io `applySubst` tm)+ return $ concatMap (\(v,(l,r)) -> [(neg `apply` [argN v],l),(v,r)]) xs+ forM sides $ \ (psi,u') -> do+ u' <- open u'+ u <- lam "i" $ \ i -> ilam "o" $ \ o -> absApp <$> u' <*> i+ (,) <$> open psi <*> open u++ let rhs = transpSys ty sys phi (absApp <$> w <*> pure iz)++ (,,) <$> ps <*> rhsTy <*> rhs++ let (ps,ty,rhs) = unAbsN $ unAbsN $ unAbs $ unAbsN $ ps_ty_rhs+ qs <- mapM (fmap (fromMaybe __IMPOSSIBLE__) . getName') [builtinINeg, builtinIMax, builtinIMin]+ rhs <- addContext cTel $+ locallyReduceDefs (OnlyReduceDefs (Set.fromList $ q_trX : qs)) $ normalise rhs+ let cl = Clause { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = cTel+ , namedClausePats = ps+ , clauseBody = Just rhs+ , clauseType = Just $ Arg (getArgInfo ty) (unDom ty)+ , clauseCatchall = empty+ , clauseRecursive = YesRecursive+ , clauseUnreachable = Just False+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }+++ debugClause "tc.cover.trxcon" cl++ reportSDoc "tc.cover.trxcon" 20 $ vcat $+ [ "clause:"+ , nest 2 $ prettyTCM . QNamed f $ cl+ ]++ let dom =+ setRelevance irrelevant $ -- See #5611.+ fromMaybe __IMPOSSIBLE__ $ scTarget old_sc+ mod = getModality dom+ -- we follow what `cover` does when updating the modality from the target.+ applyDomToContext dom $ do+ unlessM (hasQuantity0 <$> viewTC eQuantityZeroHardCompile) $ do+ reportSDoc "tc.cover.trxcon" 20 $ text "testing usable at mod: " <+> pretty mod+ addContext cTel $ usableAtModality IndexedClause mod rhs++ return cl++{-+ OLD leftInv case+ -- Γ,(φ : I),(p : Path A u v) ⊢ leftInv : ρ[τ] ≡ wkS 2 : Γ+ -- Γ,(φ : I),(p : Path A u v)(i : I) ⊢ leftInv i : Γ+ -- Γ,(φ : I),(p : Path A u v) ⊢ leftInv i0 = ρ[τ] : Γ+ -- Γ,(φ : I),(p : Path A u v) ⊢ leftInv i1 = wkS 2 : Γ+ -- leftInv[φ = i1][i] = wkS 2++ -- Γ,(φ : I),(p : Path A u v),Δ[ρ,x = refl][τ] ⊢ τ' = liftS |Δ[ρ,x = refl]| τ : Γ',Δ[ρ,x = refl]++ -- Γ,(φ : I),(p : Path A u v),Δ[ρ,x = refl][τ] ⊢ w = f old_ps[ρ,x = refl][τ'] : old_t[ρ,x = refl][τ']++ -- Γ,(φ : I),(p : Path A u v) | (i : I) ⊢ μ = ⟨ (φ ∨ ~ i) , (\ j → p (i ∧ j)) ⟩ : Id A u (p i) =?= (Id A u v)[leftInv (~ i)]+ μ[0] = ⟨ 1 , (\ _ → u[ρ[τ]]) ⟩+ μ[1] = ⟨ φ , p ⟩+ -- Γ,(φ : I),(p : Path A u v),(δ : Δ[x = ⟨ φ , p ⟩]) ⊢ vecTransp (i. Δ[leftInv (~ i),μ[i]]) φ δ : Δ[ρ[τ], x = refl u[ρ[τ]]]+-}++-- | Append an hcomp clause to the clauses of a function.+createMissingHCompClause ::+ QName+ -- ^ Function name.+ -> Arg Nat+ -- ^ index of hcomp pattern+ -> BlockingVar+ -- ^ Blocking var that lead to hcomp split.+ -> SplitClause+ -- ^ Clause before the hcomp split+ -> SplitClause+ -- ^ Clause to add.+ -> [Clause]+ -> TCM ([(SplitTag,CoverResult)], [Clause])+createMissingHCompClause f n x old_sc (SClause tel ps _sigma' _cps (Just t)) cs = setCurrentRange f $ do+ reportSDoc "tc.cover.hcomp" 20 $ addContext tel $ text "Trying to create right-hand side of type" <+> prettyTCM t+ reportSDoc "tc.cover.hcomp" 30 $ addContext tel $ text "ps = " <+> prettyTCMPatternList (fromSplitPatterns ps)+ reportSDoc "tc.cover.hcomp" 30 $ text "tel = " <+> prettyTCM tel++ io <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinIOne+ iz <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinIZero+ let+ cannotCreate :: MonadTCError m => Doc -> Closure (Abs Type) -> m a+ cannotCreate doc t = do+ typeError . SplitError $ CannotCreateMissingClause f (tel,fromSplitPatterns ps) doc t+ let old_ps = patternsToElims $ fromSplitPatterns $ scPats old_sc+ old_t = fromJust $ scTarget old_sc+ old_tel = scTel old_sc+ -- old_tel = Γ(x:H)Δ+ -- Γ(x:H)Δ ⊢ old_t+ -- vs = iApplyVars old_ps+ -- [ α ⇒ b ] = [(i,f old_ps (i=0),f old_ps (i=1)) | i <- vs]++ -- Γ(x:H)(δ : Δ) ⊢ [ α ⇒ b ]+ -- Γ(x:H)Δ ⊢ f old_ps : old_t [ α ⇒ b ]+ -- Γ,φ,u,u0,Δ(x = hcomp φ u u0) ⊢ rhs_we_define : (old_t[ α ⇒ b ])(x = hcomp φ u u0)++ -- Extra assumption:+ -- tel = Γ,φ,u,u0,Δ(x = hcomp φ u u0),Δ'+ -- ps = old_ps[x = hcomp φ u u0],ps'+ -- with Δ' and ps' introduced by fixTarget.+ -- So final clause will be:+ -- tel ⊢ ps ↦ rhs_we_define{wkS ..} ps'++ getLevel t = do+ s <- reduce $ getSort t+ case s of+ Type l -> pure (Level l)++ -- Impossible since we only have HITs in Type:+ s -> do+ reportSDoc "tc.cover.hcomp" 20 $ vcat+ [ "sort of blocking variable when creating hcomp clause is not Type"+ , nest 2 ("t =" <+> prettyTCM t)+ , nest 2 ("s =" <+> prettyTCM s)+ , ""+ , "clause:"+ , nest 2 $ prettyTCM (QNamed f empty{ clauseTel = tel, namedClausePats = fromSplitPatterns ps })+ ]+ __IMPOSSIBLE__++ -- Γ ⊢ hdelta = (x : H)(δ : Δ)+ (gamma,hdelta@(ExtendTel hdom delta)) = splitTelescopeAt (size old_tel - (blockingVarNo x + 1)) old_tel++ -- Γ,φ,u,u0,Δ(x = hcomp φ u u0) ⊢+ (working_tel,_deltaEx) = splitTelescopeAt (size gamma + 3 + size delta) tel++ -- Γ,φ,u,u0,(x:H)(δ : Δ) ⊢ rhoS : Γ(x:H)(δ : Δ)+ {- rhoS = liftS (size hdelta) $ raiseS 3 -}+ vs = iApplyVars (scPats old_sc)++ -- Γ(x:H)(δ : Δ) ⊢ [ α ⇒ b ] = [(i,f old_ps (i=0),f old_ps (i=1)) | i <- vs]+ alphab <- forM vs $ \ i -> do+ let+ -- Γ(x:H)(δ : Δ) ⊢+ tm = Def f old_ps+ -- TODO only reduce IApply _ _ (0/1), as to avoid termination problems+ (l,r) <- reduce (inplaceS i iz `applySubst` tm, inplaceS i io `applySubst` tm)+ return $ (var i, (l, r))++++ cl <- do+ (ty,rhs) <- addContext working_tel $ do+ -- Γ(x:H)Δ ⊢ g = f old_ps : old_t [ α ⇒ b ]+ -- Γ(x:H)(δ : Δ) ⊢ [ α ⇒ b ]+ -- Γ,φ,u,u0 ⊢ Δf = i.Δ[x = hfill φ u u0 i]+ -- Γ,φ,u,u0,δ : Δ(x = hcomp φ u u0) ⊢ δ_fill = i.tFillTel (i. Δf[~i]) δ (~ i) : i.Δf[i]+ -- Γ,φ,u,u0,δ : Δ(x = hcomp φ u u0) ⊢ old_t_fill = i.old_t[x = hfill φ u u0 i, δ_fill[i]]+ -- Γ,φ,u,u0,δ : Δ(x = hcomp φ u u0) ⊢ comp (\ i. old_t_fill[i])+ -- (\ i. [ φ ↦ g[x = hfill φ u u0 i,δ_fill[i]] = g[u i,δ_fill[i]]+ -- α ↦ b[x = hfill φ u u0 i,δ_fill[i]]+ -- ])+ -- (g[x = u0,δ_fill[0]]) : old_t[x = hcomp φ u u0,δ]++ runNamesT [] $ do+ tPOr <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinPOr+ tIMax <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinIMax+ tIMin <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinIMin+ tINeg <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinINeg+ tHComp <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinHComp+ tTrans <- fromMaybe __IMPOSSIBLE__ <$> getTerm' builtinTrans+ extra_ps <- open $ patternsToElims $ fromSplitPatterns $ drop (length old_ps) ps+ let+ ineg j = pure tINeg <@> j+ imax i j = pure tIMax <@> i <@> j+ trFillTel' a b c d = do+ m <- trFillTel <$> a <*> b <*> c <*> d+ x <- lift $ runExceptT m+ case x of+ Left bad_t -> cannotCreate "Cannot transport with type family:" bad_t+ Right args -> return args+ comp <- mkCompLazy "hcompClause"+ let+ hcomp la bA phi u u0 = pure tHComp <#> la <#> bA+ <#> phi+ <@> u+ <@> u0++ hfill la bA phi u u0 i = hcomp la bA+ (pure tIMax <@> phi <@> (pure tINeg <@> i))+ (lam "j" $ \ j -> pure tPOr <#> la <@> phi <@> (pure tINeg <@> i) <#> ilam "o" (\ _ -> bA)+ <@> ilam "o" (\ o -> u <@> (pure tIMin <@> i <@> j) <..> o)+ <@> ilam "o" (\ _ -> u0)+ )+ u0+ -- Γ,φ,u,u0,(δ : Δ(x = hcomp φ u u0)) ⊢ hcompS : Γ(x:H)(δ : Δ)+ hcompS <- lift $ do+ hdom <- pure $ raise 3 hdom+ let+ [phi,u,u0] = map (pure . var) [2,1,0]+ htype = pure $ unEl . unDom $ hdom+ lvl = getLevel $ unDom hdom+ hc <- pure tHComp <#> lvl <#> htype+ <#> phi+ <@> u+ <@> u0+ return $ liftS (size delta) $ hc `consS` raiseS 3+ -- Γ,φ,u,u0,Δ(x = hcomp phi u u0) ⊢ raise 3+|Δ| hdom+ hdom <- pure $ raise (3 + size delta) hdom+ htype <- open $ unEl . unDom $ hdom+ lvl <- open =<< (lift . getLevel $ unDom hdom)++ -- Γ,φ,u,u0,Δ(x = hcomp phi u u0) ⊢+ let vr = open . raise (size delta) . var+ phi <- vr 2+ u <- vr 1+ u0 <- vr 0+ -- Γ,x,Δ ⊢ f old_ps+ -- Γ ⊢ abstract hdelta (f old_ps)+ g <- open $ raise (3 + size delta) $ abstract hdelta (Def f old_ps)+ old_t <- open $ raise (3 + size delta) $ abstract hdelta (unDom old_t)+ let bapp a x = lazyAbsApp <$> a <*> x+ (delta_fill :: NamesT TCM (Abs Args)) <- (open =<<) $ do+ -- Γ,φ,u,u0,Δ(x = hcomp phi u u0) ⊢ x.Δ+ delta <- open $ raise (3 + size delta) delta+ -- Γ,φ,u,u0,Δ(x = hcomp phi u u0) ⊢ i.Δ(x = hfill phi u u0 (~ i))+ deltaf <- open =<< bind "i" (\ i ->+ (delta `bapp` hfill lvl htype phi u u0 (ineg i)))+ -- Γ,φ,u,u0,Δ(x = hcomp phi u u0) ⊢ Δ(x = hcomp phi u u0) = Δf[0]+ args <- (open =<<) $ teleArgs <$> (lazyAbsApp <$> deltaf <*> pure iz)+ bind "i" $ \ i -> addContext ("i" :: String) $ do -- for error messages.+ -- Γ,φ,u,u0,Δ(x = hcomp phi u u0),(i:I) ⊢ ... : Δ(x = hfill phi u u0 i)+ trFillTel' deltaf (pure iz) args (ineg i)+ let+ apply_delta_fill i f = apply <$> f <*> (delta_fill `bapp` i)+ call v i = apply_delta_fill i $ g <@> v+ ty <- do+ return $ \ i -> do+ v <- hfill lvl htype phi u u0 i+ hd <- old_t+ args <- delta_fill `bapp` i+ lift $ piApplyM hd $ Arg (domInfo hdom) v : args+ ty_level <- do+ t <- bind "i" $ \ x -> ty x+ s <- reduce $ getSort (absBody t)+ reportSDoc "tc.cover.hcomp" 20 $ text "ty_level, s = " <+> prettyTCM s+ case s of+ Type l -> open =<< lam "i" (\ _ -> pure $ Level l)+ _ -> do cl <- liftTCM (buildClosure t)+ liftTCM (cannotCreate "Cannot compose with type family:" cl)++ let+ pOr_ty i phi psi u0 u1 = pure tPOr <#> (ty_level <@> i)+ <@> phi <@> psi+ <#> ilam "o" (\ _ -> unEl <$> ty i) <@> u0 <@> u1+ alpha <- do+ vars <- mapM (open . applySubst hcompS . fst) alphab+ return $ foldr (imax . (\ v -> v `imax` ineg v)) (pure iz) vars++ -- Γ,φ,u,u0,Δ(x = hcomp φ u u0) ⊢ b : (i : I) → [α] -> old_t[x = hfill φ u u0 i,δ_fill[i]]+ b <- do+ sides <- forM alphab $ \ (psi,(side0,side1)) -> do+ psi <- open $ hcompS `applySubst` psi+ let f = open . raise (3 + size delta) . abstract hdelta+ side0 <- f side0+ side1 <- f side1+ return $ (ineg psi `imax` psi, \ i -> pOr_ty i (ineg psi) psi (ilam "o" $ \ _ -> apply_delta_fill i $ side0 <@> hfill lvl htype phi u u0 i)+ (ilam "o" $ \ _ -> apply_delta_fill i $ side1 <@> hfill lvl htype phi u u0 i))+ let recurse [] i = __IMPOSSIBLE__+ recurse [(psi,u)] i = u i+ recurse ((psi,u):xs) i = pOr_ty i psi (foldr (imax . fst) (pure iz) xs) (u i) (recurse xs i)+ return $ recurse sides++ ((,) <$> ty (pure io) <*>) $ do+ comp ty_level+ (lam "i" $ fmap unEl . ty)+ (phi `imax` alpha)+ (lam "i" $ \ i ->+ let rhs = (ilam "o" $ \ o -> call (u <@> i <..> o) i)+ in if null alphab then rhs else+ pOr_ty i phi alpha rhs (b i)+ )+ (call u0 (pure iz))+ reportSDoc "tc.cover.hcomp" 20 $ text "old_tel =" <+> prettyTCM tel+ let n = size tel - (size gamma + 3 + size delta)+ reportSDoc "tc.cover.hcomp" 20 $ text "n =" <+> text (show n)+ (TelV deltaEx t,bs) <- telViewUpToPathBoundary' n ty+ rhs <- pure $ raise n rhs `applyE` teleElims deltaEx bs++ cxt <- getContextTelescope+ reportSDoc "tc.cover.hcomp" 30 $ text "cxt = " <+> prettyTCM cxt+ reportSDoc "tc.cover.hcomp" 30 $ text "tel = " <+> prettyTCM tel+ reportSDoc "tc.cover.hcomp" 20 $ addContext tel $ text "t = " <+> prettyTCM t+ reportSDoc "tc.cover.hcomp" 20 $ addContext tel $ text "rhs = " <+> prettyTCM rhs++ return $ Clause { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = tel+ , namedClausePats = fromSplitPatterns ps+ , clauseBody = Just $ rhs+ , clauseType = Just $ defaultArg t+ , clauseCatchall = empty+ , clauseRecursive = MaybeRecursive -- TODO: can it be recursive?+ , clauseUnreachable = Just False -- missing, thus, not unreachable+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }+ addClauses f [cl] -- Important: add at the end.+ let result = CoverResult+ { coverSplitTree = SplittingDone (size (clauseTel cl))+ , coverUsedClauses = IntSet.singleton (length cs)+ , coverMissingClauses = []+ , coverPatterns = [cl]+ , coverNoExactClauses = IntSet.empty+ }+ hcompName <- fromMaybe __IMPOSSIBLE__ <$> getName' builtinHComp+ return ([(SplitCon hcompName, result)], cs ++ [cl])+createMissingHCompClause _ _ _ _ (SClause _ _ _ _ Nothing) _ = __IMPOSSIBLE__
@@ -1,113 +1,397 @@-{-# LANGUAGE CPP, DeriveFunctor #-} -module Agda.TypeChecking.Coverage.Match where+{-| Given -import Control.Applicative-import Control.Monad.State-import Data.Monoid-import Data.Traversable (traverse)-import Data.Function+ 1. the function clauses @cs@+ 2. the patterns @ps@ of the split clause +we want to compute a variable index (in the split clause) to split on next.++The matcher here checks whether the split clause is covered by one of+the given clauses @cs@ or whether further splitting is needed (and+when yes, where).+-}++module Agda.TypeChecking.Coverage.Match+ ( Match(..), match, matchClause+ , BlockingVar(..), BlockingVars, BlockedOnResult(..)+ , setBlockingVarOverlap+ , ApplyOrIApply(..)+ ) where++import Prelude hiding ( null )++import Data.DList (DList)+import Data.Foldable (toList)+import qualified Data.List as List+import Data.Maybe (mapMaybe, fromMaybe)+ import Agda.Syntax.Common import Agda.Syntax.Internal-import Agda.Syntax.Internal.Pattern import Agda.Syntax.Literal -import Agda.Utils.Permutation-import Agda.Utils.Size+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Coverage.SplitPattern+import Agda.TypeChecking.Pretty ( PrettyTCM(..) )+import Agda.TypeChecking.Records+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute -#include "../../undefined.h"+import Agda.Utils.List+import Agda.Utils.Null+import Agda.Syntax.Common.Pretty ( Pretty(..), text, (<+>), cat , prettyList_ )+import Agda.Utils.Monad+import Agda.Utils.Singleton+ import Agda.Utils.Impossible+import Agda.Syntax.Position (KillRange, killRange, killRangeN) --- | We use a special representation of the patterns we're trying to match--- against a clause. In particular we want to keep track of which variables--- are blocking a match.-data MPat = VarMP Nat | ConMP QName [Arg MPat] | LitMP Literal | WildMP+-- | If matching is inconclusive (@Block@) we want to know which+-- variables or projections are blocking the match.+data Match a+ = Yes a -- ^ Matches unconditionally.+ | No -- ^ Definitely does not match.+ | Block+ { blockedOnResult :: BlockedOnResult+ -- ^ @BlockedOnProj o@ if the clause has a result split.+ , blockedOnVars :: BlockingVars+ -- ^ @BlockingVar i cs ls o@ means variable @i@ is blocked on+ -- constructors @cs@ and literals @ls@.+ }+ deriving (Functor) -buildMPatterns :: Permutation -> [Arg Pattern] -> [Arg MPat]-buildMPatterns perm ps = evalState (mapM (traverse build) ps) xs+-- | Missing elimination blocking a match.+data BlockedOnResult+ = BlockedOnProj -- ^ Blocked on unsplit projection.+ { blockedOnResultOverlap :: Bool+ -- ^ True if there are also matching clauses without an unsplit+ -- copattern.+ }+ | BlockedOnApply -- ^ Blocked on unintroduced argument.+ { blockedOnResultIApply :: ApplyOrIApply+ -- ^ Is the unintroduced argument an 'IApply' pattern?+ }+ | NotBlockedOnResult++data ApplyOrIApply = IsApply | IsIApply++-- | Variable blocking a match.+data BlockingVar = BlockingVar+ { blockingVarNo :: Nat+ -- ^ De Bruijn index of variable blocking the match.+ , blockingVarCons :: [ConHead]+ -- ^ Constructors in this position.+ , blockingVarLits :: [Literal]+ -- ^ Literals in this position.+ , blockingVarOverlap :: Bool+ -- ^ True if at least one clause has a variable pattern in this+ -- position.+ , blockingVarLazy :: Bool+ -- ^ True if at least one clause has a lazy pattern in this position.+ } deriving (Show)++type BlockingVars = [BlockingVar]++-- | Substitution of 'SplitPattern's for de Bruijn indices in covering+-- clause to match 'SplitClause'.+type SplitInstantiation = [(Nat,SplitPattern)]++{-# SPECIALIZE match :: [Clause] -> [NamedArg SplitPattern] -> TCM (Match (Nat, SplitInstantiation)) #-}+-- | Match the given patterns against a list of clauses.+--+-- If successful, return the index of the covering clause.+--+match :: PureTCM m+ => [Clause] -- ^ Search for clause that covers the patterns.+ -> [NamedArg SplitPattern] -- ^ Patterns of the current 'SplitClause'.+ -> m (Match (Nat, SplitInstantiation))+match cs ps = foldr choice (return No) $ zipWith matchIt [0..] cs where- xs = permute (invertP perm) $ reverse [0 .. size perm - 1]- tick = do x : xs <- get; put xs; return x+ matchIt :: PureTCM m+ => Nat -- Clause number.+ -> Clause+ -> m (Match (Nat, SplitInstantiation))+ matchIt i c = fmap (\s -> (i, toList s)) <$> matchClause ps c - build (VarP _) = VarMP <$> tick- build (ConP con _ ps) = ConMP con <$> mapM (traverse build) ps- build (DotP t) = tick *> buildT t- build (LitP l) = return $ LitMP l+-- | If matching succeeds, we return the instantiation of the clause pattern vector+-- to obtain the split clause pattern vector.+type MatchResult = Match (DList (Nat, SplitPattern)) - buildT (Con c args) = ConMP c <$> mapM (traverse buildT) args- buildT (Var i []) = return (VarMP i)- buildT _ = return WildMP+instance Pretty BlockingVar where+ pretty (BlockingVar i cs ls o l) = cat+ [ text ("variable " ++ show i)+ , if null cs then empty else " blocked on constructors" <+> pretty cs+ , if null ls then empty else " blocked on literals" <+> pretty ls+ , if o then " (overlapping)" else empty+ , if l then " (lazy)" else empty+ ] --- | If matching is inconclusive (@Block@) we want to know which--- variable is blocking the match.-data Match a = Yes a | No | Block Nat- deriving (Functor)+yes :: Monad m => a -> m (Match a)+yes = return . Yes -instance Monoid a => Monoid (Match a) where- mempty = Yes mempty- Yes a `mappend` Yes b = Yes $ mappend a b- Yes _ `mappend` No = No- Yes _ `mappend` Block x = Block x- No `mappend` _ = No- Block x `mappend` _ = Block x+no :: Monad m => m (Match a)+no = return No -choice :: Match a -> Match a -> Match a-choice (Yes a) _ = Yes a-choice (Block x) _ = Block x-choice No m = m+blockedOnConstructor :: Monad m => Nat -> ConHead -> ConPatternInfo -> m (Match a)+blockedOnConstructor i c ci = return $ Block NotBlockedOnResult [BlockingVar i [c] [] False $ conPLazy ci] -type MatchLit = Literal -> MPat -> Match ()+blockedOnLiteral :: Monad m => Nat -> Literal -> m (Match a)+blockedOnLiteral i l = return $ Block NotBlockedOnResult [BlockingVar i [] [l] False False] -noMatchLit :: MatchLit-noMatchLit _ _ = No+blockedOnProjection :: Monad m => m (Match a)+blockedOnProjection = return $ Block (BlockedOnProj False) [] -yesMatchLit :: MatchLit-yesMatchLit _ VarMP{} = Yes ()-yesMatchLit _ WildMP{} = Yes ()-yesMatchLit _ _ = No+blockedOnApplication :: Monad m => ApplyOrIApply -> m (Match a)+blockedOnApplication b = return $ Block (BlockedOnApply b) [] --- | Match the given patterns against a list of clauses-match :: [Clause] -> [Arg Pattern] -> Permutation -> Match Nat-match cs ps perm = foldr choice No $ zipWith matchIt [0..] cs+setBlockingVarOverlap :: BlockingVar -> BlockingVar+setBlockingVarOverlap x = x { blockingVarOverlap = True }++overlapping :: BlockingVars -> BlockingVars+overlapping = map' setBlockingVarOverlap++-- | Left dominant merge of blocking vars.+zipBlockingVars :: BlockingVars -> BlockingVars -> BlockingVars+zipBlockingVars xs ys = map' upd xs where- mps = buildMPatterns perm ps+ upd (BlockingVar x cons lits o l) = case List.find ((x ==) . blockingVarNo) ys of+ Just (BlockingVar _ cons' lits' o' l') -> BlockingVar x (cons ++ cons') (lits ++ lits') (o || o') (l || l')+ Nothing -> BlockingVar x cons lits True l - -- If liberal matching on literals fails or blocks we go with that.- -- If it succeeds we use the result from conservative literal matching.- -- This is to make sure that we split enough when literals are involved.- -- For instance,- -- f ('x' :: 'y' :: _) = ...- -- f (c :: s) = ...- -- would never split the tail of the list if we only used conservative- -- literal matching.- matchIt i c = matchClause yesMatchLit mps i c +++- matchClause noMatchLit mps i c+setBlockedOnResultOverlap :: BlockedOnResult -> BlockedOnResult+setBlockedOnResultOverlap b = case b of+ BlockedOnProj{} -> b { blockedOnResultOverlap = True }+ BlockedOnApply{} -> b+ NotBlockedOnResult{} -> b - Yes _ +++ m = m- No +++ _ = No- Block x +++ _ = Block x+anyBlockedOnResult :: BlockedOnResult -> BlockedOnResult -> BlockedOnResult+anyBlockedOnResult b1 b2 = case (b1,b2) of+ (NotBlockedOnResult , b2 ) -> b2+ (b1 , NotBlockedOnResult) -> b1+ (_ , _ ) -> __IMPOSSIBLE__ --- | Check if a clause could match given generously chosen literals-matchLits :: Clause -> [Arg Pattern] -> Permutation -> Bool-matchLits c ps perm = case matchClause yesMatchLit (buildMPatterns perm ps) 0 c of- Yes _ -> True- _ -> False+-- | Left dominant merge of `BlockedOnResult`.+choiceBlockedOnResult :: BlockedOnResult -> BlockedOnResult -> BlockedOnResult+choiceBlockedOnResult b1 b2 = case (b1,b2) of+ (NotBlockedOnResult , _ ) -> NotBlockedOnResult+ (BlockedOnProj o1 , BlockedOnProj o2 ) -> BlockedOnProj (o1 || o2)+ (BlockedOnProj _ , _ ) -> BlockedOnProj True+ (BlockedOnApply b , _ ) -> BlockedOnApply b -matchClause :: MatchLit -> [Arg MPat] -> Nat -> Clause -> Match Nat-matchClause mlit qs i c = fmap (const i) $ matchPats mlit (clausePats c) qs+-- | @choice m m'@ combines the match results @m@ of a function clause+-- with the (already combined) match results $m'$ of the later clauses.+-- It is for skipping clauses that definitely do not match ('No').+-- It is left-strict, to be used with @foldr@.+-- If one clause unconditionally matches ('Yes') we do not look further.+choice :: Monad m => m (Match a) -> m (Match a) -> m (Match a)+choice m m' = m >>= \case+ Yes a -> yes a+ Block r xs -> m' >>= \case+ Block s ys -> return $ Block (choiceBlockedOnResult r s) $ zipBlockingVars xs ys+ Yes _ -> return $ Block (setBlockedOnResultOverlap r) $ overlapping xs+ No -> return $ Block r xs+ No -> m' -matchPats :: MatchLit -> [Arg Pattern] -> [Arg MPat] -> Match ()-matchPats mlit ps qs = mconcat $ zipWith (matchPat mlit) (map unArg ps) (map unArg qs)+{-# SPECIALIZE matchClause :: [NamedArg SplitPattern] -> Clause -> TCM MatchResult #-}+matchClause+ :: PureTCM m+ => [NamedArg SplitPattern]+ -- ^ Split clause patterns @qs@.+ -> Clause+ -- ^ Clause @c@ to cover split clause.+ -> m MatchResult+ -- ^ Result.+ -- If 'Yes' the instantiation @rs@ such that @(namedClausePats c)[rs] == qs@.+matchClause qs c = matchPats (namedClausePats c) qs -matchPat :: MatchLit -> Pattern -> MPat -> Match ()-matchPat _ (VarP _) _ = Yes ()-matchPat _ (DotP _) _ = Yes ()-matchPat mlit (LitP l) q = mlit l q-matchPat mlit (ConP c _ ps) q = case q of- VarMP x -> Block x- WildMP -> Yes ()- ConMP c' qs- | c == c' -> matchPats mlit ps qs- | otherwise -> No- LitMP _ -> __IMPOSSIBLE__+{-# SPECIALIZE matchPats :: DeBruijn a => [NamedArg (Pattern' a)] -> [NamedArg SplitPattern] -> TCM MatchResult #-}+-- | @matchPats ps qs@ checks whether a function clause with patterns+-- @ps@ covers a split clause with patterns @qs@.+--+-- Issue #842 / #1986: This is accepted:+-- @+-- F : Bool -> Set1+-- F true = Set+-- F = \ x -> Set+-- @+-- For the second clause, the split clause is @F false@,+-- so there are more patterns in the split clause than+-- in the considered clause. These additional patterns+-- are simply dropped by @zipWith@. This will result+-- in @mconcat []@ which is @Yes []@.++matchPats+ :: (PureTCM m, DeBruijn a)+ => [NamedArg (Pattern' a)]+ -- ^ Clause pattern vector @ps@ (to cover split clause pattern vector).+ -> [NamedArg SplitPattern]+ -- ^ Split clause pattern vector @qs@ (to be covered by clause pattern vector).+ -> m MatchResult+ -- ^ Result.+ -- If 'Yes' the instantiation @rs@ such that @ps[rs] == qs@.+matchPats [] [] = yes mempty+matchPats (p:ps) (q:qs) =+ matchPat (namedArg p) (namedArg q) `combine` matchPats ps qs++-- Patterns left in split clause:+-- Andreas, 2016-06-03, issue #1986:+-- catch-all for copatterns is inconsistent as found by Ulf.+-- Thus, if the split clause has copatterns left,+-- the current (shorter) clause is not considered covering.+matchPats [] qs@(_:_) = case mapMaybe isProjP qs of+ [] -> yes mempty -- no proj. patterns left+ _ -> no -- proj. patterns left++-- Patterns left in candidate clause:+-- If the current clause has additional copatterns in+-- comparison to the split clause, we should split on them.+matchPats (p:ps) [] = case isProjP p of+ Just{} -> blockedOnProjection+ Nothing -> blockedOnApplication (case namedArg p of IApplyP{} -> IsIApply; _ -> IsApply)++-- | Combine results of checking whether function clause patterns+-- covers split clause patterns.+--+-- 'No' is dominant: if one function clause pattern is disjoint to+-- the corresponding split clause pattern, then+-- the whole clauses are disjoint.+--+-- 'Yes' is neutral: for a match, all patterns have to match.+--+-- 'Block' accumulates variables of the split clause+-- that have to be instantiated (an projection names of copattern matches)+-- to make the split clause an instance of the function clause.+combine :: (Monad m, Semigroup a) => m (Match a) -> m (Match a) -> m (Match a)+combine m m' = m >>= \case+ Yes a -> m' >>= \case+ Yes b -> yes (a <> b)+ y -> return y+ No -> no+ x@(Block r xs) -> m' >>= \case+ No -> no+ Block s ys -> return $ Block (anyBlockedOnResult r s) (xs ++ ys)+ Yes{} -> return x++{-# SPECIALIZE matchPat :: DeBruijn a => Pattern' a -> SplitPattern -> TCM MatchResult #-}+-- | @matchPat p q@ checks whether a function clause pattern @p@+-- covers a split clause pattern @q@. There are three results:+--+-- 1. @Yes rs@ means it covers, because @p@ is a variable pattern. @rs@ collects+-- the instantiations of the variables in @p@ s.t. @p[rs] = q@.+--+-- 2. @No@ means it does not cover.+--+-- 3. @Block [x]@ means @p@ is a proper instance of @q@ and could become+-- a cover if @q@ was split on variable @x@.++matchPat+ :: (PureTCM m, DeBruijn a)+ => Pattern' a+ -- ^ Clause pattern @p@ (to cover split clause pattern).+ -> SplitPattern+ -- ^ Split clause pattern @q@ (to be covered by clause pattern).+ -> m MatchResult+ -- ^ Result.+ -- If 'Yes', also the instantiation @rs@ of the clause pattern variables+ -- to produce the split clause pattern, @p[rs] = q@.+matchPat p q = case p of++ VarP _ x ->+ yes $ singleton (fromMaybe __IMPOSSIBLE__ (deBruijnView x), q)++ DotP{} -> yes mempty+ -- Jesper, 2014-11-04: putting 'Yes [q]' here triggers issue 1333.+ -- Not checking for trivial patterns should be safe here, as dot patterns are+ -- guaranteed to match if the rest of the pattern does, so some extra splitting+ -- on them doesn't change the reduction behaviour.++ p@(LitP _ l) -> case q of+ VarP _ x -> if l `elem` splitExcludedLits x+ then no+ else blockedOnLiteral (splitPatVarIndex x) l+ _ -> isLitP q >>= \case+ Just l' -> if l == l' then yes mempty else no+ Nothing -> no++ ProjP _ d -> case q of+ ProjP _ d' -> do+ d <- getOriginalProjection d+ if d == d' then yes mempty else no+ VarP{} -> no -- not impossible, see issue #7753+ DotP{} -> __IMPOSSIBLE__+ ConP{} -> __IMPOSSIBLE__+ DefP{} -> __IMPOSSIBLE__+ LitP{} -> __IMPOSSIBLE__+ IApplyP{} -> __IMPOSSIBLE__++ IApplyP _ _ _ x ->+ yes $ singleton (fromMaybe __IMPOSSIBLE__ (deBruijnView x), q)++ -- Issue #4179: If the inferred pattern is a literal+ -- v we need to turn it into a constructor pattern.+ ConP c ci ps -> unDotP q >>= unLitP >>= \case+ VarP _ x -> blockedOnConstructor (splitPatVarIndex x) c ci+ ConP c' i qs+ | c == c' -> matchPats ps qs+ | otherwise -> no+ DotP o t -> no+ DefP{} -> no+ LitP{} -> __IMPOSSIBLE__ -- excluded by typing and unLitP+ ProjP{} -> __IMPOSSIBLE__ -- excluded by typing+ IApplyP _ _ _ x -> blockedOnConstructor (splitPatVarIndex x) c ci++ DefP o c ps -> unDotP q >>= \case+ VarP _ x -> no+ ConP c' i qs -> no+ DotP o t -> no+ LitP{} -> no+ DefP o c' qs+ | c == c' -> matchPats ps qs+ | otherwise -> no+ ProjP{} -> __IMPOSSIBLE__ -- excluded by typing+ IApplyP _ _ _ x -> __IMPOSSIBLE__ -- blockedOnConstructor (splitPatVarIndex x) c++{-# SPECIALIZE unDotP :: DeBruijn a => Pattern' a -> TCM (Pattern' a) #-}+-- | Unfold one level of a dot pattern to a proper pattern if possible.+unDotP :: (MonadReduce m, DeBruijn a) => Pattern' a -> m (Pattern' a)+unDotP (DotP o v) = reduce v >>= \case+ Var i [] -> return $ deBruijnVar i+ Con c _ vs -> do+ let ps = map' (fmap $ unnamed . DotP o) $ mustAllApplyElims vs+ return $ ConP c noConPatternInfo ps+ Lit l -> return $ LitP (LitPatternInfo (PatternInfo PatODot []) empty) l+ v -> return $ dotP v+unDotP p = return p++{-# SPECIALIZE isLitP :: Pattern' a -> TCM (Maybe Literal) #-}+isLitP :: PureTCM m => Pattern' a -> m (Maybe Literal)+isLitP (LitP _ l) = return $ Just l+isLitP (DotP _ u) = reduce u >>= \case+ Lit l -> return $ Just l+ _ -> return $ Nothing+isLitP (ConP c ci []) = do+ zero <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinZero+ if conName c == zero+ then return $ Just $ LitNat 0+ else return Nothing+isLitP (ConP c ci [a]) | visible a && isRelevant a = do+ suc <- fromMaybe __IMPOSSIBLE__ <$> getBuiltinName' builtinSuc+ if conName c == suc+ then fmap inc <$> isLitP (namedArg a)+ else return Nothing+ where+ inc :: Literal -> Literal+ inc (LitNat n) = LitNat $ n + 1+ inc _ = __IMPOSSIBLE__+isLitP _ = return Nothing++{-# SPECIALIZE unLitP :: Pattern' a -> TCM (Pattern' a) #-}+unLitP :: HasBuiltins m => Pattern' a -> m (Pattern' a)+unLitP (LitP lpi@(LitPatternInfo info prio) l@(LitNat n)) | n >= 0 = do+ constructorForm (Lit l) >>= \case+ Con c ci es -> do+ let toP (Apply (Arg i (Lit l))) = Arg i (LitP lpi l)+ toP _ = __IMPOSSIBLE__+ cpi = noConPatternInfo { conPInfo = info, conPPrio = prio }+ return $ ConP c cpi $ map' (fmap unnamed . toP) es+ _ -> __IMPOSSIBLE__+unLitP p = return p
@@ -0,0 +1,137 @@+{-| SplitClause and CoverResult types.+ -}++module Agda.TypeChecking.Coverage.SplitClause where++import Prelude hiding (null, (!!)) -- do not use partial functions like !!++import Data.Map (Map)+import qualified Data.Map as Map+import qualified Data.Set as Set+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet++import Agda.Syntax.Common hiding (DataOrRecord)+import Agda.Syntax.Common.Pretty (Pretty, pretty, prettyShow)+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Internal++import Agda.TypeChecking.Coverage.Match+import Agda.TypeChecking.Coverage.SplitPattern+import Agda.TypeChecking.Coverage.SplitTree+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Records+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Telescope.Path+import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.Warnings++import Agda.Interaction.Options++import Agda.Utils.Either+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Permutation+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.WithDefault++import Agda.Utils.Impossible+++data SplitClause = SClause+ { scTel :: Telescope+ -- ^ Type of variables in @scPats@.+ , scPats :: [NamedArg SplitPattern]+ -- ^ The patterns leading to the currently considered branch of+ -- the split tree.+ , scSubst :: Substitution' SplitPattern+ -- ^ Substitution from 'scTel' to old context.+ -- Only needed directly after split on variable:+ -- * To update 'scTarget'+ -- * To rename other split variables when splitting on+ -- multiple variables.+ -- @scSubst@ is not ``transitive'', i.e., does not record+ -- the substitution from the original context to 'scTel'+ -- over a series of splits. It is freshly computed+ -- after each split by 'computeNeighborhood'; also+ -- 'splitResult', which does not split on a variable,+ -- should reset it to the identity 'idS', lest it be+ -- applied to 'scTarget' again, leading to Issue 1294.+ , scCheckpoints :: Map CheckpointId Substitution+ -- ^ We need to keep track of the module parameter checkpoints for the+ -- clause for the purpose of inferring missing instance clauses.+ , scTarget :: Maybe (Dom Type)+ -- ^ The type of the rhs, living in context 'scTel'.+ -- 'fixTargetType' computes the new 'scTarget' by applying+ -- substitution 'scSubst'.+ }+ deriving Show++instance Pretty SplitClause where+ pretty (SClause tel ps _rho _cps mt) =+ P.vcat+ [ "SplitClause"+ , P.text "tel =" P.<+> P.pretty tel+ , P.text "ps =" P.<+> P.pretty ps+ , P.text "mt =" P.<+> P.pretty mt+ ]++data UnifyEquiv = UE+ { infoTel0 :: Telescope -- Γ0+ , infoTel :: Telescope -- Γ'+ , infoEqTel :: Telescope -- Γ0 ⊢ Δ+ , infoEqLHS :: [Term] -- Γ0 ⊢ us : Δ+ , infoEqRHS :: [Term] -- Γ0 ⊢ vs : Δ+ , infoRho :: PatternSubstitution -- Γ' ⊢ ρ : Γ0+ -- Γ = Γ0,(φ : I),(eqs : Paths Δ us vs)+ -- Γ' ⊢ ρ,i1,refls : Γ+ , infoTau :: Substitution -- Γ ⊢ τ : Γ'+ , infoLeftInv :: Substitution -- Γ | (i : I) ⊢ leftInv : Γ+ -- leftInv[i=0] = ρ[τ],i1s,refls+ -- leftInv[i=1] = idS+ }+ deriving Show++data IInfo = TheInfo UnifyEquiv | NoInfo deriving Show++-- | A @Covering@ is the result of splitting a 'SplitClause'.+data Covering = Covering+ { covSplitArg :: Arg Nat+ -- ^ De Bruijn level (counting dot patterns) of argument we split on.+ , covSplitClauses :: [(SplitTag, (SplitClause, IInfo))]+ -- ^ Covering clauses, indexed by constructor/literal these clauses share.+ }++-- | Project the split clauses out of a covering.+splitClauses :: Covering -> [SplitClause]+splitClauses (Covering _ qcs) = map (fst . snd) qcs++-- | Create a split clause from a clause in internal syntax. Used by make-case.+clauseToSplitClause :: Clause -> SplitClause+clauseToSplitClause cl = SClause+ { scTel = clauseTel cl+ , scPats = toSplitPatterns $ namedClausePats cl+ , scSubst = idS -- Andreas, 2014-07-15 TODO: Is this ok?+ , scCheckpoints = Map.empty -- #2996: not __IMPOSSIBLE__ for debug printing+ , scTarget = domFromArg <$> clauseType cl+ }+++---------------------------------------------+-- Record type for the results of @cover@+---------------------------------------------++data CoverResult = CoverResult+ { coverSplitTree :: SplitTree+ , coverUsedClauses :: IntSet -- Set Nat+ , coverMissingClauses :: [(Telescope, [NamedArg DeBruijnPattern])]+ , coverPatterns :: [Clause]+ -- ^ The set of patterns used as cover.+ , coverNoExactClauses :: IntSet -- Set Nat+ }
@@ -0,0 +1,137 @@+{-# OPTIONS -Wunused-imports #-}++module Agda.TypeChecking.Coverage.SplitPattern+ ( SplitPattern, SplitPatVar(..)+ , fromSplitPattern, fromSplitPatterns, toSplitPatterns+ , toSplitPSubst, applySplitPSubst+ , isTrivialPattern+ ) where++import Prelude hiding ( null )++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Literal++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty ( PrettyTCM(..) )+import Agda.TypeChecking.Records+import Agda.TypeChecking.Substitute++import Agda.Utils.Null+import Agda.Syntax.Common.Pretty ( Pretty(..), text, prettyList_ )+import Agda.Utils.Monad++import Agda.Utils.Impossible+import Agda.Syntax.Position (KillRange, killRange, killRangeN)++{-# SPECIALIZE isTrivialPattern :: Pattern' a -> TCM Bool #-}+-- | A pattern that matches anything (modulo eta).+isTrivialPattern :: (HasConstInfo m) => Pattern' a -> m Bool+isTrivialPattern = \case+ VarP{} -> return True+ DotP{} -> return True+ ConP c i ps -> andM $ ((conPLazy i ||) <$> isEtaCon (conName c))+ : (map (isTrivialPattern . namedArg) ps)+ DefP{} -> return False+ LitP{} -> return False+ ProjP{} -> return False+ IApplyP{} -> return True++-- | For each variable in the patterns of a split clause, we remember the+-- de Bruijn-index and the literals excluded by previous matches.++-- (See issue #708.)+data SplitPatVar = SplitPatVar+ { splitPatVarName :: PatVarName+ , splitPatVarIndex :: Int+ , splitExcludedLits :: [Literal]+ } deriving (Show)++instance Pretty SplitPatVar where+ prettyPrec _ x =+ text (patVarNameToString (splitPatVarName x)) <>+ text ("@" ++ show (splitPatVarIndex x)) <>+ ifNull (splitExcludedLits x) empty (\lits ->+ "\\{" <> prettyList_ lits <> "}")++instance PrettyTCM SplitPatVar where+ prettyTCM = prettyTCM . var . splitPatVarIndex++instance KillRange SplitPatVar where+ killRange (SplitPatVar n i lits) = killRangeN SplitPatVar n i lits++type SplitPattern = Pattern' SplitPatVar++toSplitVar :: DBPatVar -> SplitPatVar+toSplitVar x = SplitPatVar (dbPatVarName x) (dbPatVarIndex x) []++fromSplitVar :: SplitPatVar -> DBPatVar+fromSplitVar x = DBPatVar (splitPatVarName x) (splitPatVarIndex x)++instance DeBruijn SplitPatVar where+ deBruijnView x = deBruijnView (fromSplitVar x)+ deBruijnNamedVar n i = toSplitVar (deBruijnNamedVar n i)++toSplitPatterns :: [NamedArg DeBruijnPattern] -> [NamedArg SplitPattern]+toSplitPatterns = (fmap . fmap . fmap . fmap) toSplitVar++fromSplitPattern :: NamedArg SplitPattern -> NamedArg DeBruijnPattern+fromSplitPattern = (fmap . fmap . fmap) fromSplitVar++fromSplitPatterns :: [NamedArg SplitPattern] -> [NamedArg DeBruijnPattern]+fromSplitPatterns = fmap fromSplitPattern++type SplitPSubstitution = Substitution' SplitPattern++toSplitPSubst :: PatternSubstitution -> SplitPSubstitution+toSplitPSubst = (fmap . fmap) toSplitVar++fromSplitPSubst :: SplitPSubstitution -> PatternSubstitution+fromSplitPSubst = (fmap . fmap) fromSplitVar++applySplitPSubst :: TermSubst a => SplitPSubstitution -> a -> a+applySplitPSubst = applyPatSubst . fromSplitPSubst++-- TODO: merge this instance and the one for DeBruijnPattern in+-- Substitute.hs into one for Subst (Pattern' a) (Pattern' a).+instance Subst SplitPattern where+ type SubstArg SplitPattern = SplitPattern++ applySubst IdS = id+ applySubst rho = \case+ VarP i x ->+ usePatternInfo i $+ useName (splitPatVarName x) $+ useExcludedLits (splitExcludedLits x) $+ lookupS rho $ splitPatVarIndex x+ DotP i u -> DotP i $ applySplitPSubst rho u+ ConP c ci ps -> ConP c ci $ applySubst rho ps+ DefP i q ps -> DefP i q $ applySubst rho ps+ p@LitP{} -> p+ p@ProjP{} -> p+ IApplyP i l r x ->+ useEndPoints (applySplitPSubst rho l) (applySplitPSubst rho r) $+ usePatternInfo i $+ useName (splitPatVarName x) $+ useExcludedLits (splitExcludedLits x) $+ lookupS rho $ splitPatVarIndex x++ where+ -- see Subst for DeBruijnPattern+ useEndPoints :: Term -> Term -> SplitPattern -> SplitPattern+ useEndPoints l r (VarP o x) = IApplyP o l r x+ useEndPoints l r (IApplyP o _ _ x) = IApplyP o l r x+ useEndPoints l r x = __IMPOSSIBLE__++ useName :: PatVarName -> SplitPattern -> SplitPattern+ useName n (VarP o x)+ | isUnderscore (splitPatVarName x)+ = VarP o $ x { splitPatVarName = n }+ useName _ x = x++ useExcludedLits :: [Literal] -> SplitPattern -> SplitPattern+ useExcludedLits lits = \case+ (VarP o x) -> VarP o $ x+ { splitExcludedLits = lits ++ splitExcludedLits x }+ p -> p
@@ -0,0 +1,127 @@++{-# OPTIONS_GHC -Wall #-}++{-| Split tree for transforming pattern clauses into case trees.++The coverage checker generates a split tree from the clauses.+The clause compiler uses it to transform clauses to case trees.++The initial problem is a set of clauses. The root node designates+on which argument to split and has subtrees for all the constructors.+Splitting continues until there is only a single clause left at+each leaf of the split tree.++-}+module Agda.TypeChecking.Coverage.SplitTree where++import Control.DeepSeq++import Data.Tree++import GHC.Generics (Generic)++import Agda.Syntax.Abstract.Name+import Agda.Syntax.Common+import Agda.Syntax.Concrete.Pretty () --instance only+import Agda.Syntax.Literal+import Agda.Syntax.Position++import Agda.Syntax.Common.Pretty+import Agda.Utils.Null++import Agda.Utils.Impossible++type SplitTree = SplitTree' SplitTag+type SplitTrees = SplitTrees' SplitTag++-- | Abstract case tree shape.+data SplitTree' a+ = -- | No more splits coming. We are at a single, all-variable+ -- clause.+ SplittingDone+ { splitBindings :: Int -- ^ The number of variables bound in the clause+ }+ | -- | A split is necessary.+ SplitAt+ { splitArg :: Arg Int -- ^ Arg. no to split at.+ , splitLazy :: LazySplit+ , splitTrees :: SplitTrees' a -- ^ Sub split trees.+ }+ deriving (Show, Generic)++data LazySplit = LazySplit | StrictSplit+ deriving (Show, Eq, Ord, Generic)++-- | Split tree branching. A finite map from constructor names to splittrees+-- A list representation seems appropriate, since we are expecting not+-- so many constructors per data type, and there is no need for+-- random access.+type SplitTrees' a = [(a, SplitTree' a)]++-- | Tag for labeling branches of a split tree. Each branch is associated to+-- either a constructor or a literal, or is a catchall branch (currently+-- only used for splitting on a literal type).+data SplitTag+ = SplitCon QName+ | SplitLit Literal+ | SplitCatchall+ deriving (Show, Eq, Ord, Generic)++instance Pretty SplitTag where+ pretty (SplitCon c) = pretty c+ pretty (SplitLit l) = pretty l+ pretty SplitCatchall = underscore++-- * Printing a split tree++data SplitTreeLabel a = SplitTreeLabel+ { lblConstructorName :: Maybe a -- ^ 'Nothing' for root of split tree+ , lblSplitArg :: Maybe (Arg Int)+ , lblLazy :: LazySplit+ , lblBindings :: Maybe Int+ }+instance Pretty a => Pretty (SplitTreeLabel a) where+ pretty = \case+ SplitTreeLabel Nothing Nothing _ (Just n) -> text $ "done, " ++ prettyShow n ++ " bindings"+ SplitTreeLabel Nothing (Just n) lz Nothing -> lzp n lz <+> text ("split at " ++ prettyShow n)+ SplitTreeLabel (Just q) Nothing _ (Just n) -> pretty q <+> text ("-> done, " ++ prettyShow n ++ " bindings")+ SplitTreeLabel (Just q) (Just n) lz Nothing -> pretty q <+> text "->" <+> lzp n lz <+> text ("split at " ++ prettyShow n)+ _ -> __IMPOSSIBLE__+ where+ lzp n lz =+ (if hasQuantity0 (getQuantity n)+ then "erased"+ else empty) <+>+ (case lz of+ LazySplit -> "lazy"+ StrictSplit -> empty)++-- | Convert a split tree into a 'Data.Tree' (for printing).+toTree :: SplitTree' a -> Tree (SplitTreeLabel a)+toTree = \case+ SplittingDone n -> Node (SplitTreeLabel Nothing Nothing StrictSplit (Just n)) []+ SplitAt n lz ts -> Node (SplitTreeLabel Nothing (Just n) lz Nothing) $ toTrees ts++toTrees :: SplitTrees' a -> Forest (SplitTreeLabel a)+toTrees = map (\ (c,t) -> setCons c $ toTree t)+ where+ setCons :: a -> Tree (SplitTreeLabel a) -> Tree (SplitTreeLabel a)+ setCons c (Node l ts) = Node (l { lblConstructorName = Just c }) ts++instance Pretty a => Pretty (SplitTree' a) where+ pretty = text . drawTree . fmap prettyShow . toTree++instance KillRange SplitTag where+ killRange = \case+ SplitCon c -> killRangeN SplitCon c+ SplitLit l -> killRangeN SplitLit l+ SplitCatchall -> SplitCatchall++instance KillRange a => KillRange (SplitTree' a) where+ killRange = \case+ SplittingDone n -> SplittingDone n+ SplitAt i lz ts -> killRangeN (SplitAt i lz) ts++instance NFData a => NFData (SplitTree' a)+instance NFData LazySplit+instance NFData SplitTag
@@ -1,29 +1,251 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.TypeChecking.Datatypes where -import Data.List+import Control.Monad ( filterM )+import Control.Monad.Except ( MonadError(..), ExceptT(..), runExceptT ) +import Data.Maybe (fromMaybe)+ import Agda.Syntax.Common import Agda.Syntax.Internal+ import Agda.TypeChecking.Monad-import Agda.TypeChecking.Reduce import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Pretty +import Agda.Utils.Boolean ( toBool )+import Agda.Utils.CallStack+import Agda.Utils.Either+import Agda.Utils.Functor+import Agda.Syntax.Common.Pretty ( prettyShow )+import Agda.Utils.Size+ import Agda.Utils.Impossible -#include "../undefined.h"+---------------------------------------------------------------------------+-- * Constructors+--------------------------------------------------------------------------- +-- | Get true constructor with record fields.+getConHead :: (HasCallStack, HasConstInfo m) => QName -> m (Either SigError ConHead)+getConHead c = runExceptT $ do+ def <- ExceptT $ getConstInfo' c+ case theDef def of+ Constructor { conSrcCon = c' } -> return c'+ Record { recConHead = c' } -> return c'+ _ -> throwError $ SigUnknown $ prettyShow c ++ " is not a constructor"++isConstructor :: (HasCallStack, HasConstInfo m) => QName -> m Bool+isConstructor q = isRight <$> getConHead q++-- | Get true constructor with fields, expanding literals to constructors+-- if possible.+getConForm :: HasCallStack => QName -> TCM (Either SigError ConHead)+getConForm c = caseEitherM (getConHead c) (return . Left) $ \ ch -> do+ Con con _ [] <- constructorForm (Con ch ConOCon [])+ return $ Right con++-- | Augment constructor with record fields (preserve constructor name).+-- The true constructor might only surface via 'reduce'.+getOrigConHead :: HasCallStack => QName -> TCM ConHead+getOrigConHead c = setConName c <$> do+ fromRightM+ (sigError c (typeError $ AbstractConstructorNotInScope c)) $+ getConHead c+ -- | Get the name of the datatype constructed by a given constructor. -- Precondition: The argument must refer to a constructor-getConstructorData :: QName -> TCM QName+{-# SPECIALIZE getConstructorData :: QName -> TCM QName #-}+getConstructorData :: (HasCallStack, HasConstInfo m) => QName -> m QName getConstructorData c = do def <- getConstInfo c case theDef def of Constructor{conData = d} -> return d _ -> __IMPOSSIBLE__ +-- | Is the datatype of this constructor a Higher Inductive Type?+-- Precondition: The argument must refer to a constructor of a datatype or record.+consOfHIT :: (HasCallStack, HasConstInfo m) => QName -> m Bool+consOfHIT c = do+ theDef <$> getConstInfo c >>= \case+ -- A path constructor is always a constructor of a HIT,+ -- so we only need to consult the data type for point constructors.+ Constructor{ conPathCons = PathCons } -> return True+ Constructor{ conPathCons = PointCons, conData = d } ->+ theDef <$> getConstInfo d >>= \case+ Datatype{ dataHIT = hit } -> return $ toBool hit+ Record{} -> return False+ _ -> __IMPOSSIBLE__+ _ -> __IMPOSSIBLE__++-- | Is this a path constructor (of a higher inductive type)?+-- Precondition: The argument must refer to a constructor of a datatype or record.+isPathCons :: (HasCallStack, HasConstInfo m) => QName -> m Bool+isPathCons c = do+ def <- theDef <$> getConstInfo c+ case def of+ Constructor{ conPathCons = p } -> return $ p == PathCons+ _ -> __IMPOSSIBLE__++-- | @getFullyAppliedConType c t@ computes the constructor parameters+-- from data type @t@ and returns them+-- plus the instantiated type of constructor @c@.+--+-- @Nothing@ if @t@ is not a data/record type or does not have+-- a constructor @c@.+--+-- Precondition: @t@ is reduced.+getFullyAppliedConType+ :: PureTCM m+ => ConHead -- ^ Constructor.+ -> Type -- ^ Reduced type of the fully applied constructor.+ -> m (Maybe ((QName, Type, Args), Type))+ -- ^ @Nothing@ if not data or record type.+ --+ -- @Just ((d, dt, pars), ct)@ otherwise, where+ -- @d@ is the data or record type name,+ -- @dt@ is the type of the data or record name,+ -- @pars@ are the reconstructed parameters,+ -- @ct@ is the type of the constructor instantiated to the parameters.+getFullyAppliedConType c t = do+ reportSLn "tc.getConType" 35 $ unwords $+ [ "getFullyAppliedConType", prettyShow c, prettyShow t ]+ c <- fromRight __IMPOSSIBLE__ <$> getConHead (conName c)+ cdef <- getConstInfo $ conName c+ let ctype = defType cdef+ cdata = conData $ theDef cdef+ npars = conPars $ theDef cdef+ case unEl t of+ Def d es | d == cdata -> do+ reportSLn "tc.getConType" 35 $ unwords $+ [ "getFullyAppliedConType: case Def", prettyShow d, prettyShow es ]+ dt <- defType <$> getConstInfo d+ let pars = mustAllApplyElims $ take npars es+ ctPars <- ctype `piApplyM` pars+ return $ Just ((d, dt, pars), ctPars)+ _ -> return Nothing++-- | Make sure a constructor is fully applied and infer the type of the constructor.+-- Raises a type error if the constructor does not belong to the given type.+fullyApplyCon+ :: (PureTCM m, MonadBlock m, MonadTCError m)+ => ConHead -- ^ Constructor.+ -> Elims -- ^ Constructor arguments.+ -> Type -- ^ Type of the constructor application.+ -> (QName -> Type -> Args -> Type -> Elims -> Telescope -> Type -> m a)+ -- ^ Name of the data/record type,+ -- type of the data/record type,+ -- reconstructed parameters,+ -- type of the constructor (applied to parameters),+ -- full application arguments,+ -- types of missing arguments (already added to context),+ -- type of the full application.+ -> m a+fullyApplyCon c vs t ret = fullyApplyCon' c vs t ret $+ typeError . ConstructorDoesNotTargetGivenType (conName c)++-- | Like @fullyApplyCon@, but calls the given fallback function if+-- it encounters something other than a datatype.+fullyApplyCon'+ :: (PureTCM m, MonadBlock m)+ => ConHead -- ^ Constructor.+ -> Elims -- ^ Constructor arguments.+ -> Type -- ^ Type of the constructor application.+ -> (QName -> Type -> Args -> Type -> Elims -> Telescope -> Type -> m a) -- ^ See @fullyApplyCon@+ -> (Type -> m a) -- ^ Fallback function+ -> m a+fullyApplyCon' c vs t0 ret err = do+ reportSDoc "tc.getConType" 30 $ sep $+ [ "fullyApplyCon': constructor "+ , prettyTCM c+ , " with arguments"+ , prettyTCM vs+ , " at type "+ , prettyTCM t0+ ]+ (TelV tel t, boundary) <- telViewPathBoundary t0+ -- The type of the constructor application may still be a function+ -- type. In this case, we introduce the domains @tel@ into the context+ -- and apply the constructor to these fresh variables.+ addContext tel $ do+ reportSLn "tc.getConType" 35 $ " target type: " ++ prettyShow t+ t <- abortIfBlocked t+ getFullyAppliedConType c t >>= \case+ Nothing -> err t+ Just ((d, dt, pars), a) ->+ ret d dt pars a (raise (size tel) vs ++ teleElims tel boundary) tel t++-- | @getConType c t@ computes the constructor parameters from type @t@+-- and returns them plus the instantiated type of constructor @c@.+-- This works also if @t@ is a function type ending in a data/record type;+-- the term from which @c@ comes need not be fully applied+--+-- @Nothing@ if @t@ is not a data/record type or does not have+-- a constructor @c@.+getConType+ :: (PureTCM m, MonadBlock m)+ => ConHead -- ^ Constructor.+ -> Type -- ^ Ending in data/record type.+ -> m (Maybe ((QName, Type, Args), Type))+ -- ^ @Nothing@ if not ends in data or record type.+ --+ -- @Just ((d, dt, pars), ct)@ otherwise, where+ -- @d@ is the data or record type name,+ -- @dt@ is the type of the data or record name,+ -- @pars@ are the reconstructed parameters,+ -- @ct@ is the type of the constructor instantiated to the parameters.+getConType ch t = do+ let c = conName ch+ -- Optimization: if the constructor has no parameters, there+ -- is no need to reduce the type.+ npars <- getNumberOfParameters c+ if | npars == Just 0 -> do+ ctype <- defType <$> getConstInfo c+ d <- getConstructorData c+ dtype <- defType <$> getConstInfo d+ return $ Just ((d,dtype,[]),ctype)+ | otherwise -> fullyApplyCon' ch [] t+ (\d dt pars ct es tel a -> return $+ -- Now @dt@, @pars@, and @ct@ live under @tel@,+ -- so we need to remove the dependency on @tel@.+ let escape = applySubst (strengthenS impossible (size tel)) in+ Just $ escape ((d, dt, pars), ct))+ (\_ -> return Nothing)++data ConstructorInfo+ = DataCon Arity+ -- ^ Arity of the data constructor.+ | RecordCon PatternOrCopattern HasEta+ Arity+ -- ^ Arity of the record constructor.+ [Dom QName]+ -- ^ List of field names. Has length 'Arity'.++-- | Return the number of non-parameter arguments to a constructor (arity).+-- In case of record constructors, also return the field names (plus other info).+--+getConstructorInfo :: (HasCallStack, HasConstInfo m) => QName -> m ConstructorInfo+getConstructorInfo c = fromMaybe __IMPOSSIBLE__ <$> getConstructorInfo' c++getConstructorInfo' :: (HasCallStack, HasConstInfo m) => QName -> m (Maybe ConstructorInfo)+getConstructorInfo' c = do+ getConstInfo c <&> theDef >>= \case+ Constructor{ conData = d, conArity = n } -> Just <$> do+ getConstInfo d <&> theDef <&> \case+ RecordDefn (r@RecordData{ _recFields = fs, _recPatternMatching = pat }) ->+ RecordCon pat (_recEtaEquality r) n fs+ DatatypeDefn _ ->+ DataCon n+ _ -> __IMPOSSIBLE__+ _ -> return Nothing++---------------------------------------------------------------------------+-- * Data types+---------------------------------------------------------------------------+ -- | Check if a name refers to a datatype or a record with a named constructor. isDatatype :: QName -> TCM Bool isDatatype d = do@@ -34,49 +256,67 @@ _ -> return False -- | Check if a name refers to a datatype or a record.-isDataOrRecordType :: QName -> TCM Bool+isDataOrRecordType :: QName -> TCM (Maybe DataOrRecord) isDataOrRecordType d = do+ (theDef <$> getConstInfo d) >>= \case+ Record{ recEtaEquality', recPatternMatching } -> return $ Just $ IsRecord $+ case recPatternMatching of+ -- If the user explicitly asked for @pattern@, pattern matching is allowed.+ p@PatternMatching -> p+ -- Otherwise, 'recEtaEquality' might allow pattern matching.+ CopatternMatching ->+ if patternMatchingAllowed recEtaEquality' then PatternMatching else CopatternMatching+ Datatype{} -> return $ Just IsData+ _ -> return $ Nothing++-- | Precodition: 'Term' is 'reduce'd.+isDataOrRecord :: Term -> TCM (Maybe (QName, DataOrRecord))+isDataOrRecord = \case+ Def d _ -> fmap (d,) <$> isDataOrRecordType d+ _ -> return Nothing++getNumberOfParameters :: (HasCallStack, HasConstInfo m) => QName -> m (Maybe Nat)+getNumberOfParameters d = do def <- getConstInfo d case theDef def of- Datatype{} -> return True- Record{} -> return True- _ -> return False--data DatatypeInfo = DataInfo- { datatypeName :: QName- , datatypeParTel :: Telescope- , datatypePars :: Args- , datatypeIxTel :: Telescope- , datatypeIxs :: Args- }+ Datatype{ dataPars = n } -> return $ Just n+ Record{ recPars = n } -> return $ Just n+ Constructor{ conPars = n } -> return $ Just n+ _ -> return Nothing --- | Get the name and parameters from a type if it's a datatype or record type--- with a named constructor.-getDatatypeInfo :: Type -> TCM (Maybe DatatypeInfo)-getDatatypeInfo t = do- t <- reduce t+-- | This is a simplified version of @isDatatype@ from @Coverage@,+-- useful when we do not want to import the module.+getDatatypeArgs :: (HasCallStack, HasConstInfo m) => Type -> m (Maybe (QName, Args, Args))+getDatatypeArgs t = do case unEl t of- Def d args -> do- n <- getDefFreeVars d- args <- return $ genericDrop n args- def <- instantiateDef =<< getConstInfo d- TelV tel _ <- telView (defType def)- let npars = case theDef def of- Datatype{dataPars = np} -> Just np- Record{recPars = np, recNamedCon = True}- | genericLength args == np -> Just np- | otherwise -> __IMPOSSIBLE__- _ -> Nothing- return $ do- np <- npars- let (pt, it) = genericSplitAt np $ telToList tel- parTel = telFromList pt- ixTel = telFromList it- (ps, is) = genericSplitAt np args- return $ DataInfo { datatypeName = d- , datatypeParTel = parTel- , datatypePars = ps- , datatypeIxTel = ixTel- , datatypeIxs = is- }+ Def d es -> do+ let ~(Just args) = allApplyElims es+ def <- theDef <$> getConstInfo d+ case def of+ Datatype{dataPars = np} -> do+ let !(ps, is) = splitAt np args+ return $ Just (d, ps, is)+ Record{} -> do+ return $ Just (d, args, [])+ _ -> return Nothing _ -> return Nothing++getNotErasedConstructors :: QName -> TCM [QName]+getNotErasedConstructors d = do+ filterM (usableModality <.> getConstInfo) =<< getConstructors d++-- | Precondition: Name is a data or record type.+getConstructors :: QName -> TCM [QName]+getConstructors d = fromMaybe __IMPOSSIBLE__ <$>+ getConstructors' d++-- | 'Nothing' if not data or record type name.+getConstructors' :: QName -> TCM (Maybe [QName])+getConstructors' d = getConstructors_ . theDef <$> getConstInfo d++-- | 'Nothing' if not data or record definition.+getConstructors_ :: Defn -> Maybe [QName]+getConstructors_ = \case+ Datatype{dataCons = cs} -> Just cs+ Record{recConHead = h} -> Just [conName h]+ _ -> Nothing
@@ -1,7 +1,10 @@+{-# OPTIONS_GHC -Wunused-imports #-} module Agda.TypeChecking.Datatypes where -import Agda.TypeChecking.Monad.Base-import Agda.Syntax.Internal+import Agda.TypeChecking.Monad.Signature ( HasConstInfo, SigError )+import Agda.Syntax.Internal ( QName, ConHead )+import Agda.Utils.CallStack ( HasCallStack ) -getConstructorData :: QName -> TCM QName+getConHead :: (HasCallStack, HasConstInfo m) => QName -> m (Either SigError ConHead)+getConstructorData :: (HasCallStack, HasConstInfo m) => QName -> m QName
@@ -0,0 +1,199 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.DeadCode (eliminateDeadCode) where++import Control.Monad+import Control.Monad.Trans++import Data.Maybe+import qualified Data.Map.Strict as MapS+import qualified Data.HashMap.Strict as HMap+import Data.IORef++import Agda.Interaction.Options (optSaveMetas)++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Names+import Agda.Syntax.Scope.Base++import qualified Agda.Benchmarking as Bench+import qualified Agda.TypeChecking.Monad.Benchmark as Bench++import Agda.TypeChecking.Monad++import Agda.Utils.Impossible+import Agda.Utils.List+import qualified Agda.Utils.List1 as List1++import Agda.Utils.HashTable (HashTableLU, HashTableLL)+import qualified Agda.Utils.HashTable as HT++-- | Run before serialisation to remove data that's not reachable from the+-- public interface. We do not compute reachable data precisely, because that+-- would be very expensive, mainly because of rewrite rules. The following+-- things are assumed to be "roots":+-- - public definitions+-- - definitions marked as primitive+-- - definitions with COMPILE pragma+-- - all pattern synonyms (because currently all of them go into interfaces)+-- - all parameter sections (because currently all of them go into interfaces)+-- (see also issues #6931 and #7382)+-- - local builtins+-- - all rewrite rules+-- - closed display forms+-- We only ever prune dead metavariables and definitions. We return the pruned metas,+-- pruned definitions and closed display forms.+eliminateDeadCode :: ScopeInfo -> TCM (RemoteMetaStore, Definitions, DisplayForms)+eliminateDeadCode !scope = Bench.billTo [Bench.DeadCode] $ do+ !sig <- getSignature+ let !defs = sig ^. sigDefinitions+ !metas <- useR stSolvedMetaStore+ !saveMetas <- optSaveMetas <$> pragmaOptions++ -- #2921: Eliminating definitions with attached COMPILE pragmas results in+ -- the pragmas not being checked. Simple solution: don't eliminate these.+ -- #6022 (Andreas, 2022-09-30): Eliminating cubical primitives can lead to crashes.+ -- Simple solution: retain all primitives (shouldn't be many).+ let hasCompilePragma = not . MapS.null . defCompiledRep++ isPrimitive = \case+ Primitive{} -> True+ PrimitiveSort{} -> True+ _ -> False++ extraRootsFilter (name, def)+ | hasCompilePragma def || isPrimitive (theDef def) = Just name+ | otherwise = Nothing++ let !pubModules = publicModules scope++ -- Ulf, 2016-04-12:+ -- Non-closed display forms are not applicable outside the module anyway,+ -- and should be dead-code eliminated (#1928).+ let eliminateNonClosed = List1.nonEmpty . List1.filter isClosed++ !rootDisplayForms <-+ HMap.mapMaybe eliminateNonClosed <$> useTC stImportsDisplayForms++ let !rootPubNames = map' anameName $ publicNamesOfModules pubModules+ let !rootExtraDefs = mapMaybe extraRootsFilter $ HMap.toList defs+ let !rootRewrites = sig ^. sigRewriteRules+ let !rootModSections = sig ^. sigSections+ !rootBuiltins <- useTC stLocalBuiltins+ !rootPatSyns <- getPatternSyns++ -- When we're traversing the definition of a name, we want to record if the definition contains+ -- any metas. If a definition doesn't contain metas, we can skip instantiateFull on it before+ -- serialization.+ --+ -- We record "meta-closedness" in the following way. If we're traversing a name definition,+ -- "insideDef" contains the IORef Bool which can be flipped if we hit a metavariable. We+ -- store these IORef Bool-s in "seenNames". A new IORef Bool is created for each QName when we+ -- encounter it for the first time.+ !insideDef <- lift $ newIORef Nothing :: TCM (IORef (Maybe (IORef Bool)))++ !seenNames <- lift $ HT.empty :: TCM (HashTableLL QName (IORef Bool))+ !seenMetas <- lift $ HT.empty :: TCM (HashTableLU MetaId ())++ let goName :: QName -> IO ()+ goName !x = HT.insertingIfAbsent seenNames x+ -- already visited name, do nothing+ (\_ -> pure ())++ -- unvisited, insert new IORef into table+ (newIORef False)++ (\ref -> do+ prevRef <- readIORef insideDef -- save ref+ writeIORef insideDef (Just ref)+ go (HMap.lookup x defs)+ writeIORef insideDef prevRef -- restore ref+ )++ goMeta :: MetaId -> IO ()+ goMeta !m = do+ prevRef <- readIORef insideDef+ case prevRef of+ -- we're not inside any name definition+ Nothing -> pure ()+ -- we're inside a name definition, record meta occurrence+ Just ref -> writeIORef ref True++ HT.insertingIfAbsent seenMetas m+ -- already visited, do nothing+ (\_ -> pure ())++ (pure ())+ -- unvisited+ (\_ -> case MapS.lookup m metas of+ Nothing -> pure ()+ Just mv -> do+ writeIORef insideDef Nothing+ go (instBody (theInstantiation mv))+ -- The meta's judgement reaches the interface (as+ -- rmvJudgement) only under --save-metas; otherwise the+ -- meta store is dropped after instantiateFull, so+ -- nothing reachable solely through the judgement's type+ -- can occur in the serialised interface, and traversing+ -- it would only grow the kept sets and the traversal+ -- cost (quadratically in the module's section+ -- telescopes, since each solved meta's type is closed+ -- over its context).+ when saveMetas $ go (jMetaType (mvJudgement mv))+ writeIORef insideDef prevRef -- restore ref+ )++ go :: NamesIn a => a -> IO ()+ go !x = namesAndMetasIn' (either goName goMeta) x+ {-# INLINE go #-}++ Bench.billTo [Bench.DeadCode, Bench.DeadCodeReachable] $ lift $ do+ go rootDisplayForms+ foldMap goName rootPubNames+ foldMap goName rootExtraDefs+ go rootRewrites+ go rootModSections+ go rootBuiltins+ foldMap go rootPatSyns++ let goMetas :: [(MetaId, MetaVariable)] -> IO [(MetaId, RemoteMetaVariable)]+ goMetas [] = pure []+ goMetas ((!i, !m):metas) = HT.lookup seenMetas i >>= \case+ Nothing -> goMetas metas+ Just _ -> do+ let !m' = remoteMetaVariable m+ ((i, m'):) <$!> goMetas metas++ goDefs :: [(QName, Definition)] -> IO [(QName, Definition)]+ goDefs [] = pure []+ goDefs ((!x, !d):defs) = HT.lookup seenNames x >>= \case+ Nothing -> goDefs defs+ Just r -> do+ hasM <- readIORef r+ !d <- case hasM of+ True -> pure d+ False -> pure $! d {defMightContainMetas = False}+ ((x, d):) <$!> goDefs defs++ !metas <- lift $ HMap.fromList <$> goMetas (MapS.toList metas)+ !defs <- lift $ HMap.fromList <$> goDefs (HMap.toList defs)+ pure (metas, defs, rootDisplayForms)++-- | Returns the instantiation.+-- Precondition: The instantiation must be of the form @'InstV' inst@.+theInstantiation :: MetaVariable -> Instantiation+theInstantiation mv = case mvInstantiation mv of+ InstV inst -> inst+ OpenMeta{} -> __IMPOSSIBLE__+ BlockedConst{} -> __IMPOSSIBLE__+ PostponedTypeCheckingProblem{} -> __IMPOSSIBLE__++-- | Converts from 'MetaVariable' to 'RemoteMetaVariable'.+-- Precondition: The instantiation must be of the form @'InstV' inst@.+remoteMetaVariable :: MetaVariable -> RemoteMetaVariable+remoteMetaVariable !mv = RemoteMetaVariable+ { rmvInstantiation = theInstantiation mv+ , rmvModality = getModality mv+ , rmvJudgement = mvJudgement mv+ }
@@ -0,0 +1,443 @@+-- | Imperfect discrimination trees for indexing data by internal+-- syntax.+module Agda.TypeChecking.DiscrimTree+ ( insertDT+ , lookupDT, lookupUnifyDT, QueryResult(..)+ , deleteFromDT+ )+ where++import qualified Data.Map.Strict as Map+import qualified Data.Set as Set+import Data.Foldable+import Data.Maybe++import Control.Monad.Trans.Maybe+import Control.Monad.Trans+import Control.Monad++import Agda.Syntax.Internal+import Agda.Syntax.Common++import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Records+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Free++import Agda.TypeChecking.DiscrimTree.Types++import qualified Agda.Interaction.Options.ProfileOptions as Profile++import Agda.Utils.Impossible+import Agda.Utils.Trie (Trie(..))+import Agda.Utils.List++-- | Dummy term to use as a stand-in for expanded eta-records while+-- building instance trees.+etaExpansionDummy :: Term+etaExpansionDummy = Dummy "eta-record argument in instance head" []++-- | Extract a list of arguments from the list of eliminations; If+-- called while *adding* an instance, additionally replace any arguments+-- that might belong to an eta-record by dummy terms.+termKeyElims+ :: Bool -- ^ Are we adding or looking up an instance?+ -> TCM Type -- ^ Continuation to compute the type of the arguments in the spine.+ -> [Arg Term] -- ^ The spine.+ -> TCM (Int, [Term])++-- Since the case tree was generated with wildcards everywhere an eta+-- record appeared, if we're *looking up* an instance, we don't have to+-- do the censorship again.+termKeyElims False _ es = do+ let !l = length es+ !es' = map' unArg es+ pure (l, es')++termKeyElims precise ty args = do+ let+ go ty (Arg _ a:as) = flip (ifPiTypeB ty) (patternViolation . getBlocker) \dom ty' -> do++ -- Is this argument an eta record type --- or a blocked value? In+ -- either case, we replace this position by a dummy, to make sure+ -- that eta-equality is respected.+ maybeEta <- ifBlocked (unDom dom) (\_ _ -> pure True) \_ tm ->+ isJust <$> isEtaRecordType tm++ let+ here+ | maybeEta = etaExpansionDummy+ | otherwise = a++ (k, there) <- addContext dom (go (unAbs ty') as)+ pure (k + 1, here:there)++ go _ [] = pure (0, [])++ ty >>= flip go args++-- | Ticky profiling for the reason behind "inexactness" in instance+-- search. If at some point while narrowing the set of candidates we had+-- to go through all the possibilities, one of these counters is+-- incremented.+tickExplore :: Term -> TCM ()+tickExplore tm = whenProfile Profile.Instances do+ tick "explore"++ case tm of+ Def{} -> tick "explore: Def"+ Var{} -> tick "explore: Var"+ Lam _ v+ -- These two are a hunch: just like FunK, it might be worth+ -- optimising for the case where a lambda is constant (which is+ -- easy to handle, by just pretending the term is something else).+ -- These would come up in e.g. Dec (PathP (λ i → Nat) x y)+ | NoAbs{} <- v -> tick "explore: constant function"+ | Abs _ b <- v, not (0 `freeIn` b) -> tick "explore: constant function"++ | otherwise -> tick "explore: Lam"+ Lit{} -> tick "explore: Lit"+ Sort{} -> tick "explore: Sort"+ Level{} -> tick "explore: Level"+ MetaV{} -> tick "explore: Meta"+ DontCare{} -> tick "explore: DontCare"+ _ -> pure ()++-- | Split a term into a 'Key' and some arguments. The 'Key' indicates+-- whether or not the 'Term' is in head-normal form, and provides a+-- quick way to match on the head.+--+-- The 'Int' argument indicates how free a variable must be to be+-- considered a 'LocalK'.+--+-- Presently, non-head-normal terms end up with an empty argument list.+splitTermKey :: Bool -> Int -> Term -> TCM (Key, [Term], Blocker)+splitTermKey precise local tm = catchPatternErr (\b -> pure (FlexK, [], b)) do+ (b, tm') <- ifBlocked tm (\b _ -> patternViolation b) (\b -> fmap (b,) . constructorForm)++ case tm' of+ -- Adding a 'Def' to the key poses a few problems when opacity (or+ -- abstractness) are involved (see issue #7304). Suppose we have an+ -- opaque binding `X = Y`, and an opaque instance `C X`. The problem+ -- is as follows:+ --+ -- if we unfold X → Y when adding the instance, then it will not+ -- get recorded as an instance for C X, only C Y; this is 7304b.+ --+ -- if we *don't* unfold X → Y, then it only gets added as an+ -- instance of C X; in opaque blocks where X is allowed to unfold,+ -- we *won't* find it, because we're looking for C Y.+ --+ -- The solution is to throw our hands up and say "not our problem".+ -- The discrimination tree is allowed to return more results than+ -- strictly necessary, after all, so the solution is to add an+ -- instance for *neither* of C X or C Y, but instead, to treat all+ -- 'Def's headed by 'AbstractDefn' as though they were flexible+ -- (think "as though they were metas").+ Def q as | ReallyNotBlocked <- b, (as, _) <- splitApplyElims as -> do+ info <- getConstInfo q+ case theDef info of+ AbstractDefn{} | precise -> pure (FlexK, [], neverUnblock)+ _ -> do+ (arity, as) <- termKeyElims precise (pure (defType info)) as+ pure (RigidK q arity, as, neverUnblock)++ -- When adding a quantified instance, we record how many 'Pi's we went+ -- under, and only variables beyond those are considered LocalK. The+ -- others are considered FlexK since they're "pattern variables" of+ -- the instance.+ Var i as | i >= local, Just as <- allApplyElims as -> do+ let ty = unDom <$> domOfBV i+ (arity, as) <- termKeyElims precise ty as+ pure (LocalK (i - local) arity, as, neverUnblock)++ -- When looking up an instance, it's better to treat variables and+ -- neutral definitions as rigid things regardless of their spines+ -- (especially if they have projections), than it is to try to+ -- represent them accurately.+ Def q as | not precise -> pure (RigidK q 0, [], neverUnblock)+ Var i as | not precise, i >= local -> pure (LocalK (i - local) 0, [], neverUnblock)++ Con ch _ as | Just as <- allApplyElims as -> do+ let+ q = conName ch+ ty = defType <$> getConstInfo q+ (arity, as) <- termKeyElims precise ty as+ pure (RigidK q arity, as, neverUnblock)++ Pi dom ret ->+ let+ -- If we're looking at a non-dependent function type, then we+ -- might as well represent the codomain accurately; Otherwise,+ -- turn the codomain into a wildcard.+ --+ -- The use of a dummy term *shouldn't* leak to the user, because+ -- when we call splitTermKey again, it'll be handled by the last+ -- case, and become a FlexK.+ ret' = case isNoAbs (unEl <$> ret) of+ Just b -> b+ Nothing -> __DUMMY_TERM__+ in pure (PiK (getHiding dom), [unEl (unDom dom), ret'], neverUnblock)++ Lam _ body+ -- Constant lambdas come up quite a bit, particularly (in cubical+ -- mode) as the domain of a PathP. Having this trick improves the+ -- indexing of 'Dec' instances in the 1Lab significantly.+ | Just b <- isNoAbs body -> pure (ConstK, [b], neverUnblock)++ -- Probably not a good idea for accurate indexing if universes+ -- overlap literally everything else.+ Sort _ -> pure (SortK, [], neverUnblock)++ _ -> do+ reportSDoc "tc.instance.split" 30 $ pretty tm+ pure (FlexK, [], neverUnblock)++termPath :: Int -> Bool -> Int -> [Key] -> [Term] -> TCM [Key]+termPath 0 _ _ acc _ = pure $! reverse acc+termPath limit toplevel local acc [] = pure $! reverse acc+termPath limit toplevel local acc (tm:todo) = do++ -- We still want to ignore abstractness at the very top-level of+ -- instance heads, for issue #6941, to ensure that each instance ends+ -- up in the right 'class'. See the comment in `splitTermKey` about+ -- abstract definitions.+ (k, as, blk) <-+ if toplevel+ then ignoreAbstractMode (splitTermKey True local tm)+ else splitTermKey True local tm++ reportSDoc "tc.instance.discrim.add" 666 $ vcat+ [ "k: " <+> prettyTCM k+ , "as: " <+> prettyTCM as+ , "blk:" <+> prettyTCM blk+ , "lim:" <+> prettyTCM limit+ ]+ termPath (limit - 1) False local (k:acc) (as <> todo)++-- | Maximum length for the keys (thus, depth for the discrimination+-- tree) that should be used.+--+-- Adding an instance still causes reduction of everything 'rigid' in+-- the type of the instance (so if normalisation is slow, so will be+-- adding the instance) but this limit prevents us from building a+-- discrimination tree with 2^32 intermediate @case 0 of suc → ...@+-- nodes.+discrimTreeDepthLimit :: Int+discrimTreeDepthLimit = 16++-- | Insert a value into the discrimination tree, turning variables into+-- rigid locals or wildcards depending on the given scope.+insertDT+ :: (Ord a, PrettyTCM a)+ => Int -- ^ Number of variables to consider wildcards, e.g. the number of leading invisible pis in an instance type.+ -> Term -- ^ The term to use as a key+ -> a+ -> DiscrimTree a+ -> TCM (DiscrimTree a)+insertDT local key val tree = do+ path <- termPath discrimTreeDepthLimit True local [] [key]+ let it = singletonDT path val+ reportSDoc "tc.instance.discrim.add" 20 $ vcat+ [ "added value" <+> prettyTCM val <+> "to discrimination tree with case"+ , nest 2 (prettyTCM it)+ , "its type:"+ , nest 2 (prettyTCM key)+ , "its path:"+ , nest 2 (prettyTCM path)+ ]+ pure $ mergeDT it tree++-- | If a term matches this key, how many arguments does it place on the+-- spine?+keyArity :: Key -> Int+keyArity = \case+ RigidK _ a -> a+ LocalK _ a -> a+ PiK _ -> 2+ ConstK -> 1+ SortK -> 0+ FlexK -> 0++data QueryResult a = QueryResult+ { resultValues :: Set.Set a+ , resultBlocker :: Blocker+ }++instance Ord a => Semigroup (QueryResult a) where+ QueryResult s b <> QueryResult s' b' = QueryResult (s <> s') (b `unblockOnEither` b')++instance Ord a => Monoid (QueryResult a) where+ mempty = QueryResult mempty neverUnblock++setResult :: Set.Set a -> QueryResult a+setResult = flip QueryResult neverUnblock++blockerResult :: Blocker -> QueryResult a+blockerResult = QueryResult Set.empty++-- | Look up a 'Term' in the given discrimination tree, treating local+-- variables as rigid symbols. The returned set is guaranteed to contain+-- everything that could overlap the given key.+lookupDT :: forall a. (Ord a, PrettyTCM a) => Term -> DiscrimTree a -> TCM (QueryResult a)+lookupDT = lookupDT' True++-- | Look up a 'Term' in the given discrimination tree, treating local+-- variables as wildcards.+lookupUnifyDT :: forall a. (Ord a, PrettyTCM a) => Term -> DiscrimTree a -> TCM (QueryResult a)+lookupUnifyDT = lookupDT' False++lookupDT'+ :: forall a. (Ord a, PrettyTCM a)+ => Bool -- ^ Should local variables be treated as rigid?+ -> Term -- ^ The term to use as key+ -> DiscrimTree a+ -> TCM (QueryResult a)+lookupDT' localsRigid term tree = match True [term] tree where++ split :: Term -> TCM (Key, [Term], Blocker)+ split tm | localsRigid = splitTermKey False 0 tm+ split tm = do+ ctx <- getContextSize+ splitTermKey False ctx tm++ ignoreAbstractMaybe :: forall a. Bool -> TCM a -> TCM a+ ignoreAbstractMaybe True = ignoreAbstractMode+ ignoreAbstractMaybe False = id++ -- Match a spine against *all* clauses.+ explore :: [Term] -> [Term] -> [Term] -> [(Key, DiscrimTree a)] -> TCM (QueryResult a)+ explore sp0 sp1 args bs = do+ let+ cont (key, trie) res = do+ -- At the moment, explore will always be called with empty args.+ -- But even if this restriction is lifted in the future, we have+ -- to be careful about exploring. Consider:+ --+ -- instance+ -- _ : Foo (con x)+ --+ -- ⊢ Foo ?0+ --+ -- Since ?0 might be applied to more or less arguments than the+ -- one argument that is expected to be between sp0 and sp1 after+ -- matching con, we need to make sure that the spine has the+ -- right number of arguments, otherwise the (sp0, t:sp1) pattern+ -- for a Case will fail.+ let args' = take' (keyArity key) $ args ++! [ __DUMMY_TERM_WITH__ ("_pad" <> show n) | n <- [0..] ]++ reportSDoc "tc.instance.discrim.lookup" 99 $ vcat+ [ "explore" <+> prettyTCM key <+> pretty (keyArity key) <+> pretty (length args)+ , nest 2 (prettyTCM trie)+ , "sp0: " <+> prettyTCM sp0+ , "sp1: " <+> prettyTCM sp1+ , "args: " <+> prettyTCM args+ , "args':" <+> prettyTCM args'+ ]+ (<> res) <$> match False (sp0 ++ args' ++ sp1) trie++ foldrM cont mempty bs++ match :: Bool -> [Term] -> DiscrimTree a -> TCM (QueryResult a)+ match toplevel ts EmptyDT = pure mempty+ match toplevel ts (DoneDT t) = setResult t <$ do+ reportSDoc "tc.instance.discrim.lookup" 99 $ vcat+ [ "done" <+> prettyTCM ts+ , " →" <+> prettyTCM t+ ]++ match toplevel ts tree@(CaseDT i branches rest) | (sp0, t:sp1) <- splitAt i ts = do+ let+ (sp0, t:sp1) = splitAt i ts+ visit k sp' = case Map.lookup k branches of+ Just m -> match False sp' m+ Nothing -> pure mempty++ unless toplevel $ reportSDoc "tc.instance.discrim.lookup" 99 $ vcat+ [ "match" <+> prettyTCM sp0 <+> ("«" <> prettyTCM t <> "»") <+> prettyTCM sp1+ , prettyTCM tree+ ]++ -- TODO (Amy, 2024-02-12): Could use reduceB in splitTermKey, and+ -- the blocker here, to suspend instances more precisely when there+ -- is an ambiguity.+ ignoreAbstractMaybe toplevel (split t) >>= \case+ (FlexK, args, blocker) -> do++ reportSDoc "tc.instance.discrim.lookup" 99 $ vcat+ [ "flexible term was forced"+ , "t:" <+> (pretty =<< instantiate t)+ , "will explore" <+> pretty (length branches + 1) <+> "branches"+ ]+ tickExplore t++ -- If we have a "flexible head" at this position then instance+ -- search *at this point* degenerates to looking for all+ -- possible matches.+ --+ -- In any nested CaseDTs, however, it's possible for us to+ -- recover and go back to productively matching. Consider:+ --+ -- instance+ -- xa : X T1 A+ -- xb : X T2 B+ --+ -- ⊢ X ?0 A+ --+ -- Since ?0 is way too flabby to narrow which of T1 or T2 should+ -- be taken, we take both. But then we match A against A and B:+ -- this query will only return {xa}.++ branches <- explore sp0 sp1 args $ Map.toList branches+ rest <- match False ts rest++ pure $! rest <> branches <> blockerResult blocker++ (k, args, blocker) -> do+ let sp' = sp0 ++ args ++ sp1++ -- Actually take the branch corresponding to our rigid head.+ branch <- visit k sp'++ -- When exploring the rest of the tree, the value we cased on+ -- has to be put back in the tree. mergeDT does not perform+ -- commuting conversions to ensure that variables aren't+ -- repeatedly cased on.+ rest <- match False ts rest++ pure $! rest <> branch++ match _ ts tree@(CaseDT i _ rest) = do+ reportSDoc "tc.instance.discrim.lookup" 99 $ vcat+ [ "IMPOSSIBLE match" <+> prettyTCM ts+ , prettyTCM tree+ ]+ -- This really is impossible: since each branch is annotated with+ -- its arity, we only take branches corresponding to neutrals which+ -- exploded into enough arguments.+ __IMPOSSIBLE__++-- | Smart constructor for a leaf node.+doneDT :: Set.Set a -> DiscrimTree a+doneDT s | Set.null s = EmptyDT+doneDT s = DoneDT s++-- | Remove a set of values from the discrimination tree. The tree is+-- rebuilt so that cases with no leaves are removed.+deleteFromDT :: Ord a => Set.Set a -> DiscrimTree a -> DiscrimTree a+deleteFromDT gone = \case+ EmptyDT -> EmptyDT+ DoneDT s -> doneDT $! Set.difference s gone+ CaseDT i s k ->+ let+ del x = case deleteFromDT gone x of+ EmptyDT -> Nothing+ dt' -> Just dt'++ s' = Map.mapMaybe del s+ k' = deleteFromDT gone k+ in if | Map.null s' -> k'+ | otherwise -> CaseDT i s' k'
@@ -0,0 +1,140 @@+module Agda.TypeChecking.DiscrimTree.Types where++import Control.DeepSeq++import qualified Data.Map.Strict as Map+import qualified Data.Set as Set++import Data.Map.Strict (Map)+import Data.Set (Set)++import GHC.Generics (Generic)++import Agda.Syntax.Internal+import Agda.Syntax.Position+import Agda.Syntax.Common++import Agda.Utils.Impossible+import Agda.Utils.Null++data Key+ = RigidK {-# UNPACK #-} !QName {-# UNPACK #-} !Int+ -- ^ Rigid symbols (constructors, data types, record types,+ -- postulates) identified by a QName.+ | LocalK {-# UNPACK #-} !Int {-# UNPACK #-} !Int+ -- ^ Local variables.++ | PiK Hiding+ -- ^ Dependent function types. The domain will be represented+ -- accurately, for the case of a genuine dependent function type,+ -- the codomain will be a dummy.++ | ConstK+ -- ^ Constant lambdas.++ | SortK+ -- ^ Universes.++ | FlexK+ -- ^ Anything else.+ deriving (Show, Eq, Ord, Generic)++instance NFData Key++-- | A 'Term'-indexed associative data structure supporting+-- /approximate/ (conservative) lookup. Rather than using a @Trie@ keyed+-- by 'Key' directly, a 'DiscrimTree' is instead represented more like a+-- /case/ tree.+--+-- This allows us to exploit the fact that instance selection often+-- focuses on a small part of the term: Only that critical chain is+-- represented in the tree. As an example, level parameters are unlikely+-- to contribute to narrowing a search problem, so it would be wasteful+-- to have an indirection in the tree for every 'FlexK' standing for a+-- level parameter.+data DiscrimTree a+ = EmptyDT+ -- ^ The empty discrimination tree.+ | DoneDT (Set a)+ -- ^ Succeed with a given set of values.+ | CaseDT+ -- ^ Do case analysis on a term. 'CaseDT' is scoped in the same way+ -- as fast case trees for the abstract machine: When matching+ -- actually succeeds, the variable that was matched gets replaced by+ -- its arguments directly in the context.+ {-# UNPACK #-} !Int -- ^ The variable to case on.+ (Map Key (DiscrimTree a)) -- ^ The proper branches.+ (DiscrimTree a) -- ^ A further tree, which should always be explored.+ deriving (Generic, Eq, Show)++{-+The extra continuation to CaseDT is used to represent instance tables+which have non-trivial overlap, e.g.++ instance+ a : Foo X ?+ b : Foo ? X++If we commited to the {a} branch of the discrimination tree, then we+would miss {b} entirely. Note that an "obvious" overlap like++ instance+ a : Bar X+ b : Bar X++would be represented as++ case 0 of+ Bar → case 0 of+ X → done {a, b}++and the extra continuation would be empty.+-}++instance NFData a => NFData (DiscrimTree a)++instance (KillRange a, Ord a) => KillRange (DiscrimTree a) where+ killRange = \case+ EmptyDT -> EmptyDT+ DoneDT s -> killRangeN DoneDT s+ CaseDT i k o -> killRangeN CaseDT i k o++instance Null (DiscrimTree a) where+ empty = EmptyDT+ null = \case+ EmptyDT -> True+ _ -> False++-- | Merge a pair of discrimination trees. This function tries to build+-- the minimal discrimination tree that yields the union of the inputs'+-- results, though it does so slightly naïvely, without considerable+-- optimisations (e.g. it does not turn single-alternative 'CaseDT's+-- into 'DoneDT's).+mergeDT :: Ord a => DiscrimTree a -> DiscrimTree a -> DiscrimTree a+mergeDT EmptyDT x = x+mergeDT (DoneDT s) x = case x of+ EmptyDT -> DoneDT s+ DoneDT s' -> DoneDT (s <> s')+ CaseDT i bs x -> CaseDT i bs (mergeDT (DoneDT s) x)+mergeDT (CaseDT i bs els) x = case x of+ EmptyDT -> CaseDT i bs els+ DoneDT s -> CaseDT i bs (mergeDT (DoneDT s) els)+ CaseDT j bs' els' -> case compare i j of+ EQ -> CaseDT j (Map.unionWith mergeDT bs bs') (mergeDT els els')+ LT -> CaseDT i bs (mergeDT els (CaseDT j bs' els'))+ GT -> CaseDT j bs' (mergeDT els' (CaseDT i bs els))++instance Ord a => Semigroup (DiscrimTree a) where+ (<>) = mergeDT++instance Ord a => Monoid (DiscrimTree a) where+ mempty = EmptyDT++-- | Construct the case tree corresponding to only performing proper+-- matches on the given key. In this context, a "proper match" is any+-- 'Key' that is not 'FlexK'.+singletonDT :: [Key] -> a -> DiscrimTree a+singletonDT key val = go 0 key where+ go focus [] = DoneDT $ Set.singleton val+ go focus (FlexK:ts) = go (focus + 1) ts+ go focus (t:ts) = CaseDT focus (Map.singleton t (go focus ts)) EmptyDT
@@ -1,80 +1,295 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE UndecidableInstances #-} -- for Arg a => Elim' a -module Agda.TypeChecking.DisplayForm where+-- | Tools for 'DisplayTerm' and 'DisplayForm'. -import Control.Applicative+module Agda.TypeChecking.DisplayForm (displayForm) where+ import Control.Monad-import Control.Monad.Error+import Control.Monad.Trans (lift)+import Control.Monad.Trans.Maybe +import Data.Monoid (All(..))+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import Data.Map (Map)+import qualified Data.Map as Map+import qualified Data.Set as Set+ import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Internal.Names+import Agda.Syntax.Scope.Base (inverseScopeLookupName)+ import Agda.TypeChecking.Monad import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Reduce-import Agda.Syntax.Scope.Base-import Agda.Utils.Size+import Agda.TypeChecking.Level+import Agda.TypeChecking.Reduce (instantiate) -#include "../undefined.h"+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.List1 (List1)+import Agda.Utils.Maybe+import Agda.Syntax.Common.Pretty+ import Agda.Utils.Impossible -displayForm :: QName -> Args -> TCM (Maybe DisplayTerm)-displayForm c vs = do- odfs <- defDisplay <$> getConstInfo c- unless (null odfs) $ verboseS "tc.display.top" 100 $ do- n <- getContextId- let fvs = map (\(OpenThing n _) -> n) odfs- reportSLn "" 0 $ "displayForm: context = " ++ show n ++ ", dfs = " ++ show fvs- dfs <- do- xs <- mapM tryOpen odfs- return [ df | Just df <- xs ]+-- | Get the arities of all display forms for a name.+displayFormArities :: (HasConstInfo m, ReadTCState m) => QName -> m [Int]+displayFormArities q = map (length . dfPats . dget) <$> getDisplayForms q++-- | Lift a local display form to an outer context. The substitution goes from the parent context to+-- the context of the local display form (see Issue 958). Current only handles pure extensions of+-- the parent context.+liftLocalDisplayForm :: Substitution -> DisplayForm -> Maybe DisplayForm+liftLocalDisplayForm IdS df = Just df+liftLocalDisplayForm (Wk n IdS) (Display m lhs rhs) =+ -- We lift a display form by turning matches on free variables into pattern variables, which can+ -- be done by simply adding to the dfPatternVars field.+ Just $ Display (n + m) lhs rhs+liftLocalDisplayForm _ _ = Nothing++type MonadDisplayForm m =+ ( MonadReduce m+ , ReadTCState m+ , HasConstInfo m+ , HasBuiltins m+ , MonadDebug m+ )++-- | Find a matching display form for @q es@.+-- In essence this tries to rewrite @q es@ with any+-- display form @q ps --> dt@ and returns the instantiated+-- @dt@ if successful. First match wins.+displayForm :: MonadDisplayForm m => QName -> Elims -> m (Maybe DisplayTerm)+displayForm q es = do+ -- Get display forms for name q.+ odfs <- getDisplayForms q+ if (null odfs) then do+ reportSLn "tc.display.top" 101 $ "no displayForm for " ++ prettyShow q+ return Nothing+ else do+ -- Display debug info about the @Open@s.+ unlessDebugPrinting $ reportSDoc "tc.display.top" 100 $ do+ cps <- viewTC eCheckpoints+ cxt <- getContextTelescope+ return $ vcat+ [ "displayForm for" <+> pretty q+ , nest 2 $ "cxt =" <+> pretty cxt+ , nest 2 $ "cps =" <+> vcat (map pretty (Map.toList cps))+ , nest 2 $ "dfs =" <+> vcat (map pretty odfs) ]+ -- Use only the display forms that can be opened in the current context.+ dfs <- catMaybes <$> mapM (tryGetOpen liftLocalDisplayForm) odfs scope <- getScope- let matches dfs vs = [ m | Just m <- map (flip matchDisplayForm vs) dfs, inScope scope m ]+ -- Keep the display forms that match the application @q es@.+ ms <- do+ ms <- mapM (runMaybeT . (`matchDisplayForm` es)) dfs+ return [ m | Just (d, m) <- ms, wellScoped scope d ] -- Not safe when printing non-terminating terms.- -- (nfdfs, us) <- normalise (dfs, vs)- unless (null odfs) $ reportSLn "tc.display.top" 100 $ unlines- [ "displayForms: " ++ show dfs- , "arguments : " ++ show vs- , "matches : " ++ show (matches dfs vs)- , "result : " ++ show (foldr (const . Just) Nothing $ matches dfs vs)+ -- (nfdfs, us) <- normalise (dfs, es)+ unlessDebugPrinting $ reportS "tc.display.top" 100 $ vcat+ [ "name :" <+> pretty q+ , "displayForms:" <+> pretty dfs+ , "arguments :" <+> pretty es+ , "matches :" <+> pretty ms+ , "result :" <+> pretty (listToMaybe ms) ]- return $ foldr (const . Just) Nothing $ matches dfs vs -- ++ matches nfdfs us- `catchError` \_ -> return Nothing+ -- Return the first display form that matches.+ return $ listToMaybe ms where- inScope _ _ = True -- TODO: distinguish between with display forms and other display forms--- inScope scope d = case hd d of--- Just h -> maybe False (const True) $ inverseScopeLookupName h scope--- Nothing -> __IMPOSSIBLE__ -- TODO: currently all display forms have heads- hd (DTerm (Def x _)) = Just x- hd (DTerm (Con x _)) = Just x- hd (DWithApp (d : _) _) = hd d- hd _ = Nothing+ -- Look at the original display form, not the instantiated result when+ -- checking if it's well-scoped. Otherwise we might pick up out of scope+ -- identifiers coming from the source term.+ wellScoped scope (Display _ _ d)+ | isWithDisplay d = True+ | otherwise = getAll $ namesIn' (All . inScope scope) d -- all names in d should be in scope -matchDisplayForm :: DisplayForm -> Args -> Maybe DisplayTerm-matchDisplayForm (Display n ps v) vs- | length ps > length vs = Nothing+ inScope scope x = not $ null $ inverseScopeLookupName x scope++ isWithDisplay DWithApp{} = True+ isWithDisplay _ = False++-- | Match a 'DisplayForm' @q ps = v@ against @q es@.+-- Return the 'DisplayTerm' @v[us]@ if the match was successful,+-- i.e., @es / ps = Just us@.+matchDisplayForm :: MonadDisplayForm m+ => DisplayForm -> Elims -> MaybeT m (DisplayForm, DisplayTerm)+matchDisplayForm d@(Display n ps v) es+ | length ps > length es = mzero | otherwise = do- us <- match n ps $ raise 1 (map unArg vs0)- return $ substs (reverse us ++ ctx) v `apply` vs1- where- -- TODO: figure out the length of the context- ctx = [ Var i [] | i <- [0..] ]- (vs0, vs1) = splitAt (length ps) vs+ let (es0, es1) = splitAt (length ps) es + -- The 'Display' constructor acts as though it binds the pattern+ -- pattern variables up to 'n', so a match like+ --+ -- Display 1 [@1 @0] x =? [@0 _]+ --+ -- should work (it didn't; see LiftDisplayIntermediate). In+ -- effect, this is because the LHS patterns are in some context+ -- "Γ . @0", but the RHS term is only in context Γ.+ --+ -- Therefore, we should raise the RHS term by the number of+ -- pattern variables, to bring it into the context of the+ -- patterns.++ mm <- match (Window 0 n) ps (raise n es0)+ us <- forM [0 .. n - 1] $ \ i -> do+ -- #5294: Fail if we don't have bindings for all variables. This can+ -- happen outside parameterised modules when some of the parameters+ -- are not used in the lhs.+ Just u <- return $ IntMap.lookup i mm+ -- Note that the RHS terms are independent of the pattern variables.+ return (applySubst (strengthenS __IMPOSSIBLE__ n) <$> u)+ return (d, substWithOrigin (parallelS $ map woThing us) us v `applyE` es1)++type MatchResult = IntMap (WithOrigin Term)++unionMatch :: Monad m => MatchResult -> MatchResult -> MaybeT m MatchResult+unionMatch m1 m2+ | null (IntMap.intersection m1 m2) = return $ IntMap.union m1 m2+ | otherwise = mzero -- Non-linear pattern, fail for now.++unionsMatch :: Monad m => [MatchResult] -> MaybeT m MatchResult+unionsMatch = foldM unionMatch mempty++data Window = Window {dbLo, dbHi :: Nat}++inWindow :: Window -> Nat -> Maybe Nat+inWindow (Window lo hi) n | lo <= n, n < hi = Just (n - lo)+ | otherwise = Nothing++shiftWindow :: Window -> Window+shiftWindow (Window lo hi) = Window (lo + 1) (hi + 1)++-- | Class @Match@ for matching a term @p@ in the role of a pattern+-- against a term @v@.+--+-- Free variables inside the window in @p@ are pattern variables and+-- the result of matching is a map from pattern variables (shifted down to start at 0) to subterms+-- of @v@. class Match a where- match :: Nat -> a -> a -> Maybe [Term]+ match :: MonadDisplayForm m => Window -> a -> a -> MaybeT m MatchResult instance Match a => Match [a] where- match n xs ys = concat <$> zipWithM (match n) xs ys+ match n xs ys+ | length xs == length ys = unionsMatch =<< zipWithM (match n) xs ys+ | otherwise = mzero instance Match a => Match (Arg a) where- match n p v = match n (unArg p) (unArg v)+ match n p v = IntMap.map (setOrigin (getOrigin v)) <$> match n (unArg p) (unArg v) +instance Match a => Match (Elim' a) where+ match n p v =+ case (p, v) of+ (Proj _ f, Proj _ f') | f == f' -> return mempty+ _ | Just a <- isApplyElim p+ , Just a' <- isApplyElim v -> match n a a'+ -- we do not care to differentiate between Apply and IApply for+ -- printing.+ _ -> mzero+ instance Match Term where- match n p v = case (p, v) of- (Var 0 [], v) -> return [subst __IMPOSSIBLE__ v]- (Var i ps, Var j vs) | i == j -> match n ps vs- (Def c ps, Def d vs) | c == d -> match n ps vs- (Con c ps, Con d vs) | c == d -> match n ps vs- (Lit l, Lit l') | l == l' -> return []- (p, v) | p == v -> return []- _ -> fail ""+ match w p v = lift (instantiate v) >>= \ v -> case (unSpine p, unSpine v) of+ (Var i [], v) | Just j <- inWindow w i -> return $ IntMap.singleton j (WithOrigin Inserted v)+ (Var i (_:_), v) | Just{} <- inWindow w i -> mzero -- Higher-order pattern, fail for now.+ (Var i ps, Var j vs) | i == j -> match w ps vs+ (Def c ps, Def d vs) | c == d -> match w ps vs+ (Con c _ ps, Con d _ vs) | c == d -> match w ps vs+ (Lit l, Lit l') | l == l' -> return mempty+ (Lam h p, Lam h' v) | h == h' -> match (shiftWindow w) (unAbs p) (unAbs v)+ (p, v) | p == v -> return mempty -- TODO: this is wrong (this is why we lifted the rhs before)+ (p, Level l) -> match w p =<< reallyUnLevelView l+ (Sort ps, Sort pv) -> match w ps pv+ (p, Sort (Type v)) -> match w p =<< reallyUnLevelView v+ _ -> mzero++instance Match Sort where+ match w p v = case (p, v) of+ (Type pl, Type vl) -> match w pl vl+ _ | p == v -> return mempty+ _ -> mzero++instance Match Level where+ match w p v = do+ p <- reallyUnLevelView p+ v <- reallyUnLevelView v+ match w p v++-- | Substitute terms with origin into display terms,+-- replacing variables along with their origins.+--+-- The purpose is to replace the pattern variables in a with-display form,+-- and only on the top level of the lhs. Thus, we are happy to fall back+-- to ordinary substitution where it does not matter.+-- This fixes issue #2590.++class SubstWithOrigin a where+ substWithOrigin :: Substitution -> [WithOrigin Term] -> a -> a++instance SubstWithOrigin a => SubstWithOrigin [a] where+ substWithOrigin rho ots = map (substWithOrigin rho ots)++instance SubstWithOrigin a => SubstWithOrigin (List1 a) where+ substWithOrigin rho ots = fmap (substWithOrigin rho ots)++instance (SubstWithOrigin a, SubstWithOrigin (Arg a)) => SubstWithOrigin (Elim' a) where+ substWithOrigin rho ots (Apply arg) = Apply $ substWithOrigin rho ots arg+ substWithOrigin rho ots e@Proj{} = e+ substWithOrigin rho ots (IApply u v w) = IApply+ (substWithOrigin rho ots u)+ (substWithOrigin rho ots v)+ (substWithOrigin rho ots w)++++instance SubstWithOrigin (Arg Term) where+ substWithOrigin rho ots (Arg ai v) =+ case v of+ -- pattern variable: replace origin if better+ Var x [] -> case ots !!! x of+ Just (WithOrigin o u) -> Arg (mapOrigin (replaceOrigin o) ai) u+ Nothing -> Arg ai $ applySubst rho v -- Issue #2717, not __IMPOSSIBLE__+ -- constructor: recurse+ Con c ci args -> Arg ai $ Con c ci $ substWithOrigin rho ots args+ -- def: recurse+ Def q es -> Arg ai $ Def q $ substWithOrigin rho ots es+ -- otherwise: fall back to ordinary substitution+ _ -> Arg ai $ applySubst rho v+ where+ replaceOrigin _ UserWritten = UserWritten+ replaceOrigin o _ = o++instance SubstWithOrigin Term where+ substWithOrigin rho ots v =+ case v of+ -- constructor: recurse+ Con c ci args -> Con c ci $ substWithOrigin rho ots args+ -- def: recurse+ Def q es -> Def q $ substWithOrigin rho ots es+ -- otherwise: fall back to oridinary substitution+ _ -> applySubst rho v++-- Do not go into dot pattern, otherwise interaction test #231 fails+instance SubstWithOrigin DisplayTerm where+ substWithOrigin rho ots =+ \case+ DTerm' v es -> DTerm' (substWithOrigin rho ots v) $ substWithOrigin rho ots es+ DDot' v es -> DDot' (substWithOrigin rho ots v) $ substWithOrigin rho ots es+ DDef q es -> DDef q $ substWithOrigin rho ots es+ DCon c ci args -> DCon c ci $ substWithOrigin rho ots args+ DWithApp t ts es -> DWithApp+ (substWithOrigin rho ots t)+ (substWithOrigin rho ots ts)+ (substWithOrigin rho ots es)++-- Do not go into dot pattern, otherwise interaction test #231 fails+instance SubstWithOrigin (Arg DisplayTerm) where+ substWithOrigin rho ots (Arg ai dt) =+ case dt of+ DTerm' v es -> substWithOrigin rho ots (Arg ai v) <&> (`DTerm'` substWithOrigin rho ots es)+ DDot' v es -> Arg ai $ DDot' (applySubst rho v) $ substWithOrigin rho ots es+ DDef q es -> Arg ai $ DDef q $ substWithOrigin rho ots es+ DCon c ci args -> Arg ai $ DCon c ci $ substWithOrigin rho ots args+ DWithApp t ts es -> Arg ai $ DWithApp+ (substWithOrigin rho ots t)+ (substWithOrigin rho ots ts)+ (substWithOrigin rho ots es)
@@ -0,0 +1,82 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.DropArgs where++import Agda.Syntax.Common+import Agda.Syntax.Internal++import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Substitute++import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Coverage.SplitTree++import Agda.Utils.List+import Agda.Utils.Permutation+import Agda.Utils.Tuple (second)++import Agda.Utils.Impossible++---------------------------------------------------------------------------+-- * Dropping initial arguments to create a projection-like function+---------------------------------------------------------------------------++-- | When making a function projection-like, we drop the first @n@+-- arguments.+class DropArgs a where+ dropArgs :: Int -> a -> a++instance DropArgs a => DropArgs (Maybe a) where+ dropArgs n = fmap (dropArgs n)++-- | NOTE: This creates telescopes with unbound de Bruijn indices.+instance DropArgs Telescope where+ dropArgs n tel = telFromList $ drop n $ telToList tel++instance DropArgs Permutation where+ dropArgs n (Perm m p) = Perm (m - n) $! map' (subtract n) $ drop n p++-- | NOTE: does not work for recursive functions.+instance DropArgs Clause where+ dropArgs n cl =+ cl{ -- Andreas, 2012-09-25: just dropping the front of telescope+ -- makes it ill-formed (unbound indices)+ -- we should let the telescope intact!?+ -- Ulf, 2016-06-23: Indeed. After parameter refinement it's even+ -- worse: the module parameters we want to drop aren't necessarily+ -- the first things in the telescope.+ namedClausePats = drop n $ namedClausePats cl+ -- BUG: need to drop also from recursive calls!!+ }++instance DropArgs FunctionInverse where+ dropArgs n finv = fmap (dropArgs n) finv++-- | Use for dropping initial lambdas in clause bodies.+-- NOTE: does not reduce term, need lambdas to be present.+instance DropArgs Term where+ dropArgs 0 = id+ dropArgs n = \case+ Lam h b -> dropArgs (n - 1) (absBody b)+ _ -> __IMPOSSIBLE__++-- | To drop the first @n@ arguments in a compiled clause,+-- we reduce the split argument indices by @n@ and+-- drop @n@ arguments from the bodies.+-- NOTE: this only works for non-recursive functions, we+-- are not dropping arguments to recursive calls in bodies.+instance DropArgs CompiledClauses where+ dropArgs n = \case+ Case i br+ | unArg i < n -> __IMPOSSIBLE__+ | otherwise -> Case (i <&> \ j -> j - n) $ fmap (dropArgs n) br+ Done no mr xs t+ | length xs < n -> __IMPOSSIBLE__+ | otherwise -> Done no mr (drop n xs) t+ Fail xs+ | length xs < n -> __IMPOSSIBLE__+ | otherwise -> Fail (drop n xs)++instance DropArgs SplitTree where+ dropArgs n (SplittingDone m) = SplittingDone (m - n)+ dropArgs n (SplitAt i lz ts) = SplitAt (subtract n <$> i) lz $ map' (second $ dropArgs n) ts
@@ -1,71 +0,0 @@-{-# LANGUAGE CPP #-}--module Agda.TypeChecking.Eliminators where--import Control.Applicative-import Control.Monad--import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.TypeChecking.Monad-import Agda.TypeChecking.Substitute-import Agda.Utils.Impossible-import Agda.TypeChecking.Reduce--#include "../undefined.h"--data ElimView = VarElim Nat [Elim]- | DefElim QName [Elim]- | ConElim QName [Elim]- | MetaElim MetaId [Elim]- | NoElim Term--elimView :: Term -> TCM ElimView-elimView v = do- -- We can't assume that v has been reduced here in recursive calls,- -- since reducing a stuck application doesn't necessarily reduces all- -- the arguments.- v <- reduce v- case v of- Def f vs -> do- proj <- isProjection f- case proj of- Nothing -> DefElim f `app` vs- Just{} -> do- case vs of- rv : vs' -> elim (Proj f : map Apply vs') <$> elimView (unArg rv)- [] -> __IMPOSSIBLE__- -- elimView should only be called from the conversion checker- -- with properly saturated applications- Var x vs -> VarElim x `app` vs- Con c vs -> ConElim c `app` vs- MetaV m vs -> MetaElim m `app` vs- Lam{} -> noElim- Lit{} -> noElim- Level{} -> noElim- Sort{} -> noElim- Pi{} -> noElim- DontCare{} -> noElim- where- noElim = return $ NoElim v- app f vs = return $ f $ map Apply vs- elim :: [Elim] -> ElimView -> ElimView- elim _ NoElim{} = __IMPOSSIBLE__- elim es2 (VarElim x es1) = VarElim x (es1 ++ es2)- elim es2 (DefElim x es1) = DefElim x (es1 ++ es2)- elim es2 (ConElim x es1) = ConElim x (es1 ++ es2)- elim es2 (MetaElim x es1) = MetaElim x (es1 ++ es2)---- | Only used when producing error messages.-unElimView :: ElimView -> Term-unElimView v = case v of- VarElim x es -> unElim (Var x []) es- DefElim x es -> unElim (Def x []) es- ConElim x es -> unElim (Con x []) es- MetaElim x es -> unElim (MetaV x []) es- NoElim v -> v--unElim :: Term -> [Elim] -> Term-unElim v [] = v-unElim v (Apply u : es) = unElim (v `apply` [u]) es-unElim v (Proj f : es) = unElim (Def f [Arg NotHidden Relevant v]) es
@@ -1,45 +1,121 @@+{-# OPTIONS_GHC -Wunused-imports #-} -module Agda.TypeChecking.Empty where+module Agda.TypeChecking.Empty+ ( isEmptyType+ , isEmptyTel+ , ensureEmptyType+ , checkEmptyTel+ ) where -import Control.Applicative+import Control.Monad.Except ( MonadError(..) ) import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Internal.MetaVars+import Agda.Syntax.Position import Agda.TypeChecking.Monad import Agda.TypeChecking.Coverage-import Agda.TypeChecking.Constraints-import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Coverage.SplitPattern ( fromSplitPatterns )+import Agda.TypeChecking.Records+import Agda.TypeChecking.Reduce ( instantiateFull ) import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope -import Agda.Utils.Permutation-import Agda.Utils.Size+import Agda.Utils.Either+import Agda.Utils.List+import Agda.Utils.Monad --- | Make sure that a type is empty.-isReallyEmptyType :: Type -> TCM ()-isReallyEmptyType t = noConstraints $ isEmptyType t+import Agda.Utils.Impossible -isEmptyType :: Type -> TCM ()-isEmptyType t = do- tb <- reduceB t- let t = ignoreBlocking tb- case unEl <$> tb of- -- if t is blocked or a meta, we cannot decide emptyness now. postpone- NotBlocked MetaV{} -> addConstraint (IsEmpty t)- Blocked{} -> addConstraint (IsEmpty t)- _ -> do- -- from the current context xs:ts, create a pattern list- -- xs _ : ts t and try to split on _ (the last variable)+data ErrorNonEmpty+ = Fail -- ^ Generic failure+ | FailBecause TCErr -- ^ Failure with informative error+ | DontKnow Blocker -- ^ Emptyness check blocked++instance Semigroup ErrorNonEmpty where+ DontKnow u1 <> DontKnow u2 = DontKnow $ unblockOnBoth u1 u2 -- Both must unblock for this to proceed+ e@DontKnow{} <> _ = e+ _ <> e@DontKnow{} = e+ FailBecause err <> _ = FailBecause err+ Fail <> err = err++instance Monoid ErrorNonEmpty where+ mempty = Fail++-- | Ensure that a type is empty.+-- This check may be postponed as emptiness constraint.+ensureEmptyType+ :: Range+ -- ^ Range of the absurd pattern.+ -> Dom Type+ -- ^ Type that should be empty (empty data type or iterated+ -- product of such).+ -> TCM ()+ensureEmptyType r t = caseEitherM (checkEmptyType r t) failure return+ where+ failure (DontKnow u) = addConstraint u $ IsEmpty r t+ failure (FailBecause err) = throwError err+ failure Fail = typeError $ ShouldBeEmpty (unDom t) []++-- | Check whether a type is empty.+isEmptyType :: MonadTCM tcm => Dom Type -> tcm Bool+isEmptyType ty = liftTCM $ isRight <$> checkEmptyType noRange ty++-- | Check whether some type in a telescope is empty.+isEmptyTel :: MonadTCM tcm => Telescope -> tcm Bool+isEmptyTel tel = liftTCM $ isRight <$> checkEmptyTel noRange tel++-- Either the type is possibly non-empty (Left err) or it is really empty+-- (Right ()).+checkEmptyType :: Range -> Dom Type -> TCM (Either ErrorNonEmpty ())+checkEmptyType range t0 = do+ mr <- tryRecordType (unDom t0)+ case mr of++ -- If t is blocked or a meta, we cannot decide emptiness now. Postpone.+ Left (Blocked b t) -> return $ Left (DontKnow b)++ -- If t is not a record type, try to split+ Left (NotBlocked nb t) -> do+ -- from the current context xs:ts, create a pattern list+ -- xs _ : ts t and try to split on _ (the last variable) tel0 <- getContextTelescope- let gamma = telToList tel0 ++ [defaultArg ("_", t)]- ps = [ Arg h r $ VarP x | Arg h r (x, _) <- gamma ]+ let gamma = telToList tel0 +++ -- Do not forget the original 'DomInfo' (see #8744).+ [(underscore, t) <$ t0] tel = telFromList gamma+ ps = teleNamedArgs tel - r <- split Inductive tel (idP $ size tel) ps 0+ dontAssignMetas $ do+ r <- splitLast Inductive tel ps+ case r of+ Left UnificationStuck{} -> do+ blocker <- unblockOnAnyMetaIn <$> instantiateFull tel -- TODO Jesper: get proper blocking information from unification+ return $ Left $ DontKnow blocker+ Left err@ErasedDatatype{} ->+ -- This case is for disallowed erased matches on empty+ -- types.+ Left . FailBecause <$> typeError_ (SplitError err)+ Left _ ->+ return $ Left Fail+ Right cov -> do+ let ps = map (namedArg . lastWithDefault __IMPOSSIBLE__ . fromSplitPatterns . scPats) $ splitClauses cov+ if (null ps) then return (Right ()) else+ Left . FailBecause <$> do typeError_ $ ShouldBeEmpty t ps - case r of- Left err -> case err of- CantSplit c tel us vs _ -> traceCall (CheckIsEmpty t) $ typeError $ CoverageCantSplitOn c tel us vs- _ -> typeError $ ShouldBeEmpty t []- Right [] -> return ()- Right cs -> typeError $ ShouldBeEmpty t $ map (unArg . last . scPats) cs+ -- If t is a record type, see if any of the field types is empty+ Right (r, pars, def) -> do+ if not (isEtaRecordDef def) then return $ Left Fail else+ void <$> do checkEmptyTel range $ _recTel def `apply` pars++-- | Check whether one of the types in the given telescope is constructor-less+-- and if yes, return its index in the telescope (0 = leftmost).+checkEmptyTel :: Range -> Telescope -> TCM (Either ErrorNonEmpty Int)+checkEmptyTel r = loop 0+ where+ loop i EmptyTel = return $ Left Fail+ loop i (ExtendTel dom tel) = orEitherM+ [ (i <$) <$> checkEmptyType r dom+ , underAbstraction dom tel $ loop (succ i)+ ]
@@ -1,8 +1,20 @@+{-# OPTIONS_GHC -Wunused-imports #-} -module Agda.TypeChecking.Empty where+module Agda.TypeChecking.Empty+ ( isEmptyType+ , isEmptyTel+ , ensureEmptyType+ , checkEmptyTel+ ) where -import Agda.TypeChecking.Monad (TCM)-import Agda.Syntax.Internal (Type)+import Agda.TypeChecking.Monad (TCM, MonadTCM)+import Agda.Syntax.Internal (Dom, Telescope, Type)+import Agda.Syntax.Position (Range) -isReallyEmptyType :: Type -> TCM ()-isEmptyType :: Type -> TCM ()+data ErrorNonEmpty++isEmptyType :: MonadTCM tcm => Dom Type -> tcm Bool+isEmptyTel :: MonadTCM tcm => Telescope -> tcm Bool++ensureEmptyType :: Range -> Dom Type -> TCM ()+checkEmptyTel :: Range -> Telescope -> TCM (Either ErrorNonEmpty Int)
@@ -1,681 +1,2344 @@-{-# LANGUAGE CPP #-}-module Agda.TypeChecking.Errors- ( prettyError- , PrettyTCM(..)- , tcErrString- ) where--import Control.Applicative ( (<$>) )-import Control.Monad.State-import Control.Monad.Error-import qualified Data.Map as Map (empty)-import System.FilePath--import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Position-import qualified Agda.Syntax.Info as A-import qualified Agda.Syntax.Concrete as C-import qualified Agda.Syntax.Concrete.Definitions as D-import Agda.Syntax.Abstract as A-import Agda.Syntax.Internal as I-import qualified Agda.Syntax.Abstract.Pretty as P-import qualified Agda.Syntax.Concrete.Pretty as P-import Agda.Syntax.Translation.InternalToAbstract-import Agda.Syntax.Translation.AbstractToConcrete-import Agda.Syntax.Scope.Base (ScopeInfo(..))--import Agda.TypeChecking.Monad-import Agda.TypeChecking.Pretty--import Agda.Utils.FileName-import Agda.Utils.Monad-import Agda.Utils.Size--#include "../undefined.h"-import Agda.Utils.Impossible-------------------------------------------------------------------------------- * Top level function------------------------------------------------------------------------------prettyError :: TCErr -> TCM String-prettyError err = liftTCM $ liftM show $- prettyTCM err- `catchError` \err' -> text "panic: error when printing error!" $$ prettyTCM err'- `catchError` \err'' -> text "much panic: error when printing error from printing error!" $$ prettyTCM err''- `catchError` \err''' -> fsep (- pwords "total panic: error when printing error from printing error from printing error." ++- pwords "I give up! Approximations of errors:" )- $$ vcat (map (text . tcErrString) [err,err',err'',err'''])-------------------------------------------------------------------------------- * Helpers------------------------------------------------------------------------------sayWhere :: HasRange a => a -> TCM Doc -> TCM Doc-sayWhere x d = text (show $ getRange x) $$ d--sayWhen :: Range -> Maybe (Closure Call) -> TCM Doc -> TCM Doc-sayWhen r Nothing m = sayWhere r m-sayWhen r (Just cl) m = sayWhere r (m $$ prettyTCM cl)--panic :: String -> TCM Doc-panic s = fwords $ "Panic: " ++ s--nameWithBinding :: QName -> TCM Doc-nameWithBinding q =- sep [ prettyTCM q, text "bound at", text (show r) ]- where- r = nameBindingSite $ qnameName q--tcErrString :: TCErr -> String-tcErrString err = show (getRange err) ++ " " ++ case errError err of- TypeError _ cl -> errorString $ clValue cl- Exception r s -> show r ++ " " ++ s- IOException r e -> show r ++ " " ++ show e- PatternErr _ -> "PatternErr"- {- AbortAssign _ -> "AbortAssign" -- UNUSED -}--errorString :: TypeError -> String-errorString err = case err of- AmbiguousModule{} -> "AmbiguousModule"- AmbiguousName{} -> "AmbiguousName"- AmbiguousParseForApplication{} -> "AmbiguousParseForApplication"- AmbiguousParseForLHS{} -> "AmbiguousParseForLHS"- AmbiguousTopLevelModuleName {} -> "AmbiguousTopLevelModuleName"- BothWithAndRHS -> "BothWithAndRHS"- BuiltinInParameterisedModule{} -> "BuiltinInParameterisedModule"- BuiltinMustBeConstructor{} -> "BuiltinMustBeConstructor"- ClashingDefinition{} -> "ClashingDefinition"- ClashingFileNamesFor{} -> "ClashingFileNamesFor"- ClashingImport{} -> "ClashingImport"- ClashingModule{} -> "ClashingModule"- ClashingModuleImport{} -> "ClashingModuleImport"- CompilationError{} -> "CompilationError"- ConstructorPatternInWrongDatatype{} -> "ConstructorPatternInWrongDatatype"- CoverageFailure{} -> "CoverageFailure"- CoverageCantSplitOn{} -> "CoverageCantSplitOn"- CoverageCantSplitIrrelevantType{} -> "CoverageCantSplitIrrelevantType"- CoverageCantSplitType{} -> "CoverageCantSplitType"- CyclicModuleDependency{} -> "CyclicModuleDependency"- DataMustEndInSort{} -> "DataMustEndInSort"- DifferentArities -> "DifferentArities"- DoesNotConstructAnElementOf{} -> "DoesNotConstructAnElementOf"- DuplicateBuiltinBinding{} -> "DuplicateBuiltinBinding"- DuplicateConstructors{} -> "DuplicateConstructors"- DuplicateFields{} -> "DuplicateFields"- DuplicateImports{} -> "DuplicateImports"- FieldOutsideRecord -> "FieldOutsideRecord"- FileNotFound{} -> "FileNotFound"- GenericError{} -> "GenericError"- IFSNoCandidateInScope{} -> "IFSNoCandidateInScope"- IlltypedPattern{} -> "IlltypedPattern"- IncompletePatternMatching{} -> "IncompletePatternMatching"- IndexFreeInParameter{} -> "IndexFreeInParameter"- IndexVariablesNotDistinct{} -> "IndexVariablesNotDistinct"- IndicesNotConstructorApplications{} -> "IndicesNotConstructorApplications"- InternalError{} -> "InternalError"- InvalidPattern{} -> "InvalidPattern"- LocalVsImportedModuleClash{} -> "LocalVsImportedModuleClash"- MetaCannotDependOn{} -> "MetaCannotDependOn"- MetaOccursInItself{} -> "MetaOccursInItself"- ModuleArityMismatch{} -> "ModuleArityMismatch"- ModuleDefinedInOtherFile {} -> "ModuleDefinedInOtherFile"- ModuleDoesntExport{} -> "ModuleDoesntExport"- ModuleNameDoesntMatchFileName {} -> "ModuleNameDoesntMatchFileName"- NoBindingForBuiltin{} -> "NoBindingForBuiltin"- NoParseForApplication{} -> "NoParseForApplication"- NoParseForLHS{} -> "NoParseForLHS"- NoRHSRequiresAbsurdPattern{} -> "NoRHSRequiresAbsurdPattern"- NotInductive {} -> "NotInductive"- AbsurdPatternRequiresNoRHS{} -> "AbsurdPatternRequiresNoRHS"- NoSuchBuiltinName{} -> "NoSuchBuiltinName"- NoSuchModule{} -> "NoSuchModule"- NoSuchPrimitiveFunction{} -> "NoSuchPrimitiveFunction"- NotAModuleExpr{} -> "NotAModuleExpr"- NotAProperTerm -> "NotAProperTerm"- NotAValidLetBinding{} -> "NotAValidLetBinding"- NotAnExpression{} -> "NotAnExpression"- NotImplemented{} -> "NotImplemented"- NotSupported{} -> "NotSupported"- NotInScope{} -> "NotInScope"- NotLeqSort{} -> "NotLeqSort"- NotStrictlyPositive{} -> "NotStrictlyPositive"- NothingAppliedToHiddenArg{} -> "NothingAppliedToHiddenArg"- NothingAppliedToInstanceArg{} -> "NothingAppliedToInstanceArg"- OverlappingProjects {} -> "OverlappingProjects"- PatternShadowsConstructor {} -> "PatternShadowsConstructor"- PropMustBeSingleton -> "PropMustBeSingleton"- RepeatedVariablesInPattern{} -> "RepeatedVariablesInPattern"- SafeFlagPostulate{} -> "SafeFlagPostulate"- SafeFlagPragma{} -> "SafeFlagPragma"- SafeFlagPrimTrustMe{} -> "SafeFlagPrimTrustMe"- ShadowedModule{} -> "ShadowedModule"- ShouldBeASort{} -> "ShouldBeASort"- ShouldBeApplicationOf{} -> "ShouldBeApplicationOf"- ShouldBeAppliedToTheDatatypeParameters{} -> "ShouldBeAppliedToTheDatatypeParameters"- ShouldBeEmpty{} -> "ShouldBeEmpty"- ShouldBePi{} -> "ShouldBePi"- ShouldBeRecordType{} -> "ShouldBeRecordType"- ShouldEndInApplicationOfTheDatatype{} -> "ShouldEndInApplicationOfTheDatatype"- TerminationCheckFailed{} -> "TerminationCheckFailed"- TooFewFields{} -> "TooFewFields"- TooManyArgumentsInLHS{} -> "TooManyArgumentsInLHS"- TooManyFields{} -> "TooManyFields"- SplitOnIrrelevant{} -> "SplitOnIrrelevant"- DefinitionIsIrrelevant{} -> "DefinitionIsIrrelevant"- VariableIsIrrelevant{} -> "VariableIsIrrelevant"- UnequalRelevance{} -> "UnequalRelevance"- UnequalHiding{} -> "UnequalHiding"- UnequalLevel{} -> "UnequalLevel"- UnequalSorts{} -> "UnequalSorts"- UnequalTerms{} -> "UnequalTerms"- UnequalTypes{} -> "UnequalTypes"- UnequalTelescopes{} -> "UnequalTelescopes"- HeterogeneousEquality{} -> "HeterogeneousEquality"- UnexpectedWithPatterns{} -> "UnexpectedWithPatterns"- UninstantiatedDotPattern{} -> "UninstantiatedDotPattern"- UninstantiatedModule{} -> "UninstantiatedModule"- UnreachableClauses{} -> "UnreachableClauses"- UnsolvedConstraints{} -> "UnsolvedConstraints"- UnsolvedMetas{} -> "UnsolvedMetas"- WithClausePatternMismatch{} -> "WithClausePatternMismatch"- WrongHidingInApplication{} -> "WrongHidingInApplication"- WrongHidingInLHS{} -> "WrongHidingInLHS"- WrongHidingInLambda{} -> "WrongHidingInLambda"- WrongIrrelevanceInLambda{} -> "WrongIrrelevanceInLambda"- WrongNumberOfConstructorArguments{} -> "WrongNumberOfConstructorArguments"--instance PrettyTCM TCErr where- prettyTCM err = case errError err of- TypeError s e -> do- s0 <- get- put s- d <- sayWhen (envRange $ clEnv e) (envCall $ clEnv e) $ prettyTCM e- put s0- return d- Exception r s -> sayWhere r $ fwords s- IOException r e -> sayWhere r $ fwords $ show e- PatternErr _ -> sayWhere err $ panic "uncaught pattern violation"- {- AbortAssign _ -> sayWhere err $ panic "uncaught aborted assignment" -- UNUSED -}--instance PrettyTCM TypeError where- prettyTCM err = do- case err of- InternalError s -> panic s- NotImplemented s -> fwords $ "Not implemented: " ++ s- NotSupported s -> fwords $ "Not supported: " ++ s- CompilationError s -> sep [fwords "Compilation error:", text s]- GenericError s -> fwords s- TerminationCheckFailed because ->- fwords "Termination checking failed for the following functions:"- $$ (nest 2 $- fsep (punctuate comma (map (text . show . qnameName)- (concatMap termErrFunctions because))))- $$ fwords "Problematic calls:"- $$ (nest 2 $ vcat $- map (\c -> let call = text (callInfoCall c) in- case show (callInfoRange c) of- "" -> call- r -> call $$ nest 2 (text "(at" <+> text r <> text ")"))- (concatMap termErrCalls because))- PropMustBeSingleton -> fwords- "Datatypes in Prop must have at most one constructor when proof irrelevance is enabled"- DataMustEndInSort t -> fsep $- pwords "The type of a datatype must end in a sort."- ++ [prettyTCM t] ++ pwords "isn't a sort."- ShouldEndInApplicationOfTheDatatype t -> fsep $- pwords "The target of a constructor must be the datatype applied to its parameters,"- ++ [prettyTCM t] ++ pwords "isn't"- ShouldBeAppliedToTheDatatypeParameters s t -> fsep $- pwords "The target of the constructor should be" ++ [prettyTCM s] ++- pwords "instead of" ++ [prettyTCM t]- ShouldBeApplicationOf t q -> fsep $- pwords "The pattern constructs an element of" ++ [prettyTCM q] ++- pwords "which is not the right datatype"- ShouldBeRecordType t -> fsep $- pwords "Expected record type, found " ++ [prettyTCM t]- DifferentArities ->- fwords "The number of arguments in the defining equations differ"- WrongHidingInLHS t -> do- fwords "Found an implicit argument where an explicit argument was expected"- WrongHidingInLambda t -> do- fwords "Found an implicit lambda where an explicit lambda was expected"- WrongIrrelevanceInLambda t -> do- fwords "Found an irrelevant lambda where a relevant lambda was expected"- WrongHidingInApplication t -> do- fwords "Found an implicit application where an explicit application was expected"- NotInductive t -> fsep $- [prettyTCM t] ++ pwords "is not an inductive data type"- UninstantiatedDotPattern e -> fsep $- pwords "Failed to infer the value of dotted pattern"- IlltypedPattern p a -> fsep $- pwords "Type mismatch"- TooManyArgumentsInLHS n a -> fsep $- pwords "Left hand side gives too many arguments to a function of type" ++ [prettyTCM a]- WrongNumberOfConstructorArguments c expect given -> fsep $- pwords "The constructor" ++ [prettyTCM c] ++ pwords "expects" ++- [text (show expect)] ++ pwords "arguments, but has been given" ++ [text (show given)]- DoesNotConstructAnElementOf c t -> fsep $- pwords "the constructor" ++ [prettyTCM c] ++- pwords "does not construct an element of" ++ [prettyTCM t]- ConstructorPatternInWrongDatatype c d -> fsep $- [prettyTCM c] ++ pwords "is not a constructor of the datatype" ++ [prettyTCM d]- IndicesNotConstructorApplications is ->- fsep (pwords "The following indices are not constructors" ++- pwords "(or literals) applied to variables:")- $$ nest 2 (vcat $ map prettyTCM is)- IndexVariablesNotDistinct is ->- fsep (pwords "The variables in the following indices are not distinct:")- $$ nest 2 (vcat $ map prettyTCM is)- IndexFreeInParameter i pars ->- fsep (pwords "The index" ++ [prettyTCM (I.Var i [])] ++- pwords "is free in the following parameters:")- $$ nest 2 (vcat $ map prettyTCM pars)- ShadowedModule [] -> __IMPOSSIBLE__- ShadowedModule ms@(m : _) -> fsep $- pwords "Duplicate definition of module" ++ [prettyTCM m <> text "."] ++- pwords "Previous definition at" ++ [text $ show r]- where- r = case [ r | r <- map (defSiteOfLast . mnameToList) ms- , r /= noRange ] of- [] -> noRange- r : _ -> r-- defSiteOfLast [] = noRange- defSiteOfLast ns = nameBindingSite (last ns)- ModuleArityMismatch m EmptyTel args -> fsep $- pwords "The module" ++ [prettyTCM m] ++- pwords "is not parameterized, but is being applied to arguments"- ModuleArityMismatch m tel@(ExtendTel _ _) args -> fsep $- pwords "The arguments to " ++ [prettyTCM m] ++ pwords "does not fit the telescope" ++- [prettyTCM tel]- ShouldBeEmpty t [] -> fsep $- [prettyTCM t] ++ pwords "should be empty, but that's not obvious to me"- ShouldBeEmpty t ps -> fsep (- [prettyTCM t] ++- pwords "should be empty, but the following constructor patterns are valid:"- ) $$ nest 2 (vcat $ map (showPat 0) ps)-- ShouldBeASort t -> fsep $- [prettyTCM t] ++ pwords "should be a sort, but it isn't"- ShouldBePi t -> fsep $- [prettyTCM t] ++ pwords "should be a function type, but it isn't"- NotAProperTerm ->- fwords "Found a malformed term"- SplitOnIrrelevant p t -> fsep $- pwords "Cannot pattern match" ++ [prettyA p] ++- pwords "against irrelevant type" ++ [prettyTCM t]- DefinitionIsIrrelevant x -> fsep $- text "Identifier" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"- VariableIsIrrelevant x -> fsep $- text "Variable" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"- UnequalTerms cmp s t a -> fsep $- [prettyTCM s, f cmp, prettyTCM t] ++ pwords "of type" ++ [prettyTCM a]- where- f CmpEq = text "!="- f CmpLeq = text "!=<"- UnequalLevel cmp s t -> fsep $- [prettyTCM s, f cmp, prettyTCM t]- where- f CmpEq = text "!="- f CmpLeq = text "!=<"- UnequalTelescopes cmp a b -> fsep $- [prettyTCM a, f cmp, prettyTCM b]- where- f CmpEq = text "!="- f CmpLeq = text "!=<"- UnequalTypes cmp a b -> fsep $- [prettyTCM a, f cmp, prettyTCM b]- where- f CmpEq = text "!="- f CmpLeq = text "!=<"- HeterogeneousEquality u a v b -> fsep $- pwords "Refuse to solve heterogeneous constraint" ++- [prettyTCM u] ++ pwords ":" ++ [prettyTCM a] ++ pwords "=?=" ++- [prettyTCM v] ++ pwords ":" ++ [prettyTCM b]- UnequalRelevance a b -> fsep $- [prettyTCM a] ++ pwords "!=" ++ [prettyTCM b] ++--- Andreas 2010-09-21 to reveal Forced annotations, print also uglily--- [text $ show a] ++ pwords "!=" ++ [text $ show b] ++- pwords "because one is a relevant function type and the other is an irrelevant function type"- UnequalHiding a b -> fsep $- [prettyTCM a] ++ pwords "!=" ++ [prettyTCM b] ++- pwords "because one is an implicit function type and the other is an explicit function type"- UnequalSorts s1 s2 -> fsep $- [prettyTCM s1] ++ pwords "!=" ++ [prettyTCM s2]- NotLeqSort s1 s2 -> fsep $- pwords "The type of the constructor does not fit in the sort of the datatype, since"- ++ [prettyTCM s1] ++ pwords "is not less or equal than" ++ [prettyTCM s2]- TooFewFields r xs -> fsep $- pwords "Missing fields" ++ punctuate comma (map pretty xs) ++- pwords "in an element of the record" ++ [prettyTCM r]- TooManyFields r xs -> fsep $- pwords "The record type" ++ [prettyTCM r] ++- pwords "does not have the fields" ++ punctuate comma (map pretty xs)- DuplicateConstructors xs -> fsep $- pwords "Duplicate constructors" ++ punctuate comma (map pretty xs) ++- pwords "in datatype"- DuplicateFields xs -> fsep $- pwords "Duplicate fields" ++ punctuate comma (map pretty xs) ++- pwords "in record"- UnexpectedWithPatterns ps -> fsep $- pwords "Unexpected with patterns" ++ (punctuate (text " |") $ map prettyA ps)- WithClausePatternMismatch p q -> fsep $- pwords "With clause pattern" ++ [prettyA p] ++- pwords "is not an instance of its parent pattern" -- TODO: pretty for internal patterns- MetaCannotDependOn m ps i -> fsep $- pwords "The metavariable" ++ [prettyTCM $ MetaV m []] ++ pwords "cannot depend on" ++ [pvar i] ++- pwords "because it" ++ deps- where- pvar i = prettyTCM $ I.Var i []- deps = case map pvar ps of- [] -> pwords "does not depend on any variables"- [x] -> pwords "only depends on the variable" ++ [x]- xs -> pwords "only depends on the variables" ++ punctuate comma xs-- MetaOccursInItself m -> fsep $- pwords "Cannot construct infinite solution of metavariable" ++ [prettyTCM $ MetaV m []]- BuiltinMustBeConstructor s e -> fsep $- [prettyA e] ++ pwords "must be a constructor in the binding to builtin" ++ [text s]- NoSuchBuiltinName s -> fsep $- pwords "There is no built-in thing called" ++ [text s]- DuplicateBuiltinBinding b x y -> fsep $- pwords "Duplicate binding for built-in thing" ++ [text b <> comma] ++- pwords "previous binding to" ++ [prettyTCM x]- NoBindingForBuiltin x -> fsep $- pwords "No binding for builtin thing" ++ [text x <> comma] ++- pwords ("use {-# BUILTIN " ++ x ++ " name #-} to bind it to 'name'")- NoSuchPrimitiveFunction x -> fsep $- pwords "There is no primitive function called" ++ [text x]- BuiltinInParameterisedModule x -> fwords $- "The BUILTIN pragma cannot appear inside a bound context " ++- "(for instance, in a parameterised module or as a local declaration)"- NoRHSRequiresAbsurdPattern ps -> fwords $- "The right-hand side can only be omitted if there " ++- "is an absurd pattern, () or {}, in the left-hand side."- AbsurdPatternRequiresNoRHS ps -> fwords $- "The right-hand side must be omitted if there " ++- "is an absurd pattern, () or {}, in the left-hand side."- LocalVsImportedModuleClash m -> fsep $- pwords "The module" ++ [text $ show m] ++- pwords "can refer to either a local module or an imported module"- UnsolvedMetas rs ->- fsep ( pwords "Unsolved metas at the following locations:" )- $$ nest 2 (vcat $ map (text . show) rs)- UnsolvedConstraints cs ->- fsep ( pwords "Failed to solve the following constraints:" )- $$ nest 2 (vcat $ map prettyTCM cs)- CyclicModuleDependency ms ->- fsep (pwords "cyclic module dependency:")- $$ nest 2 (vcat $ map pretty ms)- FileNotFound x files ->- fsep ( pwords "Failed to find source of module" ++ [pretty x] ++- pwords "in any of the following locations:"- ) $$ nest 2 (vcat $ map (text . filePath) files)- OverlappingProjects f m1 m2 ->- fsep ( pwords "The file" ++ [text (filePath f)] ++- pwords "can be accessed via several project roots. Both" ++- [pretty m1] ++ pwords "and" ++ [pretty m2] ++- pwords "point to this file."- )- AmbiguousTopLevelModuleName x files ->- fsep ( pwords "Ambiguous module name. The module name" ++- [pretty x] ++- pwords "could refer to any of the following files:"- ) $$ nest 2 (vcat $ map (text . filePath) files)- ClashingFileNamesFor x files ->- fsep ( pwords "Multiple possible sources for module" ++ [text $ show x] ++- pwords "found:"- ) $$ nest 2 (vcat $ map (text . filePath) files)- ModuleDefinedInOtherFile mod file file' -> fsep $- pwords "You tried to load" ++ [text (filePath file)] ++- pwords "which defines the module" ++ [pretty mod <> text "."] ++- pwords "However, according to the include path this module should" ++- pwords "be defined in" ++ [text (filePath file') <> text "."]- ModuleNameDoesntMatchFileName given files ->- fsep (pwords "The name of the top level module does not match the file name. The module" ++- [ pretty given ] ++ pwords "should be defined in one of the following files:")- $$ nest 2 (vcat $ map (text . filePath) files)- BothWithAndRHS -> fsep $- pwords "Unexpected right hand side"- NotInScope xs ->- fsep (pwords "Not in scope:") $$ nest 2 (vcat $ map name xs)- where- name x = fsep [ pretty x, text "at" <+> text (show $ getRange x), suggestion (show x) ]- suggestion s- | elem ':' s = parens $ text "did you forget space around the ':'?"- | elem "->" two = parens $ text "did you forget space around the '->'?"- | otherwise = empty- where- two = zipWith (\a b -> [a,b]) s (tail s)- NoSuchModule x -> fsep $- pwords "No such module" ++ [pretty x]- AmbiguousName x ys -> vcat- [ fsep $ pwords "Ambiguous name" ++ [pretty x <> text "."] ++- pwords "It could refer to any one of"- , nest 2 $ vcat $ map nameWithBinding ys- ]- AmbiguousModule x ys -> vcat- [ fsep $ pwords "Ambiguous module name" ++ [pretty x <> text "."] ++- pwords "It could refer to any one of"- , nest 2 $ vcat $ map prettyTCM ys- ]- UninstantiatedModule x -> fsep (- pwords "Cannot access the contents of the parameterised module" ++ [pretty x <> text "."] ++- pwords "To do this the module first has to be instantiated. For instance:"- ) $$ nest 2 (hsep [ text "module", pretty x <> text "'", text "=", pretty x, text "e1 .. en" ])- ClashingDefinition x y -> fsep $- pwords "Multiple definitions of" ++ [pretty x <> text "."] ++- pwords "Previous definition at" ++ [text $ show $ nameBindingSite $ qnameName y]- ClashingModule m1 m2 -> fsep $- pwords "The modules" ++ [prettyTCM m1, text "and", prettyTCM m2] ++ pwords "clash."- ClashingImport x y -> fsep $- pwords "Import clash between" ++ [pretty x, text "and", prettyTCM y]- ClashingModuleImport x y -> fsep $- pwords "Module import clash between" ++ [pretty x, text "and", prettyTCM y]- PatternShadowsConstructor x c -> fsep $- pwords "The pattern variable" ++ [prettyTCM x] ++- pwords "has the same name as the constructor" ++ [prettyTCM c]- DuplicateImports m xs -> fsep $- pwords "Ambiguous imports from module" ++ [pretty m] ++ pwords "for" ++- punctuate comma (map pretty xs)- ModuleDoesntExport m xs -> fsep $- pwords "The module" ++ [pretty m] ++ pwords "doesn't export the following:" ++- punctuate comma (map pretty xs)- NotAModuleExpr e -> fsep $- pwords "The right-hand side of a module definition must have the form 'M e1 .. en'" ++- pwords "where M is a module name. The expression" ++ [pretty e, text "doesn't."]- FieldOutsideRecord -> fsep $- pwords "Field appearing outside record declaration."- InvalidPattern p -> fsep $- pretty p : pwords "is not a valid pattern"- RepeatedVariablesInPattern xs -> fsep $- pwords "Repeated variables in left hand side:" ++ map pretty xs- NotAnExpression e -> fsep $- [pretty e] ++ pwords "is not a valid expression."- NotAValidLetBinding nd -> fwords $- "Not a valid let-declaration"- NothingAppliedToHiddenArg e -> fsep $- [pretty e] ++ pwords "cannot appear by itself. It needs to be the argument to" ++- pwords "a function expecting an implicit argument."- NothingAppliedToInstanceArg e -> fsep $- [pretty e] ++ pwords "cannot appear by itself. It needs to be the argument to" ++- pwords "a function expecting an instance argument."- NoParseForApplication es -> fsep $- pwords "Could not parse the application" ++ [pretty $ C.RawApp noRange es]- AmbiguousParseForApplication es es' -> fsep (- pwords "Don't know how to parse" ++ [pretty (C.RawApp noRange es) <> text "."] ++- pwords "Could mean any one of:"- ) $$ nest 2 (vcat $ map pretty es')- NoParseForLHS p -> fsep $- pwords "Could not parse the left-hand side" ++ [pretty p]- AmbiguousParseForLHS p ps -> fsep (- pwords "Don't know how to parse" ++ [pretty p <> text "."] ++- pwords "Could mean any one of:"- ) $$ nest 2 (vcat $ map pretty ps)- IncompletePatternMatching v args -> fsep $- pwords "Incomplete pattern matching for" ++ [prettyTCM v <> text "."] ++- pwords "No match for" ++ map prettyTCM args- UnreachableClauses f pss -> fsep $- pwords "Unreachable" ++ pwords (plural (length pss) "clause")- where- plural 1 thing = thing- plural n thing = thing ++ "s"- CoverageFailure f pss -> fsep (- pwords "Incomplete pattern matching for" ++ [prettyTCM f <> text "."] ++- pwords "Missing cases:") $$ nest 2 (vcat $ map display pss)- where- display ps = do- ps <- nicify f ps- prettyTCM f <+> fsep (map showArg ps)-- nicify f ps = do- showImp <- showImplicitArguments- if showImp- then return ps- else return ps -- TODO: remove implicit arguments which aren't constructors-- CoverageCantSplitOn c tel cIxs gIxs -> inContext [] $ addCtxTel tel $ vcat- [ fsep $ pwords "Cannot decide whether there should be a case for the constructor" ++ [prettyTCM c <> text ","] ++- pwords "since the unification gets stuck on unifying the inferred indices"- , nest 2 $ prettyTCM cIxs- , fsep $ pwords "with the expected indices"- , nest 2 $ prettyTCM gIxs ]-- CoverageCantSplitIrrelevantType a -> fsep $- pwords "Cannot split on argument of irrelevant datatype" ++ [prettyTCM a]-- CoverageCantSplitType a -> fsep $- pwords "Cannot split on argument of non-datatype" ++ [prettyTCM a]-- NotStrictlyPositive d ocs -> fsep $- pwords "The datatype" ++ [prettyTCM d] ++ pwords "is not strictly positive, because"- ++ prettyOcc "it" ocs- where- prettyOcc _ [] = []- prettyOcc it (OccCon d c r : ocs) = concat- [ pwords it, pwords "occurs", prettyR r- , pwords "in the constructor", [prettyTCM c], pwords "of"- , [prettyTCM d <> com ocs], prettyOcc "which" ocs- ]- prettyOcc it (OccClause f n r : ocs) = concat- [ pwords it, pwords "occurs", prettyR r- , pwords "in the", [th n], pwords "clause of"- , [prettyTCM f <> com ocs], prettyOcc "which" ocs- ]- prettyR NonPositively = pwords "negatively"- prettyR (ArgumentTo i q) =- pwords "as the" ++ [th i] ++- pwords "argument to" ++ [prettyTCM q]- th 0 = text "first"- th 1 = text "second"- th 2 = text "third"- th n = text (show $ n - 1) <> text "th"-- com [] = empty- com (_:_) = comma- IFSNoCandidateInScope t -> fsep $- pwords "No variable of type" ++ [prettyTCM t] ++ pwords "was found in scope."- SafeFlagPostulate e -> fsep $- pwords "Cannot postulate" ++ [pretty e] ++ pwords "with safe flag"- SafeFlagPragma xs ->- let plural | length xs == 1 = ""- | otherwise = "s"- in fsep $ [fwords ("Cannot set OPTION pragma" ++ plural)]- ++ map text xs ++ [fwords "with safe flag."]- SafeFlagPrimTrustMe -> fsep (pwords "Cannot use primTrustMe with safe flag")- where- mpar n args- | n > 0 && not (null args) = parens- | otherwise = id-- showArg (Arg Hidden r x) = braces $ showPat 0 x- showArg (Arg Instance r x) = dbraces $ showPat 0 x- showArg (Arg NotHidden r x) = showPat 1 x-- showPat _ (I.VarP _) = text "_"- showPat _ (I.DotP _) = text "._"- showPat n (I.ConP c _ args) = mpar n args $ prettyTCM c <+> fsep (map showArg args)- showPat _ (I.LitP l) = text (show l)----instance PrettyTCM Call where- prettyTCM c = case c of- CheckClause t cl _ -> fsep $- pwords "when checking that the clause"- ++ [P.prettyA cl] ++ pwords "has type" ++ [prettyTCM t]- CheckPattern p tel t _ -> addCtxTel tel $ fsep $- pwords "when checking that the pattern"- ++ [prettyA p] ++ pwords "has type" ++ [prettyTCM t]- CheckLetBinding b _ -> fsep $- pwords "when checking the let binding" ++ [P.prettyA b]- InferExpr e _ -> fsep $- pwords "when inferring the type of" ++ [prettyA e]- CheckExpr e t _ -> fsep $- pwords "when checking that the expression"- ++ [prettyA e] ++ pwords "has type" ++ [prettyTCM t]- IsTypeCall e s _ -> fsep $- pwords "when checking that the expression"- ++ [prettyA e] ++ pwords "is a type of sort" ++ [prettyTCM s]- IsType_ e _ -> fsep $- pwords "when checking that the expression"- ++ [prettyA e] ++ pwords "is a type"- CheckArguments r es t0 t1 _ -> fsep $- pwords "when checking that" ++- map hPretty es ++ pwords "are valid arguments to a function of type" ++ [prettyTCM t0]- CheckRecDef _ x ps cs _ ->- fsep $ pwords "when checking the definition of" ++ [prettyTCM x]- CheckDataDef _ x ps cs _ ->- fsep $ pwords "when checking the definition of" ++ [prettyTCM x]- CheckConstructor d _ _ (A.Axiom _ _ c _) _ -> fsep $- pwords "when checking the constructor" ++ [prettyTCM c] ++- pwords "in the declaration of" ++ [prettyTCM d]- CheckConstructor _ _ _ _ _ -> __IMPOSSIBLE__- CheckFunDef _ f _ _ ->- fsep $ pwords "when checking the definition of" ++ [prettyTCM f]- CheckPragma _ p _ ->- fsep $ pwords "when checking the pragma" ++ [prettyA $ RangeAndPragma noRange p]- CheckPrimitive _ x e _ -> fsep $- pwords "when checking that the type of the primitive function" ++- [prettyTCM x] ++ pwords "is" ++ [prettyA e]- CheckWithFunctionType e _ -> fsep $- pwords "when checking that the type" ++- [prettyA e] ++ pwords "of the generated with function is well-formed"- CheckDotPattern e v _ -> fsep $- pwords "when checking that the given dot pattern" ++ [prettyA e] ++- pwords "matches the inferred value" ++ [prettyTCM v]- CheckPatternShadowing c _ -> fsep $- pwords "when checking the clause" ++ [P.prettyA c]- InferVar x _ ->- fsep $ pwords "when inferring the type of" ++ [prettyTCM x]- InferDef _ x _ ->- fsep $ pwords "when inferring the type of" ++ [prettyTCM x]- CheckIsEmpty t _ ->- fsep $ pwords "when checking that" ++ [prettyTCM t] ++ pwords "has no constructors"- ScopeCheckExpr e _ ->- fsep $ pwords "when scope checking" ++ [pretty e]- ScopeCheckDeclaration d _ ->- fwords "when scope checking the declaration" $$- nest 2 (pretty $ simpleDecl d)- ScopeCheckLHS x p _ ->- fsep $ pwords "when scope checking the left-hand side" ++ [pretty p] ++- pwords "in the definition of" ++ [pretty x]- TermFunDef _ f _ _ ->- fsep $ pwords "when termination checking the definition of" ++ [prettyTCM f]- SetRange r _ ->- fsep $ pwords "when doing something at" ++ [text $ show r]- CheckSectionApplication _ m1 modapp _ -> fsep $- pwords "when checking the module application" ++- [prettyA $ A.Apply info m1 modapp Map.empty Map.empty]- where- info = A.ModuleInfo noRange noRange Nothing Nothing Nothing-- where- hPretty a = pretty =<< abstractToConcreteCtx (hiddenArgumentCtx (argHiding a)) a-- simpleDecl d = d'- where [d'] = D.notSoNiceDeclarations [d]-+{-# LANGUAGE NondecreasingIndentation #-}++{-# OPTIONS_GHC -fno-warn-orphans #-}++module Agda.TypeChecking.Errors+ ( renderError+ , prettyError+ , prettyShadowedModule+ , tcErrString+ , prettyTCWarnings'+ , prettyTCWarnings+ , tcWarningsToError+ , applyFlagsToTCWarningsPreserving+ , applyFlagsToTCWarnings+ , getAllUnsolvedWarnings+ , getAllWarningsPreserving+ , getAllWarnings+ , getAllWarningsOfTCErr+ , dropTopLevelModule+ , topLevelModuleDropper+ , explainWhyInScope+ , Verbalize(verbalize), Indefinite(..), Ordinal(..)+ ) where++import Prelude hiding ( null, foldl )++import qualified Control.Exception as E+import Control.Monad ((>=>), (<=<))+import Control.Monad.Except++import qualified Data.CaseInsensitive as CaseInsens+import Data.Foldable (foldl)+import Data.Function (on)+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet+import Data.List (sortBy, dropWhileEnd, intercalate)+import qualified Data.List as List+import Data.Maybe+import qualified Data.Map as Map+import Data.Set (Set)+import qualified Data.Set as Set+import qualified Data.Text as Text+import System.FilePath+import qualified Text.PrettyPrint.Boxes as Boxes++import Agda.Interaction.Options+import Agda.Interaction.Options.Errors++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty ( prettyShow, render )+import qualified Agda.Syntax.Common.Pretty as P+import Agda.Syntax.Concrete.Definitions (notSoNiceDeclarations, NiceDeclaration (NiceDataDef, NiceRecDef))+import Agda.Syntax.Concrete.Definitions.Errors (declarationExceptionString)+import Agda.Syntax.Concrete.Pretty (attributesForModality)+import Agda.Syntax.Notation+import Agda.Syntax.Parser (agdaFileExtensions)+import Agda.Syntax.Position+import qualified Agda.Syntax.Concrete as C+import Agda.Syntax.Abstract as A+import Agda.Syntax.Internal as I+import Agda.Syntax.Translation.InternalToAbstract+import Agda.Syntax.Scope.Monad (isDatatypeModule, resolveName', tryResolveName)+import Agda.Syntax.Scope.Base+import Agda.Syntax.TopLevelModuleName (moduleNameToFileName)++import Agda.TypeChecking.Errors.Names (typeErrorString)+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Pretty.Call+import Agda.TypeChecking.Pretty.Warning+import Agda.TypeChecking.SizedTypes.Pretty ()+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Reduce (instantiate)++import Agda.Interaction.Library.Base (formatLibErrors, libFile)+import qualified Agda.Interaction.Options.Base as Opts++import Agda.Utils.AssocList qualified as AssocList+import Agda.Utils.FileName+import Agda.Utils.Float ( toStringWithoutDotZero )+import Agda.Utils.Function+import Agda.Utils.Functor ( for )+import Agda.Utils.IO ( showIOException )+import Agda.Utils.Lens+import Agda.Utils.List ( initLast, lastMaybe, hasElem )+import Agda.Utils.List1 ( List1, pattern (:|) )+import Agda.Utils.List2 ( pattern List2 )+import Agda.Utils.List1 qualified as List1+import Agda.Utils.List2 qualified as List2+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Set1 qualified as Set1+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.String ( rtrim )++import Agda.Utils.Impossible+import Agda.TypeChecking.Conversion.Errors++---------------------------------------------------------------------------+-- * Top level function+---------------------------------------------------------------------------++{-# SPECIALIZE renderError :: TCErr -> TCM String #-}+renderError :: MonadTCM tcm => TCErr -> tcm String+renderError = fmap show . prettyError++{-# SPECIALIZE prettyError :: TCErr -> TCM Doc #-}+prettyError :: MonadTCM tcm => TCErr -> tcm Doc+prettyError = liftTCM . go []+ where+ go :: [TCErr] -> TCErr -> TCM Doc+ go errs err+ | length errs > 3 = vcat $+ fwords ("total panic: error when printing error from printing error from printing error." +++ "I give up! Approximations of errors (original error last):")+ : map (text . tcErrString) errs+ | otherwise =+ applyUnless (null errs)+ (\ d -> vcat $+ "panic: error when printing error!"+ : d+ : map (text . ("when printing error " ++) . tcErrString) errs)+ (prettyTCM err)+ `catchError` go (err:errs)++---------------------------------------------------------------------------+-- * Helpers+---------------------------------------------------------------------------++panic :: Monad m => String -> m Doc+panic s = fwords $ "Panic: " ++ s++nameWithBinding :: MonadPretty m => QName -> m Doc+nameWithBinding q =+ (prettyTCM q <+> "bound at") <?> prettyTCM r+ where+ r = nameBindingSite q++tcErrString :: TCErr -> String+tcErrString err =+ unwords . filter (not . null) . (prettyShow (getRange err) :) $+ case err of+ TypeError _ _ cl -> [ typeErrorString $ clValue cl ]+ ParserError e -> [ "ParserError" ]+ GenericException msg -> [ msg ]+ IOException _ r e -> [ prettyShow r, showIOException e ]+ PatternErr{} -> [ "PatternErr" ]++instance PrettyTCM TCErr where+ prettyTCM err = case err of+ -- Gallais, 2016-05-14+ -- Given where `NonFatalErrors` are created, we know for a+ -- fact that ̀ws` is non-empty.+ TypeError loc _ Closure{ clValue = NonFatalErrors ws } -> do+ reportSLn "error" 2 $ "Error raised at " ++ prettyShow loc+ vsep $ fmap prettyTCM $ Set1.toAscList ws+ -- Andreas, 2014-03-23+ -- This use of withTCState seems ok since we do not collect+ -- Benchmark info during printing errors.+ TypeError loc s e -> withTCState (const s) $ do+ reportSLn "error" 2 $ "Error raised at " ++ prettyShow loc+ let r = clEnv e ^. eRange+ vcat+ [ hsep+ [ if null r then empty else prettyTCM r <> ":"+ , "error:"+ , brackets (text $ typeErrorString $ clValue e)+ ]+ , prettyTCM e+ , prettyTCM (clEnv e ^. eCall)+ ]+ ParserError err -> pretty err+ GenericException msg -> fwords msg+ IOException _ r e -> sayWhere r $ fwords $ showIOException e+ PatternErr{} -> sayWhere err $ panic "uncaught pattern violation"++-- | Drops given amount of leading components of the qualified name.+dropTopLevelModule' :: Int -> QName -> QName+dropTopLevelModule' k (QName (MName ns) n) = QName (MName (drop k ns)) n++-- | Drops the filename component of the qualified name.+dropTopLevelModule :: MonadPretty m => QName -> m QName+dropTopLevelModule q = ($ q) <$> topLevelModuleDropper++-- | Produces a function which drops the filename component of the qualified name.+topLevelModuleDropper :: (MonadDebug m, MonadTCEnv m, ReadTCState m) => m (QName -> QName)+topLevelModuleDropper =+ caseMaybeM currentTopLevelModule+ (return id)+ (return . dropTopLevelModule' . size)++prettyDisamb :: MonadPretty m => (QName -> Maybe (Range' SrcFile)) -> QName -> m Doc+prettyDisamb f x = do+ let d = pretty =<< dropTopLevelModule x+ caseMaybe (f x) d $ \ r -> d <+> ("(introduced at " <> prettyTCM r <> ")")++-- | Print the last range in 'qnameModule'.+prettyDisambProj :: MonadPretty m => QName -> m Doc+prettyDisambProj = prettyDisamb $ lastMaybe . filter (noRange /=) . map nameBindingSite . mnameToList . qnameModule++-- Print the range in 'qnameName'. This fixes the bad error message in #4130.+prettyDisambCons :: MonadPretty m => QName -> m Doc+prettyDisambCons = prettyDisamb $ Just . nameBindingSite++prepruneErrorRefinedContext :: forall m. MonadPretty m => Closure MetaId -> m Doc+prepruneErrorRefinedContext = prepruneError empty $+ "Failed to generalize because some of the generalized variables depend on an " +++ "unsolved meta created in a refined context (not a simple extension of the context where " +++ "generalization happens)."++prepruneErrorCyclicDependencies :: forall m. MonadPretty m => Closure MetaId -> m Doc+prepruneErrorCyclicDependencies = prepruneError empty $+ "Failed to generalize due to circular dependencies between the generalized " +++ "variables and an unsolved meta."++prepruneErrorFailedToInstantiate :: forall m. MonadPretty m => Closure MetaId -> m Doc+prepruneErrorFailedToInstantiate = prepruneError prepruneErrorBounty $+ "Failed to generalize because the generalized variables depend on an unsolved meta " +++ "that could not be lifted outside the generalization."++prepruneErrorBounty :: Doc+prepruneErrorBounty = P.fsep $ concat+ [ P.pwords "Congratulations, you have hit a so far unreproduced error in generalization!"+ , P.pwords "Please submit your self-contained reproducer (max 50 lines) at"+ , [ P.url "https://github.com/agda/agda/issues/8161" ]+ , P.pwords "to earn a honorable mention in the next Agda release."+ ]++prepruneError :: forall m. MonadPretty m => Doc -> String -> Closure MetaId -> m Doc+prepruneError bounty msg x = enterClosure x \ x -> do+ r <- getMetaRange x+ vcat+ [ pure bounty+ , fwords $ msg ++ " The problematic unsolved meta is"+ , nest 2 $ prettyTCM (MetaV x []) <+> "at" <+> pretty r+ ]++instance PrettyTCM TypeError where+ prettyTCM :: forall m. MonadPretty m => TypeError -> m Doc+ prettyTCM err = case err of+ InternalError s -> panic s++ NotImplemented s -> fwords $ "Not implemented: " ++ s++ NotSupported s -> fwords $ "Not supported: " ++ s++ CompilationError s -> sep [fwords "Compilation error:", text s]++ UserError d -> return d++ GeneralizationFailed d -> return d++ GeneralizationPrepruneErrorRefinedContext x ->+ prepruneErrorRefinedContext x++ GeneralizationPrepruneErrorCyclicDependencies x ->+ prepruneErrorCyclicDependencies x++ GeneralizationPrepruneErrorFailedToInstantiate x ->+ prepruneErrorFailedToInstantiate x++ ExecError err -> prettyTCM err++ NicifierError err -> pretty err++ OptionError s -> fwords s++ SyntaxError s -> fwords $ "Syntax error: " ++ s++ DoNotationError err -> fwords err++ IdiomBracketError err -> fwords err++ InvalidDottedExpression -> fwords "Invalid dotted expression"++ NoKnownRecordWithSuchFields fields -> fsep $+ case fields of+ [] -> pwords "There are no records in scope"+ [f] -> pwords "There is no known record with the field" ++ [ pretty f ]+ _ -> pwords "There is no known record with the fields" ++ map pretty fields++ ShouldEndInApplicationOfTheDatatype t -> fsep $+ pwords "The target of a constructor must be the datatype applied to its parameters,"+ ++ [prettyTCM t] ++ pwords "isn't"++ ShouldBeRecordType t -> fsep $+ pwords "Expected non-abstract record type, found " ++ [prettyTCM t]++ ShouldBeRecordPattern -> fsep $+ pwords "Expected record pattern"++ EtaPragmaVsNoEtaEquality -> fwords $ "Record has both ETA_EQUALITY pragma and no-eta-equality directive"++ WrongHidingInLHS -> fwords "Unexpected implicit argument"++ WrongHidingInLambda t ->+ fwords "Found an implicit lambda where an explicit lambda was expected"++ WrongHidingInProjection d ->+ sep [ "Wrong hiding used for projection " , prettyTCM d ]++ IllegalHidingInPostfixProjection arg -> fsep $+ pwords "Illegal hiding in postfix projection " +++ [pretty arg]++ WrongAnnotationInLambda ->+ fwords "Wrong annotation in lambda"++ WrongIrrelevanceInLambda ->+ fwords "Found a non-strict lambda where a irrelevant lambda was expected"++ WrongQuantityInLambda ->+ fwords "Incorrect quantity annotation in lambda"++ WrongCohesionInLambda ->+ fwords "Incorrect cohesion annotation in lambda"++ WrongPolarityInLambda ->+ fwords "Incorrect polarity annotation in lambda"++ WrongNamedArgument a xs0 -> fsep $+ pwords "Function does not accept argument "+ ++ [prettyTCM a] -- ++ pwords " (wrong argument name)"+ ++ [parens $ fsep $ text "possible arguments:" : map pretty xs | not (null xs)]+ where+ xs = List1.filter (not . isNoName) xs0++ WrongNamedArgumentInLHS h x xs -> fsep $+ pwords "Unexpected" ++ [ hid h ] ++ pwords "argument named" ++ [ text x ]+ ++ [ parens $ fsep $ text "possible arguments:" : map text xs | not (null xs) ]+ where+ hid = \case+ Hidden -> "hidden"+ Instance{} -> "instance"+ NotHidden -> "visible"++ WrongHidingInApplication t ->+ fwords "Found an implicit application where an explicit application was expected"++ HidingMismatch h h' -> fwords $+ "Expected " ++ verbalize (Indefinite h') ++ " argument, but found " +++ verbalize (Indefinite h) ++ " argument"++ RelevanceMismatch r r' -> fwords $+ "Expected " ++ verbalize (Indefinite r') ++ " argument, but found " +++ verbalize (Indefinite r) ++ " argument"++ QuantityMismatch q q' -> fwords $+ "Expected " ++ verbalize (Indefinite q') ++ " argument, but found " +++ verbalize (Indefinite q) ++ " argument"++ ForcedConstructorNotInstantiated p -> fsep $+ pwords "Failed to infer that constructor pattern "+ ++ [prettyA p] ++ pwords " is forced"++ IllformedProjectionPatternAbstract p -> fsep $+ pwords "Ill-formed projection pattern " ++ [prettyA p]++ IllformedProjectionPatternConcrete p -> fsep $+ pwords "Ill-formed projection pattern" ++ [pretty p]++ LiteralTooBig -> fsep $ concat+ [ pwords "Matching on natural number literals is done by expanding"+ , pwords "the literal to the corresponding constructor pattern,"+ , pwords "so you probably don't want to do it this way"+ ]++ NegativeLiteralInPattern -> fsep $+ pwords "Negative literals are not supported in patterns"++ CannotEliminateWithPattern b p a -> do+ let isProj = isJust (isProjP p)+ fsep $+ pwords "Cannot eliminate type" ++ prettyTCM a : if+ | isProj -> pwords "with projection pattern" ++ [prettyA p]+ | A.ProjP _ _ f <- namedArg p -> pwords "with pattern" ++ [prettyA p] +++ pwords "(suggestion: write" ++ [".(" <> prettyA (A.Proj ProjPrefix f) <> ")"] ++ pwords "for a dot pattern," +++ pwords "or remove the braces for a postfix projection)"+ | otherwise ->+ "with" : text (kindOfPattern (namedArg p)) : "pattern" : prettyA p :+ pwords "(did you supply too many arguments?)"+ where+ kindOfPattern = \case+ A.VarP{} -> "variable"+ A.ConP{} -> "constructor"+ A.ProjP{} -> __IMPOSSIBLE__+ A.DefP{} -> __IMPOSSIBLE__+ A.WildP{} -> "wildcard"+ A.DotP{} -> "dot"+ A.AbsurdP{} -> "absurd"+ A.LitP{} -> "literal"+ A.RecP{} -> "record"+ A.WithP{} -> "with"+ A.EqualP{} -> "equality"+ A.AsP _ _ p -> kindOfPattern p+ A.PatternSynP{} -> __IMPOSSIBLE__++ CannotEliminateWithProjection _ ty isAmbiguous projection -> sep+ [ "Cannot eliminate type "+ , prettyTCM (unArg ty)+ , " with projection "+ , if isAmbiguous then+ text $ prettyShow projection+ else+ prettyTCM projection+ ]++ WrongNumberOfConstructorArguments c expect given -> fsep $+ pwords "The constructor" ++ [prettyTCM c] +++ pwords "expects" ++ [prettyTCM expect] +++ pwords "arguments (including hidden ones), but has been given"+ ++ [prettyTCM given] ++ pwords "(including hidden ones)"++ CantResolveOverloadedConstructorsTargetingSameDatatype d cs -> fsep $+ pwords "Can't resolve overloaded constructors targeting the same datatype"+ ++ [parens (prettyTCM (qnameToConcrete d)) <> colon]+ ++ map pretty (List1.toList cs)++ ConstructorDoesNotTargetGivenType c t -> fsep $+ pwords "The constructor" ++ [prettyTCM c] +++ pwords "does not construct an element of" ++ [prettyTCM t]++ ConstructorPatternInWrongDatatype c d dataOrRec -> fsep $+ [prettyTCM c] ++ pwords "is not a constructor of the"+ ++ [case dataOrRec of IsData -> "datatype"; IsRecord_ -> "record type"]+ ++ [prettyTCM d]++ ShadowedModule x ms -> join $ fst <$> prettyShadowedModule x ms++ ModuleArityMismatch m EmptyTel args -> fsep $+ pwords "The module" ++ [prettyTCM m] +++ pwords "is not parameterized, but is being applied to arguments"++ ModuleArityMismatch m tel@(ExtendTel _ _) args -> fsep $+ pwords "The arguments to " ++ [prettyTCM m] ++ pwords "do not fit the telescope" +++ [prettyTCM tel]++ ShouldBeEmpty t [] -> fsep $+ prettyTCM t : pwords "should be empty, but that's not obvious to me"++ ShouldBeEmpty t ps -> fsep (+ prettyTCM t :+ pwords "should be empty, but the following constructor patterns are valid:"+ ) $$ nest 2 (vcat $ map (prettyPat 0) ps)++ ShouldBeASort t -> fsep $+ prettyTCM t : pwords "should be a sort, but it isn't"++ ShouldBePi t -> fsep $+ prettyTCM t : pwords "should be a function type, but it isn't"++ ShouldBePath t -> fsep $+ prettyTCM t : pwords "should be a Path or PathP type, but it isn't"++ CannotApply e t -> sep+ [ "Expression used as function but does not have function type:"+ , nest 2 $ "expr:" <+> prettyA e+ , nest 2 $ "type:" <+> prettyTCM t+ ]++ InvalidTypeSort s -> fsep $ prettyTCM s : pwords "is not a valid sort"++ CannotSolveSizeConstraints ccs reason -> do+ -- Print the HypSizeConstraints (snd)+ vcat $ concat+ [ [ text $ "Cannot solve size constraints" ]+ , List1.toList $ fmap (prettyTCM . snd) ccs+ , [ "Reason:" <+> pure reason | not (null reason) ]+ ]++ ContradictorySizeConstraint cc@(_,c0) -> fsep $+ pwords "Contradictory size constraint" ++ [prettyTCM c0]++ EmptyTypeOfSizes t -> fsep $ pwords "Possibly empty type of sizes:" ++ [prettyTCM t]++ FunctionTypeInSizeUniv v -> fsep $+ pwords "Functions may not return sizes, thus, function type " +++ [ prettyTCM v ] ++ pwords " is illegal"++ PostulatedSizeInModule -> fwords "We don't like postulated sizes in parametrized modules."++ SplitOnCoinductive -> fsep $ pwords "Pattern matching on coinductive types is not allowed"++ SplitOnIrrelevant t -> fsep $+ pwords "Cannot pattern match against" ++ [text $ verbalize $ getRelevance t] +++ pwords "argument of type" ++ [prettyTCM $ unDom t]++ SplitOnUnusableCohesion t -> fsep $+ pwords "Cannot pattern match against" ++ [text $ verbalize $ getCohesion t] +++ pwords "argument of type" ++ [prettyTCM $ unDom t]++ SplitOnUnusablePolarity t -> fsep $+ pwords "Cannot pattern match against" ++ [text $ verbalize $ getModalPolarity t] +++ pwords "argument of type" ++ [prettyTCM $ unDom t]++ -- UNUSED:+ -- SplitOnErased t -> fsep $+ -- pwords "Cannot pattern match against" ++ [text $ verbalize $ getQuantity t] +++ -- pwords "argument of type" ++ [prettyTCM $ unDom t]++ SplitOnNonVariable v t -> fsep $+ pwords "Cannot pattern match because the (refined) argument " +++ [ prettyTCM v ] ++ pwords " is not a variable."++ SplitOnNonEtaRecord q -> fsep $ concat+ [ pwords "Pattern matching on no-eta record type"+ , [ prettyTCM q, parens ("defined at" <+> prettyTCM r) ]+ , pwords "is not allowed"+ , [ parens "to activate, add declaration `pattern` to record definition" ]+ ]+ where r = nameBindingSite q++ SplitOnAbstract d ->+ "Cannot split on abstract data type" <+> prettyTCM d++ SplitOnUnchecked d ->+ "Cannot split on data type" <+> prettyTCM d <+> "whose definition has not yet been checked"++ SplitOnPartial dom -> vcat+ [ "Splitting on partial elements is only allowed at the type Partial, but the domain here is", nest 2 $ prettyTCM $ unDom dom ]++ SplitInProp dr -> fsep+ [ text "Cannot split on"+ , text $ kindOfData dr+ , text "in Prop unless target is in Prop"+ ]+ where+ kindOfData :: DataOrRecordE -> String+ kindOfData IsData = "datatype"+ kindOfData (IsRecord InductionAndEta {recordInduction=Nothing}) = "record type"+ kindOfData (IsRecord InductionAndEta {recordInduction=Just Inductive}) = "inductive record type"+ kindOfData (IsRecord InductionAndEta {recordInduction=Just CoInductive}) = "coinductive record type"++ DefinitionIsIrrelevant x -> fsep $+ "Identifier" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"++ DefinitionIsErased x -> fsep $+ "Identifier" : prettyTCM x : pwords "is declared erased, so it cannot be used here"++ ProjectionIsIrrelevant x -> vcat+ [ fsep [ "Projection " , prettyTCM x, " is irrelevant." ]+ , "Turn on option --irrelevant-projections to use it (unsafe)"+ ]++ VariableIsIrrelevant x -> fsep $+ "Variable" : prettyTCM (nameConcrete x) : pwords "is declared irrelevant, so it cannot be used here"++ VariableIsErased x -> fsep $+ "Variable" : prettyTCM (nameConcrete x) : pwords "is declared erased, so it cannot be used here"++ VariableIsOfUnusableCohesion x c -> fsep+ ["Variable", prettyTCM (nameConcrete x), "is declared", text (show c), "so it cannot be used here"]++ LambdaIsErased -> fwords $ "Erased pattern-matching lambdas may only be used in erased contexts"++ RecordIsErased -> fwords $+ "A record expression corresponding to an erased record " +++ "constructor must only be used in erased settings"++ InvalidModalTelescopeUse t used avail def -> fsep+ [ "Telescope variable" <+> prettyTCM t+ , "is indirectly being used in the" <+> text (verbalizePositional used) <+> "modality"+ , "but only available in the" <+> text (verbalizePositional avail) <+> "modality"+ , "when inserting into the telescope of definition"+ , pretty (defName def) <+> ":" <+> prettyTCM (defType def)+ ]+ where+ -- Only the cohesion and polarity components are relevant here.+ verbalizePositional m =+ case [ verbalize c | c /= defaultCohesion ] ++ [ verbalize p | p /= defaultPolarity ] of+ [] -> "default"+ ws -> intercalate ", " ws+ where+ c = getCohesion m+ p = getModalPolarity m++ VariableIsOfUnusablePolarity x c -> fsep $+ ["Variable", prettyTCM (nameConcrete x), "is bound with", text (verbalize p)] ++ pwords "polarity, so it cannot be used here at" +++ [text (verbalize (Indefinite l)), "position"]+ where+ PolarityModality _ p l = c++ ConversionError_ err -> prettyTCM err++ NotLeqSort s1 s2 -> fsep $+ [prettyTCM s1] ++ pwords "is not less or equal than" ++ [prettyTCM s2]++ TooManyFields r missing xs -> prettyTooManyFields r missing xs++ DuplicateConstructors xs -> (fsep . concat)+ [ [ "Duplicate" ]+ , [ pluralS xs "constructor" ]+ , pwords "in datatype:"+ ]+ <?> fsep (fmap pretty xs)++ DuplicateFields xs -> prettyDuplicateFields xs++ DuplicateOverlapPragma q old new -> fsep $+ pwords "The instance" ++ [prettyTCM q] +++ pwords "was already marked" ++ [pretty old <> "."] +++ pwords "This" ++ [pretty new] +++ pwords "pragma can not be applied to it."++ WithOnFreeVariable e v -> do+ de <- prettyA e+ dv <- prettyTCM v+ if show de == show dv+ then fsep $+ pwords "Cannot `with` on variable" ++ [return dv] +++ pwords " bound in a module telescope (or patterns of a parent clause)"+ else fsep $+ pwords "Cannot `with` on expression" ++ [return de] ++ pwords "which reduces to variable" ++ [return dv] +++ pwords " bound in a module telescope (or patterns of a parent clause)"++ UnexpectedWithPatterns ps -> fsep $+ pwords "Unexpected with patterns" ++ punctuate " |" (fmap prettyA ps)++ TooFewPatternsInWithClause -> fsep $ pwords "Too few arguments given in with-clause"+ TooManyPatternsInWithClause -> fsep $ pwords "Too many arguments given in with-clause"++ WithClausePatternMismatch p q -> fsep $+ pwords "With clause pattern " ++ [prettyA p] +++ pwords " is not an instance of its parent pattern " ++ [P.fsep <$> prettyTCMPatterns [q]]++ PathAbstractionFailed b -> vcat+ [ ("Path abstraction failed for type" <+> prettyTCM (unAbs b)) <> "."+ , "The type may be non-fibrant or its sort depends on an interval variable"+ ]++ MetaCannotDependOn m v i ->+ ifM (isSortMeta m `and2M` (not <$> hasUniversePolymorphism))+ ( {- then -}+ fsep [ text "Cannot instantiate the metavariable"+ , prettyTCM m+ , "to"+ , prettyTCM v+ , "since universe polymorphism is disabled"+ ]+ ) {- else -}+ ( fsep [ text "Cannot instantiate the metavariable"+ , prettyTCM m+ , "to solution"+ , prettyTCM v+ , "since it contains the variable"+ , prettyTCM (I.Var i [])+ , "which is not in scope of the metavariable"+ ]+ )+ MetaIrrelevantSolution m v ->+ fsep [ text "Cannot instantiate the metavariable"+ , prettyTCM m+ , "to solution"+ , prettyTCM v+ , "since (part of) the solution was created in an irrelevant context"+ ]++ MetaErasedSolution m v ->+ fsep [ text "Cannot instantiate the metavariable"+ , prettyTCM m+ , "to solution"+ , prettyTCM v+ , "since (part of) the solution was created in an erased context"+ ]++ WrongSharpArity c -> fsep $+ [prettyA c] ++ pwords "must be applied to exactly one argument"++ BuiltinMustBeConstructor s e -> fsep $+ [prettyA e] ++ pwords "must be a constructor in the binding to builtin" ++ [pretty s]++ BuiltinMustBeData s n -> fsep $+ pwords "The builtin" ++ [pretty s] ++ pwords "must be a datatype with" +++ if n == 1 then pwords "a single constructor or an (inductive) record type"+ else [pretty n] ++ pwords "constructors"++ BuiltinMustBeDef s -> fsep $+ pwords "The argument to BUILTIN" ++ [pretty s] ++ pwords "must be a defined name"++ BuiltinMustBeFunction s -> fsep $+ pwords "Builtin" ++ [pretty s] ++ pwords "must be bound to a function"++ BuiltinMustBePostulate s -> fsep $+ pwords "The argument to BUILTIN" ++ [pretty s] ++ pwords "must be a postulated name"++ NoSuchBuiltinName s -> fsep $+ pwords "There is no built-in thing called" ++ [pretty s]++ InvalidBuiltin s -> fwords s++ DuplicateBuiltinBinding b x y -> fsep $+ pwords "Duplicate binding for built-in thing" ++ [pretty b <> comma] +++ pwords "previous binding to" ++ [prettyTCM x]++ NoBindingForBuiltin x+ | x `elem` [builtinZero, builtinSuc] -> fsep $+ pwords "No binding for builtin " ++ [pretty x <> comma] +++ pwords ("use {-# BUILTIN " ++ getBuiltinId builtinNat ++ " name #-} to bind builtin natural " +++ "numbers to the type 'name'")+ | x `elem` [builtinRefl] -> fsep $+ pwords "No binding for builtin " ++ [pretty x <> comma] +++ pwords ("use {-# BUILTIN " ++ getBuiltinId builtinEquality ++ " name #-} to bind the builtin equality " +++ "type to 'name'")+ | otherwise -> fsep $+ pwords "No binding for builtin thing" ++ [pretty x <> comma] +++ pwords ("use {-# BUILTIN " ++ getBuiltinId x ++ " name #-} to bind it to 'name'")++ NoBindingForPrimitive x -> fsep $+ pwords "Missing binding for" +++ [pretty x] +++ pwords "primitive."++ DuplicatePrimitiveBinding b x y -> fsep $+ pwords "Duplicate binding for primitive thing" ++ [pretty b <> comma] +++ pwords "previous binding to" ++ [prettyTCM x]++ NoSuchPrimitiveFunction x -> fsep $+ pwords "There is no primitive function called" ++ [text x]++ WrongArgInfoForPrimitive x got expect ->+ vcat [ fsep $ pwords "Wrong definition properties for primitive" ++ [pretty x]+ , nest 2 $ text $ "Got: " ++ intercalate ", " gs+ , nest 2 $ text $ "Expected: " ++ intercalate ", " es ]+ where+ (gs, es) = unzip [ p | p@(g, e) <- zip (things got) (things expect), g /= e ]+ things i = [verbalize $ getHiding i,+ "at modality " ++ verbalize (getModality i)]++ TrustedBuiltin x -> fsep $+ pwords "The trusted builtin" ++ [text (show x)] +++ pwords "is only allowed in certain \"builtin\" modules"++ TrustedPrimitive x -> fsep $+ pwords "The trusted primitive" ++ [prettyTCM x] +++ pwords "is only allowed in certain \"builtin\" modules"++ BuiltinInParameterisedModule x -> fwords $+ "The BUILTIN pragma cannot appear inside a bound context " +++ "(for instance, in a parameterised module or as a local declaration)"++ IllegalLetInTelescope tb -> fsep $+ -- pwords "The binding" +++ pretty tb :+ pwords " is not allowed in a telescope here."++ IllegalPatternInTelescope bd -> fsep $+ pretty bd :+ pwords " is not allowed in a telescope here."++ AbsentRHSRequiresAbsurdPattern -> fwords $+ "The right-hand side can only be omitted if there " +++ "is an absurd pattern, () or {}, in the left-hand side."++ LibraryError err -> return $ formatLibErrors err++ LibTooFarDown m lib -> vcat+ [ text "An .agda-lib file for" <+> pretty m+ , text "must not be located in the directory" <+> text (takeDirectory (lib ^. libFile))+ ]++ SolvedButOpenHoles x -> do+ vcat $+ [ fsep $ prettyTCM x :+ pwords "cannot be imported since it has open interaction points"+ , "(consider adding {-# OPTIONS --allow-unsolved-metas #-} to that module)"+ ]++ CyclicModuleDependency ms0 -> do+ List2 m0 m1 ms <- for ms0 <$> topLevelModuleNameWithSourceFileCompleter+ fsep (pwords "cyclic module dependency:")+ $$ nest 2 (vcat $ (prettyTCM m0 :) $ map (("importing" <+>) . prettyTCM) (m1 : ms))++ FileNotFound x dirs ->+ fsep ( pwords "Failed to find source of module" ++ [pretty x] +++ pwords "in any of the following locations:"+ ) $$ prettyPossibleFilesForModule x dirs++ OverlappingProjects f m1 m2+ | canon d1 == canon d2 -> fsep $ concat+ [ pwords "Case mismatch when accessing file"+ , [ text $ filePath f ]+ , pwords "through module name"+ , [ pure d2 ]+ ]+ | otherwise -> fsep+ ( pwords "The file" ++ [text (filePath f)] +++ pwords "can be accessed via several project roots. Both" +++ [ pure d1 ] ++ pwords "and" ++ [ pure d2 ] +++ pwords "point to this file."+ )+ where+ canon = CaseInsens.mk . P.render+ d1 = P.pretty m1+ d2 = P.pretty m2++ AmbiguousTopLevelModuleName x files ->+ fsep ( pwords "Ambiguous module name. The module name" +++ [pretty x] +++ pwords "could refer to any of the following files:"+ ) $$ nest 2 (vcat $ fmap (text . filePath) files)++ AmbiguousProjection d disambs -> vcat+ [ "Ambiguous projection " <> prettyTCM d <> "."+ , "It could refer to any of"+ , nest 2 $ vcat $ fmap prettyDisambProj $ List2.cons d disambs+ ]++ AmbiguousOverloadedProjection ds reason -> do+ let+ x = headAmbQ ds+ nameRaw = pretty $ A.nameConcrete $ A.qnameName x+ vcat+ [ fsep+ [ text "Cannot resolve overloaded projection"+ , nameRaw+ , text "because"+ , pure reason+ ]+ , nest 2 $ text "candidates in scope:"+ , vcat $ for (getAmbiguous ds) $ \ d -> do+ t <- typeOfConst d+ text "-" <+> nest 2 (nameRaw <+> text ":" <+> prettyTCM t)+ -- , vcat . concat $ for (unAmbQ ds) \ d ->+ -- [ text "-" <+> nest 2 (nameRaw <+> text ":" <+> (prettyTCM =<< typeOfConst (fromAmbQName d))) ]+ -- +++ -- case d of+ -- AmbQName{} -> []+ -- AmbAbstractName x -> [ nest 2 $ prettyTCM x ]+ , case whyInScopeDataFromAmbiguousQName (qnameToConcrete x) ds of+ Nothing -> empty+ Just why -> explainWhyInScope why+ ]++ AmbiguousConstructor c disambs -> vcat+ [ "Ambiguous constructor " <> pretty (qnameName c) <> "."+ , "It could refer to any of"+ , nest 2 $ vcat $ fmap prettyDisambCons disambs+ ]++ InvalidFileName file reason -> fsep $+ pwords "The file name" ++ [pretty file] ++ pwords "is invalid because" +++ case reason of+ DoesNotCorrespondToValidModuleName ->+ pwords "it does not correspond to a valid module name."+ RootNameModuleNotAQualifiedModuleName defaultName ->+ pretty defaultName : pwords "is not an unqualified module name."++ ModuleDefinedInOtherFile mod file file' -> fsep $ concat+ [ pwords "You tried to load"+ , [ text (filePath file) ]+ , if moduleNameInferred mod+ then pwords "which seems to define the module"+ else pwords "which defines the module"+ , [ pretty mod <> "." ]+ , pwords "However, according to the include path this module should be defined in"+ , [ text (filePath file') ]+ -- Andreas, 2025-06-21, issue #7953:+ -- We have no test that triggers this hint, not sure it can be triggered at all.+ , if moduleNameInferred mod then pwords "(Hint: no module header was found in this file; adding one might fix this error.)"+ else empty+ ]++ ModuleNameUnexpected given expected -> do+ let+ canon = CaseInsens.mk . P.render+ dExpected = P.pretty expected+ dGiven <- prettyTCM given+ if| canon dGiven == canon dExpected -> fsep $ concat+ [ pwords "Case mismatch between the actual module name"+ , [ pure dGiven ]+ , pwords "and the expected module name"+ , [ pure dExpected ]+ ]+ | otherwise -> fsep $ concat+ [ pwords "The name of the top level module does not match the file name."+ , if moduleNameInferred (fileModuleName given) then+ pwords "The unnamed module" +++ [ do+ path <- srcFilePath $ fileModuleSourceFile given+ let r = rangeFromAbsolutePath path+ parens ("at" <> prettyTCM r)+ ]+ else pwords "The module" ++ [ pure dGiven ]+ , pwords "should probably be named"+ , [ pure dExpected ]+ ]++ ModuleNameHashCollision raw raw' -> fwords $ case raw' of+ Nothing ->+ "The module name " ++ prettyShow raw ++ " has a reserved " +++ "hash (you may want to consider renaming the module with this name)"+ Just raw' ->+ "Module name hash collision for " ++ prettyShow raw +++ " and " ++ prettyShow raw' ++ " (you may want to consider " +++ "renaming one of these modules)"++ ModuleNameDoesntMatchFileName given dirs -> vcat+ [ fsep $ concat+ [ [ "The" ]+ , [ "inferred" | moduleNameInferred given ]+ , [ "name" ]+ , [ "`" <> pretty given <> "`"]+ , pwords "of the top level module"+ , pwords "does not match the file name."+ , pwords "A such named module should be defined in one of the following files:"+ ]+ , prettyPossibleFilesForModule given dirs+ , if moduleNameInferred given then fsep $+ pwords "(Hint: no module header was found in this file; adding one might fix this error.)"+ else empty+ ]++ AbstractConstructorNotInScope q -> fsep $+ [ "Constructor"+ , prettyTCM q+ ] ++ pwords "is abstract, thus, not in scope here"++ BothWithAndRHS -> fsep $ pwords "Unexpected right hand side"++ CopatternHeadNotProjection x -> fsep $ concat+ [ pwords "Head of copattern needs to be a projection, but"+ , [ prettyTCM x ]+ , pwords "isn't one"+ ]++ NotAllowedInDotPatterns what -> fsep $ verb what ++ pwords "are not allowed in dot patterns"+ where+ verb = \case+ LetExpressions -> pwords "Let expressions"+ PatternLambdas -> pwords "Pattern lambdas"++ NotInScope x ->+ -- using the warning version to avoid code duplication+ prettyWarning $ NotInScopeW x++ NoSuchModule x -> do+ -- Andreas, 2025-10-18, issue #8144+ -- In the situation+ -- @+ -- mutual+ -- record R : Set where ...+ -- open R+ -- @+ -- which desugars to+ -- @+ -- record R : Set+ -- open R+ -- record R where ...+ -- @+ -- we want to give some hint that while record R is defined,+ -- its module R is not defined yet.+ hint <- do+ runExceptT (tryResolveName (someKindsOfNames [DataName, RecName]) Nothing x) >>= \case+ Right (DefinedName _ (AbsName y DataName _ _) _) -> do+ return "---but a data type of that name is in scope whose data module is either not defined yet or hidden"+ Right (DefinedName _ (AbsName y RecName _ _) _) -> do+ return "---but a record type of that name is in scope whose record module is either not defined yet or hidden (note that records defined in a `mutual' block cannot be opened in the same block)"+ _ -> return ""+ fsep $ pwords "No module" ++ [pretty x] ++ pwords ("in scope" ++ hint)++ AmbiguousName x reason -> vcat+ [ fsep $ pwords "Ambiguous name" ++ [pretty x <> "."] +++ pwords "It could refer to any one of"+ , nest 2 $ vcat $ fmap nameWithBinding $ ambiguousNamesInReason reason+ , explainWhyInScope $ whyInScopeDataFromAmbiguousNameReason x reason+ ]++ AmbiguousModule x ys -> vcat+ [ fsep $ pwords "Ambiguous module name" ++ [pretty x <> "."] +++ pwords "It could refer to any one of"+ , nest 2 $ vcat $ fmap help ys+ , fwords "(hint: Use C-c C-w (in Emacs) if you want to know why)"+ ]+ where+ help :: ModuleName -> m Doc+ help m = do+ anno <- caseMaybeM (isDatatypeModule m) (return empty) $ \case+ IsDataModule -> return $ "(datatype module)"+ IsRecordModule -> return $ "(record module)"+ sep [prettyTCM m, anno ]++ AmbiguousField field modules -> vcat $+ hsep [ "Ambiguity: the field", prettyTCM field, "appears in the following modules:" ]+ : map prettyTCM (List2.toList modules)++ ClashingDefinition x y suggestion -> vcat+ [ fsep $ pwords "Multiple definitions of" ++ [ pretty x <> "." ] ++ clashingWith y+ , fromMaybe empty $ fmap hint suggestion+ ]+ where+ clashingWith = \case+ ClashingAbstractName y -> do+ pwords "Previous definition" ++ [explainWhyInScope $ whyInScopeDataFromAbstractName x y]+ ClashingQName y ->+ pwords "Previous definition at" ++ [prettyTCM $ nameBindingSite y]+ hint d = do+ let dataOrRecord = case d of+ NiceDataDef{} -> "data"+ NiceRecDef{} -> "record"+ _ -> __IMPOSSIBLE__+ vcat+ [ "Perhaps you meant to write"+ , nest 2 ("'" <> pretty (notSoNiceDeclarations d) <> "'")+ , ("at" <+> (pretty . view eRange =<< askTC)) <> "?"+ , fsep $ concat+ [ [ "In", dataOrRecord ]+ , pwords "definitions separate from their"+ , [ dataOrRecord ]+ , pwords "declaration, the ':' and type must be omitted"+ ] ]++ ClashingModule m1 m2 -> fsep $+ pwords "The modules" ++ [prettyTCM m1, "and", prettyTCM m2]+ ++ pwords "clash."++ DuplicateImports m xs ->+ fsep (pwords "Ambiguous imports from module" ++ [pretty m] ++ pwords "for identifiers:")+ <?> fsep (punctuate ";" $ fmap pretty xs)+ -- Andreas, 2026-02-14 punctuate with semicolon since xs may contain "module M" or even ","++ DefinitionInDifferentModule _x -> fsep $+ pwords "Definition in different module than its type signature"++ FieldOutsideRecord -> fsep $+ pwords "Field appearing outside record declaration."++ PrivateRecordField -> fwords "Record fields cannot be private"++ InvalidPattern p -> fsep $+ pretty p : pwords "is not a valid pattern"++ InvalidPun kind x -> fsep $ concat+ [ pwords "A pun must not use the"+ , [ pure $ P.pretty kind ]+ , [ prettyTCM x ]+ ]++ RepeatedVariablesInPattern xs -> fsep $+ pwords "Repeated variables in pattern:" ++ map pretty (List1.toList xs)++ RepeatedNamesInImportDirective yss ->+ (fsep . concat)+ [ [ "Repeated" , pluralS yss "name" ]+ , pwords "in import directive:"+ ]+ <?> fsep (punctuate ";" $ fmap (prettyTCM . List2.head) yss)+ -- Andreas, 2026-02-14 punctuate with semicolon since list may contain "module M" or even ","++ DeclarationsAfterTopLevelModule -> fwords $ "No declarations allowed after top-level module."++ IllegalDeclarationBeforeTopLevelModule -> fwords $ "Illegal declaration(s) before top-level module"++ MissingTypeSignature info -> fwords "Missing type signature for" <+> prettyTCM info++ NotAnExpression e -> fsep $+ pretty e : pwords "is not a valid expression."++ NotAValidLetBinding Nothing -> fwords $ "Not a valid let binding"+ NotAValidLetBinding (Just err) -> fwords $ verbalizeNotAValidLetBinding err++ NotAValidLetExpression err -> fwords $ verbalizeNotAValidLetExpression err++ NotValidBeforeField nd -> fwords $+ "This declaration is illegal in a record before the last field"++ NoParseForApplication es -> fsep (+ pwords "Could not parse the application" ++ [pretty $ C.RawApp noRange es])++ AmbiguousParseForApplication es es' -> fsep (+ pwords "Don't know how to parse" ++ [pretty_es <> "."] +++ pwords "Could mean any one of:"+ ) $$ nest 2 (vcat $ fmap pretty' es')+ where+ pretty_es :: m Doc+ pretty_es = pretty $ C.RawApp noRange es++ pretty' :: C.Expr -> m Doc+ pretty' e = do+ p1 <- pretty_es+ p2 <- pretty e+ if render p1 == render p2 then unambiguous e else return p2++ unambiguous :: C.Expr -> m Doc+ unambiguous e@(C.OpApp r op _ xs)+ | all (isOrdinary . namedArg) xs =+ pretty $+ foldl (C.App r) (C.Ident op) $+ (fmap . fmap . fmap) fromOrdinary xs+ | any (isPlaceholder . namedArg) xs =+ pretty e <+> "(section)"+ unambiguous e = pretty e++ isOrdinary :: MaybePlaceholder (C.OpApp e) -> Bool+ isOrdinary (NoPlaceholder _ (C.Ordinary _)) = True+ isOrdinary _ = False++ fromOrdinary :: MaybePlaceholder (C.OpApp e) -> e+ fromOrdinary (NoPlaceholder _ (C.Ordinary e)) = e+ fromOrdinary _ = __IMPOSSIBLE__++ isPlaceholder :: MaybePlaceholder a -> Bool+ isPlaceholder Placeholder{} = True+ isPlaceholder NoPlaceholder{} = False++ AsPatternInPatternSynonym -> fsep $ pwords "@-patterns are not allowed in pattern synonyms"++ DotPatternInPatternSynonym -> fsep $ pwords+ "Dot or equality patterns are not allowed in pattern synonyms. Maybe use '_' instead."++ BadArgumentsToPatternSynonym x -> fsep $+ pwords "Bad arguments to pattern synonym " ++ [prettyTCM $ headAmbQ x]++ TooFewArgumentsToPatternSynonym x -> fsep $+ pwords "Too few arguments to pattern synonym " ++ [prettyTCM $ headAmbQ x]++ CannotResolveAmbiguousPatternSynonym defs -> vcat+ [ fsep $ pwords "Cannot resolve overloaded pattern synonym" ++ [prettyTCM x <> comma] +++ pwords "since candidates have different shapes:"+ , nest 2 $ vcat $ fmap prDef defs+ , fsep $ pwords "(hint: overloaded pattern synonyms must be equal up to variable and constructor names)"+ ]+ where+ (x, _) = List1.head defs+ prDef (x, (A.PatternSynDefn xs p)) = prettyA (A.PatternSynDef x (map (fmap BindName) xs) p) <?> ("at" <+> pretty r)+ where r = nameBindingSite x++ IllegalInstanceVariableInPatternSynonym x -> fsep $ concat+ [ pwords "Variable is bound as instance in pattern synonym,"+ , pwords "but does not resolve as instance in pattern: "+ , [pretty x]+ ]++ PatternSynonymArgumentShadows kind x (y :| _ys) -> vcat+ [ fsep $ concat+ [ pwords "Pattern synonym variable"+ , [ pretty x ]+ , [ "shadows" ]+ , [ pretty kind ]+ , pwords "defined at:"+ ]+ , pretty $ nameBindingSite y+ ]++ UnusedVariableInPatternSynonym x -> fsep $+ pwords "Unused variable in pattern synonym: " ++ [pretty x]++ UnboundVariablesInPatternSynonym xs -> fsep $+ pwords "Unbound variables in pattern synonym: " +++ [sep (fmap prettyA xs)]++ NoParseForLHS lhsOrPatSyn errs p -> vcat+ [ fsep $ pwords "Could not parse the" ++ prettyLhsOrPatSyn ++ [pretty p]+ , prettyErrs+ ]+ where+ prettyLhsOrPatSyn = pwords $ case lhsOrPatSyn of+ IsLHS -> "left-hand side"+ IsPatSyn -> "pattern synonym right-hand side"+ prettyErrs = case errs of+ [] -> empty+ p0 : _ -> fsep $ pwords "Problematic expression:" ++ [pretty p0]++ AmbiguousParseForLHS lhsOrPatSyn p ps -> do+ d <- pretty p+ vcat $+ [ fsep $+ pwords "Don't know how to parse" ++ [pure d <> "."] +++ pwords "Could mean any one of:"+ ]+ +++ map (nest 2 . pretty' d) (List2.toList ps)+ where+ pretty' :: Doc -> C.Pattern -> m Doc+ pretty' d1 p' = do+ d2 <- pretty p'+ if render d1 == render d2 then pretty $ unambiguousP p' else return d2++ -- the entire pattern is shown, not just the ambiguous part,+ -- so we need to dig in order to find the OpAppP's.+ unambiguousP :: C.Pattern -> C.Pattern+ unambiguousP (C.AppP x y) = C.AppP (unambiguousP x) $ (fmap.fmap) unambiguousP y+ unambiguousP (C.HiddenP r x) = C.HiddenP r $ fmap unambiguousP x+ unambiguousP (C.InstanceP r x) = C.InstanceP r $ fmap unambiguousP x+ unambiguousP (C.ParenP r x) = C.ParenP r $ unambiguousP x+ unambiguousP (C.AsP r n x) = C.AsP r n $ unambiguousP x+ unambiguousP (C.OpAppP r op _ xs) = foldl C.AppP (C.IdentP True op) xs+ unambiguousP e = e++ OperatorInformation sects (OpScope _ globals locals) err ->+ prettyTCM err+ $+$+ fsep (pwords "Operators used in the grammar:")+ $$+ nest 2+ (if null sects then "None" else+ vcat (map (text . rtrim) $+ lines $+ Boxes.render $+ (\(col1, col2, col3) ->+ Boxes.hsep 1 Boxes.top $+ map (Boxes.vcat Boxes.left) [col1, col2, col3]) $+ unzip3 $+ map prettySect $+ sortBy (compare `on` prettyShow . notaName . sectNotation) $+ properSects))+ $$+ if null relevantSimpleNames then empty else do+ fsep (pwords "Identifiers used in the grammar that overlap with the operators:")+ $$+ nest 2 (fsep (map text relevantSimpleNames))++ where+ -- Andreas, 2025-12-17, issue #3677+ -- Prepare a list of names in scope that might clash with the operators.+ -- For now, disregard qualified names.+ relevantSimpleNames = List.sort $ filter (hasElem operatorParts) simpleNames+ simpleNames =+ mapMaybe (C.isSimpleName <=< C.isUnqualified) (Map.keys globals) +++ mapMaybe C.isSimpleName (AssocList.keys locals)+ operatorParts = concatMap (stringParts . notation . sectNotation) properSects++ properSects = filter (not . closedWithoutHoles) sects++ trimLeft = dropWhile isAHole+ trimRight = dropWhileEnd isAHole++ closedWithoutHoles sect =+ sectKind sect == NonfixNotation+ &&+ null [ () | HolePart{} <- trimLeft $ trimRight $+ notation (sectNotation sect) ]++ prettyName n = Boxes.text $+ P.render (P.pretty n) +++ " (" ++ P.render (P.pretty (nameBindingSite n)) ++ ")"++ prettySect sect =+ ( Boxes.text (P.render (P.pretty section))+ Boxes.//+ strut+ , Boxes.text+ ("(" +++ kind ++ " " +++ (if notaIsOperator nota+ then "operator"+ else "notation") +++ (if sectIsSection sect+ then " section"+ else "") +++ (case sectLevel sect of+ Nothing -> ""+ Just Unrelated -> ", unrelated"+ Just (Related l) -> ", level " ++ toStringWithoutDotZero l) +++ ")")+ Boxes.//+ strut+ , "["+ Boxes.<>+ Boxes.vcat Boxes.left+ (map (\n -> prettyName n Boxes.<> ",") names +++ [prettyName name Boxes.<> "]"])+ )+ where+ nota = sectNotation sect+ section = qualifyFirstIdPart+ (foldr (\x s -> C.nameToRawName x ++ "." ++ s)+ ""+ (List1.init (C.qnameParts (notaName nota))))+ (spacesBetweenAdjacentIds $+ trim (notation nota))++ qualifyFirstIdPart _ [] = []+ qualifyFirstIdPart q (IdPart x : ps) = IdPart (fmap (q ++) x) : ps+ qualifyFirstIdPart q (p : ps) = p : qualifyFirstIdPart q ps++ spacesBetweenAdjacentIds (IdPart x : ps@(IdPart _ : _)) =+ IdPart x : IdPart (unranged " ") : spacesBetweenAdjacentIds ps+ spacesBetweenAdjacentIds (p : ps) =+ p : spacesBetweenAdjacentIds ps+ spacesBetweenAdjacentIds [] = []++ trim = case sectKind sect of+ InfixNotation -> trimLeft . trimRight+ PrefixNotation -> trimRight+ PostfixNotation -> trimLeft+ NonfixNotation -> id+ NoNotation -> __IMPOSSIBLE__++ (names, name) = List1.initLast $ Set1.toList $ notaNames nota++ strut = Boxes.emptyBox (length names) 0++ kind = case sectKind sect of+ PrefixNotation -> "prefix"+ PostfixNotation -> "postfix"+ NonfixNotation -> "closed"+ NoNotation -> __IMPOSSIBLE__+ InfixNotation ->+ case fixityAssoc $ notaFixity nota of+ NonAssoc -> "infix"+ LeftAssoc -> "infixl"+ RightAssoc -> "infixr"++{- UNUSED+ AmbiguousParseForPatternSynonym p ps -> fsep (+ pwords "Don't know how to parse" ++ [pretty p <> "."] +++ pwords "Could mean any one of:"+ ) $$ nest 2 (vcat $ map pretty ps)+-}++ SplitError e -> prettyTCM e++ ImpossibleConstructor c neg -> fsep $+ pwords "The case for the constructor " ++ [prettyTCM c] +++ pwords " is impossible" ++ [prettyTCM neg] +++ pwords "Possible solution: remove the clause, or use an absurd pattern ()."++ DatatypeIndexPolarity -> fsep $+ pwords "Cannot annotate datatype indices with polarity other than @mixed"++ InstanceNoCandidate t errs -> vcat $+ [ fsep $ pwords "No instance of type" ++ [prettyTCM t] ++ pwords "was found in scope."+ , vcat $ map prCand errs ]+ where+ prCand (term, err) =+ text "-" <+>+ vcat [ prettyTCM term <?> text "was ruled out because"+ , prettyTCM err ]++ UnquoteFailed e -> prettyTCM e++ DeBruijnIndexOutOfScope i EmptyTel [] -> fsep $+ pwords $ "de Bruijn index " ++ show i ++ " is not in scope in the empty context"+ DeBruijnIndexOutOfScope i cxt names ->+ sep [ text ("de Bruijn index " ++ show i ++ " is not in scope in the context")+ , inTopContext $ addContext ("_" :: String) $ prettyTCM cxt' ]+ where+ cxt' = cxt `abstract` raise (size cxt) (nameCxt names)+ nameCxt :: [Name] -> I.Telescope+ nameCxt [] = EmptyTel+ nameCxt (x : xs) = ExtendTel (defaultDom (El __DUMMY_SORT__ $ I.var 0)) $+ NoAbs (P.prettyShow x) $ nameCxt xs++ MissingBindingsForTelescopeVariables xs -> vcat+ [ fsep [ "Missing", pluralS xs "binding", "for", "telescope", pluralS xs "variable" <> colon ]+ <?> (fsep (fmap (text . Text.unpack) xs))+ , "All variables in the clause telescope must be bound in the left-hand side."+ ]++ NeedOptionAllowExec -> fsep $+ pwords "Option --allow-exec needed to call external commands from macros"++ NeedOptionCopatterns -> fsep $+ pwords "Option --copatterns needed to enable destructor patterns"++ NeedOptionCubical cubical reason -> fsep $ concat+ [ [ "Option" ], [ opt ], [ "required" ]+ , pwords reason+ ]+ where+ opt = case cubical of+ CFull -> "--cubical[=full]"+ CErased -> "--cubical[={full,erased}]"+ CWithoutGlue -> "--cubical[={full,erased,no-glue}]"++ NeedOptionPatternMatching -> fsep $+ pwords "Pattern matching is disabled (use option --pattern-matching to enable it)"++ NeedOptionIrrelevance -> fsep $+ pwords "Irrelevance modality is disabled (use options --irrelevance and --no-irrelevance to enable/disable irrelevance)"++ NeedOptionProp -> fsep $+ pwords "Universe Prop is disabled (use options --prop and --no-prop to enable/disable Prop)"++ NeedOptionRewriting -> fsep $+ pwords "Option --rewriting needed to add and use rewrite rules"++ NeedOptionSizedTypes reason -> fsep $+ pwords "Option --sized-types needed" ++ pwords reason++ NeedOptionTwoLevel -> fsep $+ pwords "Universe SSet is disabled (use option --two-level to enable SSet)"++ NeedOptionUniversePolymorphism -> fsep $+ pwords "Universe polymorphism is disabled (use option --universe-polymorphism to allow level arguments to sorts)"++ CannotGeneralizeEtaExpandable x metaType ->+ ("Cannot generalize over" <+> prettyTCM x <+> "of eta-expandable type") <?> prettyTCM metaType++ GeneralizeNotSupportedHere x -> fsep $+ pwords $ "Generalizable variable " ++ prettyShow x ++ " is not supported here"++ GeneralizeCyclicDependency -> fsep $+ pwords "Cyclic dependency between generalized variables"++ GeneralizedVarInLetOpenedModule x -> fsep $+ pwords "Cannot use generalized variable from let-opened module: " +++ [prettyTCM x]++ MultipleFixityDecls xs ->+ sep [ fsep $ pwords "Multiple fixity or syntax declarations for"+ , vcat $ fmap f xs+ ]+ where+ f (x, fs) = (pretty x <> ": ") <+> fsep (fmap (pretty . PrintRange) fs)++ MultiplePolarityPragmas xs -> fsep $+ pwords "Multiple polarity pragmas for" ++ map pretty (List1.toList xs)++ CannotQuote what -> do+ fwords "`quote' expects an unambiguous defined name," $$ do+ fsep $ pwords "but here the argument is" +++ case what of+ CannotQuoteNothing ->+ pwords "missing"+ CannotQuoteHidden ->+ pwords "implicit"+ CannotQuoteAmbiguous xs ->+ pwords "ambiguous:" ++ [ pretty xs ]+ CannotQuoteExpression e -> case e of+ -- These expression can be quoted:+ A.Def' _ NoSuffix -> __IMPOSSIBLE__+ -- Andreas, 2024-09-27, issue #7514:+ -- Why only quote suffix-free universes?+ A.Macro {} -> __IMPOSSIBLE__+ A.Proj {} -> __IMPOSSIBLE__+ A.Con {} -> __IMPOSSIBLE__+ A.DontCare {} -> __IMPOSSIBLE__+ A.ScopedExpr {} -> __IMPOSSIBLE__+ -- These cannot:+ A.PatternSyn {} -> other "a pattern synonym:"+ A.Var {} -> other "a variable:"+ A.Lit {} -> other "a literal:"+ A.QuestionMark {} -> pwords "a metavariable"+ A.Underscore {} -> pwords "a metavariable"+ _ ->+ pwords "a compound expression"+ where+ other s = pwords s ++ [ prettyTCM e]+ CannotQuotePattern p -> case namedArg p of+ C.IdentP {} -> __IMPOSSIBLE__+ C.HiddenP {} -> __IMPOSSIBLE__+ C.InstanceP {} -> __IMPOSSIBLE__+ C.RawAppP {} -> __IMPOSSIBLE__+ C.AbsurdP {} -> pwords "an absurd pattern"+ C.LitP {} -> pwords "a literal pattern"+ C.WildP {} -> pwords "a wildcard pattern"+ _ ->+ pwords "a compound pattern"++ CannotQuoteTerm what -> do+ fwords "`quoteTerm' expects a single visible argument," $$ do+ fsep $ pwords "but has been given" +++ case what of+ CannotQuoteTermNothing ->+ pwords "none"+ CannotQuoteTermHidden ->+ pwords "an implicit one"+++ ConstructorNameOfNonRecord res -> case res of+ UnknownName -> __IMPOSSIBLE__ -- Turned into NotInScope when the name is resolved+ name ->+ let+ qn :: m Doc+ (qn, whatis) = case name of+ DefinedName _ nm _ -> (prettyTCM nm,) case anameKind nm of+ RecName -> __IMPOSSIBLE__+ ConName -> __IMPOSSIBLE__+ CoConName -> __IMPOSSIBLE__+ FldName -> __IMPOSSIBLE__+ PatternSynName -> __IMPOSSIBLE__++ GeneralizeName -> "a generalized variable"+ DisallowedGeneralizeName -> "a generalized variable"+ MacroName -> "a macro"+ QuotableName -> "a quotable name"++ DataName -> "a data type"+ FunName -> "a function"+ AxiomName -> "a postulate"+ PrimName -> "a primitive"+ OtherDefName -> "a defined symbol"+ VarName a _ -> (prettyTCM a, "a local variable")+ FieldName (a :| _) -> (prettyTCM a, "a projection")+ ConstructorName _ (a :| _) -> (prettyTCM a, "a constructor")+ PatternSynResName (a :| _) -> (prettyTCM a, "a pattern synonym")+ in fsep $ pwords "Only record types have constructor names, but" ++ [qn, "is"] ++ pwords (whatis <> ".")++ NonFatalErrors ws -> vsep $ fmap prettyTCM $ Set1.toAscList ws++ ExplicitPolarityVsPragma p -> fsep $+ pwords "Polarity pragma used for " ++ [ prettyTCM p ] ++ pwords " but its type is already annotated with polarities."++ InstanceSearchDepthExhausted c a d -> fsep $+ pwords ("Instance search depth exhausted (max depth: " ++ show d ++ ") for candidate") +++ [hang (prettyTCM c <+> ":") 2 (prettyTCM a)]++ TriedToCopyConstrainedPrim q -> fsep $+ pwords "Cannot create a module containing a copy of" ++ [prettyTCM q]++ InvalidInstanceHeadType _ why -> fsep $ case why of+ ImproperInstHead -> pwords "Instance search can only be used to find elements in a named type"+ ImproperInstTele -> pwords "Instance search cannot be used to find elements in an explicit function type"++ SortOfSplitVarError _ doc -> return doc++ ReferencesFutureVariables term (disallowed :| _) lock leftmost+ | disallowed == leftmost+ -> fsep $ concat+ [ pwords "The lock variable"+ , [ prettyTCM =<< nameOfBV disallowed ]+ , pwords "can not appear simultaneously in the \"later\" term"+ , [ prettyTCM term ]+ , pwords "and in the lock term"+ , [ prettyTCM lock ]+ ]++ ReferencesFutureVariables term (disallowed :| rest) lock leftmost -> do+ let+ name = prettyTCM =<< nameOfBV leftmost+ lck = prettyTCM lock+ mod = case getLock lock of+ IsLock LockOLock -> "@lock"+ IsLock LockOTick -> "@tick"+ IsNotLock -> __IMPOSSIBLE__+ explain <- liftA2 (/=) lck name+ vcat $ concat+ [ [ fsep $ concat+ [ pwords "The variable"+ , [ prettyTCM =<< nameOfBV disallowed ]+ , pwords "can not be mentioned here,"+ , pwords "since it was not introduced before the variable"+ , [ name <> "." ]+ ]+ ]+ , [ fsep $ concat+ [ pwords "Variables introduced after"+ , [ name ]+ , pwords "can not be used, since that is the leftmost"+ , [ mod ]+ , pwords "variable in the locking term"+ , [ lck <> "." ]+ ]+ | explain+ ]+ , [ (fsep . concat)+ [ pwords "The following"+ , P.singPlural rest (pwords "variable is") (pwords "variables are")+ , pwords "not allowed here, either:"+ ]+ <?> fsep (map (prettyTCM <=< nameOfBV) rest)+ | not (null rest)+ ]+ ]++ DoesNotMentionTicks term ty lock ->+ let+ mod = case getLock lock of+ IsLock LockOLock -> "@lock"+ IsLock LockOTick -> "@tick"+ _ -> __IMPOSSIBLE__+ in+ vcat+ [ fsep $+ pwords "The term"+ ++ [prettyTCM lock <> ","]+ ++ pwords "given as an argument to the guarded value"+ , nest 2 (prettyTCM term <+> ":" <+> prettyTCM ty)+ , fsep (pwords ("can not be used as a " ++ mod ++ " argument, since it does not mention any " ++ mod ++ " variables."))+ ]++ MismatchedProjectionsError left right -> fsep $+ pwords "The projections" ++ [prettyTCM left] +++ pwords "and" ++ [prettyTCM right] +++ pwords "do not match"++ AttributeKindNotEnabled kind opt s -> fsep $+ [text kind] +++ pwords "attributes have not been enabled (use" +++ [text opt] +++ pwords "to enable them):" +++ [text s]++ InvalidProjectionParameter arg -> fsep $+ pwords "Invalid projection parameter " +++ [prettyA arg]++ TacticAttributeNotAllowed -> fsep $+ pwords "The @tactic attribute is not allowed here"++ CannotRewriteByNonEquation t ->+ "Cannot rewrite by equation of type" <+> prettyTCM t++ MacroResultTypeMismatch expectedType ->+ sep [ "Result type of a macro must be", nest 2 $ prettyTCM expectedType ]++ NamedWhereModuleInRefinedContext args names -> do+ let pr x v = text (x ++ " =") <+> prettyTCM v+ vcat+ [ fsep $ pwords $ "Named where-modules are not allowed when module parameters have been refined by pattern matching."+ , "(See" <+> (githubIssue 2897 <> ".)")+ , text $ "In this case the module parameter" +++ (if not (null args) then "s have" else " has") +++ " been refined to"+ , nest 2 $ vcat $ zipWith pr names args+ ]++ NamedWhereModuleUnderWith -> fsep $+ pwords "Named `where` modules are disallowed under `with` or `rewrite` since Agda 2.9.0"+ ++ [ parens $ "see" <+> githubIssue 8698 ]++ CannotGenerateHCompClause ty -> fsep $ concat+ [ pwords "Cannot generate hcomp clause at type"+ , [ prettyTCM ty ]+ ]++ CannotGenerateTransportClause f clos ->+ enterClosure clos \ failed_t -> addContext ("i" :: String, __DUMMY_DOM__) $ vcat+ [ "Could not generate a transport clause for" <+> prettyTCM f+ , "because a term of type" <+> prettyTCM (unAbs failed_t)+ , "lives in the sort" <+> prettyTCM (getSort (unAbs failed_t))+ , "and thus can not be transported"+ ]++ CannotGenerateTransportLocalRewrite f -> vcat+ [ "Could not generate a transport function for" <+> prettyTCM f+ , "because there is a local rewrite rule in its telescope"]++ CubicalNotErasure q -> prettySigCubicalNotErasure q++ CubicalPrimitiveNotFullyApplied c ->+ prettyTCM c <+> "must be fully applied"++ ExpectedIntervalLiteral e -> do+ i0 <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinIZero+ i1 <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinIOne+ fsep $ concat+ [ pwords "Expected an interval literal"+ , [ parens $ fsep [ prettyTCM i0, "or", prettyTCM i1 ] ]+ , pwords "but found:"+ , [ prettyTCM e ]+ ]++ PatternInPathLambda ->+ fwords "Patterns are not allowed in Path-lambdas"++ PatternInSystem ->+ fwords "Pattern matching or path copatterns not allowed in systems"++ FaceConstraintDisjunction ->+ fwords "Cannot have disjunctions in a face constraint"++ FaceConstraintUnsatisfiable ->+ fwords "The face constraint is unsatisfiable"++ IllTypedPatternAfterWithAbstraction p -> vcat+ [ "Ill-typed pattern after with abstraction: " <+> prettyA p+ , "(perhaps you can replace it by `_`?)"+ ]++ ComatchingDisabledForRecord recName ->+ "Copattern matching is disabled for record" <+> prettyTCM recName++ IlltypedRewriteRule d -> return d++ IncorrectTypeForRewriteRelation v reason -> case reason of+ ShouldAcceptAtLeastTwoArguments -> sep+ [ prettyTCM v <+> " does not have the right type for a rewriting relation"+ , "because it should accept at least two arguments"+ ]+ FinalTwoArgumentsNotVisible -> sep+ [ prettyTCM v <+> " does not have the right type for a rewriting relation"+ , "because its two final arguments are not both visible."+ ]+ TypeDoesNotEndInSort core tel -> sep+ [ prettyTCM v <+> " does not have the right type for a rewriting relation"+ , "because its type does not end in a sort, but in "+ <+> do inTopContext $ addContext tel $ prettyTCM core+ ]++ UnexpectedParameter par -> do+ text "Unexpected parameter" <+> prettyA par++ NoParameterOfName x xs -> fsep $+ text ("No parameter of name " ++ x)+ : [ parens $ fsep $ text "possible parameters:" : map text xs | not (null xs) ]++ UnexpectedModalityAnnotationInParameter par -> do+ text "Unexpected modality/relevance annotation in" <+> prettyA par++ SortDoesNotAdmitDataDefinitions name s ->fsep+ [ "The universe"+ , prettyTCM s+ , "of"+ , prettyTCM name+ , "does not admit data or record declarations"+ ]++ SortCannotDependOnItsIndex name t -> fsep+ [ "The sort of" <+> prettyTCM name+ , "cannot depend on its indices in the type"+ , prettyTCM t+ ]++ ExpectedBindingForParameter a b -> sep+ [ "Expected binding for parameter"+ , text (absName b) <+> text ":" <+> prettyTCM (unDom a)+ ]++ UnexpectedTypeSignatureForParameter xs -> do+ fsep (pwords "Unexpected type signature for" ++ [ pluralS xs "parameter" ]) <+> sep (fmap prettyA xs)++ UnguardedEtaRecord name -> vcat+ [ fsep $ pwords "Recursive occurrence of this record in its definition is unguarded, so eta-equality for this record might lead to non-termination in the type checker."+ , fsep $ pwords "To suppress this error, use pragma" ++ [ "{-# ETA_EQUALITY #-}" ]+ ]++ UnusableAtModality why mod t -> do+ compatible <- cubicalCompatibleOption+ cubical <- isJust <$> cubicalOption+ let+ context+ | cubical = "in Cubical Agda,"+ | compatible = "to maintain compatibility with Cubical Agda,"+ | otherwise = "when --without-K is enabled,"++ explanation what+ | cubical || compatible =+ [ ""+ , fsep ( "Note:":pwords context+ ++ pwords what ++ pwords "must be usable at the modality"+ ++ pwords "in which the function was defined, since it will be"+ ++ pwords "used for computing transports"+ )+ , ""+ ]+ | otherwise = []+ case why of+ IndexedClause ->+ vcat $+ ( fsep ( pwords "This clause has target type"+ ++ [prettyTCM t]+ ++ pwords "which is not usable at the required modality"+ ++ [attributesForModality mod <> "."]+ )+ : explanation "the target type")++ -- Arguments sometimes need to be transported too:+ IndexedClauseArg forced the_arg ->+ vcat $+ ( fsep (pwords "The argument" ++ [prettyTCM the_arg] ++ pwords "has type")+ : nest 2 (prettyTCM t)+ : fsep ( pwords "which is not usable at the required modality"+ ++ [attributesForModality mod <> "."] )+ : explanation "this argument's type")++ -- Note: if a generated clause is modality-incorrect, that's a+ -- bug in the LHS modality check+ GeneratedClause ->+ __IMPOSSIBLE_VERBOSE__ . show =<<+ prettyTCM t+ <+> "is not usable at the required modality"+ <+> attributesForModality mod+ _ -> prettyTCM t <+> "is not usable at the required modality"+ <+> attributesForModality mod++ CubicalCompilationNotSupported cubical -> fsep $ concat+ [ pwords $ "Compilation of code that uses"+ , [ text $ cubicalOptionString cubical ]+ , pwords $ "is not supported."+ ]++ QualifiedLocalModule -> fwords "Local modules cannot have qualified names"++ BackendDoesNotSupportOnlyScopeChecking backend -> fsep $ concat+ [ pwords "The backend"+ , [ prettyTCM backend ]+ , pwords "does not support --only-scope-checking."+ ]++ UnknownBackend backend backends -> pure $ P.vcat $ concat+ [ [ P.hcat [ "No backend called '", P.pretty backend, "' " ] ]+ , [ "Installed backend(s):" ]+ , map (("-" P.<+>) . P.pretty) $ Set.toAscList backends+ ]++ CustomBackendError backend err -> (pretty backend <> ":") <?> pure err++ GHCBackendError err -> prettyTCM err++ JSBackendError err -> prettyTCM err++ InteractionError err -> prettyTCM err++ where+ mpar n args+ | n > 0 && not (null args) = parens+ | otherwise = id++ prettyArg :: Arg (I.Pattern' a) -> m Doc+ prettyArg (Arg info x) = case getHiding info of+ Hidden -> braces $ prettyPat 0 x+ Instance{} -> dbraces $ prettyPat 0 x+ NotHidden -> prettyPat 1 x++ prettyPat :: Integer -> (I.Pattern' a) -> m Doc+ prettyPat _ (I.VarP _ _) = "_"+ prettyPat _ (I.DotP _ _) = "._"+ prettyPat n (I.ConP c _ args) =+ mpar n args $+ prettyTCM c <+> fsep (map (prettyArg . fmap namedThing) args)+ prettyPat n (I.DefP o q args) =+ mpar n args $+ prettyTCM q <+> fsep (map (prettyArg . fmap namedThing) args)+ prettyPat _ (I.LitP _ l) = prettyTCM l+ prettyPat _ (I.ProjP _ p) = "." <> prettyTCM p+ prettyPat _ (I.IApplyP _ _ _ _) = "_"++{-# SPECIALIZE prettyPossibleFilesForModule :: TopLevelModuleName -> List1 AbsolutePath -> TCM Doc #-}+prettyPossibleFilesForModule :: MonadPretty m => TopLevelModuleName -> List1 AbsolutePath -> m Doc+prettyPossibleFilesForModule m dirs = vcat+ [ nest 2 $ vcat $ map text $+ [ filePath dir </> moduleNameToFileName m ".AGDA"+ | dir <- List1.toList dirs+ ]+ , "where .AGDA denotes a legal extension for an Agda file"+ , parens $ fsep $ pwords "i.e., one of" ++ map text agdaFileExtensions+ ]++-- | Pretty-print error 'ShadowedModule' and return the range of the shadowed module.+{-# SPECIALIZE prettyShadowedModule :: C.Name -> List1 A.ModuleName -> TCM (TCM Doc, Range) #-}+prettyShadowedModule :: MonadPretty m => C.Name -> List1 A.ModuleName -> m (m Doc, Range)+prettyShadowedModule x ms@(m0 :| _) = do+ -- Clash! Concrete module name x already points to the abstract names ms.+ (r, m) <- do+ -- Andreas, 2017-07-28, issue #719.+ -- First, we try to find whether one of the abstract names @ms@ points back to @x@+ scope <- getScope+ -- Get all pairs (y,m) such that y points to some m ∈ ms.+ let xms0 = concat $ ms <&> \ m -> map (,m) $ inverseScopeLookupModule m scope+ reportSLn "scope.clash.error" 30 $ "candidates = " ++ prettyShow xms0++ -- Try to find x (which will have a different Range, if it has one (#2649)).+ let xms = filter ((\ y -> not (null $ getRange y) && y == C.QName x) . fst) xms0+ reportSLn "scope.class.error" 30 $ "filtered candidates = " ++ prettyShow xms++ -- If we found a copy of x with non-empty range, great!+ ifJust (listToMaybe xms) (\ (x', m) -> return (getRange x', m)) $ {-else-} do++ -- If that failed, we pick the first m from ms which has a nameBindingSite.+ let rms = concat $ ms <&> \ m -> map (,m) $+ filter (noRange /=) $ map nameBindingSite $ reverse $ mnameToList m+ -- Andreas, 2017-07-25, issue #2649+ -- Take the first nameBindingSite we can get hold of.+ reportSLn "scope.class.error" 30 $ "rangeful clashing modules = " ++ prettyShow rms++ -- If even this fails, we pick the first m and give no range.+ return $ fromMaybe (noRange, m0) $ listToMaybe rms++ return . (,r) . fsep $+ pwords "Duplicate definition of module" ++ [prettyTCM x <> "."] +++ pwords "Previous definition of" ++ [help m] ++ pwords "module" ++ [prettyTCM x] +++ pwords "at" ++ [prettyTCM r]+ where+ help :: MonadPretty m => ModuleName -> m Doc+ help m = caseMaybeM (isDatatypeModule m) empty $ \case+ IsDataModule -> "(datatype)"+ IsRecordModule -> "(record)"++instance PrettyTCM TopLevelModuleNameWithSourceFile where+ prettyTCM (TopLevelModuleNameWithSourceFile x file) = do+ path <- srcFilePath file+ let x' = setRange (rangeFromAbsolutePath path) x+ pretty (PrintRange x')++instance PrettyTCM ExecError where+ prettyTCM = \case++ ExeNotTrusted exe exes -> vcat $+ (fsep $ concat+ [ pwords "Could not find"+ , q exe+ , pwords "in list of trusted executables:"+ ]) :+ [ text $ " - " ++ Text.unpack exe | exe <- Map.keys exes ]++ ExeNotFound exe fp -> fsep $ concat+ [ pwords "Could not find file"+ , q fp+ , pwords "for trusted executable"+ , q fp+ ]++ ExeNotExecutable exe fp -> fsep $ concat+ [ [ "File" ]+ , q fp+ , pwords "for trusted executable"+ , q exe+ , pwords "does not have permission to execute"+ ]++ where+ q :: (MonadPretty m, P.Pretty a) => a -> [m Doc]+ q = singleton . quotes . pretty++++instance PrettyTCM GHCBackendError where+ prettyTCM = \case++ ConstructorCountMismatch d cs hsCons -> fsep $ concat+ [ [ prettyTCM d, "has", text (show n), "constructors,", "but" ]+ , [ "only" | hn > 0, hn < n ]+ , pwords n_forms_are+ , pwords $ "given [" ++ unwords hsCons ++ "]"+ ]+ where+ n = length cs+ hn = length hsCons+ n_forms_are = case hn of+ 1 -> "1 Haskell constructor is"+ _ -> show hn ++ " Haskell constructors are"++ NotAHaskellType top offender -> vcat+ [ fsep $ concat+ [ pwords "The type", [ prettyTCM top ]+ , pwords "cannot be translated to a corresponding Haskell type, because it contains"+ , reason offender+ ]+ , possibleFix offender+ ]+ where+ reason (BadLambda v) = pwords "the lambda term" ++ [prettyTCM v <> "."]+ reason (BadMeta v) = pwords "a meta variable" ++ [prettyTCM v <> "."]+ reason (BadDontCare v) = pwords "an erased term" ++ [prettyTCM v <> "."]+ reason (NotCompiled x) = pwords "a name that is not compiled"+ ++ [parens (prettyTCM x) <> "."]+ reason (NoPragmaFor x) = prettyTCM x : pwords "which does not have a COMPILE pragma."+ reason (WrongPragmaFor _ x) = prettyTCM x : pwords "which has the wrong kind of COMPILE pragma."++ possibleFix BadLambda{} = empty+ possibleFix BadMeta{} = empty+ possibleFix BadDontCare{} = empty+ possibleFix NotCompiled{} = empty+ possibleFix (NoPragmaFor d) = suggestPragma d $ "add a pragma"+ possibleFix (WrongPragmaFor r d) = suggestPragma d $+ sep [ "replace the value-level pragma at", nest 2 $ pretty r, "by" ]++ suggestPragma d action = do+ def <- theDef <$> getConstInfo d+ let dataPragma n = ("data type HsD", "data HsD (" ++ intercalate " | " [ "C" ++ show i | i <- [1..n] ] ++ ")")+ (hsThing, pragma) =+ case def of+ Datatype{ dataCons = cs } -> dataPragma (length cs)+ Record{} -> dataPragma 1+ _ -> ("type HsT", "type HsT")+ vcat [ sep ["Possible fix:", action]+ , nest 2 $ hsep [ "{-# COMPILE GHC", prettyTCM d, "=", text pragma, "#-}" ]+ , text ("for a suitable Haskell " ++ hsThing ++ ".")+ ]++ WrongTypeOfMain io ty -> fsep $ concat+ [ pwords "The type of main should be", [ prettyTCM io ], pwords "A, for some A."+ , pwords "The given type is:", [ prettyTCM ty ]+ ]++instance PrettyTCM JSBackendError where+ prettyTCM = \case+ BadCompilePragma -> sep+ [ "Badly formed COMPILE JS pragma. Expected"+ , "{-# COMPILE JS <name> = <js> #-}"+ ]++instance PrettyTCM InteractionError where+ prettyTCM = \case+ CannotGive e -> fsep $ pwords "Failed to give" ++ [ prettyTCM e ]++ CannotRefine s -> fsep $ pwords "Cannot refine" ++ pwords s++ CaseSplitError doc -> return doc++ ExpectedIdentifier e -> fsep $ concat+ [ pwords "Expected identifier, but found:"+ , pure $ pretty e+ ]++ ExpectedApplication -> fwords "Expected an argument of the form f e1 e2 .. en"++ NoActionForInteractionPoint ii -> vcat+ [ fwords $ "No type nor action available for hole " ++ prettyShow ii ++ "."+ , fwords $ "Possible cause: the hole has not been reached during type checking (do you see yellow?)"+ ]++ NoSuchInteractionPoint ii ->+ fsep [ "Unknown", "interaction", "point", prettyTCM ii ]++ UnexpectedWhere -> fwords "`where' clauses are not supported in holes"++instance PrettyTCM UnquoteError where+ prettyTCM = \case++ BlockedOnMeta _ m -> fsep $+ pwords $ "Unquote failed because of unsolved meta variables."++ CannotDeclareHiddenFunction f -> fsep $+ pwords "Cannot declare hidden function" ++ [ prettyTCM f ]++ CommitAfterDef -> fwords "Cannot use commitTC after declaring new definitions"++ ConInsteadOfDef x def con -> fsep $+ pwords ("Use " ++ con ++ " instead of " ++ def ++ " for constructor") +++ [prettyTCM x]++ DefineDataNotData x -> fsep $+ [prettyTCM x] +++ pwords "is not declared as a datatype or record, or it already has a definition."++ DefInsteadOfCon x def con -> fsep $+ pwords ("Use " ++ def ++ " instead of " ++ con ++ " for non-constructor")+ ++ [prettyTCM x]++ EscapingVariable v -> enterClosure v \ v ->+ hcat ["Local variable '", prettyTCM (var 0), "' escaping in result of extendContext:"]+ <?> prettyTCM v++ MissingDeclaration x -> fsep $+ pwords "Missing declaration for" ++ [ prettyTCM x ]++ MissingDefinition xs -> fsep $+ pwords "Missing definition for" ++ punctuate comma (fmap prettyTCM xs)++ NakedUnquote -> fwords "`unquote' must be applied to a term"++ NonCanonical kind t ->+ fwords ("Cannot unquote non-canonical " ++ kind)+ $$ nest 2 (prettyTCM t)++ PatLamWithoutClauses _ -> fsep $+ pwords "Cannot unquote pattern lambda without clauses. Use a single `absurd-clause` for absurd lambdas."++ StaleMeta m x ->+ sep+ [ "Cannot unquote stale metavariable"+ , pretty m <> "._" <> pretty (metaId x)+ ]++ TooManyParameters npars e -> sep+ [ fsep $ concat [ pwords "Cannot shave", [pretty npars], pwords "parameters off type" ]+ , prettyTCM e+ ]++ UnboundName x -> fsep $ pwords "Unbound name:" ++ [prettyTCM x]++instance PrettyTCM MissingTypeSignatureInfo where+ prettyTCM = \case+ MissingDataSignature x -> fsep [ "data" , "definition", prettyTCM x ]+ MissingRecordSignature x -> fsep [ "record", "definition", prettyTCM x ]+ MissingFunctionSignature lhs -> fsep [ "left", "hand", "side", prettyTCM lhs ]+++notCmp :: MonadPretty m => Comparison -> m Doc+notCmp cmp = "!" <> prettyTCM cmp+++instance PrettyTCM SplitError where+ prettyTCM :: forall m. MonadPretty m => SplitError -> m Doc+ prettyTCM err = case err of+ NotADatatype t -> enterClosure t $ \ t -> fsep $+ pwords "Cannot split on argument of non-datatype" ++ [prettyTCM t]++ BlockedType b t -> enterClosure t $ \ t -> fsep $+ pwords "Cannot split on argument of unresolved type" ++ [prettyTCM t]++ ErasedDatatype reason t -> enterClosure t $ \ t -> fsep $+ pwords "Cannot branch on erased argument of datatype" +++ [prettyTCM t] +++ case reason of+ ErasedMatchesDisabledEmpty ->+ explanation "empty"+ ErasedMatchesDisabledNonDependent ->+ explanation "non-dependent"+ ErasedMatchesDisabledDependent ->+ explanation "unrestricted"+ SeveralConstructors ->+ []+ where+ explanation arg =+ pwords "because the option" +++ pwords ("--erased-matches=" ++ arg) +++ pwords "is not active"++ CoinductiveDatatype t -> enterClosure t $ \ t -> fsep $+ pwords "Cannot pattern match on the coinductive type" ++ [prettyTCM t]++{- UNUSED+ NoRecordConstructor t -> fsep $+ pwords "Cannot pattern match on record" ++ [prettyTCM t] +++ pwords "because it has no constructor"+ -}++ UnificationStuck b c tel cIxs gIxs errs+ | length cIxs /= length gIxs -> __IMPOSSIBLE__+ | otherwise -> vcat . concat $+ [ [ fsep . concat $+ [ pwords "I'm not sure if there should be a case for the constructor"+ , [prettyTCM c <> ","]+ , pwords "because I get stuck when trying to solve the following"+ , pwords "unification problems (inferred index ≟ expected index):"+ ]+ ]+ , zipWith prEq cIxs gIxs+ , if null errs then [] else+ (fsep $ [ "Possible", pluralS errs "reason" ] ++ pwords "why unification failed:")+ : map (nest 2 . prettyTCM) errs+ ]+ where+ -- Andreas, 2019-08-08, issue #3943+ -- To not print hidden indices just as {_}, we strip the Arg and print+ -- the hiding information manually.+ prEq :: Arg Term -> Arg Term -> m Doc+ prEq cIx gIx = addContext tel $ nest 2 $ hsep [ pr cIx , "≟" , pr gIx ]+ pr arg = prettyRelevance arg . prettyHiding arg id <$> prettyTCM (unArg arg)++ CosplitNoTarget -> fsep $+ pwords "Cannot split into projections because target type is unknown"++ CosplitNoRecordType t -> enterClosure t $ \t -> fsep $+ pwords "Cannot split into projections because the target type "+ ++ [prettyTCM t] ++ pwords " is not a record type"++ CannotCreateMissingClause f cl msg t -> fsep (+ pwords "Cannot generate inferred clause for" ++ [prettyTCM f <> "."] +++ pwords "Case to handle:") $$ nest 2 (vcat $ [display cl])+ $$ ((pure msg <+> enterClosure t displayAbs) <> ".")+ where+ displayAbs :: Abs I.Type -> m Doc+ displayAbs (Abs x t) = addContext x $ prettyTCM t+ displayAbs (NoAbs x t) = prettyTCM t+ display (tel, ps) = prettyTCM $ NamedClause f True $+ empty { clauseTel = tel, namedClausePats = ps }+++ GenericSplitError s -> fsep $ pwords "Split failed:" ++ pwords s++instance PrettyTCM NegativeUnification where+ prettyTCM err = case err of+ UnifyConflict tel u v -> addContext tel $ vcat $+ [ fsep $ pwords "because unification ended with a conflicting equation "+ , nest 2 $ prettyTCM u <+> "≟" <+> prettyTCM v+ ]++ UnifyCycle tel i u -> addContext tel $ vcat $+ [ fsep $ pwords "because unification ended with a cyclic equation "+ , nest 2 $ prettyTCM (var i) <+> "≟" <+> prettyTCM u+ ]++instance PrettyTCM UnificationFailure where+ prettyTCM err = case err of+ UnifyIndicesNotVars tel a u v ixs -> addContext tel $ fsep $+ pwords "Cannot apply injectivity to the equation" ++ [prettyTCM u] +++ pwords "=" ++ [prettyTCM v] ++ pwords "of type" ++ [prettyTCM a] +++ pwords "because I cannot generalize over the indices" +++ [prettyList (map prettyTCM ixs) <> "."]++ UnifyRecursiveEq tel a i u -> addContext tel $ fsep $+ pwords "Cannot solve variable " ++ [prettyTCM (var i)] +++ pwords " of type " ++ [prettyTCM a] +++ pwords " with solution " ++ [prettyTCM u] +++ pwords " because the variable occurs in the solution," +++ pwords " or in the type of one of the variables in the solution."++ UnifyReflexiveEq tel a u -> addContext tel $ fsep $+ pwords "Cannot eliminate reflexive equation" ++ [prettyTCM u] +++ pwords "=" ++ [prettyTCM u] ++ pwords "of type" ++ [prettyTCM a] +++ pwords "because K has been disabled."++ UnifyUnusableModality tel a i u mod -> addContext tel $ fsep $+ pwords "Cannot solve variable " ++ [prettyTCM (var i)] +++ pwords "of type " ++ [prettyTCM a] +++ pwords "with solution " ++ [prettyTCM u] +++ pwords "because the solution cannot be used at" +++ [ text (verbalize $ getRelevance mod) <> ","+ , text $ verbalize $ getQuantity mod ] +++ pwords "modality"++ UnifyVarInRewrite tel a i u -> addContext tel $ fsep $+ pwords "Cannot solve variable " ++ [prettyTCM (var i)] +++ pwords "of type " ++ [prettyTCM a] +++ pwords "with solution " ++ [prettyTCM u] +++ pwords "because the variable occurs in a local rewrite rule."++ UnifyVarInRewriteEta tel i -> addContext tel $ fsep $+ pwords "Cannot eta-expand variable " ++ [prettyTCM (var i)] +++ pwords "because the variable occurs in a local rewrite rule."+++explainWhyInScope :: forall m. MonadPretty m => WhyInScopeData -> m Doc+explainWhyInScope (WhyInScopeData y _ Nothing [] []) = text (prettyShow y ++ " is not in scope.")+explainWhyInScope (WhyInScopeData y _ v xs ms) = vcat+ [ text (prettyShow y ++ " is in scope as")+ , nest 2 $ vcat [variable v xs, modules ms]+ ]+ where+ -- variable :: Maybe _ -> [_] -> m Doc+ variable Nothing vs = names vs+ variable (Just x) vs+ | null vs = asVar+ | otherwise = vcat+ [ sep [ asVar, nest 2 $ shadowing x]+ , nest 2 $ names vs+ ]+ where+ asVar :: m Doc+ asVar = do+ "* a variable bound at" <+> prettyTCM (nameBindingSite $ localVar x)+ shadowing :: LocalVar -> m Doc+ shadowing (LocalVar _ _ []) = "shadowing"+ shadowing _ = "in conflict with"+ names = vcat . map pName+ modules = vcat . map pMod++ pKind = \case+ ConName -> "constructor"+ CoConName -> "coinductive constructor"+ FldName -> "record field"+ PatternSynName -> "pattern synonym"+ GeneralizeName -> "generalizable variable"+ DisallowedGeneralizeName -> "generalizable variable from let open"+ MacroName -> "macro name"+ QuotableName -> "quotable name"+ -- previously DefName:+ DataName -> "data type"+ RecName -> "record type"+ AxiomName -> "postulate"+ PrimName -> "primitive function"+ FunName -> "defined name"+ OtherDefName -> "defined name"++ pName :: AbstractName -> m Doc+ pName a = sep+ [ "* a"+ <+> pKind (anameKind a)+ <+> text (prettyShow $ anameName a)+ , nest 2 $ "brought into scope by"+ ] $$+ nest 2 (pWhy (nameBindingSite a) (anameLineage a))+ pMod :: AbstractModule -> m Doc+ pMod a = sep+ [ "* a module" <+> text (prettyShow $ amodName a)+ , nest 2 $ "brought into scope by"+ ] $$+ nest 2 (pWhy (nameBindingSite a) (amodLineage a))++ pWhy :: Range -> WhyInScope -> m Doc+ pWhy r Defined = "- its definition at" <+> prettyTCM r+ pWhy r (Opened (C.QName x) w) | isNoName x = pWhy r w+ pWhy r (Opened m w) =+ "- the opening of"+ <+> prettyTCM m+ <+> "at"+ <+> prettyTCM (getRange m)+ $$+ pWhy r w+ pWhy r (Applied m w) =+ "- the application of"+ <+> prettyTCM m+ <+> "at"+ <+> prettyTCM (getRange m)+ $$+ pWhy r w++++---------------------------------------------------------------------------+-- * Natural language+---------------------------------------------------------------------------++class Verbalize a where+ verbalize :: a -> String++instance Verbalize Hiding where+ verbalize = hidingToString++instance Verbalize Relevance where+ verbalize = \case+ Relevant {} -> "relevant"+ Irrelevant {} -> "irrelevant"+ ShapeIrrelevant {} -> "shape-irrelevant"++instance Verbalize Quantity where+ verbalize = \case+ Quantity0{} -> "erased"+ Quantity1{} -> "linear"+ Quantityω{} -> "unrestricted"++instance Verbalize Cohesion where+ verbalize = \case+ Flat -> "flat"+ Continuous -> "continuous"+ Sharp -> "sharp"+ Squash -> "squashed"++instance Verbalize ModalPolarity where+ verbalize = \case+ UnusedPolarity -> "unused"+ StrictlyPositive -> "strictly positive"+ Positive -> "positive"+ Negative -> "negative"+ MixedPolarity -> "mixed"++instance Verbalize PolarityModality where+ verbalize (PolarityModality p o l) = verbalize p++instance Verbalize Modality where+ verbalize mod | mod == defaultModality || mod == defaultCheckModality = "default"+ verbalize mod | mod == defaultModality = "default"+ verbalize (Modality rel qnt coh pol) = intercalate ", " $+ [ verbalize rel | rel /= defaultRelevance ] +++ [ verbalize qnt | qnt /= defaultQuantity ] +++ [ verbalize coh | coh /= defaultCohesion ] +++ [ verbalize pol | pol /= defaultPolarity , pol /= modPolarity defaultCheckModality ]++-- | Indefinite article.+newtype Indefinite a = Indefinite a++instance Verbalize a => Verbalize (Indefinite a) where+ verbalize (Indefinite a) =+ case verbalize a of+ "" -> ""+ w@(c:cs) | c `elem` ['a','e','i','o'] -> "an " ++ w+ | otherwise -> "a " ++ w+ -- Aarne Ranta would whip me if he saw this.++-- | Number rendered as an ordinal (@1st@, @2nd@, etc)+newtype Ordinal = Ordinal Int+instance Verbalize Ordinal where+ verbalize (Ordinal n) = case n `mod` 10 of+ 1 -> show n <> "st"+ 2 -> show n <> "nd"+ 3 -> show n <> "rd"+ _ -> show n <> "th"
@@ -0,0 +1,34 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.Errors where++import Agda.Syntax.Common (Cohesion, PolarityModality, Relevance, Hiding, Quantity)+import Agda.Syntax.Abstract.Name++import Agda.TypeChecking.Monad.Base+import {-# SOURCE #-} Agda.TypeChecking.Monad.Debug (MonadDebug)+import {-# SOURCE #-} Agda.TypeChecking.Pretty (PrettyTCM)++instance PrettyTCM TypeError+instance PrettyTCM TCErr++-- Misplaced SPECIALISE pragma:+-- {-# SPECIALIZE renderError :: TCErr -> TCM String #-}+renderError :: MonadTCM tcm => TCErr -> tcm String++topLevelModuleDropper :: (MonadDebug m, MonadTCEnv m, ReadTCState m) => m (QName -> QName)++class Verbalize a where+ verbalize :: a -> String++instance Verbalize Relevance+instance Verbalize Cohesion+instance Verbalize Hiding+instance Verbalize Quantity+instance Verbalize PolarityModality++newtype Indefinite a = Indefinite a+instance Verbalize a => Verbalize (Indefinite a)++newtype Ordinal = Ordinal Int+instance Verbalize Ordinal
@@ -0,0 +1,387 @@+-- | Convert errors to their names.++module Agda.TypeChecking.Errors.Names where++import Agda.Syntax.Concrete.Definitions.Errors as N (DeclarationException'(..))+import Agda.TypeChecking.Monad.Base as MB+import Agda.TypeChecking.Conversion.Errors+import Agda.Interaction.Options.Errors++-- | Print the name of a 'TypeError'.+--+typeErrorString :: TypeError -> String+typeErrorString = errorNameString . typeErrorName++-- | Compute the name of a 'TypeError'.+--+typeErrorName :: TypeError -> ErrorName+typeErrorName = \case+ -- Error groups (alphabetically) with named sub errors+ ExecError err -> ExecError_ $ execErrorName err+ GHCBackendError err -> GHCBackendError_ $ ghcBackendErrorName err+ JSBackendError err -> JSBackendError_ $ jsBackendErrorName err+ ImpossibleConstructor _ err -> ImpossibleConstructor_ $ impossibleConstructorErrorName err+ InteractionError err -> InteractionError_ $ interactionErrorName err+ NicifierError err -> NicifierError_ $ declarationExceptionName err+ SplitError err -> SplitError_ $ splitErrorName err+ UnquoteFailed err -> UnquoteError_ $ unquoteErrorName err+ -- Parametrized errors+ CannotQuote what -> CannotQuote_ $ unquotableName what+ MissingTypeSignature what -> MissingTypeSignature_ $ missingTypeSignatureInfoName what+ InvalidPun kind _ -> InvalidPun_ kind+ CannotQuoteTerm what -> CannotQuoteTerm_ what+ NotAllowedInDotPatterns what -> NotAllowedInDotPatterns_ what+ NotAValidLetBinding what -> NotAValidLetBinding_ what+ NotAValidLetExpression what -> NotAValidLetExpression_ what+ PatternSynonymArgumentShadows what _ _ -> PatternSynonymArgumentShadows_ what+ -- Wrappers+ OperatorInformation _ _ err -> typeErrorName err+ ConversionError_ ConversionError{convErrTys = cmp} -> case cmp of+ FailAsTypes{} -> UnequalTypes_+ FailAsTermsOf{} -> UnequalTerms_+ -- Generic errors (alphabetically)+ CompilationError {} -> CompilationError_+ CustomBackendError {} -> CustomBackendError_+ UserError {} -> UserError_+ InternalError {} -> InternalError_+ LibraryError {} -> LibraryError_+ NonFatalErrors {} -> NonFatalErrors_+ NotImplemented {} -> NotImplemented_+ NotSupported {} -> NotSupported_+ OptionError {} -> OptionError_+ SyntaxError {} -> SyntaxError_+ -- Other errors (alphabetically)+ AbsentRHSRequiresAbsurdPattern {} -> AbsentRHSRequiresAbsurdPattern_+ AbstractConstructorNotInScope {} -> AbstractConstructorNotInScope_+ MB.AmbiguousConstructor {} -> AmbiguousConstructor_+ AmbiguousField {} -> AmbiguousField_+ AmbiguousModule {} -> AmbiguousModule_+ AmbiguousName {} -> AmbiguousName_+ AmbiguousOverloadedProjection {} -> AmbiguousOverloadedProjection_+ AmbiguousParseForApplication {} -> AmbiguousParseForApplication_+ AmbiguousParseForLHS {} -> AmbiguousParseForLHS_+ AmbiguousProjection {} -> AmbiguousProjection_+ AmbiguousTopLevelModuleName {} -> AmbiguousTopLevelModuleName_+ AsPatternInPatternSynonym {} -> AsPatternInPatternSynonym_+ AttributeKindNotEnabled {} -> AttributeKindNotEnabled_+ BackendDoesNotSupportOnlyScopeChecking {} -> BackendDoesNotSupportOnlyScopeChecking_+ BadArgumentsToPatternSynonym {} -> BadArgumentsToPatternSynonym_+ BothWithAndRHS {} -> BothWithAndRHS_+ BuiltinInParameterisedModule {} -> BuiltinInParameterisedModule_+ BuiltinMustBeConstructor {} -> BuiltinMustBeConstructor_+ BuiltinMustBeData {} -> BuiltinMustBeData_+ BuiltinMustBeDef {} -> BuiltinMustBeDef_+ BuiltinMustBeFunction {} -> BuiltinMustBeFunction_+ BuiltinMustBePostulate {} -> BuiltinMustBePostulate_+ CannotApply {} -> CannotApply_+ CannotEliminateWithPattern {} -> CannotEliminateWithPattern_+ CannotEliminateWithProjection {} -> CannotEliminateWithProjection_+ CannotGeneralizeEtaExpandable {} -> CannotGeneralizeEtaExpandable_+ CannotGenerateHCompClause {} -> CannotGenerateHCompClause_+ CannotGenerateTransportClause {} -> CannotGenerateTransportClause_+ CannotGenerateTransportLocalRewrite {} -> CannotGenerateTransportLocalRewrite_+ CannotResolveAmbiguousPatternSynonym {} -> CannotResolveAmbiguousPatternSynonym_+ CannotRewriteByNonEquation {} -> CannotRewriteByNonEquation_+ CannotSolveSizeConstraints {} -> CannotSolveSizeConstraints_+ CantResolveOverloadedConstructorsTargetingSameDatatype {} -> CantResolveOverloadedConstructorsTargetingSameDatatype_+ ClashingDefinition {} -> ClashingDefinition_+ ClashingModule {} -> ClashingModule_+ ComatchingDisabledForRecord {} -> ComatchingDisabledForRecord_+ ConstructorDoesNotTargetGivenType {} -> ConstructorDoesNotTargetGivenType_+ ConstructorNameOfNonRecord {} -> ConstructorNameOfNonRecord_+ ConstructorPatternInWrongDatatype {} -> ConstructorPatternInWrongDatatype_+ ContradictorySizeConstraint {} -> ContradictorySizeConstraint_+ CopatternHeadNotProjection {} -> CopatternHeadNotProjection_+ CubicalCompilationNotSupported {} -> CubicalCompilationNotSupported_+ CubicalNotErasure {} -> CubicalNotErasure_+ CubicalPrimitiveNotFullyApplied {} -> CubicalPrimitiveNotFullyApplied_+ CyclicModuleDependency {} -> CyclicModuleDependency_+ DatatypeIndexPolarity {} -> DatatypeIndexPolarity_+ DeBruijnIndexOutOfScope {} -> DeBruijnIndexOutOfScope_+ DeclarationsAfterTopLevelModule {} -> DeclarationsAfterTopLevelModule_+ DefinitionInDifferentModule {} -> DefinitionInDifferentModule_+ DefinitionIsErased {} -> DefinitionIsErased_+ DefinitionIsIrrelevant {} -> DefinitionIsIrrelevant_+ DoNotationError {} -> DoNotationError_+ DoesNotMentionTicks {} -> DoesNotMentionTicks_+ DotPatternInPatternSynonym {} -> DotPatternInPatternSynonym_+ DuplicateBuiltinBinding {} -> DuplicateBuiltinBinding_+ DuplicateConstructors {} -> DuplicateConstructors_+ DuplicateFields {} -> DuplicateFields_+ DuplicateImports {} -> DuplicateImports_+ DuplicateOverlapPragma {} -> DuplicateOverlapPragma_+ DuplicatePrimitiveBinding {} -> DuplicatePrimitiveBinding_+ EmptyTypeOfSizes {} -> EmptyTypeOfSizes_+ EtaPragmaVsNoEtaEquality {} -> EtaPragmaVsNoEtaEquality_+ ExpectedBindingForParameter {} -> ExpectedBindingForParameter_+ ExpectedIntervalLiteral {} -> ExpectedIntervalLiteral_+ FieldOutsideRecord {} -> FieldOutsideRecord_+ FaceConstraintDisjunction {} -> FaceConstraintDisjunction_+ FaceConstraintUnsatisfiable {} -> FaceConstraintUnsatisfiable_+ FileNotFound {} -> FileNotFound_+ ForcedConstructorNotInstantiated {} -> ForcedConstructorNotInstantiated_+ FunctionTypeInSizeUniv {} -> FunctionTypeInSizeUniv_+ GeneralizationFailed {} -> GeneralizationFailed_+ GeneralizationPrepruneErrorRefinedContext {} -> GeneralizationPrepruneErrorRefinedContext_+ GeneralizationPrepruneErrorCyclicDependencies {} -> GeneralizationPrepruneErrorCyclicDependencies_+ GeneralizationPrepruneErrorFailedToInstantiate {} -> GeneralizationPrepruneErrorFailedToInstantiate_+ GeneralizeCyclicDependency {} -> GeneralizeCyclicDependency_+ GeneralizeNotSupportedHere {} -> GeneralizeNotSupportedHere_+ GeneralizedVarInLetOpenedModule {} -> GeneralizedVarInLetOpenedModule_+ HidingMismatch {} -> HidingMismatch_+ IdiomBracketError {} -> IdiomBracketError_+ InvalidBuiltin {} -> InvalidBuiltin_+ InvalidDottedExpression {} -> InvalidDottedExpression_+ IllTypedPatternAfterWithAbstraction {} -> IllTypedPatternAfterWithAbstraction_+ IlltypedRewriteRule {} -> IlltypedRewriteRule_+ IllegalDeclarationBeforeTopLevelModule {} -> IllegalDeclarationBeforeTopLevelModule_+ IllegalHidingInPostfixProjection {} -> IllegalHidingInPostfixProjection_+ IllegalInstanceVariableInPatternSynonym {} -> IllegalInstanceVariableInPatternSynonym_+ IllegalLetInTelescope {} -> IllegalLetInTelescope_+ IllegalPatternInTelescope {} -> IllegalPatternInTelescope_+ IllformedProjectionPatternAbstract {} -> IllformedProjectionPatternAbstract_+ IllformedProjectionPatternConcrete {} -> IllformedProjectionPatternConcrete_+ IncorrectTypeForRewriteRelation {} -> IncorrectTypeForRewriteRelation_+ InstanceNoCandidate {} -> InstanceNoCandidate_+ InstanceSearchDepthExhausted {} -> InstanceSearchDepthExhausted_+ InvalidFileName {} -> InvalidFileName_+ InvalidModalTelescopeUse {} -> InvalidModalTelescopeUse_+ InvalidPattern {} -> InvalidPattern_+ InvalidProjectionParameter {} -> InvalidProjectionParameter_+ InvalidTypeSort {} -> InvalidTypeSort_+ LambdaIsErased {} -> LambdaIsErased_+ LibTooFarDown {} -> LibTooFarDown_+ LiteralTooBig {} -> LiteralTooBig_+ MacroResultTypeMismatch {} -> MacroResultTypeMismatch_+ MetaCannotDependOn {} -> MetaCannotDependOn_+ MetaErasedSolution {} -> MetaErasedSolution_+ MetaIrrelevantSolution {} -> MetaIrrelevantSolution_+ MismatchedProjectionsError {} -> MismatchedProjectionsError_+ MissingBindingsForTelescopeVariables {} -> MissingBindingsForTelescopeVariables_+ ModuleArityMismatch {} -> ModuleArityMismatch_+ ModuleDefinedInOtherFile {} -> ModuleDefinedInOtherFile_+ ModuleNameDoesntMatchFileName {} -> ModuleNameDoesntMatchFileName_+ ModuleNameHashCollision {} -> ModuleNameHashCollision_+ ModuleNameUnexpected {} -> ModuleNameUnexpected_+ MultipleFixityDecls {} -> MultipleFixityDecls_+ MultiplePolarityPragmas {} -> MultiplePolarityPragmas_+ ExplicitPolarityVsPragma {} -> ExplicitPolarityVsPragma_+ NamedWhereModuleInRefinedContext {} -> NamedWhereModuleInRefinedContext_+ NamedWhereModuleUnderWith {} -> NamedWhereModuleUnderWith_+ NeedOptionAllowExec {} -> NeedOptionAllowExec_+ NeedOptionCopatterns {} -> NeedOptionCopatterns_+ NeedOptionCubical {} -> NeedOptionCubical_+ NeedOptionPatternMatching {} -> NeedOptionPatternMatching_+ NeedOptionIrrelevance {} -> NeedOptionIrrelevance_+ NeedOptionProp {} -> NeedOptionProp_+ NeedOptionRewriting {} -> NeedOptionRewriting_+ NeedOptionSizedTypes {} -> NeedOptionSizedTypes_+ NeedOptionTwoLevel {} -> NeedOptionTwoLevel_+ NeedOptionUniversePolymorphism {} -> NeedOptionUniversePolymorphism_+ NegativeLiteralInPattern {} -> NegativeLiteralInPattern_+ NoBindingForBuiltin {} -> NoBindingForBuiltin_+ NoBindingForPrimitive {} -> NoBindingForPrimitive_+ NoKnownRecordWithSuchFields {} -> NoKnownRecordWithSuchFields_+ NoParameterOfName {} -> NoParameterOfName_+ NoParseForApplication {} -> NoParseForApplication_+ NoParseForLHS {} -> NoParseForLHS_+ NoSuchBuiltinName {} -> NoSuchBuiltinName_+ NoSuchModule {} -> NoSuchModule_+ NoSuchPrimitiveFunction {} -> NoSuchPrimitiveFunction_+ NotAnExpression {} -> NotAnExpression_+ NotInScope {} -> NotInScope_+ NotLeqSort {} -> NotLeqSort_+ NotValidBeforeField {} -> NotValidBeforeField_+ OverlappingProjects {} -> OverlappingProjects_+ PathAbstractionFailed {} -> PathAbstractionFailed_+ PatternInPathLambda {} -> PatternInPathLambda_+ PatternInSystem {} -> PatternInSystem_+ PostulatedSizeInModule {} -> PostulatedSizeInModule_+ PrivateRecordField {} -> PrivateRecordField_+ ProjectionIsIrrelevant {} -> ProjectionIsIrrelevant_+ QualifiedLocalModule {} -> QualifiedLocalModule_+ QuantityMismatch {} -> QuantityMismatch_+ RecordIsErased {} -> RecordIsErased_+ ReferencesFutureVariables {} -> ReferencesFutureVariables_+ RelevanceMismatch {} -> RelevanceMismatch_+ RepeatedNamesInImportDirective {} -> RepeatedNamesInImportDirective_+ RepeatedVariablesInPattern {} -> RepeatedVariablesInPattern_+ ShadowedModule {} -> ShadowedModule_+ ShouldBeASort {} -> ShouldBeASort_+ ShouldBeEmpty {} -> ShouldBeEmpty_+ ShouldBePath {} -> ShouldBePath_+ ShouldBePi {} -> ShouldBePi_+ ShouldBeRecordPattern {} -> ShouldBeRecordPattern_+ ShouldBeRecordType {} -> ShouldBeRecordType_+ ShouldEndInApplicationOfTheDatatype {} -> ShouldEndInApplicationOfTheDatatype_+ SolvedButOpenHoles {} -> SolvedButOpenHoles_+ SortCannotDependOnItsIndex {} -> SortCannotDependOnItsIndex_+ SortDoesNotAdmitDataDefinitions {} -> SortDoesNotAdmitDataDefinitions_+ SortOfSplitVarError {} -> SortOfSplitVarError_+ SplitInProp {} -> SplitInProp_+ SplitOnAbstract {} -> SplitOnAbstract_+ SplitOnCoinductive {} -> SplitOnCoinductive_+ SplitOnIrrelevant {} -> SplitOnIrrelevant_+ SplitOnNonEtaRecord {} -> SplitOnNonEtaRecord_+ SplitOnNonVariable {} -> SplitOnNonVariable_+ SplitOnPartial {} -> SplitOnPartial_+ SplitOnUnchecked {} -> SplitOnUnchecked_+ SplitOnUnusableCohesion {} -> SplitOnUnusableCohesion_+ SplitOnUnusablePolarity {} -> SplitOnUnusablePolarity_+ TacticAttributeNotAllowed {} -> TacticAttributeNotAllowed_+ TooFewArgumentsToPatternSynonym {} -> TooFewArgumentsToPatternSynonym_+ TooFewPatternsInWithClause {} -> TooFewPatternsInWithClause_+ TooManyFields {} -> TooManyFields_+ TooManyPatternsInWithClause {} -> TooManyPatternsInWithClause_+ TriedToCopyConstrainedPrim {} -> TriedToCopyConstrainedPrim_+ TrustedBuiltin {} -> TrustedBuiltin_+ TrustedPrimitive {} -> TrustedPrimitive_+ InvalidInstanceHeadType {} -> InvalidInstanceHeadType_+ UnboundVariablesInPatternSynonym {} -> UnboundVariablesInPatternSynonym_+ UnexpectedModalityAnnotationInParameter {} -> UnexpectedModalityAnnotationInParameter_+ UnexpectedParameter {} -> UnexpectedParameter_+ UnexpectedTypeSignatureForParameter {} -> UnexpectedTypeSignatureForParameter_+ UnexpectedWithPatterns {} -> UnexpectedWithPatterns_+ UnguardedEtaRecord {} -> UnguardedEtaRecord_+ UnknownBackend {} -> UnknownBackend_+ UnusableAtModality {} -> UnusableAtModality_+ UnusedVariableInPatternSynonym {} -> UnusedVariableInPatternSynonym_+ VariableIsErased {} -> VariableIsErased_+ VariableIsIrrelevant {} -> VariableIsIrrelevant_+ VariableIsOfUnusableCohesion {} -> VariableIsOfUnusableCohesion_+ VariableIsOfUnusablePolarity {} -> VariableIsOfUnusablePolarity_+ WithClausePatternMismatch {} -> WithClausePatternMismatch_+ WithOnFreeVariable {} -> WithOnFreeVariable_+ WrongAnnotationInLambda {} -> WrongAnnotationInLambda_+ WrongArgInfoForPrimitive {} -> WrongArgInfoForPrimitive_+ WrongCohesionInLambda {} -> WrongCohesionInLambda_+ WrongPolarityInLambda {} -> WrongPolarityInLambda_+ WrongHidingInApplication {} -> WrongHidingInApplication_+ WrongHidingInLHS {} -> WrongHidingInLHS_+ WrongHidingInLambda {} -> WrongHidingInLambda_+ WrongHidingInProjection {} -> WrongHidingInProjection_+ WrongIrrelevanceInLambda {} -> WrongIrrelevanceInLambda_+ WrongNamedArgument {} -> WrongNamedArgument_+ WrongNamedArgumentInLHS {} -> WrongNamedArgumentInLHS_+ WrongNumberOfConstructorArguments {} -> WrongNumberOfConstructorArguments_+ WrongQuantityInLambda {} -> WrongQuantityInLambda_+ WrongSharpArity {} -> WrongSharpArity_++declarationExceptionName :: DeclarationException' -> DeclarationException_+declarationExceptionName = \case+ N.AmbiguousConstructor {} -> AmbiguousConstructorN_+ AmbiguousFunClauses {} -> AmbiguousFunClauses_+ BadMacroDef {} -> BadMacroDef_+ DisallowedInterleavedMutual {} -> DisallowedInterleavedMutual_+ DuplicateAnonDeclaration {} -> DuplicateAnonDeclaration_+ DuplicateDefinition {} -> DuplicateDefinition_+ InvalidMeasureMutual {} -> InvalidMeasureMutual_+ MissingWithClauses {} -> MissingWithClauses_+ MultipleEllipses {} -> MultipleEllipses_+ OpaqueInMutual {} -> OpaqueInMutual_+ UnfoldingOutsideOpaque {} -> UnfoldingOutsideOpaque_+ UnquoteDefRequiresSignature {} -> UnquoteDefRequiresSignature_+ WrongContentBlock {} -> WrongContentBlock_+ WrongDefinition {} -> WrongDefinition_++execErrorName :: ExecError -> ExecError_+execErrorName = \case+ ExeNotTrusted {} -> ExeNotTrusted_+ ExeNotFound {} -> ExeNotFound_+ ExeNotExecutable {} -> ExeNotExecutable_++ghcBackendErrorName :: GHCBackendError -> GHCBackendError_+ghcBackendErrorName = \case+ ConstructorCountMismatch{} -> ConstructorCountMismatch_+ NotAHaskellType _ err -> NotAHaskellType_ $ notAHaskellTypeErrorName err+ WrongTypeOfMain{} -> WrongTypeOfMain_++jsBackendErrorName :: JSBackendError -> JSBackendError_+jsBackendErrorName = \case+ BadCompilePragma -> BadCompilePragma_++impossibleConstructorErrorName :: NegativeUnification -> NegativeUnification_+impossibleConstructorErrorName = \case+ UnifyConflict {} -> UnifyConflict_+ UnifyCycle {} -> UnifyCycle_++interactionErrorName :: InteractionError -> InteractionError_+interactionErrorName = \case+ CaseSplitError{} -> CaseSplitError_+ CannotRefine{} -> CannotRefine_+ CannotGive{} -> CannotGive_+ ExpectedIdentifier{} -> ExpectedIdentifier_+ ExpectedApplication{} -> ExpectedApplication_+ NoActionForInteractionPoint{} -> NoActionForInteractionPoint_+ NoSuchInteractionPoint{} -> NoSuchInteractionPoint_+ UnexpectedWhere{} -> UnexpectedWhere_++missingTypeSignatureInfoName :: MissingTypeSignatureInfo -> DataRecOrFun_+missingTypeSignatureInfoName = \case+ MissingDataSignature {} -> DataName_+ MissingRecordSignature {} -> RecName_+ MissingFunctionSignature {} -> FunName_++notAHaskellTypeErrorName :: WhyNotAHaskellType -> NotAHaskellType_+notAHaskellTypeErrorName = \case+ BadDontCare {} -> BadDontCare_+ BadLambda {} -> BadLambda_+ BadMeta {} -> BadMeta_+ NoPragmaFor {} -> NoPragmaFor_+ NotCompiled {} -> NotCompiled_+ WrongPragmaFor {} -> WrongPragmaFor_++splitErrorName :: SplitError -> SplitError_+splitErrorName = \case+ ErasedDatatype reason _ -> ErasedDatatype_ reason+ GenericSplitError {} -> GenericSplitError_+ -- Specific errors+ BlockedType {} -> BlockedType_+ CannotCreateMissingClause {} -> CannotCreateMissingClause_+ CoinductiveDatatype {} -> CoinductiveDatatype_+ CosplitNoRecordType {} -> CosplitNoRecordType_+ CosplitNoTarget {} -> CosplitNoTarget_+ NotADatatype {} -> NotADatatype_+ UnificationStuck {} -> UnificationStuck_++unquotableName :: CannotQuote -> CannotQuote_+unquotableName = \case+ CannotQuoteAmbiguous {} -> CannotQuoteAmbiguous_+ CannotQuoteExpression {} -> CannotQuoteExpression_+ CannotQuoteHidden {} -> CannotQuoteHidden_+ CannotQuoteNothing {} -> CannotQuoteNothing_+ CannotQuotePattern {} -> CannotQuotePattern_++unquoteErrorName :: UnquoteError -> UnquoteError_+unquoteErrorName = \case+ BlockedOnMeta {} -> BlockedOnMeta_+ CannotDeclareHiddenFunction {} -> CannotDeclareHiddenFunction_+ CommitAfterDef {} -> CommitAfterDef_+ ConInsteadOfDef {} -> ConInsteadOfDef_+ DefineDataNotData {} -> DefineDataNotData_+ DefInsteadOfCon {} -> DefInsteadOfCon_+ EscapingVariable {} -> EscapingVariable_+ MissingDeclaration {} -> MissingDeclaration_+ MissingDefinition {} -> MissingDefinition_+ NakedUnquote {} -> NakedUnquote_+ NonCanonical {} -> NonCanonical_+ PatLamWithoutClauses {} -> PatLamWithoutClauses_+ StaleMeta {} -> StaleMeta_+ TooManyParameters {} -> TooManyParameters_+ UnboundName {} -> UnboundName_++-- -- * Printing names of errors++-- -- The following might not be used yet:++-- ghcBackendErrorString :: GHCBackendError -> String+-- ghcBackendErrorString = ghcBackendErrorNameString . ghcBackendErrorName++-- interactionErrorString :: InteractionError -> String+-- interactionErrorString = interactionErrorNameString . interactionErrorName++-- splitErrorString :: SplitError -> String+-- splitErrorString = splitErrorNameString . splitErrorName++-- unquoteErrorString :: UnquoteError -> String+-- unquoteErrorString = unquoteErrorNameString . unquoteErrorName
@@ -1,4 +1,5 @@-{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-}+-- {-# OPTIONS_GHC -ddump-simpl -dsuppress-all -dno-suppress-type-signatures -ddump-to-file -dno-typeable-binds #-} -- | Compute eta short normal forms. module Agda.TypeChecking.EtaContract where@@ -6,14 +7,17 @@ import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Generic+ import Agda.TypeChecking.Substitute import Agda.TypeChecking.Free import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce.Monad () --instance only import {-# SOURCE #-} Agda.TypeChecking.Records import {-# SOURCE #-} Agda.TypeChecking.Datatypes+ import Agda.Utils.Monad+import Agda.Utils.List (initLast') -#include "../undefined.h" import Agda.Utils.Impossible -- TODO: move to Agda.Syntax.Internal.SomeThing@@ -22,9 +26,18 @@ binAppView :: Term -> BinAppView binAppView t = case t of- Var i xs -> app (Var i) xs- Def c xs -> app (Def c) xs- Con c xs -> app (Con c) xs+ Var i xs -> appE (Var i) xs+ Def c xs -> appE (Def c) xs+ -- Andreas, 2013-09-17: do not eta-contract when body is (record) constructor+ -- like in \ x -> s , x! (See Interaction/DoNotEtaContractFunIntoRecord)+ -- (Cf. also issue 889 (fixed differently).)+ -- At least record constructors should be fully applied where possible!+ -- TODO: also for ordinary constructors (\ x -> suc x vs. suc)?+ Con c ci xs+ | IsData <- conDataRecord c+ -> appE (Con c ci) xs+ | otherwise+ -> noApp Lit _ -> noApp Level _ -> noApp -- could be an application, but let's not eta contract levels Lam _ _ -> noApp@@ -32,38 +45,82 @@ Sort _ -> noApp MetaV _ _ -> noApp DontCare _ -> noApp+ Dummy{} -> __IMPOSSIBLE__ where noApp = NoApp t- app f [] = noApp- app f xs = App (f $ init xs) (last xs)+ appE f es0 | Just (es, Apply v) <- initLast' es0 = App (f es) v+ appE _ _ = noApp -etaContract :: TermLike a => a -> TCM a+-- | Contracts all eta-redexes it sees without reducing.+{-# SPECIALIZE etaContract :: TermLike a => a -> TCM a #-}+{-# SPECIALIZE etaContract :: TermLike a => a -> ReduceM a #-}+etaContract :: (HasConstInfo m, TermLike a) => a -> m a etaContract = traverseTermM etaOnce- where -etaOnce :: Term -> TCM Term-etaOnce v = ignoreAbstractMode $ eta v+{-# SPECIALIZE etaOnce :: Term -> TCM Term #-}+{-# SPECIALIZE etaOnce :: Term -> ReduceM Term #-}+etaOnce :: (HasConstInfo m) => Term -> m Term+etaOnce = \case+ -- Andreas, 2012-11-18: this call to reportSDoc seems to cost me 2%+ -- performance on the std-lib+ -- reportSDoc "tc.eta" 70 $ "eta-contracting" <+> prettyTCM v+ Lam i (Abs x b) -> etaLam i x b -- NoAbs can't be eta'd++ -- Andreas, 2012-12-18: Abstract definitions could contain+ -- abstract records whose constructors are not in scope.+ -- To be able to eta-contract them, we ignore abstract.+ Con c ci es -> etaCon c ci es etaContractRecord++ v -> return v++{-# INLINE etaCon #-}+-- | If record constructor, call eta-contraction function.+etaCon :: (HasConstInfo m)+ => ConHead -- ^ Constructor name @c@.+ -> ConInfo -- ^ Constructor info @ci@.+ -> Elims -- ^ Constructor arguments @args@.+ -> (QName -> ConHead -> ConInfo -> Args -> m Term)+ -- ^ Eta-contraction workhorse, gets also name of record type.+ -> m Term -- ^ Returns @Con c ci args@ or its eta-contraction.+etaCon c ci es cont = ignoreAbstractMode $ do+ let fallback = return $ Con c ci es+ -- reportSDoc "tc.eta" 20 $ "eta-contracting record" <+> prettyTCM t+ r <- getConstructorData $ conName c -- fails in ConcreteMode if c is abstract+ ifNotM (isEtaRecord r) fallback $ {-else-} do+ -- reportSDoc "tc.eta" 20 $ "eta-contracting record" <+> prettyTCM t+ let Just args = allApplyElims es+ cont r c ci args++{-# INLINE etaLam #-}+-- | Try to contract a lambda-abstraction @Lam i (Abs x b)@.+etaLam :: (MonadTCEnv m, HasOptions m)+ => ArgInfo -- ^ Info @i@ of the 'Lam'.+ -> ArgName -- ^ Name @x@ of the abstraction.+ -> Term -- ^ Body ('Term') @b@ of the 'Abs'.+ -> m Term -- ^ @Lam i (Abs x b)@, eta-contracted if possible.+etaLam i x b = do+ let fallback = return $ Lam i $ Abs x b+ case binAppView b of+ App u (Arg info v) -> do+ tyty <- typeInType+ if isVar0 tyty v+ -- Andreas, 2017-02-20 issue #2464+ -- Contracting with any irrelevant argument breaks subject reduction.+ -- E.g. \ .x -> f .(subst P eq x) can in general not be contracted to f.+ -- -- (isIrrelevant info || isVar0 tyty v)+ && sameHiding i info+ && sameModality i info+ && not (freeIn 0 u)+ then return $! strengthen impossible u+ else fallback+ _ -> fallback where- eta t@(Lam h (Abs _ b)) = do -- NoAbs can't be eta'd- imp <- shouldEtaContractImplicit- case binAppView b of- App u (Arg h' r v)- | isVar0 v && allowed imp h' && not (freeIn 0 u) ->- return $ subst __IMPOSSIBLE__ u- _ -> return t- where- isVar0 (Var 0 []) = True- isVar0 (DontCare{}) = True -- Andreas, 2011-10-01 eta-contract irrelevant functions also- isVar0 (Level (Max [Plus 0 l])) = case l of- NeutralLevel v -> isVar0 v- UnreducedLevel v -> isVar0 v- BlockedLevel{} -> False- MetaLevel{} -> False- isVar0 _ = False- allowed imp h' = h == h' && (imp || h == NotHidden)- eta t@(Con c args) = do- r <- getConstructorData c- ifM (isEtaRecord r)- (etaContractRecord r c args)- (return t)- eta t = return t+ isVar0 _ (Var 0 []) = True+ -- Andreas, 2016-01-08 If --type-in-type, all levels are equal.+ -- Jesper, 2019-10-15 issue #3073+ -- Contracting level arguments is not sound unless the domain type+ -- is in fact @Level@, e.g. @\(A : Set) → F lzero@ should not be+ -- eta-contracted to @F@.+ -- isVar0 True Level{} = True+ isVar0 tyty (Level (Max 0 [Plus 0 l])) = isVar0 tyty l+ isVar0 _ _ = False
@@ -0,0 +1,8 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.EtaContract where++import Agda.Syntax.Internal.Generic (TermLike)+import {-# SOURCE #-} Agda.TypeChecking.Monad.Signature (HasConstInfo)++etaContract :: (HasConstInfo m, TermLike a) => a -> m a
@@ -1,73 +1,248 @@-{-# LANGUAGE CPP #-}-module Agda.TypeChecking.Forcing where -import Control.Applicative+{-| A constructor argument is forced if it appears as pattern variable+in an index of the target. +For instance @x@ is forced in @sing@ and @n@ is forced in @zero@ and @suc@:++@+ data Sing {a}{A : Set a} : A -> Set where+ sing : (x : A) -> Sing x++ data Fin : Nat -> Set where+ zero : (n : Nat) -> Fin (suc n)+ suc : (n : Nat) (i : Fin n) -> Fin (suc n)+@++At runtime, forced constructor arguments may be erased as they can be+recovered from dot patterns. For instance,+@+ unsing : {A : Set} (x : A) -> Sing x -> A+ unsing .x (sing x) = x+@+can become+@+ unsing x sing = x+@+and+@+ proj : (n : Nat) (i : Fin n) -> Nat+ proj .(suc n) (zero n) = n+ proj .(suc n) (suc n i) = n+@+becomes+@+ proj (suc n) zero = n+ proj (suc n) (suc i) = n+@++This module implements the analysis of which constructor arguments are forced. The process of moving+the binding site of forced arguments is implemented in the unifier (see the Solution step of+Agda.TypeChecking.Rules.LHS.Unify.unifyStep).++Forcing is a concept from pattern matching and thus builds on the+concept of equality (I) used there (closed terms, extensional) which is+different from the equality (II) used in conversion checking and the+constraint solver (open terms, intensional).++Up to issue 1441 (Feb 2015), the forcing analysis here relied on the+wrong equality (II), considering type constructors as injective. This is+unsound for program extraction, but ok if forcing is only used to decide which+arguments to skip during conversion checking.++From now on, forcing uses equality (I) and does not search for forced+variables under type constructors. This may lose some savings during+conversion checking. If this turns out to be a problem, the old+forcing could be brought back, using a new modality @Skip@ to indicate+that this is a relevant argument but still can be skipped during+conversion checking as it is forced by equality (II).++-}++module Agda.TypeChecking.Forcing+ ( computeForcingAnnotations,+ isForced,+ nextIsForced ) where++import Control.Monad.Reader ( MonadReader, ask, local, ReaderT, runReaderT )+import Control.Monad.State ( MonadState, modify, StateT, execStateT )++import Data.Bifunctor+import Data.Function ((&))+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet+import Data.Monoid -- for (<>) in GHC 8.0.2++import Agda.Interaction.Options+ import Agda.Syntax.Common import Agda.Syntax.Internal+ import Agda.TypeChecking.Monad+import Agda.TypeChecking.Datatypes (consOfHIT) import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute-import Agda.Utils.Size+import Agda.TypeChecking.Telescope++import Agda.Utils.Boolean (implies)+import Agda.Utils.IArray (Array, listArray)+import qualified Agda.Utils.IArray as Array+import Agda.Utils.List+import Agda.Utils.Maybe import Agda.Utils.Monad-import Agda.Interaction.Options-import Agda.TypeChecking.Monad.Options+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Utils.Size+import Agda.Utils.Singleton import Agda.Utils.Impossible-#include "../undefined.h" -addForcingAnnotations :: Type -> TCM Type-addForcingAnnotations t =- ifM (not . optForcing <$> commandLineOptions)- (return t) $ do- -- t <- normalise t- let TelV tel (El _ a) = telView' t- n = size tel- indexToLevel x = n - x - 1- xs <- filter (>=0) . map indexToLevel <$> forcedVariables a- let t' = force xs t- reportSLn "tc.force" 10 $ unlines- [ "Forcing analysis"- , " xs = " ++ show xs- , " t = " ++ show t- , " t' = " ++ show t'- ]- return t'+-- | Given the type of a constructor (excluding the parameters),+-- decide which arguments are forced.+computeForcingAnnotations :: QName -> Type -> TCM [IsForced]+computeForcingAnnotations c t =+ ifNotM (optForcing <$> pragmaOptions {-then-}) (return []) $ {-else-} do+ -- Andreas, 2015-03-10 Normalization prevents Issue 1454.+ -- t <- normalise t+ -- Andreas, 2015-03-28 Issue 1469: Normalization too costly.+ -- Instantiation also fixes Issue 1454.+ -- Note that normalization of s0 below does not help.+ -- t <- instantiateFull t+ -- Ulf, 2018-01-28 (#2919): We do need to reduce the target type enough to+ -- get to the actual data type.+ -- Also #2947: The type might reduce to a pi type.+ -- Andreas, 2024-07-07, issue #6744, iteratively reduce.+ TelV tel (El _ a) <- telViewPath t+ erasureOn <- optErasure <$> pragmaOptions+ -- Modalities of constructor arguments:+ let n = size tel+ -- Candidates for forced arguments, indexed by their de Bruijn index.+ -- 'Nothing' means cannot possibly be forced.+ forcedArgCands :: ForcedVariableCandidates+ forcedArgCands = listArray (0,n-1)+ [ -- Jesper, 2023-09-20 (#6867): With --erasure, only arguments with @0 can be forced.+ if (erasureOn `implies` hasQuantity0 m)+ -- Also the argument shouldn't be irrelevant, since in that+ -- case it isn't really forced.+ && (not $ isIrrelevant m)+ then Just m else Nothing+ | m <- map getModality $ reverse $ telToList tel+ ]+ -- Computation of forced arguments:+ let vs = case a of+ Def _ us -> us+ _ -> __IMPOSSIBLE__+ forcedVars <-+ -- No candidates, no winners!+ if all isNothing forcedArgCands then pure IntSet.empty+ else runReduceM $ execForcedVariableCollection forcedArgCands $ forcedVariables vs+ let forcedArgs =+ [ if IntSet.member i forcedVars then Forced else NotForced+ | i <- downFrom n+ ]+ reportS "tc.force" 60+ [ "Forcing analysis for " ++ prettyShow c+ , " forcedVars = " ++ show (IntSet.toList forcedVars)+ , " forcedArgs = " ++ show forcedArgs+ ]+ return forcedArgs -forcedVariables :: Term -> TCM [Nat]-forcedVariables t = case t of- Var i [] -> return [i]- Con _ vs -> forcedArgs vs- Def d vs ->- ifM (isInj d)- (forcedArgs vs)- (return [])- Pi a (NoAbs _ b) ->- (++) <$> forcedVariables (unEl $ unArg a)- <*> forcedVariables (unEl b)- Pi a b -> (++) <$> forcedVariables (unEl $ unArg a)- <*> (underBinder <$> forcedVariables (unEl $ absBody b))- -- Sorts?- _ -> return []- where- underBinder xs = [ x - 1 | x <- xs, x /= 0 ]- forcedArgs vs = concat <$> mapM (forcedVariables . unArg) vs- isInj d = do- def <- getConstInfo d- return $ case theDef def of- Datatype{} -> True- Record{} -> True- -- Axiom{} -> True -- Postulates are not injective in general, right? /Olle 2011-05-05- _ -> False+-- | Candidates for forced constructor arguments (@Just m@) with their modality (@m@)+-- in the constructor telescope.+--+type ForcedVariableCandidates = Array Nat (Maybe Modality) -force :: [Nat] -> Type -> Type-force xs t = aux 0 t- where- m = maximum (-1:xs)- aux i t | i > m = t- aux i t = case t of- El s (Pi a b) -> El s $ Pi (upd a) (fmap (aux (i + 1)) b)- _ -> __IMPOSSIBLE__- where- upd a | i `elem` xs = a { argRelevance = Forced }- | otherwise = a+-- | Environment for forced variable collection.+--+data ForcedVariableContext = ForcedVariableContext+ { fvcModality :: Modality+ -- ^ Modality of current position. (Accumulated from traversed 'Arg's.)+ , fvcCandidates :: ForcedVariableCandidates+ -- ^ Candidates for forced variables. (Immutable.)+ }++-- | Which candidates are actually forced?+--+type ForcedVariableState = IntSet++-- | Monad for forced variable analysis.+--+newtype ForcedVariableCollection' a = ForcedVariableCollection+ { runForcedVariableCollection :: ReaderT ForcedVariableContext (StateT ForcedVariableState ReduceM) a }+ deriving+ ( Functor, Applicative, Monad+ , MonadReader ForcedVariableContext, MonadState ForcedVariableState+ -- Needed for HasConstInfo:+ , MonadDebug, MonadTCEnv, HasOptions+ , HasConstInfo+ -- Neded for MonadReduce:+ , ReadTCState+ , MonadReduce+ )++type ForcedVariableCollection = ForcedVariableCollection' ()++instance Semigroup ForcedVariableCollection where+ ForcedVariableCollection m <> ForcedVariableCollection m' = ForcedVariableCollection (m >> m')++instance Monoid ForcedVariableCollection where+ mempty = ForcedVariableCollection $ pure ()++instance Singleton (Nat, Modality) ForcedVariableCollection where+ singleton (i, m) = ForcedVariableCollection do+ ForcedVariableContext mc cands <- ask+ whenJust (join $ cands Array.!? i) \ m0 -> do+ -- #2819: We can only mark an argument as forced if it appears in the+ -- type with a relevance below (i.e. more relevant) than the one of the+ -- constructor argument. Otherwise we can't actually get the value from+ -- the type.+ when (composeModality mc m `moreUsableModality` m0) do+ modify $ IntSet.insert i++-- | Step into an argument labelled with the given modality.+--+underModality :: Modality -> ForcedVariableCollection -> ForcedVariableCollection+underModality m = local \ (ForcedVariableContext mc cands) -> ForcedVariableContext (composeModality mc m) cands++-- | Run the forced variable analysis monad.+execForcedVariableCollection :: ForcedVariableCandidates -> ForcedVariableCollection -> ReduceM ForcedVariableState+execForcedVariableCollection cands (ForcedVariableCollection m) =+ m & (`runReaderT` cxt)+ & (`execStateT` IntSet.empty)+ where cxt = ForcedVariableContext unitModality cands++-- | Compute the pattern variables of a term or term-like thing.+class ForcedVariables a where+ forcedVariables :: a -> ForcedVariableCollection++ default forcedVariables ::+ (ForcedVariables b, Foldable t, a ~ t b) =>+ a -> ForcedVariableCollection+ forcedVariables = foldMap forcedVariables++instance ForcedVariables a => ForcedVariables [a] where++-- Note that the 'a' does not include the 'Arg' in 'Apply'.+instance ForcedVariables a => ForcedVariables (Elim' a) where+ forcedVariables (Apply x) = forcedVariables x+ forcedVariables IApply{} = mempty -- No forced variables in path applications+ forcedVariables Proj{} = mempty++instance ForcedVariables a => ForcedVariables (Arg a) where+ forcedVariables x =+ underModality m $ forcedVariables $ unArg x+ where m = getModality x++-- | Assumes that the term is in normal form.+instance ForcedVariables Term where+ -- Andreas, 2024-07-07, issue #6744, add reduction.+ forcedVariables v = reduce v >>= \case+ Var i [] -> singleton (i, unitModality)+ Con c _ vs -> ifM (consOfHIT $ conName c) mempty $ {-else-} forcedVariables vs+ _ -> mempty++isForced :: IsForced -> Bool+isForced Forced = True+isForced NotForced = False++nextIsForced :: [IsForced] -> (IsForced, [IsForced])+nextIsForced [] = (NotForced, [])+nextIsForced (f:fs) = (f, fs)
@@ -1,213 +1,541 @@ {-# LANGUAGE CPP #-}+{-# LANGUAGE MagicHash #-}+{-# OPTIONS_GHC -Wunused-imports #-}+#if __GLASGOW_HASKELL__ > 902+{-# OPTIONS_GHC -fworker-wrapper-cbv #-}+#endif --- | Computing the free variables of a term.+{- |+Computing the free variables of a term.++The distinction between rigid and strongly rigid occurrences comes from: Jason C. Reed, PhD thesis,+2009, page 96 (see also his LFMTP 2009 paper)++The main idea is that x = t(x) is unsolvable if x occurs strongly rigidly in t. It might have a+solution if the occurrence is not strongly rigid, e.g.++ x = \f -> suc (f (x (\ y -> k))) has x = \f -> suc (f (suc k))++[Jason C. Reed, PhD thesis, page 106]++The most general function here is 'freeVarMap', which returns returns occurrence information about+every free variable. It is also a legacy function in the sense that it used to be the only function+for computing free occurrences, and it came with various functions for taking views of the resulting+'VarMap'. You can find these under the "Legacy API" here.++There are also also a bunch of specialized and optimized implementations of traversals here.++If you want to write a new function for computing free occurrence information, your task is+essentially to write a 'ComputeFree' instance and invoke 'freeVars'. These together implement a+generic traversal which has a good chance of being converted to decent code by GHC. You can look at+examples here and also look at the comments at 'ComputeFree'.+-}+ module Agda.TypeChecking.Free- ( FreeVars(..)- , Free- , freeVars+ (+ FlexRig+ , FlexRig'(..)+ , Free(..)+ , IgnoreSorts(..)+ , LensFlexRig(..)+ , VarCounts(..)+ , VarMap+ , VarMap'(..)+ , VarOcc+ , VarOcc'(..)+ , composeFlexRig+ , lookupVarMap+ , mapVarMap+ -- * Legacy API , allVars- , relevantVars+ , filterVarMap+ , filterVarMapToList+ , flexibleVars+ , freeVarMap+ , isFlexible+ , isStronglyRigid+ , isUnguarded+ , isWeaklyRigid , rigidVars- , freeIn, isBinderUsed+ , stronglyRigidVars+ , unguardedVars++ -- * MetaSet+ , MetaSet(..)+ , foldrMetaSet+ , insertMetaSet+ , metaSetToBlocker++ -- * Specialized traversals+ , allFreeVar+ , allFreeVarIgnoreAll+ , anyFreeVar+ , anyFreeVarIgnoreAll+ , closed+ , varOccurrenceIn+ , freeIn , freeInIgnoringSorts- , relevantIn- , Occurrence(..)- , occurrence+ , freeVarCounts+ , freeVarList+ , freeVarMapIgnoreAnn+ , freeVarSet+ , isBinderUsed+ , relevantInIgnoringSortAnn+ , setRelInIgnoring+ , flexRigToBlocker+ , inRewVars, theRewVars ) where -import qualified Agda.Utils.VarSet as Set-import Agda.Utils.VarSet (VarSet)+import Prelude hiding (null)+import GHC.Exts (Int(..), Int#, (-#), oneShot) -import Agda.Syntax.Common+import Data.Semigroup (Any(..), All(..))+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap++import Agda.Syntax.Common hiding (Arg, NamedArg) import Agda.Syntax.Internal -#include "../undefined.h"-import Agda.Utils.Impossible+import Agda.TypeChecking.Free.Base+import Agda.TypeChecking.Free.Generic --- | The distinction between rigid and strongly rigid occurrences comes from:--- Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP 2009 paper)------ The main idea is that x = t(x) is unsolvable if x occurs strongly rigidly--- in t. It might have a solution if the occurrence is not strongly rigid, e.g.------ x = \f -> suc (f (x (\ y -> k))) has x = \f -> suc (f (suc k))------ [Jason C. Reed, PhD thesis, page 106]+import Agda.Utils.VarSet (VarSet)+import Agda.Utils.VarSet qualified as VarSet+import Agda.Utils.StrictReader+import Agda.Utils.StrictFlipEndo+import Agda.Utils.StrictEndo qualified as NonFlip+import Agda.Utils.ExpandCase+import Agda.Utils.Impossible (__IMPOSSIBLE__)+import Agda.Utils.Maybe (fromMaybe)+import Agda.Utils.Size (size) --- | Free variables of a term, (disjointly) partitioned into strongly and--- and weakly rigid variables, flexible variables and irrelevant variables.-data FreeVars = FV- { stronglyRigidVars :: VarSet -- ^ variables at top and under constructors- , weaklyRigidVars :: VarSet -- ^ ord. rigid variables, e.g., in arguments of variables- , flexibleVars :: VarSet -- ^ variables occuring in arguments of metas. These are potentially free, depending how the meta variable is instantiated.- , irrelevantVars :: VarSet -- ^ variables under a @DontCare@, i.e., in irrelevant positions- }+-- ** All free variables together with information about their occurrence.+-------------------------------------------------------------------------------- -rigidVars :: FreeVars -> VarSet-rigidVars fv = Set.union (stronglyRigidVars fv) (weaklyRigidVars fv)+data FreeVarMap = FreeVarMap !Int {-# UNPACK #-} !VarOcc --- | @allVars fv@ includes irrelevant variables.-allVars :: FreeVars -> VarSet-allVars fv = Set.unions [rigidVars fv, flexibleVars fv, irrelevantVars fv]+instance LensFlexRig FreeVarMap MetaSet where+ {-# INLINE lensFlexRig #-}+ lensFlexRig f (FreeVarMap x occ) = FreeVarMap x <$> lensFlexRig f occ --- | All but the irrelevant variables.-relevantVars :: FreeVars -> VarSet-relevantVars fv = Set.unions [rigidVars fv, flexibleVars fv]+instance LensModality FreeVarMap where+ {-# INLINE getModality #-}+ getModality (FreeVarMap _ occ) = getModality occ+ {-# INLINE mapModality #-}+ mapModality f (FreeVarMap x occ) = FreeVarMap x (mapModality f occ) -data Occurrence- = NoOccurrence- | StronglyRigid- | WeaklyRigid- | Flexible- deriving (Eq,Show)+instance LensRelevance FreeVarMap --- | @occurrence x fv@ ignores irrelevant variables in @fv@-occurrence :: Nat -> FreeVars -> Occurrence-occurrence x fv- | x `Set.member` stronglyRigidVars fv = StronglyRigid- | x `Set.member` weaklyRigidVars fv = WeaklyRigid- | x `Set.member` flexibleVars fv = Flexible- | otherwise = NoOccurrence+instance ComputeFree FreeVarMap where+ type Collect FreeVarMap = Endo (IntMap VarOcc)+ {-# INLINE underBinders' #-}+ underBinders' n (FreeVarMap x occ) = FreeVarMap (n + x) occ+ {-# INLINE variable' #-}+ variable' x' (FreeVarMap x occ) = Endo \vars ->+ if x' < x then vars+ else IntMap.insertWith (<>) (x' - x) occ vars+ underConstructor' = defaultUnderConstructor; {-# INLINE underConstructor' #-}+ underFlexRig' = defaultUnderFlexRig; {-# INLINE underFlexRig' #-}+ underModality' = defaultUnderModality; {-# INLINE underModality' #-}+ underRelevance' = defaultUnderRelevance; {-# INLINE underRelevance' #-} --- | Mark variables as flexible. Useful when traversing arguments of metas.-flexible :: FreeVars -> FreeVars-flexible fv =- fv { stronglyRigidVars = Set.empty- , weaklyRigidVars = Set.empty- , flexibleVars = relevantVars fv- }+{-# SPECIALIZE freeVarMap :: Term -> VarMap #-}+{-# SPECIALIZE freeVarMap :: Type -> VarMap #-}+-- | Return information about every free variable.+freeVarMap :: Free t => t -> VarMap+freeVarMap t =+ VarMap (appEndo (runReader (freeVars t) (FreeVarMap 0 oneVarOcc)) mempty) --- | Mark rigid variables as non-strongly. Useful when traversion arguments of variables.-weakly :: FreeVars -> FreeVars-weakly fv = fv- { stronglyRigidVars = Set.empty- , weaklyRigidVars = rigidVars fv- }+-------------------------------------------------------------------------------- --- | Mark all free variables as irrelevant.-irrelevantly :: FreeVars -> FreeVars-irrelevantly fv = empty { irrelevantVars = allVars fv }+newtype FreeVarMapIgnoreAnn = FreeVarMapIgnoreAnn FreeVarMap+ deriving LensModality --- | Pointwise union.-union :: FreeVars -> FreeVars -> FreeVars-union (FV sv1 rv1 fv1 iv1) (FV sv2 rv2 fv2 iv2) =- FV (Set.union sv1 sv2) (Set.union rv1 rv2) (Set.union fv1 fv2) (Set.union iv1 iv2)+instance LensFlexRig FreeVarMapIgnoreAnn MetaSet where+ {-# INLINE lensFlexRig #-}+ lensFlexRig f (FreeVarMapIgnoreAnn x) = FreeVarMapIgnoreAnn <$> lensFlexRig f x -unions :: [FreeVars] -> FreeVars-unions = foldr union empty+instance LensRelevance FreeVarMapIgnoreAnn -empty :: FreeVars-empty = FV Set.empty Set.empty Set.empty Set.empty+instance ComputeFree FreeVarMapIgnoreAnn where+ type Collect FreeVarMapIgnoreAnn = Endo (IntMap VarOcc)+ {-# INLINE underBinders' #-}+ underBinders' n (FreeVarMapIgnoreAnn x) = FreeVarMapIgnoreAnn (underBinders' n x)+ {-# INLINE variable' #-}+ variable' x' (FreeVarMapIgnoreAnn x) = variable' x' x+ ignoreSorts' = IgnoreInAnnotations; {-# INLINE ignoreSorts' #-}+ underConstructor' = defaultUnderConstructor; {-# INLINE underConstructor' #-}+ underFlexRig' = defaultUnderFlexRig; {-# INLINE underFlexRig' #-}+ underModality' = defaultUnderModality; {-# INLINE underModality' #-}+ underRelevance' = defaultUnderRelevance; {-# INLINE underRelevance' #-} --- | @delete x fv@ deletes variable @x@ from variable set @fv@.-delete :: Nat -> FreeVars -> FreeVars-delete n (FV sv rv fv iv) = FV (Set.delete n sv) (Set.delete n rv) (Set.delete n fv) (Set.delete n iv)+{-# SPECIALIZE freeVarMapIgnoreAnn :: Term -> VarMap #-}+{-# SPECIALIZE freeVarMapIgnoreAnn :: (Term,Type) -> VarMap #-}+-- | Return information about every free variable, but ignore occurrences+-- in sorts of types.+freeVarMapIgnoreAnn :: Free t => t -> VarMap+freeVarMapIgnoreAnn t =+ VarMap (appEndo (runReader (freeVars t)+ (FreeVarMapIgnoreAnn (FreeVarMap 0 oneVarOcc))) mempty) --- | @subtractFV n fv@ subtracts $n$ from each free variable in @fv@.-subtractFV :: Nat -> FreeVars -> FreeVars-subtractFV n (FV sv rv fv iv) = FV (Set.subtract n sv) (Set.subtract n rv) (Set.subtract n fv) (Set.subtract n iv)+-------------------------------------------------------------------------------- --- | A single (strongly) rigid variable.-singleton :: Nat -> FreeVars-singleton x = FV { stronglyRigidVars = Set.singleton x- , weaklyRigidVars = Set.empty -- WAS: Set.singleton x- , flexibleVars = Set.empty- , irrelevantVars = Set.empty- }+newtype FreeVarCounts = FreeVarCounts Int --- * Collecting free variables.+instance ComputeFree FreeVarCounts where+ type Collect FreeVarCounts = Endo (IntMap Int)+ {-# INLINE underBinders' #-}+ underBinders' n (FreeVarCounts x) = FreeVarCounts (n + x)+ {-# INLINE variable' #-}+ variable' x' (FreeVarCounts x) = Endo \counts ->+ if x' < x then counts else IntMap.insertWith (+) (x' - x) 1 counts -class Free a where- freeVars' :: FreeConf -> a -> FreeVars+{-# SPECIALIZE freeVarCounts :: Term -> VarCounts #-}+-- | Return how many times each free variable occurs.+freeVarCounts :: Free t => t -> VarCounts+freeVarCounts t =+ VarCounts (appEndo (runReader (freeVars t) (FreeVarCounts 0)) mempty) -data FreeConf = FreeConf- { fcIgnoreSorts :: Bool- -- ^ Ignore free variables in sorts.- }+-- ** Testing that a predicate holds on any free variable+-------------------------------------------------------------------------------- --- | Doesn't go inside solved metas, but collects the variables from a--- metavariable application @X ts@ as @flexibleVars@.-freeVars :: Free a => a -> FreeVars-freeVars = freeVars' FreeConf{ fcIgnoreSorts = False }+data AnyFreeVar = AnyFreeVar !Int !(Int# -> Bool) -instance Free Term where- freeVars' conf t = case t of- Var n ts -> singleton n `union` weakly (freeVars' conf ts)- Lam _ t -> freeVars' conf t- Lit _ -> empty- Def _ ts -> weakly $ freeVars' conf ts -- because we are not in TCM- -- we cannot query whether we are dealing with a data/record (strongly r.)- -- or a definition by pattern matching (weakly rigid)- -- thus, we approximate, losing that x = List x is unsolvable- Con _ ts -> freeVars' conf ts- Pi a b -> freeVars' conf (a,b)- Sort s -> freeVars' conf s- Level l -> freeVars' conf l- MetaV _ ts -> flexible $ freeVars' conf ts- DontCare mt -> irrelevantly $ freeVars' conf mt+instance ComputeFree AnyFreeVar where+ type Collect AnyFreeVar = Any+ {-# INLINE underBinders' #-}+ underBinders' n (AnyFreeVar x f) = AnyFreeVar (n + x) f+ {-# INLINE variable' #-}+ variable' (I# x') (AnyFreeVar (I# x) f) = if I# x' < I# x then mempty else Any (f (x' -# x)) -instance Free Type where- freeVars' conf (El s t) = freeVars' conf (s, t)+{-# SPECIALIZE anyFreeVar# :: (Int# -> Bool) -> Dom' Term Type -> Bool #-}+anyFreeVar# :: Free t => (Int# -> Bool) -> t -> Bool+anyFreeVar# f t = getAny (runReader (freeVars t) (AnyFreeVar 0 f)) -instance Free Sort where- freeVars' conf s- | fcIgnoreSorts conf = empty- | otherwise = case s of- Type a -> freeVars' conf a- Prop -> empty- Inf -> empty- DLub s1 s2 -> weakly $ freeVars' conf (s1, s2)+{-# INLINE anyFreeVar #-}+-- | Compute the disjunction of a predicate on free variables.+anyFreeVar :: Free t => (Int -> Bool) -> t -> Bool+anyFreeVar f = anyFreeVar# (\n -> f (I# n)) -instance Free Level where- freeVars' conf (Max as) = freeVars' conf as+{-# SPECIALIZE allFreeVar# :: (Int# -> Bool) -> Dom' Term Type -> Bool #-}+allFreeVar# :: Free t => (Int# -> Bool) -> t -> Bool+allFreeVar# f t = not (getAny (runReader (freeVars t) (AnyFreeVar 0 (\n -> not (f n))))) -instance Free PlusLevel where- freeVars' conf ClosedLevel{} = empty- freeVars' conf (Plus _ l) = freeVars' conf l+{-# INLINE allFreeVar #-}+-- | Compute the conjunction of a predicate on free variables.+allFreeVar :: Free t => (Int -> Bool) -> t -> Bool+allFreeVar f = allFreeVar# (\n -> f (I# n)) -instance Free LevelAtom where- freeVars' conf l = case l of- MetaLevel _ vs -> flexible $ freeVars' conf vs- NeutralLevel v -> freeVars' conf v- BlockedLevel _ v -> freeVars' conf v- UnreducedLevel v -> freeVars' conf v+data AnyFreeVarIgnoreAll = AnyFreeVarIgnoreAll !Int !(Int# -> Bool) -instance Free a => Free [a] where- freeVars' conf = unions . map (freeVars' conf)+instance ComputeFree AnyFreeVarIgnoreAll where+ type Collect AnyFreeVarIgnoreAll = Any+ {-# INLINE underBinders' #-}+ underBinders' n (AnyFreeVarIgnoreAll x f) = AnyFreeVarIgnoreAll (n + x) f+ {-# INLINE variable' #-}+ variable' (I# x') (AnyFreeVarIgnoreAll (I# x) f) =+ if I# x' < I# x then mempty else Any (f (x' -# x))+ {-# INLINE ignoreSorts' #-}+ ignoreSorts' = IgnoreAll -instance Free a => Free (Maybe a) where- freeVars' conf = maybe empty (freeVars' conf)+{-# SPECIALIZE anyFreeVarIgnoreAll# :: (Int# -> Bool) -> Term -> Bool #-}+anyFreeVarIgnoreAll# :: Free t => (Int# -> Bool) -> t -> Bool+anyFreeVarIgnoreAll# f t = getAny (runReader (freeVars t) (AnyFreeVarIgnoreAll 0 f)) -instance (Free a, Free b) => Free (a,b) where- freeVars' conf (x,y) = freeVars' conf x `union` freeVars' conf y+{-# INLINE anyFreeVarIgnoreAll #-}+-- | Same as 'anyFreeVar' except occurrences in sorts of types are ignored.+anyFreeVarIgnoreAll :: (Int -> Bool) -> Term -> Bool+anyFreeVarIgnoreAll f = anyFreeVarIgnoreAll# (\n -> f (I# n)) -instance Free a => Free (Arg a) where- freeVars' conf = freeVars' conf . unArg+-- SPECIALIZED to TCM.Constraint in SizedTypes.Solve+allFreeVarIgnoreAll# :: Free t => (Int# -> Bool) -> t -> Bool+allFreeVarIgnoreAll# f t =+ not (getAny (runReader (freeVars t) (AnyFreeVarIgnoreAll 0 (\n -> not (f n))))) -instance Free a => Free (Abs a) where- freeVars' conf (Abs _ b) = subtractFV 1 $ delete 0 $ freeVars' conf b- freeVars' conf (NoAbs _ b) = freeVars' conf b+{-# INLINE allFreeVarIgnoreAll #-}+-- | Same as 'allFreeVar' except occurrences in sorts of types are ignored.+allFreeVarIgnoreAll :: Free t => (Int -> Bool) -> t -> Bool+allFreeVarIgnoreAll f = allFreeVarIgnoreAll# (\n -> f (I# n)) -instance Free a => Free (Tele a) where- freeVars' conf EmptyTel = empty- freeVars' conf (ExtendTel a tel) = freeVars' conf (a, tel)+-- ** Flex-rigid occurrence for a single variable+-------------------------------------------------------------------------------- -instance Free ClauseBody where- freeVars' conf (Body t) = freeVars' conf t- freeVars' conf (Bind b) = freeVars' conf b- freeVars' conf NoBody = empty+data SingleVarOcc = SingleVarOcc !Int !VarOcc -freeIn :: Free a => Nat -> a -> Bool-freeIn v t = v `Set.member` allVars (freeVars t)+instance LensFlexRig SingleVarOcc MetaSet where+ {-# INLINE lensFlexRig #-}+ lensFlexRig f (SingleVarOcc x occ) = SingleVarOcc x <$> lensFlexRig f occ -freeInIgnoringSorts :: Free a => Nat -> a -> Bool-freeInIgnoringSorts v t =- v `Set.member` allVars (freeVars' FreeConf{ fcIgnoreSorts = True } t)+data CollectSingleVarOcc = CSVarOccNothing | CSVarOccJust !VarOcc -relevantIn :: Free a => Nat -> a -> Bool-relevantIn v t = v `Set.member` relevantVars (freeVars' FreeConf{ fcIgnoreSorts = True } t)+instance LensRelevance SingleVarOcc where +instance LensModality SingleVarOcc where+ {-# INLINE getModality #-}+ getModality (SingleVarOcc _ occ) = getModality occ+ {-# INLINE mapModality #-}+ mapModality f (SingleVarOcc x occ) = SingleVarOcc x (mapModality f occ)++instance Semigroup CollectSingleVarOcc where+ CSVarOccJust occ <> CSVarOccJust occ' = CSVarOccJust (occ <> occ')+ CSVarOccNothing <> s = s+ s <> CSVarOccNothing = s++instance ComputeFree SingleVarOcc where+ type Collect SingleVarOcc = Endo CollectSingleVarOcc+ {-# INLINE underBinders' #-}+ underBinders' n (SingleVarOcc x occ) = SingleVarOcc (n + x) occ+ {-# INLINE variable' #-}+ variable' x' (SingleVarOcc x occ) = Endo \acc -> if x == x' then acc <> CSVarOccJust occ else acc+ underConstructor' = defaultUnderConstructor; {-# INLINE underConstructor' #-}+ underFlexRig' = defaultUnderFlexRig; {-# INLINE underFlexRig' #-}+ underModality' = defaultUnderModality; {-# INLINE underModality' #-}+ underRelevance' = defaultUnderRelevance; {-# INLINE underRelevance' #-}++{-# SPECIALIZE varOccurrenceIn :: Nat -> Term -> Maybe VarOcc #-}+{-# SPECIALIZE varOccurrenceIn :: Nat -> Sort' Term -> Maybe VarOcc #-}+-- | Compute 'VarOcc' for a single variable.+varOccurrenceIn :: Free a => Nat -> a -> Maybe VarOcc+varOccurrenceIn x a = case appEndo (runReader (freeVars a) (SingleVarOcc x oneVarOcc)) CSVarOccNothing of+ CSVarOccNothing -> Nothing+ CSVarOccJust occ -> Just occ++-- ** Plain free occurrence+--------------------------------------------------------------------------------++newtype FreeIn = FreeIn Int++instance ComputeFree FreeIn where+ type Collect FreeIn = Any+ underBinders' n (FreeIn x) = FreeIn (n + x); {-# INLINE underBinders' #-}+ variable' x' (FreeIn x) = Any (x == x'); {-# INLINE variable' #-}++{-# SPECIALIZE freeIn :: Nat -> Term -> Bool #-}+{-# SPECIALIZE freeIn :: Nat -> Type -> Bool #-}+-- | Check if single variable occurs freely.+freeIn :: Free t => Nat -> t -> Bool+freeIn x a = getAny (runReader (freeVars a) (FreeIn x))++newtype FreeInIgnoringSorts = FreeInIgnoringSorts Int++instance ComputeFree FreeInIgnoringSorts where+ type Collect FreeInIgnoringSorts = Any+ underBinders' n (FreeInIgnoringSorts x) = FreeInIgnoringSorts (n + x); {-# INLINE underBinders' #-}+ variable' x' (FreeInIgnoringSorts x) = Any (x == x'); {-# INLINE variable' #-}+ ignoreSorts' = IgnoreAll; {-# INLINE ignoreSorts' #-}++{-# SPECIALIZE freeInIgnoringSorts :: Nat -> Term -> Bool #-}+{-# SPECIALIZE freeInIgnoringSorts :: Nat -> Type -> Bool #-}+-- | Check if a single variable occurs freely outside of sorts of types.+freeInIgnoringSorts :: Free a => Nat -> a -> Bool+freeInIgnoringSorts x a = getAny (runReader (freeVars a) (FreeInIgnoringSorts x))++{-# INLINE isBinderUsed #-} -- | Is the variable bound by the abstraction actually used? isBinderUsed :: Free a => Abs a -> Bool isBinderUsed NoAbs{} = False isBinderUsed (Abs _ x) = 0 `freeIn` x++-- ** Relevant free occurrence.+--------------------------------------------------------------------------------++data RelevantInIgnoringSortAnn = RelevantInIgnoringSortAnn !Int !Relevance++instance LensRelevance RelevantInIgnoringSortAnn where+ getRelevance (RelevantInIgnoringSortAnn _ r) = r+ mapRelevance f (RelevantInIgnoringSortAnn x r) = RelevantInIgnoringSortAnn x (f r)++instance ComputeFree RelevantInIgnoringSortAnn where+ type Collect RelevantInIgnoringSortAnn = Any+ {-# INLINE underBinders' #-}+ underBinders' n (RelevantInIgnoringSortAnn x r) =+ RelevantInIgnoringSortAnn (n + x) r+ {-# INLINE variable' #-}+ variable' x' (RelevantInIgnoringSortAnn x r) = Any (x' == x && not (isIrrelevant r))+ ignoreSorts' = IgnoreInAnnotations; {-# INLINE ignoreSorts' #-}+ {-# INLINE underModality' #-}+ underModality' = Just \m (RelevantInIgnoringSortAnn x r) ->+ RelevantInIgnoringSortAnn x (composeRelevance (getRelevance m) r)+ underRelevance' = defaultUnderRelevance; {-# INLINE underRelevance' #-}++{-# SPECIALIZE relevantInIgnoringSortAnn :: Nat -> Term -> Bool #-}+{-# SPECIALIZE relevantInIgnoringSortAnn :: Nat -> Type -> Bool #-}+{-# SPECIALIZE relevantInIgnoringSortAnn :: Nat -> Dom' Term Type -> Bool #-}+-- | Does a variable occur relevantly and outside of sorts of types?+relevantInIgnoringSortAnn :: Free t => Nat -> t -> Bool+relevantInIgnoringSortAnn x t =+ getAny (runReader (freeVars t) (RelevantInIgnoringSortAnn x unitRelevance))++-- ** Closed objects+---------------------------------------------------------------------------++newtype Closed = Closed Int -- ^ Local scope size.++instance ComputeFree Closed where+ type Collect Closed = All+ underBinders' n (Closed x) = Closed (n + x); {-# INLINE underBinders' #-}+ variable' x' (Closed x) = All (x' < x); {-# INLINE variable' #-}++{-# SPECIALIZE closed :: Term -> Bool #-}+{-# SPECIALIZE closed :: Dom' Term Type -> Bool #-}+-- | Is a term closed?+closed :: Free t => t -> Bool+closed t = getAll (runReader (freeVars t) (Closed 0))++-- ** Test free occurrence for a set of variables+--------------------------------------------------------------------------------++data SetRelInIgnoring = SetRelInIgnoring !Int !Relevance++instance LensRelevance SetRelInIgnoring where+ getRelevance (SetRelInIgnoring _ r) = r+ mapRelevance f (SetRelInIgnoring x r) = SetRelInIgnoring x (f r)++newtype CollectSFII = CollectSFII {appCSFII :: VarSet -> VarSet}++instance Semigroup CollectSFII where+ {-# INLINE (<>) #-}+ CollectSFII f <> CollectSFII g = CollectSFII (oneShot \xs -> case f xs of+ xs -> if VarSet.null xs then xs else g xs)++instance Monoid CollectSFII where+ {-# INLINE mempty #-}+ mempty = CollectSFII \xs -> xs++instance ExpandCase CollectSFII where+ type Result CollectSFII = VarSet+ {-# INLINE expand #-}+ expand k = CollectSFII (oneShot \a -> k (oneShot \act -> appCSFII act a))++instance ComputeFree SetRelInIgnoring where+ type Collect SetRelInIgnoring = CollectSFII+ {-# INLINE underBinders' #-}+ underBinders' n (SetRelInIgnoring x r) = SetRelInIgnoring (n + x) r+ {-# INLINE variable' #-}+ variable' x' (SetRelInIgnoring x r) = CollectSFII \xs ->+ if x' >= x && not (isIrrelevant r)+ then VarSet.delete (x' - x) xs+ else xs+ ignoreSorts' = IgnoreInAnnotations; {-# INLINE ignoreSorts' #-}+ underModality' = Just \m (SetRelInIgnoring x r) ->+ SetRelInIgnoring x (composeRelevance (getRelevance m) r)+ underRelevance' = defaultUnderRelevance; {-# INLINE underRelevance' #-}++{-# SPECIALIZE NOINLINE setRelInIgnoring :: VarSet -> Dom Type -> VarSet #-}+{-# SPECIALIZE NOINLINE setRelInIgnoring :: VarSet -> Type -> VarSet #-}+-- | Test for a set of variables whether each variable occurs relevantly and outside of sort annotations.+-- Return the set of variables that __don't__ occur.+setRelInIgnoring :: Free t => VarSet -> t -> VarSet+setRelInIgnoring xs t+ | VarSet.null xs = xs+ | otherwise = appCSFII (runReader (freeVars t) (SetRelInIgnoring 0 unitRelevance)) xs+++-- ** Collect free variables+--------------------------------------------------------------------------------++newtype FreeVarSet = FreeVarSet Int++instance ComputeFree FreeVarSet where+ type Collect FreeVarSet = Endo VarSet+ {-# INLINE underBinders' #-}+ underBinders' n (FreeVarSet x) = FreeVarSet (n + x)+ {-# INLINE variable' #-}+ variable' x' (FreeVarSet x) = Endo \xs -> if x' < x then xs else VarSet.insert (x' - x) xs++{-# SPECIALIZE freeVarSet :: Term -> VarSet #-}+{-# SPECIALIZE freeVarSet :: Dom' Term Type -> VarSet #-}+-- | Compute the set of free variables.+freeVarSet :: Free t => t -> VarSet+freeVarSet t = appEndo (runReader (freeVars t) (FreeVarSet 0)) mempty++newtype FreeVarList = FreeVarList Int++instance ComputeFree FreeVarList where+ -- Need the non-flipped endo to get left-right element order+ type Collect FreeVarList = NonFlip.Endo [Int]+ {-# INLINE underBinders' #-}+ underBinders' n (FreeVarList x) = FreeVarList (n + x)+ {-# INLINE variable' #-}+ variable' x' (FreeVarList x) = NonFlip.Endo \xs ->+ if x' < x then xs else let !v = x' - x in v : xs++{-# SPECIALIZE freeVarList :: Term -> [Int] #-}+{-# SPECIALIZE freeVarList :: Maybe Term -> [Int] #-}+-- | Compute a (possibly non-unique) list of free variables, in preorder traversal order.+freeVarList :: Free t => t -> [Int]+freeVarList t = NonFlip.appEndo (runReader (freeVars t) (FreeVarList 0)) []++-- ** Backwards-compatible interface, for extracting information from a 'VarMap'.+---------------------------------------------------------------------------++{-# INLINE filterVarMap #-}+filterVarMap :: (VarOcc -> Bool) -> VarMap -> VarSet+filterVarMap f = \(VarMap m) ->+ IntMap.foldlWithKey'+ (\acc k v -> if f v then VarSet.insert k acc else acc)+ mempty m++{-# INLINE filterVarMapToList #-}+filterVarMapToList :: (VarOcc -> Bool) -> VarMap -> [Int]+filterVarMapToList f = \(VarMap m) ->+ IntMap.foldrWithKey'+ (\k v acc -> if f v then k:acc else acc)+ [] m++-- | Variables under only and at least one inductive constructor(s).+stronglyRigidVars :: VarMap -> VarSet+stronglyRigidVars = filterVarMap $ \case+ VarOcc StronglyRigid _ -> True+ _ -> False++-- | Variables at top or only under inductive record constructors+-- λs and Πs.+-- The purpose of recording these separately is that they+-- can still become strongly rigid if put under a constructor+-- whereas weakly rigid ones stay weakly rigid.+unguardedVars :: VarMap -> VarSet+unguardedVars = filterVarMap $ \case+ VarOcc Unguarded _ -> True+ _ -> False++-- | Rigid variables: either strongly rigid, unguarded, or weakly rigid.+rigidVars :: VarMap -> VarSet+rigidVars = filterVarMap $ \case+ VarOcc o _ -> case o of+ WeaklyRigid -> True+ Unguarded -> True+ StronglyRigid -> True+ _ -> False++-- | Variables occuring in arguments of metas.+-- These are only potentially free, depending how the meta variable is instantiated.+-- The set contains the id's of the meta variables that this variable is an argument to.+flexibleVars :: VarMap -> IntMap MetaSet+flexibleVars (VarMap m) = flip IntMap.mapMaybe m $ \case+ VarOcc (Flexible ms) _ -> Just ms+ _ -> Nothing++allVars :: VarMap -> VarSet+allVars = filterVarMap (\_ -> True)++-- | Returns the variables that correspond to local rewrite rules.+theRewVars :: Telescope -> VarSet+theRewVars = fst . allRewVars++-- | Returns all variables that occur in local rewrite rules.+inRewVars :: Telescope -> VarSet+inRewVars = snd . allRewVars++-- | Returns two sets of variables: the first set contains all variables+-- corresponding to local rewrite rules, and the second set includes all+-- variables which occur in those rewrite rules.+allRewVars :: Telescope -> (VarSet, VarSet)+allRewVars EmptyTel = (VarSet.empty, VarSet.empty)+allRewVars (ExtendTel a b) =+ fromMaybe (VarSet.empty, VarSet.empty)+ (go . fromMaybe __IMPOSSIBLE__ . rewDomRew <$> rewDom a)+ <> (allRewVars $ unAbs b)+ where+ go r =+ (VarSet.singleton $ size b, VarSet.weaken (size b + 1) $ freeVarSet r)
@@ -0,0 +1,317 @@++module Agda.TypeChecking.Free.Base where++import Control.Applicative hiding (empty)+import Control.Monad.Reader ( MonadReader(..), asks, ReaderT, Reader, runReader )++import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import Data.HashSet (HashSet)+import qualified Data.HashSet as HashSet+import Data.Set (Set)+import qualified Data.Set as Set++import Agda.Syntax.Common.Pretty+import Agda.Syntax.Common+import Agda.Syntax.Internal++import Agda.Utils.Functor+import Agda.Utils.Lens+import Agda.Utils.List1 (List1)+import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Semigroup+import Agda.Utils.Singleton+import Agda.Utils.Size++---------------------------------------------------------------------------+-- * Set of meta variables.++-- | A set of meta variables. Forms a monoid under union.++newtype MetaSet = MetaSet { theMetaSet :: HashSet MetaId }+ deriving (Eq, Show, Null, Semigroup, Monoid)++instance Singleton MetaId MetaSet where+ singleton = MetaSet . singleton++insertMetaSet :: MetaId -> MetaSet -> MetaSet+insertMetaSet m (MetaSet ms) = MetaSet $ HashSet.insert m ms++foldrMetaSet :: (MetaId -> a -> a) -> a -> MetaSet -> a+foldrMetaSet f e ms = HashSet.foldr f e $ theMetaSet ms++metaSetToBlocker :: MetaSet -> Blocker+metaSetToBlocker ms = unblockOnAny $ foldrMetaSet (Set.insert . unblockOnMeta) Set.empty ms++instance Pretty MetaSet where+ pretty = pretty . Set.fromList . HashSet.toList . theMetaSet++---------------------------------------------------------------------------+-- * Flexible and rigid occurrences (semigroup)++-- | Depending on the surrounding context of a variable,+-- it's occurrence can be classified as flexible or rigid,+-- with finer distinctions.+--+-- The constructors are listed in increasing order (wrt. information content).+data FlexRig' a+ = Flexible !a -- ^ In arguments of metas.+ -- The set of metas is used by ''Agda.TypeChecking.Rewriting.NonLinMatch''+ -- to generate the right blocking information.+ -- The semantics is that the status of a variable occurrence may change+ -- if one of the metas in the set gets solved. We may say the occurrence+ -- is tainted by the meta variables in the set.+ | WeaklyRigid -- ^ In arguments to variables and definitions.+ | Unguarded -- ^ In top position, or only under inductive record constructors (unit).+ | StronglyRigid -- ^ Under at least one and only inductive constructors.+ deriving (Eq, Show, Functor, Foldable)++type FlexRig = FlexRig' MetaSet++class LensFlexRig o a | o -> a where+ lensFlexRig :: Lens' o (FlexRig' a)++instance LensFlexRig (FlexRig' a) a where+ lensFlexRig = id++isFlexible :: LensFlexRig o a => o -> Bool+isFlexible o = case o ^. lensFlexRig of+ Flexible {} -> True+ _ -> False++isUnguarded :: LensFlexRig o a => o -> Bool+isUnguarded o = case o ^. lensFlexRig of+ Unguarded -> True+ _ -> False++isWeaklyRigid :: LensFlexRig o a => o -> Bool+isWeaklyRigid o = case o ^. lensFlexRig of+ WeaklyRigid -> True+ _ -> False++isStronglyRigid :: LensFlexRig o a => o -> Bool+isStronglyRigid o = case o ^. lensFlexRig of+ StronglyRigid -> True+ _ -> False++-- | 'FlexRig' aggregation (additive operation of the semiring).+-- For combining occurrences of the same variable in subterms.+-- This is a refinement of the 'max' operation for 'FlexRig'+-- which would work if 'Flexible' did not have the 'MetaSet' as an argument.+-- Now, to aggregate two 'Flexible' occurrences, we union the involved 'MetaSet's.++addFlexRig :: Semigroup a => FlexRig' a -> FlexRig' a -> FlexRig' a+addFlexRig = curry $ \case+ -- StronglyRigid is dominant+ (StronglyRigid, _) -> StronglyRigid+ (_, StronglyRigid) -> StronglyRigid+ -- Next is Unguarded+ (Unguarded, _) -> Unguarded+ (_, Unguarded) -> Unguarded+ -- Then WeaklyRigid+ (WeaklyRigid, _) -> WeaklyRigid+ (_, WeaklyRigid) -> WeaklyRigid+ -- Least is Flexible. We union the meta sets, as the variable+ -- is tainted by all of the involved meta variable.+ (Flexible ms1, Flexible ms2) -> Flexible $ ms1 <> ms2+{-# SPECIALIZE NOINLINE addFlexRig :: FlexRig' MetaSet -> FlexRig' MetaSet -> FlexRig' MetaSet #-}+{-# SPECIALIZE NOINLINE addFlexRig :: FlexRig' () -> FlexRig' () -> FlexRig' () #-}++-- | Unit for 'addFlexRig'.+zeroFlexRig :: Monoid a => FlexRig' a+zeroFlexRig = Flexible mempty++-- | Absorptive for 'addFlexRig'.+omegaFlexRig :: FlexRig' a+omegaFlexRig = StronglyRigid++-- | 'FlexRig' composition (multiplicative operation of the semiring).+-- For accumulating the context of a variable.+--+-- 'Flexible' is dominant. Once we are under a meta, we are flexible+-- regardless what else comes. We taint all variable occurrences+-- under a meta by this meta.+--+-- 'WeaklyRigid' is next in strength. Destroys strong rigidity.+--+-- 'StronglyRigid' is still dominant over 'Unguarded'.+--+-- 'Unguarded' is the unit. It is the top (identity) context.+--+composeFlexRig :: Semigroup a => FlexRig' a -> FlexRig' a -> FlexRig' a+composeFlexRig = curry $ \case+ (Flexible ms1, Flexible ms2) -> Flexible $ ms1 <> ms2+ (Flexible ms1, _) -> Flexible ms1+ (_, Flexible ms2) -> Flexible ms2+ (WeaklyRigid, _) -> WeaklyRigid+ (_, WeaklyRigid) -> WeaklyRigid+ (StronglyRigid, _) -> StronglyRigid+ (_, StronglyRigid) -> StronglyRigid+ (Unguarded, Unguarded) -> Unguarded+{-# SPECIALIZE NOINLINE composeFlexRig :: FlexRig' MetaSet -> FlexRig' MetaSet -> FlexRig' MetaSet #-}+{-# SPECIALIZE NOINLINE composeFlexRig :: FlexRig' () -> FlexRig' () -> FlexRig' () #-}++-- | Unit for 'composeFlexRig'.+oneFlexRig :: FlexRig' a+oneFlexRig = Unguarded++-- | Extract a blocker from an occurrence+flexRigToBlocker :: FlexRig -> Blocker+flexRigToBlocker (Flexible ms) = metaSetToBlocker ms+flexRigToBlocker _ = neverUnblock++instance Pretty a => Pretty (FlexRig' a) where+ pretty = \case+ Flexible a -> "FL" <> parens (pretty a)+ WeaklyRigid -> "WR"+ StronglyRigid -> "SR"+ Unguarded -> empty++---------------------------------------------------------------------------+-- * Multi-dimensional feature vector for variable occurrence (semigroup)++-- | Occurrence of free variables is classified by several dimensions.+-- Currently, we have 'FlexRig' and 'Modality'.+data VarOcc' a = VarOcc+ { varFlexRig :: !(FlexRig' a)+ , varModality :: {-# UNPACK #-} !Modality+ }+ deriving (Show)+type VarOcc = VarOcc' MetaSet++-- | Equality up to origin.+instance Eq a => Eq (VarOcc' a) where+ VarOcc fr m == VarOcc fr' m' = fr == fr' && sameModality m m'++instance LensModality (VarOcc' a) where+ getModality = varModality+ mapModality f (VarOcc x r) = VarOcc x $ f r++instance LensRelevance (VarOcc' a) where+instance LensQuantity (VarOcc' a) where++-- | Access to 'varFlexRig' in 'VarOcc'.+instance LensFlexRig (VarOcc' a) a where+ lensFlexRig f (VarOcc fr m) = f fr <&> \ fr' -> VarOcc fr' m+-- lensFlexRig :: Lens' (VarOcc' a) (FlexRig' a)+-- lensFlexRig f (VarOcc fr m) = f fr <&> \ fr' -> VarOcc fr' m+++-- | The default way of aggregating free variable info from subterms is by adding+-- the variable occurrences. For instance, if we have a pair @(t₁,t₂)@ then+-- and @t₁@ has @o₁@ the occurrences of a variable @x@+-- and @t₂@ has @o₂@ the occurrences of the same variable, then+-- @(t₁,t₂)@ has @mappend o₁ o₂@ occurrences of that variable.+--+-- From counting 'Quantity', we extrapolate this to 'FlexRig' and 'Relevance':+-- we care most about about 'StronglyRigid' 'Relevant' occurrences.+-- E.g., if @t₁@ has a 'StronglyRigid' occurrence and @t₂@ a 'Flexible' occurrence,+-- then @(t₁,t₂)@ still has a 'StronglyRigid' occurrence.+-- Analogously, @Relevant@ occurrences count most, as we wish e.g. to forbid+-- relevant occurrences of variables that are declared to be irrelevant.+--+-- 'VarOcc' forms a semiring, and this monoid is the addition of the semiring.++instance Semigroup a => Semigroup (VarOcc' a) where+ VarOcc o m <> VarOcc o' m' = VarOcc (addFlexRig o o') (addModality m m')++-- | The neutral element for variable occurrence aggregation is least serious+-- occurrence: flexible, irrelevant.+-- This is also the absorptive element for 'composeVarOcc', if we ignore+-- the 'MetaSet' in 'Flexible'.+instance (Monoid a) => Monoid (VarOcc' a) where+ mempty = VarOcc (Flexible mempty) zeroModality+ mappend = (<>)++-- | The absorptive element of variable occurrence under aggregation:+-- strongly rigid, relevant.+topVarOcc :: VarOcc' a+topVarOcc = VarOcc StronglyRigid topModality++-- | First argument is the outer occurrence (context) and second is the inner.+-- This multiplicative operation is to modify an occurrence under a context.+composeVarOcc :: Semigroup a => VarOcc' a -> VarOcc' a -> VarOcc' a+composeVarOcc (VarOcc o m) (VarOcc o' m') = VarOcc (composeFlexRig o o') (composeModality m m')+ -- We use the multipicative modality monoid (composition).++oneVarOcc :: VarOcc' a+oneVarOcc = VarOcc Unguarded unitModality++-- | What's the rigidity of a constructor?+constructorFlexRig :: ConHead -> Elims -> FlexRig' a+constructorFlexRig (ConHead _ _ i hit fs) es+ | hit == YesHIT = WeaklyRigid+ | otherwise = case i of++ -- Coinductive (record) constructors admit infinite cycles:+ CoInductive -> WeaklyRigid+ -- Inductive constructors do not admit infinite cycles:+ Inductive | size es == size fs -> StronglyRigid+ | otherwise -> WeaklyRigid+ -- Jesper, 2020-10-22: Issue #4995: treat occurrences in non-fully+ -- applied constructors as weakly rigid.+ -- Ulf, 2019-10-18: Now the termination checker treats inductive recursive records+ -- the same as datatypes, so absense of infinite cycles can be proven in Agda, and thus+ -- the unifier is allowed to do it too. Test case: test/Succeed/Issue1271a.agda+ -- WAS:+ -- -- Inductive record constructors do not admit infinite cycles,+ -- -- but this cannot be proven inside Agda.+ -- -- Thus, unification should not prove it either.++instance Pretty a => Pretty (VarOcc' a) where+ pretty (VarOcc a b) = pretty a <+> pretty b++-- | Representation of a variable set as map from de Bruijn indices+-- to 'VarOcc'.+type TheVarMap' a = IntMap (VarOcc' a)+newtype VarMap' a = VarMap { theVarMap :: TheVarMap' a }+ deriving (Eq, Show)++type TheVarMap = TheVarMap' MetaSet+type VarMap = VarMap' MetaSet++-- | A "set"-style 'Singleton' instance with default/initial variable occurrence.+instance Singleton Variable (VarMap' a) where+ singleton i = VarMap $ IntMap.singleton i oneVarOcc++mapVarMap :: (TheVarMap' a -> TheVarMap' b) -> VarMap' a -> VarMap' b+mapVarMap f = VarMap . f . theVarMap++lookupVarMap :: Variable -> VarMap' a -> Maybe (VarOcc' a)+lookupVarMap i = IntMap.lookup i . theVarMap++-- Andreas & Jesper, 2018-05-11, issue #3052:++-- | Proper monoid instance for @VarMap@ rather than inheriting the broken one from IntMap.+-- We combine two occurrences of a variable using 'mappend'.+instance Semigroup a => Semigroup (VarMap' a) where+ VarMap m <> VarMap m' = VarMap $ IntMap.unionWith (<>) m m'++instance Semigroup a => Monoid (VarMap' a) where+ mempty = VarMap IntMap.empty+ mappend = (<>)+ mconcat = VarMap . IntMap.unionsWith (<>) . map theVarMap+ -- mconcat = VarMap . IntMap.unionsWith mappend . coerce -- ghc 8.6.5 does not seem to like this coerce++---------------------------------------------------------------------------+-- * Plain variable occurrence counting.++newtype VarCounts = VarCounts { varCounts :: IntMap Int }+ deriving (Eq, Show)++instance Semigroup VarCounts where+ VarCounts fv1 <> VarCounts fv2 = VarCounts (IntMap.unionWith (+) fv1 fv2)++instance Monoid VarCounts where+ mempty = VarCounts IntMap.empty+ mappend = (<>)++-- | Where should we skip sorts in free variable analysis?+data IgnoreSorts+ = IgnoreNot -- ^ Do not skip.+ | IgnoreInAnnotations -- ^ Skip when annotation to a type.+ | IgnoreAll -- ^ Skip unconditionally.+ deriving (Eq, Show)++type Variable = Int
@@ -0,0 +1,356 @@+{-# LANGUAGE AllowAmbiguousTypes, CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-}++#if __GLASGOW_HASKELL__ > 902+{-# OPTIONS_GHC -fworker-wrapper-cbv #-}+#endif++{- |+Computing free variables of a term generically. Different queries can be specialized to the+appropriate short-circuiting behavior and to only pass around the necessary data. A query can be+written as an instance to the 'ComputeFree' class which bundles all parameters of the generic+traversal. The traversal itself is defined in the instance of the 'Free' class. See+Agda.TypeChecking.Free for examples of queries.++Background notes:++The distinction between rigid and strongly rigid occurrences comes from: Jason C. Reed, PhD thesis,+ 2009, page 96 (see also his LFMTP 2009 paper)++The main idea is that x = t(x) is unsolvable if x occurs strongly rigidly in t. It might have a+solution if the occurrence is not strongly rigid, e.g.++ x = \f -> suc (f (x (\ y -> k))) has x = \f -> suc (f (suc k))++[Jason C. Reed, PhD thesis, page 106]++Under coinductive constructors, occurrences are never strongly rigid. Also, function types and+lambdas do not establish strong rigidity. Only inductive constructors do so. (See issue 1271).++For further reading on semirings and semimodules for variable occurrence, see e.g. Conor McBrides "I+got plenty of nuttin'" (Wadlerfest 2016). There, he treats the "quantity" dimension of variable+occurrences.++The semiring has an additive operation for combining occurrences of subterms, and a+multiplicative operation of representing function composition. E.g. if variable @x@ appears @o@+in term @u@, but @u@ appears in context @q@ in term @t@ then occurrence of variable @x@ coming+from @u@ is accounted for as @q o@ in @t@.++Consider the example @(λ{ x → (x,x)}) y@:++ * Variable @x@ occurs once unguarded in @x@.++ * It occurs twice unguarded in the aggregation @x@ @x@++ * Inductive constructor @,@ turns this into two strictly rigid occurrences.++ If @,@ is a record constructor, then we stay unguarded.++ * The function @({λ x → (x,x)})@ provides a context for variable @y@.+ This context can be described as weakly rigid with quantity two.++ * The final occurrence of @y@ is obtained as composing the context with+ the occurrence of @y@ in itself (which is the unit for composition).+ Thus, @y@ occurs weakly rigid with quantity two.++It is not a given that the context can be described in the same way as the variable occurrence.+However, for the purpose of quantity it is the case and we obtain a semiring of occurrences with 0,+1, and even ω, which is an absorptive element for addition.+-}++module Agda.TypeChecking.Free.Generic where++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.TypeChecking.Free.Base++import Agda.Utils.ExpandCase+import Agda.Utils.Lens+import Agda.Utils.List1 (List1, pattern (:|))+import Agda.Utils.Monad+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.StrictReader++--------------------------------------------------------------------------------++-- | Instances of 'ComputeFree' are inputs to the generic traveral implemented by 'Free' instances.+-- The @r@ type parameter denotes the 'Reader' environment of the traversal.+class (ExpandCase (Collect r), Monoid (Collect r)) => ComputeFree r where+ type Collect r+ -- ^ The result type of the traversal. Most commonly, this is either a newtype wrapper on 'Bool'+ -- or some instantiation of 'StrictEndo' from 'Agda.Utils.StrictEndo'. The latter is used to+ -- efficiently accummulate sets or maps.+ underBinders' :: Int -> r -> r+ -- ^ Update the environment when going under some number of binders.+ underConstructor' :: ConHead -> Elims -> r -> r+ -- ^ Update the environment when descending into the spine of a constructor.+ underModality' :: Maybe (Modality -> r -> r)+ -- ^ Update the environment when going under a modality. 'Nothing' has the identity action.+ underFlexRig' :: Maybe (FlexRig -> r -> r)+ -- ^ Update the environment when the rigidity of the current position changes, e.g. we switch to+ -- flexible mode when going into the spine of an unsolved metavariable. See the 'Free' instances+ -- for details. 'Nothing' has the identity action. NOTE: since 'Modality' contains 'FlexRig'+ -- information, if you implement a non-trivial 'FlexRig' update, you must also implement a+ -- non-trivial modality update, in order to handle the 'FlexRig'-s there!+ underRelevance' :: Maybe (Relevance -> r -> r)+ -- ^ Update the environment with relevance information. 'Nothing' has the identity action. NOTE:+ -- since 'Modality' contains relevances, if you implement non-trivial 'Relevance' update, you+ -- must also implement a non-trivial modality update, to handle the relevances there!+ variable' :: Int -> r -> Collect r+ -- ^ Evaluating a single variable. NOTE: you have to disambiguate bound and free variables yourself!+ -- For example, when we collect all free variables in a set, we need to store an 'Int' in the reader+ -- environment to keep track of the size of the local scope, which allows us to distinguish bound and+ -- free vars.+ ignoreSorts' :: IgnoreSorts+ -- ^ Do we want to skip over sorts of types?++ ignoreSorts' = IgnoreNot; {-# INLINE ignoreSorts' #-}+ underConstructor' _ _ r = r; {-# INLINE underConstructor' #-}+ underModality' = Nothing; {-# INLINE underModality' #-}+ underFlexRig' = Nothing; {-# INLINE underFlexRig' #-}+ underRelevance' = Nothing; {-# INLINE underRelevance' #-}++{-# INLINE underBinders #-}+underBinders :: ComputeFree r => Int -> Reader r (Collect r) -> Reader r (Collect r)+underBinders = local . underBinders'++{-# INLINE underBinder #-}+underBinder :: ComputeFree r => Reader r (Collect r) -> Reader r (Collect r)+underBinder = underBinders 1++{-# INLINE underConstructor #-}+underConstructor :: ComputeFree r => ConHead -> Elims -> Reader r (Collect r) -> Reader r (Collect r)+underConstructor hd es = local (underConstructor' hd es)++{-# INLINE underModality #-}+underModality :: ComputeFree r => Modality -> Reader r (Collect r) -> Reader r (Collect r)+underModality m act = case underModality' of+ Nothing -> act+ Just f -> local (f m) act++{-# INLINE underRelevance #-}+underRelevance :: ComputeFree r => Relevance -> Reader r (Collect r) -> Reader r (Collect r)+underRelevance rel act = case underRelevance' of+ Nothing -> act+ Just f -> local (f rel) act++{-# INLINE underFlexRig #-}+underFlexRig :: ComputeFree r => FlexRig -> Reader r (Collect r) -> Reader r (Collect r)+underFlexRig fr act = case underFlexRig' of+ Nothing -> act+ Just f -> local (f fr) act++{-# INLINE variable #-}+variable :: ComputeFree r => Int -> Reader r (Collect r)+variable x = variable' x <$!> ask++--------------------------------------------------------------------------------++class Free t where+ freeVars :: ComputeFree r => t -> Reader r (Collect r)++--------------------------------------------------------------------------------++instance Free Term where+ freeVars :: forall r. ComputeFree r => Term -> Reader r (Collect r)+ freeVars t = expand \ret ->++ let t' = case (underModality' @r, underFlexRig' @r) of+ (Nothing, Nothing) -> t+ _ -> unSpine t+ in case t' of+ Var n ts -> ret (variable n <> underFlexRig WeaklyRigid (freeVars ts))+ Def _ ts -> ret (underFlexRig WeaklyRigid $ freeVars ts)+ MetaV m ts -> ret (underFlexRig (Flexible (singleton m)) $ freeVars ts)++ -- λ is not considered guarding, as+ -- we cannot prove that x ≡ λy.x is impossible.+ Lam _ t -> ret (underFlexRig WeaklyRigid $ freeVars t)+ Lit _ -> ret mempty++ -- Because we are not in TCM+ -- we cannot query whether we are dealing with a data/record (strongly r.)+ -- or a definition by pattern matching (weakly rigid)+ -- thus, we approximate, losing that x = List x is unsolvable+ Con c _ ts -> ret (underConstructor c ts $ freeVars ts)+ -- Pi is not guarding, since we cannot prove that A ≡ B → A is impossible.+ -- Even as we do not permit infinite type expressions,+ -- we cannot prove their absence (as Set is not inductive).+ -- Also, this is incompatible with univalence (HoTT).++ -- András 2026-01-22: the above comment is wrong if we use occurrence computation in RHS unification+ Pi a b -> ret $ freeVars (a, b)+ Sort s -> ret $ underRelevance shapeIrrelevant (freeVars s)+ Level l -> ret $ freeVars l+ DontCare mt -> ret $ underModality (Modality irrelevant unitQuantity unitCohesion unitPolarity) $ freeVars mt+ Dummy{} -> ret $ mempty++instance Free t => Free (Elim' t) where+ freeVars e = expand \ret -> case e of+ Apply t -> ret $ freeVars t+ Proj{} -> ret $ mempty+ IApply x y r -> ret $ freeVars (x,y,r)++instance Free t => Free (Type' t) where+ freeVars :: forall r. ComputeFree r => Type' t -> Reader r (Collect r)+ freeVars ty = expand \ret -> case ty of+ El s t -> case ignoreSorts' @r of+ IgnoreNot -> ret $ freeVars (s, t)+ _ -> ret $ freeVars t++instance Free Sort where+ freeVars :: forall r. ComputeFree r => Sort -> Reader r (Collect r)+ freeVars s = expand \ret ->+ case ignoreSorts' @r of+ IgnoreAll -> ret mempty+ _ -> case s of+ Univ _ a -> ret $ freeVars a+ Inf _ _ -> ret $ mempty+ SizeUniv -> ret $ mempty+ LockUniv -> ret $ mempty+ LevelUniv -> ret $ mempty+ IntervalUniv -> ret $ mempty+ PiSort _c a s1 s2 -> ret $+ -- We ignore variables in the blocked dependency check+ underFlexRig (Flexible mempty) (freeVars $ unDom a) <>+ underFlexRig WeaklyRigid (freeVars (s1, s2))+ FunSort s1 s2 -> ret $ freeVars s1 <> freeVars s2+ UnivSort s -> ret $ underFlexRig WeaklyRigid $ freeVars s+ MetaS x es -> ret $ underFlexRig (Flexible $ singleton x) $ freeVars es+ DefS _ es -> ret $ underFlexRig WeaklyRigid $ freeVars es+ DummyS{} -> ret $ mempty++instance Free t => Free (Maybe t) where+ freeVars mt = expand \ret -> case mt of+ Nothing -> ret mempty+ Just t -> ret $ freeVars t++instance Free t => Free [t] where+ freeVars ts = expand \ret -> case ts of+ [] -> ret mempty+ t:ts -> ret $ freeVars t <> freeVars ts++instance Free t => Free (List1 t) where+ freeVars ts = expand \ret -> case ts of+ t :| ts -> ret $ freeVars t <> freeVars ts++instance (Free a, Free b) => Free (a, b) where+ {-# INLINE freeVars #-}+ freeVars ab = expand \ret -> case ab of (a, b) -> ret $ freeVars a <> freeVars b++instance (Free a, Free b, Free c) => Free (a, b, c) where+ {-# INLINE freeVars #-}+ freeVars abc = expand \ret -> case abc of (a, b, c) -> ret $ freeVars a <> freeVars b <> freeVars c++instance (Free a, Free b, Free c, Free d) => Free (a, b, c, d) where+ {-# INLINE freeVars #-}+ freeVars abc = expand \ret -> case abc of+ (a, b, c, d) -> ret $ freeVars a <> freeVars b <> freeVars c <> freeVars d++instance (Free a, Free b, Free c, Free d, Free e) => Free (a, b, c, d, e) where+ {-# INLINE freeVars #-}+ freeVars abc = expand \ret -> case abc of+ (a, b, c, d, e) -> ret $ freeVars a <> freeVars b <> freeVars c <> freeVars d <> freeVars e++instance Free Level where+ {-# INLINE freeVars #-}+ freeVars l = expand \ret -> case l of Max _ as -> ret $ freeVars as++instance Free t => Free (PlusLevel' t) where+ {-# INLINE freeVars #-}+ freeVars pl = expand \ret -> case pl of Plus _ l -> ret $ freeVars l++instance Free t => Free (Arg t) where+ {-# INLINE freeVars #-}+ freeVars t = expand \ret ->+ ret $ underModality (getModality t) $ freeVars $ unArg t++instance Free t => Free (Dom t) where+ {-# INLINE freeVars #-}+ freeVars d = expand \ret -> ret $ freeVars (domTactic d, unDom d)++instance Free t => Free (Abs t) where+ freeVars t = expand \ret -> case t of+ Abs _ b -> ret $ underBinder $ freeVars b+ NoAbs _ b -> ret $ freeVars b++instance Free t => Free (Tele t) where+ freeVars tel = expand \ret -> case tel of+ EmptyTel -> ret $ mempty+ ExtendTel t tel -> ret $ freeVars (t, tel)++instance Free Clause where+ freeVars cl = expand \ret ->+ ret $ underBinders (size $ clauseTel cl) $ freeVars $ clauseBody cl++instance Free EqualityView where+ freeVars ev = expand \ret -> case ev of+ OtherType t -> ret $ freeVars t+ IdiomType t -> ret $ freeVars t+ EqualityType _r s _eq l t a b -> ret $ freeVars (s, l, (t, a, b))++-- | Only computes free variables that are not pattern variables (see+-- 'nlPatVars')+-- i.e., those in a 'PTerm' or 'PBoundVar's from the local context.+instance Free NLPat where+ freeVars p = expand \ret -> case p of+ PVar{} -> ret $ mempty+ PDef _ es -> ret $ freeVars es+ PLam _ u -> ret $ freeVars u+ PPi a b -> ret $ freeVars (a,b)+ PSort s -> ret $ freeVars s+ PBoundVar x es -> ret $ variable x <> freeVars es+ PTerm t -> ret $ freeVars t++instance Free NLPType where+ freeVars :: forall r. ComputeFree r => NLPType -> Reader r (Collect r)+ freeVars t = expand \ret -> case t of+ NLPType s a -> case ignoreSorts' @r of+ IgnoreAll -> ret $ freeVars a+ _ -> ret $ freeVars (s, a)++instance Free NLPSort where+ freeVars :: forall r. ComputeFree r => NLPSort -> Reader r (Collect r)+ freeVars s = expand \ret -> case ignoreSorts' @r of+ IgnoreAll -> ret mempty+ _ -> case s of+ PUniv _ l -> ret $ freeVars l+ PInf f n -> ret $ mempty+ PSizeUniv -> ret $ mempty+ PLockUniv -> ret $ mempty+ PLevelUniv -> ret $ mempty+ PIntervalUniv -> ret $ mempty++instance Free RewriteHead where+ freeVars h = expand \ret -> case h of+ RewDefHead f -> ret mempty+ RewVarHead x -> ret $ variable x++instance Free RewriteRule where+ freeVars rew = expand \ret -> case rew of+ RewriteRule gamma h ps rhs b -> ret $+ freeVars gamma <> freeVars h <>+ underBinders (size gamma) (freeVars ps <> freeVars rhs <> freeVars b)++instance Free LocalEquation where+ freeVars eq = expand \ret -> case eq of+ LocalEquation gamma lhs rhs b -> ret $+ freeVars gamma <>+ underBinders (size gamma) (freeVars lhs <> freeVars rhs <> freeVars b)++{-# INLINE defaultUnderConstructor #-}+defaultUnderConstructor :: (Semigroup a, LensFlexRig r a) => ConHead -> Elims -> r -> r+defaultUnderConstructor c h = over lensFlexRig (composeFlexRig (constructorFlexRig c h))++{-# INLINE defaultUnderFlexRig #-}+defaultUnderFlexRig :: (Semigroup a, LensFlexRig r a) => Maybe (FlexRig' a -> r -> r)+defaultUnderFlexRig = Just \fr -> over lensFlexRig (composeFlexRig fr)++{-# INLINE defaultUnderModality #-}+defaultUnderModality :: LensModality r => Maybe (Modality -> r -> r)+defaultUnderModality = Just \m -> mapModality (composeModality m)++{-# INLINE defaultUnderRelevance #-}+defaultUnderRelevance :: LensRelevance r => Maybe (Relevance -> r -> r)+defaultUnderRelevance = Just \rel -> mapRelevance (composeRelevance rel)
@@ -0,0 +1,122 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wunused-imports #-}++#if __GLASGOW_HASKELL__ > 902+{-# OPTIONS_GHC -fworker-wrapper-cbv #-}+#endif++-- | Precompute free variables in a term (and store in 'ArgInfo').+module Agda.TypeChecking.Free.Precompute+ ( PrecomputeFreeVars, precomputeFreeVars+ , precomputedFreeVars, precomputeFreeVars_ ) where++import Agda.Utils.StrictWriter ( Writer, runWriter, censor, listen, tell )++import Agda.Utils.Singleton+import Agda.Utils.VarSet (VarSet)+import qualified Agda.Utils.VarSet as VarSet++import Agda.Syntax.Common+import Agda.Syntax.Internal++type FV = Writer VarSet++precomputeFreeVars_ :: PrecomputeFreeVars a => a -> a+precomputeFreeVars_ = fst . runWriter . precomputeFreeVars++precomputedFreeVars :: PrecomputeFreeVars a => a -> VarSet+precomputedFreeVars = snd . runWriter . precomputeFreeVars++class PrecomputeFreeVars a where+ precomputeFreeVars :: a -> FV a++ default precomputeFreeVars :: (Traversable c, PrecomputeFreeVars x, a ~ c x) => a -> FV a+ precomputeFreeVars = traverse precomputeFreeVars++-- The instances where things actually happen: Arg, Abs and Term.++maybePrecomputed :: PrecomputeFreeVars a => ArgInfo -> a -> FV (ArgInfo, a)+maybePrecomputed i x =+ case getFreeVariables i of+ KnownFVs fv -> (i, x) <$ tell fv+ UnknownFVs -> do+ (x', fv) <- listen $ precomputeFreeVars x+ return (setFreeVariables (KnownFVs fv) i, x')++instance PrecomputeFreeVars a => PrecomputeFreeVars (Arg a) where+ precomputeFreeVars arg@(Arg i x) = uncurry Arg <$> maybePrecomputed i x++-- Note that we don't store free variables in the Dom. The reason is that the+-- ArgInfo in the Dom tends to get reused during type checking for the argument+-- of that domain type, and it would be tedious and error prone to ensure that+-- we don't accidentally inherit also the free variables. Moreover we don't+-- really need the free variables of the Dom.+instance PrecomputeFreeVars a => PrecomputeFreeVars (Dom a) where++instance PrecomputeFreeVars a => PrecomputeFreeVars (Abs a) where+ precomputeFreeVars (NoAbs x b) = NoAbs x <$> precomputeFreeVars b+ precomputeFreeVars (Abs x b) =+ censor (VarSet.strengthen 1) $+ Abs x <$> precomputeFreeVars b++instance PrecomputeFreeVars Term where+ precomputeFreeVars t =+ case t of+ Var x es -> do+ tell (singleton x)+ Var x <$> precomputeFreeVars es+ Lam i b -> Lam i <$> precomputeFreeVars b+ Lit{} -> pure t+ Def f es -> Def f <$> precomputeFreeVars es+ Con c i es -> Con c i <$> precomputeFreeVars es+ Pi a b -> uncurry Pi <$> precomputeFreeVars (a, b)+ Sort s -> Sort <$> precomputeFreeVars s+ Level l -> Level <$> precomputeFreeVars l+ MetaV x es -> MetaV x <$> precomputeFreeVars es+ DontCare t -> DontCare <$> precomputeFreeVars t+ Dummy{} -> pure t++-- The other instances are boilerplate.++instance PrecomputeFreeVars Sort where+ precomputeFreeVars s =+ case s of+ Univ u a -> Univ u <$> precomputeFreeVars a+ Inf _ _ -> pure s+ SizeUniv -> pure s+ LockUniv -> pure s+ LevelUniv -> pure s+ IntervalUniv -> pure s+ PiSort c a s1 s2 -> PiSort c <$>+ precomputeFreeVars a <*>+ precomputeFreeVars s1 <*> precomputeFreeVars s2+ FunSort s1 s2 -> uncurry FunSort <$> precomputeFreeVars (s1, s2)+ UnivSort s -> UnivSort <$> precomputeFreeVars s+ MetaS x es -> MetaS x <$> precomputeFreeVars es+ DefS d es -> DefS d <$> precomputeFreeVars es+ DummyS{} -> pure s++instance PrecomputeFreeVars Level where+ precomputeFreeVars (Max n ls) = Max n <$> precomputeFreeVars ls++instance PrecomputeFreeVars PlusLevel where+ precomputeFreeVars (Plus n l) = Plus n <$> precomputeFreeVars l++instance PrecomputeFreeVars Type where+ precomputeFreeVars (El s t) = uncurry El <$> precomputeFreeVars (s, t)++-- Note: don't use default instance, since that bypasses the 'Arg' in 'Apply'.+instance PrecomputeFreeVars a => PrecomputeFreeVars (Elim' a) where+ precomputeFreeVars e =+ case e of+ Apply x -> Apply <$> precomputeFreeVars x+ IApply a x y -> IApply <$> precomputeFreeVars a <*> precomputeFreeVars x <*> precomputeFreeVars y+ Proj{} -> pure e++-- The very boilerplate instances++instance PrecomputeFreeVars a => PrecomputeFreeVars [a] where+instance PrecomputeFreeVars a => PrecomputeFreeVars (Maybe a) where++instance (PrecomputeFreeVars a, PrecomputeFreeVars b) => PrecomputeFreeVars (a, b) where+ precomputeFreeVars (x, y) = (,) <$> precomputeFreeVars x <*> precomputeFreeVars y
@@ -0,0 +1,258 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE MagicHash #-}+{-# OPTIONS_GHC -Wunused-imports #-}+{-# OPTIONS_GHC -Wno-redundant-bang-patterns #-}++#if __GLASGOW_HASKELL__ > 902+{-# OPTIONS_GHC -fworker-wrapper-cbv #-}+#endif++-- | Free variable check that reduces the subject to make certain variables not+-- free. Used when pruning metavariables in Agda.TypeChecking.MetaVars.Occurs.+module Agda.TypeChecking.Free.Reduce+ ( ForceNotFree+ , forceNotFree+ , forceNonDep+ , forceNonDepSort+ , reallyFree+ , IsFree(..)+ , nonFreeVars+ ) where++import Prelude hiding (null)++import Data.Maybe+import qualified Data.IntMap.Strict as IntMap+import Data.IntMap.Strict (IntMap)+import GHC.Exts++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Free+import Agda.TypeChecking.Free.Base (constructorFlexRig, addFlexRig, oneFlexRig)+import Agda.TypeChecking.Free.Precompute++import qualified Agda.Utils.VarSet as VarSet+import Agda.Utils.VarSet (VarSet)+import Agda.Utils.StrictState+import Agda.Utils.StrictReader+import Agda.Utils.ExpandCase+import Agda.Utils.Singleton+import Agda.Utils.Impossible+++-- | A variable can either not occur (`NotFree`) or it does occur+-- (`MaybeFree`). In the latter case, the occurrence may disappear+-- depending on the instantiation of some set of metas.+data IsFree+ = MaybeFree FlexRig+ | NotFree+ deriving (Eq, Show)++-- local scope size, VarSet to enforce not occurring, FlexRig we're under, ReduceEnv+-- András, 2026-02-12: the ReduceEnv is put in the FREnv because I don't want to bother+-- fixing GHC code generation (i.e. not returning closures from case splits) for ReduceM.+data FREnv = FREnv Int VarSet FlexRig ReduceEnv++-- This is equivalent to IntMap IsFree, where the NotFree cases are factored out into+-- a VarSet for efficiency.+data FRState = FRState VarSet (IntMap FlexRig)+type FreeRed = StateT FRState (Reader FREnv)++{-# SPECIALIZE forceNotFree :: VarSet -> Term -> ReduceM (IntMap IsFree, Term) #-}+-- | Try to enforce a set of variables not occurring in a given+-- type. Returns a possibly reduced version of the type and for each+-- of the given variables whether it is either not free, or+-- maybe free depending on some metavariables.+forceNotFree :: (ForceNotFree a, Reduce a) => VarSet -> a -> ReduceM (IntMap IsFree, a)+forceNotFree xs a = ReduceM \env ->+ let (a', FRState notfree mxs) =+ runReader (runStateT (forceNotFreeR $ precomputeFreeVars_ a) (FRState xs mempty))+ (FREnv 0 xs oneFlexRig env) in+ let mxs' = VarSet.foldl' (\k -> IntMap.insert k NotFree) (MaybeFree <$> mxs) notfree in+ (mxs', a')++{-# SPECIALIZE reallyFree :: VarSet -> Term -> ReduceM (Either Blocked_ (Maybe Term)) #-}+-- | Checks if the given term contains any free variables that are in+-- the given set of variables, possibly reducing the term in the+-- process. Returns `Right Nothing` if there are such variables,+-- `Right (Just v')` if there are none (where v' is the possibly+-- reduced version of the given term) or `Left b` if the problem is+-- blocked on a meta.+reallyFree :: (Reduce a, ForceNotFree a) => VarSet -> a -> ReduceM (Either Blocked_ (Maybe a))+reallyFree xs v = do+ (mxs , v') <- forceNotFree xs v+ case IntMap.foldr pickFree NotFree mxs of+ MaybeFree (Flexible ms) -> do+ let !blocker = metaSetToBlocker ms+ pure $ Left $ Blocked blocker ()+ MaybeFree _ -> pure $ Right Nothing+ NotFree -> pure $ Right (Just v')+ where+ -- Check if any of the variables occur freely.+ pickFree :: IsFree -> IsFree -> IsFree+ pickFree (MaybeFree ms1) (MaybeFree ms2) = MaybeFree $! (ms1 `addFlexRig` ms2)+ pickFree f1 NotFree = f1+ pickFree NotFree f2 = f2++-- | Try to force a thing to no longer depend on the zero variable+-- Returns a possibly reduced version of the thing and whether the dependency+-- was successfully removed (i.e. the zero variable is still free)+forceNonDep :: (Reduce a, ForceNotFree a)+ => a -> ReduceM (IsFree, a)+forceNonDep x = do+ (fvm, x) <- forceNotFree (singleton 0) x+ pure (fromMaybe __IMPOSSIBLE__ $! IntMap.lookup 0 fvm, x)++-- | András 2026-02-24: we specialize this, because TypeChecking.Reduce imports it via the hs-boot+-- file, and if it's not specialized there, it is __impossible__ to specialzie by GHC.+forceNonDepSort :: Sort -> ReduceM (IsFree, Sort)+forceNonDepSort x = forceNonDep x++-- | Get the set of 'NotFree' variables from a variable map.+nonFreeVars :: IntMap IsFree -> VarSet+nonFreeVars =+ IntMap.foldlWithKey'+ (\acc k v -> case v of+ NotFree -> VarSet.insert k acc+ _ -> acc)+ mempty+++class (PrecomputeFreeVars a, Subst a) => ForceNotFree a where+ -- Reduce the argument if necessary, to make as many as possible of+ -- the variables in the state not free. Updates the state, marking+ -- the variables that couldn't be make not free as `MaybeFree`. By+ -- updating the state as soon as a variable can not be reduced away,+ -- we avoid trying to get rid of it in other places.+ forceNotFree' :: a -> FreeRed a++{-# NOINLINE notFreeInPrecomputedSlow #-}+notFreeInPrecomputedSlow :: Int# -> VarSet -> VarSet -> Bool+notFreeInPrecomputedSlow locals xs precomp =+ VarSet.disjoint xs (VarSet.strengthen (I# locals) precomp)++{-# INLINE noFreeInPrecomputed #-}+noFreeInPrecomputed :: Int -> VarSet -> VarSet -> Bool+noFreeInPrecomputed (I# locals) xs precomp = case (xs, precomp) of+ -- fast path+ (VarSet.VS# xs, VarSet.VS# precomp) ->+ isTrue# ((xs `and#` (precomp `shiftRL#` locals)) `eqWord#` 0##)+ -- rare slow path+ _ -> notFreeInPrecomputedSlow locals xs precomp++{-# INLINE reduceIfFreeVars #-}+-- Reduce the argument if there are offending free variables. Doesn't call the+-- continuation when no reduction is required.+reduceIfFreeVars :: (Reduce a, ForceNotFree a) => (a -> FreeRed a) -> a -> FreeRed a+reduceIfFreeVars k = \a -> do+ FRState notfrees _ <- get+ FREnv locals _ _ env <- ask+ let fvs = precomputedFreeVars a+ if noFreeInPrecomputed locals notfrees fvs+ then pure a+ else k $ precomputeFreeVars_ (unReduceM (reduce a) env)++-- Careful not to define forceNotFree' = forceNotFreeR since that would loop.+forceNotFreeR :: (Reduce a, ForceNotFree a) => a -> FreeRed a+forceNotFreeR = reduceIfFreeVars forceNotFree'++{-# INLINE underFlexRig #-}+underFlexRig :: FlexRig -> FreeRed a -> FreeRed a+underFlexRig fr' = local \(FREnv x nfs fr e) -> FREnv x nfs (composeFlexRig fr' fr) e++{-# INLINE underConstructor #-}+underConstructor :: ConHead -> Elims -> FreeRed a -> FreeRed a+underConstructor c es = underFlexRig (constructorFlexRig c es)++instance (Reduce a, ForceNotFree a) => ForceNotFree (Arg a) where+ -- Precomputed free variables are stored in the Arg so reduceIf outside the+ -- traverse.+ forceNotFree' = reduceIfFreeVars (traverse forceNotFree')++instance (Reduce a, ForceNotFree a, TermSubst a) => ForceNotFree (Dom a) where+ forceNotFree' = traverse forceNotFreeR++instance (Reduce a, ForceNotFree a) => ForceNotFree (Abs a) where+ -- Reduction stops at abstractions (lambda/pi) so do reduceIf/forceNotFreeR here.+ forceNotFree' abs = expand \ret -> case abs of+ a@NoAbs{} -> ret $ traverse forceNotFreeR a+ a@(Abs x _) -> ret do+ let updEnv :: ReduceEnv -> ReduceEnv+ updEnv e = extendReduceEnv x __DUMMY_DOM__ e+ reduceIfFreeVars+ (local (\(FREnv x nfs fr e) -> FREnv (x + 1) nfs fr (updEnv e)) . traverse forceNotFree')+ a++instance ForceNotFree a => ForceNotFree [a] where+ forceNotFree' as = expand \ret -> case as of+ [] -> ret $ pure []+ (a:as) -> ret $ (:) <$> forceNotFree' a <*> forceNotFree' as++instance (Reduce a, ForceNotFree a) => ForceNotFree (Elim' a) where+ -- There's an Arg inside Elim' which stores precomputed free vars, so let's+ -- not skip over that.+ forceNotFree' e = expand \ret -> case e of+ Apply arg -> ret $ Apply <$> forceNotFree' arg+ e@Proj{} -> ret $ pure e+ IApply x y r -> ret $ IApply <$> forceNotFreeR x <*> forceNotFreeR y <*> forceNotFreeR r++instance ForceNotFree Type where+ forceNotFree' a = expand \ret -> case a of+ El s t -> ret $ El <$> forceNotFree' s <*> forceNotFree' t++instance ForceNotFree Term where+ forceNotFree' t = expand \ret -> case t of+ Var x es -> ret do+ FREnv locals wantToNotFree fr _ <- ask+ FRState xs frs <- get+ let x' = x - locals+ expand \ret -> if (x >= locals && VarSet.member x' wantToNotFree) then ret do+ put $! FRState (VarSet.delete x' xs) (IntMap.insert x' fr frs)+ Var x <$> underFlexRig WeaklyRigid (forceNotFree' es)+ else ret do+ Var x <$> underFlexRig WeaklyRigid (forceNotFree' es)+ Def f es -> ret $ Def f <$> underFlexRig WeaklyRigid (forceNotFree' es)+ Con c h es -> ret $ Con c h <$> underConstructor c es (forceNotFree' es)+ MetaV m es -> ret $ MetaV m <$> underFlexRig (Flexible (singleton m)) (forceNotFree' es)+ Lam h b -> ret $ Lam h <$> underFlexRig WeaklyRigid (forceNotFree' b)+ Pi a b -> ret $ Pi <$> forceNotFree' a <*> forceNotFree' b -- Dom and Abs do reduceIf so not needed here+ Sort s -> ret $ Sort <$> forceNotFree' s+ Level l -> ret $ Level <$> forceNotFree' l+ DontCare t -> ret $ DontCare <$> forceNotFreeR t -- Reduction stops at DontCare so reduceIf+ t@Lit{} -> ret $ pure t+ t@Dummy{} -> ret $ pure t++instance ForceNotFree Level where+ {-# INLINE forceNotFree' #-}+ forceNotFree' (Max m as) = Max m <$> forceNotFree' as++instance ForceNotFree PlusLevel where+ {-# INLINE forceNotFree' #-}+ forceNotFree' (Plus k a) = Plus k <$> forceNotFree' a++instance ForceNotFree Sort where+ -- Reduce for sorts already goes under all sort constructors, so we can get+ -- away without forceNotFreeR here.+ forceNotFree' s = expand \ret -> case s of+ Univ u l -> ret $ Univ u <$> forceNotFree' l+ PiSort c a s1 s2 -> ret do+ -- We ignore variables in the blocked dependency check+ a <- underFlexRig (Flexible mempty) (forceNotFree' a)+ (!s1, !s2) <- underFlexRig WeaklyRigid+ ((,) <$> forceNotFree' s1 <*> forceNotFree' s2)+ pure $ PiSort c a s1 s2+ FunSort a b -> ret $ FunSort <$> forceNotFree' a <*> forceNotFree' b+ UnivSort s -> ret $ UnivSort <$> underFlexRig WeaklyRigid (forceNotFree' s)+ MetaS x es -> ret $ MetaS x <$> underFlexRig (Flexible (singleton x)) (forceNotFree' es)+ DefS d es -> ret $ DefS d <$> underFlexRig WeaklyRigid (forceNotFree' es)+ s@(Inf _ _) -> ret $ pure s+ s@SizeUniv -> ret $ pure s+ s@LockUniv -> ret $ pure s+ s@LevelUniv -> ret $ pure s+ s@IntervalUniv -> ret $ pure s+ s@DummyS{} -> ret $ pure s
@@ -0,0 +1,13 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.Free.Reduce where++import Agda.Syntax.Internal (Sort)+import Agda.TypeChecking.Free.Base (FlexRig)+import Agda.TypeChecking.Monad.Base (ReduceM)++data IsFree+ = MaybeFree !FlexRig+ | NotFree++forceNonDepSort :: Sort -> ReduceM (IsFree, Sort)
@@ -0,0 +1,103 @@+{-# OPTIONS_GHC -Wunused-imports #-}++module Agda.TypeChecking.Functions+ ( etaExpandClause+ , getDef+ ) where++import Agda.Syntax.Common+import Agda.Syntax.Internal++import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Monad.Context+import Agda.TypeChecking.Monad.Debug+import Agda.TypeChecking.Monad.Pure+import Agda.TypeChecking.Level+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope++import Agda.Utils.Impossible+import Agda.Utils.Functor ( ($>) )+import Agda.Syntax.Common.Pretty ( prettyShow )+import Agda.Utils.Monad+import Agda.Utils.Size+import Agda.Utils.List+import Agda.Utils.Tuple ( first )++{-# SPECIALIZE etaExpandClause :: Clause -> TCM (Int, Clause) #-}+-- | Expand a clause to the maximal arity, by inserting variable patterns and applying the body to+-- variables. Return the arity and the expanded clause.++-- Fixes issue #2376.+-- Replaces 'introHiddenLambdas'.+-- See, e.g., test/Succeed/SizedTypesExtendedLambda.agda.++-- This is used instead of special treatment of lambdas+-- (which was unsound: Issue #121)++etaExpandClause :: PureTCM tcm => Clause -> tcm (Int, Clause)+etaExpandClause clause = do+ case clause of+ Clause _ _ ctel ps _ Nothing _ _ _ _ _ -> let !arity = length ps in pure (arity, clause)+ Clause _ _ ctel ps Nothing (Just t) _ _ _ _ _ -> let !arity = length ps in pure (arity, clause)+ Clause rl rf ctel ps (Just body) (Just t) catchall recursive unreachable ell wm -> do++ -- Get the telescope to expand the clause with.+ TelV tel0 t' <- addContext ctel $ telView $ unArg t++ -- If the rhs has lambdas, harvest the names of the bound variables.+ let xs = peekLambdas body+ let ltel = useNames xs $! telToList tel0+ let tel = telFromList ltel+ let n = size tel+ unless (n == size tel0) __IMPOSSIBLE__ -- useNames should not drop anything+ -- Join with lhs telescope, extend patterns and apply body.+ -- NB: no need to raise ctel!+ let ctel' = telFromList $! telToList ctel ++! ltel+ ps' = raise n ps ++! teleNamedArgs tel+ body' = raise n body `apply` teleArgs tel+ reportSDoc "term.clause.expand" 30 $ inTopContext $ vcat+ [ "etaExpandClause"+ , " body = " <+> addContext ctel' (prettyTCM body)+ , " xs = " <+> text (prettyShow xs)+ , " new tel = " <+> prettyTCM ctel'+ ]+ let !arity = length ps + size tel0+ pure (arity, Clause rl rf ctel' ps' (Just body') (Just (t $> t')) catchall recursive unreachable ell wm)+ where+ -- Get all initial lambdas of the body.+ peekLambdas :: Term -> [Arg ArgName]+ peekLambdas v =+ case v of+ Lam info b -> (Arg info (absName b) :) $! peekLambdas (unAbs b)+ _ -> []++ -- Use the names of the first argument, and set the Origin all other+ -- parts of the telescope to Inserted.+ -- The first list of arguments is a subset of the telescope.+ -- Thus, if compared pointwise, if the hiding does not match,+ -- it means we skipped an element of the telescope.+ useNames :: [Arg ArgName] -> ListTel -> ListTel+ useNames [] tel = map (setOrigin Inserted) tel+ -- Andrea: we can have more Lam's than Pi's, because they might be for Path+ -- Andreas, 2017-03-24: the following case is not IMPOSSIBLE when positivity checking comes before termination checking, see examples/tactics/ac/AC.agda+ useNames (_:_) [] = []+ useNames (x:xs) (dom:tel)+ | sameHiding x dom =+ -- set the ArgName of the dom+ fmap (first $ const $ unArg x) dom : useNames xs tel+ | otherwise =+ setOrigin Inserted dom : useNames (x:xs) tel++-- | Get the name of defined symbol of the head normal form of a term.+-- Returns 'Nothing' if no such head exists.++getDef :: Term -> TCM (Maybe QName)+getDef t = reduce t >>= \case+ Def d _ -> return $ Just d+ Lam _ v -> underAbstraction_ v getDef+ Level v -> getDef =<< reallyUnLevelView v+ DontCare v -> getDef v+ _ -> return Nothing
@@ -0,0 +1,1053 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-|++This module implements the type checking part of generalisable variables. When we get here we have+a type checking problem for a type (or telescope) containing a known set of generalisable variables+and we need to produce a well typed type (or telescope) with the correct generalisations. For instance,+given++@+variable+ A : Set+ n : Nat+ xs : Vec A n++foo : SomeType xs+@++generalisation should produce @{A : Set} {n : Nat} {xs : Vec A n} → SomeType xs@ for the type of+@foo@.++The functions 'generalizeType' and 'generalizeTelescope' don't have access to the abstract syntax to+be type checked (@SomeType xs@ in the example). Instead they are provided a type checking action+that delivers a 'Type' or a 'Telescope'. The challenge is setting up a context in which @SomeType+xs@ can be type checked successfully by this action, without knowing what the telescope of+generalised variables will be. Once we have computed this telescope the result needs to be+transformed into a well typed type abstracted over it.++__At no point are we allowed to cheat!__ Any transformation between well typed terms needs to be done+by well typed substitutions.++The key idea is to run the type checking action in the context of a single variable of an unknown+type. Once we know what variables to generalise over this type is instantiated to a fresh record+type with a field for each generalised variable. Turning the result of action into something valid+in the context of the generalised variables is then a simple substitution unpacking the record+variable.++In more detail, generalisation proceeds as follows:++- Add a variable @genTel@ of an unknown type to the context ('withGenRecVar').++@+ (genTel : _GenTel)+@++- Create metavariables for the generalisable variables appearing in the problem and their+ dependencies ('createGenValues'). In the example this would be++@+ (genTel : _GenTel) ⊢+ _A : Set+ _n : Nat+ _xs : Vec _A _n+@++- Run the type checking action ('createMetasAndTypeCheck'), binding the mentioned generalisable+ variables to the corresponding newly created metavariables. This binding is stored in+ 'eGeneralizedVars' and picked up in 'Agda.TypeChecking.Rules.Application.inferDef'++@+ (genTel : _GenTel) ⊢ SomeType (_xs genTel)+@++- Compute the telescope of generalised variables ('computeGeneralization'). This is done by taking+ the unconstrained metavariables created by 'createGenValues' or created during the type checking+ action and sorting them into a well formed telescope.++@+ {A : Set} {n : Nat} {xs : Vec A n}+@++- Create a record type @GeneralizeTel@ whose fields are the generalised variables and instantiate+ the type of @genTel@ to it ('createGenRecordType').++@+ record GeneralizeTel : Set₁ where+ constructor mkGeneralizeTel+ field+ A : Set+ n : Nat+ xs : Vec A n+@++- Solve the metavariables with their corresponding projections from @genTel@.++@+ _A := λ genTel → genTel .A+ _n := λ genTel → genTel .n+ _xs := λ genTel → genTel .xs+@++- Build the unpacking substitution ('unpackSub') that maps terms in @(genTel : GeneralizeTel)@ to+ terms in the context of the generalised variables by substituting a record value for @genTel@.++@+ {A : Set} {n : Nat} {xs : Vec A n} ⊢ [mkGeneralizeTel A n xs / genTel] : (genTel : GeneralizeTel)+@++- Build the final result by applying the unpacking substitution to the result of the type checking+ action and abstracting over the generalised telescope.++@+ {A : Set} {n : Nat} {xs : Vec A n} → SomeType (_xs (mkGeneralizeTel A n xs)) ==+ {A : Set} {n : Nat} {xs : Vec A n} → SomeType xs+@++- In case of 'generalizeType' return the resulting pi type.+- In case of 'generalizeTelescope' enter the resulting context, applying the unpacking substitution+ to let bindings (TODO #6916: and also module applications!) created in the telescope, and call the+ continuation.++-}++module Agda.TypeChecking.Generalize+ ( generalizeType+ , generalizeType'+ , generalizeTelescope ) where++import Prelude hiding (null)++import Control.Monad.Except ( MonadError(..) )++import Data.Set (Set)+import Data.Set qualified as Set+import Data.Map.Strict (Map)+import Data.Map.Strict qualified as Map+import Data.List (partition, sortBy)+import Data.Monoid++import Agda.Interaction.Options.Base++import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty (prettyShow, singPlural)+import Agda.Syntax.Concrete.Name (LensInScope(..))+import Agda.Syntax.Position+import Agda.Syntax.Info (MetaNameSuggestion)+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Generic+import Agda.Syntax.Internal.MetaVars+import Agda.Syntax.Scope.Monad (bindVariable, outsideLocalVars)+import Agda.Syntax.Scope.Base (BindingSource(..))+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Conversion+import Agda.TypeChecking.Free+import Agda.TypeChecking.InstanceArguments (postponeInstanceConstraints)+import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Warnings++import Agda.Benchmarking (Phase(Typing, Generalize))+import Agda.Utils.Benchmark+import qualified Agda.Utils.BiMap as BiMap+import Agda.Utils.Function+import Agda.Utils.Functor+import Agda.Utils.Impossible+import Agda.Utils.List+import qualified Agda.Utils.List1 as List1+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Null+import qualified Agda.Utils.Set1 as Set1+import Agda.Utils.Size+import Agda.Utils.Permutation+import qualified Agda.Utils.VarSet as VarSet++-- | Generalize a telescope over a set of generalizable variables.+generalizeTelescope :: Map QName Name -> (forall a. (Telescope -> TCM a) -> TCM a) -> ([Maybe Name] -> Telescope -> TCM a) -> TCM a+generalizeTelescope vars typecheckAction ret | Map.null vars = typecheckAction (ret [])+generalizeTelescope vars typecheckAction ret = billTo [Typing, Generalize] $ withGenRecVar $ \ genRecMeta -> do+ -- Andreas, May 2026, issue #6670:+ -- createMetasAndTypeCheck may add some new anonymous modules.+ anonymousModulesBefore <- viewTC eAnonymousModules+ let s = Map.keysSet vars+ ((cxtNames, tel, letbinds, anonymousModules), namedMetas, allmetas) <-+ createMetasAndTypeCheck s $ typecheckAction $ \ tel -> do+ xs <- take' (size tel) <$> getContextNames'+ lbs <- getLetBindings -- This gives let-bindings valid in the current context+ anons <- viewTC eAnonymousModules+ return (xs, tel, lbs, anons)+ let newAnonymousModules = take' (length anonymousModules - length anonymousModulesBefore) anonymousModules++ reportSDoc "tc.generalize.metas" 60 $ vcat+ [ "open metas =" <+> (text . show . fmap ((miNameSuggestion &&& miGeneralizable) . mvInfo)) (openMetas $ allmetas)+ ]+ -- Translate the QName to the corresponding bound variable+ (genTel, genTelNames, sub) <- computeGeneralization genRecMeta namedMetas allmetas++ let boundVar q = fromMaybe __IMPOSSIBLE__ $ Map.lookup q vars+ genTelVars = (map' . fmap) boundVar genTelNames++ tel' <- applySubst sub <$> instantiateFull tel++ -- This is not so nice. When changing the context from Γ (r : R) to Γ Δ we need to do this at the+ -- level of contexts (as a Context -> Context function), so we repeat the name logic here. Take+ -- care to preserve the name of named generalized variables.+ let cxtEntry (mname, dom) = do+ let s = fst $ unDom dom+ name <- maybe (setNotInScope <$> freshName_ s) return mname+ return $ CtxVar name (snd <$> dom)+ dropCxt err = updateContext (strengthenS err 1) (cxDrop 1)+ genTelCxt <- dropCxt __IMPOSSIBLE__ $ mapM cxtEntry $ reverse $ zip' genTelVars $ telToList genTel++ -- For the explicit module telescope we get the names from the typecheck+ -- action.+ let newTelCxt :: [ContextEntry]+ newTelCxt = zipWith' CtxVar cxtNames $ reverse $ map' (fmap snd) $ telToList tel'++ -- We are in context Γ (r : R) and should call the continuation in context Γ Δ Θρ passing it Δ Θρ+ -- We have+ -- Γ (r : R) ⊢ Θ Θ = tel+ -- Γ ⊢ Δ Δ = genTel+ -- Γ Δ ⊢ ρ : Γ (r : R) ρ = sub+ -- Γ ⊢ Δ Θρ Θρ = tel'+ -- And we shouldn't forget about the let-bindings (#3470)+ -- Γ (r : R) Θ ⊢ letbinds+ -- Γ Δ Θρ ⊢ letbinds' = letbinds(lift |Θ| ρ)+ letbinds' <- applySubst (liftS (size tel) sub) <$> instantiateFull letbinds+ -- And sections created by module applications in the telescope (#6916)+ -- Γ (r : R) ⊢ Σ Σ = sectionApps+ -- Γ Δ ⊢ Σρ+ let addLet (x, LetBinding isAxiom o v dom) = addLetBinding' isAxiom o x v dom+ updateContext sub (cxPrepend genTelCxt . cxDrop 1) $+ updateContext (raiseS (size tel')) (cxPrepend newTelCxt) $+ flip (foldr $ uncurry withAnonymousModule) newAnonymousModules $+ flip (foldr addLet) letbinds' $+ ret genTelVars $ abstract genTel tel'++-- | Generalize a type over a set of (used) generalizable variables.+generalizeType :: Set QName -> TCM Type -> TCM ([Maybe QName], Type)+generalizeType s typecheckAction = do+ (ns, t, _) <- generalizeType' s $ (,()) <$> typecheckAction+ return (ns, t)++-- | Allow returning additional information from the type checking action.+generalizeType' :: Set QName -> TCM (Type, a) -> TCM ([Maybe QName], Type, a)+generalizeType' s typecheckAction = billTo [Typing, Generalize] $ withGenRecVar $ \ genRecMeta -> do++ ((t, userdata), namedMetas, allmetas) <- createMetasAndTypeCheck s typecheckAction++ reportSDoc "tc.generalize.metas" 60 $ vcat+ [ "open metas =" <+> (text . show . fmap ((miNameSuggestion &&& miGeneralizable) . mvInfo)) (openMetas $ allmetas)+ ]++ (genTel, genTelNames, sub) <- computeGeneralization genRecMeta namedMetas allmetas++ t' <- abstract genTel . applySubst sub <$> instantiateFull t++ reportSDoc "tc.generalize" 40 $ vcat+ [ "generalized"+ , nest 2 $ "t =" <+> escapeContext impossible 1 (prettyTCM t') ]++ return (genTelNames, t', userdata)++-- | Create metas for the generalizable variables and run the type check action.+createMetasAndTypeCheck ::+ Set QName -> TCM a -> TCM (a, Map MetaId QName, LocalMetaStores)+createMetasAndTypeCheck s typecheckAction = do+ ((namedMetas, x), allmetas) <- metasCreatedBy $ do+ (metamap, genvals) <- createGenValues s+ x <- locallyTC eGeneralizedVars (const genvals) typecheckAction+ return (metamap, x)+ return (x, namedMetas, allmetas)++-- | Add a placeholder variable that will be substituted with a record value packing up all the+-- generalized variables.+withGenRecVar :: (Type -> TCM a) -> TCM a+withGenRecVar ret = do+ -- Create a meta type (in Set₀) for the telescope record. It won't+ -- necessarily fit in Set₀, but since it's only used locally the sort+ -- shouldn't matter. Another option would be to put it in Setω, which is a+ -- bit more honest, but this leads to performance problems (see #3306).+ genRecMeta <- newTypeMeta (mkType 0)+ addContext (defaultDom ("genTel" :: String, genRecMeta)) $ ret genRecMeta++-- | Compute the generalized telescope from metas created when checking the *thing* (type or telescope) to be+-- generalized. Called in the context extended with the telescope record variable (whose type is+-- the first argument). Returns the telescope of generalized variables and a substitution from+-- this telescope to the current context.+computeGeneralization+ :: Type+ -- ^ The metavariable to be instantiated with record type containing+ -- as fields the variables generalized in the *thing*.+ -> Map MetaId name+ -- ^ Metas created from an occurrence of a @variable@. (The original free variables.)+ -- E.g. if you have+ -- @+ -- variable l : Level; A : Set l+ -- postulate f : A → A+ -- @+ -- then @A@ would be in this @Map@, but not @l@.+ -> LocalMetaStores+ -- ^ The metas created when type-checking the *thing*.+ -> TCM (Telescope, [Maybe name], Substitution)+ -- ^ The telescope together with binder name (left-to-right order),+ -- and substitution from this telescope to the current context.+computeGeneralization genRecMeta nameMap allmetas = postponeInstanceConstraints $ do++ reportSDoc "tc.generalize" 10 $ "computing generalization for type" <+> prettyTCM genRecMeta++ -- Pair metas with their metaInfo+ let mvs :: [(MetaId, MetaVariable)]+ mvs = Map.assocs (openMetas allmetas) +++ Map.assocs (solvedMetas allmetas)++ -- Issue 4727: filter out metavariables that were created before the+ -- current checkpoint, since they are too old to be generalized.+ -- TODO: make metasCreatedBy smarter so it doesn't see pruned+ -- versions of old metas as new metas.+ cp <- viewTC eCurrentCheckpoint+ let isFreshMeta :: MonadReduce m => MetaVariable -> m Bool+ isFreshMeta mv = enterClosure mv $ \ _ -> isJust <$> checkpointSubstitution' cp+ mvs :: [(MetaId, MetaVariable)] <- filterM (isFreshMeta . snd) mvs++ cs <- (++) <$> useTC stAwakeConstraints+ <*> useTC stSleepingConstraints++ reportSDoc "tc.generalize" 50 $ "current constraints:" <?> vcat (map' prettyTCM cs)++ constrainedMetas <- Set.unions <$> mapM (constraintMetas . clValue . theConstraint) cs++ reportSDoc "tc.generalize" 30 $ nest 2 $+ "constrainedMetas = " <+> prettyList_ (map' prettyTCM $ Set.toList constrainedMetas)++ let isConstrained x = Set.member x constrainedMetas+ -- Note: Always generalize named metas even if they are constrained. We+ -- freeze them so they won't be instantiated by the constraint, and we do+ -- want the nice error from checking the constraint after generalization.+ -- See #3276.+ isGeneralizable (x, mv) = Map.member x nameMap ||+ not (isConstrained x) && NoGeneralize /= unArg (miGeneralizable (mvInfo mv))+ isSort = isSortMeta_ . snd+ isOpen = isOpenMeta . mvInstantiation . snd++ -- Split the generalizable metas in open and closed+ let (generalizable, nongeneralizable) = partition isGeneralizable mvs+ (generalizableOpen', generalizableClosed) = partition isOpen generalizable+ (openSortMetas, generalizableOpen) = partition isSort generalizableOpen'+ (nongeneralizableOpen, nongenClosed) = partition isOpen nongeneralizable++ reportSDoc "tc.generalize" 30 $ nest 2 $ vcat+ [ "generalizable = " <+> prettyList_ (map' (prettyTCM . fst) generalizable)+ , "generalizableOpen = " <+> prettyList_ (map' (prettyTCM . fst) generalizableOpen)+ , "nongenClosed = " <+> prettyList_ (map' (prettyTCM . fst) nongenClosed)+ , "openSortMetas = " <+> prettyList_ (map' (prettyTCM . fst) openSortMetas)+ ]++ -- Issue 3301: We can't generalize over sorts+ List1.unlessNull openSortMetas $ \ ms ->+ warning $ CantGeneralizeOverSorts $ Set1.fromList $ fmap fst ms++ -- Any meta in the solution of a generalizable meta should be generalized over (if possible).+ cp <- viewTC eCurrentCheckpoint+ let canGeneralize x | isConstrained x = return False+ canGeneralize x = do+ mv <- lookupLocalMeta x+ msub <- enterClosure mv $ \ _ ->+ checkpointSubstitution' cp+ let sameContext =+ -- We can only generalize if the metavariable takes the context variables of the+ -- current context as arguments. This happens either when the context of the meta+ -- is the same as the current context and there is no pruning, or the meta context+ -- is a weakening but the extra variables have been pruned.+ -- It would be possible to generalize also in the case when some context variables+ -- (other than genTel) have been pruned, but it's hard to construct an example+ -- where this actually happens.+ case (msub, mvPermutation mv) of+ (Just IdS, Perm m xs) -> xs == [0 .. m - 1]+ (Just (Wk n IdS), Perm m xs) -> xs == [0 .. m - n - 1]+ _ -> False+ unless sameContext $ reportSDoc "tc.generalize" 20 $ do+ ty <- getMetaType x+ let Perm m xs = mvPermutation mv+ vcat+ [ text "Don't know how to generalize over"+ , nest 2 $ prettyTCM x <+> text ":" <+> prettyTCM ty+ , text "in context"+ , nest 2 $ inTopContext . prettyTCM =<< getContextTelescope+ , text "permutation:" <+> text (show (m, xs))+ , text "subst:" <+> pretty msub ]+ return sameContext++ inherited :: Set MetaId <- Set.unions <$> forM generalizableClosed \ (x, mv) ->+ case mvInstantiation mv of+ InstV inst -> do+ parentName <- getMetaNameSuggestion x+ metas <- filterM canGeneralize . Set.toList .+ allMetas Set.singleton =<<+ instantiateFull (instBody inst)+ unless (null metas) do+ reportSDoc "tc.generalize" 40 $+ hcat ["Inherited metas from ", prettyTCM x, ":"] <?> prettyList_ (map' prettyTCM metas)+ -- #4291: Override existing meta name suggestion.+ -- Don't suggest names for explicitly named generalizable metas.+ case filter (`Map.notMember` nameMap) metas of+ -- If we solved the parent with a new meta use the parent name for that.+ [m] | MetaV{} <- instBody inst -> setMetaNameSuggestion m parentName+ -- Otherwise suffix with a number.+ ms -> zipWithM_ (\ i m -> setMetaNameSuggestion m (parentName ++! "." ++! show i)) [1..] ms+ return $ Set.fromList metas+ _ -> __IMPOSSIBLE__++ let (alsoGeneralize, reallyDontGeneralize) = partition (`Set.member` inherited) $ map' fst nongeneralizableOpen+ generalizeOver = map' fst generalizableOpen ++! alsoGeneralize+ shouldGeneralize = (generalizeOver `hasElem`)++ reportSDoc "tc.generalize" 30 $ nest 2 $ vcat+ [ "alsoGeneralize = " <+> prettyList_ (map' prettyTCM alsoGeneralize)+ , "reallyDontGeneralize = " <+> prettyList_ (map' prettyTCM reallyDontGeneralize)+ ]++ reportSDoc "tc.generalize" 10 $ "we're generalizing over" <+> prettyList_ (map' prettyTCM generalizeOver)++ -- Sort metas in dependency order. Include open metas that we are not+ -- generalizing over, since they will need to be pruned appropriately (see+ -- Issue 3672).+ allSortedMetas <- fromMaybeM (typeError GeneralizeCyclicDependency) $+ dependencySortMetas (generalizeOver ++! reallyDontGeneralize ++! map' fst openSortMetas)+ let sortedMetas = filter shouldGeneralize allSortedMetas++ let dropCxt err = updateContext (strengthenS err 1) (cxDrop 1)++ -- Create the pre-record type (we don't yet know the types of the fields)+ (genRecName, genRecCon, genRecFields) <- dropCxt __IMPOSSIBLE__ $+ createGenRecordType genRecMeta sortedMetas++ reportSDoc "tc.generalize" 30 $ vcat $+ [ "created genRecordType"+ , nest 2 $ "genRecName = " <+> prettyTCM genRecName+ , nest 2 $ "genRecCon = " <+> prettyTCM genRecCon+ , nest 2 $ "genRecFields = " <+> prettyList_ (map' prettyTCM genRecFields)+ ]++ -- Solve the generalizable metas. Each generalizable meta is solved by projecting the+ -- corresponding field from the genTel record.+ cxtTel <- getContextTelescope+ let solve m field = do+ reportSDoc "tc.generalize" 30 $ "solving generalized meta" <+>+ prettyTCM m <+> ":=" <+> prettyTCM (Var 0 [Proj ProjSystem field])+ -- m should not be instantiated, but if we don't check constraints+ -- properly it could be (#3666 and #3667). Fail hard instead of+ -- generating bogus types.+ whenM (isInstantiatedMeta m) __IMPOSSIBLE__+ assignTerm' m (telToArgs cxtTel) $ Var 0 [Proj ProjSystem field]+ zipWithM_ solve sortedMetas genRecFields++ -- Record the named variables in the telescope+ let telNames = map' (`Map.lookup` nameMap) sortedMetas++ -- Build the telescope of generalized metas+ teleTypes <- do+ args <- getContextArgs+ concat <$> forM sortedMetas \ m -> do+ mv <- lookupLocalMeta m+ let info =+ (hideOrKeepInstance $+ getArgInfo $ miGeneralizable $ mvInfo mv) { argInfoOrigin = Generalization }+ HasType{ jMetaType = t } = mvJudgement mv+ perm = mvPermutation mv+ t' <- piApplyM t $ permute (takeP (length args) perm) args+ return [(Arg info $ miNameSuggestion $ mvInfo mv, t')]+ let genTel = buildGeneralizeTel genRecCon teleTypes++ reportSDoc "tc.generalize" 40 $ vcat+ [ text "teleTypes =" <+> prettyTCM teleTypes+ , text "genTel =" <+> prettyTCM genTel+ ]++ -- Now we need to prune the unsolved metas to make sure they respect the new+ -- dependencies (#3672). Also update interaction points to point to pruned metas.+ let inscope (ii, InteractionPoint{ipMeta = Just x})+ | Map.member x (openMetas allmetas) ||+ Map.member x (solvedMetas allmetas) =+ Just (x, ii)+ inscope _ = Nothing+ ips :: Map MetaId InteractionId+ <- Map.fromDistinctAscList . mapMaybe inscope . fst . BiMap.toDistinctAscendingLists <$> useTC stInteractionPoints++ -- Andreas, 2026-05-05, issue #4228, issue #5831+ -- Replace genTel also in context of solved interaction points so that showing the goal in context+ -- does not leak internals of the generalization machinery.+ let closedIPMetas = filter (`Map.member` ips) $ map fst nongenClosed++ pruneUnsolvedMetas genRecName genRecCon genTel genRecFields ips shouldGeneralize $+ allSortedMetas ++! closedIPMetas++ -- Fill in the missing details of the telescope record.+ dropCxt __IMPOSSIBLE__ $ fillInGenRecordDetails genRecName genRecCon genRecFields genRecMeta genTel++ -- Now abstract over the telescope. We need to apply the substitution that subsitutes a record+ -- value packing up the generalized variables for the genTel variable.+ let sub = unpackSub genRecCon (map' (argInfo . fst) teleTypes) (length teleTypes)++ -- Instantiate all fresh meta-variables to get rid of+ -- __DUMMY_TERM__.+ genTel <- flip instantiateWhen genTel $ \m -> do+ mv <- lookupMeta m+ case mv of+ Nothing -> __IMPOSSIBLE__+ Just Left{} -> return False+ Just (Right mv) -> isFreshMeta mv++ return (genTel, telNames, sub)++-- | Prune unsolved metas (#3672). The input includes also the generalized metas and is sorted in+-- dependency order. The telescope is the generalized telescope.+pruneUnsolvedMetas :: QName -> ConHead -> Telescope -> [QName] -> Map MetaId InteractionId -> (MetaId -> Bool) -> [MetaId] -> TCM ()+pruneUnsolvedMetas genRecName genRecCon genTel genRecFields interactionPoints isGeneralized metas = do+ unless (all isGeneralized metas) $+ prune [] genTel metas+ where+ prune :: ListTel -> Telescope -> [MetaId] -> TCM ()+ prune _ _ [] = return ()+ prune cxt tel (x : xs) | not (isGeneralized x) = do+ -- If x is a blocked term we shouldn't instantiate it.+ whenM (not <$> isBlockedTerm x) $ do+ x <- if null tel then return x else prePrune x+ pruneMeta (telFromList $ reverse cxt) x+ prune cxt tel xs+ prune cxt (ExtendTel a tel) (x : xs) = prune (fmap (x,) a : cxt) (unAbs tel) xs+ where x = absName tel+ prune _ _ _ = __IMPOSSIBLE__++ sub = unpackSub genRecCon $ map' getArgInfo $ telToList genTel++ -- If one of the fields depend on this meta, we have to make sure that this meta doesn't depend+ -- on any variables introduced after the genRec. See test/Fail/Issue3672b.agda for a test case.+ prePrune :: MetaId -> TCM MetaId+ prePrune x = do+ cp <- viewTC eCurrentCheckpoint+ mv <- lookupLocalMeta x+ (i, _A) <- enterClosure mv $ \ _ -> do+ δ <- checkpointSubstitution cp+ _A <- case mvJudgement mv of+ IsSort{} -> return Nothing+ HasType{} -> Just <$> getMetaTypeInContext x+ case δ of+ Wk n IdS -> return (n, _A)+ IdS -> return (0, _A)+ _ -> typeError . GeneralizationPrepruneErrorRefinedContext =<< buildClosure x+ if i == 0 then return x else do+ reportSDoc "tc.generalize.prune.pre" 40 $ vcat+ [ "prepruning"+ , nest 2 $ pretty x <+> ":" <+> pretty (jMetaType $ mvJudgement mv)+ , nest 2 $ "|Δ| =" <+> pshow i ]++ -- We have+ -- Γ (r : GenRec) current context+ -- Γ (r : GenRec) Δ ⊢ x : A with |Δ| = i+ -- and we need to get rid of the dependency on Δ.++ -- We can only do this if A does not depend on Δ, so check this first.+ case VarSet.minView (freeVarSet _A) of+ Just (j, _) | j < i -> typeError . GeneralizationPrepruneErrorCyclicDependencies =<< buildClosure x+ _ -> return ()++ -- If it doesn't we can strengthen it to the current context (this is done by+ -- newMetaFromOld).+ -- Γ (r : GenRec) ⊢ ρ : Γ (r : GenRec) Δ+ let ρ = strengthenS impossible i+ ρ' = raiseS i++ (y, u) <- newMetaFromOld mv ρ _A++ let uρ' = applySubst ρ' u++ reportSDoc "tc.generalize.prune.pre" 40 $ nest 2 $ vcat+ [ "u =" <+> pretty u+ , "uρ⁻¹ =" <+> pretty uρ' ]++ -- To solve it we enter the context of x again+ enterClosure mv $ \ _ -> do+ -- v is x applied to the context variables+ v <- case _A of+ Nothing -> Sort . MetaS x . map' Apply <$> getMetaContextArgs mv+ Just{} -> MetaV x . map' Apply <$> getMetaContextArgs mv+ noConstraints (doPrune x mv _A v uρ') `catchError` \ _ ->+ typeError . GeneralizationPrepruneErrorFailedToInstantiate =<< buildClosure x+ setInteractionPoint x y+ return y++ pruneMeta :: Telescope -> MetaId -> TCM ()+ pruneMeta _Θ x = do+ cp <- viewTC eCurrentCheckpoint+ mv <- lookupLocalMeta x+ -- The reason we are doing all this inside the closure of x is so that if x is an interaction+ -- meta we get the right context for the pruned interaction meta.+ enterClosure mv $ \ _ ->+ -- If we can't find the generalized record, it's already been pruned and we don't have to do+ -- anything.+ whenJustM (findGenRec mv) $ \ i -> do++ reportSDoc "tc.generalize.prune" 30 $ vcat+ [ "pruning"+ , nest 2 $ inTopContext $ prettyTCM (mvJudgement mv)+ , nest 2 $ "GenRecTel is var" <+> pretty i ]++ _ΓrΔ <- getContextTelescope+ let (_Γ, _Δ) = (telFromList gs, telFromList ds)+ where (gs, _ : ds) = splitAt (size _ΓrΔ - i - 1) (telToList _ΓrΔ)++ -- Get the type of x. By doing this here we let the checkpoint machinery sort out the+ _A <- case mvJudgement mv of+ IsSort{} -> return Nothing+ HasType{} -> Just <$> getMetaTypeInContext x++ -- We have+ -- Γ (r : GenTel) Δ current context+ -- Γ₀ (r : GenTel) top context+ -- Γ₀ ⊢ Θ prefix of the generalized telescope currently in scope+ -- Γ (r : GenTel) Δ ⊢ x : A the meta to prune++ -- Get the substitution from the point of generalization to the current context. This always+ -- succeeds since if the meta depends on GenTel it must have been created inside the+ -- generalization:+ -- Γ (r : GenTel) Δ ⊢ δ : Γ₀ (r : GenTel)+ δ <- checkpointSubstitution cp++ -- v is x applied to the context variables+ v <- case _A of+ Nothing -> Sort . MetaS x . map' Apply <$> getMetaContextArgs mv+ Just{} -> MetaV x . map' Apply <$> getMetaContextArgs mv++ -- Now ultimately we want to create the fresh meta in the context+ -- Γ Θγ Δσ where Γ ⊢ γ : Γ₀+ -- Γ Θγ ⊢ σ : Γ (r : GenTel)+ -- σ is the unpacking substitution (which is polymorphic in Γ)+ let σ = sub (size _Θ)+ -- Γ <- Γ (r : GenTel) Δ <- Γ₀ (r : GenTel) <- Γ₀+ γ = strengthenS impossible (i + 1) `composeS` δ `composeS` raiseS 1+ _Θγ = applySubst γ _Θ+ _Δσ = applySubst σ _Δ++ -- The substitution into the new context is simply lifting σ over Δ:+ -- Γ Θγ Δσ ⊢ lift i σ : Γ (r : GenTel) Δ+ let ρ = liftS i σ+ -- We also need ρ⁻¹, which is a lot easier to construct.+ ρ' = liftS i $ [ Var 0 [Proj ProjSystem fld] | fld <- reverse $ take' (size _Θ) $ genRecFields ] ++# raiseS 1++ reportSDoc "tc.generalize.prune" 30 $ nest 2 $ vcat+ [ "Γ =" <+> pretty _Γ+ , "Θ =" <+> pretty _Θ+ , "Δ =" <+> pretty _Δ+ , "σ =" <+> pretty σ+ , "γ =" <+> pretty γ+ , "δ =" <+> pretty δ+ , "ρ =" <+> pretty ρ+ , "ρ⁻¹ =" <+> pretty ρ'+ , "Θγ =" <+> pretty _Θγ+ , "Δσ =" <+> pretty _Δσ+ , "_A =" <+> pretty _A+ ]++ -- When updating the context we also need to pick names for the variables. Get them from the+ -- current context and generate fresh ones for the generalized variables in Θ.+ (newCxt, rΘ) <- do+ (rΔ, CxExtend _ rΓ) <- cxSplitAt i <$> getContext+ let setName dom@(unDom -> (s,ty)) = CtxVar <$> freshName_ s <*> (pure $ dom $> ty)+ rΘ <- mapM setName $ reverse $ telToList _Θγ+ let rΔσ = zipWith' (\ name dom -> CtxVar name (snd <$> dom))+ (map' ctxEntryName rΔ)+ (reverse $ telToList _Δσ)+ return (cxPrepend rΔσ $ cxPrepend rΘ rΓ, rΘ)++ -- Now we can enter the new context and create our meta variable.+ (y, u) <- updateContext ρ (const newCxt) $ localScope $ do++ -- First, we add the named variables to the scope, to allow+ -- them to be used in holes (#3341). These should go outside Δ (#3735).+ outsideLocalVars i $ addNamedVariablesToScope rΘ++ -- Now we can create the new meta+ newMetaFromOld mv ρ _A++ -- Finally we solve x := yρ⁻¹. The reason for solving it this way instead of xρ := y is that+ -- ρ contains dummy terms for the variables that are not in scope.+ -- If x has been instantiated by some constraint unblocked by previous pruning or+ -- generalization, use equalTerm instead of assigning to x. If this fails (see+ -- test/Fail/Issue3655b.agda for a test case), we need to give an error. This can happen if+ -- there are dependencies between generalized variables that are hidden by constraints and+ -- the dependency sorting happens to pick the wrong order. For instance, if we have+ -- α : Nat (unsolved meta)+ -- t : F α (named variable)+ -- n : Nat (named variable)+ -- and a constraint F α == F n, where F does some pattern matching preventing the constraint+ -- to be solved when n is still a meta. If t appears before n in the type these will be sorted+ -- as α, t, n, but we will solve α := n before we get to the pruning here. It's good that we+ -- solve first though, because that means we can give a more informative error message than+ -- the "Cannot instantiate..." we would otherwise get.+ let uρ' = applySubst ρ' u+ reportSDoc "tc.generalize.prune" 80 $ vcat+ [ "solving"+ , nest 2 $ sep [ pretty v <+> "=="+ , pretty uρ' <+> ":"+ , pretty _A ] ]+ noConstraints (doPrune x mv _A v uρ') `catchError` niceError x v++ reportSDoc "tc.generalize.prune" 80 $ vcat+ [ "solved"+ , nest 2 $ "v =" <+> (pretty =<< instantiateFull v)+ , nest 2 $ "uρ⁻¹ =" <+> (pretty =<< instantiateFull uρ') ]++ setInteractionPoint x y++ findGenRec :: MetaVariable -> TCM (Maybe Int)+ findGenRec mv = do+ cxt <- instantiateFull =<< getContext+ let n = length cxt+ notPruned = VarSet.fromList $+ permute (takeP n $ mvPermutation mv) $+ downFrom n+ case [ i+ | (i, CtxVar _ ((unDom -> (El _ (Def q _))))) <-+ cxWithIndex (,) cxt+ , q == genRecName+ , i `VarSet.member` notPruned+ ] of+ [] -> return Nothing+ _:_:_ -> __IMPOSSIBLE__+ [i] -> return (Just i)+ -- Nothing if sort meta+ newMetaFromOld :: MetaVariable -> Substitution -> Maybe Type -> TCM (MetaId, Term)+ newMetaFromOld mv ρ mA = setCurrentRange mv $+ case mA of+ Nothing -> do+ s@(MetaS y _) <- newSortMeta+ return (y, Sort s)+ Just _A -> do+ let _Aρ = applySubst ρ _A+ newNamedValueMeta DontRunMetaOccursCheck+ (miNameSuggestion $ mvInfo mv)+ (jComparison $ mvJudgement mv) _Aρ++ -- If x is a hole, update the hole to point to y instead.+ setInteractionPoint :: MetaId -> MetaId -> TCM ()+ setInteractionPoint x y =+ whenJust (Map.lookup x interactionPoints) (`connectInteractionPoint` y)++ doPrune :: MetaId -> MetaVariable -> Maybe Type -> Term -> Term -> TCM ()+ doPrune x mv mt v u =+ case mt of+ _ | isOpen -> assign DirEq x (getArgs v) u $ maybe AsTypes AsTermsOf mt+ Nothing -> equalSort (unwrapSort v) (unwrapSort u)+ Just t -> equalTerm t v u+ where+ isOpen = isOpenMeta $ mvInstantiation mv+ getArgs = \case+ Sort (MetaS _ es) -> mustAllApplyElims es+ MetaV _ es -> mustAllApplyElims es+ _ -> __IMPOSSIBLE__+ unwrapSort (Sort s) = s+ unwrapSort _ = __IMPOSSIBLE__++ niceError :: MetaId -> Term -> TCErr -> TCM a+ niceError x u err = do+ u <- instantiateFull u+ let err' = case err of+ TypeError{tcErrClosErr = cl} ->+ -- Remove the 'when' part from the error since it's most like the same as ours.+ err { tcErrClosErr = cl{ clEnv = (clEnv cl) & eCall .~ Nothing }}+ _ -> err+ telList = telToList genTel+ names = map' (fst . unDom) telList+ late = map' (fst . unDom) $ filter (getAny . allMetas (Any . (== x))) telList+ projs (Proj _ q)+ | q `elem` genRecFields+ , Just y <- getGeneralizedFieldName q+ = Set.singleton y+ projs _ = Set.empty+ early = flip foldTerm u \case+ Var _ es -> foldMap projs es+ Def _ es -> foldMap projs es+ MetaV _ es -> foldMap projs es+ _ -> Set.empty+ commas [] = __IMPOSSIBLE__+ commas [x] = x+ commas [x, y] = x ++! ", and " ++! y+ commas (x : xs) = x ++! ", " ++! commas xs+ cause = "There were unsolved constraints that obscured the " +++ "dependencies between the generalized variables."+ solution = "The most reliable solution is to provide enough information to make the dependencies " +++ "clear, but simply mentioning the variables in the right order should also work."+ order = sep [ fwords "Dependency analysis suggested this (likely incorrect) order:",+ nest 2 $ fwords (unwords names) ]+ guess = unwords+ [ "After constraint solving it looks like", commas late+ , "actually"+ , singPlural late (<> "s") id "depend" -- NB: this is a singular "s"+ , "on", commas $ Set.toList early+ ]+ typeError . GeneralizationFailed =<< vcat+ [ fwords $ "Variable generalization failed."+ , nest 2 $ sep ["- Probable cause", nest 4 $ fwords cause]+ , nest 2 $ sep ["- Suggestion", nest 4 $ fwords solution]+ , nest 2 $ sep $ ["- Further information"+ , nest 2 $ "-" <+> order ] +++ [ nest 2 $ "-" <+> fwords guess | not (null late), not (null early) ] +++ [ nest 2 $ "-" <+> sep [ fwords "The dependency error is", prettyTCM err' ] ]+ ]++ addNamedVariablesToScope :: [ContextEntry] -> TCM ()+ addNamedVariablesToScope cxt =+ forM_ cxt $ \ (CtxVar x _) -> do+ -- Recognize named variables by lack of '.' (TODO: hacky!)+ reportSLn "tc.generalize.eta.scope" 40 $ "Adding (or not) " ++! prettyShow (nameConcrete x) ++! " to the scope"+ when ('.' `notElem` prettyShow (nameConcrete x)) $ do+ reportSLn "tc.generalize.eta.scope" 40 " (added)"+ bindVariable LambdaBound (nameConcrete x) x++-- | Create a substition from a context where the i first record fields are variables to a context+-- where you have a single variable of the record type. Packs up the field variables in a record+-- constructor and pads with __DUMMY_TERM__s for the missing fields. Important that you apply this+-- to terms that only projects the defined fields from the record variable.+-- Used with partial record values when building the telescope of generalized variables in which+-- case we have done the dependency analysis that guarantees it is safe.+unpackSub :: ConHead -> [ArgInfo] -> Int -> Substitution+unpackSub con infos i = recSub+ where+ ar = length infos+ appl info v = Apply (Arg info v)+ recVal = Con con ConOSystem $ zipWith' appl infos $ [var j | j <- [i - 1, i - 2..0]] ++! replicate (ar - i) __DUMMY_TERM__++ -- want: Γ Δᵢ ⊢ recSub i : Γ (r : R)+ -- have:+ -- Γ Δᵢ ⊢ recVal i :# σ : Θ (r : R), if Γ Δᵢ ⊢ σ : Θ+ -- Γ Δᵢ ⊢ WkS i IdS : Γ+ recSub = recVal :# Wk i IdS++-- | Takes the list of types+-- A₁ []+-- A₂ [r.f₁]+-- A₃ [r.f₂, r.f₃]+-- ...+-- And builds the telescope+-- (x₁ : A₁ [ r := c _ .. _ ])+-- (x₂ : A₂ [ r := c x₁ _ .. _ ])+-- (x₃ : A₃ [ r := c x₁ x₂ _ .. _ ])+-- ...+buildGeneralizeTel :: ConHead -> [(Arg MetaNameSuggestion, Type)] -> Telescope+buildGeneralizeTel con xs = go 0 xs+ where+ infos = map' (argInfo . fst) xs+ recSub i = unpackSub con infos i+ go _ [] = EmptyTel+ go i ((name, ty) : xs) = ExtendTel (dom ty') $ Abs (unArg name) $ go (i + 1) xs+ where ty' = applySubst (recSub i) ty+ dom = defaultNamedArgDom (getArgInfo name) (unArg name)++-- | Create metas for all used generalizable variables and their dependencies.+createGenValues ::+ Set QName+ -- ^ Possibly empty set of generalizable variables.+ -> TCM (Map MetaId QName, Map QName GeneralizedValue)+ -- ^ A bimap from generalizable variables to their metas.+createGenValues s = do+ genvals <- locallyTC eGeneralizeMetas (const YesGeneralizeVar) $+ forM (sortBy (compare `on` getRange) $ Set.toList s) \ x -> do+ (x,) <$> createGenValue x+ let metaMap = Map.fromListWith __IMPOSSIBLE__ [ (m, x) | (x, (m, _)) <- genvals ]+ nameMap = Map.fromListWith __IMPOSSIBLE__ [ (x, v) | (x, (_, v)) <- genvals ]+ return (metaMap, nameMap)++-- | Create a generalizable meta for a generalizable variable.+createGenValue ::+ QName+ -- ^ Name of a generalizable variable.+ -> TCM (MetaId, GeneralizedValue)+ -- ^ Generated metavariable and its representation as typed term.+createGenValue x = setCurrentRange x $ do+ cp <- viewTC eCurrentCheckpoint++ def <- instantiateDef =<< getConstInfo x+ let+ nGen = case theDef def of+ GeneralizableVar NoGeneralizableArgs -> 0+ GeneralizableVar (SomeGeneralizableArgs n) -> n+ _ -> __IMPOSSIBLE__++ ty = defType def+ TelV tel _ = telView' ty+ -- Generalizable variables are never explicit, so if they're given as+ -- explicit we default to hidden.+ argTel = telFromList $ map' hideExplicit $ take' nGen $ telToList tel++ args <- newTelMeta argTel+ metaType <- piApplyM ty args++ let name = prettyShow $ nameConcrete $ qnameName x+ (m, term) <- newNamedValueMeta DontRunMetaOccursCheck name CmpLeq metaType++ -- Freeze the meta to prevent named generalizable metas from being+ -- instantiated, and set the quantity of the meta to the declared+ -- quantity of the generalisable variable.+ updateMetaVar m $ \ mv ->+ setModality (getModality (defArgInfo def)) $+ mv { mvFrozen = Frozen }++ -- Set up names of arg metas+ forM_ (zip3 [1..] (map' unArg args) (telToList argTel)) $ \ case+ (i, MetaV m _, unDom -> (x, _)) -> do+ let suf "_" = show i+ suf "" = show i+ suf x = x+ setMetaNameSuggestion m (name ++! "." ++! suf x)+ _ -> return () -- eta expanded++ -- Update the ArgInfos for the named meta. The argument metas are+ -- created with the correct ArgInfo.+ setMetaGeneralizableArgInfo m $ hideExplicit (defArgInfo def)++ reportSDoc "tc.generalize" 50 $ vcat+ [ "created metas for generalized variable" <+> prettyTCM x+ , nest 2 $ "top =" <+> prettyTCM term+ , nest 2 $ "args =" <+> prettyTCM args ]++ case term of+ MetaV{} -> return ()+ _ -> typeError $ CannotGeneralizeEtaExpandable x metaType++ return . (m,) $ GeneralizedValue+ { genvalCheckpoint = cp+ , genvalTerm = term+ , genvalType = metaType+ }++ where+ hideExplicit :: LensHiding a => a -> a+ hideExplicit = applyWhenIts visible hide+++-- | Create a not-yet correct record type for the generalized telescope. It's not yet correct since+-- we haven't computed the telescope yet, and we need the record type to do it.+createGenRecordType :: Type -> [MetaId] -> TCM (QName, ConHead, [QName])+createGenRecordType genRecMeta@(El genRecSort _) sortedMetas = noMutualBlock $ do+ current <- currentModule+ let freshQName s = qualify current <$> freshName_ (s :: String)+ mkFieldName = freshQName . (generalizedFieldName ++) <=< getMetaNameSuggestion+ genRecFields <- mapM (defaultDom <.> mkFieldName) sortedMetas+ genRecName <- freshQName generalizeRecordName+ genRecCon <- freshQName generalizeConstructorName <&> \ con -> ConHead+ { conName = con+ , conDataRecord= IsRecord CopatternMatching+ , conInductive = Inductive+ , conIsHIT = NotHIT+ , conFields = map' argFromDom genRecFields+ }+ projIx <- succ . size <$> getContext+ erasure <- optErasure <$> pragmaOptions+ inTopContext $ forM_ (zip' sortedMetas genRecFields) $ \ (meta, fld) -> do+ fieldTy <- getMetaType meta+ let field = unDom fld+ addConstant' field (getArgInfo fld) fieldTy $ FunctionDefn $+ (emptyFunctionData_ erasure)+ { _funMutual = Just []+ , _funTerminates = Just True+ , _funProjection = Right Projection+ { projProper = Just genRecName+ , projOrig = field+ , projFromType = defaultArg genRecName+ , projIndex = projIx+ , projLams = ProjLams [defaultArg "gtel"]+ }+ }+ addConstant' (conName genRecCon) defaultArgInfo __DUMMY_TYPE__ $ -- Filled in later+ Constructor { conPars = 0+ , conArity = length genRecFields+ , conSrcCon = genRecCon+ , conData = genRecName+ , conAbstr = ConcreteDef+ , conPathCons = PointCons+ , conComp = emptyCompKit+ , conProj = Nothing+ , conForced = []+ , conErased = Nothing+ , conErasure = erasure+ , conInline = False+ }+ let dummyTel 0 = EmptyTel+ dummyTel n = ExtendTel (defaultDom __DUMMY_TYPE__) $ Abs "_" $ dummyTel (n - 1)+ addConstant' genRecName defaultArgInfo (sort genRecSort) $+ Record { recPars = 0+ , recClause = Nothing+ , recConHead = genRecCon+ , recNamedCon = False+ , recFields = genRecFields+ , recTel = dummyTel (length genRecFields) -- Filled in later+ , recMutual = Just []+ , recPositivityCheck = NoPositivityCheck+ , recEtaEquality' = EtaEquality YesEta EtaFromPragma+ , recPatternMatching = CopatternMatching+ , recInduction = Nothing+ , recTerminates = Just True -- not recursive+ , recAbstr = ConcreteDef+ , recComp = emptyCompKit+ }+ reportSDoc "tc.generalize" 20 $ vcat+ [ text "created genRec" <+> prettyList_ (map' (text . prettyShow . unDom) genRecFields) ]+ reportSDoc "tc.generalize" 80 $ vcat+ [ text "created genRec" <+> text (prettyShow genRecFields) ]+ -- Solve the genRecMeta+ args <- getContextArgs+ let genRecTy = El genRecSort $ Def genRecName $ map' Apply args+ noConstraints $ equalType genRecTy genRecMeta+ return (genRecName, genRecCon, map' unDom genRecFields)++-- | Once we have the generalized telescope we can fill in the missing details of the record type.+fillInGenRecordDetails :: QName -> ConHead -> [QName] -> Type -> Telescope -> TCM ()+fillInGenRecordDetails name con fields recTy fieldTel = do+ cxtTel <- fmap hideAndRelParams <$> getContextTelescope+ let fullTel = cxtTel `abstract` fieldTel+ -- Field types+ let mkFieldTypes [] EmptyTel = []+ mkFieldTypes (fld : flds) (ExtendTel ty ftel) =+ abstract cxtTel (El s $ Pi (defaultDom recTy) (Abs "r" $ unDom ty)) :+ mkFieldTypes flds (absApp ftel proj)+ where+ s = mkPiSort (defaultDom recTy) (Abs "r" $ unDom ty)+ proj = Var 0 [Proj ProjSystem fld]+ mkFieldTypes _ _ = __IMPOSSIBLE__+ let fieldTypes = mkFieldTypes fields (raise 1 fieldTel)+ reportSDoc "tc.generalize" 40 $ text "Field types:" <+> inTopContext (nest 2 $ vcat $ map' prettyTCM fieldTypes)+ zipWithM_ setType fields fieldTypes+ -- Constructor type+ let conType = fullTel `abstract` raise (size fieldTel) recTy+ reportSDoc "tc.generalize" 40 $ text "Final genRecCon type:" <+> inTopContext (prettyTCM conType)+ setType (conName con) conType+ -- Record telescope: Includes both parameters and fields.+ modifyGlobalDefinition name $ set (lensTheDef . lensRecord . lensRecTel) fullTel+ -- #7380: Also add clauses to the field definitions+ let n = length fields+ cpi = noConPatternInfo+ fldTys = map' (fmap snd . argFromDom) $ telToList fieldTel+ conPat = ConP con cpi $! map' (\(i, arg) -> fmap unnamed $ varP (DBPatVar "x" i) <$ arg) (zip' (downFrom n) fldTys)+ forM_ (zip3 (downFrom n) fields fldTys) \ (i, fld, fldTy) -> do+ modifyFunClauses fld \ _ ->+ [Clause+ { clauseLHSRange = noRange+ , clauseFullRange = noRange+ , clauseTel = fieldTel+ , namedClausePats = [defaultNamedArg conPat]+ , clauseBody = Just $ var i+ , clauseType = Just $ raise (i + 1) fldTy+ , clauseCatchall = empty+ , clauseRecursive = NotRecursive+ , clauseUnreachable = Just False+ , clauseEllipsis = NoEllipsis+ , clauseWhereModule = Nothing+ }]+ where+ setType q ty = modifyGlobalDefinition q $ \ d -> d { defType = ty }
@@ -0,0 +1,245 @@+{-# LANGUAGE NondecreasingIndentation #-}++module Agda.TypeChecking.IApplyConfluence where++import Prelude hiding (null, (!!)) -- do not use partial functions like !!++import Control.Monad.Except ( MonadError(..) )++import Data.Bifunctor (first, second)+import Data.DList (DList)+import Data.Foldable (toList)+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet++import Agda.Syntax.Common+import Agda.Syntax.Position+import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern++import Agda.Interaction.Options++import Agda.TypeChecking.Primitive hiding (Nat)+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Records+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Rules.LHS (buildLHSSubstitutions)+import Agda.TypeChecking.Telescope.Path+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Conversion.Errors+import Agda.TypeChecking.Conversion+import Agda.TypeChecking.Substitute++import Agda.Utils.Monad+import Agda.Utils.Null+import Agda.Utils.Maybe+import Agda.Utils.Singleton+import Agda.Utils.Size+import Agda.Utils.Impossible+import Agda.Utils.Functor+++checkIApplyConfluence_ :: QName -> TCM ()+checkIApplyConfluence_ f = whenM (isJust <$> cubicalOption) $ do+ -- Andreas, 2019-03-27, iapply confluence should only be checked+ -- when --cubical[={full,erased}] is active. See+ -- test/Succeed/CheckIApplyConfluence.agda.+ -- We cannot reach the following crash point unless+ -- --cubical[={full,erased}] is active.+ __CRASH_WHEN__ "tc.cover.iapply.confluence.crash" 666+ reportSDoc "tc.cover.iapply" 10 $ text "Checking IApply confluence of" <+> pretty f+ inConcreteOrAbstractMode f $ \ d -> do+ case theDef d of+ Function{funClauses = cls', funCovering = cls} -> do+ reportSDoc "tc.cover.iapply" 10 $ text "length cls =" <+> pretty (length cls)+ when (null cls && any (not . null . iApplyVars . namedClausePats) cls') $+ __IMPOSSIBLE__+ unlessM (optKeepCoveringClauses <$> pragmaOptions) $+ modifySignature $ updateDefinition f $ updateTheDef+ $ updateCovering (const [])++ traceCall (CheckFunDefCall (getRange f) f False) $+ forM_ cls $ checkIApplyConfluence f+ _ -> return ()++-- | @checkIApplyConfluence f (Clause {namedClausePats = ps})@ checks that @f ps@+-- reduces in a way that agrees with @IApply@ reductions.+checkIApplyConfluence :: QName -> Clause -> TCM ()+checkIApplyConfluence f cl = case cl of+ Clause {clauseBody = Nothing} -> return ()+ Clause {clauseType = Nothing} -> __IMPOSSIBLE__+ -- Inserted clause, will respect boundaries whenever the+ -- user-written clauses do. Saves a ton of work!+ Clause {namedClausePats = ps} | hasDefP ps -> pure ()+ cl@Clause { clauseTel = clTel+ , namedClausePats = ps+ , clauseType = Just t+ , clauseBody = Just body+ } -> setCurrentRange (clauseLHSRange cl) $ do+ let+ trhs = unArg t+ oldCall <- viewTC eCall+ reportSDoc "tc.cover.iapply" 40 $ "tel =" <+> prettyTCM clTel+ reportSDoc "tc.cover.iapply" 40 $ "ps =" <+> pretty ps+ ps <- normaliseProjP ps+ cxt <- getContext+ clCxt <- inTopContext $ addContext clTel $ getContext+ let (_, clSub) = buildLHSSubstitutions cxt ps NoWithFunction+ forM_ (iApplyVars ps) $ \ i -> do+ unview <- intervalUnview'+ let phi = unview $ IMax (argN $ unview (INeg $ argN $ var i)) $ argN $ var i+ let es = patternsToElims ps+ let lhs = Def f es++ reportSDoc "tc.cover.iapply" 40 $ text "clause:" <+> pretty ps <+> "->" <+> pretty body+ reportSDoc "tc.cover.iapply" 20 $ "body =" <+> prettyTCM body+ inTopContext $ reportSDoc "tc.cover.iapply" 20 $ "Γ =" <+> prettyTCM clTel++ let+ k :: Substitution -> Comparison -> Type -> Term -> Term -> TCM ()+ -- TODO (Amy, 2023-07-08): Simplifying the LHS of a+ -- generated clause in its context is loopy, see #6722+ k phi cmp ty u v | hasDefP ps = compareTerm cmp ty u v+ k phi cmp ty u v = do+ u_e <- simplify u+ -- Issue #6725: Print these terms in their own TC state.+ -- If printing the values before entering the conversion+ -- checker is too expensive then we could save the TC+ -- state and print them when erroring instead, but that+ -- might cause space leaks.+ (u_p, v_p) <- (,) <$> prettyTCM u_e <*> (prettyTCM =<< simplify v)++ let+ -- Make note of the context (literally): we're+ -- checking that this specific clause in f is+ -- confluent with IApply reductions. That way if we+ -- can tell the user what the endpoints are.+ why = CheckIApplyConfluence+ (getRange cl) f+ (applySubst phi lhs)+ u_e v ty++ -- But if the conversion checking failed really early, we drop the extra+ -- information. In that case, it's just noise.+ maybeDropCall e@(TypeError loc s err)+ | ConversionError_ (ConversionError _ _ u' v' _) <- clValue err =+ -- Issue #6725: restore the TC state from the+ -- error before dealing with the stored terms.+ withTCState (const s) $ enterClosure err $ \e' -> do+ u' <- prettyTCM =<< simplify u'+ v' <- prettyTCM =<< simplify v'++ -- Specifically, we compare how the things are pretty-printed, to avoid+ -- double-printing, rather than a more refined heuristic, since the+ -- “failure case” here is *at worst* accidentally reminding the user of how+ -- IApplyConfluence works.+ if (u_p == u' && v_p == v')+ then localTC (set eCall oldCall) $ typeError e'+ else throwError e+ maybeDropCall x = throwError x++ -- Note: Any postponed constraint with this call *will* have the extra+ -- information. This is a feature: if the constraint is woken up later,+ -- then it's probably a good idea to remind the user of what's going on,+ -- instead of presenting a mysterious error.+ traceCall why (compareTerm cmp ty u v `catchError` maybeDropCall)++ updateContext clSub (const clCxt) $+ compareTermOnFace' k CmpEq phi trhs lhs body++-- | current context is of the form Γ.Δ+unifyElims :: Args+ -- ^ variables to keep Γ ⊢ x_n .. x_0 : Γ+ -> Args+ -- ^ variables to solve Γ.Δ ⊢ ts : Γ+ -> (Substitution -> [(Term,Term)] -> TCM a)+ -- Γ.Δ' ⊢ σ : Γ.Δ+ -- Γ.Δ' new current context.+ -- Γ.Δ' ⊢ [(x = u)]+ -- Γ.Δ', [(x = u)] ⊢ id_g = ts[σ] : Γ+ -> TCM a+unifyElims vs ts k = do+ dom <- getContext+ let (binds' , eqs' ) = candidate (map unArg vs) (map unArg ts)+ (binds'', eqss') =+ unzip $+ map (\(j, tts) -> case toList tts of+ t : ts -> ((j, t), map (, var j) ts)+ [] -> __IMPOSSIBLE__) $+ IntMap.toList $ IntMap.fromListWith (<>) binds'+ cod' = codomain s (IntSet.fromList $ map fst binds'')+ cod = cod' dom+ svs = size vs+ binds = IntMap.fromList $+ map (second (raise (size cod - svs))) binds''+ eqs = map (first (raise (size dom - svs))) $+ eqs' ++ concat eqss'+ s = bindS binds+ updateContext s cod' $ k s (s `applySubst` eqs)+ where+ candidate :: [Term] -> [Term] -> ([(Nat, DList Term)], [(Term, Term)])+ candidate is ts = case (is, ts) of+ (i : is, Var j [] : ts) -> first ((j, singleton i) :) $+ candidate is ts+ (i : is, t : ts) -> second ((i, t) :) $+ candidate is ts+ ([], []) -> ([], [])+ _ -> __IMPOSSIBLE__++ bindS binds = parallelS $+ case IntMap.lookupMax binds of+ Nothing -> []+ Just (max, _) -> for [0 .. max] $ \i ->+ fromMaybe (deBruijnVar i) (IntMap.lookup i binds)++ codomain+ :: Substitution+ -> IntSet -- Support.+ -> Context -> Context+ codomain s vs = Context .+ mapMaybe (\(i, c) -> if i `IntSet.member` vs+ then Nothing+ else Just c) .+ cxWithIndex (\i c -> (i, dropS (i + 1) s `applySubst` c))++-- | Like @unifyElims@ but @Γ@ is from the meta's @MetaInfo@ and+-- the context extension @Δ@ is taken from the @Closure@.+unifyElimsMeta :: MetaId -> Args -> Closure Constraint -> ([(Term,Term)] -> Constraint -> TCM a) -> TCM a+unifyElimsMeta m es_m cl k = ifM (isNothing <$> cubicalOption) (enterClosure cl $ k []) $ do+ mv <- lookupLocalMeta m+ enterClosure (getMetaInfo mv) $ \ _ -> do -- mTel ⊢+ ty <- metaType m+ mTel0 <- getContextTelescope+ unless (size mTel0 == size es_m) $ reportSDoc "tc.iapply.ip.meta" 20 $ "funny number of elims" <+> text (show (size mTel0, size es_m))+ unless (size mTel0 <= size es_m) $ __IMPOSSIBLE__ -- meta has at least enough arguments to fill its creation context.+ reportSDoc "tc.iapply.ip.meta" 20 $ "ty: " <+> prettyTCM ty++ -- if we have more arguments we extend the telescope accordingly.+ TelV mTel1 _ <- telViewUpToPath (size es_m) ty+ addContext (mTel1 `apply` teleArgs mTel0) $ do+ mTel <- getContextTelescope+ reportSDoc "tc.iapply.ip.meta" 20 $ "mTel: " <+> prettyTCM mTel++ es_m <- return $ take (size mTel) es_m+ -- invariant: size mTel == size es_m++ (c,cxt) <- enterClosure cl $ \ c -> (c,) <$> getContextTelescope+ reportSDoc "tc.iapply.ip.meta" 20 $ prettyTCM cxt++ addContext cxt $ do++ reportSDoc "tc.iapply.ip.meta" 20 $ "es_m" <+> prettyTCM es_m++ reportSDoc "tc.iapply.ip.meta" 20 $ "trying unifyElims"++ unifyElims (teleArgs mTel) es_m $ \ sigma eqs -> do++ reportSDoc "tc.iapply.ip.meta" 20 $ "gotten a substitution"++ reportSDoc "tc.iapply.ip.meta" 20 $ "sigma:" <+> prettyTCM sigma+ reportSDoc "tc.iapply.ip.meta" 20 $ "sigma:" <+> pretty sigma++ k eqs (sigma `applySubst` c)
@@ -1,45 +1,269 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE PatternSynonyms #-} {-| Functions for inserting implicit arguments at the right places. -} module Agda.TypeChecking.Implicit where +import Prelude hiding (null)++import Control.Monad+import Control.Monad.Except+import Control.Monad.IO.Class++import Data.Bifunctor (first)++import Agda.Syntax.Position (HasRange, beginningOf, getRange) import Agda.Syntax.Common+import Agda.Syntax.Common.Pretty (prettyShow)+import Agda.Syntax.Abstract (Binder, mkBinder_)+import Agda.Syntax.Info ( MetaKind (InstanceMeta, UnificationMeta) )+import Agda.Syntax.Internal as I -#include "../undefined.h"+import Agda.TypeChecking.Irrelevance+import {-# SOURCE #-} Agda.TypeChecking.MetaVars+import {-# SOURCE #-} Agda.TypeChecking.Rules.Term (unquoteTactic)+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Pretty.Constraint () -- PrettyTCM Constraint instance only+import Agda.TypeChecking.Telescope++import Agda.Utils.Function (applyWhen, applyWhenJust)+import Agda.Utils.Functor+import Agda.Utils.List+import Agda.Utils.List qualified as List+import Agda.Utils.List1 (List1, pattern (:|))+import Agda.Utils.List1 qualified as List1+import Agda.Utils.Maybe+import Agda.Utils.Null+import Agda.Utils.Tuple+ import Agda.Utils.Impossible-import Control.Applicative +-- Cut and paste from insertImplicitPatternsT:++-- | Split a given Pi 'Type' until you reach the given named argument,+-- returning the number of arguments skipped to reach the right plicity+-- and name.+splitImplicitBinderT :: HasRange a => NamedArg a -> Type -> TCM (Telescope, Type)+splitImplicitBinderT narg ty = do+ -- Split off any invisible arguments at the front (so if the first+ -- argument is visible, return tel = EmptyTel)+ TelV tel ty0 <- telViewUpTo' (-1) (not . visible) ty++ case tel of+ -- If we didn't lob off any arguments then we can use the original+ -- type and the empty telescope+ EmptyTel -> pure (EmptyTel, ty)++ -- Otherwise we try inserting implicit arguments.+ _ -> setCurrentRange narg case insertImplicit narg $ telToList tel of+ BadImplicits -> typeError WrongHidingInLHS+ NoSuchName x xs -> typeError $ WrongNamedArgumentInLHS (getHiding narg) x xs+ ImpInsert doms ->+ let (here, there) = splitTelescopeAt (length doms) tel+ in pure (here, abstract there ty0)++-- | @implicitArgs n expand t@ generates up to @n@ implicit argument+-- metas (unbounded if @n<0@), as long as @t@ is a function type+-- and @expand@ holds on the hiding info of its domain.++implicitArgs ::+ Int -- ^ @n@, the maximum number of implicts to be inserted.+ -> (Hiding -> Bool) -- ^ @expand@, the predicate to test whether we should keep inserting.+ -> Type -- ^ The (function) type @t@ we are eliminating.+ -> TCM (Args, Type) -- ^ The eliminating arguments and the remaining type.+implicitArgs n expand t = first (map' (fmap namedThing)) <$> do+ implicitNamedArgs n (\ h _x -> expand h) t++-- | @implicitNamedArgs n expand t@ generates up to @n@ named implicit arguments+-- metas (unbounded if @n<0@), as long as @t@ is a function type+-- and @expand@ holds on the hiding and name info of its domain.++implicitNamedArgs ::+ Int -- ^ @n@, the maximum number of implicts to be inserted.+ -> (Hiding -> ArgName -> Bool) -- ^ @expand@, the predicate to test whether we should keep inserting.+ -> Type -- ^ The (function) type @t@ we are eliminating.+ -> TCM (NamedArgs, Type) -- ^ The eliminating arguments and the remaining type.+implicitNamedArgs n expand t0 = do+ (ncas, t) <- implicitCheckedArgs n expand t0+ let (ns, cas) = List.unzipWith (\ (Named n ca) -> (n, ca)) ncas+ es <- liftTCM $ noHeadConstraints cas+ let nargs = zipWith' (\ n (Arg ai v) -> Arg ai (Named n v)) ns (mustAllApplyElims es)+ return (nargs, t)++-- | Make sure there are no head constraints attached to the eliminations+-- and just return the eliminations.+noHeadConstraints :: [CheckedArg] -> TCM [Elim]+noHeadConstraints = mapM noHeadConstraint++noHeadConstraint :: CheckedArg -> TCM Elim+noHeadConstraint (CheckedArg elim _ Nothing) = return elim+noHeadConstraint (CheckedArg _ range Just{} ) = do+ setCurrentRange range do+ typeError $ NotSupported $+ "Lock constraints are not (yet) supported in this position."++-- | @implicitCheckedArgs n expand t@ generates up to @n@ named implicit arguments+-- metas (unbounded if @n<0@), as long as @t@ is a function type+-- and @expand@ holds on the hiding and name info of its domain.++implicitCheckedArgs ::+ Int -- ^ @n@, the maximum number of implicts to be inserted.+ -> (Hiding -> ArgName -> Bool) -- ^ @expand@, the predicate to test whether we should keep inserting.+ -> Type -- ^ The (function) type @t@ we are eliminating.+ -> TCM ([Named_ CheckedArg], Type)-- ^ The eliminating arguments and the remaining type.+implicitCheckedArgs 0 expand t0 = return ([], t0)+implicitCheckedArgs n expand t0 = do+ t0' <- reduce t0+ reportSDoc "tc.term.args" 30 $ "implicitCheckedArgs" <+> prettyTCM t0'+ reportSDoc "tc.term.args" 80 $ "implicitCheckedArgs" <+> text (show t0')+ case unEl t0' of+ Pi dom@(unDom -> a) b+ -- Pi dom@Dom{domInfo = info, domTactic = mtac, unDom = a} b+ | let x = bareNameWithDefault "_" dom, expand (getHiding (dom ^. dInfo)) x -> do+ kind <- if hidden (dom ^. dInfo) then return UnificationMeta else do+ reportSDoc "tc.term.args.ifs" 15 $+ "inserting instance meta for type" <+> prettyTCM a+ reportSDoc "tc.term.args.ifs" 40 $ nest 2 $ vcat+ [ "x = " <+> text (show x)+ , "hiding = " <+> text (show $ getHiding (dom ^. dInfo))+ ]++ return InstanceMeta+ (_, v) <- newMetaArg kind x CmpLeq dom+ whenJust (dom ^. dTactic) \ tac -> liftTCM do+ -- We don't need to do a full 'applyDomToContext' here.+ -- 'newMetaArg' already adds the local rewrite rule constraint+ applyModalityToContext dom $ unquoteTactic tac v a+ let name = Just $ WithOrigin Inserted $ unranged x+ mc <- liftTCM $ makeLockConstraint t0' v+ let carg = CheckedArg{ caElim = Apply (Arg (dom ^. dInfo) v), caRange = empty, caConstraint = mc }+ first (Named name carg :) <$> implicitCheckedArgs (n-1) expand (absApp b v)+ _ -> return ([], t0')++-- | @makeLockConstraint u funType@(El _ (Pi (Dom{ domInfo=info, unDom=a }) _))@+-- creates a @CheckLockedVars@ constraint for lock @u : a@+-- if @getLock info == IsLock _@.+--+-- Precondition: 'Type' is reduced.+makeLockConstraint :: Type -> Term -> TCM (Maybe (Abs Constraint))+makeLockConstraint funType u =+ case funType of+ El _ (Pi dom@(unDom -> a) _) -> do+ let+ x = maybe "t" prettyShow (dom ^. dName)+ mc = case getLock (dom ^. dInfo) of+ IsLock{} -> Just $ Abs x $+ CheckLockedVars (var 0) (raise 1 funType) (raise 1 $ Arg (dom ^. dInfo) u) (raise 1 a)+ IsNotLock -> Nothing+ whenJust mc \ c -> do+ reportSDoc "tc.term.lock" 40 do+ addContext (defaultDom $ funType) $ prettyTCM c+ return mc+ _ -> return Nothing++-- | Create a metavariable of 'MetaKind'.++newMetaArg ::+ MetaKind -- ^ Kind of meta.+ -> ArgName -- ^ Name suggestion for meta.+ -> Comparison -- ^ Check (@CmpLeq@) or infer (@CmpEq@) the type.+ -> Dom Type -- ^ Type of meta plus relevance and local rewrite info.+ -> TCM (MetaId, Term) -- ^ The created meta as id and as term.+newMetaArg kind x cmp a = do+ prp <- runBlocked $ isPropM a+ let irrelevantIfProp =+ applyWhen (prp == Right True) $ applyRelevanceToContext irrelevant+ applyDomToContext a $ irrelevantIfProp $+ newMeta (argNameToString x) kind (unDom a)+ where+ newMeta :: String -> MetaKind -> Type -> TCM (MetaId, Term)+ newMeta n = \case+ InstanceMeta -> newInstanceMeta n+ UnificationMeta -> newNamedValueMeta RunMetaOccursCheck n cmp++-- | Create a questionmark (always 'UnificationMeta').++newInteractionMetaArg+ :: ArgInfo -- ^ Relevance of meta.+ -> ArgName -- ^ Name suggestion for meta.+ -> Comparison -- ^ Check (@CmpLeq@) or infer (@CmpEq@) the type.+ -> Type -- ^ Type of meta.+ -> TCM (MetaId, Term) -- ^ The created meta as id and as term.+newInteractionMetaArg info x cmp a = do+ applyModalityToContext info $+ newNamedValueMeta' RunMetaOccursCheck (argNameToString x) cmp a++---------------------------------------------------------------------------++-- | Possible results of 'insertImplicit'. data ImplicitInsertion- = ImpInsert [Hiding] -- ^ this many implicits have to be inserted- | BadImplicits -- ^ hidden argument where there should have been a non-hidden arg- | NoSuchName String -- ^ bad named argument- | NoInsertNeeded+ = ImpInsert [Dom ()] -- ^ Success: this many implicits have to be inserted (list can be empty).+ | BadImplicits -- ^ Error: hidden argument where there should have been a non-hidden argument.+ | NoSuchName ArgName [ArgName]+ -- ^ Error: bad named argument.+ -- The list contains the names of the hidden arguments+ -- (with the same hiding as the given argument) available at this point. deriving (Show) -impInsert :: [Hiding] -> ImplicitInsertion-impInsert [] = NoInsertNeeded-impInsert hs = ImpInsert hs+pattern NoInsertNeeded :: ImplicitInsertion+pattern NoInsertNeeded = ImpInsert [] --- | The list should be non-empty.-insertImplicit :: NamedArg e -> [Arg String] -> ImplicitInsertion-insertImplicit _ [] = __IMPOSSIBLE__-insertImplicit a ts | argHiding a == NotHidden = impInsert $ nofHidden ts- where- nofHidden :: [Arg a] -> [Hiding]- nofHidden = takeWhile (NotHidden /=) . map argHiding-insertImplicit a ts =- case nameOf (unArg a) of- Nothing -> maybe BadImplicits impInsert $ upto (argHiding a) $ map argHiding ts- Just x -> find [] x (argHiding a) ts- where- upto h [] = Nothing- upto h (NotHidden:_) = Nothing- upto h (h':_) | h == h' = Just []- upto h (h':hs) = (h':) <$> upto h hs- find _ x _ (Arg NotHidden _ _ : _) = NoSuchName x- find hs x hidingx (Arg hidingy r y : ts)- | x == y && hidingx == hidingy = impInsert $ reverse hs- | x == y && hidingx /= hidingy = BadImplicits- | otherwise = find (hidingy:hs) x hidingx ts- find i x _ [] = NoSuchName x+-- | If the next given argument is @a@ and the expected arguments are @ts@+-- @insertImplicit' a ts@ returns the prefix of @ts@ that precedes @a@.+--+-- If @a@ is named but this name does not appear in @ts@, the 'NoSuchName' exception is thrown.+--+insertImplicit+ :: NamedArg e -- ^ Next given argument @a@.+ -> [Dom a] -- ^ Expected arguments @ts@.+ -> ImplicitInsertion+insertImplicit a doms = insertImplicit' a $+ for doms $ \ dom ->+ dom $> bareNameWithDefault "_" dom++-- | If the next given argument is @a@ and the expected arguments are @ts@+-- @insertImplicit' a ts@ returns the prefix of @ts@ that precedes @a@.+--+-- If @a@ is named but this name does not appear in @ts@, the 'NoSuchName' exception is thrown.+--+insertImplicit'+ :: NamedArg e -- ^ Next given argument @a@.+ -> [Dom ArgName] -- ^ Expected arguments @ts@.+ -> ImplicitInsertion+insertImplicit' _ [] = BadImplicits+insertImplicit' a ts++ -- If @a@ is visible, then take the non-visible prefix of @ts@.+ | visible a = ImpInsert $! takeWhile' notVisible $ map' void ts++ -- If @a@ is named, take prefix of @ts@ until the name of @a@ (with correct hiding).+ -- If the name is not found, throw exception 'NoSuchName'.+ | Just x <- bareNameOf a = maybe (NoSuchName x candidates) ImpInsert $+ takeHiddenUntil (\ t -> x == unDom t && sameHiding a t) ts++ -- If @a@ is neither visible nor named, take prefix of @ts@ with different hiding than @a@.+ | otherwise = maybe BadImplicits ImpInsert $+ takeHiddenUntil (sameHiding a) ts++ where+ -- The names of the hidden arguments of the right hiding+ -- before the next visible argument.+ candidates :: [ArgName]+ candidates =+ [ y | t <- takeWhile notVisible ts, sameHiding a t, let y = unDom t, y /= "_" ]++ -- @takeHiddenUntil p ts@ returns the 'getHiding' of the prefix of @ts@+ -- until @p@ holds or a visible argument is encountered.+ -- If @p@ never holds, 'Nothing' is returned.+ --+ -- Precondition: @p@ should imply @not . visible@.+ takeHiddenUntil :: (Dom ArgName -> Bool) -> [Dom ArgName] -> Maybe [Dom ()]+ takeHiddenUntil p ts =+ case ts2 of+ [] -> Nothing -- Predicate was never true+ (t : _) -> if visible t then Nothing else Just $! map' void ts1+ where+ (!ts1, !ts2) = break' (\ t -> p t || visible t) ts
@@ -1,247 +1,509 @@-{-# LANGUAGE CPP #-}+{- | +"Injectivity", or more precisely, "constructor headedness", is a+property of functions defined by pattern matching that helps us solve+constraints involving blocked applications of such functions.+"Blocked" shall mean here that pattern matching is blocked on a meta+variable, and constructor headedness lets us learn more about that+meta variable.++Consider the simple example:+@+ isZero : Nat -> Bool+ isZero zero = true+ isZero (suc n) = false+@+This function is constructor-headed, meaning that all rhss are headed+by a distinct constructor. Thus, on a constraint like+@+ isZero ?X = false : Bool+@+involving an application of @isZero@ that is blocked on meta variable @?X@,+we can exploit injectivity and learn that @?X = suc ?Y@ for a new+meta-variable @?Y@.++Which functions qualify for injectivity?++1. The function needs to have at least one non-absurd clause that has+a proper match, meaning that the function can actually be blocked on a+meta. Proper matches are these patterns:++ - data constructor (@ConP@, but not record constructor)+ - literal (@LitP@)+ - HIT-patterns (@DefP@)++Projection patterns (@ProjP@) are excluded because metas cannot occupy their place!++2. All the clauses that satisfy (1.) need to be headed by a distinct constructor.++-}+ module Agda.TypeChecking.Injectivity where -import Prelude hiding (mapM) import Control.Applicative-import Control.Monad hiding (mapM)-import Control.Monad.Error hiding (mapM)-import Control.Monad.State hiding (mapM)-import Control.Monad.Reader hiding (mapM)-import Data.Map (Map)+import Control.Monad.Except ( MonadError )+import Control.Monad.Trans.Maybe ( MaybeT(MaybeT), runMaybeT )+ import qualified Data.Map as Map import qualified Data.Set as Set import Data.Maybe-import Data.List-import Data.Traversable+import Data.Traversable hiding (for)+import Data.Foldable (fold) +import qualified Agda.Syntax.Abstract.Name as A import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Internal.Pattern++import Agda.TypeChecking.Conversion.Errors (failConversion)+import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Irrelevance (isIrrelevantOrPropM) import Agda.TypeChecking.Monad+import Agda.TypeChecking.Patterns.Match (properlyMatching') import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope.Path import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Primitive-import Agda.TypeChecking.MetaVars+import {-# SOURCE #-} Agda.TypeChecking.MetaVars import {-# SOURCE #-} Agda.TypeChecking.Conversion import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Polarity+import Agda.TypeChecking.Warnings++import Agda.Interaction.Options++import Agda.Utils.Either+import Agda.Utils.Functor import Agda.Utils.List+import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Permutation+import Agda.Syntax.Common.Pretty ( prettyShow )+import Agda.Interaction.Options.ProfileOptions qualified as Profile+import Agda.Utils.StrictReader+import Agda.Utils.StrictState -#include "../undefined.h" import Agda.Utils.Impossible --- | Reduce simple (single clause) definitions.-reduceHead :: Term -> TCM (Blocked Term)-reduceHead v = ignoreAbstractMode $ do- -- first, possibly rewrite literal v to constructor form- v <- constructorForm v- reportSDoc "tc.inj.reduce" 30 $ text "reduceHead" <+> prettyTCM v- case v of- Def f args -> do- def <- theDef <$> getConstInfo f- case def of--- Function{ funClauses = [ _ ] } -> unfoldDefinition False reduceHead v f args- Datatype{ dataClause = Just _ } -> unfoldDefinition False reduceHead v f args- Record{ recClause = Just _ } -> unfoldDefinition False reduceHead v f args- _ -> return $ notBlocked v- _ -> return $ notBlocked v- headSymbol :: Term -> TCM (Maybe TermHead)-headSymbol v = ignoreAbstractMode $ do- v <- ignoreBlocking <$> reduceHead v+headSymbol v = do -- ignoreAbstractMode $ do+ -- Andreas, 2013-02-18 ignoreAbstractMode leads to information leakage++ v <- constructorForm =<< ignoreBlocking <$> reduceHead v case v of Def f _ -> do- def <- theDef <$> getConstInfo f+ let yes = return $ Just $ ConsHead f+ no = return $ Nothing+ def <- theDef <$> do ignoreAbstractMode $ getConstInfo f+ -- Andreas, 2013-02-18+ -- if we do not ignoreAbstractMode here, abstract Functions get turned+ -- into Axioms, but we want to distinguish these. case def of- Datatype{} -> return (Just $ ConHead f)- Record{} -> return (Just $ ConHead f)+ Datatype{} -> yes+ Record{} -> yes+ DataOrRecSig{} -> yes Axiom{} -> do+ reportSLn "tc.inj.axiom" 50 $ "headSymbol: " ++ prettyShow f ++ " is an Axiom." -- Don't treat axioms in the current mutual block -- as constructors (they might have definitions we -- don't know about yet).- fs <- lookupMutualBlock =<< currentMutualBlock- if Set.member f fs- then return Nothing- else return (Just $ ConHead f)- _ -> return Nothing- Con c _ -> return (Just $ ConHead c)+ caseMaybeM (viewTC eMutualBlock) yes $ \ mb -> do+ fs <- mutualNames <$> lookupMutualBlock mb+ if Set.member f fs then no else yes+ Function{} -> no+ Primitive{} -> no+ PrimitiveSort{} -> no+ GeneralizableVar{} -> __IMPOSSIBLE__+ Constructor{} -> __IMPOSSIBLE__+ AbstractDefn{}-> __IMPOSSIBLE__+ -- Andreas, 2019-07-10, issue #3900: canonicalName needs ignoreAbstractMode+ Con c _ _ -> ignoreAbstractMode $ do+ q <- canonicalName (conName c)+ ifM (isPathCons q) (return Nothing) $+ {- else -} return $ Just $ ConsHead q Sort _ -> return (Just SortHead) Pi _ _ -> return (Just PiHead)- Lit _ -> return Nothing -- handle literal heads as well? can't think of- -- any examples where it would be useful...- _ -> return Nothing+ Var i [] -> return (Just $ VarHead i) -- Only naked variables. Otherwise substituting a neutral term is not guaranteed to stay neutral.+ Lit _ -> return Nothing -- TODO: LitHead (for literals with no constructorForm)+ Lam{} -> return Nothing+ Var{} -> return Nothing+ Level{} -> return Nothing+ MetaV{} -> return Nothing+ DontCare{} -> return Nothing+ Dummy s _ -> __IMPOSSIBLE_VERBOSE__ (show s) +-- | Is this a matchable definition, or constructor, which reduces based+-- on interval substitutions?+isUnstableDef :: PureTCM m => QName -> m Bool+isUnstableDef qn = do+ defn <- getConstInfo qn+ prims <- traverse getPrimitiveName'+ [ builtinHComp+ , builtinComp+ , builtinTrans+ , builtinGlue+ , builtin_glue+ , builtin_glueU ]+ case theDef defn of+ _ | (Just qn) `elem` prims -> pure True+ Function{funIsKanOp = Just _} -> pure True+ _ -> pure False+++-- | Do a full whnf and treat neutral terms as rigid. Used on the arguments to+-- an injective functions and to the right-hand side. Only returns+-- heads which are stable under interval substitution, i.e. NOT path+-- constructors or generated hcomp/transp!+headSymbol'+ :: (PureTCM m, MonadError TCErr m)+ => Term -> m (Maybe TermHead)+headSymbol' v = do+ v <- traverse constructorForm =<< reduceB v+ case v of+ Blocked{} -> return Nothing+ NotBlocked _ v -> case v of+ Def g _ ->+ ifM (isUnstableDef g)+ (pure Nothing)+ (pure . Just $ ConsHead g)+ Con c _ _ -> do+ q <- canonicalName (conName c)+ ifM (isPathCons q)+ (pure Nothing)+ (return $ Just $ ConsHead q)+ Var i _ -> return $ Just (VarHead i)+ Sort _ -> return $ Just SortHead+ Pi _ _ -> return $ Just PiHead+ Lit _ -> return Nothing+ Lam{} -> return Nothing+ Level{} -> return Nothing+ DontCare{} -> return Nothing+ MetaV{} -> __IMPOSSIBLE__+ Dummy s _ -> __IMPOSSIBLE_VERBOSE__ (show s)++-- | Does deBruijn variable i correspond to a top-level argument, and if so+-- which one (index from the left).+topLevelArg :: Clause -> Int -> Maybe TermHead+topLevelArg Clause{ namedClausePats = ps } i =+ case [ n | (n, VarP _ (DBPatVar _ j)) <- zip' [0..] $ map' namedArg ps, i == j ] of+ [] -> Nothing+ [n] -> Just (VarHead n)+ _:_:_ -> __IMPOSSIBLE__++-- | Join a list of inversion maps.+joinHeadMaps :: [InversionMap c] -> InversionMap c+joinHeadMaps = Map.unionsWith (<>)++-- | Update the heads of an inversion map.+updateHeads :: Monad m => (TermHead -> [c] -> m TermHead) -> InversionMap c -> m (InversionMap c)+updateHeads f m = joinHeadMaps <$> mapM f' (Map.toList m)+ where f' (h, c) = (`Map.singleton` c) <$> f h c+ checkInjectivity :: QName -> [Clause] -> TCM FunctionInverse-checkInjectivity f cs- | pointLess cs = return NotInjective+checkInjectivity f cs0 = do+ ifM (anyM properlyMatchingClause cs) {-then-} (checkInjectivity' f cs) {-else-} do+ reportSLn "tc.inj.check.pointless" 35 $+ "Injectivity of " ++ prettyShow (A.qnameToConcrete f) ++ " would be pointless."+ return NotInjective where- -- Is it pointless to use injectivity for this function?- pointLess [] = True- pointLess (_:_:_) = False- pointLess [Clause{clausePats = ps}] = all (noMatch . unArg) ps- where noMatch ConP{} = False- noMatch LitP{} = False- noMatch VarP{} = True- noMatch DotP{} = True-checkInjectivity f cs = do- reportSLn "tc.inj.check" 40 $ "Checking injectivity of " ++ show f- es <- concat <$> mapM entry cs- let (hs, ps) = unzip es- reportSLn "tc.inj.check" 40 $ " right hand sides: " ++ show hs- if all isJust hs && distinct hs- then do- let inv = Map.fromList (map fromJust hs `zip` ps)- reportSLn "tc.inj.check" 20 $ show f ++ " is injective."- reportSDoc "tc.inj.check" 30 $ nest 2 $ vcat $- map (\ (h, c) -> text (show h) <+> text "-->" <+>- fsep (punctuate comma $ map (text . show) $ clausePats c)- ) $ Map.toList inv- return $ Inverse inv- else return NotInjective+ -- We can filter out absurd clauses.+ cs = filter (isJust . clauseBody) cs0+ -- We cannot filter out clauses that have no proper match, because+ -- these could be catch-all clauses.+ -- However, we need at least one proper match to get injectivity started.+ properlyMatchingClause =+ anyM (properlyMatching' False False . namedArg) . namedClausePats++-- | Precondition: all the given clauses are non-absurd and contain a proper match.+checkInjectivity' :: QName -> [Clause] -> TCM FunctionInverse+checkInjectivity' f cs = fromMaybe NotInjective <.> runMaybeT $ do+ reportSLn "tc.inj.check" 40 $ "Checking injectivity of " ++ prettyShow f++ let varToArg :: Clause -> TermHead -> MaybeT TCM TermHead+ varToArg c (VarHead i) = MaybeT $ return $ topLevelArg c i+ varToArg _ h = return h++ -- We don't need to consider absurd clauses+ let computeHead c | hasDefP (namedClausePats c) = return []+ -- hasDefP clauses are skipped, these matter only for --cubical, in which case the function will behave as NotInjective.+ computeHead c@Clause{ clauseBody = Just body , clauseType = Just tbody } = addContext (clauseTel c) $ do+ maybeIrr <- fromRight (const True) <.> runBlocked $ isIrrelevantOrPropM tbody+ -- We treat ordinary clauses with IApply copatterns as *immediately*+ -- failing the injectivity check. Consider e.g.+ -- foo x = T+ -- foo (y i) = Glue U λ { (i = i0) → T , _ ; (i = i1) → T , _ }+ -- seeing foo α = Glue ... and inverting it to α = y β loses solutions. E.g. if we+ -- later had some other α = x, now we're screwed, x ≠ y β. But if we had postponed+ -- originally we'd just compare T = Glue ... which has a chance of going through.+ let ivars = iApplyVars (namedClausePats c)+ guard (null ivars)+ h <- if maybeIrr then return UnknownHead else+ varToArg c =<< do+ lift $ fromMaybe UnknownHead <$> do+ headSymbol body+ return [Map.singleton h [c]]+ computeHead _ = return []++ hdMap <- joinHeadMaps . concat <$> mapM computeHead cs++ case Map.lookup UnknownHead hdMap of+ Just (_:_:_) -> empty -- More than one unknown head: we can't really do anything in that case.+ _ -> return ()++ reportSLn "tc.inj.check" 20 $ prettyShow f ++ " is potentially injective."+ reportSDoc "tc.inj.check" 30 $ nest 2 $ vcat $+ for (Map.toList hdMap) $ \ (h, uc) ->+ text (prettyShow h) <+> "-->" <+>+ case uc of+ [c] -> prettyTCM $ map' namedArg $ namedClausePats c+ _ -> "(multiple clauses)"+ return $ Inverse hdMap++-- | If a clause is over-applied we can't trust the head (Issue 2944). For+-- instance, the clause might be `f ps = u , v` and the actual call `f vs+-- .fst`. In this case the head will be the head of `u` rather than `_,_`.+checkOverapplication+ :: forall m. (HasConstInfo m)+ => Elims -> InversionMap Clause -> m (InversionMap Clause)+checkOverapplication es = updateHeads overapplied where- entry c = do- mv <- rhs (clauseBody c)- case mv of- Nothing -> return []- Just v -> do- h <- headSymbol v- return [(h, c)]+ overapplied :: TermHead -> [Clause] -> m TermHead+ overapplied h cs | all (not . isOverapplied) cs = return h+ overapplied h cs = ifM (isSuperRigid h) (return h) (return UnknownHead) - rhs (Bind b) = underAbstraction_ b rhs- rhs (Body v) = return $ Just v- rhs NoBody = return Nothing+ -- A super-rigid head is one that can't be eliminated. Crucially, this is+ -- applied after instantiateVars, so VarHeads are really bound variables.+ isSuperRigid SortHead = return True+ isSuperRigid PiHead = return True+ isSuperRigid VarHead{} = return True+ isSuperRigid UnknownHead = return True -- or False, doesn't matter+ isSuperRigid (ConsHead q) = do+ def <- getConstInfo q+ return $ case theDef def of+ Axiom{} -> True+ DataOrRecSig{} -> True+ AbstractDefn{} -> True+ Function{} -> False+ Datatype{} -> True+ Record{} -> True+ Constructor{conSrcCon = ConHead{ conDataRecord = d, conFields = fs }}+ -> d == IsData || null fs -- Record constructors can be eliminated by projections+ Primitive{} -> False+ PrimitiveSort{} -> __IMPOSSIBLE__+ GeneralizableVar{} -> __IMPOSSIBLE__ --- | Argument should be on weak head normal form.-functionInverse :: Term -> TCM InvView-functionInverse v = case v of- Def f args -> do- d <- theDef <$> getConstInfo f- case d of- Function{ funInv = inv } -> case inv of- NotInjective -> return NoInv- Inverse m -> return $ Inv f args m- _ -> return NoInv++ isOverapplied Clause{ namedClausePats = ps } = length es > length ps++-- | Turn variable heads, referring to top-level argument positions, into+-- proper heads. These might still be `VarHead`, but in that case they refer to+-- deBruijn variables. Checks that the instantiated heads are still rigid and+-- distinct.+instantiateVarHeads+ :: forall m c. (PureTCM m, MonadError TCErr m)+ => QName -> Elims -> InversionMap c -> m (Maybe (InversionMap c))+instantiateVarHeads f es m = runMaybeT $ updateHeads (const . instHead) m+ where+ instHead :: TermHead -> MaybeT m TermHead+ instHead h@(VarHead i)+ | Just (Apply arg) <- es !!! i = MaybeT $ headSymbol' (unArg arg)+ | otherwise = empty -- impossible?+ instHead h = return h++-- | Argument should be in weak head normal form.+functionInverse+ :: (PureTCM m, MonadError TCErr m)+ => Term -> m InvView+functionInverse = \case+ Def f es -> do+ inv <- defInverse <$> getConstInfo f+ cubical <- cubicalOption+ -- Local rewrite rules do not update definitional injectivity/invertibility+ -- so we check if any are present+ rewr <- getLocalRewriteRulesFor $ RewDefHead f+ case inv of+ NotInjective -> return NoInv+ Inverse m | null rewr -> do+ maybe NoInv (Inv f es) <$>+ (traverse (checkOverapplication es) =<< instantiateVarHeads f es m)+ -- NB: Invertible functions are never classified as+ -- projection-like, so this is fine, we are not+ -- missing parameters. (Andreas, 2013-11-01)+ Inverse m -> return NoInv _ -> return NoInv -data InvView = Inv QName Args (Map TermHead Clause)+data InvView = Inv QName [Elim] (InversionMap Clause) | NoInv -useInjectivity :: Comparison -> Type -> Term -> Term -> TCM ()-useInjectivity cmp a u v = do- uinv <- functionInverse u- vinv <- functionInverse v- case (uinv, vinv) of- (Inv f fArgs _, Inv g gArgs _)- | f == g -> do- a <- defType <$> getConstInfo f- reportSDoc "tc.inj.use" 20 $ vcat- [ fsep (pwords "comparing application of injective function" ++ [prettyTCM f] ++- pwords "at")- , nest 2 $ fsep $ punctuate comma $ map prettyTCM fArgs- , nest 2 $ fsep $ punctuate comma $ map prettyTCM gArgs- , nest 2 $ text "and type" <+> prettyTCM a- ]- pol <- getPolarity' cmp f- compareArgs pol a (Def f []) fArgs gArgs- | otherwise -> fallBack- (Inv f args inv, NoInv) -> do- a <- defType <$> getConstInfo f- reportSDoc "tc.inj.use" 20 $ fsep $- pwords "inverting injective function" ++- [ prettyTCM f, text ":", prettyTCM a, text "for", prettyTCM v- , parens $ text "args =" <+> prettyList (map prettyTCM args)- ]- invert u f a inv args =<< headSymbol v- (NoInv, Inv g args inv) -> do- a <- defType <$> getConstInfo g- reportSDoc "tc.inj.use" 20 $ fsep $- pwords "inverting injective function" ++- [ prettyTCM g, text ":", prettyTCM a, text "for", prettyTCM u- , parens $ text "args =" <+> prettyList (map prettyTCM args)- ]- invert v g a inv args =<< headSymbol u- (NoInv, NoInv) -> fallBack+-- | Precondition: The first term must be blocked on the given meta and the second must be neutral.+useInjectivity :: CompareDirection -> Blocker -> CompareAs -> Term -> Term -> TCM ()+useInjectivity dir blocker ty blk neu = locallyTC eInjectivityDepth succ $ do+ inv <- functionInverse blk+ -- Injectivity might cause non-termination for unsatisfiable constraints+ -- (#431, #3067). Look at the number of active problems and the injectivity+ -- depth to detect this.+ nProblems <- Set.size <$> viewTC eActiveProblems+ injDepth <- viewTC eInjectivityDepth+ let depth = max nProblems injDepth+ maxDepth <- maxInversionDepth+ case inv of+ NoInv -> fallback -- not invertible+ Inv f blkArgs hdMap+ | depth > maxDepth -> warning (InversionDepthReached f) >> fallback+ | otherwise -> do+ reportSDoc "tc.inj.use" 30 $ fsep $+ pwords "useInjectivity on" +++ [ prettyTCM blk, prettyTCM cmp, prettyTCM neu, prettyTCM ty]+ whenProfile Profile.Conversion $ tick "compare by reduction: injectivity"+ let canReduceToSelf = Map.member (ConsHead f) hdMap || Map.member UnknownHead hdMap+ case neu of+ -- f us == f vs <=> us == vs+ -- Crucially, this relies on `f vs` being neutral and only works+ -- if `f` is not a possible head for `f us`.+ Def f' neuArgs | f == f', not canReduceToSelf -> do+ fTy <- defType <$> getConstInfo f+ reportSDoc "tc.inj.use" 20 $ vcat+ [ fsep (pwords "comparing application of injective function" ++ [prettyTCM f] +++ pwords "at")+ , nest 2 $ fsep $ punctuate comma $ map' prettyTCM blkArgs+ , nest 2 $ fsep $ punctuate comma $ map' prettyTCM neuArgs+ , nest 2 $ "and type" <+> prettyTCM fTy+ ]+ fs <- getForcedArgs f+ pol <- getPolarity' cmp f+ reportSDoc "tc.inj.invert.success" 20 $ hsep ["Successful spine comparison of", prettyTCM f]+ whenProfile Profile.Conversion $ tick "compare by reduction: injectivity successful"+ app (compareElims pol fs fTy (Def f [])) blkArgs neuArgs++ -- f us == c vs+ -- Find the clause unique clause `f ps` with head `c` and unify+ -- us == ps with fresh metas for the pattern variables of ps.+ -- If there's no such clause we can safely throw an error.+ _ -> headSymbol' neu >>= \ case+ Nothing -> do+ reportSDoc "tc.inj.use" 20 $ fsep $+ pwords "no head symbol found for" ++ [prettyTCM neu] ++ pwords ", so not inverting"+ fallback+ Just (ConsHead f') | f == f', canReduceToSelf -> do+ reportSDoc "tc.inj.use" 20 $ fsep $+ pwords "head symbol" ++ [prettyTCM f'] ++ pwords "can reduce to self, so not inverting"+ fallback+ -- We can't invert in this case, since we can't+ -- tell the difference between a solution that makes+ -- the blocked term neutral and one that makes progress.+ Just hd -> invertFunction cmp blk inv hd fallback err success where+ err = app (\u v -> failConversion cmp u v ty) blk neu where- fallBack = addConstraint $ ValueCmp cmp a u v+ fallback = addConstraint blocker $ app (ValueCmp cmp ty) blk neu+ success blk' = app (compareAs cmp ty) blk' neu - invert :: Term -> QName -> Type -> Map TermHead Clause -> Args -> Maybe TermHead -> TCM ()- invert _ _ a inv args Nothing = fallBack- invert org f ftype inv args (Just h) = case Map.lookup h inv of- Nothing -> typeError $ UnequalTerms cmp u v a- Just (Clause{ clauseTel = tel- , clausePerm = perm- , clausePats = ps }) -> do -- instArgs args ps+ cmpApp :: (Comparison, (a -> a -> b) -> a -> a -> b)+ cmpApp = case dir of+ DirEq -> (CmpEq, id)+ DirLeq -> (CmpLeq, id)+ DirGeq -> (CmpLeq, flip)+ (cmp, app) = cmpApp++-- | The second argument should be a blocked application and the third argument+-- the inverse of the applied function.+invertFunction :: Comparison -> Term -> InvView -> TermHead -> TCM () -> TCM () -> (Term -> TCM ()) -> TCM ()+invertFunction _ _ NoInv _ fallback _ _ = fallback+invertFunction cmp blk (Inv f blkArgs hdMap) hd fallback err success = do+ fTy <- defType <$> getConstInfo f+ reportSDoc "tc.inj.use" 20 $ vcat+ [ "inverting injective function" <?> hsep [prettyTCM f, ":", prettyTCM fTy]+ , "for" <?> pretty hd+ , nest 2 $ "args =" <+> prettyList (map' prettyTCM blkArgs)+ ] -- Clauses with unknown heads are also possible candidates+ case fromMaybe [] $ Map.lookup hd hdMap <> Map.lookup UnknownHead hdMap of+ [] -> err+ _:_:_ -> fallback+ [cl@Clause{ clauseTel = tel }] -> speculateMetas fallback $ do+ let ps = clausePats cl+ perm = fromMaybe __IMPOSSIBLE__ $ clausePerm cl -- These are what dot patterns should be instantiated at- ms <- map unArg <$> newTelMeta tel+ ms <- map' unArg <$> newTelMeta tel reportSDoc "tc.inj.invert" 20 $ vcat- [ text "meta patterns" <+> prettyList (map prettyTCM ms)- , text " perm =" <+> text (show perm)- , text " tel =" <+> prettyTCM tel- , text " ps =" <+> prettyList (map (text . show) ps)+ [ "meta patterns" <+> prettyList (map' prettyTCM ms)+ , " perm =" <+> text (show perm)+ , " tel =" <+> prettyTCM tel+ , " ps =" <+> prettyList (map' (text . prettyShow) ps) ] -- and this is the order the variables occur in the patterns- let ms' = permute (invertP $ compactP perm) ms- cxt <- getContextTelescope- let sub = (reverse ms ++ idSub cxt)- margs <- runReaderT (evalStateT (metaArgs ps) ms') sub+ let msAux = permute (invertP __IMPOSSIBLE__ $ compactP perm) ms+ let sub = parallelS (reverse ms)+ margs <- runReaderT (evalStateT (mapM metaElim ps) msAux) sub reportSDoc "tc.inj.invert" 20 $ vcat- [ text "inversion"+ [ "inversion" , nest 2 $ vcat- [ text "lhs =" <+> prettyTCM margs- , text "rhs =" <+> prettyTCM args- , text "type =" <+> prettyTCM ftype+ [ "lhs =" <+> prettyTCM margs+ , "rhs =" <+> prettyTCM blkArgs+ , "type =" <+> prettyTCM fTy ] ]- pol <- getPolarity' cmp f+ -- Since we do not care for the value of non-variant metas here,+ -- we can treat 'Nonvariant' as 'Invariant'.+ -- That ensures these metas do not remain unsolved.+ pol <- purgeNonvariant <$> getPolarity' cmp f+ fs <- getForcedArgs f -- The clause might not give as many patterns as there -- are arguments (point-free style definitions).- let args' = take (length margs) args- compareArgs pol ftype org margs args'-{- Andreas, 2011-05-09 allow unsolved constraints as long as progress- unless (null cs) $ do- reportSDoc "tc.inj.invert" 30 $- text "aborting inversion; remaining constraints" <+> prettyTCM cs- patternViolation--}- -- Check that we made progress, i.e. the head symbol- -- of the original term should be a constructor.- org <- reduce org- h <- headSymbol org- case h of- Just h -> compareTerm cmp a u v- Nothing -> do- reportSDoc "tc.inj.invert" 30 $ vcat- [ text "aborting inversion;" <+> prettyTCM org- , text "plainly," <+> text (show org)- , text "has TermHead" <+> text (show h)- , text "which does not expose a constructor"- ]- patternViolation- `catchError` \err -> case errError err of- TypeError {} -> throwError err- Exception {} -> throwError err- IOException {} -> throwError err- PatternErr {} -> fallBack- {- AbortAssign {} -> fallBack -- UNUSED -}+ let blkArgs' = take (length margs) blkArgs+ compareElims pol fs fTy (Def f []) margs blkArgs' + -- Check that we made progress.+ r <- liftReduce $ unfoldDefinitionStep (Def f []) f blkArgs+ case r of+ YesReduction _ blk' -> do+ reportSDoc "tc.inj.invert.success" 20 $ hsep ["Successful inversion of", prettyTCM f, "at", pretty hd]+ KeepMetas <$ success blk'+ NoReduction{} -> do+ reportSDoc "tc.inj.invert" 30 $ vcat+ [ "aborting inversion;" <+> prettyTCM blk+ , "does not reduce"+ ]+ return RollBackMetas+ where+ nextMeta :: (MonadState [Term] m) => m Term nextMeta = do- m : ms <- get+ (m, ms) <- gets (fromMaybe __IMPOSSIBLE__ . uncons) put ms return m - dotP :: Monad m => Term -> StateT [Term] (ReaderT Substitution m) Term+ dotP :: MonadReader Substitution m => Term -> m Term dotP v = do sub <- ask- return $ substs sub v+ return $ applySubst sub v - metaArgs args = mapM metaArg args- metaArg arg = traverse metaPat arg+ metaElim+ :: (MonadState [Term] m, MonadReader Substitution m, HasConstInfo m)+ => Arg DeBruijnPattern -> m Elim+ metaElim (Arg _ (ProjP o p)) = Proj o <$> getOriginalProjection p+ metaElim (Arg info p) = Apply . Arg info <$> metaPat p - metaPat (DotP v) = dotP v- metaPat (VarP _) = nextMeta- metaPat (ConP c mt args) = do- args <- metaArgs args- return $ Con c args- metaPat (LitP l) = return $ Lit l+ metaArgs+ :: (MonadState [Term] m, MonadReader Substitution m)+ => [NamedArg DeBruijnPattern] -> m Args+ metaArgs args = mapM (traverse $ metaPat . namedThing) args++ metaPat+ :: (MonadState [Term] m, MonadReader Substitution m)+ => DeBruijnPattern -> m Term+ metaPat (DotP _ v) = dotP v+ metaPat (VarP _ _) = nextMeta+ metaPat (IApplyP{}) = nextMeta+ metaPat (ConP c mt args) = Con c (fromConPatternInfo mt) . map' Apply <$> metaArgs args+ metaPat (DefP o q args) = Def q . map' Apply <$> metaArgs args+ metaPat (LitP _ l) = return $ Lit l+ metaPat ProjP{} = __IMPOSSIBLE__++forcePiUsingInjectivity :: Type -> TCM Type+forcePiUsingInjectivity t = reduceB t >>= \ case+ Blocked _ blkTy -> do+ let blk = unEl blkTy+ inv <- functionInverse blk+ blkTy <$ invertFunction CmpEq blk inv PiHead fallback err success+ NotBlocked _ t -> return t+ where+ fallback = return ()+ err = typeError (ShouldBePi t)+ success _ = return ()
@@ -0,0 +1,29 @@+{-# OPTIONS_GHC -Wunused-imports #-}++-- | Logic for deciding which functions should be automatically inlined.+module Agda.TypeChecking.Inlining (autoInline) where++import qualified Data.IntMap as IntMap++import Agda.Interaction.Options+import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Free++-- | Mark a definition to be inlined if it satisfies the inlining criterion.+autoInline :: Defn -> TCM Defn+autoInline defn = do+ inlining <- optAutoInline <$> pragmaOptions+ if | inlining, shouldInline defn -> return $ set funInline True defn+ | otherwise -> return defn++shouldInline :: Defn -> Bool+shouldInline Function{funCompiled = Just cc} = shouldInline' cc+shouldInline _ = False++-- Only auto-inline simple definitions (no pattern matching) where no variable+-- is used more than once, and some variables are not used at all.+shouldInline' :: CompiledClauses -> Bool+shouldInline' (Done _ _ xs body) = all (< 2) counts && length counts < length xs+ where counts = IntMap.elems $ varCounts $ freeVarCounts body+shouldInline' _ = False
@@ -0,0 +1,1272 @@+{-# OPTIONS_GHC -Wunused-imports #-}++{-# LANGUAGE NondecreasingIndentation #-}++module Agda.TypeChecking.InstanceArguments+ ( findInstance+ , isInstanceConstraint+ , solveAwakeInstanceConstraints+ , shouldPostponeInstanceSearch+ , postponeInstanceConstraints+ , flushInstanceConstraints+ , getInstanceCandidates+ , getInstanceDefs+ , OutputTypeName(..)+ , getOutputTypeName+ , addTypedInstance+ , readdTypedInstance+ , addTypedInstance'+ , pruneTemporaryInstances+ , resolveInstanceHead+ ) where++import Control.Monad.Except (ExceptT(..), runExceptT, MonadError(..))++import qualified Data.Map.Strict as Map+import qualified Data.Set as Set+import qualified Data.List as List+import Data.Function (on)+import Data.Monoid hiding ((<>))+import Data.Foldable (toList, foldrM)++import Agda.Interaction.Options (optQualifiedInstances, lensOptExperimentalLazyInstances)++import Agda.Syntax.Common+import Agda.Syntax.Concrete.Name (isQualified)+import Agda.Syntax.Position+import Agda.Syntax.Internal as I+import Agda.Syntax.Internal.MetaVars+import Agda.Syntax.Scope.Base (isNameInScope, inverseScopeLookupName', AllowAmbiguousNames(..))++import qualified Agda.TypeChecking.Monad.Benchmark as Bench+import Agda.TypeChecking.Conversion.Pure (pureBlockOrEqualTerm)+import Agda.TypeChecking.Errors () --instance only+import Agda.TypeChecking.Implicit (implicitArgs)+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Records+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Warnings+import Agda.TypeChecking.Datatypes++import {-# SOURCE #-} Agda.TypeChecking.Constraints+import {-# SOURCE #-} Agda.TypeChecking.Conversion++import qualified Agda.Benchmarking as Benchmark+import Agda.TypeChecking.Monad.Benchmark (billTo)++import Agda.Utils.List+import Agda.Utils.Maybe+import Agda.Utils.Monad+import Agda.Utils.Size+import Agda.Utils.Tuple+import Agda.Syntax.Common.Pretty (prettyShow)++import qualified Agda.Interaction.Options.ProfileOptions as Profile+import Agda.Utils.WithDefault (lensCollapseDefault)+import Agda.Utils.Impossible++import Agda.TypeChecking.DiscrimTree++-- | Compute a list of instance candidates.+-- 'Nothing' if target type or any context type is a meta, error if+-- type is not eligible for instance search.+initialInstanceCandidates :: Bool -> Type -> TCM (Either Blocker [Candidate])+initialInstanceCandidates blockOverlap instTy = do+ (_, _, otn) <- getOutputTypeName instTy+ case otn of+ NoOutputTypeName -> typeError $ InvalidInstanceHeadType instTy ImproperInstHead+ OutputTypeVisiblePi -> typeError $ InvalidInstanceHeadType instTy ImproperInstTele+ OutputTypeNameNotYetKnown b -> do+ reportSDoc "tc.instance.cands" 30 $ "Instance type is not yet known. "+ return (Left b)+ OutputTypeVar -> do+ reportSDoc "tc.instance.cands" 30 $ "Instance type is a variable. "+ runBlocked (getContextCands Nothing)+ OutputTypeName n -> Bench.billTo [Bench.Typing, Bench.InstanceSearch, Bench.InitialCandidates] do+ reportSDoc "tc.instance.cands" 30 $ "Found instance type head: " <+> prettyTCM n+ runBlocked do+ local <- getContextCands (Just n)+ global <- getScopeDefs n+ lift $ tickCandidates n $ length local + length global+ pure $ local <> global+ where+ -- Ticky profiling for statistics about a class.+ tickCandidates n size = whenProfile Profile.Instances do+ n <- prettyTCM n+ let pref = "class " <> show n++ -- Number of instance constraints of this class that have gotten a+ -- set of candidates+ tick $ pref <> ": attempts"+ -- Per-class info: number of constraints where there was only one+ -- candidate (awesome) + the total number of candidates we've gone+ -- through.+ when (size == 1) $ tick $ pref <> ": only one candidate"+ when (size >= 1) $ tickN+ (pref <> ": total candidates visited")+ (fromIntegral size)++ -- get a list of variables with their type, relative to current context+ getContextCands :: Maybe QName -> BlockT TCM [Candidate]+ getContextCands cls = do+ ctx <- getContext+ reportSDoc "tc.instance.cands" 40 $ hang "Getting candidates from context" 2 (inTopContext $ prettyTCM $ PrettyContext ctx)+ -- Context variables with their types lifted to live in the full context+ let varsAndRaisedTypes = reverse $ zip' (contextTerms ctx) (flattenTel $ contextToTel ctx)+ vars = [ Candidate LocalCandidate x t (infoOverlapMode (dom ^. dInfo))+ | (x, dom@(unDom -> t)) <- varsAndRaisedTypes+ , isInstance (dom ^. dInfo)+ ]++ -- {{}}-fields of variables are also candidates, as long as those+ -- variables are themselves instance arguments.+ -- as an exception, the record argument to a record module can+ -- also introduce instances, so that {{}}-fields of a record R+ -- will be considered when checking a declaration nested in the+ -- definition of R.+ let+ cxtAndTypes =+ [ (LocalCandidate, x, t)+ | (x, dom@(unDom -> t)) <- varsAndRaisedTypes+ , isInstance (dom ^. dInfo) || argInfoOrigin (dom ^. dInfo) == RecordSelf+ ]+ reportSDoc "tc.instance.cands" 40 $ "Getting candidates by eta-expanding context" $$ nest 2 (vcat+ [ prettyTCM x <+> colon <+> prettyTCM t $$ (nest 2 $ "origin: " <> text (show o) <> ", used: " <> text (show used))+ | (x, dom@(unDom -> t)) <- varsAndRaisedTypes, let o = argInfoOrigin (dom ^. dInfo)+ , let used = isInstance (dom ^. dInfo) || o == RecordSelf+ ])+ fields <- concat <$> mapM instanceFields (reverse cxtAndTypes)+ reportSDoc "tc.instance.fields" 30 $+ if null fields then "no instance field candidates" else+ "instance field candidates" $$ do+ nest 2 $ vcat (map' debugCandidate fields)++ -- get let bindings+ env <- viewTC eLetBindings+ env <- mapM (traverse getOpen) $ Map.toList env+ let lets = [ Candidate LocalCandidate v t DefaultOverlap+ | (_, LetBinding _isAxiom _origin v dom@(unDom -> t)) <- env+ , isInstance (dom ^. dInfo)+ , usableModality (dom ^. dInfo)+ ]+ filterM (sameHead cls . candidateType) $ vars ++! fields ++! lets++ sameHead :: Maybe QName -> Type -> BlockT TCM Bool+ sameHead Nothing _ = pure True+ sameHead (Just cls) t = lift (thd3 <$> getOutputTypeName t) >>= \case+ OutputTypeName inst -> pure (inst == cls)+ OutputTypeNameNotYetKnown b -> patternViolation b+ _ -> pure False++ infoOverlapMode :: LensArgInfo a => a -> OverlapMode+ infoOverlapMode info = if isYesOverlap (getArgInfo info) then FieldOverlap else DefaultOverlap++ etaExpand :: (MonadTCM m, PureTCM m)+ => Bool -> Type -> m (Maybe (QName, Args))+ etaExpand etaOnce t =+ isEtaRecordType t >>= \case+ Nothing | etaOnce -> do+ isRecordType t >>= \case+ Nothing -> return Nothing+ Just (r, vs, _) -> do+ m <- currentModule+ -- Are we inside the record module? If so it's safe and desirable+ -- to eta-expand once (issue #2320).+ if qnameToList0 r `List.isPrefixOf` mnameToList m+ then return (Just (r, vs))+ else return Nothing+ r -> return r++ instanceFields :: (CandidateKind,Term,Type) -> BlockT TCM [Candidate]+ instanceFields = instanceFields' True++ instanceFields' :: Bool -> (CandidateKind,Term,Type) -> BlockT TCM [Candidate]+ instanceFields' etaOnce (q, v, t) = do+ TelV piTel t' <- lift $ telViewUpTo' (-1) notVisible t+ ifBlocked t' (\ m _ -> patternViolation m) $ \ _ t' -> do+ let n = size piTel+ addContext piTel $ caseMaybeM (etaExpand etaOnce t') (return []) $ \ (r, pars) -> do+ let v' = raise n v `apply` teleArgs piTel+ mtelargs <- lift $ forceEtaExpandRecord r pars v'+ case mtelargs of+ Nothing -> return [] -- Issue #8636: cannot eta-expand the value at this record type+ Just (tel, args) -> do+ let types = map' unDom $ applySubst (parallelS $ reverse $ map' unArg args) (flattenTel tel)+ fmap concat $ forM (zip' args types) $ \ (arg, t) -> do+ let+ absArg = abstract piTel (unArg arg)+ absTy = telePi piTel t+ ([ Candidate LocalCandidate absArg absTy (infoOverlapMode arg)+ | isInstance arg+ ] ++) <$>+ instanceFields' False (LocalCandidate, absArg, absTy)++ -- Compute whether we should block this instance constraint at the+ -- discrimination tree stage.+ shouldBlockOverlap :: Blocker -> Set.Set QName -> TCM Bool+ shouldBlockOverlap bs cands = do+ let+ recursive = useTC stConsideringInstance+ hack = useTC stInstanceHack+ enabled = useTC (stPragmaOptions . lensOptExperimentalLazyInstances . lensCollapseDefault)+ mutual = caseMaybeM (viewTC eMutualBlock) (pure mempty) \ mb ->+ mutualNames <$> lookupMutualBlock mb++ andM+ [ pure blockOverlap+ -- For the getInstances reflection primitive, we don't want+ -- to block on overlap, so that the user can do their thing.++ , enabled+ -- Also disable it depending on the pragma option.++ , pure $ not $ Set.null $ allBlockingMetas bs+ -- Don't block if there's no metas to block on++ , pure $ natSize cands > 1+ -- It's possible that the discrimination tree forced a+ -- metavariable even if there's exactly one candidate. In this+ -- case, we should not block, because this instance constraint+ -- might be the only thing that can solve the blocking metas.++ , not <$> hack+ -- To support 'inert improvement' (see ImproveInertRHS), we+ -- try all the candidates even if the discrimination tree+ -- thinks that there will be overlap. This is because it's+ -- possible we have e.g.+ --+ -- instance ?1 : Foo ?0, candidates {Foo T, Foo S}+ -- blocker ?0+ -- ?0 X = T X (blocked on ?0)+ --+ -- If we block ?1 on ?0 again (as we would've done during the+ -- body), then both of these go unsolved. But if we try all+ -- the candidates, we'll see that 'Foo T' is the only possible+ -- candidate, thus solving both constraints.++ , mutual <&> (`Set.disjoint` cands)+ -- Work around for #7186: the result of termination checking+ -- depends on whether we solve instance metas eagerly or late.+ -- Consider+ --+ -- instance Show-List = record { show = go }+ -- go (x ∷ xs) = show x <> show ⦃ ?0 ⦄ xs+ --+ -- If we solve ?0 eagerly, the term we use is the literal+ -- record constructor. The 'show' projection unfolds in 'go'+ -- and the termination check is happy.+ --+ -- If we solve it late, we run the risk of the clause+ -- compiler applying copattern translation to Show-List. The+ -- 'show' projection does not eagerly unfold, and the+ -- termination check explodes.++ , not <$> recursive+ -- Blocking instance selection *on a meta* while considering+ -- an instance causes the recursive instance constraint to+ -- get repeatedly woken up. Not good for performance.+ ]++ getScopeDefs :: QName -> BlockT TCM [Candidate]+ getScopeDefs n = do+ rel <- viewTC eRelevance++ InstanceTable tree counts <- lift getInstanceDefs+ QueryResult qs blocker <- lift $ lookupDT (unEl instTy) tree++ reportSDoc "tc.instance.candidates.search" 20 $ vcat+ [ "instance candidates from signature for goal:"+ , nest 2 (prettyTCM =<< instantiateFull instTy)+ , nest 2 (prettyTCM qs)+ , "length:" <+> prettyTCM (length qs)+ , "blocker:"+ , nest 2 (prettyTCM blocker)+ ]++ cands <- catMaybes <$> mapM (lift . candidate rel) (toList qs)++ should <- lift (shouldBlockOverlap blocker qs)+ when (length cands > 1 && should) do+ reportSDoc "tc.instance.defer" 20 $ vcat+ [ "Postponing because of discrimination tree overlap."+ ]+ patternViolation blocker++ -- Some more class-specific profiling.+ lift $ whenProfile Profile.Instances case Map.lookup n counts of+ Just tot -> do+ n <- prettyTCM n+ -- Record the overall total number of candidates that were+ -- skipped by lookup in the discrimination tree, and record+ -- this per-class, as well.+ let diff = fromIntegral (tot - length cands)+ tickN "instances discarded early" diff+ tickN ("class " <> show n <> ": discarded early") diff+ Nothing -> pure ()++ pure cands++ candidate :: Relevance -> QName -> TCM (Maybe Candidate)+ candidate rel q = ifNotM (isNameInScope q <$> getScope) (return Nothing) $ do+ -- Jesper, 2020-03-16: When using --no-qualified-instances,+ -- filter out instances that are only in scope under a qualified+ -- name.+ filterQualified $ do+ -- Andreas, 2012-07-07:+ -- we try to get the info for q+ -- while opening a module, q may be in scope but not in the signature+ -- in this case, we just ignore q (issue 674)+ flip catchError handle $ do+ def <- getConstInfo q+ if not (getRelevance def `moreRelevant` rel) then return Nothing else do+ -- Andreas, 2017-01-14: instantiateDef is a bit of an overkill+ -- if we anyway get the freeVarsToApply+ -- WAS: t <- defType <$> instantiateDef def+ args <- freeVarsToApply q+ let+ t = defType def `piApply` args+ rel = getRelevance $ defArgInfo def++ v = case theDef def of+ -- drop parameters if it's a projection function...+ Function{ funProjection = Right p } -> projDropParsApply p ProjSystem rel args++ -- Andreas, 2014-08-19: constructors cannot be declared as+ -- instances (at least as of now).+ -- I do not understand why the Constructor case is not impossible.+ -- Ulf, 2014-08-20: constructors are always instances.+ Constructor{ conSrcCon = c } -> Con c ConOSystem []+ _ -> Def q $! map' Apply args++ mode = case defInstance def of+ Just i -> instanceOverlap i+ Nothing -> DefaultOverlap++ -- Amy, 2025-04-10: it's possible that an instance in the+ -- discrimination tree has a type which, in the current+ -- context, has visible quantifiers (e.g. because we're+ -- outside the parametrised module it was defined in).+ --+ -- Discard them early so that they don't count towards+ -- potentially blocking on "overlap".+ TelV tele _ <- telView t+ return do+ guard (all (not . visible) tele)+ Just $ Candidate (GlobalCandidate q) v t mode+ where+ -- unbound constant throws an internal error+ handle (TypeError _ _ (Closure {clValue = InternalError _})) = return Nothing+ handle err = throwError err++ filterQualified :: TCM (Maybe Candidate) -> TCM (Maybe Candidate)+ filterQualified m = ifM (optQualifiedInstances <$> pragmaOptions) m $ do+ qc <- inverseScopeLookupName' AmbiguousAnything q <$> getScope+ let isQual = maybe True isQualified $ listToMaybe qc+ reportSDoc "tc.instance.qualified" 30 $+ if isQual then+ "dropping qualified instance" <+> prettyTCM q+ else+ "keeping instance" <+> prettyTCM q <+>+ "since it is in scope as" <+> prettyTCM qc+ if isQual then return Nothing else m+++-- | @findInstance m (v,a)s@ tries to instantiate on of the types @a@s+-- of the candidate terms @v@s to the type @t@ of the metavariable @m@.+-- If successful, meta @m@ is solved with the instantiation of @v@.+-- If unsuccessful, the constraint is regenerated, with possibly reduced+-- candidate set.+-- The list of candidates is equal to @Nothing@ when the type of the meta+-- wasn't known when the constraint was generated. In that case, try to find+-- its type again.+findInstance :: MetaId -> Maybe [Candidate] -> TCM ()+findInstance m Nothing = do+ r <- getMetaRange m+ ifM canDropRecursiveInstance (addConstraint neverUnblock (FindInstance r m Nothing)) $ do+ -- Getting initial candidates can fail, in which case we should postpone (#7286)+ catchConstraint (FindInstance r m Nothing) $ do+ -- Andreas, 2015-02-07: New metas should be created with range of the+ -- current instance meta, thus, we set the range.+ mv <- lookupLocalMeta m+ setCurrentRange mv $ do+ reportSLn "tc.instance" 20 $ "The type of the FindInstance constraint isn't known, trying to find it again."+ t <- instantiate =<< getMetaTypeInContext m+ reportSLn "tc.instance" 70 $ "findInstance 1: t: " ++! prettyShow t++ -- Issue #2577: If the target is a function type the arguments are+ -- potential candidates, so we add them to the context to make+ -- initialInstanceCandidates pick them up.+ TelV tel t <- telViewUpTo' (-1) notVisible t+ cands <- addContext tel $ initialInstanceCandidates True t+ case cands of+ Left unblock -> do+ reportSLn "tc.instance" 20 "Can't figure out target of instance goal. Postponing constraint."+ addConstraint unblock $ FindInstance r m Nothing+ Right cs -> findInstance m (Just cs)++findInstance m (Just cands) = do -- Note: if no blocking meta variable this will not unblock until the end of the mutual block+ r <- getMetaRange m+ whenJustM (findInstance' m cands) $ (\ (cands, b) -> addConstraint b $ FindInstance r m $ Just cands)++-- | Entry point for `tcGetInstances` primitive+getInstanceCandidates :: MetaId -> TCM (Either Blocker [Candidate])+getInstanceCandidates m = wrapper where+ wrapper = do+ mv <- lookupLocalMeta m+ setCurrentRange mv $ do+ t <- instantiate =<< getMetaTypeInContext m+ TelV tel t' <- telViewUpTo' (-1) notVisible t+ addContext tel $ runExceptT (worker t')++ insertCandidate :: Candidate -> [Candidate] -> TCM [Candidate]+ insertCandidate x [] = pure [x]+ insertCandidate x (y:xs) = doesCandidateSpecialise x y >>= \case+ True -> pure (x:y:xs)+ False -> (y:) <$> insertCandidate x xs++ worker :: Type -> ExceptT Blocker TCM [Candidate]+ worker t' = do+ cands <- ExceptT (initialInstanceCandidates False t')+ cands <- lift (checkCandidates m t' cands) <&> \case+ Nothing -> cands+ Just (_, cands) -> fst <$> cands+ cands <- Bench.billTo [Bench.Typing, Bench.InstanceSearch, Bench.OrderCandidates] $+ lift (foldrM insertCandidate [] cands)++ reportSDoc "tc.instance.sort" 20 $ nest 2 $+ "sorted candidates" $$ vcat (map' debugCandidate cands)++ pure cands++-- | @'doesCandidateSpecialise' c1 c2@ checks whether the instance+-- candidate @c1@ /specialises/ the instance candidate @c2@, i.e.,+-- whether the type of @c2@ is a substitution instance of @c1@'s type.+--+-- Only the final return type of the instances is considered: the+-- presence of unsolvable instance arguments in the types of @c1@ or+-- @c2@ does not affect the results of 'doesCandidateSpecialise'.+doesCandidateSpecialise :: Candidate -> Candidate -> TCM Bool+doesCandidateSpecialise c1@Candidate{candidateType = t1} c2@Candidate{candidateType = t2} = do+ whenProfile Profile.Instances $ tick "doesCandidateSpecialise"++ -- We compare+ -- c1 : ∀ {Γ} → T+ -- against+ -- c2 : ∀ {Δ} → S+ -- by moving to the context Γ ⊢, so that any variables in T's type are+ -- "rigid", but *instantiating* S[?/Δ], so its variables are+ -- "flexible"; then calling the conversion checker.++ let+ handle e = do+ reportSDoc "tc.instance.sort" 30 $ nest 2 "=> NOT specialisation"+ reportSDoc "tc.instance.sort" 40 $ prettyTCM e+ pure False++ wrap = flip catchError handle+ -- Turn failures into returning false+ . localTCState+ -- Discard any changes to the TC state (metas from+ -- instantiating t2, recursive instance constraints, etc)+ . locallyTCState stPostponeInstanceSearch (const True)+ -- Don't spend any time looking for instances in the contexts+ . nowConsideringInstance+ -- Don't execute tactics either++ TelV tel t1 <- telView t1+ addContext tel $ wrap $ do+ -- Amy, 2025-02-28: Have to raise the type of the other candidate to+ -- live in t1's context!+ (args, t2) <- implicitArgs (-1) (\h -> notVisible h) (raise (length tel) t2)++ reportSDoc "tc.instance.sort" 30 $ "Does" <+> prettyTCM (raise (length tel) c1) <+> "specialise" <+> (prettyTCM (raise (length tel) c2) <> "?")+ reportSDoc "tc.instance.sort" 60 $ vcat+ [ "Comparing candidate"+ , nest 2 (prettyTCM c1 <+> colon <+> prettyTCM t1)+ , "vs"+ , nest 2 (prettyTCM c2 <+> colon <+> prettyTCM t2)+ ]++ leqType t2 t1+ reportSDoc "tc.instance.sort" 30 $ nest 2 "=> IS specialisation"+ pure True++-- | Checks whether an instance overlaps another. This involves a strict+-- specificity check (the new instance should be more specific than the+-- old instance but not vice-versa) and the consideration of whether+-- these instances are overlappable/overlapping at all.+--+-- Fails early if the new candidate is not overlapping and the old+-- candidate is not overlappable.+doesCandidateOverlap :: Candidate -> Candidate -> TCM Bool+doesCandidateOverlap new old = if isOverlapping new || isOverlappable old+ then andM [ doesCandidateSpecialise new old+ , fmap not (doesCandidateSpecialise old new) ]+ else pure False++-- | Result says whether we need to add constraint, and if so, the set of+-- remaining candidates and an eventual blocking metavariable.+findInstance' :: MetaId -> [Candidate] -> TCM (Maybe ([Candidate], Blocker))+findInstance' m cands = do+ let+ frozen = do+ reportSLn "tc.instance.defer" 20 "Refusing to solve frozen instance meta."+ whenProfile Profile.Instances $ tick "findInstance: frozen"+ return (Just (cands, neverUnblock))++ recursive = do+ recur <- useTC stConsideringInstance+ reportSLn "tc.instance.defer" 20+ if recur+ then "Postponing recursive instance search."+ else "Postponing possibly recursive instance search."+ whenProfile Profile.Instances $ tick "findInstance: recursive"+ return $ Just (cands, neverUnblock)++ ifM (isFrozen m) frozen do+ ifM shouldPostponeInstanceSearch recursive do+ billTo [Benchmark.Typing, Benchmark.InstanceSearch] do++ -- Andreas, 2015-02-07: New metas should be created with range of the+ -- current instance meta, thus, we set the range.+ mv <- lookupLocalMeta m+ setCurrentRange mv $ do+ reportSLn "tc.instance" 15 $+ "findInstance 2: constraint: " ++! prettyShow m ++! "; candidates left: " ++! show (length cands)+ reportSDoc "tc.instance" 60 $ nest 2 $ vcat $ map' debugCandidate cands+ reportSDoc "tc.instance" 70 $ "raw" $$ do+ nest 2 $ vcat $ map' debugCandidateRaw cands++ t <- getMetaTypeInContext m+ reportSLn "tc.instance" 70 $ "findInstance 2: t: " ++! prettyShow t++ insidePi t $ \ t -> do+ reportSDoc "tc.instance" 15 $ "findInstance 3: t =" <+> prettyTCM t+ reportSLn "tc.instance" 70 $ "findInstance 3: t: " ++! prettyShow t++ mcands <-+ -- Temporarily remove other instance constraints to avoid+ -- redundant solution attempts+ holdConstraints (const isInstanceProblemConstraint) $+ checkCandidates m t cands++ debugConstraints+ case mcands of+ Just ([(_, err)], []) -> do+ reportSDoc "tc.instance" 15 $+ "findInstance 5: the only viable candidate failed..."+ throwError err++ Just (errs, []) -> do+ if null errs then reportSDoc "tc.instance" 15 $ "findInstance 5: no viable candidate found..."+ else reportSDoc "tc.instance" 15 $ "findInstance 5: all viable candidates failed..."+ -- #3676: Sort the candidates based on the size of the range for the errors and+ -- set the range of the full error to the range of the most precise candidate+ -- error.+ let sortedErrs = List.sortBy (compare `on` precision) errs+ where precision (_, err) = maybe infinity iLength $ rangeToInterval $ getRange err+ infinity = 1000000000+ setCurrentRange (take' 1 $ map' snd sortedErrs) $+ typeError $ InstanceNoCandidate t [ (candidateTerm c, err) | (c, err) <- sortedErrs ]++ Just (errs, [(c@(Candidate q term t' _), v)]) -> do+ reportSDoc "tc.instance" 15 $ vcat+ [ "instance search: attempting"+ , nest 2 $ prettyTCM m <+> ":=" <+> prettyTCM v+ ]++ reportSDoc "tc.instance" 70 $ nest 2 $+ "candidate v = " <+> pretty v++ ctxElims <- map' Apply <$> getContextArgs+ equalTerm t (MetaV m ctxElims) v++ reportSDoc "tc.instance" 15 $ vcat+ [ "findInstance 5: solved by instance search using the only candidate"+ , nest 2 $ prettyTCM c <+> "=" <+> prettyTCM term+ , "of type " <+> prettyTCM t'+ , "for type" <+> prettyTCM t+ ]++ -- If we actually solved the constraints we should wake up any held+ -- instance constraints, to make sure we don't forget about them.+ wakeupInstanceConstraints+ return Nothing -- We’re done++ _ -> do+ let cs = maybe cands (map' fst . snd) mcands -- keep the current candidates if Nothing+ reportSDoc "tc.instance" 15 $+ text ("findInstance 5: refined candidates: ") <+>+ prettyTCM (map' candidateTerm cs)+ whenProfile Profile.Instances $ tick "findInstance: multiple candidates"+ return (Just (cs, neverUnblock))++insidePi :: Type -> (Type -> TCM a) -> TCM a+insidePi t ret = reduce (unEl t) >>= \case+ Pi a b -> addContext (absName b, a) $ insidePi (absBody b) ret+ Def{} -> ret t+ Var{} -> ret t+ Sort{} -> __IMPOSSIBLE__+ Con{} -> __IMPOSSIBLE__+ Lam{} -> __IMPOSSIBLE__+ Lit{} -> __IMPOSSIBLE__+ Level{} -> __IMPOSSIBLE__+ MetaV{} -> __IMPOSSIBLE__+ DontCare{} -> __IMPOSSIBLE__+ Dummy s _ -> __IMPOSSIBLE_VERBOSE__ (show s)++-- | Apply the computation to every argument in turn by resetting the state every+-- time. Return the list of the arguments giving the result True.+--+-- If the resulting list contains exactly one element, then the state is the+-- same as the one obtained after running the corresponding computation. In+-- all the other cases, the state is reset.+--+-- Also returns the candidates that pass type checking but fails constraints,+-- so that the error messages can be reported if there are no successful+-- candidates.+filterResettingState+ :: MetaId+ -> [Candidate]+ -> (Candidate -> TCM YesNo)+ -> TCM ([(Candidate, TCErr)], [(Candidate, Term)])+filterResettingState m cands f = do+ ctxArgs <- getContextArgs+ let ctxElims = map' Apply ctxArgs+ result <- mapM (\c -> (c,) <$> localTCStateSaving (f c)) cands++ -- Check that there aren't any hard failures+ case [ err | (_, (HellNo err, _)) <- result ] of+ err : _ -> throwError err+ [] -> return ()++ -- c : Candidate+ -- r : YesNo+ -- a : Type (fully instantiated)+ -- s : TCState+ let+ result' = [ (c, v, s) | (c, (r, s)) <- result, v <- maybeToList (fromYes r) ]+ overlap = flip all result \(c, (r, s)) -> case r of+ Yes _ False -> False+ _ -> True+ result'' <- dropSameCandidates m overlap result'+ case result'' of++ -- Have to use 'putTCPreservingStats' here otherwise the stats+ -- accumulated from checking other candidates and from+ -- 'dropSameCandidates' are lost.+ [(c, v, s)] -> ([], [(c, v)]) <$ putTCPreservingStats s++ _ -> do+ let bad = [ (c, err) | (c, (NoBecause err, _)) <- result ]+ good = [ (c, v) | (c, v, _) <- result'' ]+ return (bad, good)++-- | The state used to reduce a list of candidates according to the+-- overlap rules.+data OverlapState item = OverlapState+ { survivingCands :: [item]+ -- ^ The reduced list.++ , guardingCands :: [Candidate]+ -- ^ Overlapping candidates that have been discarded, which are kept+ -- around because they might still discard some overlappable+ -- candidates.+ }++-- | Apply the instance overlap rules to reduce the list of candidates.+resolveInstanceOverlap+ :: forall item.+ Bool+ -> Relevance+ -> (item -> Candidate)+ -> [item]+ -> TCM [item]+resolveInstanceOverlap overlapOk rel itemC cands = wrapper where+ wrapper+ -- If all the candidates are incoherent: choose the leftmost candidate.+ | all (isIncoherent . candidateOverlap . itemC) cands+ , (c:_) <- cands = pure [c]++ -- If all the candidates are record field overlap: choose the leftmost candidate.+ | all ((== FieldOverlap) . candidateOverlap . itemC) cands+ , (c:_) <- cands = pure [c]++ -- If none of the candidates have a special overlap mode: there's no+ -- reason to do any work.+ | all ((DefaultOverlap ==) . candidateOverlap . itemC) cands = pure cands++ | not overlapOk = pure cands++ -- If some of the candidates are overlappable/overlapping, then we+ -- should do the work.+ | otherwise = Bench.billTo [Bench.Typing, Bench.InstanceSearch, Bench.CheckOverlap] do+ reportSDoc "tc.instance.overlap" 30 $ "overlapping instances:" $$ vcat (map' (debugCandidate . itemC) cands)++ sinkIncoherent . survivingCands <$> foldrM insert (OverlapState [] []) cands++ isGlobal Candidate{candidateKind = GlobalCandidate _} = True+ isGlobal _ = False++ -- At the end of the process, we might still have some incoherent and+ -- non-incoherent candidates, since the user might have an instance+ -- which fixes some arguments in a way that prevents it from serving+ -- as a specialisation (see test/Succeed/Overlap1).+ --+ -- See test/Succeed/OverlapDupe for a case where this is necessary.+ sinkIncoherent :: [item] -> [item]+ sinkIncoherent cands = case List.partition (isIncoherent . itemC) cands of+ (as, [c]) | all (isGlobal . itemC) as -> pure c+ (as, cs) | all (isGlobal . itemC) as -> cs ++! as+ _ -> cands++ -- Insert a new item into the overlap state.+ insertNew+ :: OverlapState item -- The state to insert into+ -> item -- The item to insert+ -> [item] -- Old items which we might overlap/be overlapped by+ -> TCM (OverlapState item)+ insertNew oldState new [] = pure oldState{ survivingCands = [new] }+ insertNew oldState newItem oldItems@(oldItem:olds) = do+ let+ new = itemC newItem+ old = itemC oldItem++ reportSDoc "tc.instance.overlap" 50 $ vcat+ [ "comparing new candidate"+ , nest 2 (debugCandidate new)+ , "versus old candidate"+ , nest 2 (debugCandidate old)+ ]++ let+ -- If the new candidate overrides the old, drop it. But if the old+ -- candidate was overlapping (and the new one isn't), we keep it+ -- as a guard, since it might knock out future candidates.+ newold = insertNew oldState newItem olds <&> \case+ OverlapState items guards ->+ if not (isOverlapping new) && isOverlapping old+ then OverlapState items guards+ else OverlapState items (old:guards)++ -- If the old candidate overrides the new, then stop inserting.+ -- But if the new candidate is overlapping, it can be added as a+ -- guard.+ oldnew = do+ if isOverlapping old || not (isOverlapping new) then pure oldState{ survivingCands = oldItems } else do+ let OverlapState{ guardingCands = guards } = oldState+ reportSDoc "tc.instance.overlap" 40 $ vcat+ [ "will become guard:"+ , nest 2 (debugCandidate new)+ , "old items:"+ , nest 2 (vcat (map' (debugCandidate . itemC) oldItems))+ ]++ -- But we can't /just/ add it to the list of guards: the new+ -- item might conflict with some of the other old candidates.+ -- We must remove those.+ alive <- filterM (fmap not . doesCandidateOverlap new . itemC) oldItems+ pure $ OverlapState alive (new:guards)++ -- If neither overrides the other, keep both!+ neither = insertNew oldState newItem olds <&> \case+ OverlapState items guards -> OverlapState (oldItem:items) guards++ ifM (new `doesCandidateOverlap` old)+ {- then -} newold+ {- else -} (ifM (old `doesCandidateOverlap` new)+ {- then -} oldnew+ {- else -} neither)++ -- Insert a new instance into the given overlap set.+ insert :: item -> OverlapState item -> TCM (OverlapState item)+ insert newItem oldState@(OverlapState oldItems guards) = do+ let new = itemC newItem+ -- If the new candidate is overridden by any of the guards, we can+ -- ditch it immediately.+ guarded <- anyM (`doesCandidateOverlap` new) guards++ reportSDoc "tc.instance.overlap" 40 $ vcat+ [ "inserting new candidate:"+ , nest 2 (debugCandidate new)+ , "against old candidates"+ , nest 2 (vcat (map' (debugCandidate . itemC) oldItems))+ , "and guarding candidates"+ , nest 2 (vcat (map' debugCandidate guards))+ , "is guarded?" <+> prettyTCM guarded+ ]++ if guarded then pure oldState else insertNew oldState newItem oldItems++-- Drop all candidates which are judgmentally equal to the first one.+-- This is sufficient to reduce the list to a singleton should all be equal.+dropSameCandidates :: MetaId -> Bool -> [(Candidate, Term, TCState)] -> TCM [(Candidate, Term, TCState)]+dropSameCandidates m overlapOk cands0 = verboseBracket "tc.instance" 30 "dropSameCandidates" $ do+ !nextMeta <- nextLocalMeta+ isRemoteMeta <- isRemoteMeta++ -- Does "it" contain any fresh meta-variables?+ let freshMetas = getAny . allMetas (\m -> Any (not (isRemoteMeta m || m < nextMeta)))++ rel <- getRelevance <$> lookupMetaModality m++ -- Take overlappable candidates into account+ cands <- resolveInstanceOverlap overlapOk rel fst3 cands0+ reportSDoc "tc.instance.overlap" 30 $ "instances after resolving overlap:" $$ vcat (map' (debugCandidate . fst3) cands)++ reportSDoc "tc.instance" 50 $ vcat+ [ "valid candidates:"+ , nest 2 $ vcat+ [ if freshMetas v+ then sep [ pretty v, parens "contains fresh metas" ]+ else sep [ prettyTCM v ]+ | (_, v, _) <- cands ] ]++ case cands of+ [] -> return cands+ cvd : _ | isIrrelevant rel -> do+ reportSLn "tc.instance" 30 "dropSameCandidates: Meta is irrelevant so any candidate will do."+ return [cvd]++ -- If there's nothing, try not to reduce the candidate.+ [cvd] -> pure [cvd]++ cvd@(_, v, st) : vas -> do+ let+ equal :: (Candidate, Term, a) -> TCM Bool+ equal (c, v', _)+ | isIncoherent c = return True -- See 'sinkIncoherent'+ | freshMetas v' = return False -- If there are fresh metas we can't compare+ | otherwise =+ verboseBracket "tc.instance" 30 "dropSameCandidates: " $ do+ reportSDoc "tc.instance" 30 $ sep [ prettyTCM v <+> "==", nest 2 $ prettyTCM v' ]+ a <- uncurry piApplyM =<< ((,) <$> getMetaType m <*> getContextArgs)+ pureBlockOrEqualTerm a v v' <&> \case+ Left{} -> False+ Right b -> b++ -- If we do actually have to remove overlap then we have to reduce+ -- the candidate to eliminate any "phantom" dependencies on fresh+ -- metas.+ -- ... issue #8215: while fastReduce is perfectly happy to block+ -- on a meta that doesn't exist, the short-circuit blocking in+ -- maybeFastReduce explodes, we have to reduce in the new TC+ -- state.+ v <- localTCState do+ putTC st+ reduce v+ if+ | freshMetas v -> do+ reportSLn "tc.instance" 30 "dropSameCandidates: Solution of instance meta has fresh metas so we don't filter equal candidates yet"+ return (cvd : vas)+ | otherwise -> (cvd :) <$> dropWhileM equal vas++data YesNo = Yes Term Bool | No | NoBecause TCErr | HellNo TCErr+ deriving (Show)++fromYes :: YesNo -> Maybe Term+fromYes (Yes t _) = Just t+fromYes _ = Nothing++debugCandidate' :: MonadPretty m => Bool -> Bool -> Candidate -> m Doc+debugCandidate' raw term c@(Candidate q v t overlap) =+ let+ cand+ | term = prettyTCM v+ | otherwise = prettyTCM c++ ty+ | raw = nest 2 (pretty t)+ | otherwise = prettyTCM t++ head = fsep [ "-", pretty overlap, cand, ":" ]+ in if | raw -> sep [ head, ty ]+ | otherwise -> head <+> ty++debugCandidate :: MonadPretty m => Candidate -> m Doc+debugCandidate = debugCandidate' False False++debugCandidateRaw :: MonadPretty m => Candidate -> m Doc+debugCandidateRaw = debugCandidate' True False++debugCandidateTerm :: MonadPretty m => Candidate -> m Doc+debugCandidateTerm = debugCandidate' False True++-- | Given a meta @m@ of type @t@ and a list of candidates @cands@,+-- @checkCandidates m t cands@ returns a refined list of valid candidates and+-- candidates that failed some constraints.+checkCandidates :: MetaId -> Type -> [Candidate] -> TCM (Maybe ([(Candidate, TCErr)], [(Candidate, Term)]))+checkCandidates m t cands =+ verboseBracket "tc.instance.candidates" 20 ("checkCandidates " ++! prettyShow m) $+ -- Andreas, 2026-05-07: Ulf, 2015-10-31 commit 711bc27+ -- If there are candidates of meta type we won't be able to solve the constraint+ -- anyway and trying can be very expensive since checking a candidate might+ -- lead to further instance problems (exponential in depth).+ ifM (anyM (isMetaV . candidateType) cands) (return Nothing) $ Just <$> do+ reportSDoc "tc.instance.candidates" 20 $ nest 2 $ "target:" <+> prettyTCM t+ reportSDoc "tc.instance.candidates" 20 $ nest 2 $ vcat+ [ "candidates", vcat (map' debugCandidate cands) ]++ t <- instantiateFull t+ cands'@(_, okay) <- filterResettingState m cands (checkCandidateForMeta m t)++ reportSDoc "tc.instance.candidates" 20 $ nest 2 $ vcat+ [ "valid candidates", vcat (map' (debugCandidate . fst) okay) ]+ reportSDoc "tc.instance.candidates" 60 $ nest 2 $ vcat+ [ "valid candidates", vcat (map' (debugCandidateTerm . fst) okay) ]++ return cands'+ where+ isMetaV :: Type -> TCM Bool+ isMetaV a = isJust . isMeta <$> instantiate a++ checkDepth :: Term -> Type -> TCM YesNo -> TCM YesNo+ checkDepth c a k = locallyTC eInstanceDepth succ $ do+ d <- viewTC eInstanceDepth+ maxDepth <- maxInstanceSearchDepth+ when (d > maxDepth) $ typeError $ InstanceSearchDepthExhausted c a maxDepth+ k++ checkCandidateForMeta :: MetaId -> Type -> Candidate -> TCM YesNo+ checkCandidateForMeta m t (Candidate q term t' _) = checkDepth term t' $ do+ Bench.billTo [Bench.Typing, Bench.InstanceSearch, Bench.FilterCandidates] $ do+ whenProfile Profile.Instances $ tick "checkCandidateForMeta"++ -- Andreas, 2015-02-07: New metas should be created with range of the+ -- current instance meta, thus, we set the range.+ mv <- lookupLocalMeta m+ setCurrentRange mv $ runCandidateCheck $+ verboseBracket "tc.instance" 20 ("checkCandidateForMeta " ++! prettyShow m) $ do+ reportSDoc "tc.instance" 20 $ vcat+ [ "checkCandidateForMeta"+ , " t =" <+> prettyTCM t+ , " t' =" <+> prettyTCM t'+ , " term =" <+> prettyTCM term+ ]+ reportSDoc "tc.instance" 70 $ vcat+ [ " t =" <+> pretty t+ , " t' =" <+> pretty t'+ , " term =" <+> pretty term+ ]+ debugConstraints++ -- Apply hidden and instance arguments (in case of+ -- --overlapping-instances, this performs recursive+ -- inst. search!).+ (args, t'') <- implicitArgs (-1) (\h -> notVisible h) t'++ reportSDoc "tc.instance" 20 $+ "instance search: checking" <+> prettyTCM t'' <+> "<=" <+> prettyTCM t+ reportSDoc "tc.instance" 70 $ vcat+ [ "instance search: checking (raw)"+ , nest 4 $ pretty t''+ , nest 2 $ "<="+ , nest 4 $ pretty t+ ]++ -- Check whether this candidate is OK, and whether it is okay+ -- for the overlap check. For the candidate to be acceptable,+ -- its type must be a subtype of the goal type.+ -- Issue #8866: the candidate must also not solve metas of the+ -- goal type directly (e.g. @spec : C Z@ for goal @C ?B@).+ -- Instantiating such a meta by another meta is fine.+ goalMetas <- allMetasList <$> instantiateFull t+ (cons, overlapOk0) <- ifNoConstraints_ (leqType t'' t) (pure ([], True)) \pid -> do+ -- To know if this candidate is safe for overlap, we have to+ -- check that it does not constrain the type of the instance+ -- goal. We can do this by running it in a new problem and+ -- checking whether the computation produced any constraints+ -- that are blocked by the instance goal.+ cons <- getConstraintsForProblem pid+ -- Make sure to put these constraints back if we end up+ -- solving the instance goal with this candidate.+ stealConstraints pid+ let+ blocking = foldMap (allBlockingMetas . constraintUnblocker) cons+ !ok = getAll $! allMetas (All . not . flip Set.member blocking) t+ pure (cons, ok)+ let+ stillFlexible :: MetaId -> TCM Bool+ stillFlexible x = lookupMetaInstantiation x >>= \case+ InstV i -> instantiate (instBody i) <&> \case+ MetaV{} -> True+ _ -> False+ _ -> pure True+ overlapOk <- (overlapOk0 &&) <$> allM stillFlexible goalMetas+ debugConstraints++ flip catchError (return . NoBecause) $ do+ -- make a pass over constraints, to detect cases where+ -- some are made unsolvable by the type comparison, but+ -- don't do this for FindInstance's to prevent loops.+ solveAwakeConstraints' True+ -- We need instantiateFull here to remove 'local' metas+ v <- instantiateFull =<< (term `applyDroppingParameters` args)+ reportSDoc "tc.instance" 15 $+ vcat [ sep [ ("instance search: found solution for" <+> prettyTCM m) <> ":"+ , nest 2 $ prettyTCM v ]+ , "app: " <+> (nest 2 $ prettyTCM =<< (term `applyDroppingParameters` args))+ ]++ reportSDoc "tc.instance.overlap" 30 $+ "candidate" <+> prettyTCM v <+> "okay for overlap?" <+> prettyTCM overlapOk+ $$ vcat (map' prettyTCM cons)++ whenProfile Profile.Instances $ tick "checkCandidateForMeta: yes"+ return $ Yes v overlapOk+ where+ runCandidateCheck = flip catchError handle . nowConsideringInstance++ hardFailure :: TCErr -> Bool+ hardFailure (TypeError _ _ err) =+ case clValue err of+ InstanceSearchDepthExhausted{} -> True+ _ -> False+ hardFailure _ = False++ handle :: TCErr -> TCM YesNo+ handle err+ | hardFailure err = do+ whenProfile Profile.Instances $ tick "checkCandidateForMeta: no"+ return $ HellNo err+ | otherwise = do+ reportSDoc "tc.instance" 50 $ "candidate failed type check:" <+> prettyTCM err+ whenProfile Profile.Instances $ tick "checkCandidateForMeta: no"+ return No+++nowConsideringInstance :: (ReadTCState m) => m a -> m a+nowConsideringInstance = locallyTCState stConsideringInstance $ const True++-- Rather than just the instance constraints, these are the constraints+-- which could be suspended by being under 'nowConsideringInstances',+-- which also includes unquote constraints.+isInstanceProblemConstraint :: ProblemConstraint -> Bool+isInstanceProblemConstraint c = case clValue (theConstraint c) of+ FindInstance{} -> True+ UnquoteTactic{} -> True+ _ -> False++wakeupInstanceConstraints :: TCM ()+wakeupInstanceConstraints =+ unlessM shouldPostponeInstanceSearch $ do+ wakeConstraints (wakeUpWhen_ isInstanceProblemConstraint)+ solveAwakeInstanceConstraints++solveAwakeInstanceConstraints :: TCM ()+solveAwakeInstanceConstraints =+ solveSomeAwakeConstraints isInstanceProblemConstraint False++postponeInstanceConstraints :: TCM a -> TCM a+postponeInstanceConstraints m =+ locallyTCState stPostponeInstanceSearch (const True) m <* wakeupInstanceConstraints++flushInstanceConstraints :: TCM ()+flushInstanceConstraints = locallyTCState stInstanceHack (const True) $ wakeupInstanceConstraints++-- | To preserve the invariant that a constructor is not applied to its+-- parameter arguments, we explicitly check whether function term+-- we are applying to arguments is a unapplied constructor.+-- In this case we drop the first 'conPars' arguments.+-- See Issue670a.+-- Andreas, 2013-11-07 Also do this for projections, see Issue670b.+-- Szumi, 2025-05-05: Unapplied projections are not considered by instance+-- search since #938.+applyDroppingParameters :: Term -> Args -> TCM Term+applyDroppingParameters t vs = do+ let fallback = return $ t `apply` vs+ case t of+ Con c ci [] -> do+ def <- theDef <$> getConInfo c+ case def of+ Constructor {conPars = n, conData = d} -> do+ -- Szumi, 2025-05-05, issue #7853: don't drop parameters from the current module.+ fv <- getDefFreeVars d+ return $! Con c ci $! map' Apply $ drop (n - fv) vs+ _ -> __IMPOSSIBLE__+ -- Def f [] -> do+ -- -- Andreas, 2022-03-07, issue #5809: don't drop parameters of irrelevant projections.+ -- mp <- isRelevantProjection f+ -- case mp of+ -- Just Projection{projIndex = n} -> do+ -- case drop n vs of+ -- [] -> return t+ -- u : us -> (`apply` us) <$> applyDef ProjPrefix f u+ -- _ -> fallback+ _ -> fallback++---------------------------------------------------------------------------+-- * Instance definitions+---------------------------------------------------------------------------++data OutputTypeName+ = OutputTypeName QName+ | OutputTypeVar+ | OutputTypeVisiblePi+ | OutputTypeNameNotYetKnown Blocker+ | NoOutputTypeName++-- | Strips all hidden and instance Pi's and return the argument+-- telescope, the head term, and its name, if possible.+getOutputTypeName :: Type -> TCM (Telescope, Term, OutputTypeName)+-- 2023-10-26, Jesper, issue #6941: To make instance search work correctly for+-- abstract or opaque instances, we need to ignore abstract mode when computing+-- the output type name.+getOutputTypeName t = ignoreAbstractMode $ do+ TelV tel t' <- telViewUpTo' (-1) notVisible t+ ifBlocked (unEl t') (\b t -> return (tel , __DUMMY_TERM__, OutputTypeNameNotYetKnown b)) $ \ _ v ->+ case v of+ -- Possible base types:+ Def n _ -> return (tel, v, OutputTypeName n)+ Sort{} -> return (tel, v, NoOutputTypeName)+ Var n _ -> return (tel, v, OutputTypeVar)+ Pi{} -> return (tel, v, OutputTypeVisiblePi)+ -- Not base types:+ Con{} -> __IMPOSSIBLE__+ Lam{} -> __IMPOSSIBLE__+ Lit{} -> __IMPOSSIBLE__+ Level{} -> __IMPOSSIBLE__+ MetaV{} -> __IMPOSSIBLE__+ DontCare{} -> __IMPOSSIBLE__+ Dummy s _ -> __IMPOSSIBLE_VERBOSE__ (show s)+++-- | Register the definition with the given type as an instance.+-- Issue warnings if instance is unusable.+addTypedInstance ::+ KwRange -- ^ Range of the @instance@ keyword.+ -> QName -- ^ Name of instance.+ -> Type -- ^ Type of instance.+ -> TCM ()+addTypedInstance = addTypedInstance' True False Nothing++-- | Like 'addTypedInstance', but delete any existing entries for the+-- given name from the discrimination tree.+readdTypedInstance ::+ KwRange -- ^ Range of the @instance@ keyword.+ -> QName -- ^ Name of instance.+ -> Type -- ^ Type of instance.+ -> TCM ()+readdTypedInstance = addTypedInstance' True True Nothing++-- | Register the definition with the given type as an instance.+addTypedInstance'+ :: Bool -- ^ Should we print warnings for unusable instance declarations?+ -> Bool -- ^ Is this the second time we're adding this QName as an instance?+ -> Maybe InstanceInfo -- ^ Is this instance a copy?+ -> KwRange -- ^ Range of the @instance@ keyword.+ -> QName -- ^ Name of instance.+ -> Type -- ^ Type of instance.+ -> TCM ()+addTypedInstance' w readd orig kwr inst t = do+ reportSDoc "tc.instance.add" 30 $ vcat+ [ "adding typed instance" <+> prettyTCM inst <+> "with type"+ , prettyTCM =<< flip abstract t <$> getContextTelescope+ ]++ (tel, hdt, n) <- getOutputTypeName t+ case n of+ OutputTypeName n -> addContext tel $ do+ tele <- getContextTelescope++ -- Insert the instance into the instance table, putting it in the+ -- discrimination tree *and* bumping the total number of instances+ -- for this class.+ tree <- useTC stInstanceTree++ -- Amélia, 2025-02-28: If the instance we're adding has no type+ -- signature, we end up adding it to the tree twice: once with a+ -- useless type, and once after checking the RHS (which will have+ -- narrowed the type).+ --+ -- To avoid spurious overlap, the useful key should trump the+ -- useless key, so we filter this QName out of the tree when+ -- re-adding an instance.+ let+ tree' | readd = deleteFromDT (Set.singleton inst) tree+ | otherwise = tree++ tree' <- insertDT (length tele) hdt inst $! tree'+ setTCLens stInstanceTree tree'++ modifyTCLens' (stSignature . sigInstances . itableCounts) $+ if readd then id else Map.insertWith (+) n 1++ let+ info = flip fromMaybe orig InstanceInfo+ { instanceClass = n+ , instanceOverlap = DefaultOverlap+ }++ -- This is no longer used to build the instance table for imported+ -- modules, but it is still used to know if an instance should be+ -- copied when applying a section.+ modifySignature $ updateDefinition inst \ d -> d { defInstance = Just info }++ -- If there's anything visible in the context, which will+ -- eventually end up in the instance's type, let's make a note to+ -- get rid of it before serialising the instance table.+ con <- isConstructor inst+ -- However, do note that data constructors can have "visible+ -- arguments" in their global type which.. aren't actually+ -- visible: the parameters.+ when (any visible tele && not con) $ modifyTCLens' stTemporaryInstances $ Set.insert inst++ OutputTypeNameNotYetKnown b -> do+ addUnknownInstance inst+ addConstraint b $ ResolveInstanceHead kwr inst++ NoOutputTypeName -> when w $ warning $ WrongInstanceDeclaration kwr+ OutputTypeVar -> when w $ warning $ WrongInstanceDeclaration kwr+ OutputTypeVisiblePi -> when w $ warning $ InstanceWithExplicitArg kwr inst++resolveInstanceHead ::+ KwRange -- ^ The range of the @instance@ keyword.+ -> QName -> TCM ()+resolveInstanceHead kwr q = do+ clearUnknownInstance q+ -- Andreas, 2022-12-04, issue #6380:+ -- Do not warn about unusable instances here.+ addTypedInstance' False True Nothing kwr q =<< typeOfConst q++-- | Try to solve the instance definitions whose type is not yet known, report+-- an error if it doesn't work and return the instance table otherwise.+getInstanceDefs :: TCM InstanceTable+getInstanceDefs = do+ (table, pending) <- getAllInstanceDefs+ unless (null pending) $ do+ patternViolation alwaysUnblock -- TODO: more refined unblocking+ return table++-- | Prune an 'Interface' to remove any instances that would be+-- inapplicable in child modules.+--+-- While in a section with visible arguments, we add any instances+-- defined locally to the instance table: you have to be able to find+-- them, after all! Conservatively, all of the local variables are+-- turned into 'FlexK's, i.e., wildcards.+--+-- But when we leave such a section, these instances have no more value:+-- even though they might technically be in scope, their types are+-- malformed, since they have visible pis.+--+-- This function deletes these instances from the instance tree in the+-- given signature to save on serialisation time *and* time spent+-- checking for candidate validity in client modules. It can't do this+-- directly in the TC state to prevent these instances from going out of+-- scope before interaction (see #7196).+pruneTemporaryInstances :: Interface -> TCM Interface+pruneTemporaryInstances int = do+ todo <- useTC stTemporaryInstances++ reportSDoc "tc.instance.prune" 30 $ vcat+ [ "leaving section"+ , prettyTCM =<< getContextTelescope+ , "todo:" <+> prettyTCM todo+ ]++ let sig' = over (sigInstances . itableTree) (deleteFromDT todo) (iSignature int)+ pure int{ iSignature = sig' }
@@ -0,0 +1,8 @@+module Agda.TypeChecking.InstanceArguments where++import Agda.TypeChecking.Monad.Base (TCM, InstanceInfo)++import Agda.Syntax.Common (KwRange)+import Agda.Syntax.Internal (QName, Type)++addTypedInstance' :: Bool -> Bool -> Maybe InstanceInfo -> KwRange -> QName -> Type -> TCM ()
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff
file too large to diff