├── .circleci └── config.yml ├── .editorconfig ├── .github ├── ISSUE_TEMPLATE │ ├── bug_report.md │ ├── enhancement_request.md │ └── support.md ├── actions │ ├── bindist-actions │ │ ├── action-deb10 │ │ │ └── action.yaml │ │ ├── action-deb11 │ │ │ └── action.yaml │ │ ├── action-deb12 │ │ │ └── action.yaml │ │ ├── action-deb9 │ │ │ └── action.yaml │ │ ├── action-fedora33 │ │ │ └── action.yaml │ │ ├── action-fedora40 │ │ │ └── action.yaml │ │ ├── action-mint193 │ │ │ └── action.yaml │ │ ├── action-mint202 │ │ │ └── action.yaml │ │ ├── action-mint213 │ │ │ └── action.yaml │ │ ├── action-ubuntu1804 │ │ │ └── action.yaml │ │ ├── action-ubuntu2004 │ │ │ └── action.yaml │ │ ├── action-ubuntu2204 │ │ │ └── action.yaml │ │ └── action-unknown │ │ │ └── action.yaml │ └── setup-build │ │ └── action.yml ├── dependabot.yml ├── generate-ci │ ├── LICENSE │ ├── README.mkd │ ├── cabal.project │ ├── gen_ci.hs │ ├── generate-ci.cabal │ └── generate-jobs ├── mergify.yml ├── scripts │ ├── bindist.sh │ ├── brew.sh │ ├── build.sh │ ├── cabal-cache.sh │ ├── common.sh │ ├── entrypoint.sh │ ├── env.sh │ ├── tar.sh │ ├── test.sh │ └── untar.sh └── workflows │ ├── bench.yml │ ├── caching.yml │ ├── flags.yml │ ├── hlint.yml │ ├── nix.yml │ ├── pre-commit.yml │ ├── release.yaml │ ├── s3-cache.yaml │ ├── supported-ghc-versions.json │ └── test.yml ├── .gitignore ├── .gitlab ├── darwin │ ├── nix │ │ ├── sources.json │ │ └── sources.nix │ └── toolchain.nix └── setup.sh ├── .gitmodules ├── .gitpod.Dockerfile ├── .gitpod.yml ├── .hlint.yaml ├── .pre-commit-config.yaml ├── .readthedocs.yaml ├── .stylish-haskell.yaml ├── CITATION.cff ├── CODEOWNERS ├── CODE_OF_CONDUCT.md ├── ChangeLog.md ├── FUNDING.yml ├── GNUmakefile ├── GenChangelogs.hs ├── LICENSE ├── README.md ├── RELEASING.md ├── Setup.hs ├── bench ├── Main.hs ├── MultiLayerModules.sh ├── README.md └── config.yaml ├── bindist ├── GNUmakefile.in ├── relpath.sh └── wrapper.in ├── cabal.project ├── default.nix ├── docs ├── .gitignore ├── Makefile ├── _static │ ├── .gitkeep │ └── theme_overrides.css ├── _templates │ └── .gitkeep ├── conf.py ├── configuration.md ├── contributing │ ├── contributing.md │ ├── imports.gif │ ├── index.rst │ ├── plugin-tutorial.lhs │ ├── plugin-tutorial.md │ └── settings-vscode.png ├── features.md ├── index.rst ├── installation.md ├── logos │ ├── logo-1024.png │ ├── logo-128.png │ ├── logo-256.png │ ├── logo-32.png │ ├── logo-512.png │ ├── logo-64.png │ └── logo.svg ├── requirements.txt ├── support │ ├── ghc-version-support.md │ ├── index.rst │ └── plugin-support.md ├── troubleshooting.md └── what-is-hls.md ├── docutils.nix ├── exe ├── Main.hs └── Wrapper.hs ├── flake.lock ├── flake.nix ├── fmt.sh ├── ghcide-bench ├── LICENSE ├── README.md ├── exe │ └── Main.hs ├── src │ ├── Experiments.hs │ └── Experiments │ │ └── Types.hs └── test │ └── Main.hs ├── ghcide-test ├── LICENSE ├── data │ ├── TH │ │ ├── THA.hs │ │ ├── THB.hs │ │ ├── THC.hs │ │ └── hie.yaml │ ├── THCoreFile │ │ ├── THA.hs │ │ ├── THB.hs │ │ ├── THC.hs │ │ └── hie.yaml │ ├── THLoading │ │ ├── A.hs │ │ ├── B.hs │ │ ├── THA.hs │ │ ├── THB.hs │ │ └── hie.yaml │ ├── THNewName │ │ ├── A.hs │ │ ├── B.hs │ │ ├── C.hs │ │ └── hie.yaml │ ├── THUnboxed │ │ ├── THA.hs │ │ ├── THB.hs │ │ ├── THC.hs │ │ └── hie.yaml │ ├── boot │ │ ├── A.hs │ │ ├── A.hs-boot │ │ ├── B.hs │ │ ├── C.hs │ │ └── hie.yaml │ ├── boot2 │ │ ├── A.hs │ │ ├── B.hs │ │ ├── B.hs-boot │ │ ├── C.hs │ │ ├── D.hs │ │ ├── E.hs │ │ └── hie.yaml │ ├── cabal-exe │ │ ├── a │ │ │ ├── a.cabal │ │ │ └── src │ │ │ │ └── Main.hs │ │ ├── cabal.project │ │ └── hie.yaml │ ├── hover │ │ ├── Bar.hs │ │ ├── Foo.hs │ │ ├── GotoHover.hs │ │ ├── GotoImplementation.hs │ │ ├── RecordDotSyntax.hs │ │ └── hie.yaml │ ├── ignore-fatal │ │ ├── IgnoreFatal.hs │ │ ├── cabal.project │ │ ├── hie.yaml │ │ └── ignore-fatal.cabal │ ├── multi-unit-reexport │ │ ├── a-1.0.0-inplace │ │ ├── a │ │ │ └── A.hs │ │ ├── b-1.0.0-inplace │ │ ├── b │ │ │ └── B.hs │ │ ├── c-1.0.0-inplace │ │ ├── c │ │ │ └── C.hs │ │ ├── cabal.project │ │ └── hie.yaml │ ├── multi-unit │ │ ├── a-1.0.0-inplace │ │ ├── a │ │ │ └── A.hs │ │ ├── b-1.0.0-inplace │ │ ├── b │ │ │ └── B.hs │ │ ├── c-1.0.0-inplace │ │ ├── c │ │ │ └── C.hs │ │ ├── cabal.project │ │ └── hie.yaml │ ├── multi │ │ ├── a │ │ │ ├── A.hs │ │ │ └── a.cabal │ │ ├── b │ │ │ ├── B.hs │ │ │ └── b.cabal │ │ ├── c │ │ │ ├── C.hs │ │ │ └── c.cabal │ │ ├── cabal.project │ │ └── hie.yaml │ ├── plugin-knownnat │ │ ├── KnownNat.hs │ │ ├── cabal.project │ │ └── plugin.cabal │ ├── recomp │ │ ├── A.hs │ │ ├── B.hs │ │ ├── P.hs │ │ └── hie.yaml │ ├── references │ │ ├── Main.hs │ │ ├── OtherModule.hs │ │ ├── OtherOtherModule.hs │ │ ├── References.hs │ │ └── hie.yaml │ ├── rootUri │ │ ├── dirA │ │ │ ├── Foo.hs │ │ │ └── foo.cabal │ │ └── dirB │ │ │ ├── Foo.hs │ │ │ └── foo.cabal │ ├── symlink │ │ ├── hie.yaml │ │ ├── other_loc │ │ │ └── .gitkeep │ │ ├── some_loc │ │ │ └── Sym.hs │ │ └── src │ │ │ └── Foo.hs │ ├── watched-files │ │ └── reload │ │ │ ├── reload.cabal │ │ │ └── src │ │ │ └── MyLib.hs │ └── working-dir │ │ ├── a │ │ ├── A.hs │ │ ├── B.hs │ │ ├── a.cabal │ │ └── wdtest │ │ ├── cabal.project │ │ └── hie.yaml ├── exe │ ├── AsyncTests.hs │ ├── BootTests.hs │ ├── CPPTests.hs │ ├── ClientSettingsTests.hs │ ├── CodeLensTests.hs │ ├── CompletionTests.hs │ ├── Config.hs │ ├── CradleTests.hs │ ├── DependentFileTest.hs │ ├── DiagnosticTests.hs │ ├── ExceptionTests.hs │ ├── FindDefinitionAndHoverTests.hs │ ├── FindImplementationAndHoverTests.hs │ ├── FuzzySearch.hs │ ├── GarbageCollectionTests.hs │ ├── HaddockTests.hs │ ├── HieDbRetry.hs │ ├── HighlightTests.hs │ ├── IfaceTests.hs │ ├── InitializeResponseTests.hs │ ├── LogType.hs │ ├── Main.hs │ ├── NonLspCommandLine.hs │ ├── OpenCloseTest.hs │ ├── OutlineTests.hs │ ├── PluginSimpleTests.hs │ ├── PositionMappingTests.hs │ ├── PreprocessorTests.hs │ ├── Progress.hs │ ├── ReferenceTests.hs │ ├── ResolveTests.hs │ ├── RootUriTests.hs │ ├── SafeTests.hs │ ├── SymlinkTests.hs │ ├── THTests.hs │ ├── UnitTests.hs │ └── WatchedFileTests.hs ├── manual │ └── lhs │ │ ├── Bird.lhs │ │ ├── Main.hs │ │ └── Test.lhs └── preprocessor │ └── Main.hs ├── ghcide ├── .editorconfig ├── .gitignore ├── CHANGELOG.md ├── LICENSE ├── README.md ├── azure-pipelines.yml ├── docs │ └── opentelemetry.md ├── exe │ ├── Arguments.hs │ └── Main.hs ├── ghcide.cabal ├── img │ └── vscode2.png ├── session-loader │ └── Development │ │ └── IDE │ │ ├── Session.hs │ │ └── Session │ │ ├── Diagnostics.hs │ │ └── Implicit.hs └── src │ ├── Control │ └── Concurrent │ │ └── Strict.hs │ ├── Development │ ├── IDE.hs │ └── IDE │ │ ├── Core │ │ ├── Actions.hs │ │ ├── Compile.hs │ │ ├── Debouncer.hs │ │ ├── FileExists.hs │ │ ├── FileStore.hs │ │ ├── FileUtils.hs │ │ ├── IdeConfiguration.hs │ │ ├── OfInterest.hs │ │ ├── PluginUtils.hs │ │ ├── PositionMapping.hs │ │ ├── Preprocessor.hs │ │ ├── ProgressReporting.hs │ │ ├── RuleTypes.hs │ │ ├── Rules.hs │ │ ├── Service.hs │ │ ├── Shake.hs │ │ ├── Tracing.hs │ │ ├── UseStale.hs │ │ └── WorkerThread.hs │ │ ├── GHC │ │ ├── CPP.hs │ │ ├── Compat.hs │ │ ├── Compat │ │ │ ├── CmdLine.hs │ │ │ ├── Core.hs │ │ │ ├── Driver.hs │ │ │ ├── Env.hs │ │ │ ├── Error.hs │ │ │ ├── Iface.hs │ │ │ ├── Logger.hs │ │ │ ├── Outputable.hs │ │ │ ├── Parser.hs │ │ │ ├── Plugins.hs │ │ │ ├── Units.hs │ │ │ └── Util.hs │ │ ├── CoreFile.hs │ │ ├── Error.hs │ │ ├── Orphans.hs │ │ ├── Util.hs │ │ └── Warnings.hs │ │ ├── Import │ │ ├── DependencyInformation.hs │ │ └── FindImports.hs │ │ ├── LSP │ │ ├── HoverDefinition.hs │ │ ├── LanguageServer.hs │ │ ├── Notifications.hs │ │ ├── Outline.hs │ │ └── Server.hs │ │ ├── Main.hs │ │ ├── Main │ │ └── HeapStats.hs │ │ ├── Monitoring │ │ └── OpenTelemetry.hs │ │ ├── Plugin.hs │ │ ├── Plugin │ │ ├── Completions.hs │ │ ├── Completions │ │ │ ├── Logic.hs │ │ │ └── Types.hs │ │ ├── HLS.hs │ │ ├── HLS │ │ │ └── GhcIde.hs │ │ ├── Test.hs │ │ └── TypeLenses.hs │ │ ├── Spans │ │ ├── AtPoint.hs │ │ ├── Common.hs │ │ ├── Documentation.hs │ │ ├── LocalBindings.hs │ │ └── Pragmas.hs │ │ └── Types │ │ ├── Action.hs │ │ ├── Diagnostics.hs │ │ ├── Exports.hs │ │ ├── HscEnvEq.hs │ │ ├── KnownTargets.hs │ │ ├── Location.hs │ │ ├── Monitoring.hs │ │ ├── Options.hs │ │ └── Shake.hs │ ├── Generics │ └── SYB │ │ └── GHC.hs │ └── Text │ └── Fuzzy │ └── Parallel.hs ├── haskell-language-server.cabal ├── hie-compat ├── CHANGELOG.md ├── LICENSE ├── README.md ├── hie-compat.cabal ├── src-ghc92 │ └── Compat │ │ └── HieAst.hs ├── src-reexport-ghc9 │ └── Compat │ │ ├── HieBin.hs │ │ ├── HieDebug.hs │ │ ├── HieTypes.hs │ │ └── HieUtils.hs ├── src-reexport-ghc92 │ └── Compat │ │ ├── HieAst.hs │ │ ├── HieBin.hs │ │ ├── HieDebug.hs │ │ ├── HieTypes.hs │ │ └── HieUtils.hs └── src-reexport │ └── Compat │ ├── HieDebug.hs │ ├── HieTypes.hs │ └── HieUtils.hs ├── hls-graph ├── LICENSE ├── README.md ├── hls-graph.cabal ├── html │ ├── README.md │ ├── data │ │ ├── metadata.js │ │ ├── profile-data.js │ │ └── progress-data.js │ ├── profile.html │ ├── shake.js │ └── ts │ │ ├── elements.tsx │ │ ├── environment.ts │ │ ├── jquery.d.ts │ │ ├── jquery.flot.d.ts │ │ ├── profile.tsx │ │ ├── reports │ │ ├── cmdplot.tsx │ │ ├── cmdtable.tsx │ │ ├── details.tsx │ │ ├── parallelism.tsx │ │ ├── rebuild.tsx │ │ ├── ruletable.tsx │ │ └── summary.tsx │ │ ├── search.tsx │ │ ├── shake-progress.ts │ │ ├── tsconfig.json │ │ ├── tslint.json │ │ ├── types.ts │ │ └── util.ts ├── src │ ├── Control │ │ └── Concurrent │ │ │ └── STM │ │ │ └── Stats.hs │ ├── Development │ │ └── IDE │ │ │ ├── Graph.hs │ │ │ └── Graph │ │ │ ├── Classes.hs │ │ │ ├── Database.hs │ │ │ ├── Internal │ │ │ ├── Action.hs │ │ │ ├── Database.hs │ │ │ ├── Key.hs │ │ │ ├── Options.hs │ │ │ ├── Paths.hs │ │ │ ├── Profile.hs │ │ │ ├── Rules.hs │ │ │ └── Types.hs │ │ │ ├── KeyMap.hs │ │ │ ├── KeySet.hs │ │ │ └── Rule.hs │ └── Paths.hs └── test │ ├── ActionSpec.hs │ ├── DatabaseSpec.hs │ ├── Example.hs │ ├── Main.hs │ ├── RulesSpec.hs │ └── Spec.hs ├── hls-plugin-api ├── LICENSE ├── bench │ └── Main.hs ├── hls-plugin-api.cabal ├── src │ └── Ide │ │ ├── Logger.hs │ │ ├── Plugin │ │ ├── Config.hs │ │ ├── ConfigUtils.hs │ │ ├── Error.hs │ │ ├── HandleRequestTypes.hs │ │ ├── Properties.hs │ │ ├── RangeMap.hs │ │ └── Resolve.hs │ │ ├── PluginUtils.hs │ │ └── Types.hs └── test │ ├── Ide │ ├── PluginUtilsTest.hs │ └── TypesTests.hs │ ├── Main.hs │ └── testdata │ └── Property │ ├── NestedPropertyDefault.json │ └── NestedPropertyVscode.json ├── hls-test-utils ├── LICENSE ├── hls-test-utils.cabal └── src │ ├── Development │ └── IDE │ │ ├── Test.hs │ │ └── Test │ │ └── Diagnostic.hs │ └── Test │ ├── Hls.hs │ └── Hls │ ├── FileSystem.hs │ └── Util.hs ├── plugins ├── hls-alternate-number-format-plugin │ ├── HLSAll.gif │ ├── README.md │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── AlternateNumberFormat.hs │ │ │ ├── Conversion.hs │ │ │ └── Literals.hs │ └── test │ │ ├── Main.hs │ │ ├── Properties │ │ └── Conversion.hs │ │ └── testdata │ │ ├── TFindLiteralDoLet.hs │ │ ├── TFindLiteralDoReturn.hs │ │ ├── TFindLiteralIntCase.hs │ │ ├── TFindLiteralIntCase2.hs │ │ ├── TFindLiteralIntPattern.hs │ │ ├── TFindLiteralList.hs │ │ ├── TFracDtoE.expected.hs │ │ ├── TFracDtoE.hs │ │ ├── TFracDtoHF.expected.hs │ │ ├── TFracDtoHF.hs │ │ ├── TFracDtoHFWithPragma.expected.hs │ │ ├── TFracDtoHFWithPragma.hs │ │ ├── TFracHFtoD.expected.hs │ │ ├── TFracHFtoD.hs │ │ ├── TIntDtoB.expected.hs │ │ ├── TIntDtoB.hs │ │ ├── TIntDtoH.expected.hs │ │ ├── TIntDtoH.hs │ │ ├── TIntDtoND.expected.hs │ │ ├── TIntDtoND.hs │ │ ├── TIntDtoO.expected.hs │ │ ├── TIntDtoO.hs │ │ ├── TIntHtoD.expected.hs │ │ ├── TIntHtoD.hs │ │ ├── hie.yaml │ │ └── test │ │ └── testdata │ │ └── TIntDtoND.expected.hs ├── hls-cabal-fmt-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── CabalFmt.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── commented_testdata.cabal │ │ ├── commented_testdata.formatted_document.cabal │ │ ├── hie.yaml │ │ ├── lib_testdata.cabal │ │ ├── lib_testdata.formatted_document.cabal │ │ ├── simple_testdata.cabal │ │ ├── simple_testdata.formatted_document.cabal │ │ └── src │ │ ├── MyLib.hs │ │ └── MyOtherLib.hs ├── hls-cabal-gild-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── CabalGild.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── commented_testdata.cabal │ │ ├── commented_testdata.formatted_document.cabal │ │ ├── hie.yaml │ │ ├── lib_testdata.cabal │ │ ├── lib_testdata.formatted_document.cabal │ │ ├── simple_testdata.cabal │ │ ├── simple_testdata.formatted_document.cabal │ │ └── src │ │ ├── MyLib.hs │ │ └── MyOtherLib.hs ├── hls-cabal-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── Cabal.hs │ │ │ └── Cabal │ │ │ ├── CabalAdd.hs │ │ │ ├── Completion │ │ │ ├── CabalFields.hs │ │ │ ├── Completer │ │ │ │ ├── FilePath.hs │ │ │ │ ├── Module.hs │ │ │ │ ├── Paths.hs │ │ │ │ ├── Simple.hs │ │ │ │ ├── Snippet.hs │ │ │ │ └── Types.hs │ │ │ ├── Completions.hs │ │ │ ├── Data.hs │ │ │ └── Types.hs │ │ │ ├── Definition.hs │ │ │ ├── Diagnostics.hs │ │ │ ├── FieldSuggest.hs │ │ │ ├── LicenseSuggest.hs │ │ │ ├── Orphans.hs │ │ │ ├── Outline.hs │ │ │ └── Parse.hs │ └── test │ │ ├── CabalAdd.hs │ │ ├── Completer.hs │ │ ├── Context.hs │ │ ├── Definition.hs │ │ ├── Main.hs │ │ ├── Outline.hs │ │ ├── Utils.hs │ │ └── testdata │ │ ├── cabal-add-testdata │ │ ├── cabal-add-bench │ │ │ ├── bench │ │ │ │ └── Main.hs │ │ │ └── cabal-add-bench.cabal │ │ ├── cabal-add-exe │ │ │ ├── cabal-add-exe.cabal │ │ │ └── src │ │ │ │ └── Main.hs │ │ ├── cabal-add-lib │ │ │ ├── cabal-add-lib.cabal │ │ │ └── src │ │ │ │ └── MyLib.hs │ │ ├── cabal-add-multitarget │ │ │ ├── bench │ │ │ │ └── Main.hs │ │ │ ├── cabal-add-multitarget.cabal │ │ │ ├── lib │ │ │ │ ├── InternalLib.hs │ │ │ │ └── MyLib.hs │ │ │ ├── src │ │ │ │ └── Main.hs │ │ │ └── test │ │ │ │ └── Main.hs │ │ ├── cabal-add-packageYaml │ │ │ ├── cabal-add-packageYaml.cabal │ │ │ ├── package.yaml │ │ │ └── src │ │ │ │ └── Main.hs │ │ ├── cabal-add-tests │ │ │ ├── cabal-add-tests.cabal │ │ │ └── test │ │ │ │ ├── Main.hs │ │ │ │ └── MainPackageImports.hs │ │ ├── cabal.project │ │ └── hie.yaml │ │ ├── code-actions │ │ ├── FieldSuggestions.cabal │ │ └── FieldSuggestions.golden.cabal │ │ ├── completer.cabal │ │ ├── completion │ │ └── autogen-completion.cabal │ │ ├── exposed.cabal │ │ ├── filepath-completions │ │ ├── .hidden │ │ ├── Content.hs │ │ ├── dir1 │ │ │ ├── f1.txt │ │ │ └── f2.hs │ │ ├── dir2 │ │ │ └── dir3 │ │ │ │ └── MARKDOWN.md │ │ ├── main-is.cabal │ │ └── textfile.txt │ │ ├── goto-definition │ │ ├── common-section │ │ │ └── simple-with-common.cabal │ │ ├── modules │ │ │ ├── module-examples.cabal │ │ │ └── src │ │ │ │ ├── Library │ │ │ │ ├── Lib.hs │ │ │ │ └── Other │ │ │ │ │ └── OtherLib.hs │ │ │ │ ├── bench │ │ │ │ ├── Config.hs │ │ │ │ └── Main.hs │ │ │ │ ├── exe │ │ │ │ ├── Config.hs │ │ │ │ └── Main.hs │ │ │ │ └── test │ │ │ │ ├── Config.hs │ │ │ │ ├── Library.hs │ │ │ │ └── Main.hs │ │ └── simple-with-common.cabal │ │ ├── hie.yaml │ │ ├── hover │ │ └── hover-deps.cabal │ │ ├── invalid.cabal │ │ ├── licenseCodeAction.cabal │ │ ├── licenseCodeAction2.cabal │ │ ├── outline-cabal │ │ ├── field.cabal │ │ ├── fieldline.cabal │ │ ├── section.cabal │ │ └── sectionarg.cabal │ │ ├── simple-cabal │ │ ├── A.hs │ │ ├── cabal.project │ │ ├── hie.yaml │ │ └── simple-cabal.cabal │ │ ├── simple.cabal │ │ ├── src-modules │ │ ├── Dir1 │ │ │ ├── Dir2 │ │ │ │ └── File2.hs │ │ │ └── Dir3 │ │ │ │ └── Dir4 │ │ │ │ └── File3.hs │ │ ├── File1.hs │ │ └── test.cabal │ │ └── unsupportedVersion.cabal ├── hls-call-hierarchy-plugin │ ├── README.md │ ├── call-hierarchy-in-emacs.gif │ ├── call-hierarchy-in-vscode.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── CallHierarchy.hs │ │ │ └── CallHierarchy │ │ │ ├── Internal.hs │ │ │ ├── Query.hs │ │ │ └── Types.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── A.hs │ │ ├── B.hs │ │ ├── C.hs │ │ └── hie.yaml ├── hls-change-type-signature-plugin │ ├── README.md │ ├── change1.gif │ ├── change2.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── ChangeTypeSignature.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── TErrorGivenPartialSignature.hs │ │ ├── TExpectedActual.expected.hs │ │ ├── TExpectedActual.hs │ │ ├── TLocalBinding.expected.hs │ │ ├── TLocalBinding.hs │ │ ├── TLocalBindingShadow1.expected.hs │ │ ├── TLocalBindingShadow1.hs │ │ ├── TLocalBindingShadow2.expected.hs │ │ ├── TLocalBindingShadow2.hs │ │ ├── TRigidType.expected.hs │ │ ├── TRigidType.hs │ │ ├── TRigidType2.expected.hs │ │ ├── TRigidType2.hs │ │ ├── error1.txt │ │ ├── error2.txt │ │ ├── error3.txt │ │ ├── error4.txt │ │ ├── error5.txt │ │ ├── ghc921-error1.txt │ │ ├── ghc921-error2.txt │ │ ├── ghc921-error3.txt │ │ └── hie.yaml ├── hls-class-plugin │ ├── README.md │ ├── codeactions.gif │ ├── codelens.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── Class.hs │ │ │ └── Class │ │ │ ├── CodeAction.hs │ │ │ ├── CodeLens.hs │ │ │ ├── ExactPrint.hs │ │ │ ├── Types.hs │ │ │ └── Utils.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── AllMethodsRequired.hs │ │ ├── CodeLensSimple.expected.hs │ │ ├── CodeLensSimple.hs │ │ ├── CodeLensWithGHC2021.expected.hs │ │ ├── CodeLensWithGHC2021.hs │ │ ├── CodeLensWithPragma.expected.hs │ │ ├── CodeLensWithPragma.hs │ │ ├── Inline.expected.hs │ │ ├── Inline.hs │ │ ├── InsertPragmaOnce.expected.hs │ │ ├── InsertPragmaOnce.hs │ │ ├── InsertWithGHC2021Enabled.expected.hs │ │ ├── InsertWithGHC2021Enabled.hs │ │ ├── InsertWithPragma.expected.hs │ │ ├── InsertWithPragma.hs │ │ ├── InsertWithoutPragma.expected.hs │ │ ├── InsertWithoutPragma.hs │ │ ├── LocalClassDefine.expected.hs │ │ ├── LocalClassDefine.hs │ │ ├── MinimalDefinitionMeet.hs │ │ ├── Qualified.expected.hs │ │ ├── Qualified.hs │ │ ├── QualifiedA.hs │ │ ├── Stale.hs │ │ ├── T1.all.expected.hs │ │ ├── T1.eq.expected.hs │ │ ├── T1.hs │ │ ├── T1.ne.expected.hs │ │ ├── T2.fmap.expected.hs │ │ ├── T2.hs │ │ ├── T3.1.expected.hs │ │ ├── T3.2.expected.hs │ │ ├── T3.hs │ │ ├── T4.expected.hs │ │ ├── T4.hs │ │ ├── T5.expected.hs │ │ ├── T5.hs │ │ ├── T6.1.expected.hs │ │ ├── T6.2.expected.hs │ │ ├── T6.expected.hs │ │ ├── T6.hs │ │ ├── T7.expected.hs │ │ ├── T7.hs │ │ ├── TH.hs │ │ ├── THDef.hs │ │ ├── Ticket3942one.hs │ │ ├── TypeFamily.expected.hs │ │ ├── TypeFamily.hs │ │ └── hie.yaml ├── hls-code-range-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── CodeRange.hs │ │ │ └── CodeRange │ │ │ ├── ASTPreProcess.hs │ │ │ └── Rules.hs │ └── test │ │ ├── Ide │ │ └── Plugin │ │ │ ├── CodeRange │ │ │ └── RulesTest.hs │ │ │ └── CodeRangeTest.hs │ │ ├── Main.hs │ │ └── testdata │ │ ├── folding-range │ │ ├── Empty.golden.txt │ │ ├── Empty.hs │ │ ├── Function.golden.txt │ │ ├── Function.golden.txt.ghc910 │ │ ├── Function.hs │ │ └── hie.yaml │ │ └── selection-range │ │ ├── Empty.golden.txt │ │ ├── Empty.golden.txt.ghc910 │ │ ├── Empty.hs │ │ ├── Function.golden.txt │ │ ├── Function.golden.txt.ghc910 │ │ ├── Function.hs │ │ ├── Import.golden.txt │ │ ├── Import.golden.txt.ghc910 │ │ ├── Import.hs │ │ └── hie.yaml ├── hls-eval-plugin │ ├── README.md │ ├── demo.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── Eval.hs │ │ │ └── Eval │ │ │ ├── Code.hs │ │ │ ├── Config.hs │ │ │ ├── GHC.hs │ │ │ ├── Handlers.hs │ │ │ ├── Parse │ │ │ ├── Comments.hs │ │ │ └── Option.hs │ │ │ ├── Rules.hs │ │ │ ├── Types.hs │ │ │ └── Util.hs │ └── test │ │ ├── Main.hs │ │ ├── cabal.project │ │ └── testdata │ │ ├── T1.expected.hs │ │ ├── T1.hs │ │ ├── T10.expected.hs │ │ ├── T10.hs │ │ ├── T11.expected.hs │ │ ├── T11.ghc94.expected.hs │ │ ├── T11.hs │ │ ├── T12.expected.hs │ │ ├── T12.hs │ │ ├── T13.expected.hs │ │ ├── T13.hs │ │ ├── T14.expected.hs │ │ ├── T14.ghc98.expected.hs │ │ ├── T14.hs │ │ ├── T16.expected.hs │ │ ├── T16.hs │ │ ├── T17.expected.hs │ │ ├── T17.hs │ │ ├── T18.expected.hs │ │ ├── T18.hs │ │ ├── T19.expected.hs │ │ ├── T19.hs │ │ ├── T2.expected.hs │ │ ├── T2.hs │ │ ├── T20.expected.hs │ │ ├── T20.hs │ │ ├── T21.hs │ │ ├── T22.expected.hs │ │ ├── T22.hs │ │ ├── T23.hs │ │ ├── T24.expected.hs │ │ ├── T24.hs │ │ ├── T25.expected.hs │ │ ├── T25.hs │ │ ├── T26.expected.hs │ │ ├── T26.hs │ │ ├── T27.expected.hs │ │ ├── T27.hs │ │ ├── T28.expected.hs │ │ ├── T28.hs │ │ ├── T3.expected.hs │ │ ├── T3.hs │ │ ├── T4.expected.hs │ │ ├── T4.hs │ │ ├── T4139.expected.hs │ │ ├── T4139.hs │ │ ├── T5.expected.hs │ │ ├── T5.hs │ │ ├── T6.expected.hs │ │ ├── T6.hs │ │ ├── T7.expected.hs │ │ ├── T7.hs │ │ ├── T8.hs │ │ ├── T9.expected.hs │ │ ├── T9.hs │ │ ├── TCPP.expected.hs │ │ ├── TCPP.hs │ │ ├── TCompare.expected.hs │ │ ├── TCompare.hs │ │ ├── TDiff.expected.default.hs │ │ ├── TDiff.expected.no-diff.hs │ │ ├── TDiff.hs │ │ ├── TEndingMulti.expected.hs │ │ ├── TEndingMulti.hs │ │ ├── TException.expected.marked.hs │ │ ├── TException.expected.nomark.hs │ │ ├── TException.hs │ │ ├── TFlags.expected.hs │ │ ├── TFlags.ghc98.expected.hs │ │ ├── TFlags.hs │ │ ├── THaddock.expected.hs │ │ ├── THaddock.hs │ │ ├── TIO.expected.hs │ │ ├── TIO.hs │ │ ├── TI_Info.hs │ │ ├── TInfo.hs │ │ ├── TInfoBang.hs │ │ ├── TInfoBangMany.hs │ │ ├── TInfoMany.hs │ │ ├── TIt.expected.hs │ │ ├── TIt.hs │ │ ├── TLHS.expected.lhs │ │ ├── TLHS.lhs │ │ ├── TLHSLaTeX.expected.lhs │ │ ├── TLHSLaTeX.lhs │ │ ├── TLanguageOptionsTupleSections.expected.hs │ │ ├── TLanguageOptionsTupleSections.hs │ │ ├── TLastLine.expected.hs │ │ ├── TLastLine.hs │ │ ├── TLocalImport.expected.hs │ │ ├── TLocalImport.hs │ │ ├── TLocalImportInTest.expected.hs │ │ ├── TLocalImportInTest.hs │ │ ├── TMulti.expected.hs │ │ ├── TMulti.hs │ │ ├── TMultiResult.expected.hs │ │ ├── TMultiResult.hs │ │ ├── TNested.expected.hs │ │ ├── TNested.hs │ │ ├── TNoImplicitPrelude.expected.hs │ │ ├── TNoImplicitPrelude.hs │ │ ├── TPlainComment.expected.hs │ │ ├── TPlainComment.hs │ │ ├── TPrelude.expected.hs │ │ ├── TPrelude.hs │ │ ├── TProperty.expected.hs │ │ ├── TProperty.hs │ │ ├── TPropertyError.ghc910.expected.hs │ │ ├── TPropertyError.ghc912.expected.hs │ │ ├── TPropertyError.ghc94.expected.hs │ │ ├── TPropertyError.ghc96.expected.hs │ │ ├── TPropertyError.ghc98.expected.hs │ │ ├── TPropertyError.hs │ │ ├── TSameDefaultLanguageExtensionsAsGhci.expected.hs │ │ ├── TSameDefaultLanguageExtensionsAsGhci.hs │ │ ├── TSectionEval.expected.hs │ │ ├── TSectionEval.hs │ │ ├── TSetup.expected.hs │ │ ├── TSetup.hs │ │ ├── TTransitive.expected.hs │ │ ├── TTransitive.hs │ │ ├── TUNPACK.expected.hs │ │ ├── TUNPACK.hs │ │ ├── Util.hs │ │ ├── hie.yaml │ │ ├── info-util │ │ ├── InfoUtil.hs │ │ └── info-util.cabal │ │ └── test.cabal ├── hls-explicit-fixity-plugin │ ├── README.md │ ├── fixity1.png │ ├── fixity2.png │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── ExplicitFixity.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Hover.hs │ │ ├── HoverImport.hs │ │ └── hie.yaml ├── hls-explicit-imports-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── ExplicitImports.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── ExplicitA.hs │ │ ├── ExplicitB.hs │ │ ├── ExplicitBreakFile.expected.hs │ │ ├── ExplicitBreakFile.hs │ │ ├── ExplicitExported.hs │ │ ├── ExplicitOnlyThis.expected.hs │ │ ├── ExplicitOnlyThis.hs │ │ ├── ExplicitStaleAction.expected.hs │ │ ├── ExplicitStaleAction.hs │ │ ├── ExplicitUsualCase.expected.hs │ │ ├── ExplicitUsualCase.hs │ │ ├── RefineA.hs │ │ ├── RefineB.hs │ │ ├── RefineC.hs │ │ ├── RefineD.hs │ │ ├── RefineE.hs │ │ ├── RefineF.hs │ │ ├── RefineG.hs │ │ ├── RefineQualified.expected.hs │ │ ├── RefineQualified.hs │ │ ├── RefineQualifiedExplicit.expected.hs │ │ ├── RefineQualifiedExplicit.hs │ │ ├── RefineUsualCase.expected.hs │ │ ├── RefineUsualCase.hs │ │ ├── RefineWithOverride.expected.hs │ │ ├── RefineWithOverride.hs │ │ └── hie.yaml ├── hls-explicit-record-fields-plugin │ ├── README.md │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── ExplicitFields.hs │ ├── test │ │ ├── Main.hs │ │ └── testdata │ │ │ ├── Construction.expected.hs │ │ │ ├── Construction.hs │ │ │ ├── ConstructionDuplicateRecordFields.hs │ │ │ ├── HsExpanded1.expected.hs │ │ │ ├── HsExpanded1.hs │ │ │ ├── HsExpanded1DuplicateRecordFields.hs │ │ │ ├── HsExpanded2.expected.hs │ │ │ ├── HsExpanded2.hs │ │ │ ├── Mixed.expected.hs │ │ │ ├── Mixed.hs │ │ │ ├── PolymorphicRecordConstruction.expected.hs │ │ │ ├── PolymorphicRecordConstruction.hs │ │ │ ├── PositionalConstruction.expected.hs │ │ │ ├── PositionalConstruction.hs │ │ │ ├── PositionalConstructionDuplicateRecordFields.hs │ │ │ ├── Unused.expected.hs │ │ │ ├── Unused.hs │ │ │ ├── Unused2.expected.hs │ │ │ ├── Unused2.hs │ │ │ ├── WildcardOnly.expected.hs │ │ │ ├── WildcardOnly.hs │ │ │ ├── WithExplicitBind.expected.hs │ │ │ ├── WithExplicitBind.hs │ │ │ ├── WithPun.expected.hs │ │ │ ├── WithPun.hs │ │ │ ├── hie.yaml │ │ │ └── noop │ │ │ ├── ExplicitBinds.hs │ │ │ ├── Infix.hs │ │ │ ├── PartiallyAppliedCon.hs │ │ │ ├── Prefix.hs │ │ │ └── Puns.hs │ └── wildcard.gif ├── hls-floskell-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Floskell.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Floskell.formatted_document.hs │ │ ├── Floskell.formatted_range.hs │ │ ├── Floskell.hs │ │ └── hie.yaml ├── hls-fourmolu-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Fourmolu.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Fourmolu.formatted.hs │ │ ├── Fourmolu.hs │ │ ├── Fourmolu2.formatted.hs │ │ ├── Fourmolu2.hs │ │ ├── Fourmolu3.formatted.hs │ │ ├── Fourmolu3.hs │ │ └── hie.yaml ├── hls-gadt-plugin │ ├── README.md │ ├── gadt.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── GADT.hs │ │ │ └── GHC.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── ConstructorContext.expected.hs │ │ ├── ConstructorContext.hs │ │ ├── Context.expected.hs │ │ ├── Context.hs │ │ ├── Data.expected.hs │ │ ├── Data.hs │ │ ├── DataContext.expected.hs │ │ ├── DataContext.hs │ │ ├── DataContextParen.expected.hs │ │ ├── DataContextParen.hs │ │ ├── Deriving.expected.hs │ │ ├── Deriving.hs │ │ ├── Forall.expected.hs │ │ ├── Forall.hs │ │ ├── Infix.expected.hs │ │ ├── Infix.hs │ │ ├── Newtype.expected.hs │ │ ├── Newtype.hs │ │ ├── Pragma.expected.hs │ │ ├── Pragma.hs │ │ ├── Record.expected.hs │ │ ├── Record.hs │ │ ├── SimpleData.expected.hs │ │ ├── SimpleData.hs │ │ ├── SimpleNewtype.expected.hs │ │ ├── SimpleNewtype.hs │ │ ├── SingleDeriving.expected.hs │ │ ├── SingleDeriving.hs │ │ ├── SingleDerivingGHC92.expected.hs │ │ ├── SingleDerivingGHC92.hs │ │ ├── TypeVariable.expected.hs │ │ ├── TypeVariable.hs │ │ └── hie.yaml ├── hls-hlint-plugin │ ├── .hlint.yaml │ ├── README.md │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Hlint.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Base.hs │ │ ├── Comments.hs │ │ ├── CppCond.hs │ │ ├── Generalise.hs │ │ ├── IgnoreAnn.hs │ │ ├── IgnoreAnnHlint.hs │ │ ├── LambdaCase.hs │ │ ├── PatternKeyword.hs │ │ ├── RightToLeftFixities.expected.hs │ │ ├── RightToLeftFixities.hs │ │ ├── StrictData.hs │ │ ├── TwoHints.hs │ │ ├── TwoHintsAndComment.hs │ │ ├── UnrecognizedPragmasOff.expected.hs │ │ ├── UnrecognizedPragmasOff.hs │ │ ├── UnrecognizedPragmasOn.expected.hs │ │ ├── UnrecognizedPragmasOn.hs │ │ ├── cpp │ │ ├── CppCond.hs │ │ ├── CppHeader.hs │ │ ├── hie.yaml │ │ └── test.h │ │ ├── fixity │ │ ├── .hlint.yaml │ │ ├── FixityDef.hs │ │ ├── FixityUse.hs │ │ └── hie.yaml │ │ ├── hie.yaml │ │ ├── ignore │ │ ├── .hlint.yaml │ │ ├── CamelCase.hs │ │ └── hie.yaml │ │ ├── lambdacase │ │ ├── LambdaCase.hs │ │ └── hie.yaml │ │ ├── test-hlint-config.yaml │ │ ├── typeapps │ │ ├── TypeApplication.hs │ │ └── hie.yaml │ │ └── unusedext │ │ ├── UnusedExtension.hs │ │ └── hie.yaml ├── hls-module-name-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── ModuleName.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── CorrectName.hs │ │ ├── Stale.hs │ │ ├── TEmptyModule.expected.hs │ │ ├── TEmptyModule.hs │ │ ├── TWrongModuleName.expected.hs │ │ ├── TWrongModuleName.hs │ │ ├── cabal.project │ │ ├── canonicalize │ │ ├── Lib │ │ │ ├── A.expected.hs │ │ │ └── A.hs │ │ └── canonicalize.cabal │ │ ├── hie.yaml │ │ ├── mainlike.expected.hs │ │ ├── mainlike.hs │ │ └── subdir │ │ ├── TWrongModuleName.expected.hs │ │ └── TWrongModuleName.hs ├── hls-notes-plugin │ ├── README.md │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Notes.hs │ └── test │ │ ├── NotesTest.hs │ │ └── testdata │ │ ├── NoteDef.hs │ │ ├── Other.hs │ │ └── hie.yaml ├── hls-ormolu-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Ormolu.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── .ormolu │ │ ├── Ormolu.expected.hs │ │ ├── Ormolu.formatted.hs │ │ ├── Ormolu.hs │ │ ├── Ormolu2.expected.hs │ │ ├── Ormolu2.formatted.hs │ │ ├── Ormolu2.hs │ │ ├── Ormolu3.expected.hs │ │ ├── Ormolu3.formatted.hs │ │ ├── Ormolu3.hs │ │ ├── hie.yaml │ │ └── test.cabal ├── hls-overloaded-record-dot-plugin │ ├── README.md │ ├── example.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── OverloadedRecordDot.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Multiline.expected.hs │ │ ├── Multiline.hs │ │ ├── MultilineCase.expected.hs │ │ ├── MultilineCase.hs │ │ ├── MultilineExpanded.expected.hs │ │ ├── MultilineExpanded.hs │ │ ├── NestedDollar.expected.hs │ │ ├── NestedDollar.hs │ │ ├── NestedDot.expected.hs │ │ ├── NestedDot.hs │ │ ├── NestedParens.expected.hs │ │ ├── NestedParens.hs │ │ ├── NoPragmaNeeded.expected.hs │ │ ├── NoPragmaNeeded.hs │ │ ├── Simple.expected.hs │ │ ├── Simple.hs │ │ └── hie.yaml ├── hls-pragmas-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Pragmas.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── AddLanguageAfterInterchaningIgnoringLaterAnn.expected.hs │ │ ├── AddLanguageAfterInterchaningIgnoringLaterAnn.hs │ │ ├── AddLanguageAfterLanguageThenOptsGhc.expected.hs │ │ ├── AddLanguageAfterLanguageThenOptsGhc.hs │ │ ├── AddLanguagePragma.expected.hs │ │ ├── AddLanguagePragma.hs │ │ ├── AddLanguagePragmaAfterInterchaningOptsGhcAndLangs.expected.hs │ │ ├── AddLanguagePragmaAfterInterchaningOptsGhcAndLangs.hs │ │ ├── AddOptsGhcAfterLanguage.expected.hs │ │ ├── AddOptsGhcAfterLanguage.hs │ │ ├── AddPragmaAfterOptsGhcIgnoreInline.expected.hs │ │ ├── AddPragmaAfterOptsGhcIgnoreInline.hs │ │ ├── AddPragmaAfterShebangPrecededByLangAndOptsGhc.expected.hs │ │ ├── AddPragmaAfterShebangPrecededByLangAndOptsGhc.hs │ │ ├── AddPragmaAfterShebangPrecededByLanguage.expected.hs │ │ ├── AddPragmaAfterShebangPrecededByLanguage.hs │ │ ├── AddPragmaIgnoreInline.expected.hs │ │ ├── AddPragmaIgnoreInline.hs │ │ ├── AddPragmaIgnoreLaterAnnPragma.expected.hs │ │ ├── AddPragmaIgnoreLaterAnnPragma.hs │ │ ├── AddPragmaWithNonStandardSpacingInPrecedingPragmas.expected.hs │ │ ├── AddPragmaWithNonStandardSpacingInPrecedingPragmas.hs │ │ ├── AfterAllWithMultipleInlines.expected.hs │ │ ├── AfterAllWithMultipleInlines.hs │ │ ├── AfterGhcOptions.expected.hs │ │ ├── AfterGhcOptions.hs │ │ ├── AfterShebang.expected.hs │ │ ├── AfterShebang.hs │ │ ├── AfterShebangAndOptionsAndPragma.expected.hs │ │ ├── AfterShebangAndOptionsAndPragma.hs │ │ ├── AfterShebangAndOptionsAndPragmasIgnoreInline.expected.hs │ │ ├── AfterShebangAndOptionsAndPragmasIgnoreInline.hs │ │ ├── AfterShebangAndOpts.expected.hs │ │ ├── AfterShebangAndOpts.hs │ │ ├── AfterShebangAndPragma.expected.hs │ │ ├── AfterShebangAndPragma.hs │ │ ├── AppendToExisting.expected.hs │ │ ├── AppendToExisting.hs │ │ ├── BeforeDocComment.expected.hs │ │ ├── BeforeDocComment.hs │ │ ├── BeforeDocInterchanging.expected.hs │ │ ├── BeforeDocInterchanging.hs │ │ ├── BlockCommentThenLineComment.expected.hs │ │ ├── BlockCommentThenLineComment.hs │ │ ├── BlockCommentThenLineHaddock.expected.hs │ │ ├── BlockCommentThenLineHaddock.hs │ │ ├── BlockCommentThenMultiLineBlockComment.expected.hs │ │ ├── BlockCommentThenMultiLineBlockComment.hs │ │ ├── BlockCommentThenMultiLineBlockHaddock.expected.hs │ │ ├── BlockCommentThenMultiLineBlockHaddock.hs │ │ ├── BlockCommentThenSingleLineBlockComment.expected.hs │ │ ├── BlockCommentThenSingleLineBlockComment.hs │ │ ├── BlockCommentThenSingleLineBlockHaddock.expected.hs │ │ ├── BlockCommentThenSingleLineBlockHaddock.hs │ │ ├── BlockCommentThenSingleLineBlockHaddockSingleLineBlockComment.expected.hs │ │ ├── BlockCommentThenSingleLineBlockHaddockSingleLineBlockComment.hs │ │ ├── Completion.hs │ │ ├── DeferredOutOfScopeVariables.expected.hs │ │ ├── DeferredOutOfScopeVariables.hs │ │ ├── DeferredTypeErrors.expected.hs │ │ ├── DeferredTypeErrors.hs │ │ ├── MissingSignatures.expected.hs │ │ ├── MissingSignatures.hs │ │ ├── ModuleOnFirstLine.expected.hs │ │ ├── ModuleOnFirstLine.hs │ │ ├── NamedFieldPuns.expected.hs │ │ ├── NamedFieldPuns.hs │ │ ├── NeedsPragmas.expected.hs │ │ ├── NeedsPragmas.hs │ │ ├── OptionsGhcAfterDecl.expected.hs │ │ ├── OptionsGhcAfterDecl.hs │ │ ├── PragmaFollowedBySingleLineBlockHaddock.hs │ │ ├── PragmaThenLineComment.expected.hs │ │ ├── PragmaThenLineComment.hs │ │ ├── PragmaThenLineHaddock.expected.hs │ │ ├── PragmaThenLineHaddock.hs │ │ ├── PragmaThenLineHaddockNewlineLineComment.expected.hs │ │ ├── PragmaThenLineHaddockNewlineLineComment.hs │ │ ├── PragmaThenMultiLineBlockComment.expected.hs │ │ ├── PragmaThenMultiLineBlockComment.hs │ │ ├── PragmaThenMultiLineBlockHaddock.expected.hs │ │ ├── PragmaThenMultiLineBlockHaddock.hs │ │ ├── PragmaThenSingleLineBlockComment.expected.hs │ │ ├── PragmaThenSingleLineBlockComment.hs │ │ ├── PragmaThenSingleLineBlockHaddock.expected.hs │ │ ├── PragmaThenSingleLineBlockHaddock.hs │ │ ├── PragmaThenSingleLineBlockHaddockSingleLineBlockComment.expected.hs │ │ ├── PragmaThenSingleLineBlockHaddockSingleLineBlockComment.hs │ │ ├── TypeApplications.expected.hs │ │ ├── TypeApplications.hs │ │ ├── UnusedImports.expected.hs │ │ ├── UnusedImports.hs │ │ └── hie.yaml ├── hls-qualify-imported-names-plugin │ ├── README.md │ ├── qualify-imported-names-demo.gif │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── QualifyImportedNames.hs │ └── test │ │ ├── Main.hs │ │ └── data │ │ ├── A.hs │ │ ├── AliasedImport.expected.hs │ │ ├── AliasedImport.hs │ │ ├── B.hs │ │ ├── Backticked.expected.hs │ │ ├── Backticked.hs │ │ ├── ExplicitHidingImport.expected.hs │ │ ├── ExplicitHidingImport.hs │ │ ├── ExplicitImport.expected.hs │ │ ├── ExplicitImport.hs │ │ ├── ExplicitPrelude.expected.hs │ │ ├── ExplicitPrelude.hs │ │ ├── NoDoubleQualify.expected.hs │ │ ├── NoDoubleQualify.hs │ │ ├── NoImport.hs │ │ ├── OnlyImportedNames.expected.hs │ │ ├── OnlyImportedNames.hs │ │ ├── Parenthesized.expected.hs │ │ ├── Parenthesized.hs │ │ ├── QualifiedImport.hs │ │ ├── Reexported.expected.hs │ │ ├── Reexported.hs │ │ ├── SameLine.expected.hs │ │ ├── SameLine.hs │ │ ├── UnaliasedImport.expected.hs │ │ ├── UnaliasedImport.hs │ │ └── hie.yaml ├── hls-refactor-plugin │ ├── src │ │ └── Development │ │ │ └── IDE │ │ │ ├── GHC │ │ │ ├── Compat │ │ │ │ └── ExactPrint.hs │ │ │ ├── Dump.hs │ │ │ └── ExactPrint.hs │ │ │ └── Plugin │ │ │ ├── CodeAction.hs │ │ │ ├── CodeAction │ │ │ ├── Args.hs │ │ │ ├── ExactPrint.hs │ │ │ ├── PositionIndexed.hs │ │ │ ├── RuleTypes.hs │ │ │ └── Util.hs │ │ │ └── Plugins │ │ │ ├── AddArgument.hs │ │ │ ├── Diagnostic.hs │ │ │ ├── FillHole.hs │ │ │ ├── FillTypeWildcard.hs │ │ │ └── ImportUtils.hs │ └── test │ │ ├── Main.hs │ │ ├── Test │ │ └── AddArgument.hs │ │ └── data │ │ ├── golden │ │ └── add-arg │ │ │ ├── AddArgFromLet.expected.hs │ │ │ ├── AddArgFromLet.hs │ │ │ ├── AddArgFromWhere.expected.hs │ │ │ ├── AddArgFromWhere.hs │ │ │ ├── AddArgFromWhereComments.expected.hs │ │ │ ├── AddArgFromWhereComments.hs │ │ │ ├── AddArgWithLambda.expected.hs │ │ │ ├── AddArgWithLambda.hs │ │ │ ├── AddArgWithSig.expected.hs │ │ │ ├── AddArgWithSig.hs │ │ │ ├── AddArgWithSigAndDocs.expected.hs │ │ │ ├── AddArgWithSigAndDocs.hs │ │ │ ├── AddArgWithTypeSynSig.expected.hs │ │ │ ├── AddArgWithTypeSynSig.hs │ │ │ ├── AddArgWithTypeSynSigContravariant.expected.hs │ │ │ ├── AddArgWithTypeSynSigContravariant.hs │ │ │ ├── Hole.expected.hs │ │ │ ├── Hole.hs │ │ │ ├── MultiSigFirst.expected.hs │ │ │ ├── MultiSigFirst.hs │ │ │ ├── MultiSigLast.expected.hs │ │ │ ├── MultiSigLast.hs │ │ │ ├── MultiSigMiddle.expected.hs │ │ │ ├── MultiSigMiddle.hs │ │ │ ├── MultipleDeclAlts.expected.hs │ │ │ ├── MultipleDeclAlts.hs │ │ │ ├── NoTypeSuggestion.expected.hs │ │ │ └── NoTypeSuggestion.hs │ │ ├── hiding │ │ ├── AVec.hs │ │ ├── BVec.hs │ │ ├── CVec.hs │ │ ├── DVec.hs │ │ ├── EVec.hs │ │ ├── FVec.hs │ │ ├── HideFunction.expected.append.E.hs │ │ ├── HideFunction.expected.append.Prelude.hs │ │ ├── HideFunction.expected.fromList.A.hs │ │ ├── HideFunction.expected.fromList.B.hs │ │ ├── HideFunction.expected.qualified.append.Prelude.hs │ │ ├── HideFunction.expected.qualified.fromList.E.hs │ │ ├── HideFunction.hs │ │ ├── HideFunctionWithoutLocal.expected.hs │ │ ├── HideFunctionWithoutLocal.hs │ │ ├── HidePreludeIndented.expected.hs │ │ ├── HidePreludeIndented.hs │ │ ├── HidePreludeLocalInfix.expected.hs │ │ ├── HidePreludeLocalInfix.hs │ │ ├── HideQualifyDuplicateRecordFields.expected.hs │ │ ├── HideQualifyDuplicateRecordFields.hs │ │ ├── HideQualifyDuplicateRecordFieldsSelf.hs │ │ ├── HideQualifyInfix.expected.hs │ │ ├── HideQualifyInfix.hs │ │ ├── HideQualifySectionLeft.expected.hs │ │ ├── HideQualifySectionLeft.hs │ │ ├── HideQualifySectionRight.expected.hs │ │ ├── HideQualifySectionRight.hs │ │ ├── HideType.expected.A.hs │ │ ├── HideType.expected.E.hs │ │ ├── HideType.hs │ │ └── hie.yaml │ │ ├── hover │ │ ├── Bar.hs │ │ ├── Foo.hs │ │ ├── GotoHover.hs │ │ ├── RecordDotSyntax.hs │ │ └── hie.yaml │ │ └── import-placement │ │ ├── CommentAtTop.expected.hs │ │ ├── CommentAtTop.hs │ │ ├── CommentAtTopMultipleComments.expected.hs │ │ ├── CommentAtTopMultipleComments.hs │ │ ├── CommentCurlyBraceAtTop.expected.hs │ │ ├── CommentCurlyBraceAtTop.hs │ │ ├── DataAtTop.expected.hs │ │ ├── DataAtTop.hs │ │ ├── ImportAtTop.expected.hs │ │ ├── ImportAtTop.hs │ │ ├── ImportPostQualified.expected.hs │ │ ├── ImportPostQualified.hs │ │ ├── ImportQualified.expected.hs │ │ ├── ImportQualified.hs │ │ ├── LangPragmaModuleAtTop.expected.hs │ │ ├── LangPragmaModuleAtTop.hs │ │ ├── LangPragmaModuleExplicitExports.expected.hs │ │ ├── LangPragmaModuleExplicitExports.hs │ │ ├── LangPragmaModuleWithComment.expected.hs │ │ ├── LangPragmaModuleWithComment.hs │ │ ├── LanguagePragmaAtTop.expected.hs │ │ ├── LanguagePragmaAtTop.hs │ │ ├── LanguagePragmaAtTopWithComment.expected.hs │ │ ├── LanguagePragmaAtTopWithComment.hs │ │ ├── LanguagePragmasThenShebangs.expected.hs │ │ ├── LanguagePragmasThenShebangs.hs │ │ ├── ModuleDeclAndImports.expected.hs │ │ ├── ModuleDeclAndImports.hs │ │ ├── MultiLineCommentAtTop.expected.hs │ │ ├── MultiLineCommentAtTop.hs │ │ ├── MultiLinePragma.expected.hs │ │ ├── MultiLinePragma.hs │ │ ├── MultipleImportsAtTop.expected.hs │ │ ├── MultipleImportsAtTop.hs │ │ ├── MultipleLanguagePragmasNoModuleDeclaration.expected.hs │ │ ├── MultipleLanguagePragmasNoModuleDeclaration.hs │ │ ├── NewTypeAtTop.expected.hs │ │ ├── NewTypeAtTop.hs │ │ ├── NoExplicitExportCommentAtTop.expected.hs │ │ ├── NoExplicitExportCommentAtTop.hs │ │ ├── NoExplicitExports.expected.hs │ │ ├── NoExplicitExports.hs │ │ ├── NoModuleDeclaration.expected.hs │ │ ├── NoModuleDeclaration.hs │ │ ├── NoModuleDeclarationCommentAtTop.expected.hs │ │ ├── NoModuleDeclarationCommentAtTop.hs │ │ ├── OptionsNotAtTopWithSpaces.expected.hs │ │ ├── OptionsNotAtTopWithSpaces.hs │ │ ├── OptionsPragmaNotAtTop.expected.hs │ │ ├── OptionsPragmaNotAtTop.hs │ │ ├── PragmaNotAtTopMultipleComments.expected.hs │ │ ├── PragmaNotAtTopMultipleComments.hs │ │ ├── PragmaNotAtTopWithCommentsAtTop.expected.hs │ │ ├── PragmaNotAtTopWithCommentsAtTop.hs │ │ ├── PragmaNotAtTopWithImports.expected.hs │ │ ├── PragmaNotAtTopWithImports.hs │ │ ├── PragmaNotAtTopWithModuleDecl.expected.hs │ │ ├── PragmaNotAtTopWithModuleDecl.hs │ │ ├── PragmasAndShebangsNoComment.expected.hs │ │ ├── PragmasAndShebangsNoComment.hs │ │ ├── PragmasShebangsAndModuleDecl.expected.hs │ │ ├── PragmasShebangsAndModuleDecl.hs │ │ ├── PragmasShebangsModuleExplicitExports.expected.hs │ │ ├── PragmasShebangsModuleExplicitExports.hs │ │ ├── PragmasThenShebangsMultilineComment.expected.hs │ │ ├── PragmasThenShebangsMultilineComment.hs │ │ ├── ShebangNotAtTop.expected.hs │ │ ├── ShebangNotAtTop.hs │ │ ├── ShebangNotAtTopNoSpace.expected.hs │ │ ├── ShebangNotAtTopNoSpace.hs │ │ ├── ShebangNotAtTopWithSpaces.expected.hs │ │ ├── ShebangNotAtTopWithSpaces.hs │ │ ├── TwoDashOnlyComment.expected.hs │ │ ├── TwoDashOnlyComment.hs │ │ ├── WhereDeclLowerInFile.expected.hs │ │ ├── WhereDeclLowerInFile.hs │ │ ├── WhereDeclLowerInFileWithCommentsBeforeIt.expected.hs │ │ ├── WhereDeclLowerInFileWithCommentsBeforeIt.hs │ │ ├── WhereKeywordLowerInFileNoExports.expected.hs │ │ └── WhereKeywordLowerInFileNoExports.hs ├── hls-rename-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Rename.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Comment.expected.hs │ │ ├── Comment.hs │ │ ├── DataConstructor.expected.hs │ │ ├── DataConstructor.hs │ │ ├── ExportedFunction.expected.hs │ │ ├── ExportedFunction.hs │ │ ├── FieldPuns.expected.hs │ │ ├── FieldPuns.hs │ │ ├── Foo.hs │ │ ├── FunctionArgument.expected.hs │ │ ├── FunctionArgument.hs │ │ ├── FunctionName.expected.hs │ │ ├── FunctionName.hs │ │ ├── Gadt.expected.hs │ │ ├── Gadt.hs │ │ ├── HiddenFunction.expected.hs │ │ ├── HiddenFunction.hs │ │ ├── ImportHiding.expected.hs │ │ ├── ImportHiding.hs │ │ ├── ImportedFunction.expected.hs │ │ ├── ImportedFunction.hs │ │ ├── IndirectPuns.expected.hs │ │ ├── IndirectPuns.hs │ │ ├── LetExpression.expected.hs │ │ ├── LetExpression.hs │ │ ├── QualifiedAs.expected.hs │ │ ├── QualifiedAs.hs │ │ ├── QualifiedFunction.expected.hs │ │ ├── QualifiedFunction.hs │ │ ├── QualifiedShadowing.expected.hs │ │ ├── QualifiedShadowing.hs │ │ ├── RealignDo.expected.hs │ │ ├── RealignDo.hs │ │ ├── RecordField.expected.hs │ │ ├── RecordField.hs │ │ ├── ShadowedName.expected.hs │ │ ├── ShadowedName.hs │ │ ├── TypeConstructor.expected.hs │ │ ├── TypeConstructor.hs │ │ ├── TypeVariable.expected.hs │ │ ├── TypeVariable.hs │ │ ├── Typeclass.expected.hs │ │ ├── Typeclass.hs │ │ └── hie.yaml ├── hls-retrie-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Retrie.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── Class.hs │ │ ├── Identity.expected.hs │ │ ├── Identity.hs │ │ ├── Imported.expected.hs │ │ ├── Imported.hs │ │ ├── Nested.expected.hs │ │ ├── NestedLet.expected.hs │ │ ├── NestedLet.hs │ │ ├── NestedNested.hs │ │ ├── NestedWhere.expected.hs │ │ ├── NestedWhere.hs │ │ ├── Operator.expected.hs │ │ ├── Operator.hs │ │ └── hie.yaml ├── hls-semantic-tokens-plugin │ ├── README.md │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── SemanticTokens.hs │ │ │ └── SemanticTokens │ │ │ ├── Internal.hs │ │ │ ├── Mappings.hs │ │ │ ├── Query.hs │ │ │ ├── SemanticConfig.hs │ │ │ ├── Tokenize.hs │ │ │ ├── Types.hs │ │ │ └── Utils.hs │ └── test │ │ ├── SemanticTokensTest.hs │ │ └── testdata │ │ ├── after_9_10 │ │ ├── T1.expected │ │ ├── T1.hs │ │ ├── TClass.expected │ │ ├── TClass.hs │ │ ├── TClassImportedDeriving.expected │ │ ├── TClassImportedDeriving.hs │ │ ├── TDataFamily.expected │ │ ├── TDataFamily.hs │ │ ├── TDataType.expected │ │ ├── TDataType.hs │ │ ├── TDatatypeImported.expected │ │ ├── TDatatypeImported.hs │ │ ├── TDoc.expected │ │ ├── TDoc.hs │ │ ├── TFunction.expected │ │ ├── TFunction.hs │ │ ├── TFunctionLet.expected │ │ ├── TFunctionLet.hs │ │ ├── TFunctionLocal.expected │ │ ├── TFunctionLocal.hs │ │ ├── TFunctionUnderTypeSynonym.expected │ │ ├── TFunctionUnderTypeSynonym.hs │ │ ├── TGADT.expected │ │ ├── TGADT.hs │ │ ├── TInstanceClassMethodBind.expected │ │ ├── TInstanceClassMethodBind.hs │ │ ├── TInstanceClassMethodUse.expected │ │ ├── TInstanceClassMethodUse.hs │ │ ├── TModuleA.hs │ │ ├── TModuleB.hs │ │ ├── TNoneFunctionWithConstraint.expected │ │ ├── TNoneFunctionWithConstraint.hs │ │ ├── TOperator.expected │ │ ├── TOperator.hs │ │ ├── TPatternMatch.expected │ │ ├── TPatternMatch.hs │ │ ├── TPatternSynonym.expected │ │ ├── TPatternSynonym.hs │ │ ├── TPatternbind.expected │ │ ├── TPatternbind.hs │ │ ├── TQualifiedName.expected │ │ ├── TQualifiedName.hs │ │ ├── TRecord.expected │ │ ├── TRecord.hs │ │ ├── TRecordDuplicateRecordFields.expected │ │ ├── TRecordDuplicateRecordFields.hs │ │ ├── TTypefamily.expected │ │ ├── TTypefamily.hs │ │ ├── TUnicodeSyntax.expected │ │ ├── TUnicodeSyntax.hs │ │ ├── TValBind.expected │ │ └── TValBind.hs │ │ └── before_9_10 │ │ ├── T1.expected │ │ ├── T1.hs │ │ ├── TClass.expected │ │ ├── TClass.hs │ │ ├── TClassImportedDeriving.expected │ │ ├── TClassImportedDeriving.hs │ │ ├── TDataFamily.expected │ │ ├── TDataFamily.hs │ │ ├── TDataType.expected │ │ ├── TDataType.hs │ │ ├── TDatatypeImported.expected │ │ ├── TDatatypeImported.hs │ │ ├── TDoc.expected │ │ ├── TDoc.hs │ │ ├── TFunction.expected │ │ ├── TFunction.hs │ │ ├── TFunctionLet.expected │ │ ├── TFunctionLet.hs │ │ ├── TFunctionLocal.expected │ │ ├── TFunctionLocal.hs │ │ ├── TFunctionUnderTypeSynonym.expected │ │ ├── TFunctionUnderTypeSynonym.hs │ │ ├── TGADT.expected │ │ ├── TGADT.hs │ │ ├── TInstanceClassMethodBind.expected │ │ ├── TInstanceClassMethodBind.hs │ │ ├── TInstanceClassMethodUse.expected │ │ ├── TInstanceClassMethodUse.hs │ │ ├── TModuleA.hs │ │ ├── TModuleB.hs │ │ ├── TNoneFunctionWithConstraint.expected │ │ ├── TNoneFunctionWithConstraint.hs │ │ ├── TOperator.expected │ │ ├── TOperator.hs │ │ ├── TPatternMatch.expected │ │ ├── TPatternMatch.hs │ │ ├── TPatternSynonym.expected │ │ ├── TPatternSynonym.hs │ │ ├── TPatternbind.expected │ │ ├── TPatternbind.hs │ │ ├── TQualifiedName.expected │ │ ├── TQualifiedName.hs │ │ ├── TRecord.expected │ │ ├── TRecord.hs │ │ ├── TRecordDuplicateRecordFields.expected │ │ ├── TRecordDuplicateRecordFields.hs │ │ ├── TTypefamily.expected │ │ ├── TTypefamily.hs │ │ ├── TUnicodeSyntax.expected │ │ ├── TUnicodeSyntax.hs │ │ ├── TValBind.expected │ │ └── TValBind.hs ├── hls-splice-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ ├── Splice.hs │ │ │ └── Splice │ │ │ └── Types.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── QQ.hs │ │ ├── TDeclKindError.error.hs │ │ ├── TDeclKindError.expected.hs │ │ ├── TDeclKindError.hs │ │ ├── TErrorExp.expected.hs │ │ ├── TErrorExp.hs │ │ ├── TErrorPat.expected.hs │ │ ├── TErrorPat.hs │ │ ├── TQQDecl.expected.hs │ │ ├── TQQDecl.hs │ │ ├── TQQExp.expected.hs │ │ ├── TQQExp.hs │ │ ├── TQQExpError.expected.hs │ │ ├── TQQExpError.hs │ │ ├── TQQPat.expected.hs │ │ ├── TQQPat.hs │ │ ├── TQQPatError.expected.hs │ │ ├── TQQPatError.hs │ │ ├── TQQType.expected.hs │ │ ├── TQQType.hs │ │ ├── TQQTypeTypeError.expected.hs │ │ ├── TQQTypeTypeError.hs │ │ ├── TSimpleDecl.expected.hs │ │ ├── TSimpleDecl.hs │ │ ├── TSimpleExp.expected.hs │ │ ├── TSimpleExp.hs │ │ ├── TSimplePat.expected.hs │ │ ├── TSimplePat.hs │ │ ├── TSimpleType.expected.hs │ │ ├── TSimpleType.hs │ │ ├── TTypeAppExp.expected.hs │ │ ├── TTypeAppExp.hs │ │ ├── TTypeKindError.96-expected.hs │ │ ├── TTypeKindError.error.hs │ │ ├── TTypeKindError.expected.hs │ │ ├── TTypeKindError.hs │ │ ├── TTypeTypeError.expected.hs │ │ ├── TTypeTypeError.hs │ │ └── hie.yaml ├── hls-stan-plugin │ ├── src │ │ └── Ide │ │ │ └── Plugin │ │ │ └── Stan.hs │ └── test │ │ ├── Main.hs │ │ └── testdata │ │ ├── .stan.toml │ │ ├── dir │ │ └── configTest.hs │ │ ├── extensions-cabal-file │ │ ├── CabalFileTest.hs │ │ └── cabal-file-test.cabal │ │ ├── extensions-language-pragma │ │ ├── LanguagePragmaTest.hs │ │ └── language-pragma-test.cabal │ │ ├── hie.yaml │ │ └── test.hs └── hls-stylish-haskell-plugin │ ├── src │ └── Ide │ │ └── Plugin │ │ └── StylishHaskell.hs │ └── test │ ├── Main.hs │ └── testdata │ ├── StylishHaskell.formatted_document.hs │ ├── StylishHaskell.formatted_range.hs │ ├── StylishHaskell.hs │ └── hie.yaml ├── release ├── README.md ├── fetch_gitlab.py ├── update_versions.sh └── upload.sh ├── scripts └── release │ ├── create-yaml-snippet.sh │ └── download-gh-artifacts.sh ├── shake-bench ├── LICENSE ├── shake-bench.cabal └── src │ └── Development │ └── Benchmark │ └── Rules.hs ├── shell.nix ├── src ├── HlsPlugins.hs └── Ide │ ├── Arguments.hs │ ├── Main.hs │ └── Version.hs ├── stack-lts22.yaml ├── stack.yaml ├── test-logs └── README.md └── test ├── README.md ├── functional ├── Config.hs ├── ConfigSchema.hs ├── Format.hs ├── FunctionalBadProject.hs ├── HieBios.hs ├── Main.hs └── Progress.hs ├── testdata ├── completion │ ├── Completion.hs │ ├── FieldsSharingSignature.hs │ └── hie.yaml ├── diagnostics │ ├── Foo.hs │ └── hie.yaml ├── format │ ├── Format.floskell.formatted.hs │ ├── Format.formatted_document.hs │ ├── Format.formatted_document_with_tabsize.hs │ ├── Format.formatted_range.hs │ ├── Format.formatted_range_with_tabsize.hs │ ├── Format.hs │ ├── Format.ormolu.formatted.hs │ ├── Format.ormolu_post_floskell.formatted.hs │ └── hie.yaml ├── hieBiosMainIs │ ├── Main.hs │ ├── Setup.hs │ ├── cabal.project │ ├── hie.yaml │ └── hieBiosMainIs.cabal ├── missingModuleTest │ ├── missingModule │ │ ├── cabal.project │ │ ├── hie.yaml │ │ ├── missingModule.cabal │ │ └── src │ │ │ └── MyLib.hs │ └── noPrefixMatch │ │ ├── app │ │ ├── Main.hs │ │ └── Other.hs │ │ ├── cabal.project │ │ ├── hie.yaml │ │ └── noPrefixMatch.cabal └── schema │ ├── ghc910 │ ├── default-config.golden.json │ └── vscode-extension-schema.golden.json │ ├── ghc912 │ ├── default-config.golden.json │ └── vscode-extension-schema.golden.json │ ├── ghc94 │ ├── default-config.golden.json │ └── vscode-extension-schema.golden.json │ ├── ghc96 │ ├── default-config.golden.json │ └── vscode-extension-schema.golden.json │ └── ghc98 │ ├── default-config.golden.json │ └── vscode-extension-schema.golden.json ├── utils └── Test │ └── Hls │ ├── Command.hs │ └── Flags.hs └── wrapper ├── Main.hs └── testdata ├── cabal-cur-ver ├── Lib.hs ├── cabal-cur-ver.cabal └── cabal.project ├── stack-specific-ghc ├── Lib.hs └── foo.cabal └── stack-with-dist-newstyle ├── dist-newstyle └── .gitkeep ├── stack-with-dist-newstyle.cabal └── stack.yaml /.github/generate-ci/README.mkd: -------------------------------------------------------------------------------- 1 | # generate-ci 2 | 3 | This is the generator for the release bindist CI. 4 | 5 | Edit ./gen_ci.hs to change configuration and run "./generate-jobs" to regenerate 6 | -------------------------------------------------------------------------------- /.github/generate-ci/cabal.project: -------------------------------------------------------------------------------- 1 | packages: . 2 | -------------------------------------------------------------------------------- /.github/generate-ci/generate-jobs: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | root="$(git rev-parse --show-toplevel)/" 6 | cd "$root/.github/generate-ci/" 7 | 8 | cabal run -v0 generate-ci "$root" > ../workflows/release.yaml 9 | 10 | -------------------------------------------------------------------------------- /.github/scripts/tar.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -eux 4 | 5 | . .github/scripts/env.sh 6 | 7 | ls -lah 8 | ls -lah out/ 9 | ls -lah store/ 10 | 11 | tar cvf "out-${ARTIFACT}-${GHC_VERSION}.tar" out/ store/ 12 | -------------------------------------------------------------------------------- /.github/scripts/untar.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -eux 4 | 5 | for bindist in out-*.tar ; do 6 | tar xf "${bindist}" 7 | done 8 | -------------------------------------------------------------------------------- /.github/workflows/supported-ghc-versions.json: -------------------------------------------------------------------------------- 1 | ["9.12", "9.10", "9.8", "9.6", "9.4"] 2 | -------------------------------------------------------------------------------- /FUNDING.yml: -------------------------------------------------------------------------------- 1 | open_collective: haskell-language-server 2 | -------------------------------------------------------------------------------- /Setup.hs: -------------------------------------------------------------------------------- 1 | import Distribution.Simple 2 | main = defaultMain 3 | -------------------------------------------------------------------------------- /docs/.gitignore: -------------------------------------------------------------------------------- 1 | _build 2 | -------------------------------------------------------------------------------- /docs/_static/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/_static/.gitkeep -------------------------------------------------------------------------------- /docs/_templates/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/_templates/.gitkeep -------------------------------------------------------------------------------- /docs/contributing/imports.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/contributing/imports.gif -------------------------------------------------------------------------------- /docs/contributing/index.rst: -------------------------------------------------------------------------------- 1 | Contributing 2 | ============ 3 | 4 | .. toctree:: 5 | :maxdepth: 2 6 | 7 | contributing 8 | plugin-tutorial 9 | -------------------------------------------------------------------------------- /docs/contributing/plugin-tutorial.lhs: -------------------------------------------------------------------------------- 1 | plugin-tutorial.md -------------------------------------------------------------------------------- /docs/contributing/settings-vscode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/contributing/settings-vscode.png -------------------------------------------------------------------------------- /docs/logos/logo-1024.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/logos/logo-1024.png -------------------------------------------------------------------------------- /docs/logos/logo-128.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/logos/logo-128.png -------------------------------------------------------------------------------- /docs/logos/logo-256.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/logos/logo-256.png -------------------------------------------------------------------------------- /docs/logos/logo-32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/logos/logo-32.png -------------------------------------------------------------------------------- /docs/logos/logo-512.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/logos/logo-512.png -------------------------------------------------------------------------------- /docs/logos/logo-64.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/docs/logos/logo-64.png -------------------------------------------------------------------------------- /docs/requirements.txt: -------------------------------------------------------------------------------- 1 | Sphinx~=8.1.3 2 | sphinx-rtd-theme~=3.0.2 3 | myst-parser~=4.0.0 4 | docutils~=0.21.2 5 | -------------------------------------------------------------------------------- /docs/support/index.rst: -------------------------------------------------------------------------------- 1 | GHC and Plugin Support 2 | ====================== 3 | 4 | .. toctree:: 5 | :maxdepth: 2 6 | 7 | ghc-version-support 8 | plugin-support 9 | -------------------------------------------------------------------------------- /fmt.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -eou pipefail 3 | curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s ghcide/src ghcide/exe ghcide-bench/exe shake-bench/src ghcide/test/exe --with-group=extra --hint=.hlint.yaml 4 | -------------------------------------------------------------------------------- /ghcide-test/data/TH/THA.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module THA where 3 | import Language.Haskell.TH 4 | 5 | th_a :: DecsQ 6 | th_a = [d| a = () |] 7 | -------------------------------------------------------------------------------- /ghcide-test/data/TH/THB.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module THB where 3 | import THA 4 | 5 | $th_a 6 | -------------------------------------------------------------------------------- /ghcide-test/data/TH/THC.hs: -------------------------------------------------------------------------------- 1 | module THC where 2 | import THB 3 | 4 | c ::() 5 | c = a 6 | -------------------------------------------------------------------------------- /ghcide-test/data/TH/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["-Wmissing-signatures", "-package template-haskell", "THA", "THB", "THC"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/THCoreFile/THC.hs: -------------------------------------------------------------------------------- 1 | module THC where 2 | import THB 3 | 4 | c ::() 5 | c = a 6 | -------------------------------------------------------------------------------- /ghcide-test/data/THCoreFile/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["-package template-haskell", "THA", "THB", "THC"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/THLoading/A.hs: -------------------------------------------------------------------------------- 1 | module A where 2 | import B (bar) 3 | 4 | foo :: () 5 | foo = bar 6 | -------------------------------------------------------------------------------- /ghcide-test/data/THLoading/B.hs: -------------------------------------------------------------------------------- 1 | module B where 2 | 3 | bar :: () 4 | bar = () 5 | -------------------------------------------------------------------------------- /ghcide-test/data/THLoading/THA.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module THA where 3 | import Language.Haskell.TH 4 | import A (foo) 5 | 6 | th_a :: DecsQ 7 | th_a = [d| a = foo |] 8 | -------------------------------------------------------------------------------- /ghcide-test/data/THLoading/THB.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module THB where 3 | import THA 4 | 5 | $th_a 6 | -------------------------------------------------------------------------------- /ghcide-test/data/THLoading/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["-package template-haskell", "THA", "THB", "A", "B"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/THNewName/A.hs: -------------------------------------------------------------------------------- 1 | module A (template) where 2 | 3 | import Language.Haskell.TH 4 | 5 | template :: DecsQ 6 | template = (\consA -> [DataD [] (mkName "A") [] Nothing [NormalC consA []] []]) <$> newName "A" 7 | -------------------------------------------------------------------------------- /ghcide-test/data/THNewName/B.hs: -------------------------------------------------------------------------------- 1 | module B(A(A)) where 2 | 3 | import A 4 | 5 | template 6 | -------------------------------------------------------------------------------- /ghcide-test/data/THNewName/C.hs: -------------------------------------------------------------------------------- 1 | module C where 2 | import B 3 | 4 | a = A 5 | -------------------------------------------------------------------------------- /ghcide-test/data/THNewName/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["-XTemplateHaskell","-Wmissing-signatures","A", "B", "C"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/THUnboxed/THB.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module THB where 3 | import THA 4 | 5 | $th_a 6 | -------------------------------------------------------------------------------- /ghcide-test/data/THUnboxed/THC.hs: -------------------------------------------------------------------------------- 1 | module THC where 2 | import THB 3 | 4 | c ::() 5 | c = a 6 | -------------------------------------------------------------------------------- /ghcide-test/data/THUnboxed/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["-Wmissing-signatures", "-package template-haskell", "THA", "THB", "THC"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/boot/A.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module A where 3 | 4 | import B( TB(..) ) 5 | 6 | newtype TA = MkTA Int 7 | deriving Eq 8 | 9 | f :: TB -> TA 10 | f (MkTB x) = MkTA x 11 | -------------------------------------------------------------------------------- /ghcide-test/data/boot/A.hs-boot: -------------------------------------------------------------------------------- 1 | module A where 2 | newtype TA = MkTA Int 3 | instance Eq TA 4 | -------------------------------------------------------------------------------- /ghcide-test/data/boot/B.hs: -------------------------------------------------------------------------------- 1 | module B(TA(..), TB(..)) where 2 | import {-# SOURCE #-} A( TA(..) ) 3 | 4 | data TB = MkTB !Int 5 | 6 | g :: TA -> TB 7 | g (MkTA x) = MkTB x 8 | -------------------------------------------------------------------------------- /ghcide-test/data/boot/C.hs: -------------------------------------------------------------------------------- 1 | module C where 2 | 3 | import B 4 | import A hiding (MkTA(..)) 5 | 6 | x = MkTA 7 | y = MkTB 8 | z = f 9 | -------------------------------------------------------------------------------- /ghcide-test/data/boot/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["A.hs", "A.hs-boot", "B.hs", "C.hs"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/boot2/B.hs: -------------------------------------------------------------------------------- 1 | module B where 2 | 3 | import D 4 | 5 | data B = B 6 | 7 | instance Show B where 8 | show B = "B" 9 | -------------------------------------------------------------------------------- /ghcide-test/data/boot2/B.hs-boot: -------------------------------------------------------------------------------- 1 | module B where 2 | 3 | data B = B 4 | -------------------------------------------------------------------------------- /ghcide-test/data/boot2/C.hs: -------------------------------------------------------------------------------- 1 | module C where 2 | 3 | import B 4 | -------------------------------------------------------------------------------- /ghcide-test/data/boot2/D.hs: -------------------------------------------------------------------------------- 1 | module D where 2 | 3 | import {-# SOURCE #-} B 4 | -------------------------------------------------------------------------------- /ghcide-test/data/boot2/E.hs: -------------------------------------------------------------------------------- 1 | module E(B(B)) where 2 | 3 | import {-# SOURCE #-} B 4 | -------------------------------------------------------------------------------- /ghcide-test/data/boot2/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["A.hs", "B.hs-boot", "B.hs", "C.hs", "D.hs", "E.hs"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/cabal-exe/a/src/Main.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = putStrLn "Hello, Haskell!" 4 | -------------------------------------------------------------------------------- /ghcide-test/data/cabal-exe/cabal.project: -------------------------------------------------------------------------------- 1 | packages: ./a -------------------------------------------------------------------------------- /ghcide-test/data/cabal-exe/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | component: "exe:a" -------------------------------------------------------------------------------- /ghcide-test/data/hover/Bar.hs: -------------------------------------------------------------------------------- 1 | module Bar (Bar(..)) where 2 | 3 | -- | Bar Haddock 4 | data Bar = Bar 5 | -------------------------------------------------------------------------------- /ghcide-test/data/hover/Foo.hs: -------------------------------------------------------------------------------- 1 | module Foo (Bar, foo) where 2 | 3 | import Bar 4 | 5 | -- | foo Haddock 6 | foo = Bar 7 | -------------------------------------------------------------------------------- /ghcide-test/data/hover/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["Foo", "Bar", "GotoHover", "RecordDotSyntax", "GotoImplementation"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/ignore-fatal/IgnoreFatal.hs: -------------------------------------------------------------------------------- 1 | -- "missing signature" is declared a fatal warning in the cabal file, 2 | -- but is ignored in this module. 3 | 4 | {-# OPTIONS_GHC -Wno-missing-signatures #-} 5 | 6 | module IgnoreFatal where 7 | 8 | a = 'a' 9 | -------------------------------------------------------------------------------- /ghcide-test/data/ignore-fatal/cabal.project: -------------------------------------------------------------------------------- 1 | packages: ignore-fatal.cabal 2 | -------------------------------------------------------------------------------- /ghcide-test/data/ignore-fatal/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | - path: "." 4 | component: "lib:ignore-fatal" 5 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit-reexport/a/A.hs: -------------------------------------------------------------------------------- 1 | module A(foo) where 2 | import Data.Text 3 | foo = () 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit-reexport/b/B.hs: -------------------------------------------------------------------------------- 1 | module B(module B) where 2 | import A 3 | qux = foo 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit-reexport/c/C.hs: -------------------------------------------------------------------------------- 1 | module C(module C) where 2 | import A 3 | import B 4 | cux = foo `seq` qux 5 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit-reexport/cabal.project: -------------------------------------------------------------------------------- 1 | packages: a b c 2 | multi-repl: True 3 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit-reexport/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: ["-unit" ,"@a-1.0.0-inplace" 4 | ,"-unit" ,"@b-1.0.0-inplace" 5 | ,"-unit" ,"@c-1.0.0-inplace" 6 | ] 7 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit/a/A.hs: -------------------------------------------------------------------------------- 1 | module A(foo) where 2 | import Data.Text 3 | foo = () 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit/b/B.hs: -------------------------------------------------------------------------------- 1 | module B(module B) where 2 | import "a" A 3 | qux = foo 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit/c/C.hs: -------------------------------------------------------------------------------- 1 | module C(module C) where 2 | import A 3 | cux = foo 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit/cabal.project: -------------------------------------------------------------------------------- 1 | packages: a b c 2 | multi-repl: True 3 | -------------------------------------------------------------------------------- /ghcide-test/data/multi-unit/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: ["-unit" ,"@a-1.0.0-inplace" 4 | ,"-unit" ,"@b-1.0.0-inplace" 5 | ,"-unit" ,"@c-1.0.0-inplace" 6 | ] 7 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/a/A.hs: -------------------------------------------------------------------------------- 1 | module A(foo) where 2 | import Control.Concurrent.Async 3 | foo = () 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/a/a.cabal: -------------------------------------------------------------------------------- 1 | name: a 2 | version: 1.0.0 3 | build-type: Simple 4 | cabal-version: >= 1.2 5 | 6 | library 7 | build-depends: base, async >= 2.0 8 | exposed-modules: A 9 | hs-source-dirs: . 10 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/b/B.hs: -------------------------------------------------------------------------------- 1 | module B(module B) where 2 | import A 3 | qux = foo 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/b/b.cabal: -------------------------------------------------------------------------------- 1 | name: b 2 | version: 1.0.0 3 | build-type: Simple 4 | cabal-version: >= 1.2 5 | 6 | library 7 | build-depends: base, a 8 | exposed-modules: B 9 | hs-source-dirs: . 10 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/c/C.hs: -------------------------------------------------------------------------------- 1 | module C(module C) where 2 | import A 3 | cux = foo 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/c/c.cabal: -------------------------------------------------------------------------------- 1 | name: c 2 | version: 1.0.0 3 | build-type: Simple 4 | cabal-version: >= 1.2 5 | 6 | library 7 | build-depends: base, a 8 | exposed-modules: C 9 | hs-source-dirs: . 10 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/cabal.project: -------------------------------------------------------------------------------- 1 | packages: a b c 2 | 3 | allow-newer: base 4 | -------------------------------------------------------------------------------- /ghcide-test/data/multi/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | - path: "./a" 4 | component: "lib:a" 5 | - path: "./b" 6 | component: "lib:b" 7 | - path: "./c" 8 | component: "lib:c" 9 | -------------------------------------------------------------------------------- /ghcide-test/data/plugin-knownnat/cabal.project: -------------------------------------------------------------------------------- 1 | packages: . 2 | 3 | -- Needed for ghc >= 9.0.2 and ghc-typelits-natnormalise == 0.7.6 4 | allow-newer: ghc-typelits-natnormalise:ghc-bignum 5 | -------------------------------------------------------------------------------- /ghcide-test/data/plugin-knownnat/plugin.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 1.18 2 | name: plugin 3 | version: 1.0.0 4 | build-type: Simple 5 | 6 | library 7 | build-depends: base, ghc-typelits-knownnat 8 | exposed-modules: KnownNat 9 | hs-source-dirs: . 10 | -------------------------------------------------------------------------------- /ghcide-test/data/recomp/A.hs: -------------------------------------------------------------------------------- 1 | module A(x) where 2 | 3 | import B 4 | 5 | x :: Int 6 | x = y 7 | -------------------------------------------------------------------------------- /ghcide-test/data/recomp/B.hs: -------------------------------------------------------------------------------- 1 | module B(y) where 2 | 3 | y :: Int 4 | y = undefined 5 | -------------------------------------------------------------------------------- /ghcide-test/data/recomp/P.hs: -------------------------------------------------------------------------------- 1 | module P() where 2 | import A 3 | import B 4 | 5 | bar = x :: Int 6 | -------------------------------------------------------------------------------- /ghcide-test/data/recomp/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["-Wmissing-signatures","B", "A", "P"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/references/Main.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import References 4 | 5 | main :: IO () 6 | main = return () 7 | 8 | 9 | 10 | a = 2 :: Int 11 | b = a + 1 12 | 13 | acc :: Account 14 | acc = Savings 15 | -------------------------------------------------------------------------------- /ghcide-test/data/references/OtherOtherModule.hs: -------------------------------------------------------------------------------- 1 | module OtherOtherModule where 2 | 3 | symbolDefinedInOtherOtherModule = "asdf" 4 | -------------------------------------------------------------------------------- /ghcide-test/data/references/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["Main","OtherModule","OtherOtherModule","References"]}} 2 | -------------------------------------------------------------------------------- /ghcide-test/data/rootUri/dirA/Foo.hs: -------------------------------------------------------------------------------- 1 | module Foo () where 2 | 3 | foo = () 4 | -------------------------------------------------------------------------------- /ghcide-test/data/rootUri/dirA/foo.cabal: -------------------------------------------------------------------------------- 1 | name: foo 2 | version: 1.0.0 3 | build-type: Simple 4 | cabal-version: >= 1.2 5 | 6 | library 7 | build-depends: base 8 | exposed-modules: Foo 9 | hs-source-dirs: . 10 | -------------------------------------------------------------------------------- /ghcide-test/data/rootUri/dirB/Foo.hs: -------------------------------------------------------------------------------- 1 | module Foo () where 2 | 3 | foo = () 4 | -------------------------------------------------------------------------------- /ghcide-test/data/rootUri/dirB/foo.cabal: -------------------------------------------------------------------------------- 1 | name: foo 2 | version: 1.0.0 3 | build-type: Simple 4 | cabal-version: >= 1.2 5 | 6 | library 7 | build-depends: base 8 | exposed-modules: Foo 9 | hs-source-dirs: . 10 | -------------------------------------------------------------------------------- /ghcide-test/data/symlink/hie.yaml: -------------------------------------------------------------------------------- 1 | 2 | cradle: 3 | direct: 4 | arguments: 5 | - -i 6 | - -isrc 7 | - -iother_loc/ 8 | - other_loc/Sym.hs 9 | - src/Foo.hs 10 | - -Wall 11 | -------------------------------------------------------------------------------- /ghcide-test/data/symlink/other_loc/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/ghcide-test/data/symlink/other_loc/.gitkeep -------------------------------------------------------------------------------- /ghcide-test/data/symlink/some_loc/Sym.hs: -------------------------------------------------------------------------------- 1 | module Sym where 2 | 3 | foo :: String 4 | foo = "" 5 | -------------------------------------------------------------------------------- /ghcide-test/data/symlink/src/Foo.hs: -------------------------------------------------------------------------------- 1 | module Foo where 2 | 3 | import Sym 4 | 5 | -------------------------------------------------------------------------------- /ghcide-test/data/watched-files/reload/src/MyLib.hs: -------------------------------------------------------------------------------- 1 | module MyLib (someFunc) where 2 | 3 | import Data.List.Split 4 | 5 | someFunc :: IO () 6 | someFunc = putStrLn "someFunc" 7 | -------------------------------------------------------------------------------- /ghcide-test/data/working-dir/a/B.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module B() where 3 | 4 | import A 5 | 6 | $th_a 7 | -------------------------------------------------------------------------------- /ghcide-test/data/working-dir/a/wdtest: -------------------------------------------------------------------------------- 1 | test 2 | -------------------------------------------------------------------------------- /ghcide-test/data/working-dir/cabal.project: -------------------------------------------------------------------------------- 1 | packages: a 2 | -------------------------------------------------------------------------------- /ghcide-test/data/working-dir/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | -------------------------------------------------------------------------------- /ghcide-test/manual/lhs/Main.hs: -------------------------------------------------------------------------------- 1 | -- Copyright (c) 2019 The DAML Authors. All rights reserved. 2 | -- SPDX-License-Identifier: Apache-2.0 3 | 4 | module Main 5 | ( 6 | main 7 | ) where 8 | 9 | import Test (main) 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /ghcide/.gitignore: -------------------------------------------------------------------------------- 1 | dist/ 2 | .stack-work/ 3 | dist-newstyle/ 4 | cabal.project.local 5 | *~ 6 | *.lock 7 | /.tasty-rerun-log 8 | .vscode 9 | /.hlint-* 10 | .shake/ 11 | ghcide 12 | ghcide-bench 13 | ghcide-preprocessor 14 | *.gcStats.log 15 | tags 16 | -------------------------------------------------------------------------------- /ghcide/img/vscode2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/ghcide/img/vscode2.png -------------------------------------------------------------------------------- /hie-compat/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Revision history for hie-compat 2 | 3 | ## 0.1.0.0 -- 2020-10-19 4 | 5 | * Initial Release 6 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc9/Compat/HieBin.hs: -------------------------------------------------------------------------------- 1 | {- 2 | Binary serialization for .hie files. 3 | -} 4 | 5 | module Compat.HieBin ( module GHC.Iface.Ext.Binary) 6 | where 7 | 8 | import GHC.Iface.Ext.Binary 9 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc9/Compat/HieTypes.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieTypes 2 | ( module GHC.Iface.Ext.Types ) where 3 | import GHC.Iface.Ext.Types 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc9/Compat/HieUtils.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieUtils 2 | ( module GHC.Iface.Ext.Utils ) where 3 | import GHC.Iface.Ext.Utils 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc92/Compat/HieAst.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieAst 2 | ( module GHC.Iface.Ext.Ast ) where 3 | import GHC.Iface.Ext.Ast 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc92/Compat/HieBin.hs: -------------------------------------------------------------------------------- 1 | {- 2 | Binary serialization for .hie files. 3 | -} 4 | 5 | module Compat.HieBin ( module GHC.Iface.Ext.Binary) 6 | where 7 | 8 | import GHC.Iface.Ext.Binary 9 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc92/Compat/HieTypes.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieTypes 2 | ( module GHC.Iface.Ext.Types ) where 3 | import GHC.Iface.Ext.Types 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport-ghc92/Compat/HieUtils.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieUtils 2 | ( module GHC.Iface.Ext.Utils ) where 3 | import GHC.Iface.Ext.Utils 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport/Compat/HieDebug.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieDebug 2 | ( module HieDebug ) where 3 | import HieDebug 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport/Compat/HieTypes.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieTypes 2 | ( module HieTypes ) where 3 | import HieTypes 4 | -------------------------------------------------------------------------------- /hie-compat/src-reexport/Compat/HieUtils.hs: -------------------------------------------------------------------------------- 1 | module Compat.HieUtils 2 | ( module HieUtils ) where 3 | import HieUtils 4 | -------------------------------------------------------------------------------- /hls-graph/html/data/metadata.js: -------------------------------------------------------------------------------- 1 | var version = "HEAD"; 2 | var generated = "10:33pm 30-Mar-2019"; 3 | -------------------------------------------------------------------------------- /hls-graph/html/ts/tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "target": "esnext", 4 | "outFile": "../shake.js", 5 | "newLine": "lf", 6 | "jsx": "react", 7 | "alwaysStrict": true 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /hls-graph/test/RulesSpec.hs: -------------------------------------------------------------------------------- 1 | module RulesSpec where 2 | 3 | import Test.Hspec 4 | 5 | spec :: Spec 6 | spec = do 7 | describe "" $ do 8 | pure () 9 | -------------------------------------------------------------------------------- /hls-graph/test/Spec.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-} 2 | -------------------------------------------------------------------------------- /hls-plugin-api/test/testdata/Property/NestedPropertyDefault.json: -------------------------------------------------------------------------------- 1 | {"baz":"baz","parent":{"boo":"boo","foo":"foo"}} -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/HLSAll.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-alternate-number-format-plugin/HLSAll.gif -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFindLiteralDoLet.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NoBinaryLiterals #-} 2 | module TFindLiteralDoLet where 3 | 4 | doLet :: IO () 5 | doLet = do 6 | let x = 199 7 | y = 144 8 | pure () 9 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFindLiteralDoReturn.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NoBinaryLiterals #-} 2 | module TFindLiteralDoReturn where 3 | 4 | doReturn :: IO Integer 5 | doReturn = do 6 | pure 54 7 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFindLiteralList.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NoBinaryLiterals #-} 2 | module TFindLiteralList where 3 | 4 | listTest = [reverse $ show 57] 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracDtoE.expected.hs: -------------------------------------------------------------------------------- 1 | module TFracDtoE where 2 | 3 | convertMe = 1.2345e2 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracDtoE.hs: -------------------------------------------------------------------------------- 1 | module TFracDtoE where 2 | 3 | convertMe = 123.45 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracDtoHF.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | {-# LANGUAGE HexFloatLiterals #-} 3 | module TFracDtoHF where 4 | 5 | convertMe = 0x1.edccccccccccdp6 6 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracDtoHF.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | module TFracDtoHF where 3 | 4 | convertMe = 123.45 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracDtoHFWithPragma.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE HexFloatLiterals #-} 2 | module TFracDtoHFWithPragma where 3 | 4 | convertMe = 0x1.edccccccccccdp6 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracDtoHFWithPragma.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE HexFloatLiterals #-} 2 | module TFracDtoHFWithPragma where 3 | 4 | convertMe = 123.45 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracHFtoD.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE HexFloatLiterals #-} 2 | module TFracDtoHF where 3 | 4 | convertMe = 123.45 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TFracHFtoD.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE HexFloatLiterals #-} 2 | module TFracDtoHF where 3 | 4 | convertMe = 0x1.edccccccccccdp6 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoB.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | {-# LANGUAGE BinaryLiterals #-} 3 | module TIntDtoB where 4 | 5 | convertMe = 0b1100 6 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoB.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | module TIntDtoB where 3 | 4 | convertMe = 12 5 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoH.expected.hs: -------------------------------------------------------------------------------- 1 | module TIntDtoH where 2 | 3 | convertMe = 0xC 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoH.hs: -------------------------------------------------------------------------------- 1 | module TIntDtoH where 2 | 3 | convertMe = 12 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoND.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | {-# LANGUAGE NumDecimals #-} 3 | module TIntDtoND where 4 | 5 | convertMe :: Integer 6 | convertMe = 1.25345e5 7 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoND.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | module TIntDtoND where 3 | 4 | convertMe :: Integer 5 | convertMe = 125345 6 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoO.expected.hs: -------------------------------------------------------------------------------- 1 | module TIntDtoO where 2 | 3 | convertMe = 0o14 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntDtoO.hs: -------------------------------------------------------------------------------- 1 | module TIntDtoO where 2 | 3 | convertMe = 12 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntHtoD.expected.hs: -------------------------------------------------------------------------------- 1 | module TIntDtoH where 2 | 3 | convertMe = 12 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/TIntHtoD.hs: -------------------------------------------------------------------------------- 1 | module TIntDtoH where 2 | 3 | convertMe = 0xC 4 | -------------------------------------------------------------------------------- /plugins/hls-alternate-number-format-plugin/test/testdata/test/testdata/TIntDtoND.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NumDecimals #-} 2 | module TIntDtoND where 3 | 4 | convertMe :: Integer 5 | convertMe = 125.345e3 6 | -------------------------------------------------------------------------------- /plugins/hls-cabal-fmt-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /plugins/hls-cabal-fmt-plugin/test/testdata/src/MyLib.hs: -------------------------------------------------------------------------------- 1 | module MyLib (someFunc) where 2 | 3 | someFunc :: IO () 4 | someFunc = putStrLn "someFunc" 5 | -------------------------------------------------------------------------------- /plugins/hls-cabal-fmt-plugin/test/testdata/src/MyOtherLib.hs: -------------------------------------------------------------------------------- 1 | module MyOtherLib where 2 | 3 | bar = 2 4 | -------------------------------------------------------------------------------- /plugins/hls-cabal-gild-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /plugins/hls-cabal-gild-plugin/test/testdata/src/MyLib.hs: -------------------------------------------------------------------------------- 1 | module MyLib (someFunc) where 2 | 3 | someFunc :: IO () 4 | someFunc = putStrLn "someFunc" 5 | -------------------------------------------------------------------------------- /plugins/hls-cabal-gild-plugin/test/testdata/src/MyOtherLib.hs: -------------------------------------------------------------------------------- 1 | module MyOtherLib where 2 | 3 | bar = 2 4 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-bench/bench/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | import Data.List.Split 4 | 5 | main :: IO () 6 | main = putStrLn "Test suite not yet implemented." 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-exe/src/Main.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Data.List.Split 4 | 5 | main = putStrLn "Hello, Haskell!" -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-lib/src/MyLib.hs: -------------------------------------------------------------------------------- 1 | module MyLib (someFunc) where 2 | 3 | import Data.List.Split 4 | 5 | someFunc :: IO () 6 | someFunc = putStrLn "someFunc" 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-multitarget/bench/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | import Data.List.Split 4 | 5 | main :: IO () 6 | main = putStrLn "Test suite not yet implemented." 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-multitarget/lib/InternalLib.hs: -------------------------------------------------------------------------------- 1 | module InternalLib (internalFunc) where 2 | 3 | import Data.List.Split 4 | 5 | internalFunc :: IO () 6 | internalFunc = putStrLn "internalFunc" 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-multitarget/lib/MyLib.hs: -------------------------------------------------------------------------------- 1 | module MyLib (someFunc) where 2 | 3 | import Data.List.Split 4 | 5 | someFunc :: IO () 6 | someFunc = putStrLn "someFunc" 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-multitarget/src/Main.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Data.List.Split 4 | 5 | main = putStrLn "Hello, Haskell!" -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-multitarget/test/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | import Data.List.Split 4 | 5 | main :: IO () 6 | main = putStrLn "Test suite not yet implemented." 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-packageYaml/src/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | import Data.List.Split 4 | 5 | main :: IO () 6 | main = putStrLn "Test suite not yet implemented." 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal-add-tests/test/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | import Data.List.Split 4 | 5 | main :: IO () 6 | main = putStrLn "Test suite not yet implemented." 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/cabal.project: -------------------------------------------------------------------------------- 1 | packages: cabal-add-exe 2 | cabal-add-lib 3 | cabal-add-tests 4 | cabal-add-bench 5 | cabal-add-multitarget 6 | cabal-add-packageYaml 7 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/cabal-add-testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/filepath-completions/.hidden: -------------------------------------------------------------------------------- 1 | test hidden file 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/filepath-completions/Content.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-cabal-plugin/test/testdata/filepath-completions/Content.hs -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/filepath-completions/dir1/f1.txt: -------------------------------------------------------------------------------- 1 | test text file 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/filepath-completions/dir1/f2.hs: -------------------------------------------------------------------------------- 1 | -- test haskell file 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/filepath-completions/dir2/dir3/MARKDOWN.md: -------------------------------------------------------------------------------- 1 | test markdown file 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/filepath-completions/textfile.txt: -------------------------------------------------------------------------------- 1 | test text file 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/Library/Lib.hs: -------------------------------------------------------------------------------- 1 | module Library.Lib where 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/Library/Other/OtherLib.hs: -------------------------------------------------------------------------------- 1 | module Library.Other.OtherLib where 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/bench/Config.hs: -------------------------------------------------------------------------------- 1 | module Config where 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/bench/Main.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = undefined -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/exe/Config.hs: -------------------------------------------------------------------------------- 1 | module Confing where -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/exe/Main.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = undefined -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/test/Config.hs: -------------------------------------------------------------------------------- 1 | module Config where -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/test/Library.hs: -------------------------------------------------------------------------------- 1 | module Library where -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/test/Main.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-cabal-plugin/test/testdata/goto-definition/modules/src/test/Main.hs -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/invalid.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 3.0 2 | name: invalid 3 | version: 0.1.0.0 4 | license: BSD3 5 | 6 | library 7 | build-depends: base 8 | default-language: Haskell2010 9 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/outline-cabal/field.cabal: -------------------------------------------------------------------------------- 1 | homepage: -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/outline-cabal/fieldline.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 3.0 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/outline-cabal/section.cabal: -------------------------------------------------------------------------------- 1 | build-depends: 2 | base >=4.16 && <5 -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/outline-cabal/sectionarg.cabal: -------------------------------------------------------------------------------- 1 | if os(windows) 2 | build-depends: Win32 -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/simple-cabal/A.hs: -------------------------------------------------------------------------------- 1 | module A where 2 | 3 | -- definitions don't matter here. 4 | foo = 1 5 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/simple-cabal/cabal.project: -------------------------------------------------------------------------------- 1 | packages: . 2 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/simple-cabal/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/src-modules/Dir1/Dir2/File2.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-cabal-plugin/test/testdata/src-modules/Dir1/Dir2/File2.hs -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/src-modules/Dir1/Dir3/Dir4/File3.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-cabal-plugin/test/testdata/src-modules/Dir1/Dir3/Dir4/File3.hs -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/src-modules/File1.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-cabal-plugin/test/testdata/src-modules/File1.hs -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/src-modules/test.cabal: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-cabal-plugin/test/testdata/src-modules/test.cabal -------------------------------------------------------------------------------- /plugins/hls-cabal-plugin/test/testdata/unsupportedVersion.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 99999.0 2 | name: invalid 3 | version: 0.1.0.0 -------------------------------------------------------------------------------- /plugins/hls-call-hierarchy-plugin/call-hierarchy-in-emacs.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-call-hierarchy-plugin/call-hierarchy-in-emacs.gif -------------------------------------------------------------------------------- /plugins/hls-call-hierarchy-plugin/call-hierarchy-in-vscode.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-call-hierarchy-plugin/call-hierarchy-in-vscode.gif -------------------------------------------------------------------------------- /plugins/hls-call-hierarchy-plugin/test/testdata/B.hs: -------------------------------------------------------------------------------- 1 | module B where 2 | import qualified C 3 | data T = A | B 4 | 5 | a = 3 + C.a 6 | b = 4 7 | c = 5 8 | -------------------------------------------------------------------------------- /plugins/hls-call-hierarchy-plugin/test/testdata/C.hs: -------------------------------------------------------------------------------- 1 | module C where 2 | 3 | a = 3 4 | b = 4 5 | c = 5 6 | -------------------------------------------------------------------------------- /plugins/hls-call-hierarchy-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["A", "B", "C"]}} 2 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/change1.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-change-type-signature-plugin/change1.gif -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/change2.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-change-type-signature-plugin/change2.gif -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TErrorGivenPartialSignature.hs: -------------------------------------------------------------------------------- 1 | module TErrorGivenPartialSignature where 2 | 3 | partial :: Int -> Int 4 | partial x = init x 5 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TExpectedActual.expected.hs: -------------------------------------------------------------------------------- 1 | module TExpectedActual where 2 | 3 | fullSig :: [Int] -> Int 4 | fullSig = go 5 | where 6 | go = head . reverse 7 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TExpectedActual.hs: -------------------------------------------------------------------------------- 1 | module TExpectedActual where 2 | 3 | fullSig :: Int -> Int 4 | fullSig = go 5 | where 6 | go = head . reverse 7 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TLocalBinding.hs: -------------------------------------------------------------------------------- 1 | module TLocalBinding where 2 | 3 | import Control.Monad (forM) 4 | 5 | local :: Int -> Int 6 | local x = let test :: Int -> Int 7 | test = forM 8 | in x + 1 9 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TRigidType.expected.hs: -------------------------------------------------------------------------------- 1 | module TRigidType where 2 | 3 | test :: [[Int]] -> Int 4 | test = go . head . reverse 5 | where 6 | go = head . reverse 7 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TRigidType.hs: -------------------------------------------------------------------------------- 1 | module TRigidType where 2 | 3 | test :: a -> Int 4 | test = go . head . reverse 5 | where 6 | go = head . reverse 7 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TRigidType2.expected.hs: -------------------------------------------------------------------------------- 1 | module TRigidType2 where 2 | 3 | test :: [Int] -> Int 4 | test = head 5 | -------------------------------------------------------------------------------- /plugins/hls-change-type-signature-plugin/test/testdata/TRigidType2.hs: -------------------------------------------------------------------------------- 1 | module TRigidType2 where 2 | 3 | test :: a -> Int 4 | test = head 5 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/codeactions.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-class-plugin/codeactions.gif -------------------------------------------------------------------------------- /plugins/hls-class-plugin/codelens.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-class-plugin/codelens.gif -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/AllMethodsRequired.hs: -------------------------------------------------------------------------------- 1 | module AllMethodsRequired where 2 | 3 | class Test a where 4 | f :: a 5 | g :: a 6 | {-# MINIMAL f,g #-} 7 | 8 | instance Test [a] where 9 | 10 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/CodeLensSimple.hs: -------------------------------------------------------------------------------- 1 | module CodeLensSimple where 2 | 3 | data A 4 | instance Eq A where 5 | (==) = _ 6 | 7 | data B 8 | instance Eq B where 9 | (==)= _ 10 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/CodeLensWithGHC2021.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE GHC2021 #-} 2 | module CodeLensWithGHC2021 where 3 | 4 | data A 5 | instance Eq A where 6 | (==) :: A -> A -> Bool 7 | (==) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/CodeLensWithGHC2021.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE GHC2021 #-} 2 | module CodeLensWithGHC2021 where 3 | 4 | data A 5 | instance Eq A where 6 | (==) = _ 7 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/CodeLensWithPragma.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE InstanceSigs #-} 2 | module CodeLensWithPragma where 3 | 4 | data A 5 | instance Eq A where 6 | (==) :: A -> A -> Bool 7 | (==) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/CodeLensWithPragma.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE InstanceSigs #-} 2 | module CodeLensWithPragma where 3 | 4 | data A 5 | instance Eq A where 6 | (==) = _ 7 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/Inline.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE InstanceSigs #-} 2 | module Inline where 3 | 4 | data A 5 | instance Eq A where (==) :: A -> A -> Bool 6 | (==) = _ 7 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/Inline.hs: -------------------------------------------------------------------------------- 1 | module Inline where 2 | 3 | data A 4 | instance Eq A where (==) = _ 5 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertPragmaOnce.hs: -------------------------------------------------------------------------------- 1 | module InsertPragmaOnce where 2 | 3 | data A aaa 4 | instance Applicative A 5 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertWithGHC2021Enabled.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE GHC2021#-} 2 | module InsertWithGHC2021Enabled where 3 | 4 | data A 5 | instance Eq A where 6 | (==) :: A -> A -> Bool 7 | (==) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertWithGHC2021Enabled.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE GHC2021#-} 2 | module InsertWithGHC2021Enabled where 3 | 4 | data A 5 | instance Eq A 6 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertWithPragma.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE InstanceSigs #-} 2 | module InsertWithPragma where 3 | 4 | data A 5 | instance Eq A where 6 | (==) :: A -> A -> Bool 7 | (==) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertWithPragma.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE InstanceSigs #-} 2 | module InsertWithPragma where 3 | 4 | data A 5 | instance Eq A 6 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertWithoutPragma.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE InstanceSigs #-} 2 | module InsertWithoutPragma where 3 | 4 | data A 5 | instance Eq A where 6 | (==) :: A -> A -> Bool 7 | (==) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/InsertWithoutPragma.hs: -------------------------------------------------------------------------------- 1 | module InsertWithoutPragma where 2 | 3 | data A 4 | instance Eq A 5 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/LocalClassDefine.hs: -------------------------------------------------------------------------------- 1 | module LocalClassDefine where 2 | 3 | data A 4 | class F a where 5 | f :: a -> Int 6 | 7 | instance F A where 8 | f = _ 9 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/MinimalDefinitionMeet.hs: -------------------------------------------------------------------------------- 1 | module MinimalDefinitionMeet where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | (==) = _ 7 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/Qualified.hs: -------------------------------------------------------------------------------- 1 | module Qualified where 2 | import qualified QualifiedA 3 | 4 | class F a where 5 | f :: a 6 | 7 | instance F QualifiedA.A where 8 | f = undefined 9 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/QualifiedA.hs: -------------------------------------------------------------------------------- 1 | module QualifiedA where 2 | 3 | data A 4 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/Stale.hs: -------------------------------------------------------------------------------- 1 | module Stale where 2 | 3 | data A a 4 | instance Functor A where 5 | fmap = _ 6 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T1.all.expected.hs: -------------------------------------------------------------------------------- 1 | module T1 where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | (==) = _ 7 | (/=) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T1.eq.expected.hs: -------------------------------------------------------------------------------- 1 | module T1 where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | (==) = _ 7 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T1.hs: -------------------------------------------------------------------------------- 1 | module T1 where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T1.ne.expected.hs: -------------------------------------------------------------------------------- 1 | module T1 where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | (/=) = _ 7 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T2.fmap.expected.hs: -------------------------------------------------------------------------------- 1 | module T2 where 2 | 3 | data X a 4 | = A a 5 | | B 6 | 7 | instance 8 | (Eq a) => Eq (X a) 9 | where 10 | 11 | instance 12 | Functor X where 13 | fmap = _ 14 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T2.hs: -------------------------------------------------------------------------------- 1 | module T2 where 2 | 3 | data X a 4 | = A a 5 | | B 6 | 7 | instance 8 | (Eq a) => Eq (X a) 9 | where 10 | 11 | instance 12 | Functor X 13 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T3.hs: -------------------------------------------------------------------------------- 1 | module T3 where 2 | 3 | class Test a where 4 | f :: a 5 | f = h 6 | g :: a 7 | h :: a 8 | h = f 9 | {-# MINIMAL f, g | g, h #-} 10 | 11 | instance Test [a] where 12 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T4.expected.hs: -------------------------------------------------------------------------------- 1 | module T4 where 2 | 3 | class Test a where 4 | _f :: a 5 | {-# MINIMAL _f #-} 6 | 7 | instance Test Int where 8 | _f = _ 9 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T4.hs: -------------------------------------------------------------------------------- 1 | module T4 where 2 | 3 | class Test a where 4 | _f :: a 5 | {-# MINIMAL _f #-} 6 | 7 | instance Test Int where 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T5.expected.hs: -------------------------------------------------------------------------------- 1 | module T5 where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | (==) = _ 7 | 8 | x = () 9 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T5.hs: -------------------------------------------------------------------------------- 1 | module T5 where 2 | 3 | data X = X 4 | 5 | instance Eq X where 6 | 7 | x = () 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/T6.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE GHC2021#-} 2 | module T6 where 3 | 4 | data A 5 | instance Eq A where 6 | (==) :: A -> A -> Bool 7 | (==) = _ 8 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/TH.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | 3 | module TH where 4 | 5 | import THDef 6 | 7 | gen ''Bool True 8 | gen ''Char 'a' 9 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/TypeFamily.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeFamilies #-} 2 | module TypeFamily where 3 | 4 | class F a where 5 | type Elem a 6 | f :: Elem a -> a 7 | 8 | instance Eq a => F [a] where 9 | f = _ 10 | -------------------------------------------------------------------------------- /plugins/hls-class-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [-XHaskell2010, QualifiedA, THDef] 4 | -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/folding-range/Empty.golden.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-code-range-plugin/test/testdata/folding-range/Empty.golden.txt -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/folding-range/Empty.hs: -------------------------------------------------------------------------------- 1 | module Empty where 2 | -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/folding-range/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "Function" 5 | - "Empty" 6 | -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/Empty.golden.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-code-range-plugin/test/testdata/selection-range/Empty.golden.txt -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/Empty.golden.txt.ghc910: -------------------------------------------------------------------------------- 1 | (1,5) (1,5) -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/Empty.hs: -------------------------------------------------------------------------------- 1 | module Empty where 2 | -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/Import.golden.txt: -------------------------------------------------------------------------------- 1 | (4,33) (4,38) => (4,32) (4,47) => (4,1) (4,47) => (3,1) (4,47) 2 | (1,8) (1,8) -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/Import.golden.txt.ghc910: -------------------------------------------------------------------------------- 1 | (4,33) (4,38) => (4,32) (4,47) => (4,1) (4,47) => (3,1) (4,47) => (1,8) (4,47) 2 | (1,8) (1,22) => (1,8) (4,47) -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/Import.hs: -------------------------------------------------------------------------------- 1 | module MultiPositions where 2 | 3 | import Data.List (find) 4 | import qualified Data.Foldable (foldl, foldl') 5 | -------------------------------------------------------------------------------- /plugins/hls-code-range-plugin/test/testdata/selection-range/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "Import" 5 | - "Function" 6 | - "Empty" 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/demo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-eval-plugin/demo.gif -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/cabal.project: -------------------------------------------------------------------------------- 1 | packages: 2 | testdata/ 3 | testdata/info-util/ 4 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T1.hs: -------------------------------------------------------------------------------- 1 | module T1 where 2 | 3 | import Data.List (unwords) 4 | 5 | -- >>> unwords example 6 | example :: [String] 7 | example = ["This","is","an","example","of","evaluation"] 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T11.expected.hs: -------------------------------------------------------------------------------- 1 | module T11 where 2 | 3 | -- >>> :kind! A 4 | -- Not in scope: type constructor or class `A' 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T11.ghc94.expected.hs: -------------------------------------------------------------------------------- 1 | module T11 where 2 | 3 | -- >>> :kind! A 4 | -- Not in scope: type constructor or class `A' 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T11.hs: -------------------------------------------------------------------------------- 1 | module T11 where 2 | 3 | -- >>> :kind! A 4 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T12.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DataKinds, TypeOperators #-} 2 | module T12 where 3 | import GHC.TypeNats ( type (+) ) 4 | 5 | type Dummy = 1 + 1 6 | 7 | -- >>> type N = 1 8 | -- >>> type M = 40 9 | -- >>> :kind N + M + 1 10 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T13.expected.hs: -------------------------------------------------------------------------------- 1 | module T13 where 2 | 3 | -- >>> :kind A 4 | -- Not in scope: type constructor or class `A' 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T13.hs: -------------------------------------------------------------------------------- 1 | module T13 where 2 | 3 | -- >>> :kind A 4 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T14.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | module T14 where 3 | 4 | foo :: Show a => a -> String 5 | foo = show 6 | 7 | -- >>> :type foo @Int 8 | -- foo @Int :: Int -> String 9 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T14.ghc98.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | module T14 where 3 | 4 | foo :: Show a => a -> String 5 | foo = show 6 | 7 | -- >>> :type foo @Int 8 | -- foo @Int :: Show Int => Int -> String 9 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T14.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | module T14 where 3 | 4 | foo :: Show a => a -> String 5 | foo = show 6 | 7 | -- >>> :type foo @Int 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T16.expected.hs: -------------------------------------------------------------------------------- 1 | module T16 where 2 | 3 | -- >>> :type +d 40+ 2 4 | -- 40+ 2 :: Integer 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T16.hs: -------------------------------------------------------------------------------- 1 | module T16 where 2 | 3 | -- >>> :type +d 40+ 2 4 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T17.expected.hs: -------------------------------------------------------------------------------- 1 | module T17 where 2 | 3 | -- >>> :type +no 42 4 | -- parse error on input `+' 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T17.hs: -------------------------------------------------------------------------------- 1 | module T17 where 2 | 3 | -- >>> :type +no 42 4 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T18.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | module T18 where 3 | 4 | -- >>> :noooop foo bar 5 | -- unknown command 'noooop' 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T18.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | module T18 where 3 | 4 | -- >>> :noooop foo bar 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T19.expected.hs: -------------------------------------------------------------------------------- 1 | module T19 where 2 | import Data.Word (Word) 3 | type W = Word 4 | 5 | -- >>> default (Word) 6 | -- >>> :type +d 40+ 2 7 | -- 40+ 2 :: Word 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T19.hs: -------------------------------------------------------------------------------- 1 | module T19 where 2 | import Data.Word (Word) 3 | type W = Word 4 | 5 | -- >>> default (Word) 6 | -- >>> :type +d 40+ 2 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T2.hs: -------------------------------------------------------------------------------- 1 | module T2 where 2 | 3 | import Data.List (unwords) 4 | 5 | -- >>> unwords example 6 | -- "Stale output" 7 | example :: [String] 8 | example = ["This","is","an","example","of","evaluation"] 9 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T20.expected.hs: -------------------------------------------------------------------------------- 1 | module T20 where 2 | import Data.Word (Word) 3 | 4 | default (Word) 5 | 6 | -- >>> :type +d 40+ 2 7 | -- 40+ 2 :: Integer 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T20.hs: -------------------------------------------------------------------------------- 1 | module T20 where 2 | import Data.Word (Word) 3 | 4 | default (Word) 5 | 6 | -- >>> :type +d 40+ 2 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T22.hs: -------------------------------------------------------------------------------- 1 | module T22 where 2 | import Data.Proxy (Proxy (..)) 3 | import GHC.TypeNats (KnownNat) 4 | import Type.Reflection (Typeable) 5 | 6 | f :: Integer 7 | f = 32 8 | 9 | -- >>> :t f 10 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T26.expected.hs: -------------------------------------------------------------------------------- 1 | module T26 where 2 | import Util () 3 | 4 | -- >>> "hello" 5 | -- "hello" 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T26.hs: -------------------------------------------------------------------------------- 1 | module T26 where 2 | import Util () 3 | 4 | -- >>> "hello" 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T27.expected.hs: -------------------------------------------------------------------------------- 1 | module T27 where 2 | 3 | -- >>> () 4 | -- () 5 | -- 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T27.hs: -------------------------------------------------------------------------------- 1 | module T27 where 2 | 3 | -- >>> () 4 | -- 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T28.expected.hs: -------------------------------------------------------------------------------- 1 | module T28 where 2 | 3 | f True = True 4 | f False = False 5 | 6 | -- >>> 1+1 7 | -- 2 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T28.hs: -------------------------------------------------------------------------------- 1 | module T28 where 2 | 3 | f True = True 4 | f False = False 5 | 6 | -- >>> 1+1 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T3.hs: -------------------------------------------------------------------------------- 1 | module T3 where 2 | 3 | 4 | -- >>> import Data.List (unwords) 5 | -- >>> unwords example 6 | example :: [String] 7 | example = ["This","is","an","example","of","evaluation"] 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T4139.expected.hs: -------------------------------------------------------------------------------- 1 | module T4139 where 2 | 3 | -- >>> 'x' 4 | -- 'x' 5 | 6 | main :: IO () 7 | main = putStrLn "Hello World!" 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T4139.hs: -------------------------------------------------------------------------------- 1 | module T4139 where 2 | 3 | -- >>> 'x' 4 | 5 | main :: IO () 6 | main = putStrLn "Hello World!" 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T5.expected.hs: -------------------------------------------------------------------------------- 1 | module T5 where 2 | 3 | -- >>> unwords example 4 | -- "This is an example of evaluation" 5 | example :: [String] 6 | example = ["This","is","an","example","of","evaluation"] 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T5.hs: -------------------------------------------------------------------------------- 1 | module T5 where 2 | 3 | -- >>> unwords example 4 | -- "This is a stale example of evaluation" 5 | example :: [String] 6 | example = ["This","is","an","example","of","evaluation"] 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T8.hs: -------------------------------------------------------------------------------- 1 | -- An empty playground 2 | module T8 where 3 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T9.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DataKinds #-} 2 | module T9 where 3 | import Data.Proxy (Proxy(..)) 4 | 5 | type P = Proxy 6 | 7 | -- >>> Proxy :: Proxy 3 8 | -- Proxy 9 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/T9.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DataKinds #-} 2 | module T9 where 3 | import Data.Proxy (Proxy(..)) 4 | 5 | type P = Proxy 6 | 7 | -- >>> Proxy :: Proxy 3 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TDiff.expected.default.hs: -------------------------------------------------------------------------------- 1 | module TDiff where 2 | 3 | -- | 4 | -- >>> myId 5 5 | -- WAS 4 6 | -- NOW 5 7 | myId :: a -> a 8 | myId x = x 9 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TDiff.expected.no-diff.hs: -------------------------------------------------------------------------------- 1 | module TDiff where 2 | 3 | -- | 4 | -- >>> myId 5 5 | -- 5 6 | myId :: a -> a 7 | myId x = x 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TDiff.hs: -------------------------------------------------------------------------------- 1 | module TDiff where 2 | 3 | -- | 4 | -- >>> myId 5 5 | -- 4 6 | myId :: a -> a 7 | myId x = x 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TEndingMulti.expected.hs: -------------------------------------------------------------------------------- 1 | module TEndingMulti where 2 | 3 | -- Now trailing doctest is allowed: 4 | 5 | {- >>> 42 6 | >>> 54 7 | 42 8 | 54 9 | -} 10 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TEndingMulti.hs: -------------------------------------------------------------------------------- 1 | module TEndingMulti where 2 | 3 | -- Now trailing doctest is allowed: 4 | 5 | {- >>> 42 6 | >>> 54-} 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TException.expected.marked.hs: -------------------------------------------------------------------------------- 1 | module TException where 2 | 3 | -- >>> exceptionalCode 4 | -- *** Exception: I am exceptional! 5 | exceptionalCode :: Int 6 | exceptionalCode = error "I am exceptional!" 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TException.expected.nomark.hs: -------------------------------------------------------------------------------- 1 | module TException where 2 | 3 | -- >>> exceptionalCode 4 | -- I am exceptional! 5 | exceptionalCode :: Int 6 | exceptionalCode = error "I am exceptional!" 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TException.hs: -------------------------------------------------------------------------------- 1 | module TException where 2 | 3 | -- >>> exceptionalCode 4 | exceptionalCode :: Int 5 | exceptionalCode = error "I am exceptional!" 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TI_Info.hs: -------------------------------------------------------------------------------- 1 | module TI_Info (Eq, Ord, Foo) where 2 | 3 | import InfoUtil (Eq, Ord, Foo) 4 | 5 | -- >>> :i Foo 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TInfo.hs: -------------------------------------------------------------------------------- 1 | module TInfo (Eq, Ord, Foo) where 2 | 3 | import InfoUtil (Eq, Ord, Foo) 4 | 5 | -- >>> :info Foo 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TInfoBang.hs: -------------------------------------------------------------------------------- 1 | module TInfoBang (Eq, Ord, Foo) where 2 | 3 | import InfoUtil (Eq, Ord, Foo) 4 | 5 | -- >>> :info! Foo 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TInfoBangMany.hs: -------------------------------------------------------------------------------- 1 | module TInfoBangMany (Eq, Ord, Foo, Bar) where 2 | 3 | import InfoUtil (Eq, Ord, Foo, Bar) 4 | 5 | -- >>> :info! Foo Bar 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TInfoMany.hs: -------------------------------------------------------------------------------- 1 | module TInfoMany (Eq, Ord, Foo, Bar) where 2 | 3 | import InfoUtil (Eq, Ord, Foo, Bar) 4 | 5 | -- >>> :info Foo Bar 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TIt.expected.hs: -------------------------------------------------------------------------------- 1 | module TIt where 2 | 3 | -- >>> "test" 4 | -- >>> it 5 | -- "test" 6 | -- "test" 7 | 8 | -- >>> pure "test2" 9 | -- >>> it 10 | -- "test2" 11 | -- "test2" 12 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TIt.hs: -------------------------------------------------------------------------------- 1 | module TIt where 2 | 3 | -- >>> "test" 4 | -- >>> it 5 | 6 | -- >>> pure "test2" 7 | -- >>> it 8 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TLastLine.expected.hs: -------------------------------------------------------------------------------- 1 | module TLastLine where 2 | 3 | -- >>> take 3 [1..] 4 | -- [1,2,3] 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TLastLine.hs: -------------------------------------------------------------------------------- 1 | module TLastLine where 2 | 3 | -- >>> take 3 [1..] -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TLocalImport.expected.hs: -------------------------------------------------------------------------------- 1 | module TLocalImport where 2 | 3 | import qualified Util 4 | 5 | -- >>> Util.tst 11 11 6 | -- True 7 | 8 | tst' :: Eq a => a -> a -> Bool 9 | tst' = Util.tst 10 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TLocalImport.hs: -------------------------------------------------------------------------------- 1 | module TLocalImport where 2 | 3 | import qualified Util 4 | 5 | -- >>> Util.tst 11 11 6 | 7 | tst' :: Eq a => a -> a -> Bool 8 | tst' = Util.tst 9 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TLocalImportInTest.expected.hs: -------------------------------------------------------------------------------- 1 | module TLocalImportInTest where 2 | 3 | -- >>> import qualified Util 4 | -- >>> Util.a 5 | -- 'a' 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TLocalImportInTest.hs: -------------------------------------------------------------------------------- 1 | module TLocalImportInTest where 2 | 3 | -- >>> import qualified Util 4 | -- >>> Util.a 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TNested.expected.hs: -------------------------------------------------------------------------------- 1 | module TNested () where 2 | {- 3 | >>> 54 4 | 54 5 | {- 6 | Nested 7 | -} 8 | -} 9 | 10 | {- 11 | {- 12 | >>> 42 13 | 42 14 | -} 15 | -} 16 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TNested.hs: -------------------------------------------------------------------------------- 1 | module TNested () where 2 | {- 3 | >>> 54 4 | {- 5 | Nested 6 | -} 7 | -} 8 | 9 | {- 10 | {- 11 | >>> 42 12 | -} 13 | -} 14 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TProperty.expected.hs: -------------------------------------------------------------------------------- 1 | -- Support for property checking 2 | module TProperty where 3 | 4 | -- prop> \(l::[Bool]) -> reverse (reverse l) == l 5 | -- +++ OK, passed 100 tests. 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TProperty.hs: -------------------------------------------------------------------------------- 1 | -- Support for property checking 2 | module TProperty where 3 | 4 | -- prop> \(l::[Bool]) -> reverse (reverse l) == l 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TPropertyError.ghc912.expected.hs: -------------------------------------------------------------------------------- 1 | -- Support for property checking 2 | module TProperty where 3 | 4 | -- prop> \(l::[Bool]) -> head l 5 | -- *** Failed! Exception: 'Prelude.head: empty list' (after 1 test): 6 | -- [] 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TPropertyError.hs: -------------------------------------------------------------------------------- 1 | -- Support for property checking 2 | module TProperty where 3 | 4 | -- prop> \(l::[Bool]) -> head l 5 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TSetup.hs: -------------------------------------------------------------------------------- 1 | -- The setup section is executed before any other test 2 | module TSetup where 3 | 4 | -- $setup 5 | -- >>> x=11 6 | -- >>> y=22 7 | 8 | -- >>> x+y 9 | 10 | -- >>> x*y 11 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TTransitive.expected.hs: -------------------------------------------------------------------------------- 1 | module TTransitive where 2 | 3 | import TLocalImport 4 | 5 | -- >>> tst' 11 11 6 | -- True 7 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/TTransitive.hs: -------------------------------------------------------------------------------- 1 | module TTransitive where 2 | 3 | import TLocalImport 4 | 5 | -- >>> tst' 11 11 6 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/Util.hs: -------------------------------------------------------------------------------- 1 | -- Used for testing local imports 2 | module Util 3 | ( tst 4 | , a 5 | , b 6 | ) 7 | where 8 | 9 | tst a b = a == b 10 | 11 | a = 'a' 12 | 13 | b = 'b' 14 | -------------------------------------------------------------------------------- /plugins/hls-eval-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | - path: "./" 4 | component: "lib:test" 5 | -------------------------------------------------------------------------------- /plugins/hls-explicit-fixity-plugin/fixity1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-explicit-fixity-plugin/fixity1.png -------------------------------------------------------------------------------- /plugins/hls-explicit-fixity-plugin/fixity2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-explicit-fixity-plugin/fixity2.png -------------------------------------------------------------------------------- /plugins/hls-explicit-fixity-plugin/test/testdata/HoverImport.hs: -------------------------------------------------------------------------------- 1 | module HoverImport where 2 | 3 | import Hover 4 | 5 | g = (>>>:) 6 | -------------------------------------------------------------------------------- /plugins/hls-explicit-fixity-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitA.hs: -------------------------------------------------------------------------------- 1 | module ExplicitA where 2 | 3 | a1 :: String 4 | a1 = "a1" 5 | 6 | a2 :: String 7 | a2 = "a2" 8 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitB.hs: -------------------------------------------------------------------------------- 1 | module ExplicitB where 2 | 3 | b1 :: String 4 | b1 = "b1" 5 | 6 | b2 :: String 7 | b2 = "b2" 8 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitBreakFile.expected.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | module ExplicitBreakFile whexe 3 | 4 | import ExplicitA ( a1 ) 5 | 6 | main = putStrLn $ "hello " ++ a1 7 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitBreakFile.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | module ExplicitBreakFile where 3 | 4 | import ExplicitA 5 | 6 | main = putStrLn $ "hello " ++ a1 7 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitExported.hs: -------------------------------------------------------------------------------- 1 | module ExplicitExported (module ExplicitA) where 2 | 3 | import ExplicitA 4 | 5 | main :: IO () 6 | main = putStrLn $ "hello " ++ a1 7 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitOnlyThis.expected.hs: -------------------------------------------------------------------------------- 1 | module ExplicitOnlyThis where 2 | 3 | import ExplicitA ( a1 ) 4 | import ExplicitB 5 | 6 | main :: IO () 7 | main = putStrLn $ "hello " ++ a1 ++ b1 8 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitOnlyThis.hs: -------------------------------------------------------------------------------- 1 | module ExplicitOnlyThis where 2 | 3 | import ExplicitA 4 | import ExplicitB 5 | 6 | main :: IO () 7 | main = putStrLn $ "hello " ++ a1 ++ b1 8 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitStaleAction.expected.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | module ExplicitStaleAction where 3 | 4 | import ExplicitA 5 | 6 | main = putStrLn $ "hello " ++ a1 7 | 8 | testing = undefined -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitStaleAction.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | module ExplicitStaleAction where 3 | 4 | import ExplicitA 5 | 6 | main = putStrLn $ "hello " ++ a1 7 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitUsualCase.expected.hs: -------------------------------------------------------------------------------- 1 | module ExplicitUsualCase where 2 | 3 | import ExplicitA ( a1 ) 4 | 5 | main :: IO () 6 | main = putStrLn $ "hello " ++ a1 7 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/ExplicitUsualCase.hs: -------------------------------------------------------------------------------- 1 | module ExplicitUsualCase where 2 | 3 | import ExplicitA 4 | 5 | main :: IO () 6 | main = putStrLn $ "hello " ++ a1 7 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineA.hs: -------------------------------------------------------------------------------- 1 | module RefineA 2 | ( module RefineB 3 | , module RefineC 4 | ) where 5 | 6 | import RefineB 7 | import RefineC -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineB.hs: -------------------------------------------------------------------------------- 1 | module RefineB where 2 | 3 | b1 :: String 4 | b1 = "b1" 5 | 6 | b2 :: String 7 | b2 = "b2" -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineC.hs: -------------------------------------------------------------------------------- 1 | module RefineC where 2 | 3 | c1 :: String 4 | c1 = "c1" -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineD.hs: -------------------------------------------------------------------------------- 1 | module RefineD (module RefineE, module RefineD) where 2 | 3 | import RefineE hiding (e1) 4 | import qualified RefineE 5 | 6 | e1 :: String 7 | e1 = RefineE.e1 <> " but overrided" -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineE.hs: -------------------------------------------------------------------------------- 1 | module RefineE where 2 | 3 | e1 :: String 4 | e1 = "e1" 5 | 6 | e2 :: String 7 | e2 = "e2" -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineF.hs: -------------------------------------------------------------------------------- 1 | module RefineF (module RefineF, module RefineG) where 2 | 3 | import RefineG 4 | 5 | f1 :: String 6 | f1 = "f1" 7 | 8 | -------------------------------------------------------------------------------- /plugins/hls-explicit-imports-plugin/test/testdata/RefineG.hs: -------------------------------------------------------------------------------- 1 | module RefineG where 2 | 3 | g1 :: String 4 | g1 = "g1" -------------------------------------------------------------------------------- /plugins/hls-explicit-record-fields-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: []}} 2 | -------------------------------------------------------------------------------- /plugins/hls-explicit-record-fields-plugin/test/testdata/noop/PartiallyAppliedCon.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Haskell2010 #-} 2 | 3 | module PartiallyAppliedCon where 4 | 5 | data T = MkT { fa :: Int, fb :: Char } 6 | 7 | foo :: Int -> Char -> T 8 | foo x = MkT x 9 | -------------------------------------------------------------------------------- /plugins/hls-explicit-record-fields-plugin/wildcard.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-explicit-record-fields-plugin/wildcard.gif -------------------------------------------------------------------------------- /plugins/hls-floskell-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /plugins/hls-fourmolu-plugin/test/testdata/Fourmolu2.formatted.hs: -------------------------------------------------------------------------------- 1 | import Data.Bool 2 | import Data.Char 3 | import Data.Data 4 | import Data.Either 5 | import Data.Int 6 | -------------------------------------------------------------------------------- /plugins/hls-fourmolu-plugin/test/testdata/Fourmolu2.hs: -------------------------------------------------------------------------------- 1 | import Data.Char 2 | import Data.Either 3 | import Data.Int 4 | import Data.Data 5 | import Data.Bool 6 | -------------------------------------------------------------------------------- /plugins/hls-fourmolu-plugin/test/testdata/Fourmolu3.formatted.hs: -------------------------------------------------------------------------------- 1 | b :: Bool 2 | b = 3 | id $ 4 | id $ 5 | case True && True of 6 | True -> True 7 | False -> False 8 | -------------------------------------------------------------------------------- /plugins/hls-fourmolu-plugin/test/testdata/Fourmolu3.hs: -------------------------------------------------------------------------------- 1 | b :: Bool 2 | b = 3 | id $ id $ 4 | case True && True of 5 | True -> True 6 | False -> False 7 | -------------------------------------------------------------------------------- /plugins/hls-fourmolu-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/gadt.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-gadt-plugin/gadt.gif -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/ConstructorContext.expected.hs: -------------------------------------------------------------------------------- 1 | module ConstructorContext where 2 | 3 | data Foo where 4 | Bar :: Show a => a -> Foo 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/ConstructorContext.hs: -------------------------------------------------------------------------------- 1 | module ConstructorContext where 2 | 3 | data Foo = forall a. (Show a) => Bar a 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Context.expected.hs: -------------------------------------------------------------------------------- 1 | module Context where 2 | 3 | data Foo a where 4 | Bar :: (Eq a, Show b, Show a) => a -> b -> Foo a 5 | Baz :: (Eq a, Show c) => c -> c -> Foo a 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Context.hs: -------------------------------------------------------------------------------- 1 | module Context where 2 | 3 | data (Eq a) => Foo a = 4 | forall b c. (Show b, Show a) => 5 | Bar a b | forall c. (Show c) => Baz c c 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Data.expected.hs: -------------------------------------------------------------------------------- 1 | module Data where 2 | 3 | data Foo where 4 | Bar :: Int -> Foo 5 | Baz :: Char -> String -> Foo 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Data.hs: -------------------------------------------------------------------------------- 1 | module Data where 2 | 3 | data Foo = Bar Int | Baz Char String 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/DataContext.expected.hs: -------------------------------------------------------------------------------- 1 | module DataContext where 2 | 3 | data T a b where 4 | F :: Ord a => a -> T a b 5 | G :: Ord a => b -> T a b 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/DataContext.hs: -------------------------------------------------------------------------------- 1 | module DataContext where 2 | 3 | data Ord a => T a b = F a | G b 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/DataContextParen.expected.hs: -------------------------------------------------------------------------------- 1 | module DataContextParen where 2 | 3 | data F a where 4 | G :: Eq a => a -> F a 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/DataContextParen.hs: -------------------------------------------------------------------------------- 1 | module DataContextParen where 2 | 3 | data (Eq a) => F a 4 | = G a 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Deriving.expected.hs: -------------------------------------------------------------------------------- 1 | module Deriving where 2 | 3 | data Foo where 4 | Bar :: Int -> Foo 5 | Baz :: Char -> String -> Foo 6 | deriving (Show, Eq) 7 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Deriving.hs: -------------------------------------------------------------------------------- 1 | module Deriving where 2 | 3 | data Foo = Bar Int | Baz Char String deriving (Show, Eq) 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Forall.expected.hs: -------------------------------------------------------------------------------- 1 | module Forall where 2 | 3 | data Foo where 4 | Bar :: Show a => a -> b -> a -> Foo 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Forall.hs: -------------------------------------------------------------------------------- 1 | module Forall where 2 | 3 | data Foo = forall a b. (Show a) => Bar a b a 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Infix.expected.hs: -------------------------------------------------------------------------------- 1 | module Infix where 2 | 3 | data Foo where 4 | (:->) :: Int -> Char -> Foo 5 | deriving () 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Infix.hs: -------------------------------------------------------------------------------- 1 | module Infix where 2 | 3 | data Foo = Int :-> Char deriving () 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Newtype.expected.hs: -------------------------------------------------------------------------------- 1 | module Newtype where 2 | 3 | newtype Foo where 4 | Bar :: Int -> Foo 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Newtype.hs: -------------------------------------------------------------------------------- 1 | module Newtype where 2 | 3 | newtype Foo = Bar Int 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Pragma.expected.hs: -------------------------------------------------------------------------------- 1 | module Pragma where 2 | 3 | data F where 4 | G :: {-# UNPACK #-}Int -> F 5 | H :: {-# NOUNPACK #-}Char -> F 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Pragma.hs: -------------------------------------------------------------------------------- 1 | module Pragma where 2 | 3 | data F = G{-# UNPACK #-}Int 4 | | H {-# NOUNPACK #-} Char 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Record.expected.hs: -------------------------------------------------------------------------------- 1 | module Record where 2 | 3 | data Foo where 4 | Foo :: {bar :: Char, baz :: Int} -> Foo 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/Record.hs: -------------------------------------------------------------------------------- 1 | module Record where 2 | 3 | data Foo = Foo { 4 | bar :: Char, 5 | baz :: Int 6 | } 7 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SimpleData.expected.hs: -------------------------------------------------------------------------------- 1 | module SimpleData where 2 | 3 | data A where 4 | B :: A 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SimpleData.hs: -------------------------------------------------------------------------------- 1 | module SimpleData where 2 | 3 | data A = B 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SimpleNewtype.expected.hs: -------------------------------------------------------------------------------- 1 | module SimpleNewtype where 2 | 3 | newtype A where 4 | B :: Int -> A 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SimpleNewtype.hs: -------------------------------------------------------------------------------- 1 | module SimpleNewtype where 2 | 3 | newtype A = B Int 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SingleDeriving.expected.hs: -------------------------------------------------------------------------------- 1 | module SingleDeriving where 2 | 3 | data Foo a b where 4 | Bar :: b -> a -> Foo a b 5 | deriving Eq 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SingleDeriving.hs: -------------------------------------------------------------------------------- 1 | module SingleDeriving where 2 | 3 | data Foo a b = Bar b a 4 | deriving (Eq) 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SingleDerivingGHC92.expected.hs: -------------------------------------------------------------------------------- 1 | module SingleDerivingGHC92 where 2 | 3 | data Foo a b where 4 | Bar :: b -> a -> Foo a b 5 | deriving (Eq) 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/SingleDerivingGHC92.hs: -------------------------------------------------------------------------------- 1 | module SingleDerivingGHC92 where 2 | 3 | data Foo a b = Bar b a 4 | deriving (Eq) 5 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/TypeVariable.expected.hs: -------------------------------------------------------------------------------- 1 | module TypeVariable where 2 | 3 | data Foo a f where 4 | Foo :: a -> Foo a f 5 | Bar :: (f a) -> Foo a f 6 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/TypeVariable.hs: -------------------------------------------------------------------------------- 1 | module TypeVariable where 2 | 3 | data Foo a f = Foo a | Bar (f a) 4 | -------------------------------------------------------------------------------- /plugins/hls-gadt-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: ["-XHaskell2010", "-XExistentialQuantification", "-XGADTs"] 4 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/.hlint.yaml: -------------------------------------------------------------------------------- 1 | # This is here so that the tests in this package don't 2 | # pick up the configuration from HLS's own .hlint.yaml 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/Base.hs: -------------------------------------------------------------------------------- 1 | main = undefined 2 | foo x = id x 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/CppCond.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE CPP #-} 2 | module CppCond where 3 | 4 | #ifdef FLAG 5 | f = (1) 6 | #else 7 | g = 2 8 | #endif 9 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/Generalise.hs: -------------------------------------------------------------------------------- 1 | main = undefined 2 | foo x y = [x, x] ++ y 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/IgnoreAnn.hs: -------------------------------------------------------------------------------- 1 | module IgnoreAnn where 2 | 3 | {-# ANN module "HLint: ignore Redundant bracket" #-} 4 | f = (1) 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/IgnoreAnnHlint.hs: -------------------------------------------------------------------------------- 1 | module IgnoreHlintAnn where 2 | 3 | {- HLINT ignore "Redundant bracket" -} 4 | f = (1) 5 | 6 | {-# HLINT ignore "Use camelCase" #-} 7 | camel_case = undefined 8 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/LambdaCase.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE LambdaCase #-} 2 | module LambdaCase where 3 | 4 | f = \case "true" -> (True) 5 | _ -> False 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/PatternKeyword.hs: -------------------------------------------------------------------------------- 1 | module Foo (pattern) where 2 | 3 | pattern = 42 4 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/StrictData.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Strict #-} 2 | f ~x = x 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/TwoHints.hs: -------------------------------------------------------------------------------- 1 | f = (1) 2 | g = (1) 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/TwoHintsAndComment.hs: -------------------------------------------------------------------------------- 1 | module TwoHintsAndComment where 2 | biggest items = foldr1 max items -- the line above will show two hlint hints, "eta reduce" and "use maximum" 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/UnrecognizedPragmasOff.expected.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} 2 | {-# HLINT ignore "Eta reduce" #-} 3 | module UnrecognizedPragmasOff where 4 | foo x = id x 5 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/UnrecognizedPragmasOff.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} 2 | module UnrecognizedPragmasOff where 3 | foo x = id x 4 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/UnrecognizedPragmasOn.expected.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wunrecognised-pragmas #-} 2 | {-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} 3 | {-# HLINT ignore "Eta reduce" #-} 4 | module UnrecognizedPragmasOn where 5 | foo x = id x 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/UnrecognizedPragmasOn.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wunrecognised-pragmas #-} 2 | module UnrecognizedPragmasOn where 3 | foo x = id x 4 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/cpp/CppCond.hs: -------------------------------------------------------------------------------- 1 | module ApplyRefact3 where 2 | 3 | #ifdef FLAG 4 | f = (1) 5 | #else 6 | g = 2 7 | #endif 8 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/cpp/CppHeader.hs: -------------------------------------------------------------------------------- 1 | module CppHeader where 2 | 3 | #include "test.h" 4 | 5 | #ifdef TEST 6 | f = (1) 7 | #else 8 | f = 1 9 | #endif 10 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/cpp/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "-XCPP" 5 | - "-DFLAG" 6 | - "CppCond" 7 | - "CppHeader" 8 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/cpp/test.h: -------------------------------------------------------------------------------- 1 | #define TEST 2 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/fixity/.hlint.yaml: -------------------------------------------------------------------------------- 1 | - fixity: "infixl 3 " 2 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/fixity/FixityDef.hs: -------------------------------------------------------------------------------- 1 | module FixityDef where 2 | 3 | infixl 3 4 | () :: Maybe a -> Maybe (Maybe b) -> Maybe String 5 | () a b = Nothing 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/fixity/FixityUse.hs: -------------------------------------------------------------------------------- 1 | module FixityUse where 2 | 3 | import FixityDef 4 | 5 | foo :: Char -> Maybe Int -> Maybe String 6 | foo c mInt = show <$> mInt pure <$> Just c 7 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/fixity/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "FixityDef" 5 | - "FixityUse" 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/ignore/.hlint.yaml: -------------------------------------------------------------------------------- 1 | - ignore: { name: "Redundant bracket" } 2 | - ignore: { name: "Use camelCase" } 3 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/ignore/CamelCase.hs: -------------------------------------------------------------------------------- 1 | module CamelCase where 2 | 3 | f = (1) 4 | 5 | camel_case = undefined 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/ignore/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "CamelCase" 5 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/lambdacase/LambdaCase.hs: -------------------------------------------------------------------------------- 1 | module LambdaCase where 2 | 3 | f = \case "true" -> (True) 4 | _ -> False 5 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/lambdacase/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "-XLambdaCase" 5 | - "LambdaCase" 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/test-hlint-config.yaml: -------------------------------------------------------------------------------- 1 | - ignore: { name: Eta reduce } 2 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/typeapps/TypeApplication.hs: -------------------------------------------------------------------------------- 1 | module TypeApplication where 2 | 3 | a = (id @Int 1) 4 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/typeapps/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "-XTypeApplications" 5 | - "TypeApplications" 6 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/unusedext/UnusedExtension.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE BangPatterns #-} 2 | -------------------------------------------------------------------------------- /plugins/hls-hlint-plugin/test/testdata/unusedext/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "UnusedExtension" 5 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/CorrectName.hs: -------------------------------------------------------------------------------- 1 | module CorrectName where 2 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/Stale.hs: -------------------------------------------------------------------------------- 1 | module Foo where 2 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/TEmptyModule.expected.hs: -------------------------------------------------------------------------------- 1 | module TEmptyModule where 2 | 3 | 4 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/TEmptyModule.hs: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/TWrongModuleName.expected.hs: -------------------------------------------------------------------------------- 1 | module TWrongModuleName 2 | ( x 3 | ) 4 | where 5 | 6 | x :: Integer 7 | x = 11 8 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/TWrongModuleName.hs: -------------------------------------------------------------------------------- 1 | module BadName 2 | ( x 3 | ) 4 | where 5 | 6 | x :: Integer 7 | x = 11 8 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/cabal.project: -------------------------------------------------------------------------------- 1 | packages: ./canonicalize 2 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/canonicalize/Lib/A.expected.hs: -------------------------------------------------------------------------------- 1 | module Lib.A where 2 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/canonicalize/Lib/A.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-module-name-plugin/test/testdata/canonicalize/Lib/A.hs -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/canonicalize/canonicalize.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 2.4 2 | name: canonicalize 3 | version: 0.1.0.0 4 | 5 | library 6 | build-depends: base 7 | hs-source-dirs: ./ 8 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/mainlike.expected.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/mainlike.hs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-module-name-plugin/test/testdata/mainlike.hs -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/subdir/TWrongModuleName.expected.hs: -------------------------------------------------------------------------------- 1 | module TWrongModuleName 2 | ( x 3 | ) 4 | where 5 | 6 | x :: Integer 7 | x = 11 8 | -------------------------------------------------------------------------------- /plugins/hls-module-name-plugin/test/testdata/subdir/TWrongModuleName.hs: -------------------------------------------------------------------------------- 1 | module BadName 2 | ( x 3 | ) 4 | where 5 | 6 | x :: Integer 7 | x = 11 8 | -------------------------------------------------------------------------------- /plugins/hls-notes-plugin/test/testdata/Other.hs: -------------------------------------------------------------------------------- 1 | module Other where 2 | 3 | import NoteDef 4 | 5 | bar :: Int 6 | bar = 4 -- See @Note [Multiple notes in comment]@ in NoteDef 7 | -------------------------------------------------------------------------------- /plugins/hls-notes-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - Other 5 | - NoteDef 6 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/.ormolu: -------------------------------------------------------------------------------- 1 | infixl 7 .=? 2 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/Ormolu2.expected.hs: -------------------------------------------------------------------------------- 1 | import Data.Bool 2 | import Data.Char 3 | import Data.Data 4 | import Data.Either 5 | import Data.Int 6 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/Ormolu2.formatted.hs: -------------------------------------------------------------------------------- 1 | import Data.Bool 2 | import Data.Char 3 | import Data.Data 4 | import Data.Either 5 | import Data.Int 6 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/Ormolu2.hs: -------------------------------------------------------------------------------- 1 | import Data.Char 2 | import Data.Either 3 | import Data.Int 4 | import Data.Data 5 | import Data.Bool 6 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/Ormolu3.expected.hs: -------------------------------------------------------------------------------- 1 | foo :: String 2 | foo = 3 | "a" .=? "b" 4 | <> "c" .=? "d" 5 | <> "e" .=? "f" 6 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/Ormolu3.formatted.hs: -------------------------------------------------------------------------------- 1 | foo :: String 2 | foo = 3 | "a" .=? "b" 4 | <> "c" .=? "d" 5 | <> "e" .=? "f" 6 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/Ormolu3.hs: -------------------------------------------------------------------------------- 1 | foo :: String 2 | foo = "a" .=? "b" 3 | <> "c" .=? "d" <> "e" .=? "f" 4 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /plugins/hls-ormolu-plugin/test/testdata/test.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 3.0 2 | name: test 3 | version: 0 4 | -------------------------------------------------------------------------------- /plugins/hls-overloaded-record-dot-plugin/example.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-overloaded-record-dot-plugin/example.gif -------------------------------------------------------------------------------- /plugins/hls-overloaded-record-dot-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: []}} 2 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenLineComment.expected.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} -- line comment 2 | {-# LANGUAGE TupleSections #-} 3 | 4 | module BlockCommentThenLineComment where 5 | 6 | a = (1,) 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenLineComment.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} -- line comment 2 | 3 | module BlockCommentThenLineComment where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenLineHaddock.expected.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} 2 | {-# LANGUAGE TupleSections #-} 3 | -- | line haddock 4 | 5 | module BlockCommentThenLineHaddock where 6 | 7 | a = (1,) 8 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenLineHaddock.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} -- | line haddock 2 | 3 | module BlockCommentThenLineHaddock where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenMultiLineBlockComment.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} {- multi 2 | line 3 | block 4 | comment 5 | -} 6 | 7 | module BlockCommentThenMultiLineBlockComment where 8 | 9 | a = (1,) 10 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenSingleLineBlockComment.expected.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} {- single line block comment -} 2 | {-# LANGUAGE TupleSections #-} 3 | 4 | module BlockCommentThenSingleLineBlockComment where 5 | 6 | a = (1,) 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenSingleLineBlockComment.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} {- single line block comment -} 2 | 3 | module BlockCommentThenSingleLineBlockComment where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/BlockCommentThenSingleLineBlockHaddock.hs: -------------------------------------------------------------------------------- 1 | {- block comment -} {-| single line block haddock -} 2 | 3 | module BlockCommentThenSingleLineBlockHaddock where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/DeferredOutOfScopeVariables.expected.hs: -------------------------------------------------------------------------------- 1 | module DeferredOutOfScopeVariables where 2 | 3 | f :: () 4 | f = let x = Doesn'tExist 5 | in undefined 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/DeferredOutOfScopeVariables.hs: -------------------------------------------------------------------------------- 1 | module DeferredOutOfScopeVariables where 2 | 3 | f :: () 4 | f = let x = Doesn'tExist 5 | in undefined 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/DeferredTypeErrors.expected.hs: -------------------------------------------------------------------------------- 1 | module DeferredTypeErrors where 2 | 3 | foo :: Int 4 | foo = () 5 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/DeferredTypeErrors.hs: -------------------------------------------------------------------------------- 1 | module DeferredTypeErrors where 2 | 3 | foo :: Int 4 | foo = () 5 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/MissingSignatures.expected.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | {-# OPTIONS_GHC -Wno-missing-signatures #-} 3 | main = putStrLn "hello" 4 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/MissingSignatures.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | main = putStrLn "hello" 3 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/ModuleOnFirstLine.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TupleSections #-} 2 | module Main where 3 | 4 | tupleSection = (1,) <$> Just 2 5 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/ModuleOnFirstLine.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | tupleSection = (1,) <$> Just 2 4 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/NamedFieldPuns.hs: -------------------------------------------------------------------------------- 1 | module NamedFieldPuns where 2 | 3 | data Record = Record 4 | { a :: Int, 5 | b :: Double, 6 | c :: String 7 | } 8 | 9 | f Record{a, b} = a 10 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaFollowedBySingleLineBlockHaddock.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} {-| haddock -} 2 | 3 | module PragmaFollowedByBlockHaddock where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenLineComment.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} -- line comment 2 | {-# LANGUAGE TupleSections #-} 3 | 4 | module PragmaThenLineComment where 5 | 6 | a = (1,) 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenLineComment.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} -- line comment 2 | 3 | module PragmaThenLineComment where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenLineHaddock.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | {-# LANGUAGE TupleSections #-} 3 | -- | line haddock 4 | 5 | module PragmaThenLineHaddock where 6 | 7 | a = (1,) 8 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenLineHaddock.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} -- | line haddock 2 | 3 | module PragmaThenLineHaddock where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenLineHaddockNewlineLineComment.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} -- | line haddock 2 | -- line comment 3 | 4 | module PragmaThenLineHaddockNewlineLineComment where 5 | 6 | a = (1,) 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenMultiLineBlockComment.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} {- multi 2 | line 3 | block 4 | comment 5 | -} 6 | 7 | module PragmaThenSingleLineBlockComment where 8 | 9 | a = (1,) 10 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenMultiLineBlockHaddock.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} {-| multi 2 | line 3 | block 4 | haddock 5 | -} 6 | 7 | module PragmaThenMultiLineBlockHaddock where 8 | 9 | a = (1,) 10 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenSingleLineBlockComment.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} {- single line block comment -} 2 | {-# LANGUAGE TupleSections #-} 3 | 4 | module PragmaThenSingleLineBlockComment where 5 | 6 | a = (1,) 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenSingleLineBlockComment.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} {- single line block comment -} 2 | 3 | module PragmaThenSingleLineBlockComment where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/PragmaThenSingleLineBlockHaddock.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} {-| single line block haddock -} 2 | 3 | module PragmaThenSingleLineBlockHaddock where 4 | 5 | a = (1,) 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/TypeApplications.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ScopedTypeVariables #-} 2 | {-# LANGUAGE TypeApplications #-} 3 | module TypeApplications where 4 | 5 | foo :: forall a. a -> a 6 | foo = id @a 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/TypeApplications.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ScopedTypeVariables #-} 2 | module TypeApplications where 3 | 4 | foo :: forall a. a -> a 5 | foo = id @a 6 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/UnusedImports.expected.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | {-# OPTIONS_GHC -Wno-unused-imports #-} 3 | 4 | 5 | module M where 6 | 7 | import Data.Functor 8 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/UnusedImports.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -Wall #-} 2 | 3 | 4 | module M where 5 | 6 | import Data.Functor 7 | -------------------------------------------------------------------------------- /plugins/hls-pragmas-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "-XHaskell2010" 5 | - "NeedsPragmas" 6 | - "TypeApplications" 7 | - "NamedFieldPuns" 8 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/qualify-imported-names-demo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/plugins/hls-qualify-imported-names-plugin/qualify-imported-names-demo.gif -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/A.hs: -------------------------------------------------------------------------------- 1 | module A (module B, a, b, op) where 2 | 3 | import B 4 | 5 | a :: Int -> Int 6 | a = id 7 | 8 | b :: String -> String 9 | b = id 10 | 11 | op :: Int -> Int -> Int 12 | op = (+) 13 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/AliasedImport.expected.hs: -------------------------------------------------------------------------------- 1 | module AliasedImport where 2 | 3 | import A as B 4 | 5 | thing = B.a 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/AliasedImport.hs: -------------------------------------------------------------------------------- 1 | module AliasedImport where 2 | 3 | import A as B 4 | 5 | thing = a 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/B.hs: -------------------------------------------------------------------------------- 1 | module B where 2 | 3 | c :: Int 4 | c = 3 5 | 6 | d :: String 7 | d = "d" 8 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/Backticked.expected.hs: -------------------------------------------------------------------------------- 1 | module Backticked where 2 | 3 | import Prelude 4 | 5 | f a b = a `Prelude.elem` b 6 | 7 | g a b = 8 | let h = f a b 9 | in a `Prelude.elem` b 10 | 11 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/Backticked.hs: -------------------------------------------------------------------------------- 1 | module Backticked where 2 | 3 | import Prelude 4 | 5 | f a b = a `elem` b 6 | 7 | g a b = 8 | let h = f a b 9 | in a `elem` b 10 | 11 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/ExplicitHidingImport.expected.hs: -------------------------------------------------------------------------------- 1 | module ExplicitHidingImport where 2 | 3 | import A 4 | import A hiding (b) 5 | 6 | thing1 = A.a 7 | thing2 = b 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/ExplicitHidingImport.hs: -------------------------------------------------------------------------------- 1 | module ExplicitHidingImport where 2 | 3 | import A 4 | import A hiding (b) 5 | 6 | thing1 = a 7 | thing2 = b 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/ExplicitImport.expected.hs: -------------------------------------------------------------------------------- 1 | module ExplicitImport where 2 | 3 | import A (a) 4 | import A (b) 5 | 6 | thing1 = a 7 | thing2 = A.b 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/ExplicitImport.hs: -------------------------------------------------------------------------------- 1 | module ExplicitImport where 2 | 3 | import A (a) 4 | import A (b) 5 | 6 | thing1 = a 7 | thing2 = b 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/NoDoubleQualify.expected.hs: -------------------------------------------------------------------------------- 1 | module NoDoubleQualify where 2 | 3 | import A as AAA 4 | 5 | thing = AAA.a 6 | thing2 = (AAA.op) 7 | thing3 = 1 `AAA.op` 2 8 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/NoDoubleQualify.hs: -------------------------------------------------------------------------------- 1 | module NoDoubleQualify where 2 | 3 | import A as AAA 4 | 5 | thing = AAA.a 6 | thing2 = (AAA.op) 7 | thing3 = 1 `AAA.op` 2 8 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/NoImport.hs: -------------------------------------------------------------------------------- 1 | module NoImport where 2 | 3 | f = 3 4 | 5 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/Parenthesized.expected.hs: -------------------------------------------------------------------------------- 1 | module Parenthesized where 2 | 3 | import Prelude 4 | 5 | thing :: [Prelude.Int] -> [Prelude.Int] -> [Prelude.Int] 6 | thing = (Prelude.<>) 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/Parenthesized.hs: -------------------------------------------------------------------------------- 1 | module Parenthesized where 2 | 3 | import Prelude 4 | 5 | thing :: [Int] -> [Int] -> [Int] 6 | thing = (<>) 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/QualifiedImport.hs: -------------------------------------------------------------------------------- 1 | module QualifiedImport where 2 | 3 | import qualified A 4 | 5 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/Reexported.expected.hs: -------------------------------------------------------------------------------- 1 | module Reexported where 2 | 3 | import A 4 | 5 | thing = A.c 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/Reexported.hs: -------------------------------------------------------------------------------- 1 | module Reexported where 2 | 3 | import A 4 | 5 | thing = c 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/SameLine.expected.hs: -------------------------------------------------------------------------------- 1 | module SameLine where 2 | 3 | import A 4 | 5 | thing = ((A.a) . (A.a) . (A.a)) (1 `A.op` 2 `A.op` 3 `A.op` 4) 6 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/SameLine.hs: -------------------------------------------------------------------------------- 1 | module SameLine where 2 | 3 | import A 4 | 5 | thing = ((a) . (a) . (a)) (1 `op` 2 `op` 3 `op` 4) 6 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/UnaliasedImport.expected.hs: -------------------------------------------------------------------------------- 1 | module UnaliasedImport where 2 | 3 | import A 4 | 5 | thing = A.a 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-qualify-imported-names-plugin/test/data/UnaliasedImport.hs: -------------------------------------------------------------------------------- 1 | module UnaliasedImport where 2 | 3 | import A 4 | 5 | thing = a 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgFromLet.expected.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> _ -> Int 2 | foo True new_def = 3 | let bar = new_def 4 | in bar 5 | 6 | foo False new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgFromLet.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> Int 2 | foo True = 3 | let bar = new_def 4 | in bar 5 | 6 | foo False = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgFromWhere.expected.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> _ -> Int 2 | foo True new_def = bar 3 | where 4 | bar = new_def 5 | 6 | foo False new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgFromWhere.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> Int 2 | foo True = bar 3 | where 4 | bar = new_def 5 | 6 | foo False = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgFromWhereComments.expected.hs: -------------------------------------------------------------------------------- 1 | foo -- c1 2 | -- | c2 3 | {- c3 -} True new_def -- c4 4 | = new_def 5 | 6 | foo False new_def = False 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgFromWhereComments.hs: -------------------------------------------------------------------------------- 1 | foo -- c1 2 | -- | c2 3 | {- c3 -} True -- c4 4 | = new_def 5 | 6 | foo False = False 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithLambda.expected.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> _ -> () -> Int 2 | foo True new_def = \() -> new_def [True] 3 | 4 | foo False new_def = const 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithLambda.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> () -> Int 2 | foo True = \() -> new_def [True] 3 | 4 | foo False = const 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithSig.expected.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> _ -> Int 2 | foo True new_def = new_def [True] 3 | 4 | foo False new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithSig.hs: -------------------------------------------------------------------------------- 1 | foo :: Bool -> Int 2 | foo True = new_def [True] 3 | 4 | foo False = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithSigAndDocs.hs: -------------------------------------------------------------------------------- 1 | foo :: 2 | -- c1 3 | Bool -- c2 4 | -- c3 5 | -> -- c4 6 | -- | c5 7 | () -- c6 8 | -> Int 9 | foo True () = new_def [True] 10 | 11 | foo False () = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithTypeSynSig.expected.hs: -------------------------------------------------------------------------------- 1 | type FunctionTySyn = Bool -> Int 2 | foo :: FunctionTySyn 3 | foo True new_def = new_def [True] 4 | 5 | foo False new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithTypeSynSig.hs: -------------------------------------------------------------------------------- 1 | type FunctionTySyn = Bool -> Int 2 | foo :: FunctionTySyn 3 | foo True = new_def [True] 4 | 5 | foo False = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithTypeSynSigContravariant.expected.hs: -------------------------------------------------------------------------------- 1 | type FunctionTySyn = Bool -> Int 2 | foo :: FunctionTySyn -> () -> _ -> Int 3 | foo True () new_def = new_def [True] 4 | 5 | foo False () new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/AddArgWithTypeSynSigContravariant.hs: -------------------------------------------------------------------------------- 1 | type FunctionTySyn = Bool -> Int 2 | foo :: FunctionTySyn -> () -> Int 3 | foo True () = new_def [True] 4 | 5 | foo False () = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/Hole.expected.hs: -------------------------------------------------------------------------------- 1 | foo _new_def = _new_def -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/Hole.hs: -------------------------------------------------------------------------------- 1 | foo = _new_def -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultiSigFirst.expected.hs: -------------------------------------------------------------------------------- 1 | bar :: Bool -> Int 2 | foo :: Bool -> _ -> Int 3 | bar = const 1 4 | foo True new_def = new_def [True] 5 | 6 | foo False new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultiSigFirst.hs: -------------------------------------------------------------------------------- 1 | foo, bar :: Bool -> Int 2 | bar = const 1 3 | foo True = new_def [True] 4 | 5 | foo False = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultiSigLast.expected.hs: -------------------------------------------------------------------------------- 1 | baz, bar :: Bool -> Int 2 | foo :: Bool -> _ -> Int 3 | bar = const 1 4 | foo True new_def = new_def [True] 5 | 6 | foo False new_def = 1 7 | baz = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultiSigLast.hs: -------------------------------------------------------------------------------- 1 | baz, bar, foo :: Bool -> Int 2 | bar = const 1 3 | foo True = new_def [True] 4 | 5 | foo False = 1 6 | baz = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultiSigMiddle.expected.hs: -------------------------------------------------------------------------------- 1 | baz, bar :: Bool -> Int 2 | foo :: Bool -> _ -> Int 3 | bar = const 1 4 | foo True new_def = new_def [True] 5 | 6 | foo False new_def = 1 7 | baz = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultiSigMiddle.hs: -------------------------------------------------------------------------------- 1 | baz, foo, bar :: Bool -> Int 2 | bar = const 1 3 | foo True = new_def [True] 4 | 5 | foo False = 1 6 | baz = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultipleDeclAlts.expected.hs: -------------------------------------------------------------------------------- 1 | foo True new_def = new_def 2 | foo False new_def = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/MultipleDeclAlts.hs: -------------------------------------------------------------------------------- 1 | foo True = new_def 2 | foo False = 1 -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/NoTypeSuggestion.expected.hs: -------------------------------------------------------------------------------- 1 | foo new_def = new_def -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/golden/add-arg/NoTypeSuggestion.hs: -------------------------------------------------------------------------------- 1 | foo = new_def -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HidePreludeIndented.expected.hs: -------------------------------------------------------------------------------- 1 | module HidePreludeIndented where 2 | 3 | import AVec 4 | import Prelude hiding ((++)) 5 | op = (++) 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HidePreludeIndented.hs: -------------------------------------------------------------------------------- 1 | module HidePreludeIndented where 2 | 3 | import AVec 4 | op = (++) 5 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HidePreludeLocalInfix.hs: -------------------------------------------------------------------------------- 1 | module HidePreludeLocalInfix where 2 | 3 | infixed xs ys = xs ++ ys 4 | 5 | data Vec a 6 | 7 | (++) :: Vec a -> Vec a -> Vec a 8 | (++) = undefined 9 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifyDuplicateRecordFields.hs: -------------------------------------------------------------------------------- 1 | module HideQualifyDuplicateRecordFields where 2 | 3 | import AVec 4 | import BVec 5 | import CVec 6 | import DVec 7 | import EVec 8 | import FVec 9 | 10 | theFun = fromList -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifyDuplicateRecordFieldsSelf.hs: -------------------------------------------------------------------------------- 1 | module HideQualifyDuplicateRecordFieldsSelf where 2 | 3 | import FVec 4 | 5 | x = fromList -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifyInfix.expected.hs: -------------------------------------------------------------------------------- 1 | module HideQualifyInfix where 2 | 3 | import AVec 4 | 5 | infixed xs ys = xs Prelude.++ ys 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifyInfix.hs: -------------------------------------------------------------------------------- 1 | module HideQualifyInfix where 2 | 3 | import AVec 4 | 5 | infixed xs ys = xs ++ ys 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifySectionLeft.expected.hs: -------------------------------------------------------------------------------- 1 | module HideQualifySectionLeft where 2 | 3 | import AVec 4 | 5 | sectLeft xs = (Prelude.++ xs) 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifySectionLeft.hs: -------------------------------------------------------------------------------- 1 | module HideQualifySectionLeft where 2 | 3 | import AVec 4 | 5 | sectLeft xs = (++ xs) 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifySectionRight.expected.hs: -------------------------------------------------------------------------------- 1 | module HideQualifySectionRight where 2 | 3 | import AVec 4 | 5 | sectLeft xs = (xs Prelude.++) 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hiding/HideQualifySectionRight.hs: -------------------------------------------------------------------------------- 1 | module HideQualifySectionRight where 2 | 3 | import AVec 4 | 5 | sectLeft xs = (xs ++) 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hover/Bar.hs: -------------------------------------------------------------------------------- 1 | module Bar (Bar(..)) where 2 | 3 | -- | Bar Haddock 4 | data Bar = Bar 5 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hover/Foo.hs: -------------------------------------------------------------------------------- 1 | module Foo (Bar, foo) where 2 | 3 | import Bar 4 | 5 | -- | foo Haddock 6 | foo = Bar 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/hover/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: {direct: {arguments: ["Foo", "Bar", "GotoHover", "RecordDotSyntax"]}} 2 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/CommentAtTop.expected.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | import Data.Monoid 5 | 6 | -- | Some comment 7 | class Semigroup a => SomeData a 8 | 9 | instance SomeData All 10 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/CommentAtTop.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | 5 | -- | Some comment 6 | class Semigroup a => SomeData a 7 | 8 | instance SomeData All 9 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/CommentCurlyBraceAtTop.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | 5 | {- Some comment -} 6 | class Semigroup a => SomeData a 7 | 8 | instance SomeData All 9 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/DataAtTop.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | 5 | data Something = Something 6 | 7 | -- | some comment 8 | class Semigroup a => SomeData a 9 | 10 | instance SomeData All 11 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/ImportPostQualified.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ImportQualifiedPost #-} 2 | {-# OPTIONS_GHC -Wprepositive-qualified-module #-} 3 | main :: IO () 4 | main = Control.when True $ putStrLn "hello" 5 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/ImportQualified.expected.hs: -------------------------------------------------------------------------------- 1 | import qualified Control.Monad as Control 2 | main :: IO () 3 | main = Control.when True $ putStrLn "hello" 4 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/ImportQualified.hs: -------------------------------------------------------------------------------- 1 | main :: IO () 2 | main = Control.when True $ putStrLn "hello" 3 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LangPragmaModuleAtTop.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | 3 | module Test where 4 | import Data.Monoid 5 | 6 | class Semigroup a => SomeData a 7 | 8 | instance SomeData All 9 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LangPragmaModuleAtTop.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | 3 | module Test where 4 | 5 | class Semigroup a => SomeData a 6 | 7 | instance SomeData All 8 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LangPragmaModuleExplicitExports.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | 3 | module Test 4 | ( SomeData(..) 5 | ) where 6 | 7 | class Semigroup a => SomeData a 8 | 9 | instance SomeData All 10 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LanguagePragmaAtTop.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | import Data.Monoid 3 | 4 | class Semigroup a => SomeData a 5 | 6 | instance SomeData All 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LanguagePragmaAtTop.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | 3 | class Semigroup a => SomeData a 4 | 5 | instance SomeData All 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LanguagePragmaAtTopWithComment.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | import Data.Monoid 3 | 4 | -- | comment 5 | class Semigroup a => SomeData a 6 | 7 | instance SomeData All 8 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/LanguagePragmaAtTopWithComment.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | 3 | -- | comment 4 | class Semigroup a => SomeData a 5 | 6 | instance SomeData All 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/ModuleDeclAndImports.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | import Data.Char 5 | import Data.Array 6 | 7 | class Semigroup a => SomeData a 8 | 9 | instance SomeData All 10 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/MultiLineCommentAtTop.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | 5 | {- Some multi 6 | line comment 7 | -} 8 | class Semigroup a => SomeData a 9 | 10 | instance SomeData All 11 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoExplicitExportCommentAtTop.expected.hs: -------------------------------------------------------------------------------- 1 | module Test where 2 | import Data.Monoid 3 | 4 | -- | a comment 5 | class Semigroup a => SomeData a 6 | 7 | instance SomeData All 8 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoExplicitExportCommentAtTop.hs: -------------------------------------------------------------------------------- 1 | module Test where 2 | 3 | -- | a comment 4 | class Semigroup a => SomeData a 5 | 6 | instance SomeData All 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoExplicitExports.expected.hs: -------------------------------------------------------------------------------- 1 | module Test where 2 | import Data.Monoid 3 | 4 | newtype Something = S { foo :: Int } 5 | 6 | class Semigroup a => SomeData a 7 | 8 | instance SomeData All 9 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoExplicitExports.hs: -------------------------------------------------------------------------------- 1 | module Test where 2 | 3 | newtype Something = S { foo :: Int } 4 | 5 | class Semigroup a => SomeData a 6 | 7 | instance SomeData All 8 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoModuleDeclaration.expected.hs: -------------------------------------------------------------------------------- 1 | import Data.Monoid 2 | newtype Something = S { foo :: Int } 3 | 4 | -- | a comment 5 | class Semigroup a => SomeData a 6 | 7 | instance SomeData All 8 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoModuleDeclaration.hs: -------------------------------------------------------------------------------- 1 | newtype Something = S { foo :: Int } 2 | 3 | -- | a comment 4 | class Semigroup a => SomeData a 5 | 6 | instance SomeData All 7 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoModuleDeclarationCommentAtTop.expected.hs: -------------------------------------------------------------------------------- 1 | import Data.Monoid 2 | -- a comment 3 | class Semigroup a => SomeData a 4 | 5 | instance SomeData All 6 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/NoModuleDeclarationCommentAtTop.hs: -------------------------------------------------------------------------------- 1 | -- a comment 2 | class Semigroup a => SomeData a 3 | 4 | instance SomeData All 5 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/OptionsPragmaNotAtTop.hs: -------------------------------------------------------------------------------- 1 | class Semigroup a => SomeData a 2 | instance SomeData All 3 | 4 | {-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} 5 | 6 | addOne :: Int -> Int 7 | addOne x = x + 1 8 | -------------------------------------------------------------------------------- /plugins/hls-refactor-plugin/test/data/import-placement/TwoDashOnlyComment.hs: -------------------------------------------------------------------------------- 1 | module Test 2 | ( SomeData(..) 3 | ) where 4 | 5 | -- no vertical bar comment 6 | class Semigroup a => SomeData a 7 | 8 | instance SomeData All 9 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/Comment.expected.hs: -------------------------------------------------------------------------------- 1 | {- IShouldNotBeRenaemable -} 2 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/Comment.hs: -------------------------------------------------------------------------------- 1 | {- IShouldNotBeRenaemable -} 2 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/DataConstructor.expected.hs: -------------------------------------------------------------------------------- 1 | data Expr = Op Int Int 2 | 3 | plus :: Expr -> Expr 4 | plus (Op n m) = Op (n + m) 0 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/DataConstructor.hs: -------------------------------------------------------------------------------- 1 | data Expr = Apply Int Int 2 | 3 | plus :: Expr -> Expr 4 | plus (Apply n m) = Apply (n + m) 0 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ExportedFunction.expected.hs: -------------------------------------------------------------------------------- 1 | module ExportedFunction (quux) where 2 | 3 | quux :: Num p => [a] -> p 4 | quux [] = 0 5 | quux xs = 1 6 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ExportedFunction.hs: -------------------------------------------------------------------------------- 1 | module ExportedFunction (foo) where 2 | 3 | foo :: Num p => [a] -> p 4 | foo [] = 0 5 | foo xs = 1 6 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/FieldPuns.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NamedFieldPuns #-} 2 | 3 | module FieldPun () where 4 | 5 | newtype Foo = Foo { bleh :: Int } 6 | 7 | unFoo :: Foo -> Int 8 | unFoo Foo{bleh} = bleh 9 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/FieldPuns.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NamedFieldPuns #-} 2 | 3 | module FieldPun () where 4 | 5 | newtype Foo = Foo { field :: Int } 6 | 7 | unFoo :: Foo -> Int 8 | unFoo Foo{field} = field 9 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/Foo.hs: -------------------------------------------------------------------------------- 1 | module Foo where 2 | 3 | foo :: Int -> Int 4 | foo x = 0 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/FunctionArgument.expected.hs: -------------------------------------------------------------------------------- 1 | module FunctionArgument () where 2 | 3 | foo :: Int -> Int 4 | foo y = y + 1 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/FunctionArgument.hs: -------------------------------------------------------------------------------- 1 | module FunctionArgument () where 2 | 3 | foo :: Int -> Int 4 | foo x = x + 1 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/FunctionName.expected.hs: -------------------------------------------------------------------------------- 1 | main = do 2 | x <- return $ baz 42 3 | return (baz x) 4 | baz, bar :: Int -> Int 5 | baz x = x + 1 6 | bar = (+ 1) . baz 7 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/FunctionName.hs: -------------------------------------------------------------------------------- 1 | main = do 2 | x <- return $ foo 42 3 | return (foo x) 4 | foo, bar :: Int -> Int 5 | foo x = x + 1 6 | bar = (+ 1) . foo 7 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/HiddenFunction.expected.hs: -------------------------------------------------------------------------------- 1 | import Foo hiding (quux) 2 | 3 | foo :: Int -> Int 4 | foo x = 0 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/HiddenFunction.hs: -------------------------------------------------------------------------------- 1 | import Foo hiding (foo) 2 | 3 | foo :: Int -> Int 4 | foo x = 0 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ImportHiding.expected.hs: -------------------------------------------------------------------------------- 1 | import Foo hiding (hiddenFoo) 2 | 3 | foo :: Int -> Int 4 | foo _ = 5 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ImportHiding.hs: -------------------------------------------------------------------------------- 1 | import Foo hiding (foo) 2 | 3 | foo :: Int -> Int 4 | foo _ = 5 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ImportedFunction.expected.hs: -------------------------------------------------------------------------------- 1 | import Foo (baz) 2 | 3 | bar :: Int -> Int 4 | bar = baz 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ImportedFunction.hs: -------------------------------------------------------------------------------- 1 | import Foo (foo) 2 | 3 | bar :: Int -> Int 4 | bar = foo 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/IndirectPuns.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NamedFieldPuns #-} 2 | 3 | module IndirectPuns () where 4 | 5 | newtype Foo = Foo { blah :: Int } 6 | 7 | unFoo :: Foo -> Int 8 | unFoo Foo{blah} = blah 9 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/IndirectPuns.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NamedFieldPuns #-} 2 | 3 | module IndirectPuns () where 4 | 5 | newtype Foo = Foo { field :: Int } 6 | 7 | unFoo :: Foo -> Int 8 | unFoo Foo{field} = field 9 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/LetExpression.expected.hs: -------------------------------------------------------------------------------- 1 | module Let () where 2 | 3 | import Foo 4 | 5 | bar :: Int 6 | bar = let foobar = 5 in 7 | foobar * foobar 8 | 9 | quux :: Int 10 | quux = Foo.foo 4 11 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/LetExpression.hs: -------------------------------------------------------------------------------- 1 | module Let () where 2 | 3 | import Foo 4 | 5 | bar :: Int 6 | bar = let foo = 5 in 7 | foo * foo 8 | 9 | quux :: Int 10 | quux = Foo.foo 4 11 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/QualifiedAs.expected.hs: -------------------------------------------------------------------------------- 1 | import qualified Foo as F 2 | 3 | bar :: Int -> Int 4 | bar = F.baz 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/QualifiedAs.hs: -------------------------------------------------------------------------------- 1 | import qualified Foo as F 2 | 3 | bar :: Int -> Int 4 | bar = F.foo 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/QualifiedFunction.expected.hs: -------------------------------------------------------------------------------- 1 | import qualified Foo 2 | 3 | bar :: Int -> Int 4 | bar = Foo.baz 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/QualifiedFunction.hs: -------------------------------------------------------------------------------- 1 | import qualified Foo 2 | 3 | bar :: Int -> Int 4 | bar = Foo.foo 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/QualifiedShadowing.expected.hs: -------------------------------------------------------------------------------- 1 | import qualified Foo as F 2 | 3 | bar :: Int -> Int 4 | bar x = F.foobar x + foo x 5 | 6 | foo :: Int -> Int 7 | foo _ = 5 8 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/QualifiedShadowing.hs: -------------------------------------------------------------------------------- 1 | import qualified Foo as F 2 | 3 | bar :: Int -> Int 4 | bar x = F.foo x + foo x 5 | 6 | foo :: Int -> Int 7 | foo _ = 5 8 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/RealignDo.expected.hs: -------------------------------------------------------------------------------- 1 | fooBarQuux :: Maybe Integer 2 | fooBarQuux = do x <- Just 5 3 | t <- Just 10 4 | pure $ x + t 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/RealignDo.hs: -------------------------------------------------------------------------------- 1 | foo :: Maybe Integer 2 | foo = do x <- Just 5 3 | t <- Just 10 4 | pure $ x + t 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/RecordField.expected.hs: -------------------------------------------------------------------------------- 1 | data Bam = Bam { 2 | number :: Int, 3 | s :: String 4 | } 5 | 6 | foo :: Bam -> Bam 7 | foo Bam {number = y} = Bam {number = y + 5, s = ""} 8 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/RecordField.hs: -------------------------------------------------------------------------------- 1 | data Bam = Bam { 2 | n :: Int, 3 | s :: String 4 | } 5 | 6 | foo :: Bam -> Bam 7 | foo Bam {n = y} = Bam {n = y + 5, s = ""} 8 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ShadowedName.expected.hs: -------------------------------------------------------------------------------- 1 | baz :: Int -> Int 2 | baz x = foo + 10 3 | where 4 | foo = 20 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/ShadowedName.hs: -------------------------------------------------------------------------------- 1 | foo :: Int -> Int 2 | foo x = foo + 10 3 | where 4 | foo = 20 5 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/TypeVariable.expected.hs: -------------------------------------------------------------------------------- 1 | bar :: Maybe b -> Maybe b 2 | bar a = a 3 | -------------------------------------------------------------------------------- /plugins/hls-rename-plugin/test/testdata/TypeVariable.hs: -------------------------------------------------------------------------------- 1 | bar :: Maybe a -> Maybe a 2 | bar a = a 3 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Class.hs: -------------------------------------------------------------------------------- 1 | module Class where 2 | 3 | class Identity x where 4 | identity :: x -> x 5 | identity x = x 6 | 7 | function x = identity x 8 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Identity.expected.hs: -------------------------------------------------------------------------------- 1 | module Identity where 2 | 3 | identity x = x 4 | 5 | function x = x 6 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Identity.hs: -------------------------------------------------------------------------------- 1 | module Identity where 2 | 3 | identity x = x 4 | 5 | function x = identity x 6 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Imported.expected.hs: -------------------------------------------------------------------------------- 1 | module Imported where 2 | 3 | import Identity 4 | 5 | f x = x 6 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Imported.hs: -------------------------------------------------------------------------------- 1 | module Imported where 2 | 3 | import Identity 4 | 5 | f x = identity x 6 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Nested.expected.hs: -------------------------------------------------------------------------------- 1 | module Nested where 2 | 3 | 4 | 5 | function x = x 6 | where 7 | identity x = x 8 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/NestedLet.expected.hs: -------------------------------------------------------------------------------- 1 | module NestedLet where 2 | 3 | 4 | 5 | function x = 6 | let identity x = x 7 | in x 8 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/NestedLet.hs: -------------------------------------------------------------------------------- 1 | module NestedLet where 2 | 3 | 4 | 5 | function x = 6 | let identity x = x 7 | in identity x 8 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/NestedNested.hs: -------------------------------------------------------------------------------- 1 | 2 | module NestedNested where 3 | 4 | 5 | 6 | function x = meme x 7 | where 8 | meme x = identity x 9 | identity x = x 10 | 11 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/NestedWhere.expected.hs: -------------------------------------------------------------------------------- 1 | module NestedWhere where 2 | 3 | 4 | 5 | function x = x 6 | where 7 | identity x = x 8 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/NestedWhere.hs: -------------------------------------------------------------------------------- 1 | module NestedWhere where 2 | 3 | 4 | 5 | function x = identity x 6 | where 7 | identity x = x 8 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Operator.expected.hs: -------------------------------------------------------------------------------- 1 | module Operator where 2 | 3 | x */ y = x 4 | 5 | function x = x 6 | -------------------------------------------------------------------------------- /plugins/hls-retrie-plugin/test/testdata/Operator.hs: -------------------------------------------------------------------------------- 1 | module Operator where 2 | 3 | x */ y = x 4 | 5 | function x = x */ () 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TClass.expected: -------------------------------------------------------------------------------- 1 | 1:8-14 TModule "TClass" 2 | 4:7-10 TClass "Foo" 3 | 4:11-12 TTypeVariable "a" 4 | 5:3-6 TClassMethod "foo" 5 | 5:10-11 TTypeVariable "a" 6 | 5:15-18 TTypeConstructor "Int" 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TClass.hs: -------------------------------------------------------------------------------- 1 | module TClass where 2 | 3 | 4 | class Foo a where 5 | foo :: a -> Int 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TClassImportedDeriving.expected: -------------------------------------------------------------------------------- 1 | 2:8-30 TModule "TClassImportedDeriving" 2 | 4:6-9 TTypeConstructor "Foo" 3 | 4:12-15 TDataConstructor "Foo" 4 | 4:26-30 TClass "Show" 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TDataType.expected: -------------------------------------------------------------------------------- 1 | 1:8-17 TModule "TDataType" 2 | 3:6-9 TTypeConstructor "Foo" 3 | 3:12-15 TDataConstructor "Foo" 4 | 3:16-19 TTypeConstructor "Int" 5 | 3:30-32 TClass "Eq" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TDataType.hs: -------------------------------------------------------------------------------- 1 | module TDataType where 2 | 3 | data Foo = Foo Int deriving (Eq) 4 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TDatatypeImported.hs: -------------------------------------------------------------------------------- 1 | module TDatatypeImported where 2 | 3 | import System.IO 4 | 5 | go :: IO () 6 | go = print 1 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TDoc.expected: -------------------------------------------------------------------------------- 1 | 1:8-12 TModule "TDoc" 2 | 4:5-10 TVariable "hello" 3 | 5:1-6 TVariable "hello" 4 | 5:10-13 TTypeConstructor "Int" 5 | 6:1-6 TVariable "hello" 6 | 6:9-15 TClassMethod "length" 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TDoc.hs: -------------------------------------------------------------------------------- 1 | module TDoc where 2 | 3 | -- | 4 | -- `hello` 5 | hello :: Int 6 | hello = length "Hello, Haskell!" 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TFunction.hs: -------------------------------------------------------------------------------- 1 | module TFunction where 2 | 3 | f :: forall a. a -> a 4 | f x = x 5 | 6 | x :: a 7 | x = undefined 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TFunctionLet.expected: -------------------------------------------------------------------------------- 1 | 1:8-20 TModule "TFunctionLet" 2 | 3:1-2 TVariable "y" 3 | 3:6-9 TTypeConstructor "Int" 4 | 4:1-2 TVariable "y" 5 | 4:9-10 TFunction "f" 6 | 4:11-12 TVariable "x" 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TFunctionLet.hs: -------------------------------------------------------------------------------- 1 | module TFunctionLet where 2 | 3 | y :: Int 4 | y = let f x = 1 in 1 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TFunctionLocal.hs: -------------------------------------------------------------------------------- 1 | module TFunctionLocal where 2 | 3 | f :: Int -> Int 4 | f 1 = g 1 5 | where 6 | g x = 1 7 | 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TInstanceClassMethodBind.hs: -------------------------------------------------------------------------------- 1 | module TInstanceClassMethodBind where 2 | 3 | 4 | data Foo = Foo Int 5 | instance Show Foo where 6 | show = undefined 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TInstanceClassMethodUse.expected: -------------------------------------------------------------------------------- 1 | 1:8-31 TModule "TInstanceClassMethodUse" 2 | 4:1-3 TFunction "go" 3 | 4:8-12 TClassMethod "show" 4 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TInstanceClassMethodUse.hs: -------------------------------------------------------------------------------- 1 | module TInstanceClassMethodUse where 2 | 3 | 4 | go = show 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TModuleA.hs: -------------------------------------------------------------------------------- 1 | module TModuleA where 2 | 3 | data Game = Game {a𐐀b :: Int} 4 | 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TModuleB.hs: -------------------------------------------------------------------------------- 1 | module TModuleB where 2 | 3 | import TModuleA 4 | import qualified TModuleA 5 | 6 | go = Game 1 7 | 8 | a𐐀bb = TModuleA.a𐐀b go 9 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TNoneFunctionWithConstraint.hs: -------------------------------------------------------------------------------- 1 | module TNoneFunctionWithConstraint where 2 | 3 | x :: (Eq a) => a 4 | x = undefined 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TPatternMatch.expected: -------------------------------------------------------------------------------- 1 | 1:8-21 TModule "TPatternMatch" 2 | 4:1-2 TFunction "g" 3 | 4:4-11 TDataConstructor "Nothing" 4 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TPatternMatch.hs: -------------------------------------------------------------------------------- 1 | module TPatternMatch where 2 | 3 | 4 | g (Nothing, _) = 1 5 | 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TPatternSynonym.expected: -------------------------------------------------------------------------------- 1 | 2:8-23 TModule "TPatternSynonym" 2 | 5:9-12 TPatternSynonym "Foo" 3 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TPatternSynonym.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE PatternSynonyms #-} 2 | module TPatternSynonym where 3 | 4 | 5 | pattern Foo = 1 6 | 7 | 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TPatternbind.hs: -------------------------------------------------------------------------------- 1 | module TVariable where 2 | 3 | (a, b) = (1, 2) 4 | 5 | f g y = g y 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TRecord.expected: -------------------------------------------------------------------------------- 1 | 1:8-15 TModule "TRecord" 2 | 4:6-9 TTypeConstructor "Foo" 3 | 4:12-15 TDataConstructor "Foo" 4 | 4:18-21 TRecordField "foo" 5 | 4:25-28 TTypeConstructor "Int" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TRecord.hs: -------------------------------------------------------------------------------- 1 | module TRecord where 2 | 3 | 4 | data Foo = Foo { foo :: Int } 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TRecordDuplicateRecordFields.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DuplicateRecordFields #-} 2 | 3 | module TRecordDuplicateRecordFields where 4 | 5 | data Foo = Foo { boo :: !String } 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TTypefamily.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeFamilies #-} 2 | module TTypefamily where 3 | 4 | type family Foo a where 5 | Foo Int = Int 6 | Foo a = String 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TUnicodeSyntax.expected: -------------------------------------------------------------------------------- 1 | 1:8-22 TModule "TUnicodeSyntax" 2 | 3:1-4 TVariable "a\66560b" 3 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TUnicodeSyntax.hs: -------------------------------------------------------------------------------- 1 | module TUnicodeSyntax where 2 | 3 | a𐐀b = "a𐐀b" 4 | 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TValBind.expected: -------------------------------------------------------------------------------- 1 | 1:8-16 TModule "TValBind" 2 | 4:1-6 TVariable "hello" 3 | 4:10-13 TTypeConstructor "Int" 4 | 5:1-6 TVariable "hello" 5 | 5:9-15 TClassMethod "length" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/after_9_10/TValBind.hs: -------------------------------------------------------------------------------- 1 | module TValBind where 2 | 3 | 4 | hello :: Int 5 | hello = length "Hello, Haskell!" 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TClass.expected: -------------------------------------------------------------------------------- 1 | 4:7-10 TClass "Foo" 2 | 4:11-12 TTypeVariable "a" 3 | 5:3-6 TClassMethod "foo" 4 | 5:10-11 TTypeVariable "a" 5 | 5:15-18 TTypeConstructor "Int" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TClass.hs: -------------------------------------------------------------------------------- 1 | module TClass where 2 | 3 | 4 | class Foo a where 5 | foo :: a -> Int 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TClassImportedDeriving.expected: -------------------------------------------------------------------------------- 1 | 4:6-9 TTypeConstructor "Foo" 2 | 4:12-15 TDataConstructor "Foo" 3 | 4:26-30 TClass "Show" 4 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TDataType.expected: -------------------------------------------------------------------------------- 1 | 3:6-9 TTypeConstructor "Foo" 2 | 3:12-15 TDataConstructor "Foo" 3 | 3:16-19 TTypeConstructor "Int" 4 | 3:30-32 TClass "Eq" 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TDataType.hs: -------------------------------------------------------------------------------- 1 | module TDataType where 2 | 3 | data Foo = Foo Int deriving (Eq) 4 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TDatatypeImported.expected: -------------------------------------------------------------------------------- 1 | 3:8-17 TModule "System.IO" 2 | 5:1-3 TVariable "go" 3 | 5:7-9 TTypeConstructor "IO" 4 | 6:1-3 TVariable "go" 5 | 6:6-11 TFunction "print" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TDatatypeImported.hs: -------------------------------------------------------------------------------- 1 | module TDatatypeImported where 2 | 3 | import System.IO 4 | 5 | go :: IO () 6 | go = print 1 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TDoc.expected: -------------------------------------------------------------------------------- 1 | 4:5-10 TVariable "hello" 2 | 5:1-6 TVariable "hello" 3 | 5:10-13 TTypeConstructor "Int" 4 | 6:1-6 TVariable "hello" 5 | 6:9-15 TClassMethod "length" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TDoc.hs: -------------------------------------------------------------------------------- 1 | module TDoc where 2 | 3 | -- | 4 | -- `hello` 5 | hello :: Int 6 | hello = length "Hello, Haskell!" 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TFunction.hs: -------------------------------------------------------------------------------- 1 | module TFunction where 2 | 3 | f :: forall a. a -> a 4 | f x = x 5 | 6 | x :: a 7 | x = undefined 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TFunctionLet.expected: -------------------------------------------------------------------------------- 1 | 3:1-2 TVariable "y" 2 | 3:6-9 TTypeConstructor "Int" 3 | 4:1-2 TVariable "y" 4 | 4:9-10 TFunction "f" 5 | 4:11-12 TVariable "x" 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TFunctionLet.hs: -------------------------------------------------------------------------------- 1 | module TFunctionLet where 2 | 3 | y :: Int 4 | y = let f x = 1 in 1 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TFunctionLocal.hs: -------------------------------------------------------------------------------- 1 | module TFunctionLocal where 2 | 3 | f :: Int -> Int 4 | f 1 = g 1 5 | where 6 | g x = 1 7 | 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TInstanceClassMethodBind.hs: -------------------------------------------------------------------------------- 1 | module TInstanceClassMethodBind where 2 | 3 | 4 | data Foo = Foo Int 5 | instance Show Foo where 6 | show = undefined 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TInstanceClassMethodUse.expected: -------------------------------------------------------------------------------- 1 | 4:1-3 TFunction "go" 2 | 4:8-12 TClassMethod "show" 3 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TInstanceClassMethodUse.hs: -------------------------------------------------------------------------------- 1 | module TInstanceClassMethodUse where 2 | 3 | 4 | go = show 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TModuleA.hs: -------------------------------------------------------------------------------- 1 | module TModuleA where 2 | 3 | data Game = Game {a𐐀b :: Int} 4 | 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TModuleB.hs: -------------------------------------------------------------------------------- 1 | module TModuleB where 2 | 3 | import TModuleA 4 | import qualified TModuleA 5 | 6 | go = Game 1 7 | 8 | a𐐀bb = TModuleA.a𐐀b go 9 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TNoneFunctionWithConstraint.hs: -------------------------------------------------------------------------------- 1 | module TNoneFunctionWithConstraint where 2 | 3 | x :: (Eq a) => a 4 | x = undefined 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TPatternMatch.expected: -------------------------------------------------------------------------------- 1 | 4:1-2 TFunction "g" 2 | 4:4-11 TDataConstructor "Nothing" 3 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TPatternMatch.hs: -------------------------------------------------------------------------------- 1 | module TPatternMatch where 2 | 3 | 4 | g (Nothing, _) = 1 5 | 6 | 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TPatternSynonym.expected: -------------------------------------------------------------------------------- 1 | 5:9-12 TPatternSynonym "Foo" 2 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TPatternSynonym.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE PatternSynonyms #-} 2 | module TPatternSynonym where 3 | 4 | 5 | pattern Foo = 1 6 | 7 | 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TPatternbind.expected: -------------------------------------------------------------------------------- 1 | 3:2-3 TVariable "a" 2 | 3:5-6 TVariable "b" 3 | 5:1-2 TFunction "f" 4 | 5:3-4 TFunction "g" 5 | 5:5-6 TVariable "y" 6 | 5:9-10 TFunction "g" 7 | 5:11-12 TVariable "y" 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TPatternbind.hs: -------------------------------------------------------------------------------- 1 | module TVariable where 2 | 3 | (a, b) = (1, 2) 4 | 5 | f g y = g y 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TRecord.expected: -------------------------------------------------------------------------------- 1 | 4:6-9 TTypeConstructor "Foo" 2 | 4:12-15 TDataConstructor "Foo" 3 | 4:18-21 TRecordField "foo" 4 | 4:25-28 TTypeConstructor "Int" 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TRecord.hs: -------------------------------------------------------------------------------- 1 | module TRecord where 2 | 3 | 4 | data Foo = Foo { foo :: Int } 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TRecordDuplicateRecordFields.expected: -------------------------------------------------------------------------------- 1 | 5:6-9 TTypeConstructor "Foo" 2 | 5:12-15 TDataConstructor "Foo" 3 | 5:18-21 TRecordField "boo" 4 | 5:26-32 TTypeSynonym "String" 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TRecordDuplicateRecordFields.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DuplicateRecordFields #-} 2 | 3 | module TRecordDuplicateRecordFields where 4 | 5 | data Foo = Foo { boo :: !String } 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TTypefamily.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeFamilies #-} 2 | module TTypefamily where 3 | 4 | type family Foo a where 5 | Foo Int = Int 6 | Foo a = String 7 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TUnicodeSyntax.expected: -------------------------------------------------------------------------------- 1 | 3:1-4 TVariable "a\66560b" 2 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TUnicodeSyntax.hs: -------------------------------------------------------------------------------- 1 | module TUnicodeSyntax where 2 | 3 | a𐐀b = "a𐐀b" 4 | 5 | 6 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TValBind.expected: -------------------------------------------------------------------------------- 1 | 4:1-6 TVariable "hello" 2 | 4:10-13 TTypeConstructor "Int" 3 | 5:1-6 TVariable "hello" 4 | 5:9-15 TClassMethod "length" 5 | -------------------------------------------------------------------------------- /plugins/hls-semantic-tokens-plugin/test/testdata/before_9_10/TValBind.hs: -------------------------------------------------------------------------------- 1 | module TValBind where 2 | 3 | 4 | hello :: Int 5 | hello = length "Hello, Haskell!" 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TErrorExp.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TErrorExp where 3 | import Language.Haskell.TH ( tupE, litE, integerL ) 4 | 5 | main :: IO () 6 | main = return (42, ()) 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TErrorExp.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TErrorExp where 3 | import Language.Haskell.TH ( tupE, litE, integerL ) 4 | 5 | main :: IO () 6 | main = return $(tupE [litE $ integerL 42, tupE []]) 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TErrorPat.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TErrorPat where 3 | import Language.Haskell.TH ( conP ) 4 | 5 | f :: () -> () 6 | f True = x 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TErrorPat.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TErrorPat where 3 | import Language.Haskell.TH ( conP ) 4 | 5 | f :: () -> () 6 | f $(conP 'True []) = x 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQDecl.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQDecl where 3 | import QQ (str) 4 | 5 | foo :: String 6 | foo = "foo" 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQDecl.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQDecl where 3 | import QQ (str) 4 | 5 | [str|foo|] 6 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQExp.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQExp where 3 | import QQ 4 | 5 | main :: IO () 6 | main = putStrLn "str" 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQExp.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQExp where 3 | import QQ 4 | 5 | main :: IO () 6 | main = putStrLn [str|str|] 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQExpError.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQExpError where 3 | import QQ 4 | 5 | main :: IO () 6 | main = pure "str" 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQExpError.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQExpError where 3 | import QQ 4 | 5 | main :: IO () 6 | main = pure [str|str|] 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQPat.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQPat where 3 | import QQ 4 | 5 | f :: String -> IO () 6 | f "str" = putStrLn "is str" 7 | f _ = putStrLn " not str" 8 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQPat.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQPat where 3 | import QQ 4 | 5 | f :: String -> IO () 6 | f [str|str|] = putStrLn "is str" 7 | f _ = putStrLn " not str" 8 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQPatError.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQPatError where 3 | import QQ 4 | 5 | f :: () -> IO () 6 | f "str" = putStrLn "is str" 7 | f _ = putStrLn " not str" 8 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TQQPatError.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE QuasiQuotes #-} 2 | module TQQPatError where 3 | import QQ 4 | 5 | f :: () -> IO () 6 | f [str|str|] = putStrLn "is str" 7 | f _ = putStrLn " not str" 8 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TSimpleExp.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TSimpleExp where 3 | import Language.Haskell.TH ( tupE, litE, integerL ) 4 | 5 | main :: IO () 6 | main = return () 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TSimpleExp.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TSimpleExp where 3 | import Language.Haskell.TH ( tupE, litE, integerL ) 4 | 5 | main :: IO () 6 | main = return $(tupE []) 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TSimplePat.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TSimplePat where 3 | import Language.Haskell.TH ( varP, mkName ) 4 | 5 | f :: x -> x 6 | f x = x 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TSimplePat.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TSimplePat where 3 | import Language.Haskell.TH ( varP, mkName ) 4 | 5 | f :: x -> x 6 | f $(varP $ mkName "x") = x 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TSimpleType.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TSimpleType where 3 | import Language.Haskell.TH ( tupleT ) 4 | 5 | main :: IO () 6 | main = return () 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TSimpleType.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | module TSimpleType where 3 | import Language.Haskell.TH ( tupleT ) 4 | 5 | main :: IO $(tupleT 0) 6 | main = return () 7 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TTypeAppExp.expected.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | {-# LANGUAGE TypeApplications #-} 3 | module TTypeAppExp where 4 | import Data.Proxy 5 | 6 | f :: Proxy Int 7 | f = Proxy @Int 8 | -------------------------------------------------------------------------------- /plugins/hls-splice-plugin/test/testdata/TTypeAppExp.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TemplateHaskell #-} 2 | {-# LANGUAGE TypeApplications #-} 3 | module TTypeAppExp where 4 | import Data.Proxy 5 | 6 | f :: Proxy Int 7 | f = $([|Proxy @Int|]) 8 | -------------------------------------------------------------------------------- /plugins/hls-stan-plugin/test/testdata/dir/configTest.hs: -------------------------------------------------------------------------------- 1 | a = length [1..] 2 | 3 | b = undefined 4 | -------------------------------------------------------------------------------- /plugins/hls-stan-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - test.hs -------------------------------------------------------------------------------- /plugins/hls-stan-plugin/test/testdata/test.hs: -------------------------------------------------------------------------------- 1 | orderPair x y 2 | | x < y = 1 3 | | x > y = 2 4 | | otherwise = 3 5 | -------------------------------------------------------------------------------- /plugins/hls-stylish-haskell-plugin/test/testdata/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: [] 4 | -------------------------------------------------------------------------------- /test-logs/README.md: -------------------------------------------------------------------------------- 1 | ## When the tests run, the logs get put here. 2 | -------------------------------------------------------------------------------- /test/testdata/completion/Completion.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | import Data.Maybe 3 | import qualified Data.List 4 | 5 | main :: IO () 6 | main = putStrLn "hello" 7 | 8 | foo :: Either a b -> Either a b 9 | foo = id 10 | -------------------------------------------------------------------------------- /test/testdata/completion/FieldsSharingSignature.hs: -------------------------------------------------------------------------------- 1 | data Foo = MkFoo { arg1, arg2, arg3 :: Int, arg4 :: Int, arg5 :: Double } 2 | -------------------------------------------------------------------------------- /test/testdata/completion/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - "Completion" 5 | - "FieldsSharingSignature" 6 | -------------------------------------------------------------------------------- /test/testdata/diagnostics/Foo.hs: -------------------------------------------------------------------------------- 1 | main = undefined 2 | foo x = id x 3 | -------------------------------------------------------------------------------- /test/testdata/diagnostics/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - Foo 5 | - -Wmissing-signatures 6 | -------------------------------------------------------------------------------- /test/testdata/format/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | direct: 3 | arguments: 4 | - Format 5 | -------------------------------------------------------------------------------- /test/testdata/hieBiosMainIs/Main.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | main :: IO () 4 | main = print foo 5 | 6 | foo = 5 :: Int 7 | -------------------------------------------------------------------------------- /test/testdata/hieBiosMainIs/Setup.hs: -------------------------------------------------------------------------------- 1 | import Distribution.Simple 2 | main = defaultMain 3 | -------------------------------------------------------------------------------- /test/testdata/hieBiosMainIs/cabal.project: -------------------------------------------------------------------------------- 1 | packages: . 2 | -------------------------------------------------------------------------------- /test/testdata/hieBiosMainIs/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/missingModule/cabal.project: -------------------------------------------------------------------------------- 1 | packages: ./ 2 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/missingModule/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/missingModule/src/MyLib.hs: -------------------------------------------------------------------------------- 1 | module MyLib where 2 | 3 | someFunc :: IO () 4 | someFunc = do 5 | putStrLn "someFunc" 6 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/noPrefixMatch/app/Main.hs: -------------------------------------------------------------------------------- 1 | 2 | main :: IO () 3 | main = do 4 | putStrLn "someFunc" 5 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/noPrefixMatch/app/Other.hs: -------------------------------------------------------------------------------- 1 | module Other where 2 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/noPrefixMatch/cabal.project: -------------------------------------------------------------------------------- 1 | packages: ./ 2 | -------------------------------------------------------------------------------- /test/testdata/missingModuleTest/noPrefixMatch/hie.yaml: -------------------------------------------------------------------------------- 1 | cradle: 2 | cabal: 3 | - path: ./app/Main.hs 4 | component: exe:testExe 5 | -------------------------------------------------------------------------------- /test/wrapper/testdata/cabal-cur-ver/Lib.hs: -------------------------------------------------------------------------------- 1 | module Lib where 2 | foo = 42 3 | -------------------------------------------------------------------------------- /test/wrapper/testdata/cabal-cur-ver/cabal.project: -------------------------------------------------------------------------------- 1 | packages: . 2 | -------------------------------------------------------------------------------- /test/wrapper/testdata/stack-specific-ghc/Lib.hs: -------------------------------------------------------------------------------- 1 | module Lib where 2 | foo = 42 3 | -------------------------------------------------------------------------------- /test/wrapper/testdata/stack-specific-ghc/foo.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 2.4 2 | name: foo 3 | version: 0.1.0.0 4 | library 5 | exposed-modules: Lib 6 | build-depends: base 7 | default-language: Haskell2010 8 | -------------------------------------------------------------------------------- /test/wrapper/testdata/stack-with-dist-newstyle/dist-newstyle/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/haskell/haskell-language-server/f1620538ebf830f0b742588b5f3aa65183227bf9/test/wrapper/testdata/stack-with-dist-newstyle/dist-newstyle/.gitkeep -------------------------------------------------------------------------------- /test/wrapper/testdata/stack-with-dist-newstyle/stack-with-dist-newstyle.cabal: -------------------------------------------------------------------------------- 1 | cabal-version: 2.4 2 | name: stack-with-dist-newstyle 3 | version: 0.1.0.0 4 | 5 | library 6 | default-language: Haskell2010 7 | -------------------------------------------------------------------------------- /test/wrapper/testdata/stack-with-dist-newstyle/stack.yaml: -------------------------------------------------------------------------------- 1 | # specific version does not matter 2 | resolver: ghc-9.6.5 3 | --------------------------------------------------------------------------------