h*%;n      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  !!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""#######$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%&&&&&&&&&'''''''''(((((((()))))*********************************************************+++++++++,,,,,,,,,,,,,,,,,---................................//////////0000000000000001111111112344455555555555556666666666666666666666666666666666666666666666666666667777777777777777777777778999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;<<<<======>>>>>>>>>>>>>>>>>>>???????????@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAABBBCCDDEEEFFFGGHIIJJJJJJJJJJJJJJJJJJJJJJJJKLLLLLMMMMNOOOOOOOOPPPPPQQQRRRSSSSSSST0.9.6.3 Safe-Inferred%&,J_U Safe-Inferred%&,J Safe-Inferred%&,Khliquidhaskell-bootGeneric ().  instance  MyType where () =  liquidhaskell-boot#A helper for better type inference. Safe-Inferred%&,K Safe-Inferred%&,7<aliquidhaskell-boot*the logging verbosity to use (defaults to )liquidhaskell-bootsource files to checkliquidhaskell-boot%path to directory for including specsliquidhaskell-bootcheck subset of binders modified (+ dependencies) since last checkliquidhaskell-boot1uninterpreted integer multiplication and divisionliquidhaskell-boot,interpretation of string theory in the logicliquidhaskell-boot)allow higher order binders into the logicliquidhaskell-bootallow higher order qualifiersliquidhaskell-boot smt timeoutliquidhaskell-boot'check all binders (overrides diffcheck)liquidhaskell-bootsave fixpoint queryliquidhaskell-bootset of binders to checkliquidhaskell-bootwhether to complain about specifications for unexported and unused valuesliquidhaskell-bootdisable termination checkliquidhaskell-bootdisable positivity checkliquidhaskell-boot0Adds precise reasoning on presence of rankNTypesliquidhaskell-bootdisable checking class instances , structuralTerm :: Bool -- ^ use structural termination checkerliquidhaskell-boot$disable structural termination checkliquidhaskell-bootenable gradual type checkingliquidhaskell-boot3scope of the outer binders on the inner refinementsliquidhaskell-bootdepth of gradual concretizationliquidhaskell-bootinteractive gradual solvingliquidhaskell-bootCheck for termination and totality, Overrides no-termination flagsliquidhaskell-boot*disable warnings output (only show errors)liquidhaskell-boot1disable creation of intermediate annotation filesliquidhaskell-boot$check internal (GHC-derived) bindersliquidhaskell-boot"maximum case expand nesting depth.liquidhaskell-bootdisable truing top level typesliquidhaskell-boot%disable totality check in definitionsliquidhaskell-boot$enable prunning unsorted Refinementsliquidhaskell-boot)number of cores used to solve constraintsliquidhaskell-bootMinimum size of a partitionliquidhaskell-boot2Maximum size of a partition. Overrides minPartSizeliquidhaskell-bootthe maximum number of parameters to accept when mining qualifiersliquidhaskell-bootname of smtsolver to use [default: try z3, cvc4, mathsat in order]liquidhaskell-boot0drop module qualifers from pretty-printed names.liquidhaskell-boot)don't show subtyping errors and contexts.liquidhaskell-bootfind and use .cabal file to include paths to sources for imported modulesliquidhaskell-boot#command-line options to pass to GHCliquidhaskell-boot..c files to compile and link against (for GHC)liquidhaskell-booteliminate (i.e. don't use qualifs for) for "none", "cuts" or "all" kvarsliquidhaskell-bootport at which lhi should listenliquidhaskell-boot>= x -> e2) specially for inference liquidhaskell-boot9print full blown core (with untidy names) in verbose mode liquidhaskell-bootsimplify GHC core before constraint-generation PLE-OPT , autoInst ntiate :: Instantiate -- ^ How to instantiate axioms liquidhaskell-boot!Disable non-concrete KVar slicing liquidhaskell-boot9Disable loading lifted specifications (for "legacy" libs) liquidhaskell-boot"Enable proof-by-logical-evaluation liquidhaskell-boot/Unfold invocations with undecided guards in PLE liquidhaskell-boot"Enable proof-by-logical-evaluation liquidhaskell-boot Use an interpreter to assist PLE liquidhaskell-boot8Enable proof-by-logical-evaluation locally, per function liquidhaskell-boot6Enable extensional interpretation of function equality liquidhaskell-boot-No inference of polymorphic type application. liquidhaskell-boot?Allow "reflection"; switches on "--higherorder" and "--exactdc" liquidhaskell-bootOnly "compile" the spec -- into .bspec file -- don't do any checking. liquidhaskell-boot#Do not check the transitive imports liquidhaskell-bootenable typeclass support. liquidhaskell-boot liquidhaskell-boot)Enable termination checking for rewriting liquidhaskell-boot>Skip this module entirely (don't even compile any specs in it) liquidhaskell-boot5Maximum PLE "fuel" (unfold depth) (default=infinite) liquidhaskell-bootPerform environment reduction liquidhaskell-boot#Don't perform environment reduction liquidhaskell-bootInline ANF bindings. Sometimes improves performance and sometimes worsens it. liquidhaskell-bootUse pandoc to generate html               Safe-Inferred%&,dl liquidhaskell-bootGenerate a string like Version 1.2, Git revision 1234.$(simpleVersion @) ::  Taken from  https://hackage.haskell.org/package/optparse-simple-0.1.1.4/docs/Options-Applicative-Simple.html#v:simpleVersion3 so we can drop the dependency on optparse-simple.   Safe-Inferred%&,<f liquidhaskell-bootA newtype wrapper around a Module which: Allows a Module! to be serialised (i.e. it has a  instance)>It tries to use stable comparison and equality under the hood. liquidhaskell-boot Converts a Module into a  . liquidhaskell-bootCreates a new   out of a  ModuleName and a UnitId.   Safe-Inferred %&,i"liquidhaskell-bootOur own simplified version of  to overcome the fact we cannot construct the "original" one as the constructor is not exported, and getHomeModuleInfo and getPackageModuleInfo> are not exported either, so we had to backport them as well. liquidhaskell-bootAbstraction of .liquidhaskell-bootOur own simplified version of . liquidhaskell-bootThe collection of dependencies and usages modules which are relevant for liquidHaskell liquidhaskell-bootDesugar a typechecked module. liquidhaskell-boot)Extract top-level comments from a module. liquidhaskell-boot-Tells if a case alternative calls to patError   Safe-Inferred%&,i !$%#"&!EFn '),(./0*+-123456789:;<=>?@ABCDGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstuvwxyz{|}~    !$%#"&!EFn '),(./0*+-123456789:;<=>?@ABCDGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstuvwxyz{|}~    Safe-Inferred%&,<~r liquidhaskell-bootDatatype For Holding GHC ModGuts ------------------------------------------ liquidhaskell-bootA  $ is virtually isomorphic to a GHC's ! but crucially we don't use the  instance defined on a  because it's Unique-based. In particular, GHC doesn't guarantee that if we load an interface multiple times we would get the same Unique for the same (, and this is a problem when we rely on s to be the same when we call  isExportedVar, which used to use a NameSet8 derived from the '[AvailInfo]'. As the name implies, a NameSet uses a s Unique> for duplicate detection and indexing, and this would lead to Vars being resolved to a + which is basically the same, but it has a  different Unique., and that would cause the lookup inside the NameSet to fail. liquidhaskell-bootCreates a new   out of a . liquidhaskell-bootConverts a list of + into a "StableNameSet", similarly to what availsToNameSet would do.   Safe-Inferred%&,~   Safe-Inferred%&,#  Safe-Inferred"%&,79<6 liquidhaskell-bootSimple unstructured type for panic ---------------------------------------- liquidhaskell-bootGeneric Type for Error Messages -------------------------------------------:INVARIANT : all Error constructors should have a pos field liquidhaskell-bootliquid type error liquidhaskell-boot(liquid type error with a counter-example liquidhaskell-bootliquid type error liquidhaskell-boot hole type liquidhaskell-boot$hole dependencies form a cycle error liquidhaskell-bootcondition failure error liquidhaskell-bootspecification parse error liquidhaskell-bootsort error in specification liquidhaskell-bootsort error in specification liquidhaskell-boot#multiple alias with same name error liquidhaskell-boot$multiple specs for same binder error liquidhaskell-boot1multiple definitions of the same instance measure liquidhaskell-boot(multiple definitions of the same measure liquidhaskell-boot duplicate fields in same datacon liquidhaskell-boot+name resolves to multiple possible GHC vars liquidhaskell-bootbad data type specification (?) liquidhaskell-boot*refined datacon mismatches haskell datacon liquidhaskell-boot9constructors in refinement do not match original datatype liquidhaskell-bootInvariant sort error liquidhaskell-bootUsing sort error liquidhaskell-bootIncompatible using error liquidhaskell-bootMeasure sort error liquidhaskell-bootHaskell bad Measure error liquidhaskell-bootUnbound symbol in specification liquidhaskell-bootUnbound predicate being applied liquidhaskell-boot#GHC error: parsing or type checking liquidhaskell-bootName resolution error liquidhaskell-boot7Mismatch in expected/actual args of abstract refinement liquidhaskell-boot%Cyclic Refined Type Alias Definitions liquidhaskell-boot5Illegal RTAlias application (from BSort, eg. in PVar) liquidhaskell-bootTermination Error liquidhaskell-bootTermination Error liquidhaskell-bootInstance Law Error liquidhaskell-boot!Refined Class/Interfaces Conflict liquidhaskell-boot#Standalone class method refinements liquidhaskell-bootNon well sorted Qualifier liquidhaskell-boot9Previously saved error, that carries over after DiffCheck liquidhaskell-boot Sigh. Other. liquidhaskell-boothaskell type location liquidhaskell-boot%specific pair of things that mismatch liquidhaskell-bootlq type location liquidhaskell-bootDifferent kinds of Check  Obligations% ------------------------------------ liquidhaskell-boot"Obligation that proves termination liquidhaskell-boot!Obligation that proves invariants liquidhaskell-boot,Obligation that proves subtyping constraints liquidhaskell-bootContext information for Error Messages ------------------------------------ liquidhaskell-boot'Construct and show an Error, then crash liquidhaskell-boot'Construct and show an Error, then crash liquidhaskell-boot'Construct and show an Error, then crash liquidhaskell-bootConstruct and show an Error with an optional SrcSpan, then crash This function should be used to mark unimplemented functionality liquidhaskell-bootConstruct and show an Error with an optional SrcSpan, then crash This function should be used to mark impossible-to-reach codepaths liquidhaskell-boot.Convert a GHC error into a list of our errors.   Safe-Inferred%&,liquidhaskell-bootLike the original $, but internally converts the input Doc2 (from the "pretty" library) into GHC's internal SDoc.   Safe-Inferred"%&()*,0 liquidhaskell-bootManipulating Source Spans ------------------------------------------------- liquidhaskell-bootEncoding and Decoding Location -------------------------------------------- liquidhaskell-bootGeneric Helpers for Accessing GHC Innards --------------------------------- liquidhaskell-bootPretty Printers ----------------------------------------------------------- liquidhaskell-bootPredicates on CoreExpr and DataCons --------------------------------------- liquidhaskell-bootSymbol Conversions -------------------------------------------------------- liquidhaskell-bootManipulating Symbols ------------------------------------------------------ liquidhaskell-bootGHC Compatibility Layer --------------------------------------------------- liquidhaskell-boot"The following functions test if a  or CoreVar can be embedded in logic. With type-class support, we can no longer erase such expressions arbitrarily. liquidhaskell-boot"The following functions test if a  or CoreVar* are just types in disguise, e.g. have  (in the GHC sense of the word), and so shouldn't appear in refinements. liquidhaskell-boot'defaultDataCons t ds' returns the list of '(dc, types)' pairs, corresponding to the _missing_ cases, i.e. _other_ than those in ds', that are being handled by DEFAULT. liquidhaskell-boot Elaboration liquidhaskell-bootSuperclass coherence liquidhaskell-bootRun a computation in GHC's typechecking monad with wired in values locally bound in the typechecking environment. liquidhaskell-boot 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. liquidhaskell-bootSymbol Instances   Safe-Inferred%&, liquidhaskell-boot3Separating literate files into code/comment chunks.liquidhaskell-boot type stringliquidhaskell-boot error stringliquidhaskell-bootline number, total width of lines i.e. max (length (show lineNum)) liquidhaskell-bootLoc -> (Var, Type) liquidhaskell-bootList of error intervals liquidhaskell-bootType information with spans liquidhaskell-bootFormats Haskell source code using HTML and mouse-over annotations liquidhaskell-bootFormats Haskell source code using HTML and mouse-over annotationsliquidhaskell-boot4annotTokenise is absurdly slow: O(#tokens x #errors)liquidhaskell-bootThe code for classify is largely stolen from Language.Preprocessor.Unlit.liquidhaskell-boot;Join up chunks of code/comment that are next to each other. liquidhaskell-bootWhether to include anchors.liquidhaskell-boot1Whether input document is literate haskell or notliquidhaskell-boot3Haskell source code, Annotations as comments at endliquidhaskell-bootColoured Haskell source code. liquidhaskell-bootWhether to include anchors.liquidhaskell-boot!Function to refine comment tokensliquidhaskell-boot1Whether input document is literate haskell or notliquidhaskell-bootHaskell Source, Annotationsliquidhaskell-bootColoured Haskell source code.   Safe-Inferred %&, liquidhaskell-boot BindVisitor; allows for generic, context sensitive traversals over the  CoreBinds  Safe-Inferred%&,7<J   Safe-Inferred"%&,/79:;<ʹ liquidhaskell-bootKVar Profile -------------------------------------------------------------- liquidhaskell-bootRecursive binder letrec x = ... liquidhaskell-bootNon recursive binder  let x = ... liquidhaskell-bootInt is the number of cases liquidhaskell-bootProjecting out field of liquidhaskell-bootOutput -------------------------------------------------------------------- liquidhaskell-bootAnnotations ------------------------------------------------------- liquidhaskell-bootVar Hole Info -----------------------------------------------------liquidhaskell-bootdue to `reflect foo`liquidhaskell-boot;due to `measure foo` with old-style (non-haskell) equationsliquidhaskell-boot5due to `measure foo` with new-style haskell equationsliquidhaskell-boot!due to `class measure` definitionliquidhaskell-boot1due to `measure foo` without equations c.f. testsposT1223.hsliquidhaskell-boot;due to selector-fields e.g. `data Foo = Foo { fld :: Int }`liquidhaskell-boot;due to checkers e.g. `is-F` for `data Foo = F ... | G ...`liquidhaskell-bootMeasuresliquidhaskell-boot Measure Refinement: {v | v = e }liquidhaskell-bootMeasure Refinement: {v | (? v)  = p }liquidhaskell-bootMeasure Refinement: {v | p}liquidhaskell-bootRefinement Type Aliases ---------------------------------------------------liquidhaskell-bootModule Names --------------------------------------------------------------liquidhaskell-bootSource Information Associated With Constraints ----------------------------liquidhaskell-bootError Data Type -----------------------------------------------------------liquidhaskell-bootDiagnostic info -----------------------------------------------------------liquidhaskell-bootthe "global" names for moduleliquidhaskell-bootthe "local" names for sub-exprsliquidhaskell-bootThe 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 constraintsliquidhaskell-bootConstructor and Destructors for RTypes ------------------------------------liquidhaskell-bootRefinement Type Aliasesliquidhaskell-bootname of the aliasliquidhaskell-boottype parametersliquidhaskell-bootvalue parametersliquidhaskell-bootwhat the alias expands to , rtMod :: !ModName -- ^ module where alias was definedliquidhaskell-boot What kind of  is it?liquidhaskell-bootUser defined data-definitions (should have refined fields)liquidhaskell-bootAutomatically lifted data-definitions (do not have refined fields)liquidhaskell-bootTermination expressionsliquidhaskell-boot x -> F.EVar xliquidhaskell-bootx -> f xliquidhaskell-bootData Constructorliquidhaskell-boot DataCon nameliquidhaskell-bootType parametersliquidhaskell-boot5The GHC ThetaType corresponding to DataCon.dataConSigliquidhaskell-bootfield-name and field-Type pairsliquidhaskell-boot!Possible output (if in GADT form)liquidhaskell-bootThe name of the  corresponding to a liquidhaskell-bootfor isVanillyAlgTyCon we can directly use the  nameliquidhaskell-bootfor  TyCon we save some  nameliquidhaskell-bootData type refinementsliquidhaskell-bootType Constructor Nameliquidhaskell-bootTyvar Parametersliquidhaskell-bootPVar Parametersliquidhaskell-bootData Constructors (Nothing is reserved for non-GADT style empty data declarations)liquidhaskell-bootSource Positionliquidhaskell-bootDefault termination measureliquidhaskell-bootType of Ind-Propliquidhaskell-bootUser-defined or Auto-liftedliquidhaskell-bootValues Related to Specifications ------------------------------------liquidhaskell-bootRefined Instances ---------------------------------------------------------liquidhaskell-bootA 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.liquidhaskell-bootRTProp is a convenient alias for Ref that will save a bunch of typing. In general, perhaps we need not expose Ref directly at all.liquidhaskell-bootRef 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 UReft applies directly to any type and has semantics _independent of_ the data-type.liquidhaskell-bootarguments. e.g. h in the above exampleliquidhaskell-boot$Abstract refinement associated with . e.g. v > h in the above exampleliquidhaskell-boot "forall x y  z:: Nat, w :: Int7 . TYPE" ^^^^^^^^^^^^^^^^^^^ (rt_pvbind)liquidhaskell-bootFor example, in [a] {h- v > h}>, we apply (via  ) * the ( denoted by `{h -> v > h}` to * the  denoted by `[]`.liquidhaskell-boot5For expression arguments to type aliases see testspos vector2.hsliquidhaskell-bootlet LH match against the Haskell type and add k-vars, e.g. `x:_` see testsposHoles.hsliquidhaskell-bootUnified Representation of Refinement Types --------------------------------liquidhaskell-bootCo- 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]liquidhaskell-boot variance info for type variablesliquidhaskell-boot%variance info for predicate variablesliquidhaskell-boot>logical UNARY function that computes the size of the structureliquidhaskell-bootGHC Type Constructorliquidhaskell-bootPredicate Parametersliquidhaskell-boot TyConInfoliquidhaskell-boot$TyCon name with location informationliquidhaskell-boot!Is this a class type constructor?liquidhaskell-bootIs Promoted Data Con?liquidhaskell-bootPredicates ----------------------------------------------------------------liquidhaskell-boot?Abstract Predicate Variables ----------------------------------liquidhaskell-boot*Which Top-Level Binders Should be Verifiedliquidhaskell-bootCorresponding GHC DataConliquidhaskell-bootType parametersliquidhaskell-bootAbstract Refinement parametersliquidhaskell-boot? Class constraints (via dataConStupidTheta)liquidhaskell-bootValue parametersliquidhaskell-boot Result typeliquidhaskell-bootWas this specified in GADT style (if so, DONT use function names as fields)liquidhaskell-boot Which module was this defined inliquidhaskell-boot)Map from symbols to equations they defineliquidhaskell-bootMap from (lifted) Vars to :; see: NOTE:LIFTED-VAR-SYMBOLS and NOTE:REFLECT-IMPORTsliquidhaskell-bootPrinter ----------------------------------------------------------------liquidhaskell-bootprint abstract-predicatesliquidhaskell-boot&print the unique suffix for each tyvarliquidhaskell-boot&print the tycons without qualificationliquidhaskell-bootgross with full infoliquidhaskell-boot#Information about Type Constructorsliquidhaskell-bootMap from GHC TyCon to RTyConliquidhaskell-boot'Map from GHC Family-Instances to RTyConliquidhaskell-bootArity of each Family-Tyconliquidhaskell-boot(Information about scope Binders Scope inliquidhaskell-boot  NOTE:ppEnvFor some mysterious reason,  must equal & or various tests fail e.g. testsclasses3pos/TypeEquality0{0,1}.hs Yikes. Find out why!liquidhaskell-bootAccessors for RTyConliquidhaskell-bootVisitors ------------------------------------------------------------------liquidhaskell-bootPrinting Warnings ---------------------------------------------------------liquidhaskell-bootF.PPrint -----------------------------------------------------------------liquidhaskell-bootTyConable Instances -------------------------------------------------------liquidhaskell-boot NOTE:DataCon-Data for each  we also store the type of the constructed data. This is *the same as* tyRes 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 tyRes corresponding to 'Thing Int' (resp. 'Thing Bool'), but in both cases, the tyData should be 'Thing a'.liquidhaskell-bootFor debugging.liquidhaskell-bootResolved versionliquidhaskell-bootBare parsed version                   Safe-Inferred"%&,/fliquidhaskell-bootUsed in filterReportErrorsWith'liquidhaskell-boot Report the msgs to the monad (usually IO)liquidhaskell-bootReport unmatched filters to the monadliquidhaskell-bootContinuation for when there are unmatched filters or unmatched errorsliquidhaskell-boot>Continuation for when there are no unmatched errors or filtersliquidhaskell-bootYields the filters that map a given error. Must only yield filters in the filters field.liquidhaskell-boot-List of filters which could have been matchedliquidhaskell-boots match errors. They are used to ignore classes of errors they match.  matches all errors. > matches any error whose "representation" contains the given <. A "representation" is pretty-printed String of the error.liquidhaskell-bootFrom GHC: TypeRepliquidhaskell-bootPretty-printing errors ----------------------------------------------------Similar in spirit to  reportErrors from the GHC API, but it uses our pretty-printer and shim functions under the hood. Also filters the errors according to the given  list.-filterReportErrors failure continue filters k will call failure/ if there are unexpected errors, or will call continue otherwise.>= x -> e2liquidhaskell-bootxliquidhaskell-bootmliquidhaskell-boot$dTliquidhaskell-booteliquidhaskell-boottliquidhaskell-boot"return"liquidhaskell-bootxeliquidhaskell-bootCliquidhaskell-boot  x1,...,xnliquidhaskell-booti :: NatLT {len patBinds}liquidhaskell-bootLift expressions into High-level patterns ---------------------------------liquidhaskell-bootLower patterns back into expressions -------------------------------------- Safe-Inferred%&,+liquidhaskell-bootPositivity Checker ------------------------------------------------------- Safe-Inferred"%&()*,/liquidhaskell-bootEmbedding RefTypes --------------------------------------------------------liquidhaskell-boot)Various functions for converting vanilla  to Specliquidhaskell-bootHelper Functions (RJ: Helping to do what?) --------------------------------liquidhaskell-boot NOTE:FamInstPredVars.related to [NOTE:FamInstEmbeds] See testsdatacon1pos/T1446.hs The function txRefSort convertsInt p ===> {v:Int | p v} which is fine, but also convertsField q' Blob a ===> {v:Field Blob a | q v}3which is NOT ok, because q expects a different arg.The above happens because, thanks to instance-family stuff, LH doesn't realize that q is actually an ARG of Field Blob Note that Field itself has no args, but Field Blob does.../That is, it is not enough to store the refined  info, solely in the - as with family instances, you need BOTH the * and the args to determine the extra info. We do so in , and by crucially extendingRefType.appRTyCon! whose job is to use the Refined TyCon that is, the RTyCon generated from the TyConP to strengthen individual occurrences of the TyCon applied to various arguments.liquidhaskell-bootfamInstTyConMb rc args uses the RTyCon AND args( to see if this is a family instance RTyCon, and if so, returns it. see [NOTE:FamInstPredVars] eg: 'famInstTyConMb tyi Field [Blob, a]' should give 'Just R:FieldBlob'liquidhaskell-boot famInstArgs c destructs a family-instance TyCon into its components, e.g. e.g. 'famInstArgs R:FieldBlob' is (Field, [Blob])liquidhaskell-bootplainTyConPVars uses the TyCon to return the "refined" RTyCon and RPVars from the refined 'data' definition for the TyCon-, e.g. will use 'List Int' to return 'List p Int' (if List has an abs-ref).liquidhaskell-bootmkRApp! is the refined variant of GHC's  mkTyConApp which ensures that that applications of the "function" type constructor are normalized to the special case FunTy _ representation. The extra _rep1, and _rep2 parameters come from the "levity polymorphism" changes in GHC 8.6 (?) See [NOTE:Levity-Polymorphism]liquidhaskell-boot NOTE:Levity-PolymorphismThanks to Joachim Brietner and Simon Peyton-Jones! With GHC's "levity polymorphism feature", see more here https://stackoverflow.com/questions/35318562/what-is-levity-polymorphism/The function type constructor actually has type(->) :: forall (r1::RuntimeRep) (r2::RuntimeRep). TYPE r1 -> TYPE r2 -> TYPE LiftedRep)so we have to be careful to follow GHC's  mkTyConApp https://hackage.haskell.org/package/ghc-8.6.4/docs/src/Type.html#mkTyConApp%which normalizes applications of the FunTyCon constructor to use the special case `FunTy _` representation thus, so that we are not stuck with incompatible representations e.g.thing -> thing ... (using RFun)and(-> 'GHC.Types.LiftedRep 'GHC.Types.LiftedRep thing thing) ... (using RApp)#More details from Joachim Brietner:Now you might think that the function arrow has the following kind: `(->) :: * -> * -> *`. But that is not the full truth: You can have functions that accept or return things with different representations than just the usual lifted one.So the function arrow actually has kind `(->) :: forall r1 r2. TYPE r1 -> TYPE r2 -> *`. And in `(-> 'GHC.Types.LiftedRep 'GHC.Types.LiftedRep thing thing)` you see this spelled out explicitly. But it really is just `(thing -> thing)`, just printed with more low-level detail.Also see@  https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#levity-polymorphism @ and other links from  +https://stackoverflow.com/a/35320729/946226 (edited)liquidhaskell-bootType Substitutions --------------------------------------------------------liquidhaskell-boot  NOTE:Hole-LitWe use  to convert RType to GHC.Type to expand any GHC related type-aliases, e.g. in Bare.Resolve.expandRTypeSynonyms. If the RType has a RHole then what to do? We, encode  as `LitTy LH_HOLE` -- which is a bit of a *hack*. The only saving grace is it is used *temporarily* and then swiftly turned back into an  via 0 (after GHC has done its business of expansion).Of course, we hope this doesn't break any GHC invariants! See issue #1476 and #1477!The other option is to *not* use  on things that have holes in them, but this seems worse, e.g. because you may define a plain GHC alias like:type ToNat a = a -> Nat/and then you might write refinement types like:{- foo :: ToNat {v:_ | 0 <= v} -}$and we'd want to expand the above to{- foo :: {v:_ | 0  =v} - Nat -}2and then resolve the hole using the (GHC) type of foo.Annotations and Solutions -------------------------------------------------liquidhaskell-bootFrom Old Fixpoint ---------------------------------------------------------liquidhaskell-bootBinders generated by class predicates, typically for constraining tyvars (e.g. FNum)liquidhaskell-bootTermination Predicates ----------------------------------------------------liquidhaskell-boot NOTE=THIS IS WHERE THE TERMINATION METRIC REFINEMENTS ARE CREATED.liquidhaskell-boottyVarsPosition t returns the type variables appearing | (in positive positions, in negative positions, in undetermined positions) | undetermined positions are due to type constructors and type applicationliquidhaskell-bootPrinting Refinement Types -------------------------------------------------liquidhaskell-bootAuxiliary Stuff Used Elsewhere ---------------------------------------------liquidhaskell-bootConverting to Fixpoint ----------------------------------------------------liquidhaskell-bootWrappers for GHC Type Elements --------------------------------------------liquidhaskell-bootReftable Instances -------------------------------------------------------liquidhaskell-bootSubable Instances ----------------------------------------------------- Safe-Inferred"%&,~liquidhaskell-bootConverting Results To Answers -------------------------------------liquidhaskell-bootThis 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 crashliquidhaskell-bootPretty 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. Safe-Inferred "%&,tliquidhaskell-bootdataConPSpecType converts a DataConP, LH's internal representation for a (refined) data constructor into a SpecType for that constructor. TODO: duplicated with Liquid.Measure.makeDataConTypeliquidhaskell-bootInterface: Replace Predicate With Uninterpreted Function Symbol -------liquidhaskell-boot 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]`liquidhaskell-boot Instantiate  with 0 ----------------------------------------------- replacePreds is the main function used to substitute an (abstract) predicate with a concrete Ref, that is either an  or RHProp4 type. The substitution is invoked to obtain the  resulting at predicate application sites in VW. The range of the  substitutions are fresh or true RefType0. That is, there are no further _quantified_  in the target.liquidhaskell-boot Requires:  not $ null s substRCon :: String -> (RPVar, SpecType) -> SpecType -> SpecTypeliquidhaskell-bootInterface: Modified CoreSyn.exprType due to predApp -------------------$$ Safe-Inferred"%&, Gliquidhaskell-boot6Horrible hack to support hardwired symbols like , , ,  and other LH generated symbols that *do not* correspond to GHC Vars and *should not* be resolved to GHC Vars.liquidhaskell-bootLH Primitive TyCons -------------------------------------------------------liquidhaskell-bootLH Primitive TyCons ----------------------------------------------liquidhaskell-bootPredicate Types for WiredIns ----------------------------------------------   Safe-Inferred%&,  Safe-Inferred"%&,/    Safe-Inferred%&, Xliquidhaskell-bootmakeDicTypeName! DOES NOT use show/symbol in the RVar case as those functions add the unique-suffix which then breaks the class resolution.liquidhaskell-bootDictionary Environment ----------------------------------------------------  ! Safe-Inferred "%&,7< liquidhaskell-bootThe name of the boundliquidhaskell-boot(Type variables that appear in the boundsliquidhaskell-boot'These are abstract refinements, for nowliquidhaskell-bootThese are value variablesliquidhaskell-bootThe body of the bound  " Safe-Inferred %&,6<>=ڕliquidhaskell-bootImported Environmentliquidhaskell-boot*Lifted specification for the target moduleliquidhaskell-bootSource file for moduleliquidhaskell-bootName for moduleliquidhaskell-boot Source Codeliquidhaskell-bootAll used Type constructorsliquidhaskell-bootClass instances?liquidhaskell-boot&Binders created by GHC eg dictionariesliquidhaskell-boot4Binders that are _read_ in module (but not defined?)liquidhaskell-boot0(Top-level) binders that are _defined_ in moduleliquidhaskell-boot!Binders that are _read_ in moduleliquidhaskell-boot's exported by the module being verifiedliquidhaskell-bootFamily instance TyConsliquidhaskell-bootFamily instance DataConsliquidhaskell-boot.Primitive GHC TyCons (from TysPrim.primTyCons)liquidhaskell-bootMap of qualified importsliquidhaskell-bootSet of _all_ imported modulesliquidhaskell-bootAll the TyThings known to GHCliquidhaskell-bootThe target/ dependencies that concur to the creation of a  and a .liquidhaskell-bootA  is derived from an input  and a set of its dependencies. The general motivations for lifting a spec are (a) name resolution, (b) the fact that some info is only relevant for checking the body of functions but does not need to be exported, e.g. termination measures, or the fact that a type signature was assumed. A  is what we serialise on disk and what the clients should will be using.What we do not have compared to a : The +, as it's not necessary/visible to clients;The 8, as they are probably not reachable for clients anyway;The (, they are now just "normal" signatures;The 3, we don't do termination checking in lifted specs;The 4, the reflection has already happened at this point;The  , we have already* turned these into measures at this point;The  , ditto as ;The  , ditto as ;The  , ditto as ;The =, we can't make any use of this information for lifted specs;The 3, we don't do termination checking in lifted specs;Apart from less fields, a  )replaces all instances of lists with sets, to enforce duplicate detection and removal on what we serialise on disk.liquidhaskell-boot User-defined properties for ADTsliquidhaskell-bootImported variables typesliquidhaskell-bootExported variables typesliquidhaskell-boot9Assumed (unchecked) types; including reflected signaturesliquidhaskell-bootImported functions and typesliquidhaskell-boot9Data type invariants; the Maybe is the generating measureliquidhaskell-boot"Data type invariants to be checkedliquidhaskell-bootLoaded spec module namesliquidhaskell-bootPredicated data definitionsliquidhaskell-bootPredicated new type definitionsliquidhaskell-bootRefType aliasesliquidhaskell-bootExpression aliasesliquidhaskell-bootGHC-Tycon-to-fixpoint Tycon mapliquidhaskell-bootQualifiers in source/spec filesliquidhaskell-bootVariables that should be checked in the environment they are usedliquidhaskell-bootAutomatically instantiate axioms in these Functions with maybe specified fuelliquidhaskell-boot4Type Constructors that get automatically sizing infoliquidhaskell-boot!Measures attached to a type-classliquidhaskell-boot'Mappings from (measure,type) -> measureliquidhaskell-bootRefined Type-Classesliquidhaskell-bootRefined Type-Classe Lawsliquidhaskell-boot? Where do these come from ?!liquidhaskell-bootTemporary (?) hack to deal with dictionaries in specifications see testspos NatClass.hsliquidhaskell-boot'Equalities used for Proof-By-Evaluationliquidhaskell-boot A generic < type, polymorphic over the inner choice of type and binder.liquidhaskell-boot User-defined properties for ADTsliquidhaskell-bootImported variables typesliquidhaskell-bootExported variables typesliquidhaskell-boot9Assumed (unchecked) types; including reflected signaturesliquidhaskell-bootImported functions and typesliquidhaskell-bootLocal type signaturesliquidhaskell-bootReflected type signaturesliquidhaskell-boot9Data type invariants; the Maybe is the generating measureliquidhaskell-boot"Data type invariants to be checkedliquidhaskell-bootLoaded spec module namesliquidhaskell-bootPredicated data definitionsliquidhaskell-bootPredicated new type definitionsliquidhaskell-bootIncluded qualifier filesliquidhaskell-bootRefType aliasesliquidhaskell-bootExpression aliasesliquidhaskell-bootGHC-Tycon-to-fixpoint Tycon mapliquidhaskell-bootQualifiers in source/spec filesliquidhaskell-bootVariables that should be checked in the environment they are usedliquidhaskell-boot+Ignore Termination Check in these Functionsliquidhaskell-boot"Theorems turned into rewrite rulesliquidhaskell-bootDefinitions using rewrite rulesliquidhaskell-boot These Functions should be unsafeliquidhaskell-bootBinders to reflectliquidhaskell-bootAutomatically instantiate axioms in these Functions with maybe specified fuelliquidhaskell-boot7Binders to turn into measures using haskell definitionsliquidhaskell-boot5Binders to turn into bounds using haskell definitionsliquidhaskell-boot;Binders to turn into logic inline using haskell definitionsliquidhaskell-bootBinders to ignore during checking; that is DON't check the corebind.liquidhaskell-boot4Type Constructors that get automatically sizing infoliquidhaskell-boot4Command-line configurations passed in through sourceliquidhaskell-boot!Measures attached to a type-classliquidhaskell-boot'Mappings from (measure,type) -> measureliquidhaskell-bootRefined Type-Classesliquidhaskell-bootRefined Type-Classe Lawsliquidhaskell-bootRelational typesliquidhaskell-bootAssumed relational typesliquidhaskell-boot$Terminating Conditions for functionsliquidhaskell-boot"TODO ? Where do these come from ?!liquidhaskell-boot)Size measure to enforce fancy terminationliquidhaskell-bootTemporary (?) hack to deal with dictionaries in specifications see testspos NatClass.hsliquidhaskell-boot'Equalities used for Proof-By-Evaluationliquidhaskell-bootA  is the spec we derive by parsing the Liquid Haskell annotations of a single file. As such, it contains things which are relevant for validation and lifting; it contains things like the pragmas the user defined, the termination condition (if termination-checking is enabled) and so on and so forth.  Crucially, as a  is still subject to "preflight checks", it may contain duplicates (e.g. duplicate measures, duplicate type declarations etc.) and therefore most of the fields for a  are lists, so that we can report these errors to the end user: it would be an error to silently ignore the duplication and leave the duplicate resolution to whichever 1 instance is implemented for the relevant field.Also, a  has not yet been subject to name resolution, so it may refer to undefined or out-of-scope entities.liquidhaskell-bootBinders to USE PLEliquidhaskell-bootLifted definitionsliquidhaskell-boot(Axioms from imported reflected functionsliquidhaskell-boot"Axioms from my reflected functionsliquidhaskell-bootBinders for reflected functionsliquidhaskell-boot*Binders to CHECK by structural terminationliquidhaskell-boot-Binders to IGNORE during termination checkingliquidhaskell-boot-Binders to IGNORE during termination checkingliquidhaskell-bootBinders to fail type checkingliquidhaskell-boot;Binders to CHECK using REFINEMENT-TYPES/termination metricsliquidhaskell-bootList of Symbol free in spec and corresponding GHC var, eg. (Cons, Cons#7uz) from testsposex1.hsliquidhaskell-boot,Predicated Data-Constructors, e.g. see testsposMap.hsliquidhaskell-boot,Predicated Type-Constructors, e.g. see testsposMap.hsliquidhaskell-bootEmbedding GHC Tycons into fixpoint sorts e.g. "embed Set as Set_set" from includeDataSet.specliquidhaskell-bootADTs extracted from Haskell 'data' definitionsliquidhaskell-bootData Constructor Measure Sigsliquidhaskell-boot$Measure Types eg. len :: [a] -> Intliquidhaskell-bootData type invariants from measure definitions, e.g forall a. {v: [a] | len(v) >= 0}liquidhaskell-bootData type invariant aliasesliquidhaskell-bootMeasure definitionsliquidhaskell-bootAsserted Reftypesliquidhaskell-bootAssumed Reftypesliquidhaskell-bootReflected Reftypesliquidhaskell-bootAuto generated Signaturesliquidhaskell-boot Mapping of  'newtype', type constructors with their refined types.liquidhaskell-bootRefined Classes from Instancesliquidhaskell-bootRefined Classes from Classesliquidhaskell-boot5Lexicographically ordered expressions for terminationliquidhaskell-bootQualifiers in SourceSpec files e.g testspos/qualTest.hsliquidhaskell-boot2Refinement type aliases (only used for qualifiers)liquidhaskell-bootThe collection of GHC  s that a  needs to verify (or skip).liquidhaskell-boot5Top-level Binders To Verify (empty means ALL binders)liquidhaskell-boot9Top-level Binders To NOT Verify (empty means ALL binders)liquidhaskell-bootVariables that should be checked "lazily" in the environment they are usedliquidhaskell-bootRefined Class methodsliquidhaskell-bootA  is what we  actually check via LiquidHaskell. It is created as part of  mkTargetSpec alongside the '. It shares a similar structure with a , but manipulates and transforms the data in preparation to the checking process.liquidhaskell-bootImported Environmentliquidhaskell-boot is a map of qualified imports.liquidhaskell-boot+All the modules that are imported qualifiedliquidhaskell-boot*Map from qualification to full module nameliquidhaskell-bootThe  type is a collection of all the things we know about a module being currently checked. It include things like the name of the module, the list of s, the )s declared in this module (that includes s for classes), typeclass instances and so and so forth. It might be consider a sort of 9 embellished with LH-specific information (for example,  are populated with datacons from the module plus the let vars derived from the A-normalisation).liquidhaskell-bootSource file for moduleliquidhaskell-bootName for moduleliquidhaskell-boot Source Codeliquidhaskell-bootAll used Type constructorsliquidhaskell-bootClass instances?liquidhaskell-boot&Binders created by GHC eg dictionariesliquidhaskell-boot4Binders that are _read_ in module (but not defined?)liquidhaskell-boot0(Top-level) binders that are _defined_ in moduleliquidhaskell-boot!Binders that are _read_ in moduleliquidhaskell-boot's exported by the module being verifiedliquidhaskell-bootFamily instance TyConsliquidhaskell-bootFamily instance DataConsliquidhaskell-boot.Primitive GHC TyCons (from TysPrim.primTyCons)liquidhaskell-bootMap of qualified importsliquidhaskell-bootSet of _all_ imported modulesliquidhaskell-bootAll the TyThings known to GHCliquidhaskell-bootThe  of the module being checked.liquidhaskell-bootThe  of the module being checked.liquidhaskell-bootDrop the given   from the dependencies.liquidhaskell-bootReturns  if the input  is a PLE one.liquidhaskell-bootReturns  if the input & was exported in the module the input  represents.# Safe-Inferred "%&,/A= = $ Safe-Inferred%&,Hliquidhaskell-boot4Intermediate representation for Measure information liquidhaskell-bootA TycEnv contains the information needed to process Type- and Data- Constructors liquidhaskell-bootA SigEnv0 contains the needed to process type signatures liquidhaskell-bootA  TyThingMap% is used to resolve symbols into GHC TyThing3 and, from there into Var, TyCon, DataCon, etc.liquidhaskell-boot LocalVars* is a map from names to lists of pairs of Ghc.Var/ and the lines at which they were defined. liquidhaskell-bootName resolution environment liquidhaskell-bootsee "syms" in old makeGhcSpec'liquidhaskell-bootsee "su" in old makeGhcSpec'liquidhaskell-bootqualified importsliquidhaskell-bootall imported modulesliquidhaskell-boot+lines at which local variables are defined.liquidhaskell-boot1global symbols, typically unlifted measures like len, fromJustliquidhaskell-bootall source infoliquidhaskell-boot2See [NOTE: Plug-Holes-TyVars] for a rationale for PlugTV liquidhaskell-boot*Use tyvars from GHC specification (in the v) liquidhaskell-boot$Use tyvars from Liquid specificationliquidhaskell-bootGeneralize ty-vars liquidhaskell-boot1Do NOT generalize ty-vars (e.g. for type-aliases)liquidhaskell-boot Converting Var to Sortliquidhaskell-bootHandling failed resolution 44% Safe-Inferred"%&)*,M}liquidhaskell-bootA  RewriteRule. is a function that maps a CoreExpr to anotherliquidhaskell-bootTop-level rewriter --------------------------------------------------------liquidhaskell-bootRewriting Pattern-Match-Tuples --------------------------------------------liquidhaskell-boot`hasTuple ys e` CHECKS if e- contains a tuple that "looks like" (y1...yn)liquidhaskell-boot`replaceTuple ys e e'` REPLACES tuples that "looks like" (y1...yn) with e'liquidhaskell-bootThe 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: https://github.com/ucsd-progsys/liquidhaskell/pull/752#issuecomment-228946210liquidhaskell-boot8`substTuple xs ys e'` returns e' [y1 := x1,...,yn := xn]liquidhaskell-boot`isVarTup xs e` returns `Just ys` if e == (y1, ... , yn) and xi ~ yi& Safe-Inferred %&,M' Safe-Inferred "%&(,Sliquidhaskell-boot A "stable" . When transforming Core into ANF notation, we need to keep around a mapping between a particular  (typically an  ) and an +. Previously this was accomplished using a VarEnv', a GHC data structure where keys are s. Working with  in GHC is not always robust enough when it comes to LH. First of all, the way s are constructed might change between GHC versions, and they are not stable between rebuilds/compilations. In the case of this module, in GHC 9 the test BST.hs was failing because two different =s, namely "wild_X2" and "dOrd_X2" were being given the same  by GHC (i.e. "X2") which was causing the relevant entry to be overwritten in the  causing a unification error.A  is simply a wrapper over an  with a different  instance that really guarantee uniqueness (for our purposes, anyway).liquidhaskell-bootA mapping between a  (see below) and an .liquidhaskell-bootA-Normalize a module ------------------------------------------------------liquidhaskell-bootA-Normalize a CoreBind3 --------------------------------------------------liquidhaskell-boot*eta-expand CoreBinds with quantified typesliquidhaskell-bootANF Environments ----------------------------------------------------------( Safe-Inferred%&,S  ) Safe-Inferred"%&(,9WGliquidhaskell-bootSpecType with Holes. It provides us a context to construct the ghc queries. I don't think we can reuse RHole since it is not intended for this use caseliquidhaskell-bootBase functor of RTypeliquidhaskell-boot "forall x y  z:: Nat, w :: Int8 . TYPE" ^^^^^^^^^^^^^^^^^^^ (rtf_pvbind)liquidhaskell-bootFor example, in [a] {h- v > h}>, we apply (via  ) * the ( denoted by `{h -> v > h}` to * the  denoted by `[]`.liquidhaskell-boot(returns (lambda binders, forall binders)liquidhaskell-bootEmbed fixpoint expressions into parsed haskell expressions. It allows us to bypass the GHC parser and use arbitrary symbols for identifiers (compared to using the string API)* Safe-Inferred"%&,/eliquidhaskell-bootUsing the environmentliquidhaskell-bootCreating an environmentliquidhaskell-bootokUnqualified mod mxs takes mxs which is a list of modulenames-var pairs all of which have the same unqualified symbol representation. The function returns Just v if 1. that list is a singleton i.e. there is a UNIQUE unqualified version, OR 2. there is a version whose module equals me.liquidhaskell-bootWe prioritize the Ghc.Var in srcVars because  _giDefVars and  gsTyThings have _different_ values for the same binder, with different types where the type params are alpha-renamed. However, for absref, we need _the same_ type parameters as used by GHC as those are used inside the lambdas and other bindings in the code. See also [NOTE: Plug-Holes-TyVars] and tests-absref-pos-Papp00.hsliquidhaskell-bootQualify various namesliquidhaskell-bootlookupLocalVar takes as input the list of "global" (top-level) vars that also match the name lx5; we then pick the "closest" definition. See testsnames&LocalSpec.hs for a motivating example.liquidhaskell-bootChecking existence of namesliquidhaskell-boot lookupTyThing* is the central place where we lookup the Env to find any  Ghc.TyThing that match that name. The code is a bit hairy as we have various heuristics to approximiate how GHC resolves names. e.g. see tests-names-pos-*.hs, esp. vector04.hs where we need the name Vector to resolve to XY and not ZY...liquidhaskell-bootReturns  if the Symbol given as a first argument represents a parent module for the second.L.symbolic "Data.Text" `isParentModuleOf` L.symbolic "Data.Text.Internal"True Invariants: The empty Symbol is always considered the module prefix of the second, in compliance with  isPrefixOfSym (AND: why?)If the parent "hierarchy" is smaller than the children's one, this is clearly not a parent module.liquidhaskell-bootmatchImp lets us prioritize TyThing defined in directly imported modules over those defined elsewhere. Specifically, in decreasing order of priority we have TyThings that we: * DIRECTLY imported WITHOUT qualification * TRANSITIVELY imported (e.g. were re-exported by SOME imported module) * QUALIFIED imported (so qualify the symbol to get this result!)liquidhaskell-boot"`unQualifySymbol name sym` splits sym$ into a pair `(mod, rest)` where ) is the name of the module, derived from sym if qualified.liquidhaskell-boot maybeResolve wraps the plain resolve to return Nothing. if the name being searched for is unknown.liquidhaskell-boot ofBareType and  ofBareTypeE should be the _only_ SpecType constructorsliquidhaskell-boot&Is this the SAME as addTyConInfo? No.  (1) adds the _real_ sorts to RProp, (2) gathers _extra_ RProp at turns them into refinements, e.g. testsposmulti-pred-app-00.hsliquidhaskell-bootresolveLocalBinds resolves that the "free" variables that appear in the type-sigs for non-toplevel binders (that correspond to other locally bound) source variables that are visible at that at non-top-level scope. e.g. tests-names-pos-local02.hs+ Safe-Inferred"%&,y]liquidhaskell-boot# qualfies the field names for each 1 to ensure things work properly when exported.liquidhaskell-bootCreate Fixpoint DataDecl from LH DataDecls --------------------------------A  is associated with a (TyCon and) , and defines the sort of relation that is established by terms of the given TyCon. A  say, pd is associated with a dd of type  when pd is the  version of the  given by `tycPropTy dd`.liquidhaskell-boot DataConMap stores the names of those ctor-fields that have been declared as SMT ADTs so we don't make up new names for them.liquidhaskell-boot'makeDataConChecker d' creates the measure for `is$d` which tests whether a given value was created by d. e.g. is$Nil or is$Cons.liquidhaskell-boot'makeDataConSelector d' creates the selector `select$d$i` which projects the i-th field of a constructed value. e.g. `select$Cons$1` and `select$Cons$2` are respectively equivalent to  and .liquidhaskell-bootmakeClassEmbeds: sort-embeddings for numeric, and family-instance tyconsliquidhaskell-bootmakeFamInstEmbeds : embed family instance tycons, see [NOTE:FamInstEmbeds]liquidhaskell-boot NOTE:FamInstEmbeds,GHC represents family instances in two ways: As an applied type,As a special tycon.For example, consider `testsposExactGADT4.hs`:class 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 IntPROBLEM: 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 BlobSo that all occurrences of the (2) are treated as (1) by the sort checker.makeNumEmbeds: embed types that have numeric instances as int [Check!]liquidhaskell-boot will prune duplicate TyCon definitions, as follows:Let the "home" of a TyCon be the module where it is defined. There are three kinds of  definitions:  Bool  = fhaskell :: x:X -> {v:Bool | v  = (flogic x)} CASE2: measure flogic :: X -> Y  = f"haskell :: x:X -> {v:Y | v = (f logic x)}liquidhaskell-bootRefine types of measures: keep going until you find the last data con! this code is a hack! we refine the last data constructor, it got complicated to support both 1. multi parameter measures (see testsposHasElem.hs) 2. measures returning functions (fromReader :: Reader r a -> (r -> a) ) TODO: SIMPLIFY by dropping support for multi parameter measuresliquidhaskell-boot'weakenResult foo t' drops the singleton constraint `v = foo x y` that is added, e.g. for measures in /strengthenResult'. This should only be used _when_ checking the body of foo where the output, is, by definition, equal to the singleton.liquidhaskell-boot%'isMeasureArg x' returns 'Just t' if x# is a valid argument for a measure.liquidhaskell-boot altsDefault% reorders the CoreAlt to ensure that  is at the end.liquidhaskell-bootTries to determine if a  maps to one of the  type constructors. We need the disjuction for GHC >= 9, where the Integer now comes from the "ghc-bignum" package, and it has different names for the constructors.  - Safe-Inferred"%&,liquidhaskell-boot returns  for unhandled lits because otherwise string-literals show up as global int-constants which blow up qualifier instantiation.[ Safe-Inferred%&,                       . Safe-Inferred "%&,liquidhaskell-boot3Intervals of line numbers that have been re-checkedliquidhaskell-boot-Map from saved-line-num ---> current-line-numliquidhaskell-boot"Variable dependencies "call-graph"liquidhaskell-bootVariable definitionsliquidhaskell-boot&line at which binder definition startsliquidhaskell-boot$line at which binder definition endsliquidhaskell-bootname of binderliquidhaskell-bootData Types ----------------------------------------------------------------+Main type of value returned for diff-check.liquidhaskell-boot checkedNames returns the names of the top-level binders that will be checkedliquidhaskell-boot returns a subset of the  [CoreBind] of the input target file which correspond to top-level binders whose code has changed and their transitive dependencies.liquidhaskell-bootAdd the specified signatures for vars-with-preserved-sigs, whose bodies have been pruned from [CoreBind] into the "assumes"liquidhaskell-bootthin 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.liquidhaskell-boot(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.liquidhaskell-bootvarBounds computes upper and lower bounds on where each top-level binder's definition can be by using ONLY the lines where the binder is defined.liquidhaskell-boot 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.liquidhaskell-bootDiff Interface ------------------------------------------------------------,`lineDiff new old` compares the contents of src with dst and returns the lines of src that are different.liquidhaskell-boot"Identifies lines that have changedliquidhaskell-bootsave" creates an .saved version of the target; file, which will be used to find what has changed the  next time target is checked.liquidhaskell-bootgetShift lm old returns Just  if the line number old shifts by  in the diff and returns Nothing otherwise.liquidhaskell-bootsetShift (lo, hi, ) lm updates the interval map lm appropriatelyliquidhaskell-bootAeson instances -----------------------------------------------------------liquidhaskell-boot Starting lineliquidhaskell-bootList of lengths of diffsliquidhaskell-bootList of changed line numbers/ Safe-Inferred"%&, liquidhaskell-bootJSON: Annotation Data Types ---------------------------------------liquidhaskell-bootoutput" creates the pretty printed outputliquidhaskell-bootannotate% actually renders the output to filesliquidhaskell-bootLike copyFile from \], but ensure that the parent  temporary directory (i.e. ".liquid") exists on disk, creating it if necessary.liquidhaskell-bootPandoc HTML Rendering (for lhs + markdown source) ------------------liquidhaskell-bootDirect HTML Rendering (for non-lhs/markdown source) ----------------liquidhaskell-boottopAndTail True is used for standalone HTML; topAndTail False for embedded HTMLliquidhaskell-bootBuilding Annotation Maps ------------------------------------------------This function converts our annotation information into that which is required by V^& to generate mouseover annotations.liquidhaskell-bootTokenizing Refinement Type Annotations in @-blocks ----------------------The token used for refinement symbols inside the highlighted types in @-blocks.liquidhaskell-bootThe top-level function for tokenizing @-block annotations. Used to tokenize comments by ACSS.liquidhaskell-bootCreating Vim Annotations ------------------------------------------liquidhaskell-bootLH Related Stuff ----------------------------------------------------------A Little Unit Test --------------------------------------------------------liquidhaskell-bootJSON Instances ----------------------------------------------------0 Safe-Inferred%&'(,| liquidhaskell-boot6The "header" like "LIQUID: SAFE", or "LIQUID: UNSAFE".liquidhaskell-bootThe list of pretty-printable messages (typically errors) together with their source locations.liquidhaskell-bootShows the LiquidHaskell banner, that includes things like the copyright, the git commit and the version.liquidhaskell-bootAttempt to canonicalize all  s in the 3 so we don't have to worry about relative paths.liquidhaskell-bootUpdating optionsliquidhaskell-bootNote that this function doesn't process list arguments properly, like  or  TODO: This is only used to parse the contents of the env var LIQUIDHASKELL_OPTS so it should be able to parse multiple arguments instead. See issue #1990.liquidhaskell-bootWrite the annotations (i.e. the files in the ".liquid" hidden folder) and report the result of the checking using a supplied function, or using an implicit JSON function, if json flag is set.liquidhaskell-boot/Writes the result of this LiquidHaskell run to stdout.liquidhaskell-bootGiven a  parameterised over a , this function returns the "header" to show to the user (i.e. "SAFE" or "UNSAFE") plus a list of s together with the  they refer to.liquidhaskell-boot Renders a  into a  and its associated .1 Safe-Inferred%&,2 Safe-Inferred%&,3 Safe-Inferred "%&,vliquidhaskell-boot3'expandVarDefs [(x1, e1), ... ,(xn, en)] returns a Subst? that contains the fully substituted definitions for each xi. For example, expandVarDefs [(x1, 'x2 + x3'), (x5, 'x1 + 1')] should return [x1 := 'x2 + x3, x5 := (x2 + x3) + 1]4 Safe-Inferred%&,5 Safe-Inferred"%&(,6 Safe-Inferred "%&,7<liquidhaskell-boot!The AST for a single parsed spec.liquidhaskell-boot definitionliquidhaskell-bootassume signature (unchecked)liquidhaskell-bootassert signature (checked)liquidhaskell-bootlocal# assertion -- TODO RJ: what is thisliquidhaskell-bootTODO RJ: what is thisliquidhaskell-boot'import' a specification moduleliquidhaskell-bootrefined 'data' declarationliquidhaskell-bootrefined  'newtype' declarationliquidhaskell-bootrelational signatureliquidhaskell-bootassume relational signatureliquidhaskell-bootrefined 'class' definitionliquidhaskell-boot'class laws' definitionliquidhaskell-bootrefined  'instance' definitionliquidhaskell-bootinclude a path -- TODO: deprecateliquidhaskell-boot invariant specificationliquidhaskell-bootusing- declaration (for local invariants on a type)liquidhaskell-boot'type' alias declarationliquidhaskell-boot predicate alias declarationliquidhaskell-bootembed declarationliquidhaskell-bootqualif definitionliquidhaskell-bootlazyvar( annotation, defer checks to *use* sitesliquidhaskell-boot- annotation, skip termination check on binderliquidhaskell-boot( annotation, the binder should be unsafeliquidhaskell-bootrewrite0 annotation, the binder generates a rewrite ruleliquidhaskell-boot rewritewith annotation, the first binder is using the rewrite rules of the second list,liquidhaskell-boot'auto-inst' or ple& annotation; use ple locally on binderliquidhaskell-boot+ annotation; lift Haskell binder as measureliquidhaskell-bootreflect8 annotation; reflect Haskell binder as function in logicliquidhaskell-bootinline7 annotation; inline (non-recursive) binder as an aliasliquidhaskell-bootignore/ annotation; skip all checks inside this binderliquidhaskell-boot= annotation; automatically generate size metric for this typeliquidhaskell-bootbound annotation; lift Haskell binder as an abstract-refinement "bound"liquidhaskell-bootbound definitionliquidhaskell-bootLIQUID; pragma, used to save configuration options in source filesliquidhaskell-boot'class measure' definitionliquidhaskell-boot'instance measure' definitionliquidhaskell-bootvariance annotations, marking type constructor params as co-, contra-, or in-variantliquidhaskell-boot<'data size' annotations, generating fancy termination metricliquidhaskell-bootfixity annotationliquidhaskell-bootdefine annotation for specifying aliases c.f. `include-CoreToLogic.lg`liquidhaskell-bootBareTypes ----------------------------------------------------------------- NOTE:BARETYPE-PARSE$Fundamentally, a type is of the formcomp -> comp -> ... -> compSobt = comp | comp -> bt!comp = circle | '(' bt ')'circle = 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]liquidhaskell-boot6Used to parse .hs and .lhs files (via ApiAnnotations).liquidhaskell-bootUsed to parse .spec files.liquidhaskell-bootParses a module spec.A module spec is a module only containing spec constructs for Liquid Haskell, and no "normal" Haskell code.liquidhaskell-bootEntry point for parsers.Resets the supply in the given state to 0, see Note [PState in parser]. Also resets the layout stack, as different spec comments in a file can start at different columns, and we do not want layout info to carry across different such comments.liquidhaskell-boot'Function to test parsers interactively.liquidhaskell-bootThe top-level parser for "bare" refinement types. If refinements are not supplied, then the default "top" refinement is used.liquidhaskell-boot For debuggingliquidhaskell-boot9Turns a list of parsed specifications into a "bare spec".This is primarily a rearrangement, as the bare spec is a record containing different kinds of spec directives in different positions, whereas the input list is a mixed list.In addition, the sigs of the spec (these are asserted/checked LH type signatues) are being qualified, i.e., the binding occurrences are prefixed with the module name.Andres: It is unfortunately totally unclear to me what the justification for the qualification is, and in particular, why it is being done for the asserted signatures only. My trust is not exactly improved by the commented out line in .liquidhaskell-boot-Parse a single top level liquid specificationliquidhaskell-bootTry 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.liquidhaskell-bootSame as tyBindsP, except the single initial symbol has already been matchedliquidhaskell-bootParses a type signature as it occurs in "assume" and "assert" directives.liquidhaskell-bootParser for a LH type synonym.liquidhaskell-boot class measureliquidhaskell-bootLHS of the thing being defined'TODO, Andres: this is still very brokenliquidhaskell-bootParse the constructors of a datatype, allowing both classic and GADT-style syntax.Note that as of 2020-10-14, we changed the syntax of GADT-style datatype declarations to match Haskell more closely and parse all constructors in a layout-sensitive block, whereas before we required them to be separated by |.liquidhaskell-bootParsing Qualifiers ---------------------------------------------liquidhaskell-bootAndres, TODO: This must be liberal with respect to reserved words (LH reserved words are not Haskell reserved words, and we want to redefine all sorts of internal stuff).9Also, this currently accepts qualified names by allowing  ... Moreover, it seems that it is currently allowed to use qualified symbolic names in unparenthesised form. Oh, the parser is also used for reflect, where apparently symbolic names appear in unqualified and unparenthesised form. Furthermore, : is explicitly excluded because a : can directly, without whitespace, follow a binder ...007 Safe-Inferred "%&,798 Safe-Inferred%&,*9 Safe-Inferred"%&(,: liquidhaskell-bootExtract Ids ---------------------------------------------------------------liquidhaskell-bootPer-Module Pipeline -------------------------------------------------------liquidhaskell-bootlookupTyThings grabs all the Names and associated TyThing known to GHC for this module; we will use this to create our name-resolution environment (see _`)liquidhaskell-bootLookup a single + in the GHC environment, yielding back the  alongside the , if one is found.liquidhaskell-boot*Returns all the available (i.e. exported) $s (type constructors) for the input .liquidhaskell-boot*Returns all the available (i.e. exported) s for the input .liquidhaskell-bootFamily instance informationliquidhaskell-bootExtract Specifications from GHC -------------------------------------------liquidhaskell-boot 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.liquidhaskell-bootFinding & Parsing Files ---------------------------------------------------Parse a spec file by path.On a parse error, we fail.TODO, Andres: It would be better to fail more systematically, but currently we seem to have an option between throwing an error which will be reported badly, or printing the error ourselves.liquidhaskell-bootPretty Printing -----------------------------------------------------------  a Safe-Inferred %&)*,<8 liquidhaskell-bootData which can be "safely" passed to the "Core" stage of the pipeline. The notion of "safely" here is a bit vague: things like imports are somewhat guaranteed not to change, but things like identifiers might, so they shouldn't land here.liquidhaskell-bootSometimes we might be in a situation where we have "wrapper" modules that simply re-exports everything from the original module, and therefore when LH tries to resolve the GHC identifier associated to a data constructor in scope (from the call to lookupTyThings4) we might not be able to find a match because the  for the input  is empty (because the type constructor are not defined in the wrapper module, but rather in the wrapped- module itself). This is why we look at the  's  to extract any re-exported  out of that.liquidhaskell-boot Ditto as for reflectedTyCons, but for identifiers.liquidhaskell-boot Just a small wrapper around the , and the text fragment of a LH spec comment.liquidhaskell-boot The target  LiftedSpec.liquidhaskell-boot5The specs which were necessary to produce the target .liquidhaskell-bootCreates a new  with no dependencies.liquidhaskell-boot(Adds a set of dependencies to the input .liquidhaskell-bootReturns the target  of this .liquidhaskell-boot%Returns all the dependencies of this .liquidhaskell-boot3Extracts all the dependencies from a collection of s.liquidhaskell-boot Constructs a  out of a .b Safe-Inferred%&,liquidhaskell-boot Serialise a 2, removing the termination checks from the target.c Safe-Inferred "%&, liquidhaskell-boot9The spec was loaded from the annotations of an interface.liquidhaskell-boot$The spec was loaded from disk (e.g. de or similar)liquidhaskell-boot#The result of searching for a spec.liquidhaskell-boot-Load any relevant spec for the input list of s, by querying both the  and the .Specs come from the interface files of the given modules or their matching _LHAssumptions modules. A module M# only matches with a module named M_LHAssumptions.Assumptions are taken from _LHAssumptions modules only if the interface file of the matching module contains no spec.liquidhaskell-bootIf this module has a "companion" '.spec' file sitting next to it, this  will try loading it.liquidhaskell-bootLoad a spec by trying to parse the relevant ".spec" file from the filesystem.liquidhaskell-bootIf this module has a "companion" '.spec' file sitting next to it, this  will try loading it.liquidhaskell-bootReturns a list of  s which can be filtered out of the dependency list, because they are selectively "toggled" on and off by the LiquidHaskell's configuration, which granularity can be  per module.liquidhaskell-bootStatic associative map of the * that needs to be filtered from the final / due to some particular configuration options.Modify this map to add any extra special case. Remember that the semantic is not which module will be added, but rather which one will be removed% from the final list of dependencies.liquidhaskell-boot,Package to exclude for loading LHAssumptionsliquidhaskell-boot8Any relevant module fetched during dependency-discovery. : Safe-Inferred "%&,3liquidhaskell-bootFixpoint Environment ------------------------------------------------------liquidhaskell-boot%Integer Keys for Fixpoint Environmentliquidhaskell-bootFixpoint Environmentliquidhaskell-boot!Map from Symbol to current BindIdliquidhaskell-bootHelper Types: Invariants --------------------------------------------------liquidhaskell-bootHelper Types: HEnv --------------------------------------------------------liquidhaskell-bootGeneration: Types ---------------------------------------------------------liquidhaskell-boottop-level fixpoint envliquidhaskell-boot subtyping constraints over RTypeliquidhaskell-boot%wellformedness constraints over RTypeliquidhaskell-boot$subtyping over Sort (post-splitting)liquidhaskell-boot5wellformedness constraints over Sort (post-splitting)liquidhaskell-boot"counter for generating fresh KVarsliquidhaskell-bootset of environment bindersliquidhaskell-boot existentialsliquidhaskell-bootsource-position annotation mapliquidhaskell-boot#information about type-constructorsliquidhaskell-boot?Mapping of new type type constructors with their refined types.liquidhaskell-boot+Terminating Metrics for Recursive functionsliquidhaskell-boot3Set of variables to ignore for termination checkingliquidhaskell-boot)"Lazy binders", skip termination checkingliquidhaskell-bootBinders that FAILED struct termination check that MUST be checkedliquidhaskell-boot ? FIX THISliquidhaskell-boot4primitive Sorts into which TyCons should be embeddedliquidhaskell-boot>Fixpoint Kut variables (denoting "back-edges"/recursive KVars)liquidhaskell-boot$Fixpoint "packs" of correlated kvarsliquidhaskell-boot&Global symbols in the refinement logicliquidhaskell-boot1Distinct constant symbols in the refinement logicliquidhaskell-bootADTs extracted from Haskell 'data' definitionsliquidhaskell-bootCheck Termination (?)liquidhaskell-bootEnable typeclass supportliquidhaskell-bootprune unsorted refinementsliquidhaskell-boot#Errors during constraint generationliquidhaskell-bootProfiling distribution of KVarsliquidhaskell-boot3number of recursive functions seen (for benchmarks)liquidhaskell-boot+Source Span associated with Fixpoint Binderliquidhaskell-boot"Refined Types of Data Constructorsliquidhaskell-boot Potentially unsorted expressionsliquidhaskell-bootSubtyping Constraints -----------------------------------------------------liquidhaskell-boot Location in original source fileliquidhaskell-bootSpecTypes for Bindings in scopeliquidhaskell-boot,Map from free Symbols (e.g. datacons) to Varliquidhaskell-bootDictionary Environmentliquidhaskell-bootGlobal literalsliquidhaskell-bootDistinct literalsliquidhaskell-bootFixpoint Environmentliquidhaskell-boot0recursive defs being processed (for annotations)liquidhaskell-bootDatatype invariantsliquidhaskell-bootDatatype recursive invariants: ignored in the base case assumed in rec callliquidhaskell-bootDatatype checkable invariantsliquidhaskell-boot6Top-level variables with (assert)-guarantees to verifyliquidhaskell-boot&Top-level variables with assumed typesliquidhaskell-boot6Top-level variables with auto generated internal typesliquidhaskell-boot+How to embed GHC Tycons into fixpoint sortsliquidhaskell-boot*Map from top-level binders to fixpoint tagliquidhaskell-bootCurrent top-level binderliquidhaskell-boot6Type of recursive function with decreasing constraintsliquidhaskell-boot6Let binding that have not been checked (c.f. LAZYVARs)liquidhaskell-bootPolymorhic let bindingsliquidhaskell-boot&Types with holes, will need refreshingliquidhaskell-bootLogical Constraintsliquidhaskell-boot)error that should be reported at the userliquidhaskell-boottop-level TargetInfoliquidhaskell-boot top level function being checkedliquidhaskell-bootForcing Strictness --------------------------------------------------------; Safe-Inferred"%&,liquidhaskell-bootUse explicitly given qualifiers .spec or source (.hs, .lhs) filesliquidhaskell-bootScrape qualifiers from function signatures (incr :: x:Int -> {v:Int | v > x})liquidhaskell-bootScrape qualifiers from refinement type aliases (type Nat = {v:Int | 0 <= 0})< Safe-Inferred%&,Q= Safe-Inferred"%&,/liquidhaskell-bootGeneration: Freshness -----------------------------------------------------Right 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  freshTyType and  freshTyExprliquidhaskell-bootUsed to generate "cut" kvars for fixpoint. Typically, KVars for recursive definitions, and also to update the KVar profile.liquidhaskell-bootThis is all hardwiring stuff to CG ----------------------------------------> Safe-Inferred"%&,liquidhaskell-bootRefinement Type Environments ----------------------------------------------? Safe-Inferred"%&,7liquidhaskell-boot2 adds a subtyping constraint into the global pool.liquidhaskell-boot(addPost: RJ: what DOES this function do?liquidhaskell-bootAdd Well formedness Constraintliquidhaskell-boot Add a warningliquidhaskell-bootAdd Identifier Annotations, used for annotation binders (i.e. at binder sites)liquidhaskell-boot/Used for annotating reads (i.e. at Var x sites)liquidhaskell-bootUpdate annotations for a location, due to (ghost) predicate applications  @ Safe-Inferred %&,69:;Jliquidhaskell-boot varTemplate2 is only called with a `Just e` argument when the e corresponds to the body of a Rec binder.liquidhaskell-bootlazVarTemplate is like  but for binders that are *not* termination checked and hence, the top-level refinement / KVar is stripped out. e.g. see testsnegT743.hs varTemplate :: CGEnv -> (Var, Maybe CoreExpr) -> CG (Template SpecType) lazyVarTemplate  (x, eo) = dbg  $ (topRTypeBase  $)  $ varTemplate'  (x, eo) where dbg = traceShow ("LAZYVAR-TEMPLATE: " ++ show x)liquidhaskell-boot topSpecType5 strips out the top-level refinement of "derived var"  A Safe-Inferred%&, liquidhaskell-bootTERMINATION TYPE ----------------------------------------------------------  B Safe-Inferred "%&,zC Safe-Inferred "%&,rliquidhaskell-boot&TODO: All this *should* happen inside Bare; but appears to happen after certain are signatures are fresh#-ed, which is why they are here.D Safe-Inferred%&,E Safe-Inferred"%&,liquidhaskell-bootReftypes from F.Fixpoint Expressions --------------------------------------liquidhaskell-bootConstraint Generation Panic -----------------------------------------------F Safe-Inferred"%&,liquidhaskell-boot behaves differently from other datacon functions. Each method type contains the full forall quantifiers instead of having them chopped offG Safe-Inferred%&,H Safe-Inferred %&,Hliquidhaskell-bootTop-level "slicing" functionI Safe-Inferred"%&,liquidhaskell-bootNOTE: Be *very* careful with the use functions from RType -> GHC.Type, e.g. toType, in this module as they cannot handle LH type holes. Since this module is responsible for plugging the holes we obviously cannot assume, as in e.g. L.H.L.Constraint.* that they do not appear.liquidhaskell-bootplugMany is used to "simultaneously" plug several different types, e.g. as arise in the fields of a data constructor. To do so we create a single "function type" that is then passed into  plugHoles. We also pass in the type parameters as dummy arguments, because, e.g. we want plugMany on the two types4forall a. a -> a -> Bool forall b. _ -> _ -> _to return something likeforall b. b -> b -> Bool"and not, forall b. a -> a -> Bool.liquidhaskell-booths typeliquidhaskell-bootlq typeliquidhaskell-bootplugged lq typeJ Safe-Inferred"%&, Wliquidhaskell-boot Using the  to do alias-expansionliquidhaskell-boot initializes the env needed to  refinements and types, that is, the below needs to be called *before* we use fgliquidhaskell-boot We apply  renameRTArgs *after* expanding each alias-definition, to ensure that the substitutions work properly (i.e. don't miss expressions hidden inside RExprArg or as strange type parameters.liquidhaskell-boot renameTys ensures that RTAlias type parameters have distinct names to avoid variable capture e.g. as in T1556.hsliquidhaskell-boot renameRTVArgs ensures that RTAlias value parameters have distinct names to avoid variable capture e.g. as in tests-names-pos-Capture01.hsliquidhaskell-boot qualifyExpand first qualifies names so that we can successfully resolve them during expansion.0When expanding, it's important we pass around a  where the type aliases have been qualified as well. This is subtle, see for example T1761. In that test, we had a type alias "OneTyAlias a = {v:a | oneFunPred v}" where "oneFunPred" was marked inline. However, inlining couldn't happen because the  had an entry for "T1761.oneFunPred", so the relevant expansion of "oneFunPred" couldn't happen. This was because the type alias entry inside  mentioned the tuple ("OneTyAlias", "{v:a | oneFunPred v}") but the  element needed to be qualified as well, before trying to expand anything.liquidhaskell-boot Expands a .liquidhaskell-bootexprArg 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  and so  converts that  into an .liquidhaskell-boot cookSpecType is the central place where a BareType. gets processed, in multiple steps, into a SpecType. See [NOTE:Cooking-SpecType] for details of each of the individual steps.liquidhaskell-bootWe don't want to generalize type variables that maybe bound in the outer scope, e.g. see testsbasicpos/LocalPlug00.hsliquidhaskell-bootFrom BareOLD.Expand expandExpr$ applies the aliases and inlines in  BareRTEnv to its argument Expr. It must first resolve the symbols in the refinement to see if they correspond to alias definitions. However, we ensure that we do not resolve bound variables (e.g. those bound in output refinements by input parameters), and we use the bs( parameter to pass in the bound symbols.liquidhaskell-bootExpand Alias Application --------------------------------------------------liquidhaskell-bootReplace Predicate Arguments With Existentials ----------------------------liquidhaskell-bootTODO: Niki please write more documentation for this, maybe an example? I can't really tell whats going on... (RJ)liquidhaskell-bootexpand on a BareType actually applies the type- and expression- aliases.liquidhaskell-bootexpand on a SpecType simply expands the refinements, i.e. *does not* apply the type aliases, but just the 1. predicate aliases, 2. inlines, 3. stuff from LogicMapliquidhaskell-boot dependenciesliquidhaskell-bootupdateliquidhaskell-bootinitialliquidhaskell-bootverticesliquidhaskell-bootfinalK Safe-Inferred%&, L Safe-Inferred"%&,~liquidhaskell-boot"Specification for Haskell functionliquidhaskell-bootHardcode imported reflected functions ------------------------------------liquidhaskell-bootExpression Definitions of Prelude Functions ------------------------------ | NV: Currently Just Hacking Composition -----------------------------liquidhaskell-boottypeclass enabledliquidhaskell-boottypeclass enabledM Safe-Inferred"%&,=liquidhaskell-bootConstraint Generation: Toplevel -------------------------------------------liquidhaskell-bootEnsure that the instance type is a subtype of the class type --------------liquidhaskell-bootConstraint Generation: Corebind -------------------------------------------liquidhaskell-bootBidirectional Constraint Generation: CHECKING -----------------------------liquidhaskell-bootinstantiatePreds' peels away the universally quantified PVars of a RType, generates fresh Ref. for them and substitutes them in the body.liquidhaskell-bootBidirectional Constraint Generation: SYNTHESIS ----------------------------liquidhaskell-boot$`exprDict e` returns the dictionary  inside the expression eliquidhaskell-bootWith GADTs and reflection, refinements can contain type variables, as  coercions (see ucsd-progsys/#1424). At application sites, we must also substitute those from the refinements (not just the types). 9https://github.com/ucsd-progsys/liquidhaskell/issues/1424 see: testsple{pos,neg}/T1424.hsliquidhaskell-bootType Synthesis for Special Pattern's -------------------------------------liquidhaskell-boot 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)liquidhaskell-boot 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.liquidhaskell-bootHelpers: Creating Fresh Refinement -------------------------------liquidhaskell-bootHelpers: Creating Refinement Types For Various Things ---------------------liquidhaskell-boot/create singleton types for function applicationliquidhaskell-bootRJ: nomeet replaces  strengthenS for  in the definition of . Why does `testsneg.strata.hs` fail EVEN if I just replace the 2 case? The fq file holds no answers, both are sat.liquidhaskell-bootCleaner Signatures For Rec-bindings ---------------------------------------liquidhaskell-boot isGenericVar determines whether the RTyVar has no class constraintsN Safe-Inferred%&,wO Safe-Inferred%&,liquidhaskell-boot coreToFun' takes a Maybe DataConMap: we need a proper map when lifting measures and reflects (which have case-of, and hence, need the projection symbols), but NOT when lifting inlines (which do not have case-of). For details, see [NOTE:Lifting-Stages]liquidhaskell-boot converts the DataCons and creates the measures for the selectors and checkers that then enable reflection.liquidhaskell-bootNOTE:Use DataconWorkIddcWorkId :: forall a1 ... aN. (a1 ~ X1 ...) => T1 -> ... -> Tn -> T checkT :: forall as. T -> Bool projT t :: forall as. T -> tliquidhaskell-bootExpand Measures -----------------------------------------------------------P Safe-Inferred"%&,Q Safe-Inferred "%&,liquidhaskell-bootChecking TargetSrc ------------------------------------------------------------------------liquidhaskell-bootChecking BareSpec ------------------------------------------------------------------------liquidhaskell-bootChecking TargetSpecliquidhaskell-boot;Used for termination checking. If we have no "len" defined yet (for example we are checking hi") then we want to skip this check.liquidhaskell-boot checkRType determines if a type is malformed in a given environment ---------------------liquidhaskell-boot checkMeasures determines if a measure definition is wellformed -----------------------------R Safe-Inferred "%&,.~ liquidhaskell-bootDe/Serializing Spec filesliquidhaskell-boot constructs the * and then validates it. Upon success, the  and the  are returned. We perform error checking in "two phases": during the first phase, we check for errors and warnings in the input  and the dependencies. During this phase we ideally want to short-circuit in case the validation failure is found in one of the dependencies (to avoid printing potentially endless failures). The second phase involves creating the , and returning either the full list of diagnostics (errors and warnings) in case things went wrong, or the final  and  together with a list of s, which shouldn't abort the compilation (modulo explicit request from the user, to treat warnings and errors).liquidhaskell-boot makeGhcSpec invokes  makeGhcSpec0 to construct the GhcSpec and then validates it using  checkGhcSpec.liquidhaskell-boot makeGhcSpec0 slurps up all the relevant information needed to generate constraints for a target module and packages them into a GhcSpec See [NOTE] LIFTING-STAGES to see why we split into lSpec0, lSpec1, etc. essentially, to get to the  as soon as possible, as thats what lets us use aliases inside data-constructor definitions.liquidhaskell-boot NOTEREFLECT-IMPORTS MAKE the full LiftedSpec, which will eventually, contain: makeHaskell{Inlines, Measures, Axioms, Bounds}+SAVE the LiftedSpec, which will be reloadedThis step creates the aliases and inlines etc. It must be done BEFORE we compute the  for (all, including the reflected binders), as we need the inlines and aliases to properly expand the SpecTypes.liquidhaskell-boot NOTELIFTING-STAGESWe split the lifting up into stage: 0. Where we only lift inlines, 1. Where we lift reflects, measures, and normalized tySigs1This is because we need the inlines to build the  BareRTEnv which then does the alias expand business, that in turn, lets us build the DataConP, i.e. the refined datatypes and their associate selectors, projectors etc, that are needed for subsequent stages of the lifting.liquidhaskell-boot 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.liquidhaskell-bootWe 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?liquidhaskell-bootresolveQualParams2 converts the sorts of parameters from, e.g.  ===> jk or Ptr ===> lm It would not be required if _all_ qualifiers are scraped from function specs, but we're keeping it around for backwards compatibility.liquidhaskell-bootupdateReflSpecSig uses the information about reflected functions to update the "assumed" signatures.liquidhaskell-bootmakeLiftedSpec is used to generate the BareSpec object that should be serialized so that downstream files that import this target can access the lifted definitions, e.g. for measures, reflected functions etc.liquidhaskell-bootReturns  if the input determines a location within the input file. Due to the fact we might have Haskell sources which have "companion" specs defined alongside them, we also need to account for this case, by stripping out the extensions and check that the LHS is a Haskell source and the RHS a spec file.liquidhaskell-bootmyRTEnv slices out the part of RTEnv that was generated by aliases defined in the _target_ file, "cooks" the aliases (by conversion to SpecType), and then saves them back as BareType.S Safe-Inferred"%&(,;3liquidhaskell-bootPer-Module Pipeline -------------------------------------------------------liquidhaskell-bootThe "client library" we will serialise on disk into an interface's .liquidhaskell-bootThe GhcInfo for the current ! that LiquidHaskell will process.liquidhaskell-boot"Unoptimising" things ----------------------------------------------------LiquidHaskell requires the unoptimised core binds in order to work correctly, but at the same time the user can invoke GHC with any optimisation flag turned out. This is why we grab the core binds by desugaring the module during parsing (before that's already too late) and we cache the core binds for the rest of the program execution.liquidhaskell-bootRepresents an abnormal but non-fatal state of the plugin. Because it is not meant to escape the plugin, it is not thrown in IO but instead carried around in an 's ; case and handled at the top level of the plugin function.liquidhaskell-bootState and configuration management -----------------------------------------A reference to cache the LH's  and produce it only once, during the dynFlags hook.liquidhaskell-bootSet to  to enable debug logging.liquidhaskell-bootUseful functions ----------------------------------------------------------- Reads the  out of a .liquidhaskell-bootCombinator which conditionally print on the screen based on the value of .liquidhaskell-bootThe Plugin entrypoint ------------------------------------------------------liquidhaskell-bootGHC Configuration & Setup -------------------------------------------------Overrides the default  options. Specifically, we need the GHC lexer not to throw away block comments, as this is where the LH spec comments would live. This is why we set the  option.liquidhaskell-bootTypechecking phase --------------------------------------------------------We hook at this stage of the pipeline in order to call "liquidhaskell". This might seems counterintuitive as LH works on a desugared module. However, there are a bunch of reasons why we do this: Tools like "ghcide" works by running the compilation pipeline up until this stage, which means that we won't be able to report errors and warnings if we call LH any later than here; Although LH works on "Core", it requires the _unoptimised_ "Core" that we grab from parsing (again) the module by using the GHC API, so we are really independent from the "normal" compilation pipeline.liquidhaskell-boot-Partially calls into LiquidHaskell's GHC API.liquidhaskell-bootWorking with bare & lifted specs ------------------------------------------liquidhaskell-bootParse the spec comments from one module, supported by the spec quotes from the imported module. Also looks for "companion specs" for the current module and merges them in if it finds one.liquidhaskell-bootThe  associated to the current module being compiled.n Safe-Inferred%&,;bopqrstouvowxowyowzow{ow|ow}ow~owowoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo o o o  o  o o o  o o o  o o o o o o o  o o o o o  o o o o o  o o o  o  o  o o o o o o o  o o  o  opqop op op op op op op op op op op op op op o o o o o  o o o o o o o o o o o o o o o o o o o  o  o o o o o o o o o o oh oh oh oh oh oh oh oh oh oh oh oh oh                                                                                                                                                                                                                                                            v                                                                                                                       !!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""#######$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$%&&&&&&&&&'''''''''(((((((()))))*********************************************************+++++++++,,,,,,,,,,,,,,,,,---................................//////////0000000000000001111111112344455555555555556666666666666666666666666666666666666666666666666666667777777777777777777777778999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;<<<<======>>>>>>>>>>>>>>>>>>>???????????@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAABBBCCDDEEEFFFGGHIIJJJJJJJJJJJJJJJJJJJJJJJJKLLLLLMMMMNOOOOOOOOPPPPPQQQRRRSSSSSSSr oho  j rrrr %%%%%%%'''''')))))*****r+++++++++r+++,,,..........//////////r0000 0 03r6666666666666666r99a a a a  a a a a a a a a a a a a a a a a a a a b b b b c c c c c c c c c c c c c c : ; ; = > @ C E I JfJgJ J J J J J J J J J J L L L L M M M M M M M M M M M M M M r M M O O O Q Q Q R R R R R R R jkR R R R S S S S S r  r  S S S r  S S S S S S 1liquidhaskell-boot-0.9.6.3-9A5uxmIRMTwLbbjDHLeYgPLiquid.GHC.API#Language.Haskell.Liquid.Types.TypesLanguage.Haskell.Liquid.UX.TidyLanguage.Haskell.Liquid.Cabal&Language.Haskell.Liquid.Types.Generics#Language.Haskell.Liquid.Types.Names!Language.Haskell.Liquid.UX.Config(Language.Haskell.Liquid.UX.SimpleVersionLiquid.GHC.API.StableModuleLiquid.GHC.API.Extra!Language.Haskell.Liquid.GHC.TypesPaths_liquidhaskell_bootLanguage.Haskell.Liquid.Misc$Language.Haskell.Liquid.Types.Errors#Language.Haskell.Liquid.GHC.Logging Language.Haskell.Liquid.GHC.MiscLanguage.Haskell.Liquid.UX.ACSS&Language.Haskell.Liquid.Types.Visitors&Language.Haskell.Liquid.Types.Variance)Language.Haskell.Liquid.Types.PrettyPrint Language.Haskell.Liquid.UX.CTags,Language.Haskell.Liquid.Transforms.InlineAux#Language.Haskell.Liquid.GHC.TypeRep%Language.Haskell.Liquid.GHC.SpanStack#Language.Haskell.Liquid.GHC.Resugar Language.Haskell.Liquid.GHC.Play%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.Types.SpecsLanguage.Haskell.Liquid.Measure"Language.Haskell.Liquid.Bare.Types*Language.Haskell.Liquid.Transforms.Rewrite&Language.Haskell.Liquid.Transforms.Rec&Language.Haskell.Liquid.Transforms.ANF!Language.Haskell.Liquid.Bare.Misc&Language.Haskell.Liquid.Bare.Elaborate$Language.Haskell.Liquid.Bare.Resolve%Language.Haskell.Liquid.Bare.DataType.Language.Haskell.Liquid.Transforms.CoreToLogic&Language.Haskell.Liquid.Types.Literals$Language.Haskell.Liquid.UX.DiffCheck#Language.Haskell.Liquid.UX.Annotate"Language.Haskell.Liquid.UX.CmdLine&Language.Haskell.Liquid.Types.Equality+Language.Haskell.Liquid.Transforms.Simplify!Language.Haskell.Liquid.UX.Errors+Language.Haskell.Liquid.Transforms.RefSplit.Language.Haskell.Liquid.Termination.StructuralLanguage.Haskell.Liquid.Parse&Language.Haskell.Liquid.UX.QuasiQuoter$Language.Haskell.Liquid.LawInstances%Language.Haskell.Liquid.GHC.Interface(Language.Haskell.Liquid.Constraint.Types,Language.Haskell.Liquid.Constraint.Qualifier-Language.Haskell.Liquid.Constraint.ToFixpoint(Language.Haskell.Liquid.Constraint.Fresh&Language.Haskell.Liquid.Constraint.Env(Language.Haskell.Liquid.Constraint.Monad+Language.Haskell.Liquid.Constraint.Template.Language.Haskell.Liquid.Constraint.Termination-Language.Haskell.Liquid.Constraint.Relational'Language.Haskell.Liquid.Constraint.Init-Language.Haskell.Liquid.Constraint.Constraint(Language.Haskell.Liquid.Constraint.Split&Language.Haskell.Liquid.Bare.Typeclass#Language.Haskell.Liquid.Bare.ToBare"Language.Haskell.Liquid.Bare.Slice$Language.Haskell.Liquid.Bare.Plugged#Language.Haskell.Liquid.Bare.Expand!Language.Haskell.Liquid.Bare.Laws"Language.Haskell.Liquid.Bare.Axiom+Language.Haskell.Liquid.Constraint.GenerateLanguage.Haskell.Liquid.Liquid$Language.Haskell.Liquid.Bare.Measure"Language.Haskell.Liquid.Bare.Class"Language.Haskell.Liquid.Bare.CheckLanguage.Haskell.Liquid.Bare"Language.Haskell.Liquid.GHC.Pluginliquidhaskell-boot+Language.Haskell.Liquid.GHC.Plugin.TutorialLanguage.Haskell.Liquid Constraint Data.VectorVectorData.Vector.Generic.BaseLanguage.Haskell.Liquid.TypesSystem DirectoryACSSBareResolve(Language.Haskell.Liquid.GHC.Plugin.Types'Language.Haskell.Liquid.GHC.Plugin.Util-Language.Haskell.Liquid.GHC.Plugin.SpecFinderPreludespecExpandexpandGHCPrim GHC.TypesIntGHC.PtrPtrLiquidHaskellBootghcGHC.Driver.PluginsPluginbaseControl.Monad.IO.ClassliftIOGHC.Utils.Panic.PlainpanicGHC.Data.FastString FastStringuniqbytesFSmkFastStringByteString mkFastStringunpackFSconcatFS mkPtrString#fsLitLanguage.Haskell.Syntax.BasicRoleBoxityBoxed!Language.Haskell.Syntax.ExtensionIdP noExtField#Language.Haskell.Syntax.Module.Name ModuleName moduleNameFSmoduleNameString mkModuleNamemkModuleNameFSGHC.Types.Name.OccurrenceOccName mkVarOccFS occNameFSLanguage.Haskell.Syntax.ImpExpIsBootInterfaceNotBootIsBootGHC.Unit.TypesModuleUnitId moduleUnit moduleNameGHC.Utils.OutputableIsDocLineline$$lines_vcatdualDocIsLinechartextftextztext<+>sepfsephcathsepdualLineIsOutputemptydocWithContextHDocHLineOutputableBndrpprBndr pprPrefixOcc pprInfixOccbndrIsJoin_maybe BindingSite LambdaBindCaseBind CasePatBindLetBindPDoc OutputablePpdoc Outputableppr SDocContextSDC sdocStyle sdocColSchemesdocLastColoursdocShouldUseColorsdocDefaultDepthsdocLineLengthsdocCanUseUnicodesdocHexWordLiterals sdocPprDebugsdocPrintUnicodeSyntaxsdocPrintCaseAsLetsdocPrintTypecheckerElaborationsdocPrintAxiomIncompssdocPrintExplicitKindssdocPrintExplicitCoercionssdocPrintExplicitRuntimeRepssdocPrintExplicitForallssdocPrintPotentialInstancessdocPrintEqualityRelationssdocSuppressTickssdocSuppressTypeSignaturessdocSuppressTypeApplicationssdocSuppressIdInfosdocSuppressCoercionssdocSuppressCoercionTypessdocSuppressUnfoldingssdocSuppressVarKindssdocSuppressUniquessdocSuppressModulePrefixessdocSuppressStgExtssdocSuppressStgRepssdocErrorSpanssdocStarIsTypesdocLinearTypessdocListTuplePunssdocPrintTypeAbbreviationssdocUnitIdForUserSDoc QualifyName NameUnqualNameQualNameNotInScope1NameNotInScope2IsEmptyOrSingleton PromotedItemPromotedItemListSyntaxPromotedItemTupleSyntaxPromotedItemDataConPromotionTickContext PromTickCtxptcListTuplePunsptcPrintRedundantPromTicksQueryPromotionTickQueryQualifyPackageQueryQualifyModuleQueryQualifyName NamePprCtx QueryQualifyqueryQualifyNamequeryQualifyModulequeryQualifyPackagequeryPromotionTickDepth AllTheWayPartWay DefaultDepthPprStylePprUserPprDumpPprCodeisListEmptyOrSingletonreallyAlwaysQualifyNamesalwaysQualifyNamesneverQualifyNamesalwaysQualifyModulesneverQualifyModulesalwaysQualifyPackagesneverQualifyPackagesalwaysPrintPromTickreallyAlwaysQualify alwaysQualify neverQualifydefaultUserStyledefaultDumpStyle mkDumpStyledefaultErrStyle mkErrStylecmdlineParserStyle mkUserStyle withUserStyle withErrStylesetStyleColouredrunSDocdefaultSDocContexttraceSDocContext withPprStyle pprDeeper pprDeeperList pprSetDepth getPprStylesdocWithContext sdocOptionupdSDocContextqualName qualModule qualPackagepromTick queryQual codeStyle dumpStyle userStyle getPprDebug ifPprDebug whenPprDebug printSDoc printSDocLnbufLeftRenderSDocpprCoderenderWithContextshowSDocOneLineshowSDocUnsafe showPprUnsafepprDebugAndThenisEmpty docToSDocptextintintegerfloatdoublerationalword doublePrecparensbracesbracketsquote doubleQuotes angleBracketscparenquotes blankLinedcolonarrowlollipoplarrowdarrowarrowtlarrowtarrowttlarrowttlambdasemicommacolonequalsspace underscoredotvbarlparenrparenlbrackrbracklbracerbrace forAllLitbullet unicodeSyntaxnest$+$catfcathang hangNotEmpty punctuateppWhenppUnless ppWhenOptionppUnlessOptioncolouredkeyword pprModuleName pprHsChar pprHsString pprHsBytesprimCharSuffixprimFloatSuffix primIntSuffixprimDoubleSuffixprimWordSuffixprimInt8SuffixprimWord8SuffixprimInt16SuffixprimWord16SuffixprimInt32SuffixprimWord32SuffixprimInt64SuffixprimWord64Suffix pprPrimChar pprPrimInt pprPrimWord pprPrimInt8 pprPrimInt16 pprPrimInt32 pprPrimInt64 pprPrimWord8 pprPrimWord16 pprPrimWord32 pprPrimWord64 pprPrefixVar pprInfixVarpprFastFilePathpprFilePathString pprWithCommas pprWithBarsspaceIfSingleQuote interppSP interpp'SP interpp'SP' pprQuotedListquotedListWithOrquotedListWithNor intWithCommasspeakNthspeakNspeakNOfpluralsingularisOrAredoOrDoes itsOrTheir thisOrThese hasOrHavebPutHDocGHC.Utils.Panic GhcException CmdLineError ProgramErrorthrowGhcExceptionthrowGhcExceptionIOGHC.Types.Id.Info IdDetailsIdInfo vanillaIdInfo emptyPluginsGHC.Types.Unique Uniquable getUniqueUniquegetKeymkUniquehasKeyGHC.Types.Name NamedThing getOccNamegetNameName nameOccName GHC.Types.VarIdTyVar SpecificityVarBndrVar FunTyFlag ForAllTyFlagGHC.CoreCoreExprCoreBndrExprGHC.Core.TyConTyCon tyConName isTupleTyConGHC.Types.TyThingTyThingGHC.Core.TyCo.RepKindPredTypeTyLitUnivCoProvenanceCoercionTypeGHC.Types.Unique.Supply MonadUnique getUniqueMGHC.Types.SrcLocLocated GenLocatedLUnhelpfulSpanReasonUnhelpfulNoLocationInfoUnhelpfulWiredInUnhelpfulInteractiveUnhelpfulGeneratedUnhelpfulOtherSrcSpan RealSrcSpan UnhelpfulSpan srcSpanFileSrcLoc RealSrcLocmkSrcLoc mkRealSrcLoc srcLocFile srcLocLine srcLocCol noSrcSpanmkGeneralSrcSpan mkRealSrcSpan mkSrcSpancombineSrcSpans isGoodSrcSpansrcSpanStartLinesrcSpanEndLinesrcSpanStartCol srcSpanEndColrealSrcSpanStartsrcSpanFileName_maybesrcSpanToRealSrcSpanunLocGHC.Types.Unique.Set mkUniqSetGHC.Types.SourceText SourceText NoSourceText mkIntegralLitmkTHFractionalLitGHC.Types.FieldLabel FieldLabel flSelector GHC.Data.BagBag bagToListGHC.Types.Fixity LexicalFixityPrefixFixityDirectionInfixRInfixNFixity GHC.Data.PairPairGHC.Driver.Flags GeneralFlag Opt_HaddockOpt_DeferTypedHolesOpt_PICOpt_ImplicitImportQualifiedOpt_KeepRawTokenStreamModuleNameWithIsBoot GenWithIsBootgwib_mod gwib_isBootfsToUnit unitStringtoUnitIdGHC.Unit.Module.Location ModLocation ml_hs_fileGHC.Unit.ModulemoduleStableStringGHC.Types.PkgQualPkgQual NoPkgQualLanguage.Haskell.Syntax.ExprLHsExprHsExprLanguage.Haskell.Syntax.Type PromotionFlag NotPromotedGHC.Types.Basic InlinePragmainl_src inl_inlineinl_satinl_actinl_rulePprPrec TopLevelFlag NotTopLevelAritytopPrecfunPrec noOccInfoisStrongLoopBreaker isDeadOccGHC.Core.DataConDataCon dataConWrapIddataConFullSigdataConFieldLabelsdataConExTyCoVars dataConTyCon dataConWorkId dataConNameGHC.Builtin.Types tupleTyCon tupleDataCon naturalTyliftedTypeKindtypeSymbolKind listTyConmkVarOcc mkTyVarOccmkTcOcc occNameString nameSrcLoc nameSrcSpanisExternalNameisInternalName nameModulenameModule_maybe isSystemNamemkInternalName mkSystemName stableNameCmpnameStableString getSrcSpan getOccString TyVarBinderBndrFTF_T_T SpecifiedSpecRequiredvarNamevarTypeDFunId varUnique setVarUnique setVarName setVarType binderVar tyVarKindmkTyVaridInfo idDetails mkLocalVarisTyVarisIdisCoVar isLocalId GHC.Core.TypetyConAppTyCon_maybesplitTyConApp_maybe mkTyConAppGHC.Types.Var.SetVarSet emptyVarSet unitVarSet extendVarSetextendVarSetList elemVarSetGHC.Types.Var.EnvemptyInScopeSetmkRnEnv2GHC.Types.Avail AvailInfoAvailAvailTC availNamesgreNameMangledNameGHC.Types.Name.Reader ImpItemSpecImpAll ImpDeclSpecis_modis_asis_qualis_dloc ImportSpecImpSpecRdrNamemkUnqual mkVarUnqualmkQual getRdrName nameRdrNamegresFromAvailsgreMangledNameglobalRdrEnvEltslookupGRE_RdrNamemkGlobalRdrEnvGHC.Parser.AnnotationLocatedNgetLocAnoLocA noAnnSrcSpannoAnnGHC.Hs.ExtensionGhcRnGhcPs ideclNameideclAs LImportDeclGHC.Types.CostCentre CostCentrecc_locGHC.Builtin.NamesitName dATA_FOLDABLEgHC_REALge_RDRle_RDRlt_RDRgt_RDR minus_RDR times_RDRplus_RDRand_RDRnot_RDR varQual_RDR eqClassName ordClassName bindMName negateNameisStringClassName eqClassKeyfractionalClassKey ordClassKey dollarIdKeynumericClassKeysfractionalClassKeysGHC.Types.Annotations AnnTarget ModuleTarget AnnPayload Annotation ann_target ann_valuefindAnnsGHC.Driver.PhasesPhaseStopLnGHC.Core.Coercion.Axiom CoAxiomRuleCoAxiomBranched coAxiomTyConGHC.Core.Coercion coercionKindGHC.Core.ClassClass classTyCon classNameclassKey classTyVarsclassAllSelIds classSCSelIds classMethods classSCTheta classBigSig tyConBinders tyConTyVars tyConKind tyConArity TyConBndrVisAnonTCB TyConBinder mkPrimTyCon isPrimTyCon isAlgTyConisVanillaAlgTyCon isNewTyConisTypeSynonymTyConisGadtSyntaxTyCon isFamilyTyConisBoxedTupleTyConisPromotedDataCon tyConDataConstyConDataCons_maybetyConSingleDataCon_maybe newTyConRhssynTyConDefn_maybesynTyConRhs_maybe isClassTyContyConClass_maybeisFamInstTyContyConFamInst_maybe PhantomProvProofIrrelProvReflGRefl TyConAppCoAppCoForAllCoFunCoCoVarCo AxiomInstCo AxiomRuleCoUnivCoSymCoTransCoSelCoLRCoInstCoKindCoSubCoHoleCoNumTyLitStrTyLit CharTyLitTyVarTyAppTyTyConAppForAllTyFunTyLitTyCastTy CoercionTyft_argft_res mkTyVarTy mkTyVarTysmkFunTy mkForAllTysGHC.Builtin.Types.Prim primTyCons isArrowTyCon eqPrimTyConeqReprPrimTyConGHC.Core.TyCo.SubstemptyTvSubstEnv emptySubst extendCvSubst mkTvSubstPrs substTyWithsubstTyManyTyexpandTypeSynonyms isTyVarTy splitAppTyssplitFunTy_maybe splitFunTys piResultTystyConAppArgs_maybe splitTyConAppnewTyConInstRhssplitForAllTyCoVarsisFunTy dropForAllsisTYPEorCONSTRAINTirrelevantMultGHC.Core.TyCo.CompareeqType nonDetCmpTypeGHC.Types.Tickish GenTickishProfNoteHpcTick Breakpoint SourceNote profNoteCC profNoteCount profNoteScope tickModuletickId breakpointExt breakpointId breakpointFVs sourceSpan sourceName CoreTickishGHC.Types.Literal LitNumType LitNumIntLiteralLitChar LitNumber LitStringLitFloat LitDouble literalType mkRepReflCoGHC.Types.ErrorSeverity SevWarning MessageClass MCDiagnostic MsgEnvelope errMsgSpanDiagnosticReasonWarningWithoutFlag DiagnosticdefaultDiagnosticOptsMessages getMessages mkPlainErrorerrorsOrFatalWarningsFoundGHC.Utils.Logger getLoggerLoggerlogFlags putLogMsgGHC.Utils.ErrorpprLocMsgEnvelope withTimingGHC.Driver.BackendinterpreterBackendGHC.Core.UnifyruleMatchTyKiX tcUnifyTyGHC.Core.Predicate mkClassPredgetClassPredTysgetClassPredTys_maybe isEvVarType isClassPredisEqPred isEqPrimPredisDictIdStrictnessMarkdataConRepTypedataConUnivTyVars dataConThetadataConWrapId_maybedataConImplicitTyThingsdataConRepStrictnessdataConWrapperTypedataConInstArgTysdataConOrigArgTysdataConRepArgTysisTupleDataConisVanillaDataCon classDataConHsArgHsValArgHsType HsForAllTyHsQualTyHsTyVarHsAppTy HsWildCardTy HsTyVarBndr UserTyVar HsSigTypeHsSigHsWildCardBndrsHsWCHsOuterTyVarBndrsHsOuterImplicitLHsTypeLanguage.Haskell.Syntax.Binds FixitySigSigTypeSigFixSig InlineSigLanguage.Haskell.Syntax.DeclsHsDeclSigDLHsDeclHsVar HsOverLit ExprWithTySigLanguage.Haskell.SyntaxHsModule hsmodDeclsCoreAltCoreBindCoreArg CoreProgram Unfolding DFunUnfolding CoreUnfoldinguf_tmplBindNonRecRecAltConDataAltLitAltDEFAULTAltArgLitAppLamLetCaseCastTickmaybeUnfoldingTemplatecmpAltmkAppsmkTyAppsmkTyArgmkLams bindersOf flattenBindscollectBinderscollectTyBinderscollectTyAndValBinders collectArgs isTypeArgGHC.Core.Reduction ReductionGHC.Core.ConLikeConLike RealDataConCafInfo NoCafRefsrealUnfoldingInfoinlinePragInfooccInfo VanillaIdRecSelId DataConWorkId DataConWrapIdcafInfo setOccInfo setCafInfomayHaveCafRefs GHC.Types.IdidType setIdInfo modifyIdInfomkExportedLocalId mkUserLocalisRecordSelectorisClassOpId_maybeisDFunId idDataConrealIdUnfolding idOccInfo isConLikeIdAnIdAConLikeATyCon intTyConName boolTyConName listTyConNameanyTytrue_RDR charTyCon charDataConstringTyintTyintTyCon intDataConboolTy boolTyCon falseDataCon trueDataConfalseDataConId trueDataConId nilDataCon consDataCon GHC.Core.FVsexprFreeVarsListGHC.Core.FamInstEnv FamInstEnv FamInstEnvs FamFlavorDataFamilyInstFamInst fi_flavoremptyFamInstEnvfamInstEnvEltstopNormaliseType_maybeGHC.Core.UtilsexprTypeGHC.Core.Subst extendIdSubst substExprGHC.Core.Opt.OccurAnaloccurAnalysePgm GHC.Core.Make mkCoreLams mkCoreLets mkCoreConApps mkCoreApps pAT_ERROR_IDGHC.Iface.SyntaxIfaceAnnotationifAnnotatedValue GHC.Hs.TypemkHsForAllInvisTeleGHC.Driver.SessionGhcLink LinkInMemoryGhcMode CompManager getDynFlagsDynFlagsghcModeghcLinkbackend debugLevelgoptgopt_setxopt_set updOptLevelGHC.Tc.Utils.TcType tcSplitDFunTytcSplitMethodTyGHC.Tc.Types.Evidence TcEvBindsEvBindsGHC.Core.InstEnvClsInst is_dfun_nameis_clsis_tysis_dfuninstanceDFunId instanceSig instEnvEltsGHC.Unit.Finder.Types FindResultFound NoPackage FoundMultipleNotFoundGHC.Driver.PprshowSDocshowPprGHC.Data.IOEnvfailMgetEnv GHC.Hs.UtilsmkHsAppmkHsLam mkHsIntegralmkHsFractionalnlHsVarnlVarPatnlHsIfnlList nlHsAppTy nlHsTyVar nlHsFunTy nlHsTyConApphsTypeToHsSigTypehsTypeToHsSigWcType mkHsDictLetGHC.Tc.Types.Origin lexprCtOriginGHC.Unit.Module.ModGutsModGuts mg_module mg_exports mg_usagesmg_tcsmg_binds mg_inst_envmg_fam_inst_envGHC.Unit.Module.ModIface ModIface_ mi_module mi_exportsmi_anns mi_globalsGHC.Unit.ExternalExternalPackageState eps_ann_envExternalUnitCacheeuc_epsGHC.Unit.Home.ModInfoHomePackageTable HomeModInfohm_iface lookupHpt GHC.Unit.EnvUnitEnvue_epsue_hptGHC.Unit.Module.ModSummary ModSummaryms_mod ms_location ms_hspp_file ms_hspp_opts ms_mod_nameGHC.Tc.Errors.TypesmkTcRnUnknownMessageGHC.Driver.Env.TypesHscEnv hsc_dflags hsc_mod_graph hsc_plugins hsc_unit_envGHC.Types.SourceError SourceErrorsrcErrorMessagesGHC.Driver.Errors printMessagesGHC.Driver.Config.Diagnostic initDiagOptsinitDsMessageOptsGHC.Driver.MonadGhc getSession withSession GHC.Tc.Types WhereFromImportBySystemTcGblEnvtcg_mod tcg_rdr_env tcg_exportstcg_rn_importstcg_anns tcg_instsEnvenv_topTcMTcRninstallCoreToDostcPlugindefaultingPlugin holeFitPlugin driverPluginpluginRecompileparsedResultActionrenamedResultActiontypeCheckResultActionspliceRunActioninterfaceLoadActionCommandLineOption purePlugin defaultPluginGHC.Unit.FinderfindImportedModulefindExposedPackageModuleGHC.Builtin.UtilsisNumericClassGHC.Iface.ErrorscannotFindModuleGHC.HsToCore.TypesDsMGHC.Rename.ExprrnLExprGHC.Tc.Gen.Expr tcInferRhoGHC.Tc.Utils.Monad newUniqueaddErrAtaddErrsreportDiagnosticsreportDiagnostic failIfErrsMcaptureConstraints failWithTcdiscardConstraints pushTcLevelM initIfaceTcRnGHC.Iface.Load loadInterfaceGHC.HsToCore.MonadinitDsTcinitDsWithModGutsGHC.HsToCore.ExprdsLExprGHC.Tc.Utils.Zonk zonkTopLExpr GHC.Tc.Solver InferModeNoRestrictionscaptureTopConstraintssimplifyInteractive simplifyInferGHC.Rename.Names renamePkgQualGHC.Tc.Gen.Bind tcValBindsGHC.Tc.Gen.App tcInferSigma GHC.Tc.ModulegetModuleInterfaceGHC.Driver.MainhscTcRcLookupName hscDesugarGHC.Driver.Pipeline compileFileDesugaredModuledm_typechecked_moduledm_core_moduleTypecheckedModuletm_parsed_moduletm_checked_module_info tm_internals_ ParsedModulepm_mod_summarypm_parsed_sourcemodInfoTopLevelScope isDictonaryIdghc-boot-9.6.3GHC.Serialized toSerializedfromSerializeddeserializeWithData.liquid-fixpoint-0.9.6.3-IJMQwHCJBzY5uWC3Ln0mXX#Language.Fixpoint.Types.PrettyPrintPPrint pprintTidy pprintPrecpprintshowppLanguage.Fixpoint.Types.SpansLocloclocEvaldummyLocLanguage.Fixpoint.Types.NamesLocText LocSymbolisDummy tidySymbol dummyNameliquidHaskellMain$fEqGenerically$fBinaryGenerically$fHashableGenerically lenLocSymbol anyTypeSymbolfunctionComposisionSymbol selfSymbol HasConfig getConfigConfigloggingVerbosityfilesidirs diffchecklinear stringTheory higherorder higherorderqs smtTimeout fullcheck saveQuerychecksnoCheckUnknown notermination nopositivity rankNTypes noclasschecknostructuraltermgradualbscopegdepth ginteractive totalHaskell nowarnings noannotations checkDerivedcaseExpandDepth notruetypes nototality pruneUnsortedcores minPartSize maxPartSize maxParams smtsolver shortNames shortErrorscabalDir ghcOptionscFiles eliminateportexactDCnoADTexpectErrorContainingexpectAnyError scrapeImportsscrapeInternalsscrapeUsedImports elimStats elimBoundjsoncounterExamples timeBindsnoPatternInline untidyCorenoSimplifyCorenoslicenoLiftedImportproofLogicEvalpleWithUndecidedGuardsoldPLE interpreterproofLogicEvalLocalextensionality nopolyinfer reflection compileSpecnoCheckImports typeclass auxInlinerwTerminationCheck skipModule noLazyPLEfuelenvironmentReductionnoEnvironmentReductioninlineANFBindings pandocHtmlexcludeAutomaticAssumptionsForallowPLEallowGlobalPLE allowLocalPLE patternFlaghigherOrderFlag exactDCFlag pruneFlag maxCaseExpandhasOpt totalityCheckterminationCheckstructuralTerm$fHasConfigConfig$fGenericConfig $fDataConfig $fShowConfig $fEqConfig simpleVersion StableModuleunStableModuletoStableModule renderModulemkStableModule$fHashableModuleName$fBinaryStableModule$fShowStableModule$fEqStableModule$fOrdStableModule$fHashableStableModule$fGenericStableModule ApiCommentApiLineCommentApiBlockComment fsToUnitId thisPackagetyConRealArityrenderWithStyle dataConSigrelevantModules parseModuleIOtypecheckModuleIOdesugarModuleIO apiCommentsapiCommentsParsedSourcelookupModSummarymodInfoLookupNameIO moduleInfoTc isPatErrorAltqualifiedNameFSshowPprQualifiedshowSDocQualified strictNothing$fEqApiComment$fShowApiComment MGIModGutsMI mgi_binds mgi_modulemgi_tcs mgi_exports mgi_cls_inst StableName MkStableName unStableName mkStableNameavailsToStableNameSet miModGuts mgiNamestring$fEqStableName$fHashableStableName$fShowStableName$fGenericStableNameversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirValidateErrValNat.&&..||.up timedAction!? safeFromJust safeFromLefttakeLastgetNthfst4snd4thd4thrd3 mapFifth5 mapFourth4addFst3addThd3dropFst3dropThd3replaceNthd5snd5fst5fourth4third4mapSndMfirstMsecondMfirst3Msecond3Mthird3Mthird3zip4zip5unzip4 getCssPathgetCoreToLogicPathzipMaybesafeZipWithErrorsafeZip3WithErrorsafeZip4WithErrormapNsmapN zipWithDefM zipWithDefsinglemapFst3mapSnd3mapThd3hashMapMapWithKeyhashMapMapKeys concatMapM replaceSubset replaceWith firstElems splitters bchopAltschopAltssortDiff<->mkGraph tryIgnorecondNull firstJust intToString mapAccumMifM nubHashOn nubHashLast nubHashLastM uniqueByKey uniqueByKey'join fstByRanksortOn firstGroupmapErr catEitherskeyDiff concatUnzip sayReadFile lastModified$fApplicativeValidate$fFunctorValidate WithModelNoModel UserErrorTError ErrSubTypeErrSubTypeModel ErrFCrashErrHole ErrHoleCycle ErrAssTypeErrParse ErrTySpec ErrTermSpec ErrDupAlias ErrDupSpecs ErrDupIMeas ErrDupMeas ErrDupField ErrDupNames ErrBadData ErrDataConErrDataConMismatchErrInvtErrIAl ErrIAlMisErrMeasErrHMeas ErrUnbound ErrUnbPredErrGhc ErrResolve ErrMismatch ErrPartPred ErrAliasCycleErrIllegalAliasApp ErrAliasApp ErrTermin ErrStTermErrILaw ErrRClass ErrMClass ErrBadQualErrSaved ErrFilePragmaErrTyCon ErrLiftExp ErrParseAnn ErrNoSpecErrFail ErrFailUsed ErrRewrite ErrPosTyConErrOtherposmsgcidctxtacttexpctxMtactMsvarthl holesCycleoblcondpErrkndvartypexpmsg'kindlocstycondconfieldnamesdcsrdcsinvtAstUsmshslqTydifflqPosectrargNexpNactNacyclednamedposbindcnameinameclsinstsqnamenamtcnamesrcFbspFclientstcdcObligOTermOInvOConsCtxErrorctErrctCtx ParseErrorerrorsWithContext errDupSpecs dropModeluErrorpanicDoctodo impossibleppErrorunpackRealSrcSpanpackRealSrcSpan srcSpanFileMbppTicks sourceErrors$fFromJSONKeySrcSpan$fToJSONKeySrcSpan$fFromJSONSrcSpan$fToJSONSrcSpan$fFromJSONRealSrcSpan$fToJSONRealSrcSpan$fPPrintSrcSpan$fPPrintParseError $fPPrintOblig $fNFDataOblig $fShowOblig $fBinaryOblig$fNFDataWithModel$fFromJSONTError$fToJSONTError $fEqTError$fExceptionTError $fShowTError$fPPrintTError $fEqCtxError$fFunctorCtxError$fGenericTError$fFunctorTError$fFunctorWithModel$fShowWithModel $fEqWithModel$fGenericWithModel $fEqOblig$fGenericOblig $fDataOblig$fHashableOblig fromPJDoc putWarnMsgaddTcRnUnknownMessageaddTcRnUnknownMessages TcWiredIn tcWiredInNametcWiredInFixity tcWiredInType HashableTypegetHType isAnonBindermkAlive tickSrcSpan stringTyVar stringVar maybeAuxVar stringTyConstringTyConWithKindhasBaseTypeVar isBaseTypeisTmpVar isTmpSymbol validTyVartvIdtidyCBsunTick unTickExprisFractionalClass isOrdClass notracePprtracePprpprShow toFixSDocsDocDocpprDoc myQualify showSDocDumptypeUniqueStringfSrcSpan fSourcePosfSrcSpanSrcSpansrcSpanFSrcSpansourcePos2SrcSpansourcePosSrcSpansourcePosSrcLocsrcSpanSourcePossrcSpanSourcePosEsrcSpanFilenamesrcSpanStartLoc srcSpanEndLoconeLinelineColrealSrcSpanSourcePosrealSrcLocSourcePosrealSrcSpanSourcePosE getSourcePos getSourcePosE locNamedThingnamedLocSymbol varLocInfo namedPanic isExternalId isTupleId idDataConM isDataConIdgetDataConVarUniqueisDictionaryExpression realTcArity kindTCArity kindArity uniqueHash lookupRdrName ignoreInline symbolTyVarlocalVarSymbolexportedVarSymbolqualifiedNameSymbolfastStringTexttyConTyVarsDefnoTyVarstakeModuleUniquesplitModuleUnique base62ToIsplitModuleNamedropModuleNamesAndUniquedropModuleNamesdropModuleNamesCorrecttakeModuleNamesdropModuleUnique cmpSymbol sepModNames sepUnique mungeNames qualifySymbolisQualifiedSym isQualified wrapParens isParened isDictionaryisMethod isInternalisWorkerisSCSel stripParensstripParensSym desugarModule gHC_VERSIONsymbolFastStringshowCBsignoreCoreBinds findVarDeffindVarDefMethoddictionarySymbols methodSymbolscoreBindSymbols simplesymbolbinders expandVarTypeisEmbeddedDictExprisEmbeddedDictVarisEmbeddedDictType isPrelEqPred isPrelEqTyCon isOrdPred isNumericPred isPredExpr isPredVar isPredTypeanyFdefaultDataConsisEvVar elabRnExprcanonSelectorChainsbuildCoherenceObligcoherenceObligToRefcoherenceObligToRefE withWiredInprependGHCRealQual isFromGHCReal $fNFDataVar $fNFDataType $fNFDataTyCon $fNFDataClass $fShowTyCon $fShowClass $fShowVar $fShowName$fFixpointType$fFixpointName $fFixpointVar$fHashableDataCon$fHashableClass$fHashableTyCon $fHashableVar $fSymbolicVar$fSymbolicName$fSymbolicClass$fSymbolicTyCon$fSymbolicFastString$fLocVar$fHashableSrcSpan$fOutputableHashSet $fHashableLoc$fOutputableHashableType$fOrdHashableType$fEqHashableType$fEqLoc$fOrdLoc $fShowLocStatusSafeUnsafeErrorCrashAnnMapAnntypeserrorsstatussptypeshscolourhsannottokeniseWithLoc srcModuleNamebreakS $fShowAnnMap $fShowLit$fShowAnnotation $fEqStatus $fOrdStatus $fShowStatus CoreVisitorenvFbindFexprF CBVisitablefreeVarsreadVarsletVarsliterals coreVisitor$fCBVisitableAltCon$fCBVisitableAlt$fCBVisitableExpr$fCBVisitableBind$fCBVisitableListVariance Invariant Bivariant Contravariant Covariant VarianceInfo flipVariancemakeTyConVariance$fPPrintVariance$fNFDataVariance$fBinaryVariance$fMonoidVariance$fSemigroupVariance $fEqVariance$fDataVariance$fShowVariance$fGenericVariance$fHashableVarianceMSpecctorMapmeasMapcmeasMapimeasKVProfKVKindRecBindE NonRecBindE TypeInstE PredInstELamECaseELetEProjectEOutputOo_varso_typeso_templso_botso_resultAnnotAnnUseAnnDefAnnRDfAnnLocAnnInfoAIHoleInfohtypehlochenvinfoRClassrcNamercSupersrcTyVars rcMethodsCMeasureCMcNamecSort MeasureKind MsReflect MsMeasureMsLiftedMsClass MsAbsMeasure MsSelector MsChecker UnSortedExpr UnSortedExprsMeasureMmsNamemsSortmsEqnsmsKind msUnSortedDefmeasurectordsortbindsbodyBodyEPRRTEnvRTE typeAliases exprAliasesModTypeTarget SrcImport SpecImportModNameCinfoCici_locci_errci_var ErrorResult DiagnosticsWarningAREnvREnvreGlobalreLocal UReftableofUReftRTypeRepty_varsty_predsty_bindsty_infoty_reftsty_argsty_resRTAliasRTArtNamertTArgsrtVArgsrtBody HasDataDeclNoDeclHasDecl DataDeclKindDataUser DataReflectedSizeFun IdSizeFun SymSizeFunDataCtordcNamedcTyVarsdcThetadcFieldsdcResultDataNameDnNameDnConDataDecltycName tycTyVarstycPVarstycDCons tycSrcPostycSFun tycPropTytycKindHAxiomAxiomanamernameabindsatypesalhsarhs MethodTypeMT tyInstancetyClassRDEnvDEnvRISig RIAssumedRILawsRILrilName rilSupers rilTyArgsrilEqusrilPos RInstanceRIriclassrityperisigsOkRT TyConableisFunisListisTupleppTyconisClassisEmbeddedDictisEqualisOrdClsisEqClsisNumCls isFracClsSubsTysubt SpecRTAlias BareRTAlias BareRTEnv SpecRTEnv LocSpecType LocBareType SpecRTVarBRPropRRPropSpecPropSpecRepSpecTypeBareTypePrTypeRReftRPVarBPVarRSortBSortRRTypeBRTypeUReftMkUReftur_reftur_predHSegHBindHVarhs_addrhs_valWorldRTPropRefRProprf_argsrf_bodyRTVInfo RTVNoInfo rtv_is_polrtv_namertv_kind rtv_is_valRTVar ty_var_value ty_var_infoRTypeRVarRFunRAllTRAllPRAppRAllERExRExprArgRAppTyRRTyRHolert_varrt_reftrt_bindrt_rinfort_inrt_out rt_tvbindrt_tyrt_ref rt_pvbindrt_tyconrt_argsrt_pargs rt_allargrt_exargrt_argrt_resrt_envrt_oblPVURTVU TyConInfovarianceTyArgsvariancePsArgs sizeFunctionRTyConrtc_tcrtc_infoBTyConbtc_tc btc_classbtc_promRTyVarRTVBTyVarBTVRelExprERBasic ERChecked ERUnChecked PredicatePrUsedPVarPVKindPVPropPVHPropPVarPVpnameptypepargpargs TargetVarsAllVarsOnlyDataConPdcpLocdcpCon dcpFreeTyVars dcpFreePred dcpTyConstrs dcpTyArgsdcpTyRes dcpIsGadt dcpModuledcpLocETyConPtcpLoctcpContcpFreeTyVarsTy tcpFreePredTy tcpVarianceTs tcpVariancePs tcpSizeFunLMaplmVarlmArgslmExprLogicMapLM lmSymDefs lmVarSymsPPEnvPPppPsppTyVarppShortppDebugRFInfopermitTCTyConMaptcmTyRTytcmFIRTy tcmFtcArityBScope defRFInfo classRFInfoclassRFInfoTypemkRFInfoppEnv ppEnvShort toLogicMap eAppWithMappvTypepvars rtyVarTypetyVarVarmkBTyConisBoolisRVar isClassBTyCon rTyConPVs rTyConPropVsisPropPVisEqType isClassTypeisEmbeddedClassdefaultTyConInfo ignoreOblig makeRTVar mapTyVarValue dropTyVarInfo setRtvPol rTVarToBindrPropP getMethodTypeszFunhasDecldataNameSymbol mapRTAVars lmapEAlias fromRTypeRep toRTypeRepmkArrow bkArrowDeepbkArrow safeBkArrowmkUnivs bkUnivClassbkUniv bkUnivClass'bkClassrFunrFun' rFunDebugrClsrRCls addInvCondpApppappSym mapExprReft isTrivialmapReftemapReft foldRTypeisBase hasHoleTymapReftMmapPropMfoldReft foldReft' efoldReft mapRFInfomapBotmapBindofRSorttoRSort insertsSEnv rTypeValueVar rTypeReftstripRTypeBase topRTypeBase mkWarning mkDiagnosticsemptyDiagnosticsnoErrors allWarnings allErrors printWarningisTarget isSrcImport isSpecImport getModName getModStringqualifyModName ordSrcSpan emptyKVProf updKVProfholeisHolehasHole liquidBegin liquidEnd $fShowDataCon$fPPrintTyThing $fOrdDataCon $fOrdTyCon$fPPrintDataCon$fSymbolicDataCon$fSubableWithModel$fSymbolicModuleName$fNFDataTError$fBinaryRFInfo$fNFDataRFInfo$fHashableRFInfo $fShowLMap$fSemigroupLogicMap$fMonoidLogicMap$fNFDataPVKind$fBinaryPVKind $fPPrintPVar$fHashablePVar $fNFDataPVar $fBinaryPVar $fOrdPVar$fEqPVar $fSubablePVar$fPPrintPredicate$fReftablePredicate$fSubablePredicate$fSemigroupPredicate$fMonoidPredicate$fNFDataPredicate$fBinaryPredicate $fEqPredicate$fPPrintRelExpr$fBinaryRelExpr$fPPrintBTyVar$fSymbolicBTyVar$fNFDataBTyVar$fHashableBTyVar$fBinaryBTyVar$fIsStringBTyVar $fOrdBTyVar $fEqBTyVar$fPPrintRTyVar$fSymbolicRTyVar$fNFDataRTyVar $fLocBTyCon $fShowBTyCon$fPPrintBTyCon$fFixpointBTyCon $fOrdBTyCon $fEqBTyCon$fNFDataBTyCon$fSymbolicBTyCon$fBinaryBTyCon$fBinaryRTVInfo$fNFDataRTVInfo $fPPrintRTVar $fNFDataRTVar $fBinaryRTVar $fEqRTVar $fNFDataRef $fBinaryRef $fPPrintRef $fNFDataRType $fBinaryRType $fShowRTVar$fSubableUReft$fExpressionUReft$fReftableUReft $fBinaryUReft $fNFDataUReft $fMonoidUReft$fSemigroupUReft$fSubableRType $fSubableRef$fTyConableBTyCon$fTyConableLocated$fTyConableSymbol$fTyConableTyCon$fPPrintRILaws$fBinaryRILaws $fBinaryRISig $fPPrintRISig$fBinaryRInstance$fPPrintRInstance $fShowAxiom$fPPrintDataName$fSymbolicDataName$fShowDataName $fLocDataName$fBinaryDataName$fHashableDataName $fLocDataCtor$fBinaryDataCtor$fPPrintSizeFun$fBinarySizeFun$fNFDataSizeFun $fShowSizeFun$fShowTyConInfo$fNFDataTyConInfo$fDefaultTyConInfo $fShowRTyCon$fPPrintRTyCon$fFixpointRTyCon $fEqRTyCon$fTyConableRTyCon$fNFDataRTyCon$fSymbolicRTyCon $fLocDataConP $fLocTyConP$fBinaryDataDeclKind$fNFDataDataDeclKind$fSymbolicDataDecl$fShowDataDecl $fLocDataDecl $fOrdDataDecl $fEqDataDecl$fBinaryDataDecl$fPPrintHasDataDecl$fBinaryRTAlias $fUReftable()$fUReftableUReft $fPPrintAREnv$fFunctorAREnv $fNFDataAREnv $fMonoidAREnv$fSemigroupAREnv$fMonoidDiagnostics$fSemigroupDiagnostics $fPPrintCinfo $fNFDataCinfo $fLocCinfo $fShowCinfo$fFixpointCinfo$fHashableModType$fSymbolicModName$fPPrintModName$fHashableModName$fSemigroupRTEnv $fMonoidRTEnv $fSubableBody $fPPrintBody $fBinaryBody $fSubableDef $fPPrintDef $fBinaryDef$fBifunctorDef$fBinaryMeasureKind$fSubableMeasure $fShowMeasure$fPPrintMeasure$fBinaryMeasure$fBifunctorMeasure $fLocMeasure$fShowCMeasure$fPPrintCMeasure$fBinaryRClass$fPPrintRClass$fPPrintHoleInfo$fFunctorHoleInfo$fNFDataAnnInfo$fSemigroupAnnInfo$fMonoidAnnInfo $fNFDataAnnot$fSemigroupOutput$fMonoidOutput$fPPrintOutput$fPPrintKVKind$fNFDataKVKind$fHashableKVKind$fNFDataKVProf$fPPrintKVProf $fMonoidMSpec$fSemigroupMSpec $fShowMSpec $fPPrintMSpec$fBifunctorMSpec $fDataMSpec$fGenericMSpec$fFunctorMSpec$fGenericKVProf$fGenericKVKind $fEqKVKind $fOrdKVKind $fShowKVKind $fDataKVKind$fGenericOutput$fFunctorOutput $fDataAnnot$fGenericAnnot$fFunctorAnnot $fDataAnnInfo$fGenericAnnInfo$fFunctorAnnInfo $fEqRClass $fShowRClass$fFunctorRClass $fDataRClass$fGenericRClass$fHashableRClass$fDataCMeasure$fGenericCMeasure$fFunctorCMeasure $fEqMeasure $fDataMeasure$fGenericMeasure$fFunctorMeasure$fHashableMeasure$fEqMeasureKind$fOrdMeasureKind$fShowMeasureKind$fDataMeasureKind$fGenericMeasureKind$fHashableMeasureKind $fShowDef $fDataDef $fGenericDef$fEqDef $fFunctorDef $fHashableDef $fShowBody $fDataBody $fGenericBody$fEqBody$fHashableBody $fEqModName $fOrdModName $fShowModName$fGenericModName $fDataModName $fEqModType $fOrdModType $fShowModType$fGenericModType $fDataModType $fEqCinfo$fGenericCinfo$fEqDiagnostics $fEqWarning $fShowWarning $fEqRTAlias $fDataRTAlias$fGenericRTAlias$fFunctorRTAlias$fHashableRTAlias$fShowHasDataDecl$fDataDataDecl$fGenericDataDecl$fHashableDataDecl$fEqDataDeclKind$fDataDataDeclKind$fGenericDataDeclKind$fShowDataDeclKind$fHashableDataDeclKind$fGenericTyConP $fDataTyConP$fGenericDataConP$fDataDataConP$fGenericRTyCon $fDataRTyCon$fGenericTyConInfo$fDataTyConInfo $fDataSizeFun$fGenericSizeFun $fEqSizeFun$fHashableSizeFun$fDataDataCtor$fGenericDataCtor $fEqDataCtor$fHashableDataCtor $fEqDataName $fOrdDataName$fDataDataName$fGenericDataName$fShowMethodType$fSemigroupDEnv $fMonoidDEnv $fShowDEnv $fFunctorDEnv $fEqRInstance$fGenericRInstance$fFunctorRInstance$fDataRInstance$fShowRInstance$fHashableRInstance $fEqRISig$fGenericRISig$fFunctorRISig $fDataRISig $fShowRISig$fHashableRISig $fEqRILaws $fShowRILaws$fFunctorRILaws $fDataRILaws$fGenericRILaws$fHashableRILaws $fEqUReft$fGenericUReft $fDataUReft$fFunctorUReft$fFoldableUReft$fTraversableUReft$fHashableUReft$fGenericWorld $fDataWorld $fGenericHSeg $fDataHSeg $fEqRType$fGenericRType $fDataRType$fFunctorRType$fHashableRType$fEqRef $fGenericRef $fDataRef $fFunctorRef $fHashableRef$fGenericRTVar $fDataRTVar$fHashableRTVar$fGenericRTVInfo $fDataRTVInfo$fFunctorRTVInfo $fEqRTVInfo$fHashableRTVInfo$fGenericBTyCon $fDataBTyCon$fHashableBTyCon$fGenericRTyVar $fDataRTyVar $fShowBTyVar$fGenericBTyVar $fDataBTyVar $fEqRelExpr $fShowRelExpr $fDataRelExpr$fGenericRelExpr$fGenericPredicate$fDataPredicate$fHashablePredicate $fGenericPVar $fDataPVar $fShowPVar $fFunctorPVar$fGenericPVKind $fDataPVKind$fFunctorPVKind$fFoldablePVKind$fTraversablePVKind $fShowPVKind$fShowLogicMap $fShowPPEnv$fGenericRFInfo $fDataRFInfo $fShowRFInfo $fEqRFInfoFilterReportErrorsArgs errorReporterfilterReporterfailurecontinuematchingFiltersfiltersFilter StringFilter AnyFilterpprManyOrderedpprintLongList pprintSymbolrtypeDocfilterReportErrors getFilters reduceFiltersfilterReportErrorsWithdefaultFilterReporter $fPPrintUReft $fPPrintTidy $fPPrintRTEnv$fPPrintRTAlias $fPPrintRType$fPPrintLogicMap $fPPrintLMap $fShowAnnInfo$fPPrintAnnInfo $fPPrintAnnot$fShowPredicate $fPPrintClass $fPPrintType $fPPrintTyCon $fPPrintName $fPPrintBind $fPPrintExpr $fPPrintVar$fPPrintSourceError $fEqFilter $fOrdFilter $fShowFilterTagEnvTagKey defaultTag memTagEnv makeTagEnvgetTag inlineAuxshowTy $fEqCoercion$fEqType $fSubstTym$fSubstTyCoAxiomRule$fSubstTyUnivCoProvenance$fSubstTyCoAxiom $fSubstTyRole$fSubstTyCoercion $fSubstTyType $fEqVarBndrSpan SpanStackpushsrcSpanshowSpan $fShowSpanPatternPatBind PatReturn PatProject PatSelfBindPatSelfRecBindpatE1patXpatE2patMpatDctpatTyApatTyBpatFFpatEpatTypatRetpatXEpatCtorpatBindspatIdxliftlower$fPPrintPatternSubablesubsubTyTyConOccurrenceTyConOccposOccnegOcc OccurrenceMapgetNonPositivesTyConmakeOccurrencesmakeOccurrencefindOccurrenceisRecursivenewTyCondataConImplicitIdssubVar substTysWithmapTypestringClassArg$fOutputableTyConOccurrence$fSemigroupTyConOccurrence$fMonoidTyConOccurrence$fOutputableHashMap $fSubableType $fSubableBind $fSubableVar $fSubableAlt$fSubableCoercion $fSubableExpr$fEqTyConOccurrence PositionsPosppospnegpunknownFreeVarstrengthenDataConTypepdVarfindPVaruRTypeuRType' uRTypeGenuPVaruReftuToprVarrTyVar updateRTVar rTVarInfo kindToRType isValKindbTyVar symbolRTyVar bareRTyVar normalizePdsrExrAppgApp pdVarReft tyConBTyConstrengthenRefTypeGen strengthen quantifyRTyquantifyFreeRTy addTyConInfo appRTyConfamInstTyConType famInstArgs isNumeric generalize allTyVars allTyVars' freeTyVars tyClassessubsTyVarsMeetsubsTyVarsNoMeetsubsTyVarNoMeet subsTyVarMeetsubsTyVarMeet'subts subvUReft subvPredicateofType bareOfType dataConReftisBaseTy dataConMsRefttoTyperTypeSortedReft rTypeSort applySolutionshiftVVtypeSorttypeUniqueSymbolexpandProductType classBinds makeNumEnv isDecreasing makeDecrType isSizeable makeLexRefa mkTyConInfotyVarsPosition $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$fSubsTySymbolSymbolRef$fSubsTySymbolSymbolRType$fSubsTytvtyReft$fSubsTytvtySymbol$fSubsTytvty()$fSubsTyBTyVarRTypeRTVar$fSubsTyBTyVarRTypeBTyVar$fSubsTyRTyVarRTypeRTVar$fSubsTyRTyVarRTypeRTyVar$fHashableRTyCon$fHashableRTyVar $fOrdRTyVar $fEqRTyVar$fFixpointClass$fFixpointList$fReftableRType$fReftableRType0 $fReftableRef$fReftableRef0$fReftableRef1$fReftableRef2$fReftableRef3$fFreeVarBTyConBTyVar$fFreeVarRTyConRTyVar $fMonoidRef$fSemigroupRef $fMonoidRType$fSemigroupRType$fSemigroupPositions$fMonoidPositionsResultresulterrorToUserError cinfoError tidySpecType panicError$fExceptionList$fPPrintCtxError$fPPrintCtxError0$fResultFixResult$fResultTError $fResultList$fResultTError0 makeTyConInfodataConPSpecTypedataConWorkRep dataConTyreplacePredsWithRefs pVartoRConc pvarRType replacePreds substPVarpredType substParg pappAritypappSort$fShowDataConP$fPPrintDataConP $fShowTyConP$fPPrintTyConP isWiredIn isWiredInNamedcPrefixwiredSortedSyms dictionaryVardictionaryTyVardictionaryBindcombineProofsNameproofTyConName wiredTyCons wiredDataConsisDerivedInstance meetVarTypes Freshablefreshtruerefresh refreshTy refreshVV refreshArgsrefreshArgsSub refreshHoles$fFreshablemRType$fFreshablemUReft$fFreshablemReft$fFreshablemList$fFreshablemExpr$fFreshablemSymbolmakeDictionariesmakeDictionary dfromListdmapty fromRISigdmapdinsertdlookupdhasinfoRRBEnvRBEnvRRBoundRBoundBoundbnametyvarsbparamsbargsbbody makeBound$fBifunctorBound$fFunctorBound $fPPrintBound $fShowBound $fEqBound$fHashableBound $fBinaryBound $fDataBound$fGenericBoundGhcSpecSP_gsSig_gsQual_gsData_gsName_gsVars_gsTerm_gsRefl_gsLaws_gsImps _gsConfig_gsLSpecGhcSrcSrc _giTarget _giTargetMod_giCbs_gsTcs_gsCls _giDerVars _giImpVars _giDefVars _giUseVars _gsExports_gsFiTcs_gsFiDcs _gsPrimTcs _gsQualImps _gsAllImps _gsTyThingsTargetDependenciesgetDependencies LiftedSpecliftedMeasures liftedImpSigs liftedExpSigs liftedAsmSigs liftedSigsliftedInvariantsliftedIaliases liftedImportsliftedDataDeclsliftedNewtyDecls liftedAliasesliftedEaliases liftedEmbedsliftedQualifiers liftedLvars liftedAutoisliftedAutosizeliftedCmeasuresliftedImeasures liftedClasses liftedClawsliftedRinstance liftedIlaws liftedDsizeliftedDvariance liftedBounds liftedDefs liftedAxeqsSpecmeasuresimpSigsexpSigsasmSigssigs localSigsreflSigs invariantsialiasesimports dataDecls newtyDeclsincludesaliasesealiasesembeds qualifierslvarslazyrewrites rewriteWithfailsreflectsautoishmeashboundsinlinesignoresautosizepragmas cmeasures imeasuresclassesclaws relationalasmRel termexprs rinstanceilaws dvariancedsizeboundsdefsaxeqsBareSpec MkBareSpec getBareSpec SpecMeasureBareDef BareMeasureVarOrLocSymbol LawInstancelilNameliSupers lilTyArgslilEquslilPos GhcSpecLawsSpLaws gsLawDefs gsLawInst GhcSpecReflSpRefl gsAutoInst gsHAxioms gsImpAxioms gsMyAxioms gsReflects gsLogicMap gsWiredReft gsRewritesgsRewritesWith GhcSpecTermSpTermgsStTerm gsAutosizegsLazygsFail gsNonStTerm GhcSpecNamesSpNames gsFreeSymsgsDconsPgsTconsP gsTcEmbedsgsADTs gsTyconEnv GhcSpecDataSpDatagsCtorsgsMeas gsInvariants gsIaliases gsMeasures gsUnsorted GhcSpecSigSpSiggsTySigs gsAsmSigs gsRefSigsgsInSigs gsNewTypesgsDicts gsMethodsgsTexprs gsRelationgsAsmRel GhcSpecQualSpQual gsQualifiers gsRTAliases GhcSpecVarsSpVar gsTgtVars gsIgnoreVarsgsLvars gsCMethods TargetSpecgsSiggsQualgsDatagsNamegsVarsgsTermgsReflgsLawsgsImpsgsConfigQImports qiModulesqiNames TargetSrcgiTarget giTargetModgiCbsgsTcsgsCls giDerVars giImpVars giDefVars giUseVars gsExportsgsFiTcsgsFiDcs gsPrimTcs gsQualImps gsAllImps gsTyThings TargetInfogiSrcgiSpecemptyLiftedSpecdropDependencyisPLEVar isExportedVar toTargetSrc fromTargetSrc toTargetSpec toBareSpec fromBareSpec toLiftedSpecunsafeFromLiftedSpec$fBinaryEquation$fMonoidGhcSpecVars$fSemigroupGhcSpecVars$fMonoidGhcSpecSig$fSemigroupGhcSpecSig$fMonoidGhcSpecTerm$fSemigroupGhcSpecTerm$fMonoidGhcSpecRefl$fSemigroupGhcSpecRefl$fHasConfigTargetSpec$fHasConfigTargetInfo $fMonoidSpec$fSemigroupSpec $fPPrintSpec $fBinarySpec$fMonoidBareSpec$fSemigroupBareSpec$fMonoidTargetDependencies$fSemigroupTargetDependencies$fHasConfigGhcSpec$fEqTargetDependencies$fShowTargetDependencies$fGenericTargetDependencies$fBinaryTargetDependencies$fEqLiftedSpec$fGenericLiftedSpec$fShowLiftedSpec$fHashableLiftedSpec$fBinaryLiftedSpec$fGenericBareSpec$fShowBareSpec$fBinaryBareSpec $fGenericSpec $fShowSpec$fShowTargetSpec$fShowGhcSpecLaws$fShowLawInstance$fShowGhcSpecRefl$fShowGhcSpecTerm$fShowGhcSpecNames$fShowGhcSpecData$fShowGhcSpecSig$fShowGhcSpecQual$fShowGhcSpecVars$fShowQImports$fShowTyConMapmkMmkMSpec'mkMSpec dataConTypes defRefTypebodyPredMeasEnv meMeasureSpec meClassSymsmeSyms meDataCons meClasses meMethodsmeCLaws DataConMapTycEnvtcTyCons tcDataCons tcSelMeasures tcSelVars tcTyConMaptcAdts tcDataConMaptcEmbstcNameSigEnvsigEmbs sigTyRTyMap sigExportssigRTEnv TyThingMap LocalVarsREreLMapreSyms_reSubst _reTyThingsreCfg reQualImps reAllImps reLocalVars reGlobSymsreSrcPlugTVHsTVLqTVGenTVRawTVModSpecsplugSrc varSortedReftvarRSort failMaybe$fPPrintPlugTV$fHasConfigEnv$fMonoidMeasEnv$fSemigroupMeasEnv $fShowPlugTV rewriteBindstransformRecExprtransformScope outerScTr innerScTrsetIdTRecBound isIdTRecBound$fFreshableVar$fFreshableUnique$fFreshableInt anormalize$fShowStableId$fHashableStableId $fEqStableId$fHasConfigAnfEnv $fFunctorDsM $fMonadDsM$fMonadUniqueDsM$fApplicativeDsMvmap runMapTyVarsisKind matchKindArgs mkVarExprjoinVarsimpleSymbolVar hasBoolResultelaborateSpecTypefixExprToHsExpr$fCorecursiveRType$fRecursiveRType$fFunctorRTypeF ResolveSym resolveLocSymQualifyqualifyLookupmakeEnvsrcVars qualifyTopqualifyTopDummylookupGhcNamedVar lookupGhcVarlookupGhcDataConlookupGhcTyConlookupGhcDnTyCon knownGhcType knownGhcVar knownGhcTyConknownGhcDataConunQualifySymbol errResolvemaybeResolveSym ofBareType ofBareTypeE coSubRReftofBPVar txRefSortresolveLocalBindspartitionLocalBinds$fQualifyRType$fQualifyRType0$fQualifyQualifier$fQualifyUReft $fQualifyExpr$fQualifyRTAlias $fQualifySpec $fQualify(,)$fQualifyHashMap$fQualifyDataDecl$fQualifyDataCtor$fQualifyMeasure $fQualifyDef$fQualifyMeasure0$fQualifyRTyCon$fQualifyTyConInfo $fQualifyBody$fQualifyMaybe $fQualifyList$fQualifyLocated$fQualifySymbol$fQualifyEquation$fQualifySizeFun$fQualifyTyConP$fQualifyTyConMap$fResolveSymSymbol$fResolveSymDataCon$fResolveSymTyCon$fResolveSymVar dataConMapmakeDataConCheckermakeDataConSelectoraddClassEmbeds makeDataDeclsmeetDataConSpec makeConTypes dataDeclSizemakeRecordSelectorSigs normalize logicTypeinlineSpecTypemeasureSpecType weakenResult runToLogicrunToLogicWithBoolBinds coreToDef coreToFun coreToLogicmkLitmkImkS $fShowExpr $fSimplifyAlt$fSimplifyBind$fSimplifyExprliteralFRefType literalFReft literalConstDstartendbinder DiffCheckDCnewBinds oldOutputnewSpec checkedVarsslicethincoreDeps dependsOn filterBindscoreDefs saveResult$fFromJSONOutput$fToJSONOutput$fFromJSONAnnInfo$fToJSONAnnInfo $fFromJSONDoc $fToJSONDoc$fFromJSONFixResult$fFromJSONSourcePos$fToJSONSourcePos$fPPrintDiffCheck$fOrdDefmkOutputannotate annErrors$fToJSONAnnMap $fToJSONLoc$fToJSONStatus $fToJSONAssoc$fToJSONAnnErrors$fToJSONAnnot1 OutputResultorHeader orMessagesconfiggetOptsprintLiquidHaskellBannercanonicalizePathsmkOpts withPragmas defConfig reportResult addErrors$fShowCtxError$fFixpointFixResultREq=*= compareRType $fREqLocated $fREqExpr $fREqReft $fREqUReft$fREqRef $fREqRTypesimplifyBounds tidyErrorsplitXRelatedRefs $fIsFreexterminationVars$fFunctorResult$fApplicativeResult $fMonadResult$fSemigroupResult$fMonoidResult$fFoldableFunInfo$fFunctorFunInfo$fMonoidFunInfo$fSemigroupFunInfo $fEqParam $fShowResult$fShowTermErrorPspecMeasAssmAsrtLAsrtAsrtsImptDDeclNTDecl RelationalAssmRelCLawsILawsRInstInclInvtUsingAliasEAliasEmbedQualifLVarsLazyFailRewrite RewritewithInstsHMeasReflectInlineIgnoreASizeHBoundPBoundPragmaCMeasIMeasVariaDSizeBFixDefineBPspechsSpecificationPspecSpecificationP singleSpecP parseTest'parseSymbolToLogic $fPPrintPspec $fDataPspec $fShowPspec$fShowParamComp $fEqPcScope $fShowPcScope LiquidQuoteliquidQuoteSpecSimpl Simplified FoundExprArg FoundHolelqlqDec throwErrorInQ mkSpecDecs symbolNamesimplifyBareTypesimplifyBareType'simplifyBareType''filterExprArgs locSourcePos dataToExpQ' textToExpQextQ $fMonadSimpl$fApplicativeSimpl$fDataLiquidQuote$fFunctorSimplcheckLawInstances classCons derivedVars importVars updLiftedSpec clearSpeckeepRawTokenStream allImportsqualifiedImportslookupTyThingsavailableTyCons availableVarsmodSummaryHsFilecheckFilePragmasmakeFamInstEnvextractSpecCommentsextractSpecQuotes' parseSpecFile makeLogicMap pprintCBs$fResultSourceError$fPPrintTargetVars$fShowTargetInfo$fPPrintTargetInfo$fPPrintTargetSpecFEnvFEfeBindsfeEnvfeIdEnv RTyConIAl RTyConInvHEnvCGInfofEnvhsCshsWfsfixCsfixWfs freshIndexebindsannotMap tyConInfonewTyEnv termExprs specLVarsspecLazy specTmVarsautoSize tyConEmbedkutskvPackscgLitscgConstscgADTstcheck cgiTypeclass pruneRefs logErrorskvProfrecCount bindSpansallowHOghcI dataConTysunsortedFixWfCFixSubCWfCSubCSubRsenvlhsrhsobligref LConstraintLCCGEnvCGEcgLocrenvsyenvdenvlitEnvconstEnvfenvrecsinvsrinvsialgrtysassmsintysembtgEnvtgKeytreclcbforallcbholeslcscerrcgInfocgVarCG getLocation getTemplates fromListHEnvelemHEnv mkRTyConInv mkRTyConIAl addRTyConInvaddRInvremoveInvariantrestoreInvariantmakeRecInvariants insertsFEnvinitFEnv$fSemigroupLConstraint$fMonoidLConstraint $fNFDataRInv $fNFDataFEnv $fNFDataCGEnv $fShowCGEnv $fPPrintCGEnv$fHasConfigCGEnv $fNFDataWfC $fPPrintWfC $fNFDataSubC $fPPrintSubC$fNFDataCGInfo$fPPrintCGInfo $fShowRInvgiQuals useSpcQuals fixConfig cgInfoFInfo canRewrite refinementEQsrefreshArgsTop freshTyType freshTyExpraddKutstrueTy$fFreshableStateTInteger fromListREnv insertREnv lookupREnvlocalBindsOfType toListREnvextendEnvWithVV addBindersrTypeSortedReft'+= globalizeaddSEnvaddEEnv+++=-=?= setLocationsetBindsetRecssetTRecaddCaddPostaddW addWarningaddIdA boundRecVaraddLocA updateLocAaddA lookupNewTypeenvToSubTemplateAssertedAssumedInternalUnknown unTemplateaddPostTemplatesafeFromAsserted varTemplate topSpecType derivedVarextender$fPPrintTemplate$fFunctorTemplate$fFoldableTemplate$fTraversableTemplate$fShowTemplateTCheckTerminationCheck StrataCheckNoCheckmkTCheck doTermCheck makeTermEnvs makeDecrIndexrecType checkIndexunOConsconsCBSizedTysconsCBWithExprs $fShowTCheck consAssmRel consRelTop $fShowRelPredinitEnvinitCGIaddConstraintsconstraintToLogicsplitWsplitC panicUnboundcompileClasseselaborateClassDcpmakeClassAuxTypes specToBare measureToBare sliceSpecsmakePluggedSigmakePluggedDataCon makeRTEnv qualifyExpand cookSpecType cookSpecTypeEspecExpandType plugHoles$fExpandHashMap $fExpandList $fExpandMaybe $fExpand(,)$fExpandLocated $fExpandSpec $fExpandDef$fExpandMeasure$fExpandDataDecl$fExpandDataCtor $fExpandBody$fExpandRTAlias$fExpandRTAlias0 $fExpandRType$fExpandRType0 $fExpandUReft $fExpandReft $fExpandExprmakeInstanceLawsmakeHaskellAxioms wiredReflectsgenerateConstraintsconsEcaseEnv$fMonadFailIdentitycheckTargetInfomakeHaskellMeasuresmakeHaskellInlinesmakeHaskellDataDeclsmakeMeasureSelectorsmakeMeasureSpec'makeMeasureSpec varMeasuresmakeClassMeasureSpecmakeMethodTypes makeCLaws makeClassesmakeSpecDictionariesmakeDefaultMethodscheckTargetSrc checkBareSpeccheckTargetSpecloadLiftedSpecsaveLiftedSpecmakeTargetSpecplugin$fUnoptimise(,)$fUnoptimiseModSummary$fUnoptimiseDynFlags$fEqLiquidCheckException$fOrdLiquidCheckException$fShowLiquidCheckExceptiongeqghc-prim GHC.Classes==Eqfrom'&cmdargs-0.10.22-Bo66f0Kl3eE5G8AycK8y3n System.Console.CmdArgs.VerbosityQuietGHC.BaseStringbinary-0.8.9.1Data.Binary.ClassBinary ModuleInfoLH ModuleInfo EpaCommentTypecheckedModuleLHerrlin annotTokeniseclassifyjoinL rtc_pvarsSymbolppEnvDefTrue maybeParenSubstTy ToTypeable#Language.Fixpoint.Types.RefinementsReftfamInstTyConMbplainRTyConPVarsmkRApp refAppTyToFun cmpLexRef substRConGHC.Listheadtail Data.TuplefstsndmaxAritymakeDicTypeName RewriteRule_safeSimplifyPatTuplehasTuple replaceTuplefixCase substTupleisVarTupStableIdAnfEnvaeVarEnvnormalizeTopBindnormalizeForAllTysfreshNormalVar SpecTypeFRTypeFRAllPFRAppFcollectSpecTypeBinders okUnqualifiedlookupLocalVar lookupTyThingisParentModuleOfmatchImpGHC.RealmodCtorTypequalifyDataCtor DataPropDeclmakeFamInstEmbeds makeNumEmbeds resolveTyCons resolveDecls canonizeDeclscheckDataCtors GHC.MaybeNothingcheckDataCtorDupField checkDataDecldataConResultTy isMeasureArg normalizeAlts isBangInteger ghc-bignumGHC.Num.IntegerIntegerChkItvDeps assumeSpec varBounds meetSpanslineDiff diffLinesgetShiftsetShiftAssoc copyFileCreateParentDirIfMissing renderPandoc renderDirect topAndTailmkAnnMaprefTokentokAnnotvimAnnot_annsGHC.IOFilePath canonConfig parsePragmawriteResultStdoutresDocsLanguage.Fixpoint.Types.Errors FixResultCErrorpretty-1.1.3.6Text.PrettyPrint.HughesPJDoc cErrToSpanned expandVarDefsControl.Monad.Failfail ParamCompspecificationPparseWithError bareTypeP qualifySpecmkSpecspecP fallbackSpecP tyBindsRemPtyBindPrtAliasP cMeasurePbinderP dataCtorsPfTyConP binderIdR.extractSpecCommentTcDatatcAvailableTyConstcAvailableVars SpecComment'megaparsec-9.6.1-CSU4Snz6l3kDUBWV6d4zcsText.Megaparsec.Pos SourcePosllTargetllDeps mkLiquidLib LiquidLibaddLibDependencies libTargetlibDepsallDepsmkTcData mkSpecComment PipelineDatapdUnoptimisedCorepdTcDatapdSpecComments tcAllImportstcQualifiedImportstcResolvedNamesserialiseLiquidLibdeserialiseLiquidLibdeserialiseLiquidLibFromEPS pluginAbortInterfaceLocation DiskLocationSpecFinderResultfindRelevantSpecsfindCompanionSpec SpecFinderlookupInterfaceAnnotationslookupCompanionSpecconfigToRedundantDependenciesconfigSensitiveDependencies SpecNotFound SpecFoundLibFoundSearchLocationRInv useSigQuals useAlsQualsaddKVars updREnvLocal varTemplate' predsUnifyforallExprRefTypeplugMany renameRTArgs renameTys renameRTVArgsexpandBareSpecexprArggeneralizeWith expandExpr expandApp txExpToBind expToBindT graphExpand axiomTypemakeCompositionExpressionmakeAssumeTypegrabBody consClass consCBTopcconsEinstantiatePreds getExprDict subsTyReft consPattern cconsFreshE projectTypes freshPredRefargType makeSingleton strengthenTop varRefType otherwiseexprLoc isGenericVar coreToFun'makeMeasureSelector expandMeasure checkSizeFun checkRType checkMeasures makeGhcSpec makeGhcSpec0makeLiftedSpec1makeLiftedSpec0reflectedTyCons isEmbeddedresolveQParams addReflSigsmakeLiftedSpec isLocInFilemyRTEnvProcessModuleResult pmrClientLib pmrTargetInfo UnoptimiseLiquidCheckException Data.EitherEitherLeftcfgRef debugLogs GHC.IORefIORefdebugLogcustomDynFlags typecheckHookliquidHaskellCheckloadDependencies getLiquidSpec