!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST U V W X Y Z [ \ ] ^ _ ` a bcdefghijklmnopqrstuvwxyz{|}~         !"#$%&'()*+,-./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*[*\*]*^*_*`*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,{,|,}-~-----------........../////////000000000000000111111112222222222222222223      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~4444444444555555555555555555555666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777 7 7 7 7 7777777777777777777 7!7"7#7$7%7&7'7(7)7*7+,-./0123456789:;<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L9M9N9O9P9Q9R9S9T9U9V: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={=|=}=~=======>?@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAABBBBBBBBBCDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF F F F F FFFFFFGGGGGGGGHHIJJ J!J"J#J$J%J&J'J(J)J*J+J,J-J.J/J0J1J2J3J4J5J6J7J8J9J:J;J<J=J>K?K@KAKBKCKDKEKFKGKHKIKJKKKLKMKNKOKPLQLRLSLTLULVLWLXLYLZL[L\L]L^L_L`MaMbMcNdNeNfNgOhPiPjPkPlPmPnPoPpPqQrQsQtQuQvQwRxRyRzR{R|R}R~RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSTTTTTTTTTTTTTTTT T T T U U U U U U U U U U U V V W W W W W X Y Y Y Z Z Z Z Z Z Z Z !Z "Z #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` ga ha ia ja ka la mb nb ob pc qc rc sd td ud vd wd xd yd zd {d |d }e ~e f f f f f g g h h i i i i i i i i i i i j j j j j j j j j j j j j j j j j j j j j j j j j j j j j j j j j j k k k k k k k k k k k k k k k k k k k k k k k k k l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l m m m n n n n n n n n n n n n n n n n n n n n n n !n "n #n $n %n &n 'n (n )n *n +n ,n -n .n /n 0n 1n 2n 3n 4n 5n 6n 7n 8n 9n :n ;n <n =n >n ?n @n An Bn Cn Do Eo Fo Go Ho Ip Jp Kp Lq Mq Nq Oq Pq Qq Rq Sq Tq Uq Vq Wq Xq Yq Zq [q \q ]q ^q _q `q aq bq cq dq eq fr gr hr ir jr ks ls ms ns os ps qs rs ss ts us vt wt x y z { | } ~   uSafeOIISafeNOJJMapping ------------------------------------------------------------------MJPowersets ----------------------------------------------------------------NJCombining ---------------------------------------------------------------- JKLMNOPQR JKLMNOPQRNoneOPSS SafeOTUVWXTUVWX None"#Ol 1Decide whether to add a tick to a binding or not.  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. Tickishs 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.YZYZ     None;<=OrRun a  action inside the   monad.sRun a  action inside the   monad. 5Build a set of desugarer environments derived from a  .tRun a & action in the context of an existing  (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 zeroUEmit a warning for the current source location NB: Warns whether or not -Wxyz is setDEmit a warning only if the correct WarnReason is set in the DynFlags\Issue an error, but return the expression for (), so that we can continue reporting errors. QAttempt to load the given module and return its exported entities if successful.The COMPLETE* pragams provided by the user for a given  .=Fail with an error message if the type is levity polymorphic.RCheck an expression for levity polymorphism, failing if it is levity polymorphic.Runs the thing_inside. If there are no errors, then returns the expr given. Otherwise, returns unitExpr. This is useful for doing a bunch of levity polymorphism checks and then avoiding making a core App. (If we make a core App on a levity polymorphic argument, detecting how to handle the let/app invariant might call isUnliftedType, which panics on a levity polymorphic type.) See #12709 for an example of why this machinery is necessary. Run a ' with DPH things in scope if necessary. %Extend the global environment with a  & containing the exported entities of,uv iff '-XParallelArrays' specified (see also  ).wx iff  '-fvectorise' specified. If '-XParallelArrays'< given, we populate the builtin table for desugaring those. Populate   from  .Get a name from Data.Array.Parallel for the desugarer, from the  / component of the global desugerar environment.Lookup a name exported by wx or wxA. Panic if there isn't one, or if it is defined multiple times.Lookup a name exported by wx or wx, returning  ; if it's not defined. Panic if it's defined multiple times.c ! 678bcdefghijklmnopqrstuvwxyz{|}~csrutq87 wyz|}v{x 6 ~! bmnijklfghocdepcdefgijklmn NoneO%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 -- otherwiseUnconditionally make a   strict.ticks 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 bindsOriginal patternOriginal patternBanged pattern5cdefgijkl5ijklfgcdeNoneO(NoneOǘNoneONoneO]}Desugar top level binds, strict binds are treated like normal binds since there is no good time to force before first usage.Desugar all other kind of bindings, Ids of strict binds are returned to later be forced in the binding group body, see Note [Desugar Strict binds] 7Desugar a single binding (or group of recursive binds). yThis is where we apply INLINE and INLINABLE pragmas. All we need to do is to attach the unfolding information to the Id.5Other decisions about whether to inline are made in calcUnfoldingGuidance_ but the decision about whether to then expose the unfolding in the interface file is made in yz using this information.  Returns a CoreExpr :: TypeRep ty The 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.  EvTerm for  Typeable ty The type tyReturn CoreExpr :: TypeRep ty namely  typeRep# dictI Remember that typeRep# :: forall k (a::k). Typeable k a -> TypeRep a NoneONoneOVU NoneFOT +Represent result signature of a type family Represent 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. 1Represent injectivity annotation of a type family  Represent a type variable binder #Represent a kind wrapped in a Maybe :Construct Core expression for Nothing of a given type name 5Construct Core expression for Nothing of a given type :Store given Core expression in a Just of a given type name 5Store given Core expression in a Just of a given type %Name of the TyCon of the element type The element type %Name of the TyCon of the element type The element type  NoneOsptInitCode 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.NoneO^ZqThe 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(*$'#&%")None&'-FNO|H ^The arity of a pattern/pattern vector is the number of top-level patterns that are not guards Either a list of patterns that are not covered, or their type, in case we have no patterns at hand. Not having patterns at hand can arise when handling EmptyCase expressions, in two cases:JThe type of the scrutinee is a trivially inhabited type (like Int or Char)4The type of the scrutinee cannot be reduced to WHNF.-In both these cases we have no inhabitation candidates for the type at hand, but we don't want to issue just a wildcard as missing. Instead, we print a type annotated wildcard, so that the user knows what kind of patterns is expected (e.g. (_ :: Int), or (_ :: F Int), where F Int does not reduce). Pattern check resultRedundant clauses?Not-covered clauses (or their type, if no pattern is available)Clauses with inaccessible RHSMore details about the classification of clauses into useful, redundant and with inaccessible right hand side can be found here: 7https://ghc.haskell.org/trac/ghc/wiki/PatternMatchCheck 4When we learned that a given match group is complete 9From the original definition of the type constructor. From a user-provided COMPLETE pragma 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 The empty pattern check result :Non-exhaustive empty case with unknown/trivial inhabitants$Check a single pattern binding (let) $Check a single pattern binding (let)*Check a matchgroup (case, functions, etc.) Check a matchgroup (case, functions, etc.). To be called on a non-empty list of matches. For empty case expressions, use checkEmptyCase' instead. Check an empty case expression. Since there are no clauses to process, we only compute the uncovered set. See Note [Checking EmptyCase Expressions] for details. Generate all inhabitation candidates for a given type. The result is either (Left ty), if the type cannot be reduced to a closed algebraic type (or if it's one trivially inhabited, like Int), or (Right candidates), if it can. In this case, the candidates are the singnature of the tycon, each one accompanied by the term- and type- constraints it gives rise to. See also Note [Checking EmptyCase Expressions] 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)` UCreate a term equality of the form: `(x ~ x)` (always discharged by the term oracle) +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]) KCheck whether a data constructor is the only way to construct a data type. {For a given conlike, finds all the sets of patterns which could be relevant to that conlike by consulting the result type.lThese come from two places. 1. From data constructors defined with the result type constructor. 2. From COMPLETEF pragmas which have the same type as the result type constructor. 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  FInitialise with default values for covering and divergent information. 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   if check is not supported. Value Set Abstractions Pattern Vectors Value Abstractions Patterns                ! " #  $ % & ' ( )  * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A NoneO} B C D E F G H I J K L MNone$O N'the desugared rhs of the bind statement S in (>>=) :: Q -> (R -> S) -> TNoneO O P Q R S T U V NoneO^L Variant of  that ensures that the result is not levity polymorphic. This should be used when the resulting expression will be an argument to some other function. See Note [Levity polymorphism checking] in DsMonad See Note [Levity polymorphism invariants] in CoreSyn W4The 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.NoneO\"Main entry point to the desugarer.  NoneO XThrow some errors.!$Convert a typechecked module to Core!!NoneDO"#$%&'()"#$%&'()None &';=NOQV*KData type for high-level patterns -----------------------------------------+e1 >>= x -> e21x3m4$dT8e9t:"return";xe<C=  x1,...,xn>i :: NatLT {len patBinds}?KLift expressions into High-level patterns ---------------------------------@KLower patterns back into expressions --------------------------------------*+,-./0123456789:;<=>?@*+,-./012345678349:;19<=>1818?@*+,-./012345678349:;19<=>1818SafeOGAASafeDOBCDEFGHIJKLMNOPQRSTUVWBCDEFGHIJKLMNOPQRSTUVWW8Safe ;<=>?FOTb]Function Equality Y)proof operators with optional proof terms5Comparison operators requiring proof terms optionallyiBecause provide lemmata ? or "5k,Proof combinators (are Proofean combinators)mGproof goes from Int to resolve types for the optional proof combinatorsp%proof operators requiring proof terms*Comparison operators requiring proof terms XYZ[\]^_`abcdefghijklmnopqrstuvw spqrcba_^`jhklimnogdefvtu]wXYZ[\ XYZ[\ Z^ [_ \` ]a ^b Ycde ^3_3`3a3b3c3h2i3j3p3q3r3s3 NoneO!SafeO6Gross hack, to force dependency and loading of module."None16Ov#None16OC=source files to check%path to directory for including specsBcheck subset of binders modified (+ dependencies) since last check1uninterpreted integer multiplication and division,interpretation of string theory in the logic)allow higher order binders into the logicallow higher order qualifiers$allow function extentionality axioms%allow lambda alpha-equivalence axioms$allow lambda beta-equivalence axioms-allow lambda normalization-equivalence axioms'check all binders (overrides diffcheck)save fixpoint queryset of binders to checkIwhether to complain about specifications for unexported and unused valuesdisable termination checkenable gradual type checkingdepth of gradual concretizationinteractive 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 NO-TRIGGER , proofMethod :: ProofMethod -- ^ How to create automatic instances NO-TRIGGER , fuel :: Int -- ^ Fuel for axiom instantiationDebug Instantiation!Disable non-concrete KVar slicing9Disable loading lifted specifications (for "legacy" libs)"Enable proof-by-logical-evaluationKK _ ` a b>$NoneO%None&'16;<=>?NOST cJThe Unique Monad ---------------------------------------------------------IMake each gradual appearence unique ------------------------------------- dJexpandWF ----------------------------------------------------------------- e f g h i j k l m n o p q r s t u&NoneOz'None;=NO v w(SafeOD    )NoneNO? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR*None 136;=NO6/VKSimple unstructured type for panic ----------------------------------------WKGeneric Type for Error Messages -------------------------------------------:INVARIANT : all Error constructors should have a pos fieldXliquid type errorY(liquid type error with a counter-exampleZliquid type error[condition failure error\specification parse error]sort error in specification^sort error in specification_#multiple alias with same name error`$multiple specs for same binder errora1multiple definitions of the same instance measureb(multiple definitions of the same measurec duplicate fields in same datacond+name resolves to multiple possible GHC varsebad data type specification (?)f*refined datacon mismatches haskell datacongInvariant sort errorhUsing sort erroriIncompatible using errorjMeasure sort errorkHaskell bad Measure errorlUnbound symbol in specificationmUnbound predicate being appliedn#GHC error: parsing or type checkingo)Mismatch between Liquid and Haskell typesp7Mismatch in expected/actual args of abstract refinementq%Cyclic Refined Type Alias Definitionsr5Illegal RTAlias application (from BSort, eg. in PVar)tTermination Erroru!Refined Class/Interfaces ConflictvNon well sorted Qualifierw9Previously saved error, that carries over after DiffCheck| Sigh. Other.}haskell 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 codepaths.Convert a GHC error into a list of our errors.hSUTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~}~}~}~}~}~}}}}}}}~}~}~}~}~}~}~}}}~}~}}}}~}~}}~}~}}~}~}~}~STUVSTUWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~}~}~}~}~}~}}}}}}}~}~}~}~}~}~}~}}}~}~}}}}~}~}}~}~}}~}~}~}~+None%&';=NOQVd 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 --------------------------------------------------------3KManipulating Symbols ------------------------------------------------------FKGHC 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 Instancesu      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOcdb      !"#$%&'()*+,-./a012`_^]\[ZYXWVUTSRQP3456789:;<=>?@ABCDEFGHIJKLMNO ,NoneO- x3Separating literate files into code/comment chunks. y type string z error string {Bline number, total width of lines i.e. max (length (show lineNum))oLoc -> (Var, Type)pList of error intervalsrAFormats Haskell source code using HTML and mouse-over annotationssAFormats 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.rWhether to include anchors.1Whether input document is literate haskell or not3Haskell source code, Annotations as comments at endColoured Haskell source code.sWhether to include anchors.!Function to refine comment tokens1Whether input document is literate haskell or notHaskell Source, AnnotationsColoured Haskell source code.hkijlmnqoprstuvrsmnopqvuhijklt x   y z {hijklmnopq-None%&'0;=NOQVd0q JGHC Type Substitutions ---------------------------------------------------                           ! " # $ % & ' ( ) * + , - . / 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.None1;<=NOV4/NoneO7# A single span,binder for whom we are generating constraintnearest known Source Span Opaque type for a stack of spans s t0None;=NOd7 1NoneO82None;=O93NoneO9None"#+013456;<=>?KNO3KKVar Profile --------------------------------------------------------------Recursive binder letrec x = ...Non recursive binder  let x = ...Int is the number of casesProjecting out field ofKOutput --------------------------------------------------------------------CAnnotations -------------------------------------------------------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 Aliases!name of the alias"type parameters#value parameters$what the alias expands to%start position&end position* What kind of 8 is it?+BUser defined data-definitions (should have refined fields),BAutomatically lifted data-definitions (do not have refined fields)-Termination expressions. x -> F.EVar x/x -> f x0Data Constructor2 DataCon name3 (fieldName, fieldType)4!Possible output (if in GADT form)5The name of the   corresponding to a 86for isVanillyAlgTyCon we can directly use the   name7for FamInst TyCon we save some  u name8Data type refinements:Type Constructor Name;Tyvar Parameters<PVar Parameters=PLabel Parameters>Data Constructors?Source Position@Default termination measureAType of Ind-PropBUser-defined or Auto-liftedEEValues Related to Specifications ------------------------------------SERefined 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  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  argument in } in the UReftR applies directly to any type and has semantics _independent of_ the data-type.$Abstract refinement associated with  "forall x y  z:: Nat, w :: Int7 . TYPE" ^^^^^^^^^^^^^^^^^^^ (rt_pvbind)"forall  zw$ . TYPE" ^^^^^ (rt_sbind)5For expression arguments to type aliases see testspos vector2.hs;let LH match against the Haskell type and add k-vars, e.g. `x:_` see testsposHoles.hsBCo- 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] variance info for type variables%variance info for predicate variables>logical UNARY function that computes the size of the structureGHC Type Constructor vPredicate Parameters TyConInfo$TyCon name with location information!Is this a class type constructor?Is Promoted Data Con?KPredicates ----------------------------------------------------------------?Abstract Predicate Variables ----------------------------------*Which Top-Level Binders Should be VerifiedType parametersAbstract Refinement parameters? strata stuff? Class constraints (via  w)Value parameters>Result type , tyData :: !SpecType -- ^ The generic ADT, see [NOTE:DataCon-Data]KWas this specified in GADT style (if so, DONT use function names as fields) Which module was this defined in)Map from symbols to equations they defineMap from (lifted) Vars to  x:; 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  xH 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 checking JBinders 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 module!lBinders that are _read_ in module , tyCons :: ![TyCon] -- ^ Types that are defined inside module"Imported .hqual files# ??? dead?$ ??? dead?%(All specification information for module&HPrinter ----------------------------------------------------------------8Accessors for RTyConJF.PPrint -----------------------------------------------------------------KTyConable Instances ------------------------------------------------------- NOTE:DataCon-Data for each M we also store the type of the constructed data. This is *the same as* X for *vanilla* ADTs (e.g. List, Maybe etc.) but may differ for GADTs. For example,9data Thing a where X :: Thing Int Y :: Thing Bool Here the  associated with X (resp. Y ) has N corresponding to 'Thing Int' (resp. 'Thing Bool'), but in both cases, the tyData should be 'Thing a'.For debugging.y9;<=>CB?A@DEHGFSUTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPRQSTUVWXY[\_Z^]`abcdefghijklmnopqrstuvwxyz{|}~     $!%# "&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%     CBA@?><=9;567:A<=;@?98G !"#$%&XMYZ[\]^_`abcCDEF>0z{|}~-./I89:;<=>?@AB567K01234'()J*+,xmylwuqrpnokjvtsNOPQRSTUVWXY1\[`a]fde^bcgh_BZ{|}ijlmnoHGFED&'()*+,-stuvwx     yzLkefghidHrpq./MNOSTUVWPQR~EFGHIJKLDC2347 y      !"#$%&'()*+,-./012345678 9:;<=>?@ABEFGHIJKLNOPQRSTUVWYZ[\]^_`abcefghiz{|}~) v !       !"#$%&'()*+4None;=O~5None+<NO zFrom GHC: TypeRepKPretty Printing RefType ---------------------------------------------------KA whole bunch of PPrint instances follow ----------------------------------XX6NoneNOiThe TagKey is the top-level binder, and Tag is a singleton Int list7None&'+;<=>?NOQV {KEmbedding RefTypes --------------------------------------------------------)Various functions for converting vanilla  | to SpecKHelper Functions (RJ: Helping to do what?) --------------------------------KType Substitutions --------------------------------------------------------KAnnotations and Solutions -------------------------------------------------KFrom Old Fixpoint ---------------------------------------------------------TBinders generated by class predicates, typically for constraining tyvars (e.g. FNum)KTermination Predicates ---------------------------------------------------- } 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 -----------------------------------------------------@@ ~   None;<=O+CConverting Results To Answers -------------------------------------1This 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 crash7KPretty 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.:+,-./010:/1+,-.+,8None1;<=NOB 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]`C 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 p resulting at predicate application sites in {|. 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 -> SpecTypeDGInterface: Modified CoreSyn.exprType due to predApp -------------------#r[<=>?@ABCDEFG#r?=<C@ADBE[GF>9NoneOL6Horrible hack to support hardwired symbols like  ,  ,  ,  w and other LH generated symbols that *do not* correspond to GHC Vars and *should not* be resolved to GHC Vars.OKLH Primitive TyCons -------------------------------------------------------RBLH Primitive TyCons ---------------------------------------------- KPredicate Types for WiredIns ---------------------------------------------- LMNOPQRSTU TUNOPQSRLM:NoneOtVV;None +;<=>?NOV WXYZ[\]^_ WXYZ[\]_^WXYZ<None;<O ghijklmnop ghijmnopkl=None16<NOwThe name of the boundx(Type variables that appear in the boundsy'These are abstract refinements, for nowzThese are value variables{The body of the bound qrstuvxwyz{| uvwxyz{tsrq|uvwxyz{>NoneO?None;=O @None;<=O, 3Intervals 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 ends name 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 -----------------------------------------------------------  Starting lineList of lengths of diffsList of changed line numbers    ANone;<=NO?U CJSON: Annotation Data Types ---------------------------------------output" creates the pretty printed outputannotate% actually renders the output to files DPandoc 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 HTML IBuilding Annotation Maps ------------------------------------------------TThis function converts our annotation information into that which is required by {}& 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 ----------------------------------------------------    BNone;=NOVBAttempt to canonicalize all   s in the 3 so we don't have to worry about relative paths. Updating optionsCExit Function -----------------------------------------------------CNoneOCfDNone;=OC  ENone+6;<=OX  User-defined properties for ADTs9Assumed (unchecked) types; including reflected signaturesImported functions and typesLocal type signaturesReflected type signatures9Data type invariants; the Maybe is the generating measure"Data type invariants to be checkedLoaded spec module namesPredicated data definitionsPredicated new type definitionsIncluded qualifier filesRefType aliasesExpression aliasesGHC-Tycon-to-fixpoint Tycon mapQualifiers in source/spec files#Information on decreasing argumentsAVariables that should be checked in the environment they are used+Ignore Termination Check in these FunctionsBinders to reflectMAutomatically instantiate axioms in these Functions with maybe specified fuel7Binders to turn into measures using haskell definitions5Binders to turn into bounds using haskell definitions;Binders to turn into logic inline using haskell definitions4Type Constructors that get automatically sizing info4Command-line configurations passed in through source!Measures attached to a type-class'Mappings from (measure,type) -> measureRefined Type-Classes$Terminating Conditions for functions? Where do these come from ?!KTemporary (?) hack to deal with dictionaries in specifications see testspos NatClass.hs,AxiomEqualities used for Proof-By-Evaluation33#FNone1;<=NOmG 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 specification Try 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 measure LHS of the thing being defined @Parsing Qualifiers ---------------------------------------------'     '     !   GNone13NOo  ~NoneOpHNoneOpXINoneOs JReplace Predicate Arguments With Existentials ----------------------------mNiki: please write more documentation for this, maybe an example? I can't really tell whats going on... (RJ)  JNone;<=>?NOw70KError-Reader-IO For Bare Transformation -----------------------------------11u stores the names of those ctor-fields that have been declared as SMT ADTs so we don't make up new names for them.' (!"#$%&)*+,-./0123456789:;0/. !"#$%&'()*+,-789:3;45612 !"#$%&'()*+,KNone<O~B/'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.C-'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   and  .>?@ABCDEFGHIJKLMNOEFML>?@AGHIKNODJBC>?@ALNone;<=NO2 PQRSTUVWXYZ[ VWXYZ[TUQRSP  P  MNoneOSbb returns   for unhandled lits because otherwise string-literals show up as global int-constants which blow up qualifier instantiation.Z[`ab`abZ[NNone;<=Ok "Specification for Haskell functioncc  ONone &';<=NOQV A  RewriteRule. is a function that maps a CoreExpr to anothergKTop-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 ~ yiggPNone1;<=NOV,hijklmhijkml   QNone;=KNO)qKA-Normalize a module ------------------------------------------------------ A-Normalize a CoreBind3 -------------------------------------------------- *eta-expand CoreBinds with quantified types KANF Environments ----------------------------------------------------------qq    RNone<ENOBwKFixpoint Environment ------------------------------------------------------y%Integer Keys for Fixpoint EnvironmentzFixpoint Environment{!Map from Symbol to current BindId KHelper 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 invariantsKDatatype recursive invariants: ignored in the base case assumed in rec callDatatype checkable invariants6Top-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 checkedKForcing Strictness --------------------------------------------------------dwxyz{|}~ewxyz{~}|wxyz{  ~ "SNone +;<=>?NOV%KGeneration: Freshness -----------------------------------------------------FRight now, we generate NO new pvars. Rather than clutter code with < calls, put it in one place where the above invariant is  obviously4 enforced. Constraint generation should ONLY use  freshTy_type and  freshTy_expr ~Used to generate "cut" kvars for fixpoint. Typically, KVars for recursive definitions, and also to update the KVar profile.KThis is all hardwiring stuff to CG ----------------------------------------WXYZ[\]^_TNone3;<=>?KNOVeU KRefinement Type Environments ----------------------------------------------    UNone<NOػ  2 adds a subtyping constraint into the global pool. (addPost: RJ: what DOES this function do? Add Well formedness Constraint  Add a warning NAdd Identifier Annotations, used for annotation binders (i.e. at binder sites) /Used for annotating reads (i.e. at Var x sites) HUpdate annotations for a location, due to (ghost) predicate applications             VNone;=Oc    WNone<Oe; KReftypes from F.Fixpoint Expressions -------------------------------------- KConstraint Generation Panic -----------------------------------------------          XNone<Oܫ  YNoneNO      ZNone;<=O* KQuerying 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.                 [None;<=NO % & % & % &\None;=NOt KExpand Alias Application -------------------------------------------------- 2 3 4 2 3 4 2 3]None<NO^ ?exprArg converts a tyVar to an exprVar because parser cannot tell this function allows us to treating (parsed) "types" as "value" arguments, e.g. type Matrix a Row Col = List (List a Row) Col Note that during parsing, we don't necessarily know whether a string is a type or a value expression. E.g. in testspos5T1189.hs, the string `Prop (Ev (plus n n))` where Prop is the alias: {-" type Prop E = {v:_ | prop v = E} 4-} the parser will chomp in `Ev (plus n n)` as a q and so   converts that q into an  . A B C D E A B C D E^NoneNO F F initializes the env needed to  3Q refinements and types, that is, the below needs to be called *before* we use  F F_None"#<NO KExpand Measures ----------------------------------------------------------- L L converts the  uYs and creates the measures for the selectors and checkers that then enable reflection. NOTE:Use DataconWorkIddcWorkId :: forall a1 ... aN. (a1 ~ X1 ...) => T1 -> ... -> Tn -> T checkT :: forall as. T -> Bool projT t :: forall as. T -> t G H I J K L M N O P Q G H I Q M N O L K J P   `None<HNO ]KAPI: Bare Refinement Types ------------------------------------------------ R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f R S T U V W X \ [ Z ] ^ _ ` b d c e f Y aaNone<NOS  # qualfies the field names for each 01 to ensure things work properly when exported. KCreate Fixpoint DataDecl from LH DataDecls --------------------------------A   is associated with a (  and) 8P, and defines the sort of relation that is established by terms of the given  . A   say, pd is associated with a dd of type 8 when pd is the p version of the q given by `tycPropTy dd`. gHmakeClassEmbeds: sort-embeddings for numeric, and family-instance tycons JmakeFamInstEmbeds : embed family instance tycons, see [NOTE:FamInstEmbeds]  NOTE:FamInstEmbedsFor various reasons, GHC represents family instances in two ways: (1) As an applied type, (2) As a special tycon. For example, consider `tests/pos/ExactGADT4.hs`:Lclass PersistEntity record where data EntityField record :: * -> **data Blob = B { xVal :: Int, yVal :: Int }instance PersistEntity Blob where data EntityField Blob dog where BlobXVal :: EntityField Blob Int BlobYVal :: EntityField Blob Int"here, the type of the constructor BlobXVal can be represented as: EntityField Blob Int,or R$58$EntityFieldBlobdog IntyPROBLEM: For various reasons, GHC will use _both_ representations interchangeably, which messes up our sort-checker.8SOLUTION: To address the above, we create an "embedding",R$58$EntityFieldBlobdog :-> EntityField BlobJSo that all occurrences of the (2) are treated as (1) by the sort checker.FmakeNumEmbeds: embed types that have numeric instances as int [Check!]   will prune duplicate   definitions, as follows:Let the "home" of a  C be the module where it is defined. There are three kinds of 8 definitions: <A "home"-definition is one that belongs to its home module,CAn "orphan"-definition is one that belongs to some non-home module.A + definition MUST be a "home" definition - otherwise you can avoid importing the definition and hence, unsafely pass its invariants!So, resolveTyConDecls# implements the following protocol:(a) If there is a Home6 definition, then use it, and IGNORE others.c(b) If there are ONLY "orphan" definitions, then pick the one from module being analyzed./We COULD relax to allow for exactly one orphan + definition which is the one that should be selected, but that seems like a slippery slope, as you can avoid importing the definition and hence, unsafely pass its invariants! (Feature not bug?) cSee [NOTE:Orphan-TyCons], the below function tells us which of (possibly many) DataDecls to use. iNOTE: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   for the *proposition* described- by the corresponding    8 , 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 ( # 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 --------------------------------------- ''canonizeDecls ds' returns a subset of ds@ with 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.   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] This computes the result of a  u application. For   we can just use the  # applied to the relevant tyvars. DataConP ty-varsvanilla result typeuser-provided result type12 g h i j k l h i k l j g12bNone "#<HNOVX mYChecking GhcSpec ------------------------------------------------------------------------  checkRTypeO determines if a type is malformed in a given environment ---------------------  checkMeasuresO determines if a measure definition is wellformed ----------------------------- m n o m n ocNone"#%<NOjG )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 p_ for (all, including the reflected binders), as we need the inlines and aliases to properly  3 the SpecTypes. _reflectedTyConsS returns the list of `[TyCon]` that must be reflected but which are defined *outside* the current module e.g. in Base or somewhere that we don't have access to the code. // _reflectedTyCons :: Config -> Ms.BareSpec -> BareM [TyCon] // _reflectedTyCons cfg spec // | exactDC cfg = mapM (lookupGhcTyCon "reflectedTyCons") $ tycName  $0 Ms.dataDecls spec // | otherwise = return [] We cannot reflect embedded tycons (e.g. Bool) as that gives you a sort conflict: e.g. what is the type of is-True? does it take a GHC.Types.Bool or its embedding, a bool? KsymbolVarMap resolves each Symbol occuring in the spec to its Var ---------%      p q r%      p r q      dNone;<=NOVzT KPer-Module Pipeline ------------------------------------------------------- sKGHC Interface Pipeline ---------------------------------------------------- tKGHC Configuration & Setup ------------------------------------------------- uKExtract 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 ----------------------------------------------------------- s t u v w s t w v ueNone ;<=>?NOV}N $&TODO: All this *should* happen inside Bare; but appears to happen after certain are signatures are fresh#-ed, which is why they are here. } ~ } ~fNone0345;<=>?KNOVW 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" *KConstraint Generation: Checking ------------------------------------------- +instantiatePreds' peels away the universally quantified PVars of a RType, generates fresh Ref. for them and substitutes them in the body. ,instantiateStrata generates fresh Strata: vars and substitutes them inside the body of the type. -KType Synthesis ------------------------------------------------------------ .Type Synthesis for Special Pattern's ------------------------------------- / 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  - (synthesis) and  * (checking) 0 0 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. 1BHelpers: Creating Fresh Refinement ------------------------------- 2KHelpers: Creating Refinement Types For Various Things --------------------- 3/create singleton types for function application 4RJ: nomeet replaces  strengthenS for  in the definition of  5 . Why does `tests/neg/strata.hs`$ fail EVEN if I just replace the  62 case? The fq file holds no answers, both are sat. 7KCleaner Signatures For Rec-bindings ---------------------------------------   8 9 : ; <gNone%<OeT AUse explicitly given qualifiers .spec or source (.hs, .lhs) files =MScrape qualifiers from function signatures (incr :: x:Int -> {v:Int | v > x}) >LScrape qualifiers from refinement type aliases (type Nat = {v:Int | 0 <= 0})  hNone<O  iNoneO  4 5 5 5 5 3 3jNone16;=O=      kNone%&'+,-FHOST    lNone"#%KOQV Twhether to keep going after finding a counter-example, useful for checking coverage _whether to stop after a certain number of successful tests, or enumerate the whole input space +whether to use SmallCheck's notion of depth extra options to pass to GHC ,Find the refined type of a data constructor. Given 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). 'Generate a fresh variable of the given  ?. Given a data constructor d1, create a new choice variable corresponding to d. Ask the SMT solver for the   of the given variable.1 1    @mNone%6O] 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.    nNone7;<=FOSTV] 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  . /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]. <the symbolic variable corresponding to the root of the valueBthe type of values we're generating (you can probably ignore this)                          A B C D E F G H I J K L M N O P Q R S T U V      oNone"#%)+-;<=FOTV]< D9A 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  Wable. You should never have to define a new  D instance. E|Test that a function inhabits the given refinement type by enumerating valid inputs and calling the function on the inputs. D E F E D F D X Y Z [pNone %;<=FOTVqNone"#$&'+1CDFOV]+ [Attempt to monomorphize a  D& according to simple defaulting rules. ^The parsed statement L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e Q R S T U V W O P M N X Y Z L [ \ ] ^ _ ` a b c d e M N O PrNone$NOV iThis fellow does the real work f g h i g i f hsNone16;=O \JResponse ----------------------------------------------------------------- lJCommand ------------------------------------------------------------------ mJState -------------------------------------------------------------------- k l m n o p q l k q m n o p \ ] ^ m n o ptNoneO v w w vNone%COQV zkTest whether a function inhabits its refinement type by enumerating valid inputs and calling the function. |Like  z, but returns the  % instead of printing to standard out. ~Like  zO, but accepts options to control the enumeration depth, solver, and verbosity. Like  ~, but returns the  % instead of printing to standard out. z the functionthe name of the function0the path to the module that defines the function!    D x y z { | } ~  & z | ~ { }  D       x y x y _        !"#$%&'()*+,-./ 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 defghijklmnopqrstuvwxyz{|}~       !""""""""""""##### #!#"###$#%#%#&#'#(#)#*#+#,#-#.#/#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$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+{+|+}+~+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,----------- - . . . ......./////////0000 0!0"0#0$0%0&0'0(0)0*0+1,1-1.1/10111213242526272829292:2;2<2=2>2?2@2A2B2C2D3EFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abccdefghijklmnopqqrstuvwxyz{|}~      !"#$%&'())*+,--./00123456789:;<=>?@ABCDEFGGHIJKLMNOPQRRSTUVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~44444444445555 5 5 5 5 5555555555555666666 7!7"7#7$7%7&7'7(7)7*7+7,7-7.7/707172737475767778797:7;7<7=7>7?7@7A7I7B7C7D7E7F7G7H7I7J7K7L7M7N7O7P7Q7R7S7T7U7V7W7X7Y7Z7[7\7]7^7_7`7a7b7c7d7e7f7g7h7i7j7k7l7m7n7o7p7q7r7s7t7u7v7w7x7y7z7{7|7}7~777777777777772777777777PQR88888888888888889999999999:;;;;;;;;;;;;;;;;<<<<<<<<<<====================>?@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAA A A A B BBBB{BBBBCDDeDEEEEEEEEEEE E!EE"E#E$E%E&E'E(E)E*E+E,E-E.E/E0E1E2E3E4E5E6E7E8E9E:E;E<E=E>E?E@EAEBECEDFEFFFGFHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeFfFgFhFiFjFkFlFmFnFoFpGqGqGrGsGtGuGvGwHxHyIzJ{J|J}J~JJJJJJ6J$JJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLMMMNN)N+N(OPPPPPPPPPQQQQQQRRRRRRRRRRRRRRRRRRRvRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R!R !R "R #R $R %R &R 'R (R )R *R +R ,R -R .R /R 0R 1R 2R 3R 4R 5R 6R 7R 8R 9R :R ;R <S =S >S ?S @S AS BT CT DT ET FT GT HT IT JT KT LT MT NT OT PT QT RT ST TT UU VU WU XU YU ZU [U \U ]U ^U _U `V aV bW cW dW eW fW gX hY iY jY kZ lZ mZZ nZ oZ pZ qZ rZ sZ tZ uZ v[ w[ x[ y[ z[ {[ |[ }[ ~[ [ [ [ [ \ \\ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ^ _ _ _ _ _ _ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` a a a a a a b b b c c c d d d d d d d d d d e e f f f f f g%g h h ii i iii i i i i i j j j j j j jj j j j j j j j|j j j j j j j j j j j j j j j j j j j k k k k k k k k k k k k k k kk k k k k kk k k k l l l l l l l l l l l l l !ll "l #l}l $l %l &l 'l 'lxl (l )l *l +l ,l -l .ll /l 0l 1l 2l 3l 4l 5l 6l 7ll 8l 9l :ll ;l <l =l >l ?l @l Al Bl Cl Dl El Fl Gm Hm Im Jn Kn Ln Mn Nn On Pn Qn Rn Sn Tn Un Vn Wn Xn Yn Zn [n \n ]n ^n _n `n an bn cn dn en fn gn hn in jn kn ln mn nn on pn qn rn sn tn un vn wn xn yn zn {n |n }n ~n n n n n o o o o o p p p q q q q q q q q q q q q q q q q q q q q q q q q q q r r r r r s s s s s s ss s s st t                   -                                                                        ! " # $ % & ' ( ) * + , - . / 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 Z [ \ ] ^ _ _ ` a 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  {  |  }  ~                        # # # # % % % % % % % % % % % % % % % % % %9% ' ' , , , , , , , , , , , , -          "                      ! " # $ % & ' ( ) * + , - . / 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  Z [ \  ]  ^ _ ` a b c d e f g h i j k l k m k n k o k p k q k r s t  u  v  w  x  y  z  {  |  }  ~                                      - //     5 l7  7 7 7 7 7 7 7 7 8 9 @ @Z@7@q@ @ @ @ @ @ @ @ @ @ @A A A A A A A A A A A A A A A A A A  B D D F F F F F F F F F F F F F F F F G G G G I I II I L LL L L L L L L L N NN O O O O O O  O PPP P PP Q Q Q Q Q Q Q Q Q Q Q QQQ R R R R R RS T W    \ ]   _:_ _ _ _ a !a "a #a $a %a &a ' ( )a *a +a , -b .b /c 0c 1c 2c 3c 4c 5c 6c 7c 8c 9c :d ;d <d =d >e ?f @f Af Bf Cf Df Ef Ff Gf Hf If Jf Kf Lf Mf Nf Of P Qf Rf Sf Tf Uf Vf Wg Xg Y ( Zln [n \n ]n ^n _n `n an bn cn dn en fn gn hn in jn kn ln mn nn on p q ro so to So uss vs w x,liquidhaskell-0.8.2.2-CpzODPl6eK730bIB0y0Im0'Language.Haskell.Liquid.Desugar.DsMonad Test.Target(Language.Haskell.Liquid.Desugar.TmOracleLanguage.Haskell.Liquid.TypesLanguage.Haskell.Liquid.UX.TidyGradual.GUI.Misc Gradual.MiscGradual.TrivialLanguage.Haskell.Liquid.Bag(Language.Haskell.Liquid.Desugar.Coverage&Language.Haskell.Liquid.Desugar.DsExpr%Language.Haskell.Liquid.Desugar.Match'Language.Haskell.Liquid.Desugar.DsUtils'Language.Haskell.Liquid.Desugar.DsCCall)Language.Haskell.Liquid.Desugar.DsForeign'Language.Haskell.Liquid.Desugar.DsGRHSs'Language.Haskell.Liquid.Desugar.DsBinds(Language.Haskell.Liquid.Desugar.MatchCon(Language.Haskell.Liquid.Desugar.MatchLit&Language.Haskell.Liquid.Desugar.DsMeta.Language.Haskell.Liquid.Desugar.StaticPtrTable%Language.Haskell.Liquid.Desugar.Check*Language.Haskell.Liquid.Desugar.DsListComp(Language.Haskell.Liquid.Desugar.DsArrows'Language.Haskell.Liquid.Desugar.Desugar'Language.Haskell.Liquid.Desugar.HscMainLanguage.Haskell.Liquid.Foreign#Language.Haskell.Liquid.GHC.ResugarLanguage.Haskell.Liquid.ListLanguage.Haskell.Liquid.Prelude(Language.Haskell.Liquid.ProofCombinators#Language.Haskell.Liquid.Types.Names,Language.Haskell.Liquid.Types.Specifications&Language.Haskell.Liquid.Types.Variance!Language.Haskell.Liquid.UX.Config Gradual.TypesGradual.UniquifyGradual.RefinementsGradual.ConcretizePaths_liquidhaskellLanguage.Haskell.Liquid.Misc$Language.Haskell.Liquid.Types.Errors Language.Haskell.Liquid.GHC.MiscLanguage.Haskell.Liquid.UX.ACSS#Language.Haskell.Liquid.GHC.TypeRep&Language.Haskell.Liquid.Types.Visitors%Language.Haskell.Liquid.GHC.SpanStack Language.Haskell.Liquid.GHC.PlayGradual.PrettyPrintingGradual.GUI.TypesGradual.GUI.Annotate$Language.Haskell.Liquid.Types.Strata)Language.Haskell.Liquid.Types.PrettyPrint Language.Haskell.Liquid.UX.CTags%Language.Haskell.Liquid.Types.RefType&Language.Haskell.Liquid.Types.PredTypeLanguage.Haskell.Liquid.WiredIn"Language.Haskell.Liquid.Types.Meet#Language.Haskell.Liquid.Types.Fresh*Language.Haskell.Liquid.Types.Dictionaries$Language.Haskell.Liquid.Types.Bounds+Language.Haskell.Liquid.Transforms.Simplify!Language.Haskell.Liquid.UX.Errors$Language.Haskell.Liquid.UX.DiffCheck#Language.Haskell.Liquid.UX.Annotate"Language.Haskell.Liquid.UX.CmdLine Gradual.GUI+Language.Haskell.Liquid.Transforms.RefSplitLanguage.Haskell.Liquid.MeasureLanguage.Haskell.Liquid.Parse&Language.Haskell.Liquid.UX.QuasiQuoter#Language.Haskell.Liquid.Bare.ToBare(Language.Haskell.Liquid.Bare.Existential Language.Haskell.Liquid.Bare.Env!Language.Haskell.Liquid.Bare.Misc.Language.Haskell.Liquid.Transforms.CoreToLogic&Language.Haskell.Liquid.Types.Literals"Language.Haskell.Liquid.Bare.Axiom*Language.Haskell.Liquid.Transforms.Rewrite&Language.Haskell.Liquid.Transforms.Rec&Language.Haskell.Liquid.Transforms.ANF(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.SymSort$Language.Haskell.Liquid.Bare.Plugged#Language.Haskell.Liquid.Bare.Lookup$Language.Haskell.Liquid.Bare.Resolve#Language.Haskell.Liquid.Bare.Expand#Language.Haskell.Liquid.Bare.OfType"Language.Haskell.Liquid.Bare.RTEnv$Language.Haskell.Liquid.Bare.Measure!Language.Haskell.Liquid.Bare.Spec%Language.Haskell.Liquid.Bare.DataType"Language.Haskell.Liquid.Bare.CheckLanguage.Haskell.Liquid.Bare%Language.Haskell.Liquid.GHC.Interface'Language.Haskell.Liquid.Constraint.Init+Language.Haskell.Liquid.Constraint.Generate,Language.Haskell.Liquid.Constraint.Qualifier-Language.Haskell.Liquid.Constraint.ToFixpointTest.Target.ExprTest.Target.TypesTest.Target.UtilTest.Target.MonadTest.Target.EvalTest.Target.TargetableTest.Target.TestableTest.Target.Targetable.FunctionLanguage.Haskell.Liquid.ModelLanguage.Haskell.Liquid.Liquid)Language.Haskell.Liquid.Interactive.Types+Language.Haskell.Liquid.Interactive.Handler Data.ArrayParallelData.Array.ParallelPrimTidyPgm addExternalLanguage.Haskell.Liquid ConstraintACSS LiquidHaskellExpandexpandbaseGHC.Base<*>pure*> Applicative Data.Functor<$><*(QuickCheck-2.10.1-BUFYQzp5Pjm7JbQeTzW89lTest.QuickCheck.All monomorphic Control.Monad mapAndUnzipMData.TraversablemapMghc TcRnMonadnewUniqueSupply newUnique whenGOptM unsetWOptM unsetGOptMxoptM 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.6-7ekgo2vNzFQLD9cAgffOsCLanguage.Fixpoint.Types.Names dummyName tidySymbolisDummy LocSymbolLocTextLanguage.Fixpoint.Types.SpansdummyLocvallocElocLocLocated#Language.Fixpoint.Types.PrettyPrintshowpppprint pprintPrec pprintTidyPPrintscriptmapThd3mapSndM mapMWithLog powersetUpToflattenexpand2expand3allCombinationssimplifyBagemptygetputunionaddTicksToBinds hpcInitCode$fMonadUniqueTM$fHasDynFlagsTM $fMonadTM$fApplicativeTM $fFunctorTM$fEqTickDensity$fEqTickishType DsWarning CanItFailCanFailCantFail MatchResult DsWrapper EquationInfoEqnInfoeqn_patseqn_rhsDsMatchContext idDsWrapperorFailfixDsinitDsTcinitDsinitDsWithModGutsinitTcDsForSolver newUniqueIdduplicateLocalDs newPredVarDsnewSysLocalDsNoLP newSysLocalDsnewFailLocalDsnewSysLocalsDsNoLPnewSysLocalsDs getGhcModeDs getDictsDs addDictsDs getTmCsDs addTmCsDsincrCheckPmIterDs resetPmIterDs getSrcSpanDs putSrcSpanDswarnDs warnIfSetDserrDs errDsCoreExpr failWithDsfailDs askNoErrsDsmkPrintUnqualifiedDsdsLookupGlobaldsLookupGlobalId dsLookupTyCondsLookupDataCondsLookupConLikedsGetFamInstEnvs dsGetMetaEnvdsGetCompleteMatchesdsLookupMetaEnvdsExtendMetaEnvdiscardWarningsDs dsNoLevPolydsNoLevPolyExpr dsWhenNoErrsdsInitPArrBuiltin dsDPHBuiltindsLookupDPHRdrEnvdsLookupDPHRdrEnv_maybe$fMonadThingsIOEnv$fOutputableDsMatchContext$fOutputableEquationInfo dsLocalBinds dsSyntaxExprdsLExpr dsLExprNoLPdsExprmatchSinglePat matchSimply matchWrappermatchCaseAlt MkCaseAltalt_pat alt_bndrs alt_wrapper alt_resultselectSimpleMatchVarLselectMatchVarsselectMatchVarfirstPat shiftEqns matchCanFailalwaysFailMatchResultcantFailMatchResultextractMatchResultcombineMatchResultsadjustMatchResultadjustMatchResultDs wrapBindswrapBindseqVarmkCoLetMatchResultmkViewMatchResultmkEvalMatchResultmkGuardedMatchResultmkCoPrimCaseMatchResultmkCoAlgCaseMatchResultmkCoSynCaseMatchResult mkErrorAppDs mkCoreAppDs mkCoreAppsDsmkCastDsmkSelectorBinds mkLHsPatTupmkLHsVarPatTupmkVanillaTuplePatmkBigLHsVarTupId mkBigLHsTupIdmkBigLHsVarPatTupIdmkBigLHsPatTupId mkOptTickBoxmkBinaryTickBoxdecideBangHoodaddBangdsCCallmkFCallunboxArg boxResult resultWrapper dsForeigns dsGuardeddsGRHSsdsGRHS isTrueLHsExpr dsTopLHsBinds dsLHsBindsdsSpec dsMkUserRuledecomposeRuleLhs dsHsWrapper dsTcEvBinds_s dsTcEvBinds dsEvBindsmatchConFamily matchPatSyndsLit dsOverLit dsOverLit'warnAboutIdentitieswarnAboutOverflowedLiteralswarnAboutEmptyEnumerations tidyLitPattidyNPat matchLiteralshsLitKey matchNPatsmatchNPlusKPats dsBracket sptInitCodeTmStatePmVarEnv canDivergeflattenPmVarEnvinitialTmState solveOneEq extendSubstexprDeepLookuptmOracle pmLitType checkSingle checkMatches genCaseTmCs2 genCaseTmCs1isAnyPmCheckEnabled$fOutputableValVec$fMonoidCovered$fOutputableCovered$fMonoidDiverged$fOutputableDiverged$fMonoidProvenance$fOutputableProvenance$fMonoidPartialResult$fOutputablePartialResult $fShowCovered$fShowDiverged$fShowProvenance$fEqProvenance$fOrdProvenancematchEquations dsListComp dsPArrComp dsMonadComp dsProcExpr dsValBindsdeSugar deSugarExprhscDesugarWithLocintCSizecSizeIntmkPtr isNullPtrfpLenpLenderefeqPtrPatternPatBind PatReturn PatProject PatSelfBindPatSelfRecBindpatE1patXpatE2patMpatDctpatTyApatTyBpatFFpatEpatTypatRetpatXEpatCtorpatBindspatIdxliftlower transposeplusminustimeseqneqleqgeqltgt liquidAssertB liquidAssert liquidAssume liquidAssumeB unsafeError liquidErrorcrashforcechooseisEvenisOdd safeZipWith==>PAndPOrPOrLeftPOrRightArg>.<.>=.<=.==.==?QEDProoftrivial***∵?&&&prooftoProof simpleProof<=:<:>:==:castWithTheoremcast byTheorem=*=.$fToProvea(->) $fToProveab $fOptEqab $fOptEqa(->) $fOptLEqab $fOptLEqa(->) $fOptGEqaa $fOptGEqa(->) $fOptLessab$fOptLessa(->) $fOptGtab $fOptGta(->) lenLocSymbol anyTypeSymbol specAnchorVariance Invariant Bivariant Contravariant Covariant VarianceInfo$fPPrintVariance$fNFDataVariance$fBinaryVariance$fDataVariance$fShowVariance$fGenericVariance HasConfig getConfig patternFlaghigherOrderFlag pruneFlag expandFlaghasOpt totalityCheckterminationCheckConfigfilesidirs diffchecklinear stringTheory higherorder higherorderqsextensionalityalphaEquivalencebetaEquivalence normalForm fullcheck saveQuerychecksnoCheckUnknown noterminationgradualgdepth ginteractive totalHaskell autoproofs nowarnings noannotationstrustInternals nocaseexpandstrata notruetypes nototality pruneUnsortedcores minPartSize maxPartSize maxParams smtsolver shortNames shortErrorscabalDir ghcOptionscFiles eliminateportexactDCnoADTnoMeasureFields scrapeImportsscrapeInternalsscrapeUsedImports elimStats elimBoundjsoncounterExamples timeBindsnoPatternInline untidyCorenoSimplifyCore nonLinCutsautoInstantiatedebugInstantionationnoslicenoLiftedImportproofLogicEvalallowPLEallowGlobalPLE allowLocalPLE$fSerializeSMTSolver$fShowInstantiate$fDefaultInstantiate$fSerializeInstantiate$fSerializeConfig$fHasConfigConfig$fEqInstantiate$fDataInstantiate$fGenericInstantiate$fGenericConfig $fDataConfig $fShowConfig $fEqConfigGSpanGMapGSubGConfiggtargetdepthpIdpNumber defConfigsetPId makeGConfigtoGMapfromGMapfromGSub removeInfouniquify $fUniqueExpr $fUniqueReft$fUniqueSortedReft $fUniqueInt$fUniqueIBindEnv $fUniqueSimpC$fUniqueHashMapmakeGMapGradual concretize$fGSubableReft$fGSubableSortedReft$fGSubableHashMap$fGSubableSimpC$fGSubableSizedEnv$fGradualGInfoversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameNat.&&..||.up timedAction!? safeFromJusttakeLastgetNthfst4snd4 mapFourth4addFst3addThd3dropFst3dropThd3replaceNfourth4third4firstMsecondMfirst3Msecond3Mthird3Mthird3zip4 getIncludeDir getCssPathgetCoreToLogicPathzipMaybesafeZipWithErrorsafeZip3WithErrormapNsmapN zipWithDefMsinglemapFst3mapSnd3 firstMaybeshashMapMapWithKeyhashMapMapKeys concatMapM firstElems splitters bchopAltschopAltssortDiff angleBracketsmkGraph tryIgnorecondNull firstJust intToString mapAccumMifM nubHashOn nubHashLast nubHashLastM uniqueByKey uniqueByKey'join 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 ErrParseAnnErrOtherposmsgctxtacttexpctxMtactMoblcondpErrvartypexpmsg'kindlocstycondconfieldnamesinvtAstUsmshslqTylqPosectrargNexpNactNacyclednamedposbindclsinstsqnamenamtcnameObligOTermOInvOConsCtxErrorctErrctCtxerrorWithContext errDupSpecs dropModeluErrorpanicDocpanictodo impossibleppErrorunpackRealSrcSpan realSrcSpanppError'ppVar sourceErrors$fFromJSONKeySrcSpan$fToJSONKeySrcSpan$fFromJSONSrcSpan$fToJSONSrcSpan$fFromJSONRealSrcSpan$fToJSONRealSrcSpan$fPPrintSrcSpan$fNFDataParseError$fPPrintParseError $fPPrintOblig $fNFDataOblig $fShowOblig $fBinaryOblig$fNFDataWithModel$fFromJSONTError$fToJSONTError $fOrdTError $fEqTError$fExceptionTError $fShowTError$fPPrintTError $fOrdCtxError $fEqCtxError$fGenericOblig $fDataOblig$fFunctorWithModel$fShowWithModel $fEqWithModel$fGenericWithModel$fGenericTError$fFunctorTError$fFunctorCtxErrorPrecL MGIModGutsMI mgi_binds mgi_modulemgi_deps mgi_dir_imps mgi_rdr_envmgi_tcs mgi_fam_insts mgi_exports mgi_cls_inst isAnonBindermkAlive miModGuts mg_dir_impsmgi_namestring srcSpanTick tickSrcSpan stringTyVar stringVar stringTyConstringTyConWithKindhasBaseTypeVar isBaseType validTyVartvIdtidyCBsunTick unTickExprisFractionalClasstracePprpprShow toFixSDocsDocDocpprDocshowPprshowSDoc myQualify showSDocDumptypeUniqueStringfSrcSpanfSrcSpanSrcSpansrcSpanFSrcSpansourcePos2SrcSpansourcePosSrcSpansourcePosSrcLocsrcSpanSourcePossrcSpanSourcePosEsrcSpanFilenamesrcSpanStartLoc srcSpanEndLoconeLinelineColrealSrcSpanSourcePosrealSrcSpanSourcePosE getSourcePos getSourcePosE locNamedThingnamedLocSymbol varLocInfo namedPaniccollectArgumentscollectValBinders'ignoreLetBinds isTupleId idDataConM isDataConIdgetDataConVarUniqueisDictionaryExpression realTcArity kindTCArity kindArity uniqueHash lookupRdrNamequalImportDecl ignoreInlinesymbolTyConWithKind symbolTyCon symbolTyVarlocalVarSymbolexportedVarSymbolqualifiedNameSymbolfastStringTexttyConTyVarsDefnoTyVarssplitModuleNamedropModuleNamesAndUniquedropModuleNamesdropModuleNamesCorrecttakeModuleNamesdropModuleUnique 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$fOutputableHashSet $fHashableLoc$fEqLoc$fOrdLoc $fShowLocStatusSafeUnsafeErrorCrashAnnMapAnntypeserrorsstatushscolourhsannottokeniseWithLoc srcModuleNamebreakS $fShowAnnMap $fEqStatus $fOrdStatus $fShowStatus$fShowAnnotation $fShowLitmkTyArgshowTy $fEqCoercion$fEqType $fSubstTym$fSubstTyCoAxiomRule$fSubstTyUnivCoProvenance$fSubstTyCoAxiom $fSubstTyRole$fSubstTyCoercion $fSubstTyType $fEqTyVarBndr CBVisitablefreeVarsreadVarsletVarsliterals$fCBVisitableAltCon$fCBVisitable(,,)$fCBVisitableExpr$fCBVisitableBind$fCBVisitable[]SpanVarTick SpanStackpushsrcSpanshowSpan $fShowSpanSubablesubsubTydataConImplicitIdssubVar substTysWith substExprmapTypestringClassArg $fSubableType $fSubableBind $fSubableVar $fSubable(,,)$fSubableCoercion $fSubableExprPrettypretty simplifyExpr $fPretty[] $fPretty(,)$fPrettySymbol $fPrettyKVar $fPrettyExprPKeys DependenciesSDepsDeps LocTokensUniqueuIduLocuName makePKeyskVarIdsrcDeps gSpanToDepskVarSpan takeFileName symbolLoc $fShowUnique renderHtmlMSpecctorMapmeasMapcmeasMapimeasKVProfKVKindRecBindE NonRecBindE TypeInstE PredInstELamECaseELetEProjectEOutputOo_varso_typeso_templso_botso_resultAnnotAnnUseAnnDefAnnRDfAnnLocAnnInfoAIRClassrcNamercSupersrcTyVars rcMethodsCMeasureCMcNamecSortMeasureMnamesorteqnsDefmeasuredparamsctordsortbindsbodyBodyEPRRTEnvRTE typeAliases exprAliasesModTypeTarget SrcImport SpecImportModNameCinfoCici_locci_errci_var ErrorResultREnvreGlobalreLocal UReftableofUReftRTypeRepty_varsty_preds ty_labelsty_bindsty_reftsty_argsty_resRTAliasRTArtNamertTArgsrtVArgsrtBodyrtPosrtPosE HasDataDeclNoDeclHasDecl DataDeclKindDataUser DataReflectedSizeFun IdSizeFun SymSizeFunDataCtordcNamedcFieldsdcResultDataNameDnNameDnConDataDeclDtycName tycTyVarstycPVars tycTyLabstycDCons tycSrcPostycSFun tycPropTytycKindAxiomEqHAxiomAxiomanamernameabindsatypesalhsarhsRDEnvDEnvRISig RIAssumed RInstanceRIriclassrityperisigsOkRT TyConableisFunisListisTupleppTyconisClassisEqualisNumCls isFracClsSubsTysubtStrataStratumSVarSDivSWhnfSFin LocSpecType LocBareTypeBRPropRRPropSpecPropSpecRepSpecTypeBareTypePrTypeRReftRPVarBPVarRSortBSortRRTypeBRTypeUReftMkUReftur_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 freeLabels tyConstrstyArgstyRes dcpIsGadt dcpModuledc_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 rTVarToBindrPropPisSVarszFunhasDecldataNameSymbol mapRTAVars lmapEAlias fromRTypeRep toRTypeRepmkArrow bkArrowDeepbkArrow safeBkArrowmkUnivsbkUnivbkClassrFunrClsrRCls addInvCondpApppappSym isTrivialmapReft foldRTypeisBaseisFunTymapReftMmapPropMfoldReft foldReft' efoldReftmapBotmapBindofRSorttoRSort insertsSEnv rTypeValueVar rTypeReftstripRTypeBase topRTypeBase makeDivType makeFinType getStrata isSrcImport isSpecImport getModName getModStringmapRTmapRE emptyKVProf updKVProfholeisHolehasHole liquidBegin liquidEnd $fShowDataCon$fPPrintDataCon$fSymbolicDataCon$fSubableWithModel$fSymbolicModuleName$fShowModuleName$fNFDataTError$fSubableQualifier $fShowLMap$fMonoidLogicMap$fNFDataPVKind$fBinaryPVKind $fPPrintPVar$fHashablePVar $fNFDataPVar $fBinaryPVar $fOrdPVar$fEqPVar $fSubablePVar$fPPrintPredicate$fReftablePredicate$fSubablePredicate$fMonoidPredicate$fNFDataPredicate$fBinaryPredicate$fPPrintBTyVar$fSymbolicBTyVar$fNFDataBTyVar$fHashableBTyVar$fBinaryBTyVar$fIsStringBTyVar $fOrdBTyVar $fEqBTyVar$fPPrintRTyVar$fSymbolicRTyVar$fNFDataRTyVar $fShowBTyCon$fPPrintBTyCon$fFixpointBTyCon $fEqBTyCon$fNFDataBTyCon$fSymbolicBTyCon$fBinaryBTyCon$fBinaryRTVInfo$fNFDataRTVInfo $fPPrintRTVar $fNFDataRTVar $fBinaryRTVar $fEqRTVar $fNFDataRef $fBinaryRef $fPPrintRef $fNFDataRType $fBinaryRType $fShowRTVar$fPPrintStratum $fShowStratum$fSubableStratum$fBinaryStratum$fNFDataStratum $fPPrint[] $fReftable[] $fMonoid[]$fSubableUReft$fExpressionUReft$fReftableUReft $fBinaryUReft $fNFDataUReft $fMonoidUReft$fSubableRType $fSubableRef$fTyConableBTyCon$fTyConableLocated$fTyConableSymbol$fTyConableTyCon $fBinaryRISig$fBinaryRInstance $fShowAxiom$fPPrintDataName$fSymbolicDataName$fShowDataName $fLocDataName$fBinaryDataName$fHashableDataName $fLocDataCtor$fBinaryDataCtor$fPPrintSizeFun$fBinarySizeFun$fNFDataSizeFun $fShowSizeFun$fShowTyConInfo$fNFDataTyConInfo$fDefaultTyConInfo $fShowRTyCon$fPPrintRTyCon$fFixpointRTyCon $fEqRTyCon$fTyConableRTyCon$fNFDataRTyCon $fLocDataConP$fBinaryDataDeclKind$fNFDataDataDeclKind$fSymbolicDataDecl$fShowDataDecl $fLocDataDecl $fOrdDataDecl $fEqDataDecl$fBinaryDataDecl$fBinaryRTAlias $fUReftable()$fUReftableUReft $fNFDataREnv $fNFDataCinfo $fLocCinfo$fFixpointCinfo$fSymbolicModName$fPPrintModName $fMonoidRTEnv $fSubableBody $fPPrintBody $fBinaryBody $fSubableDef $fPPrintDef $fBinaryDef$fBifunctorDef$fSubableMeasure $fShowMeasure$fPPrintMeasure$fBinaryMeasure$fBifunctorMeasure$fHasConfigGhcSpec$fHasConfigGhcInfo$fShowCMeasure$fPPrintCMeasure$fBinaryRClass$fNFDataAnnInfo$fMonoidAnnInfo $fNFDataAnnot$fMonoidOutput$fPPrintKVKind$fNFDataKVKind$fHashableKVKind$fNFDataKVProf$fPPrintKVProf $fMonoidMSpec $fShowMSpec $fPPrintMSpec$fBifunctorMSpec $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 $fEqDataName $fOrdDataName$fDataDataName$fGenericDataName$fDataDataCtor$fGenericDataCtor $fDataSizeFun$fGenericSizeFun$fGenericTyConInfo$fDataTyConInfo$fGenericRTyCon $fDataRTyCon$fGenericDataConP$fDataDataConP$fGenericTyConP $fDataTyConP$fEqDataDeclKind$fDataDataDeclKind$fGenericDataDeclKind$fShowDataDeclKind$fDataDataDecl$fGenericDataDecl$fShowHasDataDecl $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$fFunctorMSpec SubStratumsubSsubsS<:= solveStrata$fSubStratumRType$fSubStratumAnnot$fSubStratum[]$fSubStratum(,)$fSubStratumStratumpprManyOrderedpprintLongList pprintSymbolrtypeDoc $fPPrintUReft $fPPrintTidy$fPPrintRTAlias $fPPrintRType$fPPrintLogicMap $fPPrintLMap $fShowAnnInfo$fPPrintAnnInfo $fPPrintAnnot$fShowPredicate $fPPrintClass $fPPrintType $fPPrintTyCon $fPPrintName $fPPrintVar$fPPrintSourceError$fPPrintErrMsgTagEnvTagKey defaultTag memTagEnv makeTagEnvgetTagFreeVarstrengthenDataConTypepdVarfindPVaruRTypeuRType' uRTypeGenuPVaruReftuToprVarrTyVar updateRTVar rTVarInfo kindToRType isValKindbTyVar symbolRTyVar bareRTyVar normalizePdsrExrAppgApp pdVarReft tyConBTyConstrengthenRefTypeGenmeetable strengthen quantifyRTyquantifyFreeRTy addTyConInfo appRTyCon generalize tyClassessubsTyVars_meetsubsTyVars_nomeetsubsTyVar_nomeetsubsTyVar_meetsubsTyVar_meet'subts subvUReft subvPredicateofType bareOfType dataConReftisBaseTy dataConMsRefttoTyperTypeSortedReft rTypeSort applySolutionshiftVVtypeSorttypeUniqueSymbol tyConNameexpandProductType classBinds makeNumEnv isDecreasing makeDecrType isSizeable makeLexRefa mkTyConInfo $fPPrintREnv $fShowRef $fShowRType$fPPrintDataCtor$fPPrintDataDecl $fShowUReft $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$fHashableRTyVar $fOrdRTyVar $fEqRTyVar $fEqPredicate $fEqRType$fFixpointClass $fFixpoint[]$fReftableRType$fReftableRType0 $fReftableRef$fReftableRef0$fReftableRef1$fReftableRef2$fReftableRef3$fFreeVarBTyConBTyVar$fFreeVarRTyConRTyVar $fMonoidRef $fMonoidRTypeResultresulterrorToUserError cinfoError isTmpSymbol tidySpecType panicError $fException[]$fPPrintCtxError$fPPrintCtxError0$fResultFixResult$fResultTError $fResult[]$fResultTError0 makeTyConInfodataConPSpecTypedataConWorkRep dataConTyreplacePredsWithRefs pVartoRConc pvarRType replacePredspredType substParg pappAritypappSort$fShowDataConP$fPPrintDataConP $fShowTyConP$fPPrintTyConP isWiredIndcPrefixwiredSortedSyms dictionaryVardictionaryTyVardictionaryBindcombineProofsNameproofTyConName wiredTyCons wiredDataCons meetVarTypes Freshablefreshtruerefresh refreshTy refreshVV refreshArgsrefreshArgsSub refreshHoles$fFreshablemRType$fFreshablem[]$fFreshablemUReft$fFreshablemReft$fFreshablem[]0$fFreshablemExpr$fFreshablemSymbolmakeDictionariesmakeDictionary dfromListdmaptymapRISig fromRISigdmapdinsertdlookupdhasinfoRRBEnvRBEnvRRBoundRBoundBoundbnametyvarsbparamsbargsbbody makeBound$fBifunctorBound $fPPrintBound $fShowBound $fEqBound$fHashableBound $fBinaryBound $fDataBound$fGenericBoundsimplifyBounds tidyError DiffCheckDCnewBinds oldOutputnewSpec checkedVarsslicethin filterBinds saveResult$fFromJSONOutput$fToJSONOutput$fFromJSONAnnInfo$fToJSONAnnInfo $fFromJSONDoc $fToJSONDoc$fFromJSONFixResult$fToJSONFixResult$fFromJSONSourcePos$fToJSONSourcePos $fFunctorDiff$fPPrintDiffCheck$fOrdDefmkOutputannotate annErrors$fToJSONAnnMap $fToJSONLoc$fToJSONStatus $fToJSONAssoc$fToJSONAnnErrors$fToJSONAnnot1getOptscanonicalizePathsmkOpts withPragmasexitWithResult addErrors$fShowCtxError$fFixpointFixResultrendersplitXRelatedRefs $fIsFreexSpecmeasuresasmSigssigs 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 LiquidQuoteliquidQuoteSpeclq $fMonadSimpl$fApplicativeSimpl$fFunctorSimpl$fDataLiquidQuote specToBare measureToBare txExpToBindBareEnvBEmodNametcEnvrtEnvvarEnvhscEnvlogicEnvdcEnvaxSymspropSymsbeConfigbeIndexInlnEnvTCEnvWarnBareM DataConMap dataConMap setDataDeclsinsertLogicEnv insertAxiomaddDefsinModule withVArgs setRTAlias setREAliasexecBare$fHasConfigBareEnv$fFreshableWriterTInteger MapTyVarSTMTVSTvmaperrmsgmakeDataConCheckermakeDataConSelector symbolMeasure makeSymbols freeSymbols initMapSt runMapTyVars mapTyVarsisKind matchKindArgs mkVarExprjoinVarsimpleSymbolVar hasBoolResult normalize logicTypestrengthenResultstrengthenResult' runToLogicrunToLogicWithBoolBinds coreToDef coreToFun coreToLogicmkLitmkImkS $fShowExpr$fSimplify(,,)$fSimplifyBind$fSimplifyExprliteralFRefType literalFReft literalConstmakeHaskellAxioms rewriteBindstransformRecExprtransformScope outerScTr innerScTrsetIdTRecBound isIdTRecBound$fFreshableVar$fFreshableUnique$fFreshableInt anormalize$fHasConfigAnfEnv $fFunctorDsM $fMonadDsM$fMonadUniqueDsM$fApplicativeDsMFEnvFEfeBindsfeEnvfeIdEnv RTyConIAl RTyConInvHEnvCGInfofEnvhsCshsWfssCsfixCsisBindfixWfs freshIndexannotMap tyConInfospecDecrnewTyEnv termExprs specLVarsspecLazyautoSize tyConEmbedkutskvPackscgLitscgConstscgADTstcheckscheck pruneRefs logErrorskvProfrecCount bindSpansallowHOghcI dataConTysFixWfCFixSubCWfCSubCSubRsenvlhsrhsobligref LConstraintLCCGEnvCGEcgLocrenvsyenvdenvlitEnvconstEnvfenvrecsfargsinvsrinvsialgrtysassmsintysembtgEnvtgKeytreclcbholeslcsaenvcerrcgInfocgVarCG fromListHEnvelemHEnv addArgument addArguments mkRTyConInv mkRTyConIAl addRTyConInvaddRInvremoveInvariantrestoreInvariantmakeRecInvariants insertsFEnvinitFEnv$fMonoidLConstraint $fNFDataRInv $fNFDataFEnv $fNFDataCGEnv $fShowCGEnv $fPPrintCGEnv$fHasConfigCGEnv $fNFDataWfC $fPPrintWfC $fNFDataSubC$fSubStratumSubC $fPPrintSubC$fNFDataCGInfo$fPPrintCGInfo $fShowRInvrefreshArgsTop freshTy_type freshTy_expraddKutstrueTy$fFreshableStateTInteger fromListREnv insertREnv lookupREnvlocalBindsOfType toListREnvextendEnvWithVV addBindersrTypeSortedReft'+= globalizeaddSEnv+++=-=?= setLocationsetBindsetRecssetTRec getLocation pushConsBindaddCaddPostaddW addWarningaddIdA boundRecVaraddLocA updateLocAaddA lookupNewTypeaddConstraintsconstraintToLogicsplitWsplitSsplitCenvToSub panicUnbound txRefSortmakePluggedSigsmakePluggedAsmSigsmakePluggedDataCons GhcLookup lookupName lookupGhcVarlookupGhcDnTyConlookupGhcTyConlookupGhcDataCon$fSymbolicFieldLbl$fGhcLookupDataName$fGhcLookupFieldLbl$fGhcLookupName$fGhcLookupLocated Resolvableresolve$fResolvable()$fResolvablePVar$fResolvablePredicate$fResolvableReft$fResolvableUReft$fResolvableSort$fResolvableSymbol$fResolvableLocated$fResolvableExpr$fResolvableQualifier$fResolvable[] ExpandAliasesexpand'$fExpandAliases(,)$fExpandAliases[]$fExpandAliasesMaybe$fExpandAliasesLocated$fExpandAliasesUReft$fExpandAliasesDataConP$fExpandAliasesMeasure$fExpandAliasesDef$fExpandAliasesBody$fExpandAliasesRType$fExpandAliasesReft$fExpandAliasesExpr ofBareType ofMeaSortofBPVar mkLSpecType mkSpecType' makeRTEnvmakeHaskellDataDeclsmakeHaskellMeasuresmakeHaskellInlinesstrengthenHaskellInlinesstrengthenHaskellMeasuresmakeMeasureSelectorsmakeMeasureSpecmakeMeasureSpec'makeClassMeasureSpec varMeasuresmakeHaskellBounds makeClassesmakeQualifiers makeHintsmakeLVarmakeLazy makeAutoInstsmakeDefs makeHBounds makeTExpr makeHInlines makeHMeasmakeTargetVarsmakeAssertSpecmakeAssumeSpecmakeDefaultMethods lookupIds makeIAliases makeNewTypesmakeInvariantsmakeSpecDictionaries makeBoundsaddClassEmbeds makeDataDecls makeConTypesmeetDataConSpecmakeTyConEmbedsmakeRecordSelectorSigs checkGhcSpeccheckTerminationExprcheckTy makeGhcSpecsaveLiftedSpecloadLiftedSpec getGhcInfos runLiquidGhc exportedVars isExportedVar pprintCBs$fResultSourceError$fPPrintTargetVars $fShowGhcInfo$fPPrintGhcInfo$fPPrintGhcSpecinitEnvinitCGIgenerateConstraints$fFunctorTemplate$fFoldableTemplate$fTraversableTemplate$fShowTemplate useSpcQuals fixConfig cgInfoFInfogeleiffimpappprop $fNumExprValVBVVVXVSVCPassedFailedErrored MeasureEnv DataConEnvValueVariableTargetExceptionSmtFailedToProduceOutputSmtErrorExpectedValuesPreconditionCheckFailed EvalError ensureValuesboolsort choicesort$fExceptionTargetException$fShowTargetException $fSMTLIB2[] $fSymbolic(,) $fPPrintVal $fShowResult $fGenericVal $fShowVal$fEqVal$fOrdValResArgsAllHave ConstraintsMapHListNil:::DepthiomyTracereftmakeDecl deconSort applyPreds propPsToProp propPToPropsplitEApp_maybe stripQualsgetSpecrunGhc loadModule $fShowHList TargetState variableschoices constraintsdepsrealizedctorEnvmeasEnvembEnv tyconInfofreesyms constructorschosensortsfilePathmakingTy smtContext TargetOptssolververboselogging keepGoing maxSuccessscDepthghcOpts runTargetfreshInt defaultOpts initState whenVerbosenoteUsedaddDep addConstraintaddConstructormaking lookupCtorguardedaddSort addVariable freshChoicegetValue$fMonadThrowTarget$fFunctorTarget$fApplicativeTarget $fMonadTarget$fMonadIOTarget$fAlternativeTarget$fMonadStateTarget$fMonadCatchTarget$fMonadReaderTargetevalevalWithevalExpr TargetablequerydecodechecktoExprgetTypeqqueryunfoldapplyunapplyoneOfwhichOf constrainofReft $fGDecode:+: $fGDecodeM1 $fGCheck:+: $fGCheckM1 $fGQueryK1 $fGToExprK1$fTargetable(,,,)$fTargetable(,,)$fTargetable(,)$fTargetableEither$fTargetableMaybe$fTargetable[]$fTargetableBool$fTargetableWord8$fTargetableChar$fTargetableInteger$fTargetableInt$fTargetable()$fGToExprCtor:+: $fGToExprM1$fGQueryCtors:+: $fGQueryM1$fGToExprFieldsU1$fGToExprFieldsM1$fGToExprFields:*:$fGToExprCtorM1$fGRecursiveU1$fGRecursiveM1$fGRecursive:*:$fGQueryFieldsU1$fGQueryFieldsM1$fGQueryFields:*:$fGQueryCtorsM1$fGDecodeFieldsU1$fGDecodeFieldsM1$fGDecodeFields:*: $fGDecodeM10$fGDecodeFieldsK1$fGCheckFieldsU1$fGCheckFieldsM1$fGCheckFields:*: $fGCheckM10$fGCheckFieldsK1Testabletestsetup $fTestablea$fTestable(->)$fTargetable(->)$fTargetable(->)0$fTargetable(->)1Su TargetDictDict getModelsgetModel getModel' withContexttoFixCfg dictProxy asTypeOfDictaddDictsaddDictaddDict' monomorphizemonomorphizeOnemonomorphizeFree hscParsedStmthandleWarnings ioMsgMaybe throwErrors getWarnings clearWarnings logWarningshscParsedDeclsMbEnvliquidliquidConstraints runLiquid $fShowCinfoResponseCommandStatesCountsMbEnv$fSerializeStatus$fGenericStatus $fDataStatushandlerinitialTestTtargetTH targetResulttargetResultTH targetWith targetWithTHtargetResultWithtargetResultWithTHshouldTickBindaddTickLHsExprLetBodytickSameFileOnlyTMunTM TickishType ProfNotesHpcTicks Breakpoints SourceNotes TickTransEnvTTEfileNamedensity tte_dflagsexportsdeclPathinScope blackListthis_mod tickishTypeTickTransStateTT tickBoxCount mixEntries uniqSupply TickDensityTickForCoverageTickForBreakPointsTickAllFunctionsTickTopFunctionsTickExportedFunctions TickCallSitesTcMghc-prim GHC.TypesIOmkDsEnvsFromTcGblTcGblEnvHscTypesModGuts dsLoadModuleTyConinitDPHloadDAPRdrName GlobalRdrEnv checkLoadDAPinitDPHBuiltins ds_parr_bi ds_dph_envNothingHsPatPatdsHsBind makeCorePairds_ev_typeablegetReprepFamilyResultSigrepFamilyResultSigToMaybeKindrepInjectivityAnn repTyVarBndr repMaybeLKind coreNothing coreNothing'coreJust coreJust'CoreMkC TmOracleEnvvarInsolveComplexEqextendSubstAndSolvesimplifyComplexEqsimplifyPmExprsimplifyEqExprapplySubstComplexEq varDeepLookupPmArityUncoveredCandidatesPmResult Provenance FromBuiltin FromCompleteDeltaValVec emptyPmResultuncoveredWithTy checkSingle' checkMatches'checkEmptyCase'inhabitationCandidatesfake_pat isFakeGuardmkCanFailPmPat nilPattern mkLitPattern translateNPattranslatePatVectranslateConPatVectranslateGuardscantFailPatterntranslateGuard translateLet translateBindtranslateBoolGuard pmPatType mkOneConFullmkGuardmkNegEqmkPosEqmkIdEqmkPmVarmkPmVarsmkPmIdId mkPmId2Forms vaToPmExpr coercePatVec coercePmPatsingleConstructorallCompleteMatchestyOracle patternArityrunManymkInitialUncoveredpmcheckIpmcheckpmcheckGuardsI pmcheckGuards pmcheckHdI pmcheckHdusimpleutailuconkconmkUnionmkConsforcesforce_ifTrue substInValAbs wrapUpTmStatedsPmWarn warnPmIters exhaustiveexhaustiveWarningFlagDynFlags WarningFlag ValSetAbsPatVecValAbsUncoveredPatternsTypeOfUncoveredpmresultProvenancepmresultRedundantpmresultUncoveredpmresultInaccessible PartialResultpresultProvenencepresultCoveredpresultUncoveredpresultDivergentDiverged NotDivergedCovered NotCoveredMkDelta delta_ty_cs delta_tm_csPmPatPmConPmVarPmNLitPmGrd 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_exprPatTyPATVAPatGroupPgAnyPgConPgSynPgLitPgNPgOverSPgNpKPgBangPgCoPgViewPgOverloadedList dsMcBindStmtDsCmdEnvarr_id compose_idfirst_idapp_id choice_idloop_idmaxBuildLengthToProveOptGtOptLessOptGEqOptLEqOptEq Instantiate NoInstancesLiquidInstancesLiquidInstancesLocalUniqueMexpandWF RelativePosOutsideInsideSmallerGreater NoRelativeUniqueSTfreshIdkmapchangecacheulocubsbenvuniqGSubablegsubstLiterrlin annotTokeniseclassifyjoinLCodeunL AnnotationASubstTyTyCoRepprovSize pprTcAppCo pprDataConspprTyLitsubstForAllCoBndrCallbackextendCvSubstWithClone setCvSubstEnv coVarsOfCostyCoVarsOfProvtyCoVarsOfCoList KindCoercionTyLitNumTyLitStrTyLitsubstTyVarBndrCallbacksubstForAllCoBndrcheckValidSubstisValidTCvSubstsubstTysWithCoVars zipCvSubstmkTyCoInScopeSetnoFreeVarsOfCocloseOverKindsFV delBinderVar coercionSizetypeSizetidyCostidyCotidyKind tidyOpenKind tidyTopType tidyOpenType tidyOpenTypestidyType tidyTypes tidyTyVarOcctidyOpenTyCoVartidyOpenTyCoVarstidyFreeTyCoVarstidyTyVarBinderstidyTyVarBindertidyTyCoVarBndrtidyTyCoVarBndrsppSuggestExplicitKinds pprArrowChain pprPrefixApp pprTypeApppprTyVar pprTyVars pprTvBndr pprTvBndrs pprUserForAll pprForAll pprSigmaTypepprThetaArrowTypprTheta pprClassPred pprParendKind pprParendTypecloneTyVarBndrscloneTyVarBndrsubstCoVarBndrsubstTyVarBndr lookupCoVar substCoVars substCoVarsubstCossubstCoUncheckedsubstCo lookupTyVar substTyVars substTyVarsubstThetaUnchecked substThetasubstTysUncheckedsubstTyssubstTyUncheckedsubstTysubstTyAddInScopesubstTyWithCoVarssubstCoWithUnchecked substCoWithsubstTyWithInScopesubstTyWithUnchecked substTyWithzipCoEnvzipTyEnv mkTvSubstPrs zipTvSubst unionTCvSubstextendTvSubstListextendTvSubstAndInScope extendCvSubstextendTvSubstWithCloneextendTvSubstBinder extendTvSubstextendTCvSubstextendTCvInScopeSetextendTCvInScopeListextendTCvInScope zapTCvSubst setTvSubstEnvnotElemTCvSubst isInScopegetTCvSubstRangeFVs getTCvInScope getCvSubstEnv getTvSubstEnv mkTvSubst mkTCvSubstisEmptyTCvSubstmkEmptyTCvSubst emptyTCvSubstcomposeTCvSubstcomposeTCvSubstEnvemptyCvSubstEnvemptyTvSubstEnvnoFreeVarsOfTypecloseOverKindsDSetcloseOverKindsListcloseOverKinds coVarsOfCo coVarsOfTypes coVarsOfType tyCoFVsOfCos tyCoVarsOfCos tyCoFVsOfCotyCoVarsOfCoDSet tyCoVarsOfCotyCoFVsOfTypestyCoVarsOfTypesListtyCoVarsOfTypesDSettyCoVarsOfTypes tyCoFVsBndr tyCoFVsOfTypetyCoVarsOfTypeListtyCoVarsOfTypeDSettyCoVarsOfTypedropRuntimeRepArgsisRuntimeRepVarisRuntimeRepKindedTyisRuntimeRepTyisUnliftedTypeKindisLiftedTypeKind mkTyConTyisCoercionTypemkPiTysmkPiTy mkForAllTys mkForAllTymkFunTysmkFunTy mkTyVarTys mkTyVarTyisVisibleBinderisInvisibleBindertyThingCategorypprTyThingCategorypprShortTyThing KindOrType CoercionN CoercionR CoercionP CoercionHolechUnique chCoercion TvSubstEnv CvSubstEnv binderKind binderArgFlag binderVars binderVarsameVisisInvisibleArgFlagisVisibleArgFlagArgFlagRequired SpecifiedInferred TyVarBinder BasicTypes maybeParenpickLRTyPrecTopPrecFunPrecTyOpPrec TyConPrecpprKindpprTypeTypeTyVarTyAppTyTyConAppFunTyForAllTyLitTyCastTy CoercionTyTyThingAnIdAConLikeATyConACoAxiomCoercionReflUnivCo TyConAppCoAppCoForAllCoFunCoCoVarCo AxiomInstCoSymCoTransCo AxiomRuleCoNthCoLRCoInstCo CoherenceCoKindCoSubCoUnivCoProvenanceUnsafeCoerceProv PhantomProvProofIrrelProv PluginProvHoleProvTCvSubstTyBinderNamedAnonPredTypeKind ThetaTypesubstunStackDataCon rtc_pvarsdataConStupidThetaSymbolKVP ToTypeable#Language.Fixpoint.Types.RefinementsReft cmpLexRefTyConvtcFVartcFTVartcFApptcFLit substRConGHC.Listheadtail Data.TuplefstsndmaxArityChkItvstartendbinder assumeSpec dependsOn meetSpanslineDiff diffLinesgetShiftsetShiftAssoc renderPandoc renderDirect topAndTailmkAnnMaprefTokentokAnnotvimAnnot_annsAnnot1A1identannrowcol AnnErrorsAscGHC.IOFilePath canonConfigIsFreeisFree ParamComp bareTypePmkSpecspecP fallbackSpecP tyBindsRemP cMeasurePbinderPfTyConPPcScope PcImplicit PcExplicit PcNoSymbolPC_pci_pctSimpl Simplified FoundExprArg FoundHoleExStemappmapSimplifyinlineLStatelsSymMaplsErrorlsEmblsBoolslsDCMap axiomType RewriteRule_safeSimplifyPatTuplehasTuple replaceTuplefixCase substTupleCoreSynCaseisVarTupTrEnvTr_locnormalizeTopBindnormalizeForAllTysfreshNormalVarAnfEnvaeVarEnv aeSrcSpanaeCfgDsSTst_bindsrunDsMRInv _rinv_args _rinv_type _rinv_nameaddKVars updREnvLocalforallExprRefTypeNameString expandAppexprArgExprmakeMeasureSelector DataConSelCheckProjCtorTypequalifyDataCtor DataPropDeclmakeFamInstEmbeds makeNumEmbeds resolveTyCons resolveDeclsLanguage.Fixpoint.Types.Sorts suffixSymbol canonizeDecls checkDataDecldataConResultTyisVanillaDataCon checkRType checkMeasuresinitPropSymbolsmakeLiftedSpec0reflectedTyCons isEmbedded symbolVarMap ReplaceEnvRE_reEnv_reFEnv_reEmb_reTyiSpecEnvextractSpecCommentsextractSpecCommentfindAndParseSpecFiles predsUnify makeDecrIndex consCBTop varTemplate varTemplate' topSpecTypecconsEinstantiatePredsinstantiateStrataconsE consPattern cconsFreshE projectTypes freshPredRefargType makeSingleton strengthenTop varRefType otherwiseexprLocTemplateAssertedAssumedInternalUnknown useSigQuals useAlsQualsSort GCheckFields gcheckFields GDecodeFields gdecodeFields GQueryFields gqueryFields GRecursive gconArgTys GToExprFields gtoExprFields GQueryCtors gqueryCtors GToExprCtor gtoExprCtorGCheckgcheckGDecodegdecodeGQuerygqueryGToExprgtoExprGHC.ShowShow queryArgs decodeArgsmkExprsResOkResFail