<       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!"""""#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'%(%)%*%+%,%-%.%/%0%1%2%3%4%5&6&7&8&9&:&;&<&=&>'?'@'A'B'C'D'E'F'G'H'I'J'K(L(M(N(O(P(Q(R(S(T)U*V*W*X*Y*Z*[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     +,,,,,,,,,,------- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P/Q/R/S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111112222222222333333333333333444444444455555566666 6 6 6 6 66666666666 !"#$%&'()7*7+7,7-7.7/707172737475767778797:7;7<7=7>7?7@7A7B7C7D7E7F7G7H7I7J7K7L7M7N7O7P7Q7R7S7T7U7V7W7X7Y8Z8[8\8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}8~88888889:;;;;;;;;<<<<<<<<<===========================>>>>>>>>???????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @ @ @ @ @@@@@@@@@@@@@@@@@@@ @!@"@#@$@%@&@'@(@)@*@+@,@-@.@/@0@1@2@3@4@5@6@7@8@9A:A;A<A=A>A?A@AAABACADAEAFAGAHAIAJAKALAMANBOBPBQBRBSBTBUBVBWBXBYBZB[B\B]B^B_B`BaCbCcCdCeCfCgChCiCjCkClDmDnEoEpEqErEsFtFuGvHwHxHyHzH{H|H}H~HHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIJJJJJJJJJJJKKKKKKKKKKKKKKKKKKLLLMMMMMMMMMMMMMNNNNNNOPQQQQQQQQQQQQQQQQRRRRRRRRRRRSSSSSSSSSSSSSS S S S S S S S T T T U U U U U U V V V W W W W X X X Y Y Z Z [ [ [ ![ "[ #[ $[ %[ &[ '[ (\ )\ *] +] ,] -] .] /^ 0^ 1^ 2^ 3^ 4^ 5^ 6^ 7^ 8^ 9^ :^ ;^ <^ =^ >^ ?^ @^ A^ B^ C^ D^ E^ F^ G^ H_ I_ J_ K_ L_ M_ N_ O_ P_ Q_ R_ S_ T_ U_ V_ W_ X_ Y_ Z_ [_ \_ ]_ ^_ __ `_ a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ {_ |_ }_ ~_ _ _ _ ` ` ` a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a b b b c c c c c d d d d d d d d d d d d d d d d d d d d d d d d d d e e e e f f f f f f f f f f f g g          hNoneM IJKLMNOPQRS IJKLMNOPQR IJKLMNOPQRS IJKLMNOPQRSI4J5K5L5M5N3O3SafeM T UVWXYZTUVWXYZTUVWXZY T UVWXYZNone05M=nsource files to checko%path to directory for including specspBcheck subset of binders modified (+ dependencies) since last checkq1uninterpreted integer multiplication and divisionr,interpretation of string theory in the logics)allow higher order binders into the logictallow higher order qualifiersu$allow function extentionality axiomsv%allow lambda alpha-equivalence axiomsw$allow lambda beta-equivalence axiomsx-allow lambda normalization-equivalence axiomsy'check all binders (overrides diffcheck)zsave fixpoint query{set of binders to check|Iwhether to complain about specifications for unexported and unused values}disable termination check~enable gradual type checkinginteractive gradual solvingBCheck for termination and totality, Overrides no-termination flags*automatically construct proofs from axioms*disable warnings output (only show errors)1disable creation of intermediate annotation files%type all internal variables with truedisable case expandenable strata analysisdisable truing top level types%disable totality check in definitions$enable prunning unsorted Refinements)number of cores used to solve constraintsMinimum size of a partition2Maximum size of a partition. Overrides minPartSizeAthe maximum number of parameters to accept when mining qualifiersBname of smtsolver to use [default: try z3, cvc4, mathsat in order]0drop module qualifers from pretty-printed names.)don't show subtyping errors and contexts.Ifind and use .cabal file to include paths to sources for imported modules#command-line options to pass to GHC..c files to compile and link against (for GHC)Heliminate (i.e. don't use qualifs for) for "none", "cuts" or "all" kvarsport at which lhi should listen<Automatically generate singleton types for data constructors%Disable ADTs (only used with exactDC)?Do not automatically lift data constructor fields into measures.scrape qualifiers from imported specifications*scrape qualifiers from auto specifications4scrape qualifiers from used, imported specificationsprint eliminate stats)eliminate upto given depth of KVar chains#print results (safe/errors) as JSON3attempt to generate counter-examples to type errors2check and time each (asserted) type-sig separatelyAtreat code patterns (e.g. e1 >>= x -> e2) specially for inference9print full blown core (with untidy names) in verbose mode.simplify GHC core before constraint-generationtreat non-linear kvars as cutsHow to instantiate axioms!How to create automatic instancesFuel for axiom instantiationDebug Instantiation!Disable non-concrete KVar slicing9Disable loading lifted specifications (for "legacy" libs)a[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   U[cb\]^_`adefghijklmpznoqrstuvwxy{|}~Ulmnopqrstuvwxyz{|}~[\]^_`abcghijkdef[\]^_`abcdefghijkl>mnopqrstuvwxyz{|}~    None05M  SafeM6Gross hack, to force dependency and loading of module. NoneM Safe 9:;<=DMRFunction Equality )proof operators with optional proof terms5Comparison operators requiring proof terms optionallyBecause provide lemmata ? or "5,Proof combinators (are Proofean combinators)Gproof goes from Int to resolve types for the optional proof combinators%proof operators requiring proof terms*Comparison operators requiring proof terms2      (       3333332333333 SafeBM                    8NoneLM8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKNone 0259;LM.OKSimple unstructured type for panic ----------------------------------------PKGeneric Type for Error Messages -------------------------------------------:INVARIANT : all Error constructors should have a pos fieldQliquid type errorR(liquid type error with a counter-exampleSliquid type errorTcondition failure errorUspecification parse errorVsort error in specificationWsort error in specificationX#multiple alias with same name errorY$multiple specs for same binder errorZ1multiple definitions of the same instance measure[(multiple definitions of the same measure\ duplicate fields in same datacon]+name resolves to multiple possible GHC vars^bad data type specification (?)_*refined datacon mismatches haskell datacon`Invariant sort erroraUsing sort errorbIncompatible using errorcMeasure sort errordHaskell bad Measure erroreUnbound symbol in specificationfUnbound predicate being appliedg#GHC error: parsing or type checkingh)Mismatch between Liquid and Haskell typesi7Mismatch in expected/actual args of abstract refinementj%Cyclic Refined Type Alias Definitionsk5Illegal RTAlias application (from BSort, eg. in PVar)mTermination Errorn!Refined Class/Interfaces ConflictoNon well sorted Qualifierp9Previously saved error, that carries over after DiffChecku Sigh. Other.vhaskell type locationlq type locationDifferent kinds of Check  Obligations% ------------------------------------"Obligation that proves termination!Obligation that proves invariants,Obligation that proves subtyping constraintsKContext information for Error Messages ------------------------------------'Construct and show an Error, then crash'Construct and show an Error, then crash'Construct and show an Error, then crashConstruct and show an Error with an optional SrcSpan, then crash This function should be used to mark unimplemented functionalityConstruct and show an Error with an optional SrcSpan, then crash This function should be used to mark impossible-to-reach codepathsLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                   ! " #eLNMOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzvw{|zvwxyzv}wx~vwvwvwvvvvvvvwvwvwvwvwvwvwvvvwvwvvvvwvwvvwvwvvwvwvwvwLMNO?LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzvw{|zvwxyzv}wx~vwvwvwvvvvvvvwvwvwvwvwvwvwvvvwvwvvvvwvwvvwvwvvwvwvwvw                   ! " #SafeMNone %&9;LMOTKData type for high-level patterns -----------------------------------------e1 >>= x -> e2xm$dTet"return"xeC  x1,...,xni :: NatLT {len patBinds}KLift expressions into High-level patterns ---------------------------------KLower patterns back into expressions -------------------------------------- $ % & $ % &NoneBMNoneM\qThe state of the term oracle (includes complex constraints that cannot progress unless we get more information). 'The environment of the oracle contains 1. A Bool (are there any constraints we cannot handle? (PmExprOther)). 2. A substitution we extend with every step and return as a result.The type of substitutions.`Check whether a constraint (x ~ BOT) can succeed, given the resulting state of the term oracle. (BCheck whether a variable is in the free variables of an expression=Flatten the DAG (Could be improved in terms of performance.).Initial state of the oracle.%Solve a complex equality (top-level). )Solve a complex equality. *EExtend the substitution and solve the (possibly updated) constraints.When we know that a variable is fresh, we do not actually have to check whether anything changes, we know that nothing does. Hence, / simply extends the substitution, unlike what  * does. +Simplify a complex equality. ,tSimplify an expression. The boolean indicates if there has been any simplification or if the operation was a no-op. -@Simplify an equality expression. The equality is given in parts. .:Apply an (un-flattened) substitution to a simple equality. /3Apply an (un-flattened) substitution to a variable.6Apply an (un-flattened) substitution to an expression.&External interface to the term oracle.Type of a PmLit ' ( ) * + , - . /"#$%&'()*0/.-,+321450/.-,+32145(*$'#&%") ' ( ) * + , - . /NoneMsptInitCode module statics+ is a C stub to insert the static entries statics of module into the static pointer table.fEach entry contains the fingerprint used to locate the entry and the top-level binding for the entry.None9;M (Get in-scope type constraints (pm check)(Add in-scope type constraints (pm check)(Get in-scope term constraints (pm check)(Add in-scope term constraints (pm check)xIncrease the counter for elapsed pattern match check iterations. If the current counter is already over the limit, fail<Reset the counter for pattern match check iterations to zero.Emit a warning for the current source location!Get a name from Data.Array.Parallel for the desugarer, from the  00 component of the global desugerar environment.$Lookup a name exported by hi or hiA. Panic if there isn't one, or if it is defined multiple times.%Lookup a name exported by hi or hi, returning  1; if it's not defined. Panic if it's defined multiple times.+3Gets a reference to the SPT entries created so far.7    2 3  !"#$%&'()*+,-.W ! 678      !"#$%&'()*+,W    87     6 '+ !"#$%&! ()*,0    2 3  !"#$%&'()*+,-.NoneMa%Use -XStrict to add a ! or remove a ~Examples: ~pat => pat -- when -XStrict (even if pat = ~pat') !pat => !pat -- always pat => !pat -- when -XStrict pat => pat -- otherwise5789:;<=>?@ABCDEFGHIJKLMNOPQR 4 5 6 7STUVWticks to add, possibly The pattern(Expression to which the pattern is bound~Id the rhs is bound to, for desugaring strict binds (see Note [Desugar Strict binds] in DsBinds) and all the desugared binds 8 9 : ; <XYZ[\]^ =_`aOriginal pattern4789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a4@A789:;<DCEFGHLMOBNPQRJISTUVKYXZ[\]^W=>?_`a0789:;<=>?@ABCDEFGHIJKLMNOPQR 4 5 6 7STUVW 8 9 : ; <XYZ[\]^ =_`aNoneMbcd >ebcdebcdebcd >eNoneMTfg ?h @ Ai B Cjklmn Dop fghijklmnop fgmnjklpohifg ?h @ Ai B Cjklmn DopNoneM E+Represent result signature of a type family FRepresent result signature using a Maybe Kind. Used with data families, where the result signature can be either missing or a kind but never a named result variable. G1Represent injectivity annotation of a type family H Represent a type variable binder I#Represent a kind wrapped in a Maybe J:Construct Core expression for Nothing of a given type name K5Construct Core expression for Nothing of a given type L:Store given Core expression in a Just of a given type name M5Store given Core expression in a Just of a given type N O Pq Q R S T U V W X E F G Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  H I                           ! " # $ % & ' ( ) * + , - . / 0 1 2 J%Name of the TyCon of the element type KThe element type L%Name of the TyCon of the element type MThe element type 3 4 5 6qq N O Pq Q R S T U V W X E F G Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  H I                           ! " # $ % & ' ( ) * + , - . / 0 1 2 J K L M 3 4 5 6NoneMrstu 7v 8rstuvrstuvrstu 7v 8NoneM 9w : ; < = > ? @ A B C D E F G H I J K L M Nww 9w : ; < = > ? @ A B C D E F G H I J K L M NNoneMx}Desugar top level binds, strict binds are treated like normal binds since there is no good time to force before first usage.yDesugar all other kind of bindings, Ids of strict binds are returned to later be forced in the binding gorup body, see Note [Desugar Strict binds] O7Desugar a single binding (or group of recursive binds).xy P Q OThe Ids of strict binds, to be forced in the body of the binding group see Note [Desugar Strict binds] and all bindings and their desugared right hand sides. R S Tz{ U|}~ V W X Y Z [ \ ] xyz{|}~ xy|z}~{xy P Q O R S Tz{ U|}~ V W X Y Z [ \ ]NoneM ^ _ ` a b c ^ _ ` a b cNone!"M d1Decide whether to add a tick to a binding or not. e A let body is treated differently from addTickLHsExprEvalInner above with TickForBreakPoints, because for breakpoints we always want to tick the body, even if it is not a redex. See test break012. This gives the user the opportunity to inspect the values of the let-bound variables. fTickishs that only make sense when their source code location refers to the current file. This might not always be true due to LINE pragmas in the code - which would confuse at least HPC.x g h i j k l m n o p q r s t u v w x y z { | } ~   d e f ] g h i j k l m n o p q r s t u v w x y z { | } ~    d e f None%&,DM> ^The arity of a pattern/pattern vector is the number of top-level patterns that are not guards Pattern check resultRedundant clausesNot-covered clausesClauses with inaccessible RHS Term and type constraints to accompany each value vector abstraction. For efficiency, we store the term oracle state instead of the term constraints. TODO: Do the same for the type constraints? Value Vector Abstractions$Check a single pattern binding (let) $Check a single pattern binding (let)*Check a matchgroup (case, functions, etc.) *Check a matchgroup (case, functions, etc.) IA fake guard pattern (True <- _) used to represent cases we cannot handle ECheck whether a guard pattern is generated by the checker (unhandled)  Generate a canFail" pattern vector of a specific type ,Create an empty list pattern of a given type )Create a (non-overloaded) literal pattern %Translate an overloaded literal (see tidyNPat in deSugar/MatchLit.hs) {Translate a list of patterns (Note: each pattern is translated to a pattern vector but we do not concatenate the results). Translate a constructor pattern 8Translate a list of guard statements to a pattern vector )Check whether a pattern can fail to match &Translate a guard statement to Pattern Translate let-bindings Translate a pattern guard Translate a boolean guard Get the type out of a PmPat. For guard patterns (ps <- e) we use the type of the first (or the single -WHEREVER IT IS- valid to use?) pattern vGenerate a value abstraction for a given constructor (generate fresh variables of the appropriate type for arguments) Create a guard pattern 9Create a term equality of the form: `(False ~ (x ~ lit))` /Create a term equality of the form: `(x ~ lit)` +Generate a variable pattern of a given type 6Generate many variable patterns, given a list of types Generate a fresh   of a given type tGenerate a fresh term variable of a given and return it in two forms: * A variable pattern * A variable expression )Convert a value abstraction an expression uConvert a pattern vector to a list of value abstractions by dropping the guards (See Note [Translating As Patterns]) Convert a pattern to a list of value abstractions (will be either an empty list if the pattern is a guard pattern, or a singleton list in all other cases) by dropping the guards (See Note [Translating As Patterns]) 4Get all constructors in the family (including given) 7Check whether a set of type constraints is satisfiable. mCompute the arity of a pattern vector patVecArity :: PatVec -> PmArity patVecArity = sum . map patternArityCompute the arity of a pattern Lift a pattern matching action from a single value vector abstration to a value set abstraction, but calling it on every vector and the combining the results. jGenerate the initial uncovered set. It initializes the delta with all term and type constraints in scope. fIncrease the counter for elapsed algorithm iterations, check that the limit is not exceeded and call  fIncrease the counter for elapsed algorithm iterations, check that the limit is not exceeded and call  fIncrease the counter for elapsed algorithm iterations, check that the limit is not exceeded and call  Matching function: Check simultaneously a clause (takes separately the patterns and the list of guards) for exhaustiveness, redundancy and inaccessibility. Check the list of guards WWorker function: Implements all cases described in the paper for all three functions (covered,  uncovered and  divergent) apart from the Guard cases which are handled by  CTake the tail of all value vector abstractions in the uncovered set RPrepend a value abstraction to all value vector abstractions in the uncovered set "Given a data constructor of arity a^ and an uncovered set containing value vector abstractions of length `(a+n)`, pass the first nj value abstractions to the constructor (Hence, the resulting value vector abstractions will have length `n+1`) Get the union of two covered, uncovered and divergent value set abstractions. Since the covered and divergent sets are represented by a boolean, union means computing the logical or (at least one of the two is non-empty). FAdd a value vector abstraction to a value set abstraction (uncovered). "Set the divergent set to not empty 2Set the divergent set to non-empty if the flag is  Generate equalities when checking a case expression: case x of { p1 -> e1; ... pn -> en } When we go deeper to check e.g. e1 we record two equalities: (x ~ y), where y is the initial uncovered when checking (p1; .. ; pn) and (x ~ p1).Generate a simple equality when checking a case expression: case x of { matches } When checking matches we record that (x ~ y) where y is the initial uncovered. All matches will have to satisfy this equality.Check whether any part of pattern match checking is enabled (does not matter whether it is the redundancy check or the exhaustiveness check). Apply a term substitution to a value vector abstraction. All VAs are transformed to PmExpr (used only before pretty printing). Wrap up the term oracle's state once solving is complete. Drop any information about unhandled constraints (involving HsExprs) and flatten (height 1) the substitution. BIssue all the warnings (coverage, exhaustiveness, inaccessibility) cIssue a warning when the predefined number of iterations is exceeded for the pattern match checker ICheck whether the exhaustiveness checker should run (exhaustiveness only) LDenotes whether an exhaustiveness check is supported, and if so, via which   it's controlled. Returns  1 if check is not supported. This variable shows the maximum number of lines of output generated for warnings. It will limit the number of patterns/equations displayed to maximum_output. (TODO: add command-line option?)l   Value Set Abstractions     Pattern Vectors Value Abstractions Patterns      ! " # $ % & ' ( ) * + , - . /  0 1 2 3 4 5 6 7        8  9 : ; < = V                 ! " # $ % & ' ( ) * + , - . /  0 1 2 3 4 5 6 7        8  9 : ; < = NoneM'/012 > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _/012210//012 > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ NoneM8 ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  1 ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  !None#M   'the desugared rhs of the bind statement S in (>>=) :: Q -> (R -> S) -> T    NoneM 4The longest list length which we will desugar using build.This is essentially a magic number and its setting is unfortunate rather arbitrary. The idea here, as mentioned in Note [Desugaring explicit lists], is to avoid deforesting large static data into large(r) code. Ideally we'd want a smaller threshold with larger consumers and vice-versa, but we have no way of knowing what will be consuming our list in the desugaring impossible to set generally correctly.0The effect of reducing this number will be that buildP fusion is applied less often. From a runtime performance perspective, applying build more liberally on "moderately" sized lists should rarely hurt and will often it can only expose further optimization opportunities; if no fusion is possible it will eventually get rule-rewritten back to a list). We do, however, pay in compile time. 9Creates an name for an entry in the Static Pointer Table.The name has the form  sptEntry: N where  N) is generated from a per-module counter.3456 3456f653f43456 "NoneM~Extract information from the rename and typecheck phases to produce a dependencies information for the module being compiled."Main entry point to the desugarer.      #NoneM Throw some errors.$Convert a typechecked module to Core    $None$%&9;LMOTb KManipulating Source Spans -------------------------------------------------KDatatype For Holding GHC ModGuts ------------------------------------------KEncoding and Decoding Location --------------------------------------------KGeneric Helpers for Accessing GHC Innards ---------------------------------KPretty Printers -----------------------------------------------------------KManipulating CoreExpr -----------------------------------------------------KPredicates on CoreExpr and DataCons ---------------------------------------KSymbol Conversions --------------------------------------------------------KManipulating Symbols ------------------------------------------------------KGHC Compatibility Layer --------------------------------------------------- NOTE:REFLECT-IMPORTSwe **eschew** the unique suffix for exported vars, to make it possible to lookup names from symbols _across_ modules; anyways exported names are top-level and you shouldn't have local binders that shadow them. However, we **keep** the unique suffix for local variables, as otherwise there are spurious, but extremely problematic, name collisions in the fixpoint environment.Symbol Instances      !"#q     #"!      {       !"#%None9;LMb'()*+,-./01234'()*+,-.*'()4321+0/,-. '()*+,-./01234&NoneM5 A single span6,binder for whom we are generating constraint7nearest known Source Span8 Opaque type for a stack of spans5678 9:; <=56789:;<56789:;< 5678 9:; <='None$%&9;LMOTb JGHC Type Substitutions --------------------------------------------------- >? @ ABCDEFGHIJ                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  >?@>?@  >? @ ABCDEFGHIJ(None09:;LMT) K LM N OP QRSKLMNOPKLMNPO%   K LM N OP QRS)None %&9:;LMOT A  RewriteRule. is a function that maps a CoreExpr to anotherTKTop-level rewriter -------------------------------------------------------- KRewriting Pattern-Match-Tuples -------------------------------------------- `hasTuple ys e` CHECKS if e- contains a tuple that "looks like" (y1...yn) J`replaceTuple ys e e'` REPLACES tuples that "looks like" (y1...yn) with e' The substitution ( \) can change the type of the overall case-expression, so we must update the type of each  1 with its new, possibly updated type. See: Mhttps://github.com/ucsd-progsys/liquidhaskell/pull/752#issuecomment-228946210 8`substTuple xs ys e'` returns e' [y1 := x1,...,yn := xn] D`isVarTup xs e` returns `Just ys` if e == (y1, ... , yn) and xi ~ yi T TT T *None9;ILMUKA-Normalize a module ------------------------------------------------------ A-Normalize a CoreBind3 -------------------------------------------------- *eta-expand CoreBinds with quantified types KANF Environments ----------------------------------------------------------& U       VUU  U       VNone!"*/023459:;<=ILMzbKKVar Profile --------------------------------------------------------------cRecursive binder letrec x = ...dNon recursive binder  let x = ...hInt is the number of casesjProjecting out field ofkKOutput --------------------------------------------------------------------wCAnnotations -------------------------------------------------------Measures Measure Refinement: {v | v = e }Measure Refinement: {v | (? v)  = p }Measure Refinement: {v | p}KRefinement Type Aliases ---------------------------------------------------KModule Names --------------------------------------------------------------KSource Information Associated With Constraints ----------------------------KError Data Type -----------------------------------------------------------.The type used during constraint generation, used also to define contexts for errors, hence in this file, and NOT in elsewhere. **DO NOT ATTEMPT TO MOVE** Am splitting into + global : many bindings, shared across all constraints + local : few bindings, relevant to particular constraintsthe "global" names for modulethe "local" names for sub-exprsKConstructor and Destructors for RTypes ------------------------------------Refinement Type Aliasesname of the aliastype parametersvalue parameterswhat the alias expands tostart positionend positionTermination expressions x -> F.EVar xx -> f xData Constructor DataCon name (fieldName, fieldType)!Possible output (if in GADT form)Data type refinementsType Constructor NameTyvar ParametersPVar ParametersPLabel ParametersData ConstructorsSource PositionDefault termination measureType of Ind-PropEValues Related to Specifications ------------------------------------ERefined Instances ---------------------------------------------------A World is a Separation Logic predicate that is essentially a sequence of binders that satisfies two invariants (TODO:LIQUID): 1. Each `hs_addr :: Symbol` appears at most once, 2. There is at most one  in a list.RTProp is a convenient alias for RefM that will save a bunch of typing. In general, perhaps we need not expose Ref directly at all.Ref describes `Prop ` and HProp? arguments applied to type constructors. For example, in [a] {h- v > h}>, we apply (via * ) * the ( denoted by `{h -> v > h}` to * the K denoted by `[]`. Thus, Ref is used for abstract-predicate (arguments) that are associated with _type constructors_ i.e. whose semantics are _dependent upon_ the data-type. In contrast, the X argument in   in the UReftR applies directly to any type and has semantics _independent of_ the data-type.$Abstract refinement associated with K( "forall x y  z:: Nat, w :: Int7 . TYPE" ^^^^^^^^^^^^^^^^^^^ (rt_pvbind))"forall  zw$ . TYPE" ^^^^^ (rt_sbind)-5For expression arguments to type aliases see testspos vector2.hs0;let LH match against the Haskell type and add k-vars, e.g. `x:_` see testsposHoles.hsFBCo- and Contra-variance for TyCon --------------------------------Indexes start from 0 and type or predicate arguments can be both covariant and contravaariant e.g., for the below Foo dataTypedata Foo a b c d  p:: b -6 Prop, q :: Int -> Prop, r :: a -> Prop> = F (a r -> b p) | Q (c -> a) | G (Int q -> a r)there will be:varianceTyArgs = [Bivariant , Covariant, Contravatiant, Invariant] variancePsArgs = [Covariant, Contravatiant, Bivariant]H variance info for type variablesI%variance info for predicate variablesJ>logical UNARY function that computes the size of the structureMGHC Type ConstructorPredicate ParametersN TyConInfoQ$TyCon name with location informationR!Is this a class type constructor?SIs Promoted Data Con?ZKPredicates ----------------------------------------------------------------^?Abstract Predicate Variables ----------------------------------d*Which Top-Level Binders Should be VerifiedjType parameterskAbstract Refinement parametersl? strata stuffm? Class constraintsnValue parameterso Result typepKWas this specified in GADT style (if so, DONT use function names as fields))Map from symbols to equations they defineMap from (lifted) Vars to :; see: NOTE:LIFTED-VAR-SYMBOLS and NOTE:REFLECT-IMPORTs&The following is the overall type for specificationsA obtained from parsing the target source and dependent librariesAsserted ReftypesAssumed ReftypesAuto generated SignaturesData Constructor Measure SigsDLiterals/Constants e.g. datacons: EQ, GT, string lits: "zombie",...%Measure Types eg. len :: [a] -> InthData Type Invariants that came from the definition of var measure eg. forall a. {v: [a] | len(v) >= 0}Data Type Invariant Aliases,Predicated Data-Constructors e.g. see testsposMap.hs,Predicated Type-Constructors eg. see testsposMap.hsList of H free in spec and corresponding GHC var eg. (Cons, Cons#7uz) from testsposex1.hsUHow to embed GHC Tycons into fixpoint sorts e.g. "embed Set as Set_set" from includeDataSet.spec*Qualifiers in Source/Spec files e.g testspos qualTest.hsADTs extracted from Haskell 'data' definitions5Top-level Binders To Verify (empty means ALL binders)8Lexicographically ordered size witnesses for termination5Lexicographically ordered expressions for termination Mapping of  'newtype', type constructors with their refined types.AVariables that should be checked in the environment they are used-Binders to IGNORE during termination checking-Binders to IGNORE during termination checkingJBinders to expand with automatic axiom instances maybe with specified fuelConfiguration OptionsName's exported by the module being verifiedDictionary EnvironmentAxioms from reflected functionsBinders for reflected functionsRefinement type aliases=GHC Information : Code & Spec ------------------------------Source file for moduleName for module(GHC Env used to resolve names for module Source Code?4Binders that are _read_ in module (but not defined?)0(Top-level) binders that are _defined_ in modulelBinders that are _read_ in module , tyCons :: ![TyCon] -- ^ Types that are defined inside moduleImported .hqual files ??? dead? ??? dead?(All specification information for moduleHPrinter ----------------------------------------------------------------Accessors for RTyCon;JF.PPrint -----------------------------------------------------------------GName of the data-typeIFor debugging.fKTyConable Instances -------------------------------------------------------c[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>  ?@    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~l=<9;:@?>ABCDEGH[cb\]^_`almpznoqrstuvwxy{|}~LNMOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~[\]^_`abgihcdefjklmnopqrstuvwxyz{|}~      !"#$*%&'()+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bacdfeghjiklmnopqrstuvwxyz{|}~  lmnopqrstuvwxyz{|}~[\]^_`abcdef=<;:9CBAHGOPQRSVWKLMNFGHIJ$%&'()*+,-./0123452678797:;<23=73>7?@2ABC7TU !"#^_`abc[\]XY     ghijklmnopqrstuvwxyzEDZwxrstuvklmnopq@>?ED[\]^_`yz{|}~bcdefghija{|}~  P[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$)%&'()*+,-./0123452678797:;<23=73>7?@2ABC7DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg hijklmnopqrstuvwxyz{|}~!  !"#$%&'()*+,-./0123456789:;<=>  ?@    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~+NoneMABCDABCD,None9;MEFGHIJEFGHIJ-None059;M !"#$%&'()*+,-./012345! "#$%&'()*+,-./0()*+,-54.'&%32$#/0 !"1 !"#$%&'()*+,-./012345.None*:LMKFrom GHC: TypeRepBKPretty Printing RefType ---------------------------------------------------OKA whole bunch of PPrint instances follow ----------------------------------1;<=LMNOP>QRSTKUVWXYZ[\]^_`abcdef?@ABCDEFGHIJKLMNO;<=>>;<=1;<=LMNOP>QRSTKUVWXYZ[\]^_`abcdef?@ABCDEFGHIJKLMNO/None9;M ghPijklmQRPP ghPijklmQR0None%&*9:;<=LMOTnKEmbedding RefTypes --------------------------------------------------------W)Various functions for converting vanilla o to Spec]KHelper Functions (RJ: Helping to do what?) --------------------------------yKType Substitutions --------------------------------------------------------KAnnotations and Solutions -------------------------------------------------KFrom Old Fixpoint ---------------------------------------------------------TBinders generated by class predicates, typically for constraining tyvars (e.g. FNum)KTermination Predicates ----------------------------------------------------p NOTE=THIS IS WHERE THE TERMINATION METRIC REFINEMENTS ARE CREATED.KPrinting Refinement Types -------------------------------------------------LAuxiliary Stuff Used Elsewhere ---------------------------------------------KConverting to Fixpoint ----------------------------------------------------KWrappers for GHC Type Elements --------------------------------------------JReftable Instances -------------------------------------------------------GSubable Instances -----------------------------------------------------nqrstuvSwTUVWXYZ[\xy]^_z{|`}a~bcdefghijklmnopqrstuvwxyz{|}~p>STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>\[WXYZUVSrsmn|}c^]hgdeiy{zwxvutoplqf~kjT_ba`nqrstuvSwTUVWXYZ[\xy]^_z{|`}a~bcdefghijklmnopqrstuvwxyz{|}~p1None05:LMThe name of the bound(Type variables that appear in the bounds'These are abstract refinements, for nowThese are value variablesThe body of the bound  2None9:M    3None09:;LM pvarRType  returns a trivial RType2 corresponding to the function signature for a PVar . For example, if  :: T1 -> T2 -> T3 -> Prop then  pvarRType  returns an RType with an RTycon called  predRTyCon `RApp predRTyCon [T1, T2, T3]` Instantiate ^ with 0 ----------------------------------------------- replacePredsk is the main function used to substitute an (abstract) predicate with a concrete Ref, that is either an  or RHProp4 type. The substitution is invoked to obtain the  resulting at predicate application sites in jk. The range of the ^ substitutions are fresh or true RefType0. That is, there are no further _quantified_ ^ in the target. Requires:  not $ null sB substRCon :: String -> (RPVar, SpecType) -> SpecType -> SpecTypeGInterface: Modified CoreSyn.exprType due to predApp -------------------#!ghjiklmnopqrstuvwxyz!rstuvwxyzghijklmnopq#4None09:;LMT 5NoneLMThe TagKey is the top-level binder, and Tag is a singleton Int list  6NoneM 3Separating literate files into code/comment chunks. type string error stringBline number, total width of lines i.e. max (length (show lineNum)) Loc -> (Var, Type) List of error intervalsAFormats Haskell source code using HTML and mouse-over annotationsAFormats Haskell source code using HTML and mouse-over annotations"annotTokenise is absurdly slow: O( tokens x errors)IThe code for classify is largely stolen from Language.Preprocessor.Unlit.;Join up chunks of code/comment that are next to each other.3     Whether to include anchors.1Whether input document is literate haskell or not3Haskell source code, Annotations as comments at endColoured Haskell source code.Whether to include anchors.!Function to refine comment tokens1Whether input document is literate haskell or notHaskell Source, AnnotationsColoured Haskell source code.          $     None9:;MCConverting Results To Answers -------------------------------------This function is put in this module as it depends on the Exception instance, which depends on the PPrint instance, which depends on tidySpecType.Show an Error, then crash$KPretty Printing Error Messages -------------------------------------------- Need to put  PPrint Error: instance here (instead of in Types), as it depends on PPrint SpecTypes, which lives in this module.  !"#$%&'(FF !"#$%&'(7None*59:;M + User-defined properties for ADTs,9Assumed (unchecked) types; including reflected signatures-Imported functions and types.Local type signatures/Reflected type signatures0Data type invariants1"Data type invariants to be checked2Loaded spec module names3Predicated data definitions4Predicated new type definitions5Included qualifier files6RefType aliases7Expression aliases8GHC-Tycon-to-fixpoint Tycon map9Qualifiers in source/spec files:#Information on decreasing arguments;AVariables that should be checked in the environment they are used<Ignore Termination Check in these Functions , axioms :: !(S.HashSet LocSymbol) -- ^ Binders to turn into SMT axioms=Binders to reflect>MAutomatically instantiate axioms in these Functions with maybe specified fuel?7Binders to turn into measures using haskell definitions@5Binders to turn into bounds using haskell definitionsA;Binders to turn into logic inline using haskell definitionsB4Type Constructors that get automatically sizing infoC4Command-line configurations passed in through sourceD!Measures attached to a type-classE'Mappings from (measure,type) -> measureFRefined Type-ClassesG$Terminating Conditions for functionsI? Where do these come from ?!KKTemporary (?) hack to deal with dictionaries in specifications see testspos NatClass.hsL,AxiomEqualities used for Proof-By-Evaluation<)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST U    VW3[\]^_`)*5A<J92-K+,./0134678:;=>?@BCDEFGHILMNOPQRSTU3)*+,-./0123456789:;<=>?@ABCDEFGHIJKL[\]^_`ONMQSRPTU)#*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST U    VW8None09:;LM KBareTypes ----------------------------------------------------------------- NOTE:BARETYPE-PARSE#Fundamentally, a type is ofthe formcomp -> comp -> ... -> compSobt = comp | comp '->' bt!comp = circle | '(' bt ')'Qcircle = the ground component of a baretype, sans parens or "->" at the top levelEach comp^ should have a variable to refer to it, either a parser-assigned one or given explicitly. e.g. xs : [Int]|KTop Level Parsing API -----------------------------------------------------5Used to parse .hs and .lhs files (via ApiAnnotations)}Used to parse .spec files~The top-level parser for "bare" refinement types. If refinements are not supplied, then the default "top" refinement is used. For debugging-Parse a single top level liquid specificationTry the given parser on the tail after matching the reserved word, and if it fails fall back to parsing it as a haskell signature for a function with the same name.KSame as tyBindsP, except the single initial symbol has already been matched class measureLHS of the thing being defined@Parsing Qualifiers ---------------------------------------------YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'Yvoeks`zZ[\]^_abcdfghijlmnpqrtuwxy{|}~'|}~{YZ[\]^_`abcdefghijklmnopqrstuvwxyzY!Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9NoneM:None9;M  ;None9:;LM CJSON: Annotation Data Types ---------------------------------------output" creates the pretty printed outputannotate% actually renders the output to filesDPandoc HTML Rendering (for lhs + markdown source) ------------------DDirect HTML Rendering (for non-lhs/markdown source) ----------------topAndTail True is used for standalone HTML; topAndTail False for embedded HTMLIBuilding Annotation Maps ------------------------------------------------TThis function converts our annotation information into that which is required by jl& to generate mouseover annotations.ITokenizing Refinement Type Annotations in @-blocks ----------------------OThe token used for refinement symbols inside the highlighted types in @-blocks.^The top-level function for tokenizing @-block annotations. Used to tokenize comments by ACSS.CCreating Vim Annotations ------------------------------------------KLH Related Stuff ----------------------------------------------------------KA Little Unit Test --------------------------------------------------------CJSON Instances ----------------------------------------------------=7<None9;LMTAttempt to canonicalize all  s in the l3 so we don't have to worry about relative paths.Updating optionsCExit Function -----------------------------------------------------      pp      =None9:;M3Intervals of line numbers that have been re-checked-Map from saved-line-num ---> current-line-num"Variable dependencies "call-graph"Variable definitions&line at which binder definition starts$line at which binder definition endsname of binderKData Types ----------------------------------------------------------------+Main type of value returned for diff-check. checkedNames@ returns the names of the top-level binders that will be checked returns a subset of the  [CoreBind] of the input targetm file which correspond to top-level binders whose code has changed and their transitive dependencies.~Add the specified signatures for vars-with-preserved-sigs, whose bodies have been pruned from [CoreBind] into the "assumes"thin cbs sp vs returns a subset of the cbs :: [CoreBind]+ which correspond to the definitions of vs and the functions transitively called therein for which there are *no* type signatures. Callees with type signatures are assumed to satisfy those signatures.(Given a call graph, and a list of vars,  checks all functions to see if they call any of the functions in the vars list. If any do, then they must also be rechecked. cuts off the start-line to be no less than the line at which the binder is defined. Without this, i.e. if we ONLY use the ticks and spans appearing inside the definition of the binder (i.e. just eSp) then the generated span can be WAY before the actual definition binder, possibly due to GHC INLINE pragmas or dictionaries OR ... for an example: see the "INCCHECK: Def" generated by liquid -d benchmarksbytestring-0.9.2.1Data/ByteString.hs where spanEnd~ is a single line function around 1092 but where the generated span starts mysteriously at 222 where Data.List is imported.KDiff Interface ------------------------------------------------------------,`lineDiff new old` compares the contents of src with dst and returns the lines of src that are different."Identifies lines that have changedsave" creates an .saved version of the target; file, which will be used to find what has changed the  next time target is checked.getShift lm old returns Just  if the line number old shifts by  in the diff and returns Nothing otherwise.setShift (lo, hi, ) lm updates the interval map lm appropriatelyKAeson instances -----------------------------------------------------------N !"#$%&'()*+,-./012345 Starting lineList of lengths of diffsList of changed line numbers6789:;<=>?@ABCDE  F !"#$%&'()*+,-./0123456789:;<=>?@ABCDE>None02LMFGHIJKLMNOPQRSTUFGHIJKLMNOPQRSTUmNoneM?NoneM6Horrible hack to support hardwired symbols like V, W, X, Yw and other LH generated symbols that *do not* correspond to GHC Vars and *should not* be resolved to GHC Vars.KLH Primitive TyCons -------------------------------------------------------BLH Primitive TyCons ----------------------------------------------ZKPredicate Types for WiredIns ----------------------------------------------[\]^Z_`abc  [\]^Z_`abc@None:CLMBKFixpoint Environment ------------------------------------------------------%Integer Keys for Fixpoint EnvironmentFixpoint Environment!Map from Symbol to current BindIddKHelper Types: Invariants --------------------------------------------------KHelper Types: HEnv --------------------------------------------------------KGeneration: Types ---------------------------------------------------------top-level fixpoint env subtyping constraints over RType%wellformedness constraints over RType.additional stratum constrains for let bindings$subtyping over Sort (post-splitting).tracks constraints that come from let-bindings5wellformedness constraints over Sort (post-splitting)"counter for generating fresh KVarsset of environment binderssource-position annotation map#information about type-constructors ? FIX THIS?Mapping of new type type constructors with their refined types.+Terminating Metrics for Recursive functions3Set of variables to ignore for termination checking)"Lazy binders", skip termination checking ? FIX THIS4primitive Sorts into which TyCons should be embedded>Fixpoint Kut variables (denoting "back-edges"/recursive KVars)$Fixpoint "packs" of correlated kvars&Global symbols in the refinement logic1Distinct constant symbols in the refinement logicADTs extracted from Haskell 'data' definitionsCheck Termination (?)Check Strata (?)prune unsorted refinements#Errors during constraint generationProfiling distribution of KVars3number of recursive functions seen (for benchmarks)+Source Span associated with Fixpoint Binder"Refined Types of Data ConstructorsKSubtyping Constraints ----------------------------------------------------- Location in original source fileSpecTypes for Bindings in scope,Map from free Symbols (e.g. datacons) to VarDictionary EnvironmentGlobal literalsDistinct literalsFixpoint Environment0recursive defs being processed (for annotations) 0recursive defs being processed (for annotations) Datatype invariants KDatatype recursive invariants: ignored in the base case assumed in rec call Datatype checkable invariants 6Top-level variables with (assert)-guarantees to verify&Top-level variables with assumed types6Top-level variables with auto generated internal types+How to embed GHC Tycons into fixpoint sorts*Map from top-level binders to fixpoint tagCurrent top-level binder6Type of recursive function with decreasing constraints6Let binding that have not been checked (c.f. LAZYVARs)&Types with holes, will need refreshingLogical ConstraintsKaxiom environment maps reflected Haskell functions to the logical functions{error that should be reported at the user , cgCfg :: !Config -- ^ top-level config optionstop-level GhcInfo top level function being checked/KForcing Strictness --------------------------------------------------------defghi     j !"#klm$no%&'p()*+,-./01234567d      !"#$%&'()e     )(!#$"%&' 0defghi"     j !"#klm$no%&'p()*+,-./01234567ANone 9:;<=LMTBKGeneration: Freshness -----------------------------------------------------FRight now, we generate NO new pvars. Rather than clutter code with W< calls, put it in one place where the above invariant is  obviously4 enforced. Constraint generation should ONLY use  freshTy_type and  freshTy_exprq~Used to generate "cut" kvars for fixpoint. Typically, KVars for recursive definitions, and also to update the KVar profile.)9:;<rstuv=>w?@xyAz{BC|q}D~EFGHIJKLM 9:;<=>?@ABCDE 9:;<=>@?ABCED&9:;<rstuv=>w?@xyAz{BC|q}D~EFGHIJKLMBNone29:;<=ILMTcKRefinement Type Environments ----------------------------------------------#NOPQRSTUVWXYZ[\]^_`NOPQRSTUVWXYZ[\]^_`YVSTXZWNROQP[U\]^_`#NOPQRSTUVWXYZ[\]^_`CNone:LMbb2 adds a subtyping constraint into the global pool.c(addPost: RJ: what DOES this function do?dAdd Well formedness Constrainte Add a warningfNAdd Identifier Annotations, used for annotation binders (i.e. at binder sites)h/Used for annotating reads (i.e. at Var x sites)iHUpdate annotations for a location, due to (ghost) predicate applications abcdefghijk abcdefghijk abcdefghijk abcdefghijkDNone9;MlmlmmllmENone:McKReftypes from F.Fixpoint Expressions --------------------------------------rKConstraint Generation Panic -----------------------------------------------nopqrnopqrpnoqrnopqrFNoneMststststGNoneMJReplace Predicate Arguments With Existentials ----------------------------umNiki: please write more documentation for this, maybe an example? I can't really tell whats going on... (RJ)uuu uHNone:LMKError-Reader-IO For Bare Transformation -----------------------------------u stores the names of those ctor-fields that have been declared as SMT ADTs so we don't make up new names for them.!vwxyz{|}~vwx|yz{}~vwxyz{|}~v wxyz{|}~INone9;LMKExpand Alias Application --------------------------------------------------JNone9:;MKQuerying GHC for Id, Type, Class, Con etc. --------------------------------0It's possible that we have already resolved the : we are looking for, but have had to turn it back into a , e.g. to be used in an Expr , as in {v:Ordering | v = EQ}$. In this case, the fully-qualified  ( GHC.Types.EQO) will likely not be in scope, so we store our own mapping of fully-qualified s to s and prefer pulling  s from it.KNone:M/'makeDataConChecker d' creates the measure for `is$d`5 which tests whether a given value was created by d. e.g. is$Nil or is$Cons.-'makeDataConSelector d' creates the selector  `select$d$i`B which projects the i-th field of a constructed value. e.g. `select$Cons$1` and `select$Cons$2`# are respectively equivalent to V and W.ddLNoneLMMNone9:;LMNNone:LMexprArg converts a tyVar to an exprVar because parser cannot tell HORRIBLE HACK To allow treating upperCase X as value variables X e.g. type Matrix a Row Col = List (List a Row) ColONoneLM initializes the env needed to Q refinements and types, that is, the below needs to be called *before* we use no          PNone:MQNone9:;LM: !"#$%&'()*+,-./0123456789:;<=  1 !"#$%&'()*+,-./0123456789:;<=RNone!":LM>KExpand Measures -----------------------------------------------------------(>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ  &>?@ABCDEFGHIJKLMNOPQRSTUVWXYZSNone:FLMKAPI: Bare Refinement Types ------------------------------------------------$[\]^_ `a b c d e fgh i            $[\]^_ `a b c d e fgh iTNoneM   returns  1 for unhandled lits because otherwise string-literals show up as global int-constants which blow up qualifier instantiation.j  k       j  k UNone:LMlm# qualfies the field names for each 1 to ensure things work properly when exported.nKCreate Fixpoint DataDecl from LH DataDecls --------------------------------A n is associated with a (o and) P, and defines the sort of relation that is established by terms of the given o. A n say, pd is associated with a dd of type  when pd is the  version of the  given by `tycPropTy dd`. NOTE:AUTO-INDPRED (teststodoIndPred1.hs) -- DO NOT DELETE -- RJ: too hard, too brittle, I _thought_ we could just -- generate the F.DataDecl, but really, you need the GHC -- names for the Prop-Ctor if you want to be able to `import` -- a predicate across modules. Seems a LOT easier to just have -- the program explicitly create the the proposition type -- e.g. as shownn in (testspos]IndPred0.hs) --------------------------------------------------------------------------------0type SpecTypeRep = RTypeRep RTyCon RTyVar RReft- |  makePropDecl creates the p for the *proposition* described- by the corresponding o   , e.g. testspos/IndPred0.hs makePropDecl :: F.TCEmb TyCon -> TyCon -> DataPropDecl -> Maybe F.DataDecl makePropDecl tce tc (dd, pd) = makePropTyDecl tce tc dd  $ pd5makePropTyDecl :: F.TCEmb TyCon -> TyCon -> DataDecl -> SpecType -> F.DataDecl makePropTyDecl tce tc dd t = F.DDecl { F.ddTyCon = ftc , F.ddVars = length (ty_vars tRep) , F.ddCtors = [ makePropTyCtor tce ftc tRep ] } where ftc = propFTycon tc dd tRep = toRTypeRep tSpropFTycon :: TyCon -> DataDecl -> F.FTycon propFTycon tc = F.symbolFTycon . fmap (q# F.propConName) . tyConLocSymbol tcmakePropTyCtor :: F.TCEmb TyCon -> F.FTycon -> SpecTypeRep -> F.DataCtor makePropTyCtor tce ftc t = F.DCtor { F.dcName = F.fTyconSymbol ftc , F.dcFields = makePropTyFields tce ftc t }makePropTyFields :: F.TCEmb TyCon -> F.FTycon -> SpecTypeRep -> [F.DataField] makePropTyFields tce ftc t = makeDataFields tce ftc as xts where as = [ a | RTVar a _ <- ty_vars t ] xts = zipWith (i t -> (fld i, t)) [0..] (ty_args t) tcSym = F.fTyconSymbol ftc fld = F.atLoc tcSym . GM.symbolMeasure "propField" (val tcSym) . JustisPropDecl :: F.DataDecl -> Bool isPropDecl d = (F.isSuffixOfSym F.propConName . F.symbol . F.ddTyCon $ d) && (length (F.ddCtors d) == 1)wqualifyDataDecl :: ModName -> DataDecl -> DataDecl qualifyDataDecl name d = d { tycName = qualifyName name (tycName d)}qualifyName :: ModName -> LocSymbol -> LocSymbol qualifyName n x = F.atLoc x $ GM.qualifySymbol nSym (val x) where nSym = GM.takeModuleNames (F.symbol n)KBare Predicate: DataCon Definitions ---------------------------------------r''canonizeDecls ds' returns a subset of dsA where duplicates, e.g. arising due to automatic lifting (via makeHaskellDataDecls). We require that the lifted versions appear LATER in the input list, and always use those instead of the unlifted versions.ss checks that the supplied DataDecl is indeed a refinement of the GHC TyCon. We just check that the right tyvars are supplied as errors in the names and types of the constructors will be caught elsewhere. [e.g. testserrorsBadDataDecl.hs]#ln tu vwxyz{|} ~r sm       #ln tu vwxyz{|} ~r sm  VNone !":FLMT YChecking GhcSpec ------------------------------------------------------------------------ checkRTypeO determines if a type is malformed in a given environment --------------------- checkMeasuresO determines if a measure definition is wellformed -----------------------------!         !   WNone9:;M"Specification for Haskell function          XNone!"$:LM)see NOTE:AUTO-INDPRED in Bare/DataType.hs NOTEREFLECT-IMPORTS nMAKE the full LiftedSpec, which will eventually, contain: makeHaskell{Inlines, Measures, Axioms, Bounds}+SAVE the LiftedSpec, which will be reloadedXThis step creates the aliases and inlines etc. It must be done BEFORE we compute the _ for (all, including the reflected binders), as we need the inlines and aliases to properly  the SpecTypes.KsymbolVarMap resolves each Symbol occuring in the spec to its Var ---------G   %   %   B   YNone$:Mc AUse explicitly given qualifiers .spec or source (.hs, .lhs) filesMScrape qualifiers from function signatures (incr :: x:Int -> {v:Int | v > x})LScrape qualifiers from refinement type aliases (type Nat = {v:Int | 0 <= 0})                  ZNone:M        [None9:;LMTKPer-Module Pipeline ------------------------------------------------------- KGHC Interface Pipeline ---------------------------------------------------- KGHC Configuration & Setup ------------------------------------------------- KExtract Ids ---------------------------------------------------------------KExtract Specifications from GHC -------------------------------------------m pulls out the specification part from a full comment string, i.e. if the string is of the form: 1. '{- S "-}' then it returns the substring S, 2. '{-@ ... -}' then it throws a malformed SPECIFICATION ERROR, and 3. Otherwise it is just treated as a plain comment so we return Nothing.KFinding & Parsing Files ---------------------------------------------------KHandle Spec Files --------------------------------------------------------- 'KPretty Printing ----------------------------------------------------------->   !"#$%&'() !*+,-./0123456789:;<=>?@ABCDEFGHIJ "K # $ % & '   ! "   " ! >   !"#$%&'() !*+,-./0123456789:;<=>?@ABCDEFGHIJ "K # $ % & '\None 9:;<=LMTL&TODO: All this *should* happen inside Bare; but appears to happen after certain are signatures are fresh#-ed, which is why they are here. (MNOPQRSTLUVWXYZ )[ ( ) ( ) (MNOPQRSTLUVWXYZ )[]None/2349:;<=ILMT *KConstraint Generation: Toplevel -------------------------------------------\KTERMINATION TYPE ----------------------------------------------------------]KConstraint Generation: Corebind -------------------------------------------^ varTemplate2 is only called with a `Just e` argument when the e corresponds to the body of a Rec binder._lazVarTemplate is like ^ but for binders that are *not* termination checked and hence, the top-level refinement / KVar is stripped out. e.g. see testsnegrT743.hs varTemplate :: CGEnv -> (Var, Maybe CoreExpr) -> CG (Template SpecType) lazyVarTemplate  (x, eo) = dbg  $ (topRTypeBase  $)  $W varTemplate'  (x, eo) where dbg = traceShow ("LAZYVAR-TEMPLATE: " ++ show x)` topSpecType5 strips out the top-level refinement of "derived var"aKConstraint Generation: Checking -------------------------------------------binstantiatePreds' peels away the universally quantified PVars of a RType, generates fresh Ref. for them and substitutes them in the body.cinstantiateStrata generates fresh Strata: vars and substitutes them inside the body of the type.dKType Synthesis ------------------------------------------------------------eType Synthesis for Special Pattern's -------------------------------------f consFreshE is used to *synthesize* types with a **fresh template**. e.g. at joins, recursive binders, polymorphic instantiations etc. It is the "portal" that connects d (synthesis) and a (checking)gg masks (i.e. true's out) all types EXCEPT those at given indices; it is used to simplify the environment used when projecting out fields of single-ctor datatypes.hBHelpers: Creating Fresh Refinement -------------------------------iKHelpers: Creating Refinement Types For Various Things ---------------------j/create singleton types for function applicationkRJ: nomeet replaces  strengthenS for l in the definition of l . Why does `tests/neg/strata.hs`$ fail EVEN if I just replace the m2 case? The fq file holds no answers, both are sat.nKCleaner Signatures For Rec-bindings ---------------------------------------\opqrs *t\uvwxyz{|}~]^_`abcdefghiljkn * *Xopqrs *t\uvwxyz{|}~]^_`abcdefghiljkn^None$%&*+,DFMQR / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F 7 8 9 : 4 5 6 G 3 2 1 0 / ; < = > ? @ A B C D E F / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G_None!"$IMOT bTwhether to keep going after finding a counter-example, useful for checking coverage c_whether to stop after a certain number of successful tests, or enumerate the whole input space d+whether to use SmallCheck's notion of depth eextra options to pass to GHC r,Find the refined type of a data constructor. sGiven a data constructor d. and an action, create a new choice variable cG and execute the action while guarding any generated constraints with c . Returns (action-result, c). t'Generate a fresh variable of the given . wGiven a data constructor d1, create a new choice variable corresponding to d. xAsk the SMT solver for the % of the given variable.7 H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y1 H I V Y X M U P J K L N O Q R S T W Z [ \ ] ` c ^ _ a b d e f g h i j k l m n o p q r s t u v w x1 k l m n o u v p q r s t w h x f g H I J K L M N O P Q R S T U V W X Y Z [ j \ ] ^ _ ` a b c d e i H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y`None$5M[ TEvaluate a refinement with the given expression substituted for the value variable. ~Evaluate a refinement with the given expression substituted for the value variable, in the given environment of free symbols.      aNone69:;DMQRT[ iA class of datatypes for which we can efficiently generate constrained values by querying an SMT solver.kIf possible, instances should not be written by hand, but rather by using the default implementations via  GHC.Generics, e.g. jimport GHC.Generics import Test.Target.Targetable data Foo = ... deriving Generic instance Targetable Foo PConstruct an SMT query describing all values of the given type up to the given  7. /Reconstruct a Haskell value from the SMT model. }Check whether a Haskell value inhabits the given type. Also returns a logical expression corresponding to the Haskell value. 4Translate a Haskell value into a logical expression. OWhat is the Haskell type? (Mainly used to make the SMT queries more readable). Given a data constuctor d and a refined type for dFs output, return a list of types representing suitable arguments for d. Given a data constructor d and a list of expressions xs/, construct a new expression corresponding to d xs. Split a symbolic variable representing the application of a data constructor into a pair of the data constructor and the sub-variables. (Given a symbolic variable and a list of  (choice, var) pairs, oneOf x choices asserts that x must equal one of the vars in choices. Given a symbolic variable x, figure out which of x-s choice varaibles was picked and return it. CAssert a logical predicate, guarded by the current choice variable. Given a refinement {v | p} and an expression e, construct the predicate p[e/v].X     H   bNone $9:;DMRT   cNone!"$(*,9:;DMRT[ 9A class of functions that Target can test. A function is Testable iff! all of its component types are  $ and all of its argument types are able. You should never have to define a new   instance. |Test that a function inhabits the given refinement type by enumerating valid inputs and calling the function on the inputs.         dNone!"#%&*0ABDMT[ Attempt to monomorphize a  & according to simple defaulting rules. The parsed statement      eNone#LMT This fellow does the real work        fNone059;M JResponse ----------------------------------------------------------------- JCommand ------------------------------------------------------------------ JState --------------------------------------------------------------------           gNoneM      None$AMOT kTest whether a function inhabits its refinement type by enumerating valid inputs and calling the function. Like  , but returns the % instead of printing to standard out. Like  O, but accepts options to control the enumeration depth, solver, and verbosity. Like  , but returns the % instead of printing to standard out.  the functionthe name of the function0the path to the module that defines the function !! " \ ] ` c ^ _ a b d e i &  !" \ ] ^ _ ` a b c d e i   pqrpqspqtpquvwxpyzpq{p|}p~      !"#$%&'()*+,-./0123456789:;<=>? @ A B C D E F G H I J K L M N O O P Q R S T U V W X Y Z Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~             `      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrrstuvwxxyz{|}~ !!! " " " " "#$$$$$$$$$$$$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%&&&&&&&&&'''''''''''''((((((((()******       !"#$%&'()**+,-./01234567889:;<=>>?@ABCDEFFGHGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij+k,l,m,n,o,p,q,r,s,t,u-v-w-x-y-z-{-|-}-~------k-------------------.....................///000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0 0 0 0 00000000000000000001 1!1"1#1$1$1%1&1'1(1)1*1+1,1-1.1/101112232425262728292:2;2<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K4L4M4N4O4P4Q4R4S4T4U5V5W5X5Y5Z5[6\6]6^66_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n|opqrstu+,/vwxyz{7|7|7}7~77777777777777777777777777777777777777777777888888888888888888888888888888888888888888889:;;;;;;;;<<<<<<<<<========================K==N=>>>>>>>>?? ? ? ? ? ?????@@@@@@@@@@@@@@@ @!@"@#@@$@%@&@'@(@)@*@+@,@-@.@/@0@1@2@3@4@5@6@7@8@9@:@;@<@=@>@>@?@?@@@A@B@C@D@E@F@G@H@I@J@K@L@M@N@O@P@Q@R@S@T@U@V@W@X@Y@Z@[@\@]@^@_@`@a@b@c@d@@e@f@g@h@i@j@k@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}@~@@AAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBCCCCCCCCCCCDDEEEEEFFGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIoIIIIIIIIIIIIJJJJJJJJJJJKKKKKKKKKKKKKKKK K K L L L M M M M M M M M M M M M M N N N N N N O P Q Q Q Q Q Q Q !Q "Q #Q $Q %Q &Q 'Q (Q )Q *R +R ,R -R .R /R 0R 1R 2R 3R 4R 5S 6S 7S 8S 9S :S ;S <S =S >S ?S @S AS BS CS DS ES FS GS HS IS JT KT LT MU NU OU PU QU RU SV TV UV VW WWWWX XX YX ZYY [Z \Z ][ ^[ _[ `[ a[ b[ c[ d[ e[ f[ g\ h\ i] j] k] l] m] n^ o^ p^ q^ r^ s^ t^ u^ v^ w^ x^ y^ z^ {^ |^^ }^ ~^ ^ ^ ^^ ^ ^ ^ _ _ _ _ _ _ _ _ _ _ _ _ _ __ _ __ _ _ _ _ _ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ _ __ _ _ __ _ _ _ _ _ _ _ _ _ _ _ _ ` ` ` a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a b b b c c c c c d d d d d d d d d d d d d d d d d d d d d d d d d d e e e e f f f f f f fdf f f flg !g " # $ % & ' ( ) * + , - . / 0 1 2 3 4  5  6  7  8  9  : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `pq a b  c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F  G HD I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !       !        " " " " " " " " " # # # # # # # # && & & & ' ' ' ' ' '                               ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N  O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                  ((( ( (#( ( ( ( ( ( ( ( h( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) )  ) )))))))))) ) ) ) ) ))))))R))**************** *!* *"*#*$*%*&* *'*(*)***+*,*-*.*/*0*1*23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW+X+Y+Z+[,\,],^,_,`,a. 9.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.V.W.z/{/|/}/~///000000000M0000000000000000000000000000000000000000000000000111111223333333333333333333344444455556666666666666666666666666666'66666666     77777 777777778888 8!8"8#8$8%8&8'8(8)8*8+8,8-8.8/8081828384858z868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8\8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}8~8888888888888888888888888888888888888888888888888888888888888888888889::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;p<< < < < < <<< \<<<<<<<<<<<<<<===== =!="=#=$=%=&='=(=)=/=*=+=,=-=.=/=0=1=2=3=4=5=6=7=8=9=:=8=;=<===>=?=@=A=B=C=D=E=F=G=H=I=J=K=L=M=N>O>P>Q>R>S>T>U>V>W>X>Y>Z>[>\>]>^p_`p_apbcpbd?e?f?g?h?i?j?k?l?m?n@o@o@p@q@r@@s@t@u@v@w@x@yAzA{A|A}A~AAAAAAAAAAAAAAABBBBBBBBBBBB BBBBDDDEEEEEEEEEEEEEEEEEEEEEEEEE[FFFFFFGGGGGGGGGGGGGGGHHHIIIIIIpqJJJJJJJJJJJJJJJKKKKKKKLLLLMMMMMMNNNNNNNNNNNNNNOOOOOO O O O O OOOOOOPPPPQQQQQQQQQQ Q!Q"Q#Q Q$Q%Q&Q'Q(Q)Q*Q+Q,Q-Q.Q/Q0Q1Q2Q3Q4Q5Q6Q7Q8Q9Q:Q;Q<Q=Q>Q?RR@RARBRCRDRERFRGRHRIRJRKRLRMRNRORPRQRRRSRTRURVRWRXRYRZR[S\S]S^S_S`SaSbScSdSeSfSgShSiSjTkTlUmUnUoppq.rUsUtUuUvUwUxUyUzU{U|U}U~UUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWW WWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXmXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYY Y Y Y Y ZZZZZZZZ[[[[[[[[[[[ [!["[#[$[%[&['[([)[*[+[,[-[.[/[0[1[2[3[4[5[6[7[8[9[:[;[<[=[>[?[@[A[B[C[D[E[F[G[[H\I\J\K\L\M\N\O\P\Q\ \R\S\T\U\V\W]X]Y]Z][]\]]]^]_]`]a]b]c]d]e]f]g]hpqi]j]k]l]m]n]o]p]q]r]s]t]u]v]w]x]y]z]{]|]}]~]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]q_____``````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbpccc ccccccceeeeeeeeeeeeef\ffg,liquidhaskell-0.8.0.3-1uar7tLHplBBkhvBFAPyWm'Language.Haskell.Liquid.Desugar.DsMonad Test.Target(Language.Haskell.Liquid.Desugar.TmOracleLanguage.Haskell.Liquid.TypesLanguage.Haskell.Liquid.UX.TidyTest.Target.ExprPaths_liquidhaskell!Language.Haskell.Liquid.UX.Config&Language.Haskell.Liquid.Types.Variance,Language.Haskell.Liquid.Types.Specifications#Language.Haskell.Liquid.Types.Names(Language.Haskell.Liquid.ProofCombinatorsLanguage.Haskell.Liquid.PreludeLanguage.Haskell.Liquid.Misc$Language.Haskell.Liquid.Types.ErrorsLanguage.Haskell.Liquid.List#Language.Haskell.Liquid.GHC.ResugarLanguage.Haskell.Liquid.Foreign.Language.Haskell.Liquid.Desugar.StaticPtrTable%Language.Haskell.Liquid.Desugar.Match&Language.Haskell.Liquid.Desugar.DsExpr'Language.Haskell.Liquid.Desugar.DsUtils'Language.Haskell.Liquid.Desugar.DsGRHSs(Language.Haskell.Liquid.Desugar.MatchLit&Language.Haskell.Liquid.Desugar.DsMeta'Language.Haskell.Liquid.Desugar.DsCCall)Language.Haskell.Liquid.Desugar.DsForeign'Language.Haskell.Liquid.Desugar.DsBinds(Language.Haskell.Liquid.Desugar.MatchCon(Language.Haskell.Liquid.Desugar.Coverage%Language.Haskell.Liquid.Desugar.Check(Language.Haskell.Liquid.Desugar.DsArrows*Language.Haskell.Liquid.Desugar.DsListComp'Language.Haskell.Liquid.Desugar.Desugar'Language.Haskell.Liquid.Desugar.HscMain Language.Haskell.Liquid.GHC.Misc Language.Haskell.Liquid.GHC.Play%Language.Haskell.Liquid.GHC.SpanStack#Language.Haskell.Liquid.GHC.TypeRep&Language.Haskell.Liquid.Transforms.Rec*Language.Haskell.Liquid.Transforms.Rewrite&Language.Haskell.Liquid.Transforms.ANF+Language.Haskell.Liquid.Transforms.Simplify$Language.Haskell.Liquid.Types.StrataTest.Target.Types)Language.Haskell.Liquid.Types.PrettyPrint+Language.Haskell.Liquid.Transforms.RefSplit%Language.Haskell.Liquid.Types.RefType$Language.Haskell.Liquid.Types.Bounds*Language.Haskell.Liquid.Types.Dictionaries&Language.Haskell.Liquid.Types.PredType&Language.Haskell.Liquid.Types.Visitors Language.Haskell.Liquid.UX.CTagsLanguage.Haskell.Liquid.UX.ACSSLanguage.Haskell.Liquid.MeasureLanguage.Haskell.Liquid.Parse"Language.Haskell.Liquid.Types.Meet!Language.Haskell.Liquid.UX.Errors#Language.Haskell.Liquid.UX.Annotate"Language.Haskell.Liquid.UX.CmdLine$Language.Haskell.Liquid.UX.DiffCheck&Language.Haskell.Liquid.UX.QuasiQuoterLanguage.Haskell.Liquid.WiredIn(Language.Haskell.Liquid.Constraint.Types(Language.Haskell.Liquid.Constraint.Fresh&Language.Haskell.Liquid.Constraint.Env(Language.Haskell.Liquid.Constraint.Monad-Language.Haskell.Liquid.Constraint.Constraint(Language.Haskell.Liquid.Constraint.Split#Language.Haskell.Liquid.Bare.ToBare(Language.Haskell.Liquid.Bare.Existential Language.Haskell.Liquid.Bare.Env#Language.Haskell.Liquid.Bare.Expand#Language.Haskell.Liquid.Bare.Lookup!Language.Haskell.Liquid.Bare.Misc$Language.Haskell.Liquid.Bare.Plugged$Language.Haskell.Liquid.Bare.Resolve#Language.Haskell.Liquid.Bare.OfType"Language.Haskell.Liquid.Bare.RTEnv$Language.Haskell.Liquid.Bare.SymSort.Language.Haskell.Liquid.Transforms.CoreToLogic$Language.Haskell.Liquid.Bare.Measure!Language.Haskell.Liquid.Bare.Spec&Language.Haskell.Liquid.Types.Literals%Language.Haskell.Liquid.Bare.DataType"Language.Haskell.Liquid.Bare.Check"Language.Haskell.Liquid.Bare.AxiomLanguage.Haskell.Liquid.Bare,Language.Haskell.Liquid.Constraint.Qualifier-Language.Haskell.Liquid.Constraint.ToFixpoint%Language.Haskell.Liquid.GHC.Interface'Language.Haskell.Liquid.Constraint.Init+Language.Haskell.Liquid.Constraint.GenerateTest.Target.UtilTest.Target.MonadTest.Target.EvalTest.Target.TargetableTest.Target.Targetable.FunctionTest.Target.TestableLanguage.Haskell.Liquid.ModelLanguage.Haskell.Liquid.Liquid)Language.Haskell.Liquid.Interactive.Types+Language.Haskell.Liquid.Interactive.HandlerData.Array.ParallelPrimLanguage.Haskell.Liquid ConstraintACSS LiquidHaskellExpandexpandbaseGHC.Base<*>pure*> Applicative(QuickCheck-2.10.1-4LhrkZYHBQBGV9iolvwNWcTest.QuickCheck.All monomorphic Data.Functor<$><* Control.Monad mapAndUnzipMData.TraversablemapMghc TcRnMonad newLocalNamenewUniqueSupply newUnique whenGOptM unsetWOptM unsetGOptM TcRnTypesDsMenumFromThenToPVarenumFromToPVarappPVar emptyPVar indexPVar crossMapPVarzipPVar filterPVarmapPVar singletonPVar replicatePVar lengthPVar PArrBuiltin DsMetaEnvDsSpliceDsBound DsMetaValPmExprpprPmExprWithParens runPmPprM filterComplexhsExprToPmExprlhsExprToPmExprisNotPmExprOther falsePmExpr toComplexeqPmLit PmExprOtherPmExprEq PmExprLit PmExprCon PmExprVarPmOLitPmSLitPmLitSimpleEq ComplexEq UniqSupply MonadUtilsfoldrMfoldlM.liquid-fixpoint-0.7.0.3-KAiUwi99gqCFzmxRW41eBZLanguage.Fixpoint.Types.SpansvallocElocLocLocated#Language.Fixpoint.Types.PrettyPrint pprintTidy pprintPrecPPrintLanguage.Fixpoint.Types.NamesLocText LocSymboldummyLocshowpppprint tidySymbolisDummy dummyNameeqgelegtltiffimpappvarprop $fNumExprversion getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName HasConfig getConfig patternFlaghigherOrderFlag pruneFlag expandFlaghasOpt totalityCheckterminationCheck ProofMethodRewrite AllMethods Instantiate NoInstances SMTInstancesLiquidInstancesLiquidInstancesLocalConfigfilesidirs diffchecklinear stringTheory higherorder higherorderqsextensionalityalphaEquivalencebetaEquivalence normalForm fullcheck saveQuerychecksnoCheckUnknown noterminationgradual ginteractive totalHaskell autoproofs nowarnings noannotationstrustInternals nocaseexpandstrata notruetypes nototality pruneUnsortedcores minPartSize maxPartSize maxParams smtsolver shortNames shortErrorscabalDir ghcOptionscFiles eliminateportexactDCnoADTnoMeasureFields scrapeImportsscrapeInternalsscrapeUsedImports elimStats elimBoundjsoncounterExamples timeBindsnoPatternInline untidyCorenoSimplifyCore nonLinCutsautoInstantiate proofMethodfueldebugInstantionationnoslicenoLiftedImportallowSMTInstationationallowLiquidInstationationallowLiquidInstationationGlobalallowLiquidInstationationLocal allowRewrite$fHasConfigConfig$fShowInstantiate$fDefaultInstantiate$fShowProofMethod$fDefaultProofMethod$fSerializeConfig$fSerializeSMTSolver$fSerializeInstantiate$fSerializeProofMethod$fEqInstantiate$fDataInstantiate$fGenericInstantiate$fEqProofMethod$fDataProofMethod$fGenericProofMethod$fGenericConfig $fDataConfig $fShowConfig $fEqConfigVariance Invariant Bivariant Contravariant Covariant VarianceInfo$fPPrintVariance$fNFDataVariance$fBinaryVariance$fDataVariance$fShowVariance$fGenericVariance specAnchor lenLocSymbol anyTypeSymbolPAndPOrPOrLeftPOrRightArg>.<.>=.<=.==.==?QEDProoftrivial***∵?==>&&&prooftoProof simpleProof<=:<:>:==:castWithTheoremcast byTheorem=*=. $fOptGtab $fOptGta(->) $fOptLessab$fOptLessa(->) $fOptGEqaa $fOptGEqa(->) $fOptLEqab $fOptLEqa(->) $fOptEqab $fOptEqa(->)$fToProvea(->) $fToProveabplusminustimesneqleqgeq liquidAssertB liquidAssert liquidAssume liquidAssumeB unsafeError liquidErrorcrashforcechooseisEvenisOdd safeZipWithNat timedAction!? safeFromJustfst4snd4 mapFourth4addFst3addThd3dropFst3dropThd3replaceNfourth4third4mapSndMfirstMsecondMfirst3Msecond3Mthird3Mthird3zip4 getIncludeDir getCssPathgetCoreToLogicPathsafeZipWithErrorsafeZip3WithErrormapNsmapN zipWithDefMsinglemapFst3mapSnd3mapThd3 firstMaybeshashMapMapWithKeyhashMapMapKeys concatMapM firstElems splitters bchopAltschopAltssortDiff angleBracketsmkGraph tryIgnore=>><<=condNull firstJust intToString mapAccumMifM nubHashOn nubHashLast nubHashLastM WithModelNoModel UserErrorTError ErrSubTypeErrSubTypeModel ErrFCrash ErrAssTypeErrParse ErrTySpec ErrTermSpec ErrDupAlias ErrDupSpecs ErrDupIMeas ErrDupMeas ErrDupField ErrDupNames ErrBadData ErrDataConErrInvtErrIAl ErrIAlMisErrMeasErrHMeas ErrUnbound ErrUnbPredErrGhc ErrMismatch ErrPartPred ErrAliasCycleErrIllegalAliasApp ErrAliasApp ErrTermin ErrRClass ErrBadQualErrSaved ErrFilePragmaErrTyCon ErrLiftExp ErrParseAnnErrOtherposmsgctxtacttexpctxMtactMoblcondpErrtypexpmsg'kindlocstycondconfieldnamesinvtAstUsmshslqTylqPosectrargNexpNactNacyclednamedposbindclsinstsqnamenamtcnameObligOTermOInvOConsCtxErrorctErrctCtxerrorWithContext dropModeluErrorpanicDocpanictodo impossibleppErrorunpackRealSrcSpan realSrcSpanppError'$fFromJSONTError$fToJSONTError$fFromJSONSrcSpan$fToJSONSrcSpan$fFromJSONRealSrcSpan$fToJSONRealSrcSpan$fExceptionTError $fShowTError$fPPrintSrcSpan$fNFDataWithModel$fPPrintTError $fOrdTError $fEqTError$fNFDataParseError $fPPrintOblig $fNFDataOblig $fShowOblig $fBinaryOblig $fOrdCtxError $fEqCtxError$fPPrintParseError$fGenericOblig $fDataOblig$fFunctorWithModel$fShowWithModel $fEqWithModel$fGenericWithModel$fGenericTError$fFunctorTError$fFunctorCtxError transposePatternPatBind PatReturn PatProject PatSelfBindPatSelfRecBindpatE1patXpatE2patMpatDctpatTyApatTyBpatFFpatEpatTypatRetpatXEpatCtorpatBindspatIdxliftlowerintCSizecSizeIntmkPtr isNullPtrfpLenpLenderefeqPtrTmStatePmVarEnv canDivergeflattenPmVarEnvinitialTmState solveOneEq extendSubstexprDeepLookuptmOracle pmLitType sptInitCode DsWarning CanItFailCanFailCantFail MatchResult DsWrapper EquationInfoEqnInfoeqn_patseqn_rhsDsMatchContext idDsWrapperorFailfixDsinitDsinitDsTcinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDs newSysLocalDsnewFailLocalDsnewSysLocalsDs getGhcModeDs getDictsDs addDictsDs getTmCsDs addTmCsDsincrCheckPmIterDs resetPmIterDs getSrcSpanDs putSrcSpanDswarnDs failWithDsmkPrintUnqualifiedDsdsLookupGlobaldsLookupGlobalId dsDPHBuiltin dsLookupTyCondsLookupDataCondsLookupDPHRdrEnvdsLookupDPHRdrEnv_maybedsInitPArrBuiltindsGetFamInstEnvs dsGetMetaEnvdsLookupMetaEnvdsExtendMetaEnvdsGetStaticBindsVardiscardWarningsDs$fMonadThingsIOEnv$fOutputableEquationInfomatchSinglePat matchSimply matchWrappermatch dsLocalBinds dsSyntaxExprdsLExprdsExprCaseAlt MkCaseAltalt_pat alt_bndrs alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkLHsVarPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupId mkOptTickBoxmkBinaryTickBoxdecideBangHood dsGuardeddsGRHSsdsGRHS isTrueLHsExprdsLit dsOverLitwarnAboutIdentitieswarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey hsOverLitKey matchNPatsmatchNPlusKPats dsBracketdsCCallmkFCallunboxArg boxResult resultWrapper dsForeigns dsTopLHsBinds dsLHsBindsdsSpec dsMkUserRuledecomposeRuleLhs dsHsWrapper dsTcEvBinds_s dsTcEvBinds dsEvBindsmatchConFamily matchPatSynaddTicksToBinds hpcInitCode$fMonadUniqueTM$fHasDynFlagsTM $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickDensity$fEqTickishType checkSingle checkMatches genCaseTmCs2 genCaseTmCs1isAnyPmCheckEnabled$fOutputableValVecmatchEquations dsProcExpr dsListComp dsPArrComp dsMonadComp dsValBindsmkDependencies mkUsedNames mkUsageInfodeSugar deSugarExprhscDesugarWithLocPrecL MGIModGutsMI mgi_binds mgi_modulemgi_deps mgi_dir_imps mgi_rdr_envmgi_tcs mgi_fam_insts mgi_exports mgi_cls_instmkAlive miModGuts mg_dir_impsmgi_namestring srcSpanTick tickSrcSpan stringTyVar stringVar stringTyConstringTyConWithKindhasBaseTypeVar isBaseType validTyVartvIdtidyCBsunTick unTickExprisFractionalClasstracePprpprShow toFixSDocsDocDocpprDocshowPprshowSDoc myQualify showSDocDumptypeUniqueStringfSrcSpanfSrcSpanSrcSpansrcSpanFSrcSpansourcePos2SrcSpansourcePosSrcSpansourcePosSrcLocsrcSpanSourcePossrcSpanSourcePosEsrcSpanFilenamesrcSpanStartLoc srcSpanEndLoconeLinelineColrealSrcSpanSourcePosrealSrcSpanSourcePosE getSourcePos getSourcePosE locNamedThingnamedLocSymbol varLocInfocollectArgumentscollectTyBinderscollectValBinders'ignoreLetBinds isTupleId idDataConM isDataConIdgetDataConVarUniqueisDictionaryExpression realTcArity kindArity uniqueHash lookupRdrNamequalImportDecl ignoreInlinesymbolTyConWithKind symbolTyCon symbolTyVarlocalVarSymbolexportedVarSymbolqualifiedNameSymbolfastStringTexttyConTyVarsDefsplitModuleNamedropModuleNamesAndUniquedropModuleNamestakeModuleNamesdropModuleUnique cmpSymbol sepModNames sepUnique mungeNames qualifySymbol isQualified wrapParens isParened isDictionary isInternal stripParensstripParensSym desugarModule gHC_VERSIONsymbolFastStringlintCoreBindingssynTyConRhs_maybetcRnLookupRdrNameshowCBs findVarDefcoreBindSymbols simplesymbolbinders $fNFDataVar $fNFDataType $fNFDataTyCon $fNFDataClass $fShowTyCon $fShowClass $fShowVar $fShowName$fFixpointType$fFixpointName $fFixpointVar$fHashableTyCon $fHashableVar $fSymbolicVar$fSymbolicName$fSymbolicClass$fSymbolicTyCon$fSymbolicFastString$fHashableSrcSpan $fHashableLoc$fOutputableHashSet$fEqLoc$fOrdLoc $fShowLocSubablesubsubTydataConImplicitIdssubVar substTysWithmapTypestringClassArg $fSubableType $fSubableBind $fSubableVar $fSubable(,,)$fSubableCoercion $fSubableExprSpanVarTick SpanStackemptypushsrcSpanshowSpan $fShowSpanFunTymkTyArgshowTy $fSubstTym$fSubstTyCoAxiomRule$fSubstTyUnivCoProvenance$fSubstTyCoAxiom $fSubstTyRole$fSubstTyCoercion $fSubstTyType $fEqCoercion $fEqTyBinder$fEqTypetransformRecExprtransformScope outerScTr innerScTrsetIdTRecBound isIdTRecBound$fFreshableVar$fFreshableUnique$fFreshableInt rewriteBinds anormalize$fHasConfigAnfEnv $fFunctorDsM $fMonadDsM$fMonadUniqueDsM$fApplicativeDsMMSpecctorMapmeasMapcmeasMapimeasKVProfKVKindRecBindE NonRecBindE TypeInstE PredInstELamECaseELetEProjectEOutputOo_varso_typeso_templso_botso_resultAnnotAnnUseAnnDefAnnRDfAnnLocAnnInfoAIRClassrcNamercSupersrcTyVars rcMethodsCMeasureCMcNamecSortMeasureMnamesorteqnsDefmeasuredparamsctordsortbindsbodyBodyEPRRTEnvRTE typeAliases exprAliasesModTypeTarget SrcImport SpecImportModNameCinfoCici_locci_errci_varError ErrorResultREnvreGlobalreLocal UReftableofUReftRTypeRepty_varsty_preds ty_labelsty_bindsty_reftsty_argsty_resRTAliasRTArtNamertTArgsrtVArgsrtBodyrtPosrtPosESizeFun IdSizeFun SymSizeFunDataCtordcNamedcFieldsdcResultDataDeclDtycName tycTyVarstycPVars tycTyLabstycDCons tycSrcPostycSFun tycPropTyAxiomEq axiomName axiomArgs axiomBodyaxiomEqHAxiomAxiomanamernameabindsatypesalhsarhsRDEnvDEnvRISig RIAssumed RInstanceRIriclassrityperisigsOkRT TyConableisFunisListisTupleppTyconisClassisEqualisNumCls isFracClsSubsTysubtStrataStratumSVarSDivSWhnfSFin LocSpecType LocBareTypeBRPropRRPropSpecPropSpecTypeBareTypePrTypeRReftRPVarBPVarRSortBSortRRTypeBRTypeUReftMkUReftur_reftur_pred ur_strataHSegHBindHVarhs_addrhs_valWorldRTPropRefRProprf_argsrf_bodyRTVInfo RTVNoInfortv_namertv_kind rtv_is_valRTVar ty_var_value ty_var_infoRTypeRVarRFunRAllTRAllPRAllSRAppRAllERExRExprArgRAppTyRRTyRHolert_varrt_reftrt_bindrt_inrt_out rt_tvbindrt_ty rt_pvbindrt_sbindrt_tyconrt_argsrt_pargs rt_allargrt_exargrt_argrt_resrt_envrt_refrt_oblPVURTVU TyConInfovarianceTyArgsvariancePsArgs sizeFunctionRTyConrtc_tcrtc_infoBTyConbtc_tc btc_classbtc_promRTyVarRTVBTyVarBTV PredicatePrUsedPVarPVKindPVPropPVHPropPVarPVpnameptypepargpargs TargetVarsAllVarsOnlyDataConPdc_loc freeTyVarsfreePred freeLabelstyConststyArgstyRes dcpIsGadtdc_locETyConPty_loc freeTyVarsTy freePredTy freeLabelTy varianceTs variancePssizeFunLMaplmVarlmArgslmExprLogicMapLM lmSymDefs lmVarSymsGhcSpecSPgsTySigs gsAsmSigsgsInSigsgsCtorsgsLitsgsMeas gsInvariants gsIaliasesgsDconsPgsTconsP gsFreeSyms gsTcEmbeds gsQualifiersgsADTs gsTgtVarsgsDecrgsTexprs gsNewTypesgsLvarsgsLazy gsAutosize gsAutoInstgsConfig gsExports gsMeasures gsTyconEnvgsDictsgsAxioms gsReflects gsLogicMap gsProofType gsRTAliasesGhcInfoGItarget targetModenvcbsderVarsimpVarsdefVarsuseVarshqFilesimportsincludesspecPPEnvPPppPsppTyVarppSsppShortppEnv ppEnvShort toLogicMap eAppWithMappvTypepvarsrtyVarUniqueSymboltyVarUniqueSymbol rtyVarTypemkBTyCon mkClassBTyConmkPromotedBTyConisBoolisRVar isClassBTyCon isClassRTyCon rTyConPVs rTyConPropVsisPropPVisEqType isClassTypedefaultTyConInfo ignoreOblig makeRTVar mapTyVarValue dropTyVarInfo rTVarToBindrPropPisSVarszFun mapRTAVars lmapEAlias fromRTypeRep toRTypeRepmkArrow bkArrowDeepbkArrow safeBkArrowmkUnivsbkUnivbkClassrFunrClsrRCls addInvCondpApppappSym isTrivialmapReftisBaseisFunTymapReftMmapPropMfoldReft foldReft' efoldReftmapBotmapBindofRSorttoRSort insertsSEnv rTypeValueVar rTypeReftstripRTypeBase topRTypeBase makeDivType makeFinType getStrata isSrcImport isSpecImport getModName getModStringmapRTmapRE emptyKVProf updKVProfholeisHolehasHole liquidBegin liquidEnd $fPPrintRef$fPPrintRTyVar$fPPrintBTyVar $fMonoidMSpec $fShowMSpec $fPPrintMSpec$fBifunctorMSpec $fShowDataCon$fPPrintDataCon$fSymbolicDataCon$fNFDataKVProf$fPPrintKVProf$fPPrintKVKind$fNFDataKVKind$fHashableKVKind$fMonoidOutput $fNFDataAnnot$fNFDataAnnInfo$fMonoidAnnInfo$fBinaryRClass$fSubableWithModel $fSubableBody $fSubableDef$fSubableMeasure$fShowCMeasure$fPPrintCMeasure $fShowMeasure$fPPrintMeasure $fPPrintDef $fPPrintBody$fBinaryMeasure $fBinaryDef $fBinaryBody$fBifunctorMeasure$fBifunctorDef $fMonoidRTEnv$fSymbolicModuleName$fSymbolicModName$fShowModuleName$fPPrintModName $fNFDataCinfo $fLocCinfo$fNFDataTError $fNFDataREnv$fPPrintPredicate $fPPrintPVar $fPPrint[]$fPPrintStratum $fShowStratum$fReftablePredicate$fSubableRType $fSubableRef$fSubableUReft$fExpressionUReft$fReftableUReft $fUReftable()$fUReftableUReft $fReftable[]$fSubableStratum$fBinaryRTAlias$fSymbolicDataDecl$fPPrintDataDecl$fShowDataDecl $fLocDataDecl $fLocDataCtor $fOrdDataDecl $fEqDataDecl$fBinaryDataDecl$fBinaryDataCtor$fBinarySizeFun$fNFDataSizeFun $fShowSizeFun$fSubableAxiomEq $fShowAxiom$fPPrintAxiomEq$fBinaryAxiomEq $fBinaryRISig$fBinaryRInstance $fShowBTyCon $fShowRTyCon$fPPrintBTyCon$fPPrintRTyCon$fFixpointCinfo$fFixpointBTyCon$fFixpointRTyCon $fEqBTyCon $fEqRTyCon$fTyConableBTyCon$fTyConableLocated$fTyConableSymbol$fTyConableTyCon$fTyConableRTyCon $fMonoid[]$fBinaryStratum$fNFDataStratum $fBinaryUReft $fNFDataRef $fBinaryRef$fBinaryRTVInfo$fNFDataRTVInfo $fNFDataRTVar $fBinaryRTVar $fEqRTVar $fNFDataRType $fBinaryRType $fShowRTVar$fShowTyConInfo$fNFDataTyConInfo$fDefaultTyConInfo$fNFDataRTyCon$fNFDataBTyCon$fSymbolicBTyCon$fBinaryBTyCon$fSymbolicRTyVar$fSymbolicBTyVar$fNFDataRTyVar$fNFDataBTyVar$fHashableBTyVar$fBinaryBTyVar$fIsStringBTyVar $fOrdBTyVar $fEqBTyVar $fNFDataUReft$fSubableQualifier$fSubablePredicate $fSubablePVar $fMonoidUReft$fMonoidPredicate$fNFDataPredicate$fBinaryPredicate$fNFDataPVKind$fBinaryPVKind$fHashablePVar $fNFDataPVar $fBinaryPVar $fOrdPVar$fEqPVar $fLocDataConP $fShowLMap$fMonoidLogicMap$fHasConfigGhcSpec$fHasConfigGhcInfo $fShowPPEnv$fShowLogicMap$fGenericPVKind $fDataPVKind$fFunctorPVKind$fFoldablePVKind$fTraversablePVKind $fShowPVKind $fGenericPVar $fDataPVar $fShowPVar $fFunctorPVar$fGenericPredicate$fDataPredicate $fShowBTyVar$fGenericBTyVar $fDataBTyVar$fGenericRTyVar $fDataRTyVar$fGenericBTyCon $fDataBTyCon$fGenericRTVInfo $fDataRTVInfo$fFunctorRTVInfo$fGenericRTVar $fDataRTVar $fGenericRef $fDataRef $fFunctorRef$fGenericRType $fDataRType$fFunctorRType $fGenericHSeg $fDataHSeg$fGenericWorld $fDataWorld$fGenericStratum $fDataStratum $fEqStratum$fGenericUReft $fDataUReft$fFunctorUReft$fFoldableUReft$fTraversableUReft$fGenericRISig$fFunctorRISig $fDataRISig $fShowRISig$fGenericRInstance$fFunctorRInstance$fDataRInstance$fShowRInstance $fMonoidDEnv $fShowDEnv$fGenericAxiomEq $fShowAxiomEq$fDataDataCtor$fGenericDataCtor $fDataSizeFun$fGenericSizeFun$fDataDataDecl$fGenericDataDecl$fGenericTyConInfo$fDataTyConInfo$fGenericRTyCon $fDataRTyCon$fGenericDataConP$fDataDataConP$fGenericTyConP $fDataTyConP $fDataRTAlias$fGenericRTAlias $fEqCinfo $fOrdCinfo$fGenericCinfo $fEqModType $fOrdModType $fShowModType $fEqModName $fOrdModName $fShowModName $fShowBody $fDataBody $fGenericBody$fEqBody $fShowDef $fDataDef $fGenericDef$fEqDef $fFunctorDef $fDataMeasure$fGenericMeasure$fFunctorMeasure$fDataCMeasure$fGenericCMeasure$fFunctorCMeasure $fShowRClass$fFunctorRClass $fDataRClass$fGenericRClass $fDataAnnInfo$fGenericAnnInfo$fFunctorAnnInfo $fDataAnnot$fGenericAnnot$fFunctorAnnot$fGenericOutput$fFunctorOutput$fGenericKVKind $fEqKVKind $fOrdKVKind $fShowKVKind $fDataKVKind$fGenericKVProf $fDataMSpec$fGenericMSpec$fFunctorMSpecsimplifyBounds SubStratumsubSsubsS<:= solveStrata$fSubStratumRType$fSubStratumAnnot$fSubStratum[]$fSubStratum(,)$fSubStratumStratumValVBVVVXVSVCResultPassedFailedErrored MeasureEnv DataConEnvValueVariableTargetExceptionSmtFailedToProduceOutputSmtErrorExpectedValuesPreconditionCheckFailed EvalError ensureValuesboolsort choicesort $fPPrintVal $fSMTLIB2[] $fSymbolic(,)$fExceptionTargetException$fShowTargetException $fShowResult $fGenericVal $fShowVal$fEqVal$fOrdValpprManyOrderedpprintLongList pprintSymbolrtypeDoc $fPPrintUReft $fPPrintTidy$fPPrintRTAlias $fPPrintRType$fPPrintLogicMap $fPPrintLMap $fShowAnnInfo$fPPrintAnnInfo $fPPrintAnnot$fShowPredicate $fPPrintClass $fPPrintType $fPPrintTyCon $fPPrintName $fPPrintVar$fPPrintSourceError$fPPrintErrMsgsplitXRelatedRefs $fShowUReft $fIsFreexFreeVarstrengthenDataConTypepdVarfindPVaruRTypeuRType' uRTypeGenuPVaruReftuToprVarrTyVar updateRTVar rTVarInfo kindToRType isValKindbTyVar symbolRTyVar bareRTyVar normalizePdsrExrApp tyConBTyConstrengthenRefTypeGenmeetable strengthen quantifyRTyquantifyFreeRTy addTyConInfo appRTyCon generalize tyClassessubsTyVars_meetsubsTyVars_nomeetsubsTyVar_nomeetsubsTyVar_meetsubsTyVar_meet'subts subvUReft subvPredicateofType bareOfType dataConReftisBaseTy dataConMsRefttoTyperTypeSortedReft rTypeSort applySolutionshiftVVtypeSorttypeUniqueSymbol tyConNamemkDataConIdsTy classBinds makeNumEnv isDecreasing makeDecrType isSizeable makeLexRefa mkTyConInfo $fPPrintREnv $fShowRef $fShowRType$fPPrintDataCtor $fShowRTyVar $fShowRTAlias$fExpressionVar$fSubsTytvtyRef$fSubsTyBTyVarRTypeRType$fSubsTyBTyVarRTypeBTyCon$fSubsTytvtyUReft$fSubsTytvRTypePredicate$fSubsTyRTyVarRTypeRType$fSubsTyRTyVarRTyVarRType$fSubsTyVarTypeRType$fSubsTyRTyVarRTypeRType0$fSubsTyRTyVarRTypeRType1$fSubsTyRTyVarRTypeRTyCon$fSubsTytvtyPVar$fSubsTytvtyPVKind$fSubsTyRTyVarRTypeSort$fSubsTySymbolRTypeSort$fSubsTyBTyVarRTypeSort$fSubsTytvty(,)$fSubsTytvtyExpr$fSubsTytvtyReft$fSubsTytvtySymbol$fSubsTytvty()$fSubsTyBTyVarRTypeRTVar$fSubsTyBTyVarRTypeBTyVar$fSubsTyRTyVarRTypeRTVar$fSubsTyRTyVarRTypeRTyVar$fHashableRTyCon $fOrdRTyCon$fHashableRTyVar $fOrdRTyVar $fEqRTyVar $fEqPredicate $fEqRType$fFreeVarBTyConBTyVar$fFreeVarRTyConRTyVar$fFixpointClass $fFixpoint[]$fReftableRType$fReftableRType0 $fReftableRef$fReftableRef0$fReftableRef1$fReftableRef2$fReftableRef3 $fMonoidRef $fMonoidRTypeRRBEnvRBEnvRRBoundRBoundBoundbnametyvarsbparamsbargsbbody makeBound$fBifunctorBound $fPPrintBound $fShowBound $fEqBound$fHashableBound $fBinaryBound $fDataBound$fGenericBoundmakeDictionariesmakeDictionary dfromListdmaptymapRISig fromRISigdmapdinsertdlookupdhasinfo makeTyConInfodataConPSpecType dataConTyreplacePredsWithRefs pVartoRConc pvarRType replacePredspredType substParg pappAritypappSort$fShowDataConP$fPPrintDataConP $fShowTyConP$fPPrintTyConP CBVisitablefreeVarsreadVarsletVarsliterals$fCBVisitableAltCon$fCBVisitable(,,)$fCBVisitableExpr$fCBVisitableBind$fCBVisitable[]TagEnvTagKey defaultTag memTagEnv makeTagEnvgetTagStatusSafeUnsafeCrashAnnMapAnntypeserrorsstatushscolourhsannot srcModuleNamebreakS $fShowAnnMap $fEqStatus $fOrdStatus $fShowStatus$fShowAnnotation $fShowLitresulterrorToUserError cinfoError isTmpSymbol tidySpecType panicError $fException[]$fPPrintCtxError$fPPrintCtxError0$fResultFixResult$fResultTError $fResult[]$fResultTError0SpecmeasuresasmSigssigs localSigsreflSigs invariantsialiases dataDecls newtyDeclsaliasesealiasesembeds qualifiersdecrlvarslazyreflectsautoishmeashboundsinlinesautosizepragmas cmeasures imeasuresclasses termexprs rinstance dvarianceboundsdefsaxeqs SpecMeasure BareMeasureBareSpec qualifySpecmkMmkMSpec'mkMSpec dataConTypes defRefType $fMonoidSpec $fBinarySpec $fGenericSpecPspecMeasAssmAsrtLAsrtAsrtsImptDDeclNTDeclInclInvtIAliasAliasEAliasEmbedQualifDecrLVarsLazyInstsHMeasReflectInlineASizeHBoundPBoundPragmaCMeasIMeasClassRInstVariaBFixDefineBPspechsSpecificationPspecSpecificationP singleSpecPparseSymbolToLogic $fEqPcScope $fShowPcScope$fShowParamComp $fDataPspec $fShowPspec meetVarTypes tidyErrormkOutputannotate$fToJSONAnnMap $fToJSONAssoc $fToJSON[] $fToJSONLoc$fToJSONAnnot1$fToJSONStatusgetOptscanonicalizePathsmkOpts withPragmas defConfigexitWithResult addErrors$fFixpointFixResult$fShowCtxError DiffCheckDCnewBinds oldOutputnewSpec checkedVarsslicethin filterBinds saveResult$fFromJSONOutput$fToJSONOutput$fFromJSONAnnInfo$fToJSONAnnInfo$fFromJSONHashMap$fToJSONHashMap $fFromJSONDoc $fToJSONDoc$fFromJSONFixResult$fToJSONFixResult$fFromJSONSourcePos$fToJSONSourcePos $fFunctorDiff$fPPrintDiffCheck$fOrdDef LiquidQuoteliquidQuoteSpeclq $fMonadSimpl$fApplicativeSimpl$fFunctorSimpl$fDataLiquidQuote isWiredIndcPrefixwiredSortedSyms dictionaryVardictionaryTyVardictionaryBindcombineProofsNameproofTyConName wiredTyCons wiredDataCons pdVarReftFEnvFEfeBindsfeEnvfeIdEnv RTyConIAl RTyConInvHEnvCGInfofEnvhsCshsWfssCsfixCsisBindfixWfs freshIndexannotMap tyConInfospecDecrnewTyEnv termExprs specLVarsspecLazyautoSize tyConEmbedkutskvPackscgLitscgConstscgADTstcheckscheck pruneRefs logErrorskvProfrecCount bindSpansallowHOghcI dataConTysFixWfCFixSubCWfCSubCSubRsenvlhsrhsobligref LConstraintLCCGEnvCGEcgLocrenvsyenvdenvlitEnvconstEnvfenvrecsfargsinvsrinvsialgrtysassmsintysembtgEnvtgKeytreclcbholeslcsaenvcerrcgInfocgVarCG fromListHEnvelemHEnv addArgument addArguments mkRTyConInv mkRTyConIAl addRTyConInvaddRInvremoveInvariantrestoreInvariantmakeRecInvariants insertsFEnvinitFEnv$fNFDataCGInfo $fNFDataWfC $fNFDataSubC $fNFDataFEnv $fNFDataCGEnv $fNFDataRInv$fPPrintCGInfo$fSubStratumSubC $fPPrintWfC $fPPrintSubC $fShowCGEnv $fPPrintCGEnv$fMonoidLConstraint$fHasConfigCGEnv $fShowRInv Freshablefreshtruerefresh refreshTy refreshVVrefreshArgsTop refreshArgs refreshHoles freshTy_type freshTy_expraddKutstrueTy$fFreshablemRType$fFreshablem[]$fFreshablemUReft$fFreshablemReft$fFreshablem[]0$fFreshablemExpr$fFreshablemSymbol$fFreshableStateTInteger fromListREnv insertREnv lookupREnvlocalBindsOfType toListREnvextendEnvWithVV addBindersrTypeSortedReft'+= globalizeaddSEnv+++=-=?= setLocationsetBindsetRecssetTRec getLocation pushConsBindaddCaddPostaddW addWarningaddIdA boundRecVaraddLocA updateLocAaddA lookupNewTypeaddConstraintsconstraintToLogicsplitWsplitSsplitCenvToSub panicUnbound specToBare measureToBare txExpToBindBareEnvBEmodNametcEnvrtEnvvarEnvhscEnvlogicEnvdcEnvaxSymspropSymsbeConfigInlnEnvTCEnvWarnBareM DataConMap dataConMap setDataDeclsinsertLogicEnv insertAxiomaddDefsinModule withVArgs setRTAlias setREAliasexecBare$fHasConfigBareEnv ExpandAliases$fExpandAliases(,)$fExpandAliases[]$fExpandAliasesMaybe$fExpandAliasesLocated$fExpandAliasesUReft$fExpandAliasesDataConP$fExpandAliasesMeasure$fExpandAliasesDef$fExpandAliasesBody$fExpandAliasesRType$fExpandAliasesReft$fExpandAliasesExpr GhcLookup lookupNamelookupGhcThing lookupGhcVarlookupGhcTyConlookupGhcDataCon$fSymbolicFieldLbl$fGhcLookupFieldLbl$fGhcLookupName$fGhcLookupLocated MapTyVarSTMTVSTvmaperrmsgmakeDataConCheckermakeDataConSelector symbolMeasure makeSymbols freeSymbols initMapSt runMapTyVars mapTyVarsisKind matchKindArgs mkVarExprjoinVarsimpleSymbolVar hasBoolResultmakePluggedSigsmakePluggedAsmSigsmakePluggedDataCons Resolvableresolve$fResolvable()$fResolvablePVar$fResolvablePredicate$fResolvableReft$fResolvableUReft$fResolvableSort$fResolvableSymbol$fResolvableLocated$fResolvableExpr$fResolvableQualifier$fResolvable[] ofBareType ofMeaSortofBSortofBPVar mkLSpecType mkSpecType' makeRTEnv txRefSort normalize logicTypestrengthenResultstrengthenResult' runToLogicrunToLogicWithBoolBinds coreToDef coreToFun coreToLogicmkLitmkImkS$fSimplify(,,)$fSimplifyBind$fSimplifyExpr $fShowExprmakeHaskellDataDeclsmakeHaskellMeasuresmakeHaskellInlinesstrengthenHaskellInlinesstrengthenHaskellMeasuresmakeMeasureSelectorsmakeMeasureSpecmakeMeasureSpec'makeClassMeasureSpec varMeasuresmakeHaskellBounds makeClassesmakeQualifiers makeHintsmakeLVarmakeLazy makeAutoInstsmakeDefs makeHBounds makeTExpr makeHInlines makeHMeasmakeTargetVarsmakeAssertSpecmakeAssumeSpecmakeDefaultMethods lookupIds makeIAliases makeNewTypesmakeInvariantsmakeSpecDictionaries makeBoundsliteralFRefType literalFReft literalConstmakeNumericInfo makeDataDecls makeConTypesmeetDataConSpecmakeTyConEmbedsmakeRecordSelectorSigs checkGhcSpeccheckTerminationExprcheckTymakeHaskellAxioms makeGhcSpecsaveLiftedSpecloadLiftedSpec useSpcQuals fixConfig cgInfoFInfo getGhcInfos runLiquidGhc exportedVars isExportedVar pprintCBs$fResultSourceError$fPPrintTargetVars $fShowGhcInfo$fPPrintGhcInfo$fPPrintGhcSpecinitEnvinitCGIgenerateConstraints$fFunctorTemplate$fFoldableTemplate$fTraversableTemplate$fShowTemplateResArgsAllHave ConstraintsMapHListNil:::DepthiomyTracereftmakeDecl deconSort applyPreds propPsToProp propPToPropsplitEApp_maybe stripQualsgetSpecrunGhc loadModule $fShowHList TargetState variableschoices constraintsdepsrealizedctorEnvmeasEnvembEnv tyconInfofreesyms constructorschosensortsfilePathmakingTy smtContext TargetOptsdepthsolververboselogging keepGoing maxSuccessscDepthghcOpts runTargetfreshInt defaultOpts initState whenVerbosenoteUsedaddDep addConstraintaddConstructormaking lookupCtorguardedaddSort addVariable freshChoicegetValue$fMonadThrowTarget$fFunctorTarget$fApplicativeTarget $fMonadTarget$fMonadIOTarget$fAlternativeTarget$fMonadStateTarget$fMonadCatchTarget$fMonadReaderTargetevalevalWithevalExpr TargetablequerydecodechecktoExprgetTypeqqueryunfoldapplyunapplyoneOfwhichOf constrainofReft$fGCheckFieldsU1$fGDecodeFieldsU1$fGQueryFieldsU1$fGRecursiveU1$fGToExprFieldsU1$fGCheckFieldsM1$fGDecodeFieldsM1$fGQueryFieldsM1$fGRecursiveM1$fGToExprFieldsM1$fGCheckFields:*:$fGDecodeFields:*:$fGQueryFields:*:$fGRecursive:*:$fGToExprFields:*: $fGCheckM1 $fGDecodeM1$fGQueryCtorsM1$fGToExprCtorM1 $fGCheck:+: $fGDecode:+:$fGQueryCtors:+:$fGToExprCtor:+:$fGCheckFieldsK1$fGDecodeFieldsK1 $fGQueryK1 $fGToExprK1 $fGCheckM10 $fGDecodeM10 $fGQueryM1 $fGToExprM1$fTargetable(,,,)$fTargetable(,,)$fTargetable(,)$fTargetableEither$fTargetableMaybe$fTargetable[]$fTargetableBool$fTargetableWord8$fTargetableChar$fTargetableInteger$fTargetableInt$fTargetable()$fTargetable(->)$fTargetable(->)0$fTargetable(->)1Testabletestsetup $fTestablea$fTestable(->)Su TargetDictDict getModelsgetModel getModel' withContexttoFixCfg dictProxy asTypeOfDictaddDictsaddDictaddDict' monomorphizemonomorphizeOnemonomorphizeFree hscParsedStmthandleWarnings ioMsgMaybe throwErrors getWarnings clearWarnings logWarningshscParsedDeclsMbEnvliquid runLiquid $fShowCinfoResponseCommandStatesCountsMbEnv$fSerializeStatus$fGenericStatus $fDataStatushandlerinitialTestTtargetTH targetResulttargetResultTH targetWith targetWithTHtargetResultWithtargetResultWithTHcatchIObindirlibdirdatadir libexecdir sysconfdirallowInstancestotalityCheck'terminationCheck'ToProveOptGtOptLessOptGEqOptLEqOptEqsrcSpanContext srcSpanInfo getFileLines makeContextmakeContextLine makeContext1ppObligerrSpan pprSrcSpanpprRealSrcSpannestssepVcat blankLineppFullppReqInContext pprintBindppReqModelInContextvsep pprintModelppPropInContexterrSavedppVar ppSrcSpansppNamesppList_mbIdexprArgsis TmOracleEnvvarInsolveComplexEqextendSubstAndSolvesimplifyComplexEqsimplifyPmExprsimplifyEqExprapplySubstComplexEq varDeepLookup ds_parr_biNothingmkDsEnvs sort_alts mkPatSynCase mkDataConCase mkPArrCase strip_bangsis_flat_prod_lpatis_flat_prod_pat is_triv_lpat is_triv_pat mkFailurePair matchGuards dsOverLit'conversionNameswarnAboutOverflowedLiteralsgetLHsIntegralLitgetIntegralLit litValKeyrepFamilyResultSigrepFamilyResultSigToMaybeKindrepInjectivityAnn repTyVarBndr repMaybeLKind coreNothing coreNothing'coreJust coreJust'CoreMkC GenSymBindrepTopPrepTopDshsSigTvBindersrepTyClDrepRoleD repDataDefn repSynDecl repFamilyDeclrepFamilyDeclsrepAssocTyFamDefaults repLFunDeps repLFunDeprepInstD repClsInstDrepStandaloneDerivD repTyFamInstD repTyFamEqnrepDataFamInstDrepForD repCCallConv repSafetyrepFixDrepRuleD ruleBndrNames repRuleBndrrepAnnD repAnnProvrepCrepSrcUnpackednessrepSrcStrictness repBangTy repDerivsrep_sigs rep_sigs'rep_sig rep_ty_sig rep_wc_ty_sig rep_inlinerep_specialiserep_specialiseInst repInline repRuleMatch repPhasesaddSimpleTyVarBinds addTyVarBindsaddTyClTyVarBindsrepTyVarBndrWithKind repLContext repContext repHsSigTyperepHsSigWcTyperepLTysrepLTy repForallrepTyrepTyLitrepLKindrepNonArrowLKindrepNonArrowKindrepRole repSplice rep_splicerepLEsrepLErepE repMatchTup repClauseTup repGuardsrepLGRHS repFields repUpdFieldsrepLStsrepStsrepBinds rep_val_binds rep_binds rep_binds'rep_bind repLambdarepLPsrepLPrepP sort_by_locde_loc mkGenSymsaddBinds lookupLBinder lookupBinder lookupLOcc lookupOcc globalVar lookupType wrapGenSymsnameLit occNameLitunCrep2dataCon'dataConrepPlitrepPvarrepPtuprepPunboxedTuprepPconrepPrec repPinfix repPtilderepPbang repPaspatrepPwildrepPlistrepPview repVarOrConrepVarrepConrepLitrepApprepLam repLamCaserepTup repUnboxedTuprepCond repMultiIfrepLetErepCaseErepDoErepComp repListExp repSigExp repRecCon repRecUpd repFieldExp repInfixApp repSectionL repSectionR repGuarded repNormal repLNormalGE repNormalGErepPatGE repBindStrepLetSt repNoBindStrepParStrepFrom repFromThen repFromTo repFromThenTorepMatch repClauserepValrepFunrepData repNewtyperepTySynrepInst repOverlaprepClassrepDeriv repPragInl repPragSpecrepPragSpecInlrepPragSpecInst repPragRule repPragAnn repTySynInstrepDataFamilyDrepOpenFamilyDrepClosedFamilyD repTySynEqn repRoleAnnotD repFunDeprepProtorepCtxt repDataConrepGadtDataCons repConstr repTForallrepTvarrepTapprepTappsrepTSig repTequalityrepTPromotedListrepTLit repTWildCard repNamedTyCon repTupleTyConrepUnboxedTupleTyCon repArrowTyCon repListTyConrepPromotedDataConrepPromotedTupleTyConrepPromotedNilTyConrepPromotedConsTyCon repPlainTV repKindedTVrepKVarrepKCon repKTuple repKArrowrepKListrepKApprepKAppsrepKStarrepKConstraintrepNoSig repKindSig repTyVarSig repLiteral mk_integer mk_rational mk_stringmk_charrepOverloadedLiteralmk_litrepNameS repGensymrepBindQ repSequenceQ repUnboundVarrepListcoreList coreList'nonEmptyCoreList coreStringLit coreIntLitcoreVar notHandledL notHandledmk_alt maybeNarrowBinding dsForeigns' dsFImport dsCImportfun_type_arg_stdcall_infodsFCall dsPrimCall dsFExportdsFExportDynamictoCNamemkFExportCBitsforeignExportInitialisermkHObj unpackHObj showStgType showFFITypetoCType typeTyCon insertRetAddr ret_addr_arg getPrimTyOfprimTyDescChardsHsBind ds_lhs_binds dsLHsBind makeCorePair dictAritydsSpecs ruleOrphWarndsEvBinddsEvTermdsEvDelayedError dsEvTypeableds_ev_typeablegetReptyConRep dsEvCallStack ConArgPatsmatchOneConLikecompatible_pats same_fieldsselectConMatchVars conArgPatsshouldTickBindaddTickLHsExprLetBodytickSameFileOnly MixEntry_TMunTMFreeVars TickishType ProfNotesHpcTicks Breakpoints SourceNotes TickTransEnvTTEfileNamedensity tte_dflagsexportsdeclPathinScope blackListthis_mod tickishTypeTickTransStateTT tickBoxCount mixEntries uniqSupply TickDensityTickForCoverageTickForBreakPointsTickAllFunctionsTickTopFunctionsTickExportedFunctions TickCallSitesguessSourceFile mkModBreakswriteMixEntries mkDensityshouldTickPatBindaddTickLHsBindsaddTickLHsBindbindTickaddTickLHsExpraddTickLHsExprRHSaddTickLHsExprEvalInneraddTickLHsExprNeverisGoodBreakExpr isCallSiteaddTickLHsExprOptAltaddBinTickLHsExpr addTickHsExpr addTickTupArgaddTickMatchGroup addTickMatch addTickGRHSs addTickGRHSaddTickGRHSBody addTickLStmtsaddTickLStmts' addTickStmtaddTickaddTickApplicativeArgaddTickStmtAndBindersaddTickHsLocalBindsaddTickHsValBindsaddTickHsIPBinds addTickIPBindaddTickSyntaxExpr addTickLPataddTickHsCmdTop addTickLHsCmd addTickHsCmdaddTickCmdMatchGroupaddTickCmdMatchaddTickCmdGRHSsaddTickCmdGRHSaddTickLCmdStmtsaddTickLCmdStmts'addTickCmdStmtaddTickHsRecordBindsaddTickHsRecFieldaddTickArithSeqInfoliftLcoveragePassesnoFVsgetStatesetStategetEnvwithEnv getDensity ifDensity getFreeVarsfreeVar addPathEntry getPathEntry getFileNameisGoodSrcSpan'isGoodTickSrcSpanifGoodTickSrcSpan bindLocals isBlackListed allocTickBox allocATickBox mkTickishallocBinTickBoxmkBinTickBoxHpcmkHpcPos hpcSrcSpanmatchesOneOfManymixHashPmArityPmResultDeltaValVec checkSingle' checkMatches'fake_pat isFakeGuardmkCanFailPmPat nilPattern mkLitPattern translateNPattranslatePatVectranslateConPatVectranslateGuardscantFailPatterntranslateGuard translateLet translateBindtranslateBoolGuard pmPatType mkOneConFullmkGuardmkNegEqmkPosEqmkPmVarmkPmVarsmkPmIdId mkPmId2Forms vaToPmExpr coercePatVec coercePmPatallConstructorstyOracle patternArityrunManymkInitialUncoveredpmcheckIpmcheckpmcheckGuardsI pmcheckGuards pmcheckHdI pmcheckHdutailuconkconmkUnionmkConsforcesforce_ifghc-prim GHC.TypesTrue substInValAbs wrapUpTmStatedsPmWarn warnPmIters exhaustiveexhaustiveWarningFlagDynFlags WarningFlagmaximum_outputTriple Uncovered ValSetAbsMkDelta delta_ty_cs delta_tm_csPatVecValAbsPmPatPmConPmVarPmNLitPmGrd pm_con_conpm_con_arg_tys pm_con_tvs pm_con_dicts pm_con_args pm_var_id pm_lit_lit pm_lit_id pm_lit_not pm_grd_pv pm_grd_exprPatTyPATVAPmMnullaryConPattern truePatternvanillaConPattern mkListPatVec translatePattranslateMatchnewEvVarnameTypedots pp_contextppr_patsppr_eqnppr_constraint ppr_uncoveredPatGroupPgAnyPgConPgSynPgLitPgNPgNpKPgBangPgCoPgViewPgOverloadedList matchEmptymatchVariables matchBangs matchCoercion matchViewmatchOverloadedListdecomposeFirstPatgetCoPat getBangPat getViewPatgetOLPat tidyEqnInfotidy1 tidy_bang_patpush_bang_into_newtype_argmatch_single_pat_vargroupEquationssubGroup subGroupOrd subGroupUniq sameGroup viewLExprEqpatGroupDsCmdEnvarr_id compose_idfirst_idapp_id choice_idloop_idmkCmdEnvdo_arr do_composedo_firstdo_app do_choicedo_loop do_premap mkFailExpr mkFstExpr mkSndExpr coreCaseTuple coreCasePair mkCorePairTymkCorePairExprmkCoreUnitExpr envStackType splitTypeAt buildEnvStack matchEnvStackmatchEnv matchVarStackmkHsEnvStackExprdsLCmddsCmd dsTrimCmdArgdsfixCmd trimInputdsCmdDo dsCmdLStmt dsCmdStmtdsRecCmd dsfixCmdStmts dsCmdStmts matchSimplys leavesMatchreplaceLeavesMatchreplaceLeavesGRHSfoldbcollectPatBinderscollectPatsBinderscollectlcollectEvBinders add_ev_bndrcollectLStmtsBinderscollectLStmtBinderscollectStmtBindersdsInnerListComp dsTransStmt deListComp deBindComp dfListComp dfBindComp mkZipBind mkUnzipBind dePArrComp dePArrParCompdeLambdamkLambda parrElemType dsMcStmtsdsMcStmt matchTuple dsMcBindStmtdsInnerMonadComp mkMcUnzipMmaxBuildLengthmkSptEntryName dsIPBinds ds_val_binddsUnliftedBindunliftedMatchOnly findFielddsExplicitList dsArithSeqdsDohandle_failure mk_fail_msgwarnDiscardedDoBindings badMonadBindmk_mod_usage_info mkFileSrcSpan dsImpSpecscombineEvBindsaddExportFlagsAndRulesdsRulewarnRuleShadowing unfold_coercedsVect hscDesugar' getHscEnvunStack mbSrcSpan spanSrcSpan maybeSpanSubstTysubsteqType'sep' substType substCoercionTyCoRep pprTcAppCo pprDataConsppr_typepprTyLitsubstCoVarBndrCallbacksubstForAllCoBndrCallbackextendTvSubstBinderextendCvSubstWithCloneextendTvSubstWithClone setCvSubstEnv coVarsOfCostyCoVarsOfProvtyCoVarsOfCoList tyCoFVsBndrTyLitNumTyLitStrTyLit KindCoercionsubstTyVarBndrCallbacksubstForAllCoBndrsubstTyWithBinderssubstTysWithCoVarssubstTyWithInScopezipTyBinderSubst zipCvSubstmkTyCoInScopeSetcloseOverKindsFVdelBinderVarFV delBinderVartidyCostidyCotidyKind tidyOpenKind tidyTopType tidyOpenType tidyOpenTypestidyType tidyTypes tidyTyVarOcctidyOpenTyCoVartidyOpenTyCoVarstidyFreeTyCoVars tidyTyBinders tidyTyBindertidyTyCoVarBndrtidyTyCoVarBndrs pprArrowChain pprPrefixApp pprTcAppTy pprTypeApp pprTvBndr pprTvBndrs pprForAllpprForAllImplicit pprUserForAll pprSigmaTypepprThetaArrowTypprTheta pprClassPred pprParendKindpprKind pprParendTypepprType maybeParencloneTyVarBndrscloneTyVarBndrsubstCoVarBndrsubstTyVarBndr lookupCoVar substCoVars substCoVarsubstCossubstCoUncheckedsubstCo lookupTyVar substTyVars substTyVarsubstThetaUnchecked substThetasubstTysUncheckedsubstTyssubstTyUncheckedsubstTysubstTyAddInScopesubstTyWithBindersUncheckedsubstTyWithCoVarssubstCoWithUnchecked substCoWithsubstTyWithUnchecked substTyWithzipCoEnvzipTyEnv mkTvSubstPrs zipTvSubst unionTCvSubstextendTvSubstListextendTvSubstAndInScope extendCvSubst extendTvSubstextendTCvSubstextendTCvInScopeSetextendTCvInScopeListextendTCvInScope zapTCvSubst setTvSubstEnvnotElemTCvSubst isInScopegetTCvSubstRangeFVs getTCvInScope getCvSubstEnv getTvSubstEnv mkTvSubst mkTCvSubstisEmptyTCvSubstmkEmptyTCvSubst emptyTCvSubstcomposeTCvSubstcomposeTCvSubstEnvemptyCvSubstEnvemptyTvSubstEnvpprTyThingCategory pprTyThingtyCoVarsOfTelescopecloseOverKindsDSetcloseOverKindsListcloseOverKinds coVarsOfCo coVarsOfTypes coVarsOfType tyCoFVsOfCos tyCoVarsOfCos tyCoFVsOfCotyCoVarsOfCoDSet tyCoVarsOfCotyCoFVsOfTypestyCoVarsOfTypesListtyCoVarsOfTypesDSettyCoVarsOfTypes tyCoFVsOfTypetyCoVarsOfTypeListtyCoVarsOfTypeDSettyCoVarsOfTypepickLRdropRuntimeRepArgsisRuntimeRepVarisRuntimeRepKindedTyisRuntimeRepTyisUnliftedTypeKindisLiftedTypeKind mkTyConTy isAnonBinder isNamedBinderisVisibleBinderisInvisibleBinder binderTypeisCoercionTypemkFunTysmkFunTy mkTyVarTys mkTyVarTysameVisVisibilityFlagVisible Specified Invisible KindOrType CoercionN CoercionR CoercionP CoercionHolechUnique chCoercion TvSubstEnv CvSubstEnvTyPrecTopPrecFunPrecTyOpPrec TyConPrec mkForAllTysTypeTyVarTyAppTyTyConAppForAllTyLitTyCastTy CoercionTyTyBinderNamedAnonTyThingAnIdAConLikeATyConACoAxiomCoercionReflUnivCo TyConAppCoAppCoForAllCoCoVarCo AxiomInstCoSymCoTransCo AxiomRuleCoNthCoLRCoInstCo CoherenceCoKindCoSubCo LeftOrRightCLeftCRightUnivCoProvenanceUnsafeCoerceProv PhantomProvProofIrrelProv PluginProvHoleProvTCvSubstPredTypeKind ThetaTypeTrEnvTr_locTEinlineLoopBreakerinlineFailCases isTypeError isCaseArgscTranstransPgtransBd transExpr isNonPolyRecnonPolycollectNonRecLets appTysAndIdstrans makeTrans mkRecBindsmkSubs mkFreshIds freshUnique mapNonRecmapBndmapExprmapAltmapBdM RewriteRule_safeSimplifyPatTuplehasTuple replaceTuplefixCase substTupleCoreSynCaseisVarTupListNE simplifyCore tidyTuplesrewriteBindWith rewriteWith_tidyAltsimplifyPatTuplevarTuple takeBinds matchTypes isProjection _showExpr_showVar _errorSkipreplaceIrrefutPatreplaceIrrefutPat'isIrrefutErrorVarmkSubsteqVarsisVar secondHalfnormalizeTopBindnormalizeForAllTysfreshNormalVarAnfEnvaeVarEnv aeSrcSpanaeCfgDsMWDsSTst_bindsrunDsMmodGutsTypeEnvnormalizeTyVars normalizeBind normalizeNameshouldNormalizeaddnormalizeLiteralstitch _mkCoreLets'normalizePatternexpandDefaultCaseexpandDefaultCase' cloneCase sortCasesanfOcc emptyAnfEnv lookupAnfEnv extendAnfEnvat rtc_pvarsSymbolKVP QualifierExpr ppEnvCurrent_ppEnvPrintPredsdropAppisApppdTruepdAnd mapQualBodyisProp ty_var_is_valrtvinfo_is_valisClassOrSubClassmapAxiomEqExpr isTauto_ureft ppTy_ureftppr_reftppr_strpToRefemapReftemapRef emapExprArgmapRefM mapBotRef mapBindRefstripAnnotationsstripAnnotationsRef insertSEnvmapRBase makeLTypeppr_pvar emptyOutput ppRefArgsppRefSym dropBoundLikeisBoundLikePredisImp simplifyLenallSVarsnoSVarnoUpdate updateFin updateDivsolvepprAnnInfoBindspprAnnInfoBindpprXOTppAliaspprints ppr_rtypeppTyConB shortModules ppr_rsubtypeppExists ppAllExprppReftPs ppr_dbind ppr_rty_fun ppr_rty_fun' ppr_forall ppr_rtvar_def ppr_symbolsppr_cls ppr_pvar_def ppr_pvar_kindppr_name ppr_pvar_sortppr_refdotIsFreeisFree splitRType splitUReftsplitRef splitReft splitPred ToTypeable#Language.Fixpoint.Types.RefinementsReft cmpLexRefTyConvtcFVartcFTVartcFApptcFLiteqRSorteqpdrTVarbTVar bTVarInfo mkTVarInfo kindToBRType kindToRType_rPred tyConRTyConbAppaddPdsnlzPpprt_rawstrengthenRefTypestrengthenRefType_meets expandRApp rtPropToprtPropPVmkRTProppvArgs isNumeric addNumSizeFun subsTyVars subsTyVarsubsFree subsFreessubsFreeRAppTymkRApp refAppTyToFun subsFreeRefofType_ ofLitType isBaseDataCon appSolRefa tyConFTyCon tyVarSorttypeSortForAll typeSortFungrabArgsexpandProductType mkProductTy rTyVarSymbolmkDType mkDecrFun makeLexReftmakeTyConVariancedataConsOfTyCon makeBoundType partitionPsisPApp toUsedPVars toUsedPVarmakeRefmakeDictionaryNamemakeDicTypeName substRConmkRTyCon rpredType predRTyCon wpredRTyCon symbolRTyCon substPredpad substPredP splitRPvar freeArgsPs freeArgsPsRefmeetListWithPSubsmeetListWithPSubsRefmeetListWithPSubmeetListWithPSubRefpredName wpredName symbolType predFTyCon exprFreeVars exprReadVars exprLetVars exprLiterals extendEnvbindings CallGraphcallGraphRanks makeCallGraphbindEqnsLiterrlin annotTokeniseclassifyjoinLCodeunLCommentTransform AnnotationAlitSpanshsannot' spanAnnotspanLineinRangetokeniseWithCommentTransform tokenSpansplusLocrenderAnnotTokenrenderTypAnnotrenderErrAnnotrenderLinAnnot lineStringinsertAnnotAnchorssplitSrcAndAnns tokenModule annotParse parseLines ppAnnotTyp ppAnnotErrallProg tidyValueVarstidyVV tidySymbolstidyLocalRefas tidyEqualtidyInternalRefas tidyDSymbols tidyFunBinds tidyTyVars bindersTxtyVars subsTyVarsAllfunBinds ppSpecTypeErr ppSpecTypecheckDuplicateMeasuremakeDataConTypeextendresultTy noDummySymscombineDCTypes mapArgumens stitchArgspanicFieldNumMismatch panicDataConrefineWithCtorBodybodyPred ParamComp bareTypePmkSpecspecP fallbackSpecP tyBindsRemP cMeasurePbinderPfTyConPPcScope PcImplicit PcExplicit PcNoSymbolPC_pci_pctspecificationPmapRightparseWithErrorparseErrorError remParseError remLineColtoLogicP toLogicOnePdefinePangles stringLiteralnullPCbtPcompPcircleP anglesCirclePholePC namedCirclePunnamedCirclePbareTypeBracesPbareArgP bareAtomP bareAtomBindP refBindBindPrefDefPrefPoptBindPholePholeRefP refasHolePbbaseP maybeBind lowerIdTailbTyConP classBTyConPstratumP bstratumP bbaseNoAppPmaybeP bareTyArgPbareAtomNoAppP constraintPconstraintEnvPrrTybareAllP tyVarDefsPtyVarIdP tyKindVarIdPkindP predVarDefsP predVarDefP predVarIdPbPVarpropositionSortPpropositionTypePmkPropositionTypexyP dummyBindPisPropBareTypeisPrimBareType getClassesdummyPsymsP dummyRSort predicatesP predicate1PmmonoPredicatePmonoPredicatePmonoPredicate1P predVarUsePfunArgsPboundP infixGenPinfixPinfixlPinfixrP maybeDigitbRPropbRVarbLstbTupbConbAppTy reftUReft predUReft dummyReft dummyTyIdpragmaP autoinstPlazyVarPaxiomPhboundPinlinePasizeP decreaseP filePathP datavarianceP variancePtyBindsP tyBindNoLocPtyBindP termBareTypeP termTypeP invariantP invaliasP genBareTypePembedPaliasPealiasPrtAliasPaliasIdP hmeasurePmeasureP iMeasureP oneClassArg instanceP riMethodSigPclassPrawBodyPtyBodyP locUpperIdP' upperIdP'condIdP' infixCondIdP'grabs measureDefP measurePatPtupPatPconPatPconsPatPnilPatPnullaryConPatPmkTupPatmkNilPat mkConsPat tupDataCondataConFieldsP dataConFieldP predTypeDDPbbindPdataConP adtDataConP tRepFields dataConNameP dataSizeP dataDeclP emptyDecl dataDeclBodyP dataCtorsPnoWhere dataPropTyP meetErrorCtxMCtxtidyErrContexttidyCtxtidyCtxM stripReft stripRTypetidyREnv tidyREnvM expandFix tidyTemps niceTempsAssoc renderPandoc renderDirect topAndTailmkAnnMaprefTokentokAnnotvimAnnot_annsAnnot1A1identannrowcol AnnErrorsAnnTypesAsc doGeneratemkBotswriteFilesOrStrings generateHtml renderHtml renderPandoc' checkExitCode pandocCmd pandocPreProc htmlHeader htmlClosecssHTMLmkStatus mkAnnMapErrcinfoErr mkAnnMapTypmkAnnMapBinders closeAnnotscloseAfilterA collapseApickOneAtrimLiquidAnnottokBodyisMeasisDataisTypeisIncl spacePrefix tokeniseSpec chopAltDBGvimBindannTypesinsiGHC.IOFilePath canonConfigCErrordefaultMaxParamsconfig defaultPort cmdArgsRun' withSmtSolver findSmtSolver canonicalizeenvCfg copyright withPragma parsePragmadefFuel consoleResultconsoleResultFullconsoleResultJsonresultWithContextwriteCheckVars writeResultresDocs errToFCrashChkItvDepsstartendbinder assumeSpec dependsOn meetSpanslineDiff diffLinesgetShiftsetShift sliceSaved sliceSaved'diffVarssigVars globalDiffisDiffthinWithcoreDeps txClosurespecDefsspecSigscoreDefscoreDeflineSpancatSpansbindFilevarFile exprSpansaltSpans isJunkSpan lineDiff' diffShifts loadResult adjustOutput adjustTypes adjustResult errorsResult adjustErrors adjustSrcSpan isCheckedSpanisCheckedRealSpan adjustSpan adjustReal checkedItvfilelinelineESimpl Simplified FoundExprArg FoundHolelqDec throwErrorInQ mkSpecDecs symbolNamesimplifyBareTypesimplifyBareType'simplifyBareType''filterExprArgs locSourcePos dataToExpQ' textToExpQextQGHC.Listheadtail Data.TuplefstsndmaxArity isWiredInLoc isWiredInName wiredInNamesisWiredInShapewiredTyDataConslistTyDataConstupleTyDataConsmkpsmkps_RInv _rinv_args _rinv_type _rinv_name pprCGInfo lookupRInvgoodInvs unifiableconjoinInvariantShiftconjoinInvariant insertFEnvaddKVars trueRefTypetrueRefrefreshRefType refreshReffreshSym refreshVVRefrefreshArgsSub refreshPs refreshHoles'noHolesfreshTy_reftypeisKut specTypeKVarsofType'fixTy exprRefType exprRefType_ bindRefType_extendγ updREnvLocal filterREnv deleteREnv memberREnv globalREnvrenvMaps localsREnv globalsREnvaddBind addClassBindaddCGEnv normalizeVV _dupBindError++=setBind'constraintToLogicOnesubConstraintToLogicOne combinationsforallExprRefTypersplitWbsplitWbsplitW'splitsSWithVariancersplitsSWithVariancebsplitSrsplitSsplitfWithVariance updateEnvtraceTyparensrHolesplitsCWithVariancersplitsCWithVariancebsplitC addLhsInv checkStratumbsplitC'unifyVVrsplitCforallExprReftforallExprReft_forallExprReftLookup dataConToBare specToBareTC specToBareTVtxRTypetxRTVtxPVExStemappmap expToBindT expToBindReftgetBinds addExistsaddExist expToBindRef expToBind expToBindParg expToBindExpr freshSymbol _setEmbeds setModule mkExprAlias expandApp txPredReft' expandExpr expandSym expandSym' expandEAppNameStringlookupGhcThing'symbolicString symbolLookupwiredInsymbolLookupEnvsymbolLookupEnvOrig makeRdrNamemakeOccsymbolLookupEnvFulllookupTheModule lookupTheNameghcSplitModuleNameghcSymbolString isTupleDClookupGhcDataCon'makeDataConSelector'dcSymbolfreeSyms mapTyRVarmatchKindArgs' varFunSymbolisFunVar plugHolesaddRefs maybeTrue killHoles resolveSym resolveCtorresolveCtorVar isSpecialSymaddSymisConexprArgmapMPvar mkSpecTypetxParamtxPvarpredMaprtypePredBindsofBRType matchTyConfailRTAliasAppexpandRTAliasApp bareTCApptyAppexpandRTypeSynonymsNodeGraph AliasTable makeRTAliases makeREAliases graphExpandbuildAliasTablefromAliasSymbolbuildAliasGraphbuildAliasNodecheckCyclicAliases cycleAliasErrgenExpandOrderordNubbuildTypeEdgesbuildExprEdges addSymSort addSymSortRefaddSymSortRef' spliceArgsSimplifysimplifyinlineLStatelsSymMaplsErrorlsEmblsBoolslsDCMapLogicMvarTypethrowvarRTypecoreToLg checkBoolAlts casesToLg checkDataConaltToLg coreToIte toPredApp toLogicAppmakeApp eVarWithMapvarExpr isPolyCstisCstbrelsbops splitArgs tomaybesymboltosymbol tosymbol'makesubmkR ignoreVar_simpleSymbolVar' isErasableisANFisDead isUndefined HasDataDeclNoDeclHasDeclzipMap hasDataDeclhasDecl tyConDataDecl dataConDeclmakeMeasureInlinemakeMeasureDefinitionerrHMeasstrengthenHaskellmeetLocmakeMeasureSelectormakeMeasureChecker mkMeasureDConmkMeasureDCon_ measureCtors mkMeasureSort isSimpleType varSpecTypemakeHaskellBound coreToFun'toBoundcapitalizeBound expandMeasureexpandMeasureDefexpandMeasureBody makeHIMeas varSymbols varsAftergrepClassAssertsgrepClassAssumes makeLocalSpecmakeSpec mkVarSpec makeIAliases' makeNewTypes'makeInvariants'makeSpecDictionarymakeSpecDictionaryOneresolveDictionariesmkBound makeRTypeBasemkReftCtorTypequalifyDataCtor DataPropDeclTyConLanguage.Fixpoint.Types.Sorts suffixSymbol canonizeDecls checkDataDeclmakeNumericInfoOne instanceTyCon groupDataConsmakeFDataDecls makeDataDecltyConLocSymbol makeDataCtor fieldNamemakeDataFieldsmuSort makeConTypes'groupVariances dataConSpec' checkDataCtor ofBDataDeclvarSignToVariancegetPsSig getPsSigPsaddps ofBDataCtornormalizeField qualifyField qualifyNamemakeTyConEmbeds' checkRType checkMeasurescheckQualifierscheckQualifier checkSizeFun_checkRefinedClasses_checkDuplicateFieldNames_firstDuplicatecheckInvcheckIAl checkIAlOnecheckRTAliases checkBindcheckDupIntersectcheckDuplicatecheckDuplicateRTAlias checkMismatchtyCompaterrTypeMismatchtyToBind checkAppTys checkTcAritycheckAbstractRefs checkReft checkMeasure checkMBodycheckMBodyUnify checkMBody' dropNArgscheckClassMeasures axiomType updateLMapXVgetReflectDefsfindVarDefType makeAxiommkError makeSMTAxiommakeAssumeTypegrabBody isBoolBind strengthenRes updateLMapunDummy singletonAppinitPropSymbolsmakeLiftedSpec0 symbolVarMapReplaceM ReplaceState ReplaceEnvRE_reEnv_reFEnv_reEmb_reTyi initAxSymbolsimportedSymbolsexportedSymbolslistLMap postProcess ghcSpecEnvadtEnv _propCtormakeLiftedSpec1 varLocSymvarLocSimpleSyminsert _dumpSigs liftedVarMap checkLiftedcheckShadowedSpecs checkDisjoint makeGhcSpec'measureSymbolsaddRTEnvmakeExactDataCons varInModulemakeDataConCtor getReflects getAxiomEqs makeGhcAxiomsqualifyAxiomEq makeLogicMap emptySpec makeGhcSpec0 makeGhcSpec1 qualifyDefsqualifyMeasure qualifyRTyConqualifyTyConInfoqualifyLocSymbol qualifyTyConPqualifySizeFunqualifySymbol' makeGhcSpec2 makeGhcSpec3 makeGhcSpec4insertHMeasLogicEnvmakeGhcSpecCHOP1makeGhcSpecCHOP3makeMeasureInvariants isSymbolOfVarmeasureTypeToInvmakeGhcSpecCHOP2 txRefSort'replaceLocalBinds traverseExprs traverseBindswithExtendedEnvvarShortSymbolreplaceLocalBindsOne useSigQuals useAlsQuals maxQualParamsuseQuals needQuals alsQualifiers specAliases validQual sigQualifiersqualifyingBinders scrapeVars specBinders specAxiomVars refTypeQuals refTopQualsmkPQualmkQualenvSortignoreQualifiers targetFInfomakeAxiomEnvironment makeSimplify makeEquationsspecTypeToLogicspecTypeToResultRef makeAxiomsSpecEnvextractSpecCommentsextractSpecCommentfindAndParseSpecFiles DepGraphNodeDepGraph getGhcInfos'createTempDirectoryIfMissingconfigureDynFlagsconfigureGhcTargetssetTargetModules compileCFilesreachableModules buildDepGraphmkDepGraphNode isHomeModulemodSummaryImportsimportDeclModule classCons derivedVars derivedVs unfoldDepexprDep importVars definedVarsprocessModules processModulekeepRawTokenStreamloadDependenciesOf loadModule'processTargetModule toGhcSpecmodSummaryHsFilecachedBareSpecscheckFilePragmasextractSpecQuotesextractSpecQuoterefreshSymbols refreshSymbol getPatSpec getRealSpectransParseSpecsnoTerm parseSpecFile moduleHquals moduleFiles moduleFile specIncludesreqFilemakeMGIModGuts errMsgErrors predsUnifymakeDataConTypesmakeAutoDecrDataConsidTyConlenOfmakeSizedDataConsmergeDataConTypes refreshArgs' strataUnifyassmgrtyassmGrtygrtyTopinfoLits coreBindLits makeDecrIndex consCBTop varTemplate varTemplate' topSpecTypecconsEinstantiatePredsinstantiateStrataconsE consPattern cconsFreshE projectTypes freshPredRefargType makeSingleton strengthenTop varRefType otherwiseexprLocTemplateAssertedAssumedInternalUnknownconsActmakeDecrIndexTyrecType checkIndex makeRecTypeunOConsmergecondition safeLogIndex checkHintcheckValidHint consCBLettrustVar derivedVar doTermCheckconsCBSizedTysconsCBWithExprs makeFinTy makeTermEnvs addObligationconsCBgrepDictionaryconsBind killSubst killSubstReftdefAnn addPToEnvextender unTemplateaddPostTemplatesafeFromAssertedcconsE'lambdaSingletonaddFunctionConstraintsplitConstraints substStrata cconsLazyLet caseKVKindupdateEnvironment checkMonadunRRTycastTycastTy' isClassConCo checkUnbound dropExistsdropConstraints cconsCasecaseEnvaltReftunfoldRinstantiateTysinstantiatePvs checkTyConcheckFuncheckAllcheckErrvarAnnargExprlamExpr??= varRefType'funExpr singletonReftstrengthenMeettopMeet isGenericSortseedsortTysarrowizeunObjevalPred evalPredBlob1 evalPredBlob2fromExpr evalExpr'isTheorySymbol evalExprBlob1 evalExprBlob2evalBrel applyMeasureevalSetevalBodyevalRelevalBop GCheckFields gcheckFields GDecodeFields gdecodeFields GQueryFields gqueryFields GRecursive gconArgTys GToExprFields gtoExprFields GQueryCtors gqueryCtors GToExprCtor gtoExprCtorGCheckgcheckGDecodegdecodeGQuerygqueryGToExprgtoExprreproxy reproxyRep reproxyGElemqualifyqualifiedDatatypeName reproxyLeft reproxyRight gisRecursive gqueryCtorgetCtorsdataConSymbol_noUniquegenFun stitchFungenExprevalTypefreshen evalTypesGHC.ShowShow queryArgs decodeArgsmkExprsprocesssmt2manyfunc mySmt2Sort checkManycheckOneactOrDiehandle liquidOnenewPrune maybeEither liquidQueries liquidQuerydumpCs pprintManysolveCse2uResOkResFail runLiquid'