#compdef ghc ghci ghc-pkg # ------------------------------------------------------------------------------ # Copyright (c) 2014 Github zsh-users - https://github.com/zsh-users # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the zsh-users nor the # names of its contributors may be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL ZSH-USERS BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ # Description # ----------- # # Completion script for ghc 9.10.3 (https://www.haskell.org/ghc/) # # ------------------------------------------------------------------------------ # Authors # ------- # # * Gérard Milmeister # * Philip Dexter # # ------------------------------------------------------------------------------ # # ghci # _ghc_ghci() { local -a ghci_flags=( "-fshow-loaded-modules[Show the names of modules that GHCi loaded after a :load command]" "-fprint-bind-result[Turn on printing of binding results in GHCi]" "-fimplicit-import-qualified[Put in scope qualified identifiers for every loaded module]" "-fno-it[No longer set the special variable it]" "-interactive-print[Select the function to use for printing evaluated expressions]:name" "-fbreak-points[Insert breakpoints in the GHCi debugger]" "-fprint-evld-with-show[Instruct :print to use Show instances where possible]" "-fghci-hist-size=[Set the number of entries GHCi keeps for :history]:size" "-fbreak-on-exception[Break on any exception thrown]" "-fbreak-on-error[Break on uncaught exceptions and errors]" "-flocal-ghci-history[Use current directory for the GHCi command history file]" "-fghci-leak-check[(Debugging only) check for space leaks when loading new modules in GHCi]" "-ignore-dot-ghci[Disable reading of .ghci files]" "-ghci-script[Read additional .ghci files]" "-fexternal-interpreter[Run interpreted code in a separate process]" "-XExtendedDefaultRules[Use GHCi's extended default rules in a normal module]" ) _arguments \ $ghci_flags[@] \ '*:: :_files' } # # ghc # _ghc_compiler() { typeset -A opt_args local context state line local curcontext="$curcontext" local ret=1 # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/using.rst.txt local -a using_flags=( "--interactive[Interactive mode ]" "--run[Run a Haskell program]:file:_files" "--make[Build a multi-module Haskell program, automatically figuring out dependencies]" "-e[Evaluate the given expr]:expr" "-E[Stop after preprocessing]" "-C[Stop after generating C]" "-S[Stop after generating assembly]" "-c[Stop after generating object]" "--merge-objs[Merge a set of objects into a GHCi library]" "-M[generate dependency information suitable for use in a Makefile]" "--frontend[run GHC with the given frontend plugin]:plugin" "-shared[Create a shared object]" "(- *)--help[Display help]" "--show-iface[display the contents of an interface file]:file:_files -g '*.hi'" {--supported-extensions,--supported-languages}"[display the supported language extensions]" "--show-options[display the supported command line options]" "--info[display information about the compiler]" "--version[display GHC version]" "--numeric-version[display GHC version (numeric only)]" "--print-booter-version[display bootstrap compiler version]" "--print-build-platform[display platform on which GHC was built]" "--print-c-compiler-flags[C compiler flags used to build GHC]" "--print-c-compiler-link-flags[C linker flags used to build GHC]" "--print-debug-on[print whether GHC was built with -DDEBUG]" "--print-global-package-db[display GHC's global package database directory]" "--print-have-interpreter[display whether GHC was built with interactive support]" "--print-have-native-code-generator[display whether target platform has NCG support]" "--print-host-platform[display host platform of GHC]" "--print-leading-underscore[display use of leading underscores on symbol names]" "--print-libdir[display GHC library directory]" "--print-ld-flags[display linker flags used to compile GHC]" "--print-object-splitting-supported[display whether GHC supports object splitting]" "--print-project-git-commit-id[display Git commit id GHC is built from]" "--print-project-version[display GHC version]" "--print-rts-ways[display which way RTS was built]" "--print-stage[display stage number of GHC]" "--print-support-smp[display whether GHC was compiled with SMP support]" "--print-tables-next-to-code[display whether GHC was compiled with --enable-tables-next-to-code]" "--print-target-platform[display target platform of GHC]" "--print-unregisterised[display whether this GHC was built in unregisterised mode]" "-j[When compiling with --make, compile n modules in parallel]:num" "-jsem[When compiling with --make, coordinate with other processes through the semaphore]" "-unit[Specify the options to build a specific unit]:file:_files" "-working-dir[Specify the directory a unit is expected to be compiled in]:dir:_files -/" "-this-package-name[The name of the package which this module would be part of when installed]:unit_id" "-hidden-module[A module which should not be visible outside its unit]:module_name" "-reexported-module[A module which should be reexported from this unit]:module_name" "-x[Override default behaviour for source files]:suffix" "-v[Verbose mode equivalent to -v3]" "-v0[Disable all non-essential messages]" "-v1[Minimal verbosity]" "-v2[Print the name of each compilation phase]" "-v3[Same as -v2 except that in addition the full command line for each compilation phase]" "-v4[Same as -v3 except that intermediate program representation is also printed]" "-fprint-potential-instances[display all available instances in type error messages]" "-fhide-source-paths[hide module source and object paths]" "-fprint-unicode-syntax[Use unicode syntax when printing expressions, types and kinds]" "-fprint-explicit-foralls[Print explicit forall quantification in types]" "-fprint-explicit-kinds[Print explicit kind foralls and kind arguments in types]" "-fprint-explicit-coercions[Print coercions in types]" "-fprint-axiom-incomps[Display equation incompatibilities in closed type families]" "-fprint-equality-relations[Distinguish between equality relations when printing]" "-fprint-expanded-synonyms[In type errors, also print type-synonym-expanded types]" "-fprint-redundant-promotion-ticks[Print redundant DataKinds promotion ticks]" "-fprint-typechecker-elaboration[Print extra information from typechecker]" "-fdefer-diagnostics[Defer and group diagnostic messages by severity]" "-fdiagnostics-as-json[Output diagnostics in Json format specified by JSON schema]" "-fdiagnostics-color=⟨always|auto|never⟩[Use colors in error messages]" "-fdiagnostics-show-caret[Whether to show snippets of original source code]" "-fshow-error-context[Whether to show textual information about error context]" "-fprint-error-index-links=f[Whether to emit diagnostic codes as ANSI hyperlinks to the Haskell Error Index]:type:(always auto never)" "-ferror-spans[Output full span in error messages]" "-fkeep-going[Continue compilation as far as possible on errors]" "-freverse-errors[Output errors in reverse order]" "-Rghc-timing[Summarise timing stats for GHC]" "-mavx[(x86 only) Enable support for AVX SIMD extensions]" "-mavx2[(x86 only) Enable support for AVX2 SIMD extensions]" "-mavx512cd[(x86 only) Enable support for AVX512-CD SIMD extensions]" "-mavx512er[(x86 only) Enable support for AVX512-ER SIMD extensions]" "-mavx512f[(x86 only) Enable support for AVX512-F SIMD extensions]" "-mavx512pf[(x86 only) Enable support for AVX512-PF SIMD extensions]" "-msse[(x86 only) Use SSE for floating-point operations]" "-msse2[(x86 only) Use SSE2 for floating-point operations]" "-msse3[(x86 only) Use SSE3 for floating-point operations]" "-msse4[(x86 only) Use SSE4 for floating-point operations]" "-msse4.2[(x86 only) Use SSE4.2 for floating-point operations]" "-mbmi[(x86 only) Use BMI1 for bit manipulation operations]" "-mbmi2[(x86 only) Use BMI2 for bit manipulation operations]" "-mfma[Use native FMA instructions for fused multiply-add floating-point operations]" "-haddock[Parse Haddock comments and include them in the interface file it produces]" "-ghcversion-file ⟨path to ghcversion.h⟩[Use this ghcversion.h file]:version_file:_files" "-H[Set the minimum size of the heap to the given size]:size" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/debug-info.rst.txt local -a debug_info_flags=( "-g-[Produce DWARF debug information in compiled object files]:level:(0 1 2)" "-finfo-table-map[Embed a lookup table in the generated binary]" "-finfo-table-map-with-stack[Include info tables for STACK closures in the info table map]" "-fno-info-table-map-with-stack[Omit info tables for STACK closures from the info table map]" "-finfo-table-map-with-fallback[Include info tables with no source location information]" "-fno-info-table-map-with-fallback[Omit info tables with no source location information]" "-fdistinct-constructor-tables[Generate a fresh info table for each usage of a data constructor]" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/debugging.rst.txt local -a debugging_flags=( "-ddump-to-file[Dump to files instead of stdout]" "-ddump-file-prefix=[Set the prefix of the filenames used for debugging output]:prefix" "-fdump-with-ways[Include the tag of the enabled ways in the extension of dump files]" "-dshow-passes[Print out each pass name as it happens]" "-dipe-stats[Show statistics about IPE information]" "-dfaststring-stats[Show statistics for fast string usage when finished]" "-ddump-faststrings[Dump the whole FastString table when finished]" "-dppr-debug[Turn on debug printing (more verbose)]" "-ddump-timings[Dump per-pass timing and allocation statistics]" "-ddump-parsed[Dump parse tree]" "-ddump-parsed-ast[Dump parser output as a syntax tree]" "-dkeep-comments[Include comments in the parser]" "-ddump-if-trace[Trace interface files]" "-ddump-tc-trace[Trace typechecker]" "-ddump-rn-trace[Trace renamer]" "-ddump-ec-trace[Trace exhaustiveness checker]" "-ddump-cs-trace[Trace constraint solver]" "-ddump-rn-stats[Renamer stats]" "-ddump-rn[Dump renamer output]" "-ddump-rn-ast[Dump renamer output as a syntax tree]" "-ddump-tc[Dump typechecker output]" "-ddump-tc-ast[Dump typechecker output as a syntax tree]" "-ddump-hie[Dump the hie file syntax tree]" "-ddump-splices[Dump TH spliced expressions, and what they evaluate to]" "-dth-dec-file[Dump evaluated TH declarations into '*.th.hs' files]" "-ddump-types[Dump type signatures]" "-ddump-deriv[Dump deriving output]" "-ddump-call-arity[Dump output of the call arity analysis pass]" "-ddump-core-stats[Print a one-line summary of the size of the Core program]" "-ddump-ds[Dump desugarer output]" "-ddump-exitify[Dump output of the exitification pass]" "-ddump-simpl-iterations[Dump output from each simplifier iteration]" "-ddump-simpl-stats[Dump simplifier stats]" "-ddump-simpl-trace[Dump trace messages in simplifier]" "-dverbose-core2core[Show output from each core-to-core pass]" "-ddump-spec[Dump specialiser output]" "-ddump-spec-constr[Dump specialiser output from SpecConstr]" "-ddump-rules[Dump rewrite rules]" "-ddump-rule-firings[Dump rule firing info]" "-ddump-rule-rewrites[Dump detailed rule firing info]" "-drule-check=⟨str⟩[Dump information about potential rule application]" "-dinline-check=⟨str⟩[Dump information about inlining decisions]" "-ddump-simpl[Dump final simplifier output]" "-ddump-inlinings[Dump inlinings performed by the simplifier]" "-ddump-verbose-inlinings[Dump all considered inlinings]" "-ddump-dmdanal[Dump demand analysis output]" "-ddump-dmd-signatures[Dump top-level demand signatures]" "-ddump-cpranal[Dump CPR analysis output]" "-ddump-cpr-signatures[Dump CPR signatures]" "-ddump-cse[Dump CSE output]" "-ddump-full-laziness[Dump full laziness pass output]" "-ddump-float-in[Dump float in output]" "-ddump-liberate-case[Dump liberate case output]" "-ddump-static-argument-transformation[Dump static argument transformation output]" "-ddump-worker-wrapper[Dump worker-wrapper output]" "-ddump-occur-anal[Dump occurrence analysis output]" "-ddump-prep[Dump prepared core]" "-ddump-late-cc[Dump core with late cost centres added]" "-ddump-view-pattern-commoning[Dump commoned view patterns]" "-ddump-stg-from-core[Show CoreToStg output]" "-dverbose-stg2stg[Show output from each STG-to-STG pass]" "-ddump-stg-unarised[Show unarised STG]" "-ddump-stg-cg[Show output after Stg2Stg]" "-ddump-stg-tags[Show output of the tag inference pass.]" "-ddump-stg-final[Show output of last STG pass.]" "-ddump-cmm-verbose-by-proc[Show output from main C-\\- pipeline passes (grouped by proc)]" "-ddump-cmm-verbose[Write output from main C-\\- pipeline passes to files]" "-ddump-cmm-from-stg[Dump STG-to-C-\\- output]" "-ddump-cmm-raw[Dump raw C-\\-]" "-ddump-cmm-cfg[Dump the results of the C-\\- control flow optimisation pass]" "-ddump-cmm-thread-sanitizer[Dump the results of the C-\\- ThreadSanitizer elaboration pass]" "-ddump-cmm-cbe[Dump the results of common block elimination]" "-ddump-cmm-switch[Dump the results of switch lowering passes]" "-ddump-cmm-proc[Dump the results of proc-point analysis]" "-ddump-cmm-sp[Dump the results of the C-\\- stack layout pass]" "-ddump-cmm-sink[Dump the results of the C-\\- sinking pass]" "-ddump-cmm-caf[Dump the results of the C-\\- CAF analysis pass]" "-ddump-cmm-procmap[Dump the results of the C-\\- proc-point map pass]" "-ddump-cmm-split[Dump the results of the C-\\- proc-point splitting pass]" "-ddump-cmm-info[Dump the results of the C-\\- info table augmentation pass.]" "-ddump-cmm-cps[Dump the results of the CPS pass]" "-ddump-cmm[Dump the final C-\\- output]" "-ddump-cfg-weights[Dump the assumed weights of the CFG.]" "-ddump-llvm[Dump LLVM intermediate code.]" "-ddump-c-backend[Dump C code produced by the C (unregisterised) backend]" "-ddump-cmm-opt[Dump the results of C-\\- to C-\\- optimising passes]" "-ddump-opt-cmm[Dump the results of C-\\- to C-\\- optimising passes]" "-ddump-asm-conflicts[Dump register conflicts from the register allocator]" "-ddump-asm-native[Dump initial assembly]" "-ddump-asm-liveness[Dump assembly augmented with register liveness]" "-ddump-asm-regalloc[Dump the result of register allocation]" "-ddump-asm-regalloc-stages[Dump the build/spill stages of the register allocator]" "-ddump-asm-stats[Dump statistics from the register allocator]" "-ddump-asm[Dump final assembly]" "-ddump-js[Dump final JavaScript code]" "-ddisable-js-minifier[Generate pretty-printed JavaScript code instead of minified code]" "-ddisable-js-c-sources[Disable the link with C sources compiled to JavaScript]" "-ddump-bcos[Dump interpreter byte code]" "-ddump-debug[Dump generated DWARF debug information]" "-ddump-rtti[Trace runtime type inference]" "-ddump-foreign[Dump foreign export stubs]" "-ddump-ticked[Dump the code instrumented by HPC]" "-ddump-mod-map[Dump the state of the module mapping database]" "-dppr-user-length[Set the depth for printing expressions in error msgs]" "-dppr-cols=⟨n⟩[Set the width of debugging output]" "-dppr-case-as-let[Print single alternative case expressions as strict lets]" "-dhex-word-literals[Print values of type Word# in hexadecimal]" "-dno-debug-output[Suppress unsolicited debugging output]" "-dsuppress-all[In dumps, suppress everything (except for uniques) that is suppressible]" "-dsuppress-ticks[Suppress 'ticks' in the pretty-printer output]" "-dsuppress-uniques[Suppress the printing of uniques in debug output]" "-dsuppress-idinfo[Suppress extended information about identifiers where they are bound]" "-dsuppress-unfoldings[Suppress the printing of the stable unfolding of a variable]" "-dsuppress-module-prefixes[Suppress the printing of module qualification prefixes]" "-dsuppress-timestamps[Suppress timestamps in dumps]" "-dsuppress-type-signatures[Suppress type signatures]" "-dsuppress-type-applications[Suppress type applications]" "-dsuppress-coercions[Suppress the printing of coercions in Core dumps to make them shorter]" "-dsuppress-coercion-types[Suppress the printing of coercion types]" "-dsuppress-var-kinds[Suppress the printing of variable kinds]" "-dsuppress-stg-free-vars[Suppress the printing of closure free variable lists in STG output]" "-dsuppress-core-sizes[Suppress the printing of core size stats per binding]" "-dsuppress-stg-reps[Suppress rep annotations on STG args]" "-dlint[Enable several common internal sanity checkers]" "-dcore-lint[Turn on internal sanity checking]" "-dlinear-core-lint[Turn on internal sanity checking]" "-dstg-lint[STG pass sanity checking]" "-dcmm-lint[C-\\- pass sanity checking]" "-dasm-lint[ASM pass sanity checking]" "-fllvm-fill-undef-with-garbage[Intruct LLVM to fill dead STG registers with garbage]" "-falignment-sanitisation[Compile with alignment checks for all info table dereferences]" "-fproc-alignment[Align functions at given boundary]" "-fcatch-nonexhaustive-cases[Add a default error alternative to case expressions]" "-forig-thunk-info[Generate stg_orig_thunk_info stack frames on thunk entry]" "-fcheck-prim-bounds[Instrument array primops with bounds checks]" "-fcmm-thread-sanitizer[Enable ThreadSanitizer instrumentation of memory accesses]" "-dinitial-unique=[Start UniqSupply allocation]:supply" "-dunique-increment=[Set the increment for the generated Unique's]:i" "-dno-typeable-binds[Don't generate bindings for Typeable methods]" "-dtag-inference-checks[Affirm tag inference results are correct at runtime]" "-funoptimized-core-for-interpreter[Disable optimizations with the interpreter]" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/packages.rst.txt local -a packages_flags=( "*-package[Expose package]:_ghc_pkg_list_packages" "*-package-id[Expose package by id]:id" "-hide-all-packages[Hide all packages by default]" "*-hide-package[Hide package]:package:_ghc_pkg_list_packages" "*-ignore-package[Ignore package]:package:_ghc_pkg_list_packages" "-no-auto-link-packages[Don't automatically link in the base and rts packages]" "-this-unit-id[Compile to be part of unit]:id" "*-trust[Expose package and set it to be trusted]:package:_ghc_pkg_list_packages" "*-distrust[Expose package and set it to be distrusted]:package:_ghc_pkg_list_packages" "-distrust-all-packages[Distrust all packages by default]" "-package-db[Add file to the package db stack]:file:_files" "-no-global-package-db[Remove the global package db from the stack]" "-no-user-package-db[Remove the user's package db from the stack]" "-clear-package-db[Clear the package db stack]" "-global-package-db[Add the global package db to the stack]" "-user-package-db[Add the user's package db to the stack]" "-package-env[Use the specified package environment]:file:_files" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/phases.rst.txt local -a phases_flags=( "-pgmL[Literate pre-processor command]:cmd" "-pgmP[C pre-processor command]:cmd" "-pgmJSP[JavaScript C-pre-processor command]:cmd" "-pgmCmmP[C-- C pre-processor command]:cmd" "-pgmc[C compilercommand]:cmd" "-pgmcxx[C++ compiler command]:cmd" "-pgmlo[LLVM optimiser command]:cmd" "-pgmlc[LLVM compiler command]:cmd" "-pgmlas[LLVM assembler command]:cmd" "-pgms[splitter command]:cmd" "-pgma[assembler command]:cmd" "-pgml[linker command]:cmd" "-pgmlm[linker command when merging object files]:cmd" "-pgmF[pre-processor command when -F is specified]:cmd" "-pgmotool[inspect mach-o dylibs command]:cmd" "-pgminstall_name_tool[command to inject runpath into mach-o dylibs on macOS]:command" "-pgmwindres[command for embedding manifests on Windows]:command" "-pgmi[external interpreter command]:command" "-optL[literate pre-processor options]:options" "-optP[cpp options]:options" "-optJSP[JavaScript C pre-processor options]:options" "-optCmmP[C-- C pre-processor options]:options" "-optF[custom pre-processor options]:options" "-optc[C compiler options]:options" "-pgml-supports-no-pie[Indicate that the linker supports -no-pie]" "-optcxx[C++ compiler options]:options" "-optlo[LLVM optimiser options]:options" "-optlc[LLVM compiler options]:options" "-optlas[LLVM assembler options]:options" "-opta[assembler options]:options" "-optl[linker options]:options" "-optlmption⟩[linker options when merging object files]:options" "-optwindres[windres options]:options" "-opti[options of the interpreter sub-process]:options" "-cpp[Run the C pre-processor on Haskell source files]" "*-D[Define a symbol in the C pre-processor]:symbol" "*-U[Undefine a symbol in the C pre-processor]:symbol" "*-I[Directories for #include files]:dir:_files -/" "-F[Enable the use of a pre-processor]" "-fasm[Use the native code generator]" "-fllvm[Compile using the LLVM code generator]" "-fno-code[Omit code generation]" "-fwrite-interface[Always write interface files]" "-fwrite-if-simplified-core[Write an interface file containing the simplified core of the module]" "-fobject-code[Generate object code]" "-fbyte-code[Generate byte-code]" "-fbyte-code-and-object-code[Generate object code and byte-code]" "-fPIC[Generate position-independent code (where available)]" "-fexternal-dynamic-refs[Generate code for linking against dynamic libraries]" "-fPIE[Generate code for a position-independent executable (where available)]" "-dynamic[Build dynamically-linked object files and executables]" "-dynamic-too[Build dynamic object files *as well as* static object files during compilation]" "-fexpose-internal-symbols[Produce symbols for all functions, including internal functions]" "-fprefer-byte-code[Use byte-code if it is available to evaluate TH splices]" "*-l[Link in library]:lib:->library" "-c[Stop after generating object file]" "-framework[Link in the framework]:name" "-staticlib[Generate a standalone static library]" "*-L[Directories for searching libraries]:dir:_files -/" "-fuse-rpaths[Set the rpath based on -L flags]" "*-framework-path ⟨dir⟩[Directories searched for frameworks on Darwin/OS X/iOS]:dir:_files -/" "-fsplit-sections[Split sections for link-time dead-code stripping]" "-static[Use static Haskell libraries]" "-dynamic[Build dynamically-linked object files and executables]" "-shared[Generate a shared library (as opposed to an executable)]" "-dynload[Selects one of a number of modes for finding shared libraries at runtime]" "-flink-rts[Link the runtime when generating a shared or static library]" "-main-is[Set main module and function]:thing" "-no-hs-main[Don't assume this program contains main]" "-debug[Use the debugging runtime]" "-threaded[Use the threaded runtime]" "-single-threaded[Use the single-threaded runtime]" "-eventlog[Enable runtime event tracing]" "-rtsopts=[Control whether the RTS behaviour]:flag:(none some all ignore ignoreAll)" "-with-rtsopts=[Default RTS options]:options" "-no-rtsopts-suggestions[Don't print RTS suggestions about linking with]" "-fno-gen-manifest[Do not generate a manifest file (Windows only)]" "-fno-embed-manifest[Do not embed the manifest in the executable (Windows only)]" "-fno-shared-implib[Don't generate an import library for a DLL (Windows only)]" "-dylib-install-name[Set the install name]:name:_files" "-rdynamic[add all symbols, not only used ones, to the dynamic symbol table]" "-fwhole-archive-hs-libs[Inserts the flag '-Wl,--whole-archive' before any -l flags]" "-pie[Instruct the linker to produce a position-independent executable]" "-no-pie[Don't instruct the linker to produce a position-independent executable]" "-fkeep-cafs[Do not garbage-collect CAFs (top-level expressions) at runtime]" "-fcompact-unwind[Instruct the linker to produce a __compact_unwind section.]" ) local -a profiling_flags=( "-prof[Turn on profiling]" "-fno-prof-count-entries[Do not collect entry counts]" "-fprof-callers=[Auto-add SCCs to all call-sites of the named function]:name" "-fprof-auto[Auto-add SCCs to all bindings not marked INLINE]" "-fprof-auto-top[Auto-add SCCs to all top-level bindings not marked INLINE]" "-fprof-auto-exported[Auto-add SCCs to all exported bindings not marked INLINE]" "-fprof-auto-calls[Auto-add SCCs to all call sites]" "-fprof-late[Auto-add SCCs to all top level bindings *after* the core pipeline has run]" "-fprof-late-inline[Auto-add SCCs to all top level bindings *after* the optimizer has run and retain them when inlining]" "-fprof-late-overloaded[Auto-add SCCs to all top level overloaded bindings *after* the core pipeline has run]" "-fprof-late-overloaded-calls[Auto-add SCCs to all call sites that include dictionary arguments *after* the core pipeline has run]" "-fprof-cafs[Auto-add SCCs to all CAFs]" "-fprof-manual[Process manual 'SCC' annotations]" "-fhpc[Turn on Haskell program coverage instrumentation]" "-hpcdir=[Set the directory where GHC places '.mix' files]:dir:_files -/" "-ticky[Turn on ticky-ticky profiling]" "-ticky-allocd[Track the number of times each closure type is allocated]" "-ticky-dyn-thunk[Track allocations of dynamic thunks]" "-ticky-LNE[Treat join point binders similar to thunks/functions]" "-ticky-tag-checks[Emit dummy ticky counters to record how many tag-inference checks tag inference avoided]" "-ticky-ap-thunk[Don't use standard AP thunks on order to get more reliable entry counters]" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/separate_compilation.rst.txt local -a separate_compilation_flags=( "*-i-[import path directories]:dir:->ghc_include_directory" "-o[set output filename]:file:_files" "-dyno[set dynamic output filename]:file:_files" "-odir[set directory for object files]:dir:_files -/" "-ohi[set the filename in which to put the interface]:file:_files" "-dynohi[set the filename in which to put the dynamic interface]:file:_files" "-hidir[set directory for interface files]:dir:_files -/" "-hiedir[set directory for extended interface files]:dir:_files -/" "-stubdir[redirect FFI stub files]:dir:_files -/" "-dumpdir[redirect dump files]:dir:_files -/" "-outputdir[set output directory]:dir:_files -/" "-osuf[set the output file suffix]:suffix" "-dynosuf[set the dynamic output file suffix]:suffix" "-hisuf[set the suffix to use for interface files]:suffix" "-dynhisuf[set the suffix to use for dynamic interface files]:suffix" "-hiesuf[set the suffix to use for extended interface files]:suffix" "-hcsuf[set the suffix to use for intermediate C files]:suffix" "-keep-hc-file[Retain intermediate .hc files]" "-keep-hi-files[Retain intermediate .hi files]" "-keep-hscpp-file[Retain intermediate .hscpp files]" "-keep-llvm-file[Retain intermediate LLVM .ll files]" "-keep-o-files[Retain intermediate .o files]" "-keep-s-file[Retain intermediate .s files]" "-keep-tmp-files[Retain all intermediate temporary files]" "-tmpdir[set the directory for temporary files]:dir:_files -/" "-ddump-hi[Dump the new interface to stdout]" "-ddump-hi-diffs[Show the differences vs. the old interface]" "-ddump-minimal-imports[Dump a minimal set of imports]" "--show-iface[interface file]:file:_files" "-fwrite-ide-info[Write out extended interface files]" "-fvalidate-ide-info[Perform some sanity checks on the extended interface files]" "-fforce-recomp[Turn off recompilation checking]" "-fignore-optim-changes[Do not recompile modules just to match changes to optimisation flags]" "-fignore-hpc-changes[Do not recompile modules just to match changes to HPC flags]" "-ddump-mod-cycles[Dump module cycles]" "-dep-makefile[Makefile path]:file:_files" "-dep-suffix[Make dependencies that declare that files with suffix]:suffix" "-exclude-module=[exclude module]:file:_files" "-include-pkg-deps[Regard modules imported from packages as unstable]" "-include-cpp-deps[Include preprocessor dependencies]" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/using-concurrent.rst.txt local -a concurrent_flags=( "-feager-blackholing[Turn on eager blackholing]" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/using-optimisation.rst.txt local -a optimization_flags=( "-O-[Set optimization level]:num:(0 1 2)" "-fcore-constant-folding[Enable constant folding in Core]" "-fcase-merge[Enable case-merging]" "-fcase-folding[Enable constant folding in case expressions]" "-fcall-arity[Enable call-arity optimisation]" "-fexitification[Enables exitification optimisation]" "-fcmm-elim-common-blocks[Enable Cmm common block elimination]" "-fcmm-sink[Enable Cmm sinking]" "-fcmm-static-pred[Enable static control flow prediction]" "-fcmm-control-flow[Enable control flow optimisation in the Cmm backend]" "-fasm-shortcutting[Enable shortcutting on assembly]" "-fblock-layout-cfg[Use the new cfg based block layout algorithm]" "-fblock-layout-weights[Sets edge weights used by the new code layout algorithm]" "-fblock-layout-weightless[Ignore cfg weights for code layout]" "-fcpr-anal[Turn on Constructed Product Result analysis]" "-fcse[Enable common sub-expression elimination]" "-fstg-cse[Enable common sub-expression elimination on the STG]" "-fspec-eval[Enables speculative evaluation]" "-fspec-eval-dictfun[Enables speculative evaluation of dictionary functions]" "-fdicts-cheap[Make dictionary-valued expressions seem cheap to the optimiser]" "-fdicts-strict[Make dictionaries strict]" "-fdo-eta-reduction[Enable eta-reduction]" "-fdo-lambda-eta-expansion[Enable lambda eta-expansion]" "-fdo-clever-arg-eta-expansion[Enable sophisticated argument eta-expansion]" "-feager-blackholing[Turn on eager blackholing]" "-fexcess-precision[Enable excess intermediate precision]" "-fexpose-all-unfoldings[Expose all unfoldings, even for very large or recursive functions]" "-ffloat-in[Turn on the float-in transformation]" "-ffull-laziness[Turn on full laziness (floating bindings outwards)]" "-fignore-asserts[Ignore assertions in the source]" "-fignore-interface-pragmas[Ignore pragmas in interface files]" "-fkeep-auto-rules[Keep all 'auto' rules, generated by specialisation]" "-flate-dmd-anal[Run demand analysis again]" "-fliberate-case[Turn on the liberate-case transformation]" "-fliberate-case-threshold=[Set the size threshold for the liberate-case]:threshold" "-floopification[Turn saturated self-recursive tail-calls into local jumps in the generated assmbly]" "-fmax-inline-alloc-size=[Set the maximum size of inline array allocations]:size" "-fmax-inline-memcpy-insns=[Inline 'memcpy' calls if they would generate no more than 'n' insns]:insns" "-fmax-inline-memset-insns=[Inline 'memset' calls if they would generate no more than 'n' insns]:insns" "-fmax-relevant-binds=[Set the maximum number of bindings to display in type error messages]:num" "-fmax-uncovered-patterns=[Set the maximum number of patterns to display in warnings about non-exhaustive ones]:nums" "-fmax-simplifier-iterations=[Set the max iterations for the simplifier]:num" "-flocal-float-out[Enable local floating definitions out of let-binds]" "-flocal-float-out-top-level[Enable local floating to float top-level bindings]" "-fmax-worker-args=[Maximum number of value arguments for a worker]:workers" "-fno-opt-coercion[Turn off the coercion optimiser]" "-fno-pre-inlining[Turn off pre-inlining]" "-fno-state-hack[Turn off the 'state hack' whereby any lambda with a real-world]" "-fomit-interface-pragmas[Don't generate interface pragmas]" "-fomit-yields[Omit heap checks when no allocation is being performed]" "-fpedantic-bottoms[Make GHC be more precise about its treatment of bottom]" "-fregs-graph[Use the graph colouring register allocator for register]" "-fregs-iterative[Use the iterative coalescing graph colouring register allocator]" "-fsimplifier-phases=[Set the number of phases for the simplifier]:phases" "-fsimpl-tick-factor=[Set the percentage factor for simplifier ticks]:factor" "-fdmd-unbox-width=[Boxity analysis pretends that returned records with this many fields can be unboxed]:width" "-fspec-constr[Turn on the SpecConstr transformation]" "-fspec-constr-keen[Specialize a call with an explicit constructor argument]" "-fspec-constr-count=[Set to ⟨n⟩ the maximum number of specialisations created by the SpecConstr transformation]:count" "-fspec-constr-threshold=[Set the size threshold for the SpecConstr]:threshold" "-fspecialise[Turn on specialisation of overloaded functions]" "-fspecialise-aggressively[Turn on specialisation of overloaded functions regardless of size]" "-fcross-module-specialise[Turn on specialisation of overloaded functions imported from other modules]" "-fpolymorphic-specialisation[Allow specialisation to abstract over free type variables]" "-flate-specialise[Run a late specialisation pass]" "-fspecialise-incoherents[Enable specialisation on incoherent instances]" "-finline-generics[Annotate methods of derived Generic and Generic1 instances with inline pragmas]" "-finline-generics-aggressively[Annotate methods of all derived Generic and Generic1 instances with inline pragmas]" "-fsolve-constant-dicts[When solving constraints, try to eagerly solve super classes]" "-fstatic-argument-transformation[Turn on the static argument transformation]" "-fstg-lift-lams[Enable late lambda lifting on the STG intermediate]" "-fstg-lift-lams-known[Allow turning known into unknown calls while performing]" "-fstg-lift-lams-non-rec-args=[Create top-level non-recursive functions with at most parameters]:num" "-fstg-lift-lams-rec-args=[Create top-level recursive functions with at most parameters]:num" "-fstrictness[Turn on demand analysis]" "-fstrictness-before=[Run an additional demand analysis before simplifier phase ⟨n⟩ parameters]" "-funbox-small-strict-fields[Flatten strict constructor fields with a pointer-sized]" "-funbox-strict-fields[Flatten strict constructor fields]" "-funfolding-creation-threshold=[Tweak unfolding settings]:threshold" "-funfolding-dict-discount=[Tweak unfolding settings]:num" "-funfolding-fun-discount=[Tweak unfolding settings]:num" "-funfolding-use-threshold=[Tweak unfolding settings]:threshold" "-funfolding-case-threshold=[Reduce inlining for cases nested deeper than n]:threshold" "-funfolding-case-scaling=[Apply a penalty of (inlining_cost * '1/n') for each level of case nesting]:penalty" "-fworker-wrapper[Enable the worker/wrapper transformation]" "-fworker-wrapper-cbv[Enable w/w splits for wrappers whos sole purpose is evaluating arguments]" "-fbinary-blob-threshold=[Tweak assembly generator for binary blobs]:size" ) # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/packages-warnings.rst.txt local -a warnings_flags=( "-Wdefault[enable default flags]" "-W[enable normal warnings]" "-Wall[enable almost all warnings]" "-Weverything[enable all warnings supported by GHC]" "-Wcompat[enable future compatibility warnings]" "-w[disable all warnings]" "-fshow-warning-groups[show which group an emitted warning belongs to]" "*-Werror=-[make warnings fatal]:flag" "*-Wwarn=-[make warnings non-fatal]:flag" "*-Wno-error=[make a specific warning non-fatal]:flag" "-Wunrecognised-warning-flags[throw a warning when an unrecognised -W... flag]" "-Wcompat-unqualified-imports[Report unqualified imports of core libraries]" "-Wprepositive-qualified-module[Report imports with a leading/prepositive 'qualified']" "-Wtyped-holes[Report warnings when errors are]" "-Wdeferred-type-errors[Report warnings when deferred type errors are enabled]" "-Wdeferred-out-of-scope-variables[Report warnings when variable out-of-scope errors are]" "-Wpartial-type-signatures[warn about holes in partial type signatures when]" "-fhelpful-errors[Make suggestions for mis-spelled names.]" "-Wunrecognised-pragmas[warn about uses of pragmas that GHC doesn't recognise]" "-Wmisplaced-pragmas[warn about uses of file header pragmas in the module body]" "-Wmissed-specialisations[warn when specialisation of an imported, overloaded function fails.]" "-Wall-missed-specialisations[warn when specialisation of any overloaded function fails.]" "-Wextended-warnings[warn about uses of functions & types that have WARNING or DEPRECATED pragmas]" ## TODO # "-Wx-[warn about uses of functions & types that have WARNING pragmas with the given category]:category" "-Wdeprecations[warn about uses of functions & types that have DEPRECATED pragmas]" "-Wwarnings-deprecations[warn about uses of functions & types that have DEPRECATED pragmas]" "-Wnoncanonical-monad-instances[warn when Applicative or Monad instances have noncanonical definitions]" "-Wnoncanonical-monoid-instances[warn when Semigroup or Monfoid instances have noncanonical definitions]" "-Wdeprecated-flags[warn about uses of commandline flags that are deprecated]" "-Wunsupported-calling-conventions[warn about use of an unsupported calling convention]" "-Wdodgy-foreign-imports[warn about dodgy foreign imports]" "-Wdodgy-exports[warn about dodgy exports]" "-Wdodgy-imports[warn about dodgy imports]" "-Woverflowed-literals[warn about literals that will overflow their type]" "-Wempty-enumerations[warn about enumerations that are empty]" "-Wderiving-defaults[warn about default deriving when using both]" "-Wduplicate-constraints[warn when a constraint appears duplicated in a type signature]" "-Wredundant-constraints[Have the compiler warn about redundant constraints in type signatures.]" "-Wduplicate-exports[warn when an entity is exported multiple times]" "-Widentities[warn about uses of Prelude numeric conversions that are probably the identity (and hence could be omitted)]" "-Wimplicit-lift[warn about implicit lift in Template Haskell quotes]" "-Wimplicit-prelude[warn when the Prelude is implicitly imported]" "-Wincomplete-patterns[warn when a pattern match could fail]" "-Wincomplete-uni-patterns[warn when a pattern match in a lambda expression]" "-fmax-pmcheck-models=[soft limit on the number of parallel models]:models" "-Wincomplete-record-updates[warn when a record update could fail]" "-Wincomplete-record-selectors[warn when a record selector application could fail]" "-Wmissing-deriving-strategies[warn when a deriving clause is missing a deriving strategy]" "-Wmissing-fields[warn when fields of a record are uninitialised]" "-Wmissing-export-lists[warn when a module declaration does not explicitly list all exports]" "-Wmissing-import-lists[warn when an import declaration does not explicitly list all the names brought into scope]" "-Wmissing-methods[warn when class methods are undefined]" "-Wmissing-signatures[warn about top-level functions without signatures]" "-Wmissing-exported-signatures[warn about top-level functions without signatures]" "-Wmissing-local-signatures[warn about polymorphic local bindings without signatures]" "-Wmissing-pattern-synonym-signatures[warn when pattern synonyms do not have type signatures]" "-Wmissing-kind-signatures[warn when type declarations don't have kind signatures nor CUSKs]" "-Wmissing-poly-kind-signatures[warn when inferred polykinded type or class declaration don't have kind signatures nor CUSKs]" "-Wmissing-exported-pattern-synonym-signatures[warn about pattern synonyms without signatures, only if they are exported]" "-Wname-shadowing[warn when names are shadowed]" "-Worphans[warn when the module contains orphan instance declarations or rewrite rules]" "-Woverlapping-patterns[warn about overlapping patterns]" "-Winaccessible-code[warn about inaccessible code]" "-Wstar-is-type[warn when * is used to mean Data.Kind.Type]" "-Wstar-binder[warn about binding the (*) type operator despite]" "-Wsimplifiable-class-constraints[Warn about class constraints in a type signature that can be simplified using a top-level instance declaration]" "-Wtabs[warn if there are tabs in the source file]" "-Wtype-defaults[warn when defaulting happens]" "-Wmonomorphism-restriction[warn when the Monomorphism Restriction is applied]" "-Wunsupported-llvm-version[Warn when using -fllvm with an unsupported version of LLVM]" "-Wmissed-extra-shared-lib[Warn when GHCi can't load a shared li.]" "-Wunticked-promoted-constructors[warn if promoted constructors are not ticked]" "-Wunused-binds[warn about bindings that are unused. Alias for]" "-Wunused-top-binds[warn about top-level bindings that are unused]" "-Wunused-local-binds[warn about local bindings that are unused]" "-Wunused-pattern-binds[warn about pattern match bindings that are unused]" "-Wunused-imports[warn about unnecessary imports]" "-Wunused-matches[warn about variables in patterns that aren't used]" "-Wunused-do-bind[warn about do bindings that appear to throw away values of types other than ()]" "-Wunused-type-patterns[warn about unused type variables which arise from patterns in in type family and data family instances]" "-Wunused-foralls[warn about type variables in user-written forall that are unused]" "-Wunused-record-wildcards[Warn about record wildcard matches when none of the bound variables are used.]" "-Wredundant-bang-patterns[Warn about redundant bang patterns]" "-Wredundant-record-wildcards[Warn about record wildcard matches when the wildcard binds no patterns]" "-Wredundant-strictness-flags[Warn about redundant strictness flags]" "-Wwrong-do-bind[warn about do bindings that appear to throw away monadic values]" "-Winline-rule-shadowing[Warn if a rewrite RULE might fail to fire]" "-Wcpp-undef[warn on uses of the #if directive on undefined identifiers]" "-Wunbanged-strict-patterns[warn on pattern bind of unlifted variable]" "-Wmissing-home-modules[warn when encountering a home module imported]" "-Wpartial-fields[warn when defining a partial record field]" "-Wunused-packages[warn when package is requested on command line, but not needed]" "-Winvalid-haddock[warn when a Haddock comment occurs in an invalid position]" "-Woperator-whitespace-ext-conflict[warn on uses of infix operators that would be parsed differently]" "-Woperator-whitespace[warn on prefix, suffix, and tight infix uses of infix operators]" "-Wderiving-typeable[warn when Typeable is derived]" "-Wambiguous-fields[warn about ambiguous field selectors or updates]" "-Wunicode-bidirectional-format-characters[warn about the usage of unicode bidirectional layout override characters]" "-Wgadt-mono-local-binds[warn when pattern matching on a GADT without MonoLocalBinds]" "-Wtype-equality-out-of-scope[warn when type equality a ~ b is used despite being out of scope]" "-Wtype-equality-requires-operators[warn when type equality a ~ b is used despite being out of scope]" "-Wloopy-superclass-solve[*(deprecated)* warn when creating potentially-loopy superclass constraint evidence]" "-Wterm-variable-capture[warn when an implicitly quantified type variable captures a term's name]" "-Wmissing-role-annotations[warn when type declarations don't have role annotations]" "-Wimplicit-rhs-quantification[warn when type variables on the RHS of a type synonym are implicitly quantified]" "-Wdeprecated-type-abstractions[warn when type abstractions in constructor patterns are used without enabling TypeApplications]" "-Wincomplete-export-warnings[warn when some but not all of exports for a name are warned about]" "-Wbadly-staged-types[warn when type binding is used at the wrong TH stage.]" "-Winconsistent-flags[warn when command line options are inconsistent in some way.]" "-Wdata-kinds-tc[warn when an illegal use of a type or kind without]" "-Wdefaulted-exception-context[warn when an Control.Exception.Context.ExceptionContext implicit parameter is defaulted to]" ) local -a extension_flags=( "-XCPP[Enable the C Preprocessor]" "-XAllowAmbiguousTypes[Allow the user to write ambiguous types]" "-XApplicativeDo[Enable Applicative do-notation desugaring]" "-XArrows[Enable arrow notation extension]" "-XBinaryLiterals[Enable support for binary literals]" "-XBlockArguments[Allow do blocks and other constructs as function arguments.]" "-XConstrainedClassMethods[Enable constrained class methods]" "-XConstraintKinds[Enable a kind of constraints]" "-XGHC2024[Use GHC's set of default language extensions from 2024]" "-XGHC2021[Use GHC's set of default language extensions from 2021]" "-XHaskell2010[Use the Haskell 2010 language edition]" "-XDataKinds[Enable datatype promotion]" "-XListTuplePuns[Enable punning for list, tuple and sum types]" "-XDatatypeContexts[Allow contexts on data types]" "-XDefaultSignatures[Enable default signatures.]" "-XDeriveAnyClass[Enable deriving for any class.]" "-XDeriveFunctor[Enable deriving for the Functor class]" "-XDeriveFoldable[Enable deriving for the Foldable class]" "-XDeriveTraversable[Enable deriving for the Traversable class]" "-XDeriveDataTypeable[Enable deriving for the Data class]" "-XDeriveLift[Enable deriving for the Lift class]" "-XDerivingStrategies[Enables deriving strategies.]" "-XDerivingVia[Enable deriving instances via types of the same runtime representation]" "-XDisambiguateRecordFields[Enable record field disambiguation]" "-XDuplicateRecordFields[Allow definition of record types with identically-named fields]" "-XEmptyCase[Allow empty case alternatives]" "-XEmptyDataDeriving[Allow deriving instances of standard type classes for empty data types]" "-XExistentialQuantification[Enable liberalised type synonyms]" "-XExplicitForAll[Enable explicit universal quantification]" "-XExplicitNamespaces[Enable using the keyword type to specify the namespace of entries in imports and exports]" "-XExtendedLiterals[Enable numeric literal postfix syntax for unboxed integers]" "-XForeignFunctionInterface[Enable foreign function interface]" "-XUnliftedFFITypes[Enable unlifted FFI types]" "-XGHCForeignImportPrim[Enable prim calling convention. Intended for internal use only]" "-XInterruptibleFFI[Enable interruptible FFI]" "-XCApiFFI[Enable the CAPI calling convention]" "-XFieldSelectors[Control visibility of field selector functions]" "-XFlexibleContexts[Remove some restrictions on class contexts]" "-XFunctionalDependencies[Enable functional dependencies]" "-XGADTs[Enable generalised algebraic data types]" "-XGADTSyntax[Enable generalised algebraic data type syntax]" "-XTransformListComp[Enable generalised list comprehensions]" "-XDeriveGeneric[Enable deriving for the Generic class]" "-XHexFloatLiterals[Enable support for hexadecimal floating point literals]" "-XImplicitParams[Enable Implicit Parameters]" "-XImportQualifiedPost[ImportQualifiedPost allows the syntax import M qualified]" "-XImpredicativeTypes[Enable impredicative types]" "-XTypeSynonymInstances[Enable type synonyms in instance heads]" "-XFlexibleInstances[Enable flexible instances]" "-XUndecidableInstances[Enable undecidable instances]" "-XOverlappingInstances[Enable overlapping instances]" "-XIncoherentInstances[Enable incoherent instances]" "-XInstanceSigs[Enable instance signatures]" "-XKindSignatures[Enable kind signatures]" "-XLambdaCase[Enable lambda-case expressions]" "-XMonoLocalBinds[Enable do not generalise local bindings]" "-XLexicalNegation[Use whitespace to determine whether the minus sign stands for negation or subtraction]" "-XLiberalTypeSynonyms[Enable liberalised type synonyms]" "-XLinearTypes[Enable linear types]" "-XMagicHash[Allow '#' as a postfix modifier on identifiers]" "-XMonadComprehensions[Enable monad comprehensions]" "-XNoMonomorphismRestriction[Disable the monomorphism restriction]" "-XMultiParamTypeClasses[Enable multi parameter type classes]" "-XMultiWayIf[Enable multi-way if-expressions]" "-XNegativeLiterals[Enable support for negative literals]" "-XGeneralisedNewtypeDeriving[Enable newtype deriving]" "-XNPlusKPatterns[Enable support for n+k patterns]" "-XEmptyDataDecls[Allow definition of empty data types]" "-XNumDecimals[Enable support for 'fractional' integer literals]" "-XNumericUnderscores[Enable support for numeric underscores]" "-XOverloadedLabels[Enable overloaded labels]" "-XOverloadedLists[Enable overloaded lists]" "-XOverloadedRecordDot[Record '.' syntax]" "-XOverloadedRecordUpdate[Record '.' syntax record updates]" "-XOverloadedStrings[Enable overloaded string literals]" "-XPackageImports[Enable package-qualified imports]" "-XParallelListComp[Enable parallel list comprehensions]" "-XPartialTypeSignatures[Enable partial type signatures]" "-XNamedWildCards[Enable named wildcards.]" "-XNoPatternGuards[Disable pattern guards]" "-XPatternSynonyms[Enable pattern synonyms]" "-XTypeInType[Deprecated. Enable kind polymorphism and datatype promotion]" "-XPolyKinds[Enable kind polymorphism]" "-XCUSKs[Enable detection of complete user-supplied kind signatures]" "-XStandaloneKindSignatures[Allow the use of standalone kind signatures]" "-XStarIsType[Treat '*' as Data.Kind.Type]" "-XUnboxedTuples[Enable the use of unboxed tuple syntax]" "-XUnboxedSums[Enable unboxed sums]" "-XUnliftedNewtypes[Enable unlifted newtypes]" "-XUnliftedDatatypes[Enable unlifted data types]" "-XQualifiedDo[Enable qualified do-notation desugaring]" "-XQuantifiedConstraints[Allow forall quantifiers in constraints]" "-XRankNTypes[Enable rank-N types]" "-XRank2Types[Enable rank-2 types]" "-XDeepSubsumption[Enable deep subsumption]" "-XNoImplicitPrelude[Don't implicitly import Prelude]" "-XRebindableSyntax[Employ rebindable syntax]" "-XPostfixOperators[Enable postfix operators]" "-XNamedFieldPuns[Enable record puns]" "-XRecordWildCards[Enable record wildcards]" "-XRecursiveDo[Enable recursive do (mdo) notation]" "-XRequiredTypeArguments[Enable required type arguments in terms]" "-XRoleAnnotations[Enable role annotations]" "-XSafe[Enable the Safe mode]" "-XTrustworthy[Enable the Trustworthy mode]" "-XUnsafe[Enable Unsafe mode.]" "-XScopedTypeVariables[Enable lexically-scoped type variables]" "-XStandaloneDeriving[Enable standalone deriving]" "-XStaticPointers[Enable static pointers]" "-XBangPatterns[Enable bang patterns]" "-XStrictData[Enable default strict datatype fields]" "-XStrict[Make bindings in the current module strict by default]" "-XTemplateHaskell[Enable Template Haskell]" "-XTemplateHaskellQuotes[Enable quotation subset of Template Haskell]" "-XQuasiQuotes[Enable quasiquotation]" "-XNoTraditionalRecordSyntax[Disable support for traditional record syntax]" "-XTupleSections[Enable tuple sections]" "-XTypeAbstractions[Enable type abstraction syntax in patterns and type variable binders]" "-XTypeApplications[Enable type application syntax in terms and types]" "-XTypeData[Enable type data declarations]" "-XTypeFamilies[Enable type families]" "-XTypeFamilyDependencies[Enable injective type families]" "-XTypeOperators[Enable type operators]" "-XUndecidableSuperClasses[Allow all superclass constraints]" "-XUnicodeSyntax[Enable unicode syntax]" "-XViewPatterns[Enable view patterns]" ) _arguments \ $using_flags[@] \ $debug_info_flags[@] \ $debugging_flags[@] \ $package_flags[@] \ $phases_flags[@] \ $profiling_flags[@] \ $separate_compilation_flags[@] \ $concurrent_flags[@] \ $optimization_flags[@] \ $warnings_flags[@] \ $extension_flags[@] \ "*:: :_files" \ && ret=0 case $state in (ghc_include_directory) _ghc_include_directory && ret=0 ;; (library) _wanted libraries expl library \ compadd - \ ${^=LD_LIBRARY_PATH:-/usr/lib /usr/local/lib}/lib*.(a|so*)(:t:fr:s/lib//) \ && ret=0 ;; esac return ret } _ghc_include_directory() { compset -P '*:' compset -S ':*' _path_files -r': ' -/ } # # ghc-pkg # _ghc_pkg() { typeset -A opt_args local context state line local curcontext="$curcontext" local ret=1 _arguments -C \ '(- *)'{-h,--help}'[Print this usage information]' \ '1: :_ghc_pkg_subcommands' \ '*:: :->arg' \ && ret=0 case $state in (arg) local -a options=( "--user[use current user's package database]" '--global[user the global package database]' {-f,--package-db=}'[use the specified package database]:database:_files' '--global-package-db[location of the global package database]:dir:_files -/' '(--no-user-package-db --user-package-db)--no-user-package-db[never read the user package database]' '(--no-user-package-db --user-package-db)--user-package-db=[location of the user package database]:database:_files' '--force[ignore missing dependencies, directories and libraries]' '--force-files[ignore missing directories and libraries only]' '--enable-multi-instance[allow registering multiple instances of the same package version]' '--expand-env-vars[expand environment variables in input package descriptions]' '(--expand-pkgroot --no-expand-pkgroot)--expand-pkgroot[expand pkgroot-relative paths in output package descriptions]' '(--expand-pkgroot --no-expand-pkgroot)--no-expand-pkgroot[preserve pkgroot-relative paths in output package descriptions]' '(- *)'{-?,--help}'[display this help and exit]' '(- *)'{-V,--version}'[output version information and exit]' '--simple-output[print output in easy-to-parse format for some commands]' '--show-unit-ids[print unit-ids instead of package identifiers]' '--names-only[only print package names, not versions]' '--ignore-case[ignore case for substring matching]' {--ipid,--unit-id}'[interpret package arguments as unit IDs]' {-V,--verbose=-}'[verbosity level]:level:(0 1 2)' ) case $words[1] in (init|register|update) options+=('*: :_files') ;; (unregister|expose|hide|trust|distrust|list|latest|describe) options+=('*: :_ghc_pkg_list_packages') ;; (field) options+=('*: :_ghc_pkg_field') ;; (find-module) options+=('*: :_ghc_pkg_find-module') ;; esac _arguments $options && ret=0 ;; esac return ret } _ghc_pkg_subcommands() { local -a subcommands=( "init:Create and initialize a package database at the given location" "register:Register the package using package description" "update:Register the package (overwriting existing package)" "unregister:Unregister the specified package" "check:Check consistency of dependencies in the package database" "expose:Expose the specified package" "hide:Hide the specified package" "trust:Trust the specified package" "distrust:Distruct the specified package" "list:List registered packages" "find-module:List registered packages exposing module" "latest:Prints the highest registered version of a package" "describe:Give the registered description for the specified package" "field:Extract the specified field of the package description" "dot:Generate a graph of the package dependencies in a form suitable" "dump:Dump the registered description for every package" "recache:Regenerate the package database cache" ) _describe -t subcommands 'subcommand' subcommands "$@" } _ghc_pkg_field() { _ghc_pkg_available_packages _arguments \ '1:package:_values $_ghc_pkg_packages' \ '2:field:_ghc_pkg_field_fields' } _ghc_pkg_field_fields() { # https://ghc.gitlab.haskell.org/ghc/doc/users_guide/_sources/packages.rst.txt local -a fields=( name id version license license-file copyright maintainer stability homepage package-url description category author exposed exposed-modules hidden-modules reexposed-modules trusted import-dirs library-dirs hs-libraries extra-libraries include-dirs includes depends hugs-options cc-options ld-options framework-dirs frameworks haddock-interfaces haddock-html ) _values -s ',' $fields } _ghc_pkg_find-module() { if ( [[ ${+_ghc_modules} -eq 0 ]] || _cache_invalid GHC_MODULES ) && ! _retrieve_cache GHC_MODULES; then if (( $+commands[perl] )); then _ghc_modules=( $(ghc-pkg dump \ | perl -wln -00 -e 'm/^exposed-modules:(.*)/ms and print $1' 2>/dev/null \ | perl -wln -e 'm{^\s+([A-Z].*)$} and $a = $1 and $a =~ s/,/ /g; $a =~ s/ /\n/g and (($a =~ m/^(.*)\s+from\s+/ and print $1) or print $a)' 2>/dev/null )) else _ghc_modules=( $(ghc-pkg dump | sed -n '/^exposed-modules:/{s/^exposed-modules:[ ]\+\(.*\)$/\1/;s/ /\n/;p;be};b;:e;n;/^ /{s/^[ ]\+\(.*\)$/\1/;s/ /\n/;p;be}') ) fi _store_cache GHC_MODULES _ghc_modules fi compadd "$@" -a -- _ghc_modules } _ghc_pkg_available_packages() { if ( [[ ${+_ghc_pkg_packages} -eq 0 ]] || _cache_invalid GHC_PACKAGES ) && ! _retrieve_cache GHC_PACKAGES; then _ghc_pkg_packages=( $(ghc-pkg list --simple-output --names-only) ) _store_cache GHC_PACKAGES _ghc_pkg_packages fi } _ghc_pkg_list_packages() { _ghc_pkg_available_packages compadd "$@" -a -- _ghc_pkg_packages } # # dispatcher # case $service in (ghc) _ghc_compiler ;; (ghci) _ghc_ghci ;; (ghc-pkg) _ghc_pkg ;; esac # Local Variables: # mode: Shell-Script # sh-indentation: 2 # indent-tabs-mode: nil # sh-basic-offset: 2 # End: # vim: ft=zsh sw=2 ts=2 et