h*F4                    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 1.9.0 (C) 2015-2016, University of Twente, 2016-2017, Myrtle Software Ltd, 2021, QBayLogic B.V., 2022, Google Inc.,BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred(13679:;<=?4 clash-ghcPrint deprecated flag warning4 clash-ghcDeprecated flag clash-ghc Use X instead56(C) 2020-2021, QBayLogic B.V., 2022 , Google Inc.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred"(13679:;<=?- clash-ghcEvaluate a term to WHNF.7 clash-ghcAttempt to apply the case-of-known-constructor transformation on a case expression. If no suitable alternative can be chosen, attempt to transform the case expression to try and expose more opportunities.8 clash-ghcAttempt to apply a transformation to a case expression to expose more opportunities for caseCon. If no transformations can be applied the case expression can only be neutral.9 clash-ghcGiven a predicate to check if an alternative is a match, find the best alternative that matches the predicate. Best is defined as being the most specific matching pattern (meaning DefaultPat is only used if no other pattern tried matches).(C) 2020, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred(13679:;<=? clash-ghcEvaluate a primitive with the given arguments. See NOTE [Evaluating primitives] for more information. clash-ghc)Evaluation function for forcing arguments clash-ghcThe primitive to evaluate clash-ghc'The arguments supplied to the primitive clash-ghc&The result of evaluating the primitive(C) 2020-2021, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred(13679:;<=?(C) 2020, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred(13679:;<=? 2 clash-ghcThe partial evaluator for the GHC front-end. For more details about the implementation see Clash.GHC.PartialEval.Eval for evaluation to WHNF and Clash.GHC.PartialEval.Quote for quoting to NF. Safe-Inferred(13679:;<=? : clash-ghcLike ;=, but returning a horizontally spaced SDoc instead of a list:textLines "a\nb"a $$ b<:=>(C) 2013-2016, University of Twente, 2016-2017, Myrtle Software Ltd, 2017-2022, Google Inc. 2021-2024, QBayLogic B.V.,BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred"(13679:;<=?Y? clash-ghc1Flatten a list type structure to a list of types.@ clash-ghcTry to determine boolean value by looking at constructor name of type.A clash-ghc4Returns string of (LitTy (StrTyLit s)) construction.B clash-ghcReturns string in Text form of (LitTy (StrTyLit s)) construction.C clash-ghc5Returns integer of (LitTy (NumTyLit n)) construction.D clash-ghc"Try to interpret a Type as an AttrE clash-ghcIf this type has an annotate type synonym, return list of attributes.F clash-ghcWrap given type in an annotation if it is annotated using the constructs defined in Clash.Annotations.SynthesisAttributes.G clash-ghcConverts GHC Type to a Clash Type. Strips newtypes and signals, with the exception of newtypes used as annotations (see: SynthesisAttributes).H clash-ghcGiven the type:  forall dom a0 a1 .. aN . Signal dom (a0, a1, .., aN) -> (Signal dom a0, Signal dom a1, .., Signal dom aN)  or the type  forall dom a0 a1 .. aN . (Signal dom a0, Signal dom a1, .., Signal dom aN) -> Signal dom (a0, a1, .., aN) Generate the term: dom. a0. a1. ..  aN. x -> x?In other words: treat "bundle" and "unbundle" primitives as id.I clash-ghcGiven the type: forall a. forall b. forall clk. (a -> b) -> Signal clk a -> Signal clk bGenerate the term: (a:*).(b:*)./(clk:Clock).(f : (Signal clk a -> Signal clk b)). (x : Signal clk a).f x J clash-ghcGiven the type: 'forall a. forall dom. a -> Signal dom aGenerate the term (a:*).(dom:Domain).(x:Signal dom a).xK clash-ghcGiven the type: forall dom. forall a. forall b. Signal dom (a -> b) -> Signal dom a -> Signal dom b Generate the term:  (dom:Domain).(a:*)./(b:*).(f : (Signal dom a -> Signal dom b)). (x : Signal dom a).f x L clash-ghcGiven the type: forall t.forall n.forall a.Vec n (Signal t a) -> Signal t (Vec n a) Generate the term:  (t:Domain).*(n:Nat)./(a:*).(vs:Signal t (Vec n a)).vs M clash-ghcGiven the type: forall f.forall a.forall b.forall dom.Applicative f => (a -> f b) -> Signal dom a -> f (Signal dom b) Generate the term:  (f:* -> *).(a:*).(b:*).(dom:Clock).(dict:Applicative f). (g:a -> f b).(x:Signal dom a).g x N clash-ghcGiven the type: forall (r :: Rep) (a :: TYPE Lifted) (b :: TYPE r). (a -> b) -> a -> bGenerate the term: (r:Rep)6(a:TYPE Lifted)./(b:TYPE r).(f : (a -> b)).(x : a).f xO clash-ghcGiven the type: ?forall a. forall dom. Signal dom (Signal dom a) -> Signal dom aGenerate the term (a:*).(dom:Domain).(x:Signal dom a).xP clash-ghcGiven the type: /forall a. CallStack -> (HasCallStack => a) -> aGenerate the term (a:*).7(callStack:CallStack).(f:HasCallStack => a).f callStackQ clash-ghcGiven the type: forall a. a -> aGenerate the term /(a:*).(x:a).xR clash-ghcGiven type type: forall (r :: RuntimeRep) (o :: TYPE r).(State# RealWorld -> o) -> oGenerate the term: (r:RuntimeRep).3(o:TYPE r).(f:State# RealWord -> o) -> f realWorld#S clash-ghcGiven type type: forall (n :: Nat) (a :: Type) .Knownnat n => Typeable a => (BitVector n -> a) -> BitVector n -> aGenerate the term: (n:Nat).1(a:TYPE r).(kn:KnownNat n).(f:a -> BitVector n).fT clash-ghcGiven the type: 7forall (name :: Symbol) (a :: Type) . a -> (name ::: a)Generate the term: (name:Symbol).(a:Type).(x:a) ->  TICKxU clash-ghcGiven the type: %forall (a :: Type) . String -> a -> aGenerate the term: !/(a:Type).(ctx:String).(x:a) -> xVWXYZ[\]^_`abcde(C) 2013-2016, University of Twente, 2016-2017, Myrtle Software Ltd 2022-2024, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred%&'(13679:;<=? 2 f clash-ghc&Stores modules with easy binder lookupg clash-ghc?Data structure tracking loaded binders (and their related data)h clash-ghc Binder + expression it's bindingi clash-ghc$Type class dict projection functionsj clash-ghcBinders with missing unfoldingsk clash-ghcPrimitives; either an primitive data structure or a path to a directory containing json filesl clash-ghcCustom data representationsm clash-ghcLoaded module cachen clash-ghcCollects free variables in an expression, and splits them into "normal" free variables and class ops.o clash-ghc*Add a binder to the appropriate fields of g, and recursively load binders found in the optionally supplied expression.p clash-ghcGiven a list of top-level binders, recursively load all the binders, primitives, and type classes it is using. (Exported function.)q clash-ghc Try to fetch a IfaceDecl from a f. If a module has not been loaded before, load it using GHC. Additionally, add annotations mentioned in the module to g.r clash-ghcGet the s& of an annotation target if it exists.q clash-ghcBinder to load clash-ghcDeclaration, if found tpugvhijklm(C) 2021-2022, QBayLogicBSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred'(13679:;<=?# clash-ghcChecks whether MonoLocalBinds and MonomorphismRestricton language extensions are enabled or not in modules. clash-ghcChecks whether MonoLocalBinds and MonomorphismRestriction language extensions are enabled when generating the HDL directly e.g. in GHCi. modules. clash-ghc Module name clash-ghcstring passed with -main-is clash-ghcThrows exception if -main-is was set, but no such top entity was found. Otherwise, returns main top entity and all top entities (transitively) used in the main top entity.  (C) 2013-2016, University of Twente, 2016-2017, Myrtle Software Ltd, 2017-2024, Google Inc. 2021-2024, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred%&'(13679:;<=>?3Fw clash-ghc!Search databases for given modulex clash-ghcLoad a module from a Haskell file. Function does NOT look in currently loaded modules.y clash-ghcGiven a type that represents the RHS of a KnownConf type family instance, unpack the fields of the DomainConfiguration and make a VDomainConfiguration.z clash-ghcGiven a set of bindings, make explicit non-recursive bindings and recursive binding groups.Needed because: 1. GHC does not preserve this information in interface files, 2. Binders in Clash's BindingsMap are not allowed to be mutually recursive, only self-recursive. 3. Clash.GHC.GenerateBindings.mkBindings turns groups of mutually recursive bindings into self-recursive bindings which can go into the BindingsMap.{ clash-ghc!Find annotations by given targets| clash-ghcFind all annotations of a certain type in all modules seen so far.} clash-ghc:Find all annotations belonging to all binders seen so far.~ clash-ghcFind annotations of type  DataReprAnn and convert them to  DataRepr' clash-ghcFind synthesize annotations and make sure each binder has no more than a single annotation. clash-ghcFind test bench annotations and return a map tying top entities to their test benches. If there is a binder called  testBench _without_ an annotation it assumed to belong to a binder called  topEntity.. If the latter does not exist, the function  testBench is left alone. clash-ghcCreate a fully qualified name from a var, excluding package. Example output: "Clash.Sized.Internal.BitVector.low. clash-ghcFind primitive annotations bound to given binders, or annotations made in modules of those binders. clash-ghc"Remove all strictness annotations:Remove strictness annotations from data type declarations (only works for data types that are currently being compiled, i.e., that are not part of a pre-compiled imported library)We need to remove strictness annotations because GHC will introduce casts between Integer and Clash' numeric primitives otherwise, where Clash will error when it sees such casts. The reason it does this is because Integer is a completely unconstrained integer type and is currently (erroneously) translated to a 64-bit integer in the HDL; this means that we could lose bits when the original numeric type had more bits than 64.Removing these strictness annotations is perfectly safe, as they only affect simulation behavior. clash-ghc6The package id of the clash-prelude we were built with clash-ghcCheck that we're using the same clash-prelude as we were built withBecause if they differ clash won't be able to recognize any ANNotations.w clash-ghcModule name. Can either be a filepath pointing to a .hs file, or a qualified module name (example:  Data.List).x clash-ghcModule name. Can either be a filepath pointing to a .hs file, or a qualified module name (example:  Data.List).  clash-ghcAllows us to have some initial action, such as sharing a linker state See  8https://github.com/clash-lang/clash-compiler/issues/1686 and https://mail.haskell.org/pipermail/ghc-devs/2021-March/019605.html clash-ghc Use color clash-ghc HDL target clash-ghc Module name clash-ghcFlags to run GHC with clash-ghc0Import dirs to use when no DynFlags are provided clash-ghcName of annotation clash-ghcBinders searched for clash-ghcParsed annotations clash-ghc7function to (attempts to) combine different annotations clash-ghcName of annotation clash-ghcBinders searched for clash-ghcParsed annotations clash-ghc Root binders clash-ghc,(design under test, associated test benches)  (C) 2013-2016, University of Twente, 2017, QBayLogic, Google Inc., 2021-2022, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred"'(13679:;<=?72 clash-ghcSafe indexing, returns a  if the index does not exist clash-ghcIf this CoreBndr is a primitive, check it's Haskell definition for potential problems.Warns when a primitive: * isn't marked NOINLINE * produces an error when evaluating its result to WHNF * isn't using all its arguments clash-ghcAllows us to have some initial action, such as sharing a linker state See  8https://github.com/clash-lang/clash-compiler/issues/1686 and https://mail.haskell.org/pipermail/ghc-devs/2021-March/019605.html clash-ghc!primitives (blackbox) directories clash-ghcimport directories (-i flag) clash-ghcPackage database clash-ghc HDL target Safe-Inferred"(13679:;<=?A clash-ghcType of some span of source code. Most of these fields are unboxed but Haddock doesn't show that. clash-ghc&The span we associate information with clash-ghcThe  associated with the span clash-ghc The actual  associated with the span, if any. This can be useful for accessing a variety of information about the identifier such as module, locality, definition location, etc. clash-ghcInfo about a module. This information is generated every time a module is loaded. clash-ghcSummary generated by GHC. Can be used to access more information about the module. clash-ghcGenerated set of information about all spans in the module that correspond to some kind of identifier for which there will be type info and/or location info. clash-ghcAgain, useful from GHC for accessing information (exports, instances, scope) from a module. clash-ghc7The timestamp of the file used to generate this record. clash-ghcTest whether second span is contained in (or equal to) first span. This is basically  for  clash-ghc Filter all  which are contained in  clash-ghc Construct a  from a  and optionally a  and an  (for  and  respectively) clash-ghcConvenience wrapper around  which needs only a  clash-ghcConvenience wrapper around  which results in a  clash-ghcTry to find the location of the given identifier at the given position in the module. clash-ghc6Find any uses of the given identifier in the codebase. clash-ghc>Filter out redundant spans which surround/contain other spans. clash-ghcTry to resolve the name located at the given position, or otherwise resolve based on the current module's scope. clash-ghc?Try to resolve the name from another (loaded) module's exports. clash-ghc4Try to resolve the type display from the given span. clash-ghc'Try to find the type of the given span. clash-ghc%Guess a module name from a file path. clash-ghc.Collect type info data for the loaded modules. clash-ghcGet the source file path from a ModSummary. If the .hs file is missing, and the .o file exists, we return the .o file path. clash-ghc/Get info about the module: summary, types, etc. clash-ghc#Get ALL source spans in the module. Safe-Inferred(13679:;<=?O clash-ghcTreatment of ./.ghci files. For now we either load or ignore. But later we could implement a "safe mode" where only safe operations are performed. clash-ghcUnterminated multiline command clash-ghcUsed to denote GHCi command execution result. Specifically, used to distinguish between two ghci execution modes - REPL5 and "Expression evaluation mode (ghc -e)". When in REPL mode, we don't want to exit GHCi session when error occurs, (which is when we use  CmdSuccess). Otherwise, when in expression evaluation mode, all command failures should lead to GHCi session termination (with ExitFailure 1) which is when  CmdFailure2 is used(this is useful when executing scripts).  CleanExit is used to signal end of GHCi session (for example, when ":quit" command is called). clash-ghcA GHCi command clash-ghc"Name of GHCi command (e.g. "exit") clash-ghcThe 8 value denotes whether to exit GHCi cleanly or error out clash-ghc9Commands which are excluded from default completion and :help summary. This is usually set for commands not useful for interactive use but rather for IDEs. clash-ghc for arguments clash-ghcof type  IO a -> IO a clash-ghc input line clash-ghc caches the  for loaded modules, so that we don't rebuild it each time the user sets a breakpoint. clash-ghcavailable ghci commands clash-ghcuser-defined macros clash-ghc: at the GHCi prompt repeats the last command, so we remember it here clash-ghc?The command wrapper is run for each command or statement. The 6 value denotes whether the command is successful and  means to exit GHCi. clash-ghcThe imports that the user has asked for, via import declarations and :module commands. This list is persistent over :reloads (but any imports for modules that are not loaded are temporarily ignored). After a :load, all the home-package imports are stripped from this list.See bugs #2049, #1873, #1360 clash-ghcAn import added automatically after a :load, usually of the most recently compiled module. May be empty if there are no modules loaded. This list is replaced by :load, :reload, and :add. In between it may be modified by :module. clash-ghcThese are "always-on" imports, added to the context regardless of what other imports we have. This is useful for adding imports that are required by setGHCiMonad. Be careful adding things here: you can create ambiguities if these imports overlap with other things in scope.NB. although this is not currently used by GHCi itself, it was added to support other front-ends that are based on the GHCi code. Potentially we could also expose this functionality via GHCi commands. clash-ghcThese imports are added to the context when -XImplicitPrelude is on and we don't have a *-module in the context. They can also be overridden by another import for the same module, e.g. "import Prelude hiding (map)" clash-ghc$True if this is 'ghc -e' (or runghc) clash-ghchelp text to display to a user clash-ghchFlush stdout; hFlush stderr in the interpreter clash-ghchSetBuffering NoBuffering for stdinstdoutstderr clash-ghcRun a single Haskell expression clash-ghcCompile "hFlush stdout; hFlush stderr" once, so we can use it repeatedly clash-ghc8Invoke "hFlush stdout; hFlush stderr" in the interpreter clash-ghcTurn off buffering for stdin, stdout, and stderr in the interpreter clash-ghcRun a 4 action to compile an expression for internal usage. Safe-Inferred(13679:;<=?Q  Safe-Inferred(13679:;<=?QX Safe-Inferred%&(13679:;<=?R clash-ghcGrab weak references to some of the data structures representing the currently loaded modules. clash-ghc Safe-Inferred"(13679:;<=?U clash-ghcInteger width. The width Clash assumes an Integer to be (instead of it begin an arbitrarily large, runtime sized construct). clash-ghcCustom bit representations clash-ghcType constructor map clash-ghcType to convert to HWType clash-ghc"Name of type (for error reporting) clash-ghc6[(Fully qualified constructor name, constructor value) clash-ghc/Constructor map (used to look through newtypes) clash-ghc"Type representing some constructor (C) 2013-2016, University of Twente, 2016-2017, Myrtle Software Ltd, 2017-2022, Google Inc., 2017-2024, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred"'(13679:;<=?^ clash-ghc#Evaluation of primitive operations. clash-ghcLift a binary function over ' values to be used as literal Evaluator clash-ghc5Helper to run a function over sized types on integersThis only works on function of type (sized n -> sized n -> sized n) The resulting function must be executed with reifyNat clash-ghcType constructor? clash-ghc Result type clash-ghc forall n. clash-ghc KnownNat n clash-ghcValue to construct clash-ghc Result type clash-ghcMask clash-ghcValue clash-ghc Result type clash-ghc forall n. clash-ghc KnownNat n clash-ghcmask clash-ghcValue to construct clash-ghc Result type clash-ghc forall n. clash-ghc KnownNat n clash-ghcValue to construct clash-ghcEither undefined (if given value is out of bounds of given type) or term representing literal clash-ghc Result type clash-ghc forall n. clash-ghc KnownNat n clash-ghcValue to construct clash-ghc$(result type, forall n., KnownNat n) clash-ghcMask clash-ghcValue clash-ghc$(result type, forall n., KnownNat n) clash-ghcvalue clash-ghc$literal argument extraction function clash-ghcliteral contruction function clash-ghcfunction to run clash-ghcfirst argument clash-ghcsecond argument clash-ghcSNat TyCon name clash-ghcVec TyCon name clash-ghcSNat TyCon name clash-ghcVec TyCon name clash-ghcVec TyCon name clash-ghcVec TyCon name clash-ghcVec TyCon name clash-ghcVec TyCon name clash-ghcVec TyCon name clash-ghcVec TyCon name clash-ghcIndex TyCon name clash-ghcIndex TyCon name clash-ghcBitVector TyCon Name clash-ghcBitVector TyCon Name clash-ghcBitVector TyCon Name clash-ghcBitVector TyCon Name (C) 2017-2022, Google Inc., 2021-2024, QBayLogic B.V.BSD2 (see the file LICENSE)%QBayLogic B.V.  Safe-Inferred"'(13679:;<=?a  clash-ghcUnwind the stack by 1 clash-ghc!Small-step operational semantics.* clash-ghcTake a list of types or type variables and create a lambda / type lambda for each one around the given term.+ clash-ghc'Update the Heap with the evaluated term, clash-ghcApply a value to a function- clash-ghcInstantiate a type-abstraction. clash-ghcEvaluate a case-expression0 clash-ghc!Allocate let-bindings on the heap1 clash-ghc6Create a unique name and substitution for a let-binder !"#$%&'()*+,-./01 !"#$%&'()*+,-./01 Safe-Inferred(13679:;<=?b8 Safe-Inferred"%&(13679:;<=?~V+ clash-ghcsubject's haddocks clash-ghc$type signature + category + location clash-ghchaddocks for arguments clash-ghcTakes a file name and prefixes it with the appropriate GHC appdir. Uses ~/.ghc (getAppUserDataDirectory) if it exists If it doesn't, then it uses $XDG_DATA_HOME/ghc Earlier we always used to use ~/.ghc, but we want to gradually move to $XDG_DATA_HOME to respect the XDG specificationAs a migration strategy, we will only create new directories in the appropriate XDG location. However, we will use the old directory if it already exists. clash-ghc,How to get the next input line from the user clash-ghcTakes a string, presumably following "%call", and tries to parse a command and arguments in parentheses: parseCallEscape " (cmd arg1 arg2)rest" = Just ("cmd" :| ["arg1", "arg2"], "rest") parseCallEscape "( )rest" = Nothing clash-ghcThe main read-eval-print loop clash-ghc.Evaluate a single line of user input (either : command or Haskell code). A result of Nothing means there was no more input to process. Otherwise the result is Just b where b is True if the command succeeded; this is relevant only to ghc -e, which will exit with status 1 if the command was unsuccessful. GHCi will continue in either case. TODO: replace Bool with CmdExecOutcome clash-ghcEntry point to execute some haskell code from user. The return value True indicates success, as in . clash-ghc7Clean up the GHCi environment after a statement has run clash-ghcEntry point for execution a ': command' input from user clash-ghc(Generate a typed ghciStepIO expression $ghciStepIO :: Ty String -> IO String. clash-ghcProduce output containing the type/kind signature, category, and definition location of a TyThing. clash-ghcSets '-fdefer-type-errors' if defer is true, executes load and unsets '-fdefer-type-errors' again if it has not been set before. clash-ghc:load command clash-ghc:add command clash-ghc:unadd command clash-ghc:reload command clash-ghc9Load/compile targets and (optionally) collect module-infoThis collects the necessary SrcSpan annotated type information (via ) required by the  :all-types, :loc-at, :type-at, and :uses commands.Meta-info collection is not enabled by default and needs to be enabled explicitly via :set +c. The reason is that collecting the type-information for all sub-spans can be quite expensive, and since those commands are designed to be used by editors and tooling, it's useless to collect this data for normal GHCi sessions. clash-ghcKeep any package modules (except Prelude) when changing the context. clash-ghcFilters a list of , clearing out any home package imports so only imports from external packages are preserved. ( counts as a home package import, because we are only able to bring a full top-level into scope when the source is available.) clash-ghcRun an  wrapped GhcMonad, while handling source errors and printing  strings to . If in expression evaluation mode - throw GhcException and exit. clash-ghc Inverse of  for "pure" computations (c.f.  for ) clash-ghc:type8 command. See also Note [TcRnExprMode] in GHC.Tc.Module. clash-ghc:type-at command clash-ghc:uses command clash-ghc:loc-at command clash-ghc :all-types command clash-ghcParse a span:  module-name/filepath  sl  sc  el  ec string clash-ghcPretty-print "real" s as  filename:( line, col)-( line-end, col-end) while simply unpacking s clash-ghc Variant of  for s clash-ghc:kind command clash-ghc A version of  that treats sequences enclosed in double quotes as single words and that does not break on backslash-escaped spaces. E.g., 'words' ""lorem ipsum" dolor"' and 'words' "lorem\ ipsum dolor"' yield '["lorem ipsum", "dolor"]'. Used to scan for file paths in . clash-ghcSets the GHC context from the GHCi state. The GHC context is always set this way, we never modify it incrementally.We ignore any imports for which the ModuleName does not currently exist. This is so that the remembered_ctx can contain imports for modules that are not currently loaded, perhaps because we just did a :reload and encountered errors.Prelude is added if not already present in the list. Therefore to override the implicit Prelude import you can say 'import Prelude ()' at the prompt, just as in Haskell source. clash-ghcfilterSubsumed is js returns the elements of js not subsumed by any of is. clash-ghcReturns True if the left import subsumes the right one. Doesn't need to be 100% accurate, conservatively returning False is fine. (EXCEPT: (IIModule m) *must* subsume itself, otherwise a panic in plusProv will ensue (#5904))Note that an IIModule does not necessarily subsume an IIDecl, because e.g. a module might export a name that is only available qualified within the module itself.Note that 'import M' does not necessarily subsume 'import M(foo)', because M might not export foo and we want an error to be produced in that case. clash-ghcnewDynFlags will *not* read package environment files, therefore we use  rather than parseDynamicFlags. This function is called very often and results in repeatedly loading environment files (see #19650) clash-ghc4Provide completions for last word in a given string.Takes a tuple of two strings. First string is a reversed line to be completed. Second string is likely unused, 8 always passes an empty string as second item in tuple. clash-ghcReturn a list of visible module names for autocompletion. (NB: exposed != visible) clash-ghcReturns the span of the largest tick containing the srcspan given clash-ghclist a section of a source file around a particular SrcSpan. If the highlight flag is True, also highlight the span using start_bold/end_bold. clash-ghcWhen in expression evaluation mode (ghc -e), we want to exit immediately. Otherwis, just print out the message. clash-ghc*Optionally show a fixity declaration like  infixr 4 #We always display the fixity of terms with symbolic names (like  $). For other terms we only display the fixity if it has been set to a value other than the default infixl 9.We have no way of distinguishing between a fixity that has been manually set to infixl 9 and a fixity that has assumed infixl 9 as the default, so we choose to not display the fixity in both cases (for terms with non-symbolic names). See #19200. clash-ghcException handler clash-ghcSource error handler clash-ghcfilename   Safe-Inferred(13679:;<=?> clash-ghcEnsure sanity of options.Throws  or  if not. clash-ghc=Check that we don't have multiple units with the same UnitId. clash-ghc Print ABI hash of input modules.The resulting hash is the MD5 of the GHC version used (#5328, see 6) and of the existing ABI hash from each module (see ). clash-ghcList of module names2323 !"#$%&'() * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D  E F G H I J K L M NOPQRSTUVWXYWXZ[\]^_`abcdefghijklmnopqrsttuvwxyz{|}~SWWWWWWSWWW                       WWSWWSTW WW  WWclash-ghc-1.9.0-inplaceClash.GHC.PartialEval.EvalClash.GHC.PartialEval.PrimitiveClash.GHC.PartialEval.QuoteClash.GHC.PartialEvalClash.GHCi.CommonClash.GHC.LoadModulesClash.GHC.GenerateBindingsClash.GHC.NetlistTypesClash.GHC.EvaluatorClash.GHC.Evaluator.Primitive Clash.Main clash-ghcClash.GHC.ClashFlagsClash.GHC.UtilClash.GHC.GHC2CoreClash.GHC.LoadInterfaceFilesClash.GHCi.UI.InfoClash.GHCi.UI.MonadClash.GHCi.UI.TagsClash.GHCi.UtilClash.GHCi.LeakData.Text.ExtraPaths_clash_ghc Clash.GHCi.UIevalapplyapplyTy evalPrimitivequote ghcEvaluatorgetMainTopEntitycheckMonoLocalBindsModcheckMonoLocalBindscheckImportDirs ghcLibDir loadModulessetWantedLanguageExtensions$fShowLoadModulesException$fExceptionLoadModulesExceptiongenerateBindingsghcTypeToHWType newLetBinding ghcUnwindghcStepisUndefinedPrimValisUndefinedXPrimVal ghcPrimUnwind ghcPrimStep$fMonadUniquePrimEvalMonad$fFunctorPrimEvalMonad$fApplicativePrimEvalMonad$fMonadPrimEvalMonad$fMonadStateSupplyPrimEvalMonad evaluatorstepVarstepData stepLiteralstepPrimstepLam stepTyLamstepApp stepTyAppstepLetstepCasestepCaststepTick newBinderupdate instantiate scrutinise substInAltallocateletSubst defaultMaindefaultMainWithAction deprecatedparseClashFlags flagsClashcaseContryTransformCase findBestAlt textLinesbase Data.OldListlineshandleClashExceptionghcGHC.Utils.OutputableshowSDocUnsafe showPprUnsafelistTypeToListOfTypesboolTypeToBool tyLitToString tyLitToTexttyLitToInteger coreToAttr coreToAttrs annotateType coreToTypebundleUnbundleTerm mapSignalTerm signalTerm appSignalTerm vecUnwrapTerm traverseTerm dollarTermjoinTermwithFrozenCallStackTermidTerm runRWTermcheckUnpackUndefTerm nameModTermxToErrorCtxTermC2C GHC2CoreState GHC2CoreEnv_srcSpan _famInstEnvssrcSpantyConMap coreToTermcoreToId coreToNamemodNameMqualifiedNameStringqualifiedNameString' makeAllTyConsemptyGHC2CoreState DeclCache LoadedBinders lbBinders lbClassOps lbUnlocatablelbPrimslbReprslbCache bndrsInExpraddBndrMloadExternalBinders getIfaceDeclMgetAnnTargetName_maybeclash-lib-1.9.0-inplaceClash.Primitives.TypesnameloadExternalExprsgetUnresolvedPrimitivesloadExternalModuleloadLocalModuleunpackKnownConfmakeRecursiveGroupsfindAnnotationsByTargetsfindAllModuleAnnotationsfindNamedAnnotationsfindCustomReprAnnotationsfindSynthesizeAnnotationsfindTestBenchestoQualNmfindPrimitiveAnnotationsremoveStrictnessAnnotations preludePkgIdcheckForInvalidPreludeerrOnDuplicateAnnotationscombineAnnotationsWith indexMaybe GHC.MaybeNothingcheckPrimitiveSpanInfospaninfoSrcSpan spaninfoTypeGHC.Core.TyCo.RepType spaninfoVar GHC.Types.VarVarModInfomodinfoSummary modinfoSpans modinfoInfomodinfoLastUpdatecontainsSpanInfoGHC.Types.SrcLoc containsSpanspaninfosWithinspanInfoFromRealSrcSpan RealSrcSpanIdspanInfoFromRealSrcSpan'srcSpanFilePath srcSpanFileGHC.IOFilePathfindLoc findNameUsesstripSurroundingfindNameresolveNameFromModule resolveNamefindType guessModule collectInfo srcFilePath getModInfoprocessAllTypeCheckedModuleLocalConfigBehaviourCommandIncompleteCmdExecOutcomeCommandcmdName cmdAction cmdHiddencmdCompletionFunchaskeline-0.8.2.1#System.Console.Haskeline.CompletionCompletionFunc evalWrapper line_number tickarrays TickArray ghci_commands ghci_macros last_command cmd_wrapperghc-prim GHC.TypesBoolremembered_ctx transient_ctx extra_importsprelude_importsghc_e short_helpflushStdHandles noBufferingrunStmtinitInterpBufferingflushInterpBuffersturnOffBuffering runInternalGHC.Driver.MonadGhcMonadGHCiunGHCi startGHCi GHCiStateoptionsstoppromptargsprogname prompt_conteditor multiMode localConfig break_ctrbreakscmdqueue long_helplastErrorLocations mod_infos ifaceCache GhciMonad getGHCiState setGHCiStatemodifyGHCiState reifyGHCi GHCiOptionShowType ShowTiming RevertCAFs Multiline CollectInfo isOptionSet setOption unsetOption CommandResultCommandCompletecmdInput cmdResultcmdStats cmdSuccess CleanExit CmdSuccess CmdFailureSourceLocalConfigIgnoreLocalConfigPromptFunction BreakLocation breakModulebreakLoc breakTick breakEnabled onBreakCmdGHC.Driver.SessionextractDynFlags getDynFlagsrunDecls runDecls'resume recordBreak revertCAFs ActionStats actionAllocsactionElapsedTimerunAndPrintStats runWithStats printStatsprintForUserNeverQualifyprintForUserModInfo printForUserprintForUserPartWayprettyLocationscompileGHCiExprturnOffBuffering_ mkEvalWrappercreateCTagsWithLineNumbersCmdcreateCTagsWithRegExesCmdcreateETagsFileCmdanyToPtrgetLeakIndicatorscheckLeakIndicatorsLeakIndicatorsshowtshowtlfromType liftUnsigned2clash-prelude-1.9.0-inplaceClash.Sized.Internal.UnsignedUnsigned runSizedF mkSizedLitmkBitLitmkBitVectorLit mkIndexLitE mkIndexLitmkBitVectorLit' mkIndexLit' liftSized2 splitAtPrim splitAtTy foldSplitAtTy vecAppendPrim vecAppendTyvecZipWithPrim vecZipWithTy vecImapGoTy indexAddTy bvAppendPrim bvAppendTy bvSplitPrim bvSplitTyversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDirdocs sigAndLocargDocsgetAppDataFile nextInputLineparseCallEscape runCommands runOneCommand afterRunStmtspecialCommand getGhciStepIO sigAndLocDocwrapDeferTypeErrors loadModule_ addModule unAddModule reloadModuledoLoadAndCollectInfosetContextKeepingPackageModuleskeepPackageImportsGHC.Runtime.ContextInteractiveImportIIModulerunExceptGhciMonadtransformers-0.6.1.0Control.Monad.Trans.ExceptExceptTthrowEGHC.IO.StdHandlesstderrexceptT runExceptTexceptExcept typeOfExpr typeAtCmdusesCmdlocAtCmd allTypesCmd parseSpanArg showSrcSpanSrcSpan UnhelpfulSpanshowRealSrcSpan kindOfTypewords'words scriptCmdsetGHCContextFromGHCiStatefilterSubsumed iiSubsumes newDynFlagsparseDynamicFlagsCmdLineghciCompleteWord completeCmdallVisibleModulesenclosingTickSpan listAroundprintErrAndMaybeExit showFixity runCommands' runScript interactiveUI GhciSettingsavailableCommands shortHelpText fullHelpText defPrompt defPromptContdefaultGhciSettings ghciCommandsghciWelcomeMsgmakeHDL checkOptionsGHC.Utils.Panic UsageError CmdLineErrorcheckUnitCyclesabiHashGHC.Settings.Constants hiVersionGHC.Unit.Module.ModIface mi_mod_hash