68a78e4...main · rowtype-yoga/purslint

git.iko.soy/rowtype-yoga/purslint

137 files changed+1633−1125

since splitsnapshots

unifiedsplit

.github/ISSUE_TEMPLATE/bug_report.ymlnew file+53

@@ -0,0 +1,53 @@

1+name: Bug report

2+description: Report incorrect lint results with input and output.

3+title: "[Bug]: "

4+labels:

5+ - bug

6+body:

7+ - type: markdown

8+ attributes:

9+ value: |

10+ Thanks for taking the time to report a bug.

11+ If possible, include a golden file with input, actual output, and expected output.

12+ - type: textarea

13+ id: input

14+ attributes:

15+ label: Input

16+ description: |

17+ Paste the input here (or attach a golden file and mention the filename).

18+ Include any relevant configuration.

19+ placeholder: |

20+ ```purs

21+ -- Your input code here

22+ ```

23+ validations:

24+ required: true

25+ - type: textarea

26+ id: actual

27+ attributes:

28+ label: Actual output

29+ description: Paste the current output from purslint.

30+ placeholder: |

31+ ```

32+ -- Warnings, fixes, or logs

33+ ```

34+ validations:

35+ required: true

36+ - type: textarea

37+ id: expected

38+ attributes:

39+ label: Expected output

40+ description: Describe the expected output or behaviour.

41+ placeholder: |

42+ ```

43+ -- Expected warnings, fixes, or logs

44+ ```

45+ validations:

46+ required: true

47+ - type: textarea

48+ id: extra

49+ attributes:

50+ label: Additional context

51+ description: Links, screenshots, or anything else helpful.

52+ validations:

53+ required: false

.github/workflows/publish-npm.ymlnew file+27

@@ -0,0 +1,27 @@

1+name: Publish npm package

3+on:

4+ release:

5+ types: [published]

6+ workflow_dispatch:

8+permissions:

9+ contents: read

10+

11+jobs:

12+ publish:

13+ runs-on: ubuntu-latest

14+ steps:

15+ - uses: actions/checkout@v4

16+

17+ - uses: actions/setup-node@v4

18+ with:

19+ node-version: "20"

20+ registry-url: "https://registry.npmjs.org"

21+

22+ - run: npm install -g purescript@0.15.15

23+ - run: npm install --no-audit --no-fund

24+ - run: npm run dist

25+ - run: npm publish --access public

26+ env:

27+ NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-openvsx.ymlnew file+29

@@ -0,0 +1,29 @@

1+name: Publish Open VSX

3+on:

4+ workflow_dispatch:

5+ release:

6+ types: [published]

8+permissions:

9+ contents: read

10+

11+jobs:

12+ publish:

13+ runs-on: ubuntu-latest

14+ steps:

15+ - uses: actions/checkout@v4

16+

17+ - uses: actions/setup-node@v4

18+ with:

19+ node-version: "20"

20+

21+ - run: npm install -g purescript@0.15.15

22+ - run: npm install

23+ working-directory: vscode-extension

24+ - run: npx vsce package

25+ working-directory: vscode-extension

26+ - run: npx ovsx publish -p "${OPENVSX_TOKEN}"

27+ working-directory: vscode-extension

28+ env:

29+ OPENVSX_TOKEN: ${{ secrets.OPENVSX_TOKEN }}

.github/workflows/publish-vscode.ymlnew file+26

@@ -0,0 +1,26 @@

1+name: Publish VS Code Marketplace

3+on:

4+ workflow_dispatch:

5+ release:

6+ types: [published]

8+permissions:

9+ contents: read

10+

11+jobs:

12+ publish:

13+ runs-on: ubuntu-latest

14+ steps:

15+ - uses: actions/checkout@v4

16+

17+ - uses: actions/setup-node@v4

18+ with:

19+ node-version: "20"

20+

21+ - run: npm install

22+ working-directory: vscode-extension

23+ - run: npx vsce publish --pat "${VSCE_TOKEN}"

24+ working-directory: vscode-extension

25+ env:

26+ VSCE_TOKEN: ${{ secrets.VSCE_TOKEN }}

CONTRIBUTING.mdnew file+6

@@ -0,0 +1,6 @@

1+# Contributing

3+## Publishing (Marketplace)

5+Publisher management and VSIX uploads live here:

6+https://marketplace.visualstudio.com/manage/publishers/RowtypeYoga

LICENSEnew file+21

@@ -0,0 +1,21 @@

1+MIT License

5+Permission is hereby granted, free of charge, to any person obtaining a copy

6+of this software and associated documentation files (the "Software"), to deal

7+in the Software without restriction, including without limitation the rights

8+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

9+copies of the Software, and to permit persons to whom the Software is

10+furnished to do so, subject to the following conditions:

11+

12+The above copyright notice and this permission notice shall be included in all

13+copies or substantial portions of the Software.

14+

15+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

16+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

17+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

18+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

19+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

20+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

21+SOFTWARE.

README.md+100−67

@@ -1,92 +1,96 @@

1−# PureLint

1+# Purslint

3−A PureScript linter inspired by [hlint](https://github.com/ndmitchell/hlint), providing suggestions for cleaner, more idiomatic PureScript code.

3+<p align="center">

4+ <img src="vscode-extension/purslint.png" alt="Purslint logo" width="180" />

5+</p>

5−## Features

7+<p align="center">

8+ <a href="https://github.com/user-attachments/assets/6d855014-18f5-4729-be28-e91ec2d19c8f">

9+ <img src="demo.gif" alt="Purslint demo" width="480" />

10+ </a>

11+</p>

612

7−PureLint includes 10 lint rules:

13+A PureScript linter.

814

9−| Rule | Description | Example |

10−|------|-------------|---------|

11−| `FmapId` | `map identity x` → `x` | Redundant identity mapping |

12−| `ConcatMap` | `join <<< map f` → `f =<< _` | Use bind instead of join+map |

13−| `MapFusion` | `map f <<< map g` → `map (f <<< g)` | Fuse consecutive maps |

14−| `UseTraverse` | `sequence <<< map f` → `traverse f` | Use traverse |

15−| `NotEqual` | `not (x == y)` → `x /= y` | Use not-equal operator |

16−| `UseGuard` | `if c then Just x else Nothing` → `guard` | Use guard from Control.MonadZero |

17−| `EtaReduce` | `\x -> f x` → `f` | Eta reduce lambdas |

18−| `EtaReduceDecl` | `f x = g x` → `f = g` | Eta reduce declarations |

19−| `RedundantBind` | `x >>= pure` → `x` | Remove redundant bind |

20−| `LetToWhere` | `let x = y in z` → `z where x = y` | Prefer where clauses |

15+Purslint is very new and may have bugs, so please use an editor with undo functionality. :D

2116

22−## Installation

17+## Install

2318

24−### Prerequisites

19+### VS Code (Marketplace)

2520

26−- [PureScript](https://www.purescript.org/) compiler (`purs`)

27−- [Spago](https://github.com/purescript/spago) package manager

28−- [Go](https://golang.org/) 1.19+

29−- [psgo](https://github.com/puregocore/psgo) - PureScript to Go compiler

21+Install from the Visual Studio Marketplace:

22+[Purslint](https://marketplace.visualstudio.com/items?itemName=RowtypeYoga.purslint).

3023

31−### Building

24+### CLI (npm)

3225

3326```bash

34−# Install dependencies

35−spago install

36−

37−# Build CLI

38−purs compile --codegen corefn 'lib/**/*.purs' 'bin/purelint-cli/**/*.purs' '.spago/**/*.purs'

39−psgo output/*/corefn.json

40−cp output/Main/Main.go main_cli.go

41−go build -o purelint main_cli.go

42−

43−# Build LSP

44−purs compile --codegen corefn 'lib/**/*.purs' 'bin/purelint-lsp/**/*.purs' '.spago/**/*.purs'

45−psgo output/*/corefn.json

46−cp output/Main/Main.go main_lsp.go

47−go build -o purelint-lsp main_lsp.go

48−

49−# Build and run tests

50−purs compile --codegen corefn 'lib/**/*.purs' 'test/**/*.purs' '.spago/**/*.purs'

51−psgo output/*/corefn.json

52−cp output/Test.Main/Test_Main.go test_main.go

53−go build -o test-runner test_main.go

54−./test-runner

27+npm install -g purslint

28+

29+# CLI

30+purslint --help

31+```

32+

33+### Neovim (nvim-lspconfig)

34+

35+After building `purslint-lsp` (see build steps below), you can configure Neovim like this:

36+

37+```lua

38+require("lspconfig").purslint = {

39+ default_config = {

40+ cmd = { "/path/to/purslint-lsp" },

41+ filetypes = { "purescript" },

42+ root_dir = require("lspconfig.util").root_pattern(".git", "spago.yaml", "package.json"),

43+ },

44+}

45+

46+require("lspconfig").purslint.setup({})

47+```

48+

49+If you prefer to run the bundled JS directly:

50+

51+```lua

52+cmd = { "node", "/path/to/dist/purslint-lsp.js" }

5553```

5654

55+### Zed Editor

56+

57+A Zed extension is available in the `zed-extension/` directory. To install:

58+

59+1. Open Zed

60+2. Go to Extensions (Cmd+Shift+X)

61+3. Click "Install Dev Extension"

62+4. Select the `zed-extension/` directory

63+

64+The extension will automatically use the `purslint-lsp` binary.

65+

5766## Usage

5867

5968### CLI

6069

6170```bash

6271# Lint a single file

63−./purelint src/Main.purs

72+./purslint src/Main.purs

6473

6574# Lint multiple files

66−./purelint src/*.purs

75+./purslint src/*.purs

6776

6877# Lint with config file (optional)

69−./purelint --config purelint.json src/*.purs

78+./purslint --config purslint.json src/*.purs

7079```

7180

7281### LSP (Language Server Protocol)

7382

74−The LSP binary (`purelint-lsp`) provides IDE integration. It communicates via stdio using the standard LSP protocol.

75−

76−#### Zed Editor

83+The LSP binary (`purslint-lsp`) provides IDE integration. It communicates via stdio using the standard LSP protocol.

7784

78−A Zed extension is available in the `zed-extension/` directory. To install:

85+## Features

7986

80−1. Open Zed

81−2. Go to Extensions (Cmd+Shift+X)

82−3. Click "Install Dev Extension"

83−4. Select the `zed-extension/` directory

87+Purslint currently ships with **81 lint rules**, covering common PureScript refactors and simplifications.

8488

85−The extension will automatically use the `purelint-lsp` binary.

89+For a complete list, see `lib/purslint/src/Purslint/Rules/`.

8690

8791## Configuration

8892

89−Create a `purelint.json` file in your project root:

93+Create a `purslint.json` file in your project root:

9094

9195```json

9296{

@@ -96,36 +100,63 @@ Create a `purelint.json` file in your project root:

96100

97101## Architecture

98102

99−PureLint is written in PureScript and compiled to Go using `psgo` (purescript-native). This allows:

103+Purslint is written in PureScript and compiled to JavaScript via

104+`purs-backend-es`, then bundled for Node.js. This allows:

100105

101106- Full access to the PureScript CST parser (`purescript-language-cst-parser`)

102−- Native binary performance

103−- Easy distribution without runtime dependencies

107+- Straightforward distribution via npm

108+- A single runtime across CLI and LSP

104109

105110### Project Structure

106111

107112```

108−purelint/

109−├── lib/purelint/src/ # Core library

110−│ └── Purelint/

113+purslint/

114+├── lib/purslint/src/ # Core library

115+│ └── Purslint/

111116│ ├── Rules/ # Lint rules

112117│ ├── Runner.purs # Rule runner

113118│ ├── Types.purs # Core types

114119│ └── Imports.purs # Import checking

115120├── bin/

116−│ ├── purelint-cli/ # CLI application

117−│ └── purelint-lsp/ # LSP server

121+│ ├── purslint-cli/ # CLI application

122+│ └── purslint-lsp/ # LSP server

118123├── test/ # Test suite

119124└── zed-extension/ # Zed editor extension

120125```

121126

122127## Development

123128

129+### Prerequisites

130+

131+- [PureScript](https://www.purescript.org/) compiler (`purs`)

132+- [Spago](https://github.com/purescript/spago) package manager

133+- [Node.js](https://nodejs.org/) 18+

134+

135+### Building

136+

137+```bash

138+# Install dependencies

139+npm install

140+

141+# Build and bundle CLI + LSP

142+npm run dist

143+

144+# Run tests

145+npm test

146+```

147+

148+### Publishing to npm

149+

150+Publishing is handled by GitHub Actions. Add an `NPM_TOKEN` secret with an

151+automation or granular token that has publish rights for `purslint`, then

152+create a GitHub Release to trigger the workflow. You can also run it manually

153+via the workflow dispatch.

154+

124155### Adding a New Rule

125156

126−1. Create a new file in `lib/purelint/src/Purelint/Rules/`

157+1. Create a new file in `lib/purslint/src/Purslint/Rules/`

1271582. Implement the rule using the CST traversal API

128−3. Export the rule from `Purelint.Rules`

159+3. Export the rule from `Purslint.Rules`

1291604. Add tests in `test/Test/Main.purs`

1301615. Rebuild and test

131162

@@ -133,6 +164,8 @@ purelint/

133164

134165- `purescript-language-cst-parser` - PureScript CST parser

135166- `purescript-lsp` - LSP protocol implementation (Go FFI)

167+- `purs-backend-es` - PureScript to JavaScript backend

168+- `esbuild` - Bundler for CLI and LSP

136169

137170## License

138171

bin/purelint-cli/src/Main.pursdeleted−370

@@ -1,370 +0,0 @@

1−module Main where

2−

3−import Prelude

4−

5−import Data.Array as Array

6−import Data.Either (Either(..))

7−import Data.Foldable (for_)

8−import Data.Maybe (Maybe(..))

9−import Data.Newtype (unwrap)

10−import Data.String.CodeUnits as String

11−import Effect (Effect)

12−import Effect.Console (log)

13−import Node.FS.Simple as FS

14−import Node.CLI as Process

15−import Purelint.Config (defaultConfig, filterRules, parseConfig)

16−import Purelint.Fix (applyAllFixes)

17−import Purelint.Rule (Rule)

18−import Purelint.Rules.BooleanSimplify (booleanSimplifyRule)

19−import Purelint.Rules.CollapseLambdas (collapseLambdasRule)

20−import Purelint.Rules.ConcatMap (concatMapRule)

21−import Purelint.Rules.EtaReduce (etaReduceRule)

22−import Purelint.Rules.EtaReduceDecl (etaReduceDeclRule)

23−import Purelint.Rules.AlternativeLaw (alternativeLawRule)

24−import Purelint.Rules.EvaluateBool (evaluateBoolRule)

25−import Purelint.Rules.EvaluateConst (evaluateConstRule)

26−import Purelint.Rules.EvaluateEither (evaluateEitherRule)

27−import Purelint.Rules.EvaluateFst (evaluateFstRule)

28−import Purelint.Rules.MapIdentity (mapIdentityRule)

29−import Purelint.Rules.FunctorLaw (functorLawRule)

30−import Purelint.Rules.LetToDo (letToDoRule)

31−import Purelint.Rules.LetToWhere (letToWhereRule)

32−import Purelint.Rules.MapFusion (mapFusionRule)

33−import Purelint.Rules.MonadLaw (monadLawRule)

34−import Purelint.Rules.MonoidIdentity (monoidIdentityRule)

35−import Purelint.Rules.NotEqual (notEqualRule)

36−import Purelint.Rules.NothingBind (nothingBindRule)

37−import Purelint.Rules.RedundantBind (redundantBindRule)

38−import Purelint.Rules.RedundantFlip (redundantFlipRule)

39−import Purelint.Rules.RedundantGuard (redundantGuardRule)

40−import Purelint.Rules.RedundantId (redundantIdRule)

41−import Purelint.Rules.RedundantIf (redundantIfRule)

42−import Purelint.Rules.RedundantNegate (redundantNegateRule)

43−import Purelint.Rules.RedundantNot (redundantNotRule)

44−import Purelint.Rules.RedundantReverse (redundantReverseRule)

45−import Purelint.Rules.UnlessNot (unlessNotRule)

46−import Purelint.Rules.UseAll (useAllRule)

47−import Purelint.Rules.UseAnd (useAndRule)

48−import Purelint.Rules.UseAny (useAnyRule)

49−import Purelint.Rules.UseApplicative (useApplicativeRule)

50−import Purelint.Rules.UseApplyFlipped (useApplyFlippedRule)

51−import Purelint.Rules.UseBimap (useBimapRule)

52−import Purelint.Rules.UseBindFlip (useBindFlipRule)

53−import Purelint.Rules.UseBreak (useBreakRule)

54−import Purelint.Rules.UseComparing (useComparingRule)

55−import Purelint.Rules.UseConst (useConstRule)

56−import Purelint.Rules.UseDollar (useDollarRule)

57−import Purelint.Rules.UseEitherMap (useEitherMapRule)

58−import Purelint.Rules.UseElemIndex (useElemIndexRule)

59−import Purelint.Rules.UseFindMap (useFindMapRule)

60−import Purelint.Rules.UseFold (useFoldRule)

61−import Purelint.Rules.UseFoldBool (useFoldBoolRule)

62−import Purelint.Rules.UseFoldMap (useFoldMapRule)

63−import Purelint.Rules.UseFoldMapId (useFoldMapIdRule)

64−import Purelint.Rules.UseFor (useForRule)

65−import Purelint.Rules.UseFromJust (useFromJustRule)

66−import Purelint.Rules.UseFromMaybe (useFromMaybeRule)

67−import Purelint.Rules.UseFstSnd (useFstSndRule)

68−import Purelint.Rules.UseGuard (useGuardRule)

69−import Purelint.Rules.UseGuardMaybe (useGuardMaybeRule)

70−import Purelint.Rules.UseHead (useHeadRule)

71−import Purelint.Rules.UseIsJust (useIsJustRule)

72−import Purelint.Rules.UseIsNothing (useIsNothingRule)

73−import Purelint.Rules.UseJoin (useJoinRule)

74−import Purelint.Rules.UseLastReverse (useLastReverseRule)

75−import Purelint.Rules.UseMapMaybe (useMapMaybeRule)

76−import Purelint.Rules.UseMaybeMap (useMaybeMapRule)

77−import Purelint.Rules.UseMinMax (useMinMaxRule)

78−import Purelint.Rules.UseMinimumSort (useMinimumSortRule)

79−import Purelint.Rules.UseNotElem (useNotElemRule)

80−import Purelint.Rules.UseNull (useNullRule)

81−import Purelint.Rules.UseOn (useOnRule)

82−import Purelint.Rules.UseOr (useOrRule)

83−import Purelint.Rules.UsePatternGuards (usePatternGuardsRule)

84−import Purelint.Rules.UseReplicate (useReplicateRule)

85−import Purelint.Rules.UseSequence (useSequenceRule)

86−import Purelint.Rules.UseSpan (useSpanRule)

87−import Purelint.Rules.UseTraverse (useTraverseRule)

88−import Purelint.Rules.UseTraverseSequence (useTraverseSequenceRule)

89−import Purelint.Rules.UseUncurry (useUncurryRule)

90−import Purelint.Rules.UseUnless (useUnlessRule)

91−import Purelint.Rules.UseUnwrap (useUnwrapRule)

92−import Purelint.Rules.UseVoid (useVoidRule)

93−import Purelint.Rules.UseWhen (useWhenRule)

94−import Purelint.Rules.UseZip (useZipRule)

95−import Purelint.Rules.WhenNot (whenNotRule)

96−import Purelint.Rules.RedundantParens (redundantParensRule)

97−import Purelint.Runner (runRules)

98−import Purelint.Types (LintResult(..), LintWarning(..), Severity(..), SourceCode(..), Suggestion(..))

99−

100−-- | All available rules (76 total)

101−allRules :: Array Rule

102−allRules =

103− [ alternativeLawRule

104− , booleanSimplifyRule

105− , collapseLambdasRule

106− , concatMapRule

107− , etaReduceRule

108− , etaReduceDeclRule

109− , evaluateBoolRule

110− , evaluateConstRule

111− , evaluateEitherRule

112− , evaluateFstRule

113− , mapIdentityRule

114− , functorLawRule

115− , letToDoRule

116− , letToWhereRule

117− , mapFusionRule

118− , monadLawRule

119− , monoidIdentityRule

120− , notEqualRule

121− , nothingBindRule

122− , redundantBindRule

123− , redundantFlipRule

124− , redundantGuardRule

125− , redundantIdRule

126− , redundantIfRule

127− , redundantNegateRule

128− , redundantNotRule

129− , redundantParensRule

130− , redundantReverseRule

131− , unlessNotRule

132− , useAllRule

133− , useAndRule

134− , useAnyRule

135− , useApplicativeRule

136− , useApplyFlippedRule

137− , useBimapRule

138− , useBindFlipRule

139− , useBreakRule

140− , useComparingRule

141− , useConstRule

142− , useDollarRule

143− , useEitherMapRule

144− , useElemIndexRule

145− , useFindMapRule

146− , useFoldRule

147− , useFoldBoolRule

148− , useFoldMapRule

149− , useFoldMapIdRule

150− , useForRule

151− , useFromJustRule

152− , useFromMaybeRule

153− , useFstSndRule

154− , useGuardRule

155− , useGuardMaybeRule

156− , useHeadRule

157− , useIsJustRule

158− , useIsNothingRule

159− , useJoinRule

160− , useLastReverseRule

161− , useMapMaybeRule

162− , useMaybeMapRule

163− , useMinMaxRule

164− , useMinimumSortRule

165− , useNotElemRule

166− , useNullRule

167− , useOnRule

168− , useOrRule

169− , usePatternGuardsRule

170− , useReplicateRule

171− , useSequenceRule

172− , useSpanRule

173− , useTraverseRule

174− , useTraverseSequenceRule

175− , useUncurryRule

176− , useUnlessRule

177− , useUnwrapRule

178− , useVoidRule

179− , useWhenRule

180− , useZipRule

181− , whenNotRule

182− ]

183−

184−-- | Load config from .purelintrc file

185−loadConfig :: Effect _

186−loadConfig = do

187− hasConfig <- FS.exists ".purelintrc"

188− if hasConfig then do

189− content <- FS.readTextFile ".purelintrc"

190− pure $ parseConfig content

191− else

192− pure defaultConfig

193−

194−-- | Format a source range for display

195−formatRange :: { start :: { line :: Int, column :: Int }, end :: { line :: Int, column :: Int } } -> String

196−formatRange r = show (r.start.line + 1) <> ":" <> show (r.start.column + 1) <> "-" <> show (r.end.line + 1) <> ":" <> show (r.end.column + 1)

197−

198−-- | Format severity for display

199−formatSeverity :: Severity -> String

200−formatSeverity Refactor = "[refactor]"

201−formatSeverity Hint = "[hint]"

202−formatSeverity Warning = "[warning]"

203−formatSeverity Error = "[error]"

204−

205−-- | Format a single warning for display

206−formatWarning :: String -> LintWarning -> String

207−formatWarning filePath (LintWarning w) =

208− filePath <> ":" <> formatRange w.range <> " " <> formatSeverity w.severity <> " " <> unwrap w.ruleId <> ": " <> unwrap w.message <>

209− case w.suggestion of

210− Nothing -> ""

211− Just (Suggestion s) -> "\n Replace with: " <> unwrap s.replacement

212−

213−-- | Lint a single file with config

214−lintFileWithConfig :: Array Rule -> String -> Effect Int

215−lintFileWithConfig rules filePath = do

216− content <- FS.readTextFile filePath

217− case runRules rules (SourceCode content) of

218− Left err -> do

219− log $ filePath <> ": " <> err

220− pure 0

221− Right (LintResult result) -> do

222− for_ result.warnings \w -> do

223− log $ formatWarning filePath w

224− pure (Array.length result.warnings)

225−

226−-- | Fix a single file

227−fixFile :: Array Rule -> String -> Effect Int

228−fixFile rules filePath = do

229− content <- FS.readTextFile filePath

230− case runRules rules (SourceCode content) of

231− Left err -> do

232− log $ filePath <> ": " <> err

233− pure 0

234− Right result@(LintResult r) -> do

235− let fixedContent = applyAllFixes content result

236− when (fixedContent /= content) do

237− FS.writeTextFile filePath fixedContent

238− log $ filePath <> ": fixed " <> show (Array.length r.warnings) <> " issue(s)"

239− pure (Array.length r.warnings)

240−

241−-- | Recursively find all .purs files in a directory

242−findPursFiles :: String -> Effect (Array String)

243−findPursFiles dir = do

244− entries <- FS.readdir dir

245− files <- Array.foldM (collectFiles dir) [] entries

246− pure files

247− where

248− collectFiles :: String -> Array String -> String -> Effect (Array String)

249− collectFiles parentDir acc entry = do

250− let path = parentDir <> "/" <> entry

251− -- Skip hidden directories and node_modules

252− if String.take 1 entry == "." || entry == "node_modules" || entry == ".spago" then

253− pure acc

254− else do

255− stats <- FS.stat path

256− if stats.isDirectory then do

257− subFiles <- findPursFiles path

258− pure (acc <> subFiles)

259− else if String.takeRight 5 entry == ".purs" then

260− pure (Array.snoc acc path)

261− else

262− pure acc

263−

264−-- | Lint a file or directory with config

265−lintPathWithConfig :: Array Rule -> String -> Effect Int

266−lintPathWithConfig rules path = do

267− stats <- FS.stat path

268− if stats.isDirectory then do

269− files <- findPursFiles path

270− counts <- Array.foldM (\acc file -> do

271− count <- lintFileWithConfig rules file

272− pure (acc + count)) 0 files

273− pure counts

274− else

275− lintFileWithConfig rules path

276−

277−-- | Fix a file or directory

278−fixPath :: Array Rule -> String -> Effect Int

279−fixPath rules path = do

280− stats <- FS.stat path

281− if stats.isDirectory then do

282− files <- findPursFiles path

283− counts <- Array.foldM (\acc file -> do

284− count <- fixFile rules file

285− pure (acc + count)) 0 files

286− pure counts

287− else

288− fixFile rules path

289−

290−-- | Show usage

291−showUsage :: Effect Unit

292−showUsage = do

293− log "purelint - a linter for PureScript (70 rules)"

294− log ""

295− log "Usage: purelint [OPTIONS] [FILES/DIRECTORIES...]"

296− log ""

297− log "Options:"

298− log " --help Show this help"

299− log " --fix Auto-fix issues (where possible)"

300− log " --init Create a sample .purelintrc"

301− log " --list List all available rules"

302− log ""

303− log "Configuration:"

304− log " Create .purelintrc in your project root to disable rules."

305− log " Add one rule name per line (lines starting with # are comments)."

306− log ""

307− log "Examples:"

308− log " purelint src/ Lint all .purs files in src/"

309− log " purelint --fix src/ Auto-fix issues in src/"

310− log " purelint src/Main.purs Lint a single file"

311−

312−-- | List all available rules

313−listRules :: Effect Unit

314−listRules = do

315− log $ "Available rules (" <> show (Array.length allRules) <> " total):"

316− log ""

317− for_ allRules \rule -> do

318− log $ " " <> unwrap rule.ruleId

319−

320−-- | Create sample config file

321−initConfig :: Effect Unit

322−initConfig = do

323− hasConfig <- FS.exists ".purelintrc"

324− if hasConfig then

325− log ".purelintrc already exists"

326− else do

327− let sampleConfig = """# purelint configuration

328−# Add rule names (one per line) to disable them

329−# Example:

330−# EtaReduce

331−# LetToWhere

332−"""

333− FS.writeTextFile ".purelintrc" sampleConfig

334− log "Created .purelintrc"

335−

336−main :: Effect Unit

337−main = do

338− args <- Process.argv

339− -- args[0] is node, args[1] is the script, args[2..] are the actual arguments

340− let userArgs = Array.drop 1 args

341− case userArgs of

342− [] -> showUsage

343− ["--help"] -> showUsage

344− ["-h"] -> showUsage

345− ["--list"] -> listRules

346− ["--init"] -> initConfig

347− _ -> do

348− -- Check for --fix flag

349− let hasFix = Array.elem "--fix" userArgs

350− let paths = Array.filter (\a -> a /= "--fix") userArgs

351−

352− -- Load config and filter rules

353− config <- loadConfig

354− let enabledRules = filterRules allRules config

355−

356− if hasFix then do

357− -- Fix mode

358− _ <- Array.foldM (\acc path -> do

359− count <- fixPath enabledRules path

360− pure (acc + count)) 0 paths

361− pure unit

362− else do

363− -- Lint mode

364− totalWarnings <- Array.foldM (\acc path -> do

365− count <- lintPathWithConfig enabledRules path

366− pure (acc + count)) 0 paths

367− when (totalWarnings > 0) do

368− log ""

369− log $ "Total: " <> show totalWarnings <> " warning" <> if totalWarnings == 1 then "" else "s"

370− Process.exit 1

bin/purelint-lsp.jsdeleted−3

@@ -1,3 +0,0 @@

1−#!/usr/bin/env node

2−import { main } from "../output-lsp/Main.LSP/index.js";

3−main();

bin/purelint.jsdeleted−3

@@ -1,3 +0,0 @@

1−#!/usr/bin/env node

2−import { main } from "../output-cli/Main/index.js";

3−main();

bin/purelint-cli/spago.yaml → bin/purslint-cli/spago.yamlrenamed+3−2

@@ -1,5 +1,5 @@

11package:

2− name: purelint-cli

2+ name: purslint-cli

33 dependencies:

44 - arrays

55 - console

@@ -8,8 +8,9 @@ package:

88 - foldable-traversable

99 - maybe

1010 - newtype

11+ - optparse

1112 - prelude

12− - purelint

13+ - purslint

1314 - strings

1415 - node-buffer

1516 - node-fs

bin/purslint-cli/src/Main.pursnew file+419

@@ -0,0 +1,419 @@

1+module Main where

3+import Prelude

5+import Data.Array as Array

6+import Data.Either (Either(..))

7+import Data.Enum (fromEnum)

8+import Data.Foldable (for_)

9+import Data.Maybe (Maybe(..))

10+import Data.Newtype (unwrap)

11+import Data.String.CodeUnits as String

12+import Data.Tuple.Nested ((/\))

13+import Effect (Effect)

14+import Effect.Console (log)

15+import Node.FS.Simple as FS

16+import Node.CLI as Process

17+import Options.Applicative (Parser, argument, execParserPure, fullDesc, header, help, helper, info, long, many, metavar, progDesc, str, switch, (<**>))

18+import Options.Applicative.Builder (defaultPrefs)

19+import Options.Applicative.Types (CompletionResult(..), ParserFailure(ParserFailure), ParserResult(..))

20+import Options.Applicative.Help.Types (ParserHelp(ParserHelp), renderHelp)

21+import Purslint.Config (defaultConfig, filterRules, parseConfig)

22+import Purslint.Fix (applyAllFixes)

23+import Purslint.Rule (Rule)

24+import Purslint.Rules.BooleanSimplify (booleanSimplifyRule)

25+import Purslint.Rules.CollapseLambdas (collapseLambdasRule)

26+import Purslint.Rules.ConcatMap (concatMapRule)

27+import Purslint.Rules.EtaReduce (etaReduceRule)

28+import Purslint.Rules.EtaReduceDecl (etaReduceDeclRule)

29+import Purslint.Rules.AlternativeLaw (alternativeLawRule)

30+import Purslint.Rules.EvaluateBool (evaluateBoolRule)

31+import Purslint.Rules.EvaluateConst (evaluateConstRule)

32+import Purslint.Rules.EvaluateEither (evaluateEitherRule)

33+import Purslint.Rules.EvaluateFst (evaluateFstRule)

34+import Purslint.Rules.MapIdentity (mapIdentityRule)

35+import Purslint.Rules.FunctorLaw (functorLawRule)

36+import Purslint.Rules.LetToDo (letToDoRule)

37+import Purslint.Rules.LetToWhere (letToWhereRule)

38+import Purslint.Rules.MapFusion (mapFusionRule)

39+import Purslint.Rules.MonadLaw (monadLawRule)

40+import Purslint.Rules.MonoidIdentity (monoidIdentityRule)

41+import Purslint.Rules.NotEqual (notEqualRule)

42+import Purslint.Rules.NothingBind (nothingBindRule)

43+import Purslint.Rules.RedundantBind (redundantBindRule)

44+import Purslint.Rules.RedundantFlip (redundantFlipRule)

45+import Purslint.Rules.RedundantGuard (redundantGuardRule)

46+import Purslint.Rules.RedundantId (redundantIdRule)

47+import Purslint.Rules.RedundantIf (redundantIfRule)

48+import Purslint.Rules.RedundantNegate (redundantNegateRule)

49+import Purslint.Rules.RedundantNot (redundantNotRule)

50+import Purslint.Rules.RedundantReverse (redundantReverseRule)

51+import Purslint.Rules.UnlessNot (unlessNotRule)

52+import Purslint.Rules.UseAll (useAllRule)

53+import Purslint.Rules.UseAnd (useAndRule)

54+import Purslint.Rules.UseAny (useAnyRule)

55+import Purslint.Rules.UseApplicative (useApplicativeRule)

56+import Purslint.Rules.UseApplyFlipped (useApplyFlippedRule)

57+import Purslint.Rules.UseBimap (useBimapRule)

58+import Purslint.Rules.UseBindFlip (useBindFlipRule)

59+import Purslint.Rules.UseBreak (useBreakRule)

60+import Purslint.Rules.UseComparing (useComparingRule)

61+import Purslint.Rules.UseConst (useConstRule)

62+import Purslint.Rules.UseDollar (useDollarRule)

63+import Purslint.Rules.UseEitherMap (useEitherMapRule)

64+import Purslint.Rules.UseElemIndex (useElemIndexRule)

65+import Purslint.Rules.UseFindMap (useFindMapRule)

66+import Purslint.Rules.UseFold (useFoldRule)

67+import Purslint.Rules.UseFoldBool (useFoldBoolRule)

68+import Purslint.Rules.UseFoldMap (useFoldMapRule)

69+import Purslint.Rules.UseFoldMapId (useFoldMapIdRule)

70+import Purslint.Rules.UseFor (useForRule)

71+import Purslint.Rules.UseFromJust (useFromJustRule)

72+import Purslint.Rules.UseFromMaybe (useFromMaybeRule)

73+import Purslint.Rules.UseFstSnd (useFstSndRule)

74+import Purslint.Rules.UseGuard (useGuardRule)

75+import Purslint.Rules.UseGuardMaybe (useGuardMaybeRule)

76+import Purslint.Rules.UseHead (useHeadRule)

77+import Purslint.Rules.UseIsJust (useIsJustRule)

78+import Purslint.Rules.UseIsNothing (useIsNothingRule)

79+import Purslint.Rules.UseJoin (useJoinRule)

80+import Purslint.Rules.UseLastReverse (useLastReverseRule)

81+import Purslint.Rules.UseMapMaybe (useMapMaybeRule)

82+import Purslint.Rules.UseMaybeMap (useMaybeMapRule)

83+import Purslint.Rules.UseMinMax (useMinMaxRule)

84+import Purslint.Rules.UseMinimumSort (useMinimumSortRule)

85+import Purslint.Rules.UseNotElem (useNotElemRule)

86+import Purslint.Rules.UseNull (useNullRule)

87+import Purslint.Rules.UseCaseOf (useCaseOfRule)

88+import Purslint.Rules.FlattenCase (flattenCaseRule)

89+import Purslint.Rules.UseOn (useOnRule)

90+import Purslint.Rules.UseOr (useOrRule)

91+import Purslint.Rules.UsePatternGuards (usePatternGuardsRule)

92+import Purslint.Rules.UseReplicate (useReplicateRule)

93+import Purslint.Rules.UseSequence (useSequenceRule)

94+import Purslint.Rules.UseSpan (useSpanRule)

95+import Purslint.Rules.UseTraverse (useTraverseRule)

96+import Purslint.Rules.UseTraverseSequence (useTraverseSequenceRule)

97+import Purslint.Rules.UseUncurry (useUncurryRule)

98+import Purslint.Rules.UseUnless (useUnlessRule)

99+import Purslint.Rules.UseUnwrap (useUnwrapRule)

100+import Purslint.Rules.UseVoid (useVoidRule)

101+import Purslint.Rules.UseWhen (useWhenRule)

102+import Purslint.Rules.UseZip (useZipRule)

103+import Purslint.Rules.WhenNot (whenNotRule)

104+import Purslint.Rules.RedundantParens (redundantParensRule)

105+import Purslint.Runner (runRules)

106+import Purslint.Types (LintResult(..), LintWarning(..), Severity(..), SourceCode(..), Suggestion(..))

107+

108+type CliOptions =

109+ { fix :: Boolean

110+ , listRules :: Boolean

111+ , initConfig :: Boolean

112+ , paths :: Array String

113+ }

114+

115+-- | All available rules (81 total)

116+allRules :: Array Rule

117+allRules =

118+ [ alternativeLawRule

119+ , booleanSimplifyRule

120+ , collapseLambdasRule

121+ , concatMapRule

122+ , etaReduceRule

123+ , etaReduceDeclRule

124+ , evaluateBoolRule

125+ , evaluateConstRule

126+ , evaluateEitherRule

127+ , evaluateFstRule

128+ , mapIdentityRule

129+ , functorLawRule

130+ , letToDoRule

131+ , letToWhereRule

132+ , mapFusionRule

133+ , monadLawRule

134+ , monoidIdentityRule

135+ , notEqualRule

136+ , nothingBindRule

137+ , redundantBindRule

138+ , redundantFlipRule

139+ , redundantGuardRule

140+ , redundantIdRule

141+ , redundantIfRule

142+ , redundantNegateRule

143+ , redundantNotRule

144+ , redundantParensRule

145+ , redundantReverseRule

146+ , unlessNotRule

147+ , useAllRule

148+ , useAndRule

149+ , useAnyRule

150+ , useApplicativeRule

151+ , useApplyFlippedRule

152+ , useBimapRule

153+ , useBindFlipRule

154+ , useBreakRule

155+ , useComparingRule

156+ , useConstRule

157+ , useDollarRule

158+ , useEitherMapRule

159+ , useElemIndexRule

160+ , useFindMapRule

161+ , useFoldRule

162+ , useFoldBoolRule

163+ , useFoldMapRule

164+ , useFoldMapIdRule

165+ , useForRule

166+ , useFromJustRule

167+ , useFromMaybeRule

168+ , useFstSndRule

169+ , useGuardRule

170+ , useGuardMaybeRule

171+ , useHeadRule

172+ , useIsJustRule

173+ , useIsNothingRule

174+ , useJoinRule

175+ , useLastReverseRule

176+ , useMapMaybeRule

177+ , useMaybeMapRule

178+ , useMinMaxRule

179+ , useMinimumSortRule

180+ , useNotElemRule

181+ , useNullRule

182+ , useOnRule

183+ , useOrRule

184+ , usePatternGuardsRule

185+ , useCaseOfRule

186+ , flattenCaseRule

187+ , useReplicateRule

188+ , useSequenceRule

189+ , useSpanRule

190+ , useTraverseRule

191+ , useTraverseSequenceRule

192+ , useUncurryRule

193+ , useUnlessRule

194+ , useUnwrapRule

195+ , useVoidRule

196+ , useWhenRule

197+ , useZipRule

198+ , whenNotRule

199+ ]

200+

201+-- | Load config from .purslintrc file

202+loadConfig :: Effect _

203+loadConfig = do

204+ hasConfig <- FS.exists ".purslintrc"

205+ if hasConfig then do

206+ content <- FS.readTextFile ".purslintrc"

207+ pure $ parseConfig content

208+ else

209+ pure defaultConfig

210+

211+-- | Format a source range for display

212+formatRange :: { start :: { line :: Int, column :: Int }, end :: { line :: Int, column :: Int } } -> String

213+formatRange r = show (r.start.line + 1) <> ":" <> show (r.start.column + 1) <> "-" <> show (r.end.line + 1) <> ":" <> show (r.end.column + 1)

214+

215+-- | Format severity for display

216+formatSeverity :: Severity -> String

217+formatSeverity Refactor = "[refactor]"

218+formatSeverity Hint = "[hint]"

219+formatSeverity Warning = "[warning]"

220+formatSeverity Error = "[error]"

221+

222+-- | Format a single warning for display

223+formatWarning :: String -> LintWarning -> String

224+formatWarning filePath (LintWarning w) =

225+ filePath <> ":" <> formatRange w.range <> " " <> formatSeverity w.severity <> " " <> unwrap w.ruleId <> ": " <> unwrap w.message <>

226+ case w.suggestion of

227+ Nothing -> ""

228+ Just (Suggestion s) -> "\n Replace with: " <> unwrap s.replacement

229+

230+-- | Lint a single file with config

231+lintFileWithConfig :: Array Rule -> String -> Effect Int

232+lintFileWithConfig rules filePath = do

233+ content <- FS.readTextFile filePath

234+ case runRules rules (SourceCode content) of

235+ Left err -> do

236+ log $ filePath <> ": " <> err

237+ pure 0

238+ Right (LintResult result) -> do

239+ for_ result.warnings \w -> do

240+ log $ formatWarning filePath w

241+ pure (Array.length result.warnings)

242+

243+-- | Fix a single file

244+fixFile :: Array Rule -> String -> Effect Int

245+fixFile rules filePath = do

246+ content <- FS.readTextFile filePath

247+ case runRules rules (SourceCode content) of

248+ Left err -> do

249+ log $ filePath <> ": " <> err

250+ pure 0

251+ Right result@(LintResult r) -> do

252+ let fixedContent = applyAllFixes content result

253+ when (fixedContent /= content) do

254+ FS.writeTextFile filePath fixedContent

255+ log $ filePath <> ": fixed " <> show (Array.length r.warnings) <> " issue(s)"

256+ pure (Array.length r.warnings)

257+

258+-- | Recursively find all .purs files in a directory

259+findPursFiles :: String -> Effect (Array String)

260+findPursFiles dir = do

261+ entries <- FS.readdir dir

262+ files <- Array.foldM (collectFiles dir) [] entries

263+ pure files

264+ where

265+ collectFiles :: String -> Array String -> String -> Effect (Array String)

266+ collectFiles parentDir acc entry = do

267+ let path = parentDir <> "/" <> entry

268+ -- Skip hidden directories and node_modules

269+ if String.take 1 entry == "." || entry == "node_modules" || entry == ".spago" then

270+ pure acc

271+ else do

272+ stats <- FS.stat path

273+ if stats.isDirectory then do

274+ subFiles <- findPursFiles path

275+ pure (acc <> subFiles)

276+ else if String.takeRight 5 entry == ".purs" then

277+ pure (Array.snoc acc path)

278+ else

279+ pure acc

280+

281+-- | Lint a file or directory with config

282+lintPathWithConfig :: Array Rule -> String -> Effect Int

283+lintPathWithConfig rules path = do

284+ stats <- FS.stat path

285+ if stats.isDirectory then do

286+ files <- findPursFiles path

287+ counts <- Array.foldM (\acc file -> do

288+ count <- lintFileWithConfig rules file

289+ pure (acc + count)) 0 files

290+ pure counts

291+ else

292+ lintFileWithConfig rules path

293+

294+-- | Fix a file or directory

295+fixPath :: Array Rule -> String -> Effect Int

296+fixPath rules path = do

297+ stats <- FS.stat path

298+ if stats.isDirectory then do

299+ files <- findPursFiles path

300+ counts <- Array.foldM (\acc file -> do

301+ count <- fixFile rules file

302+ pure (acc + count)) 0 files

303+ pure counts

304+ else

305+ fixFile rules path

306+

307+-- | Show usage

308+showUsage :: Effect Unit

309+showUsage = do

310+ log "purslint - a linter for PureScript (81 rules)"

311+ log ""

312+ log "Usage: purslint [OPTIONS] [FILES/DIRECTORIES...]"

313+ log ""

314+ log "Options:"

315+ log " --help Show this help"

316+ log " --fix Auto-fix issues (where possible)"

317+ log " --init Create a sample .purslintrc"

318+ log " --list List all available rules"

319+ log ""

320+ log "Configuration:"

321+ log " Create .purslintrc in your project root to disable rules."

322+ log " Add one rule name per line (lines starting with # are comments)."

323+ log ""

324+ log "Examples:"

325+ log " purslint src/ Lint all .purs files in src/"

326+ log " purslint --fix src/ Auto-fix issues in src/"

327+ log " purslint src/Main.purs Lint a single file"

328+

329+-- | List all available rules

330+listRules :: Effect Unit

331+listRules = do

332+ log $ "Available rules (" <> show (Array.length allRules) <> " total):"

333+ log ""

334+ for_ allRules \rule -> do

335+ log $ " " <> unwrap rule.ruleId

336+

337+-- | Create sample config file

338+initConfig :: Effect Unit

339+initConfig = do

340+ hasConfig <- FS.exists ".purslintrc"

341+ if hasConfig then

342+ log ".purslintrc already exists"

343+ else do

344+ let sampleConfig = """# purslint configuration

345+# Add rule names (one per line) to disable them

346+# Example:

347+# EtaReduce

348+# LetToWhere

349+"""

350+ FS.writeTextFile ".purslintrc" sampleConfig

351+ log "Created .purslintrc"

352+

353+parseFlags :: Array String -> Effect (Maybe CliOptions)

354+parseFlags args = case parseFlags' (Array.drop 2 args) of

355+ Success cli -> pure (Just cli)

356+ Failure (ParserFailure pf) -> case pf programName of

357+ ph@(ParserHelp _) /\ exitCode /\ i /\ _unit -> do

358+ log $ renderHelp i ph

359+ Process.exit (fromEnum exitCode)

360+ pure Nothing

361+ CompletionInvoked (CompletionResult { execCompletion }) -> do

362+ executedCompletion <- execCompletion programName

363+ log executedCompletion

364+ Process.exit 0

365+ pure Nothing

366+ where

367+ programName = "purslint"

368+

369+parseFlags' :: Array String -> ParserResult CliOptions

370+parseFlags' = execParserPure defaultPrefs opts

371+ where

372+ opts =

373+ info (flagsParser <**> helper) $

374+ fullDesc

375+ <> progDesc "Lint PureScript source files"

376+ <> header "purslint - a linter for PureScript"

377+

378+flagsParser :: Parser CliOptions

379+flagsParser = ado

380+ fix <- switch $ long "fix" <> help "Auto-fix issues (where possible)"

381+ listRules <- switch $ long "list" <> help "List all available rules"

382+ initConfig <- switch $ long "init" <> help "Create a sample .purslintrc"

383+ pathsList <- many $ argument str $ metavar "PATH..."

384+ let paths = Array.fromFoldable pathsList

385+ in { fix, listRules, initConfig, paths }

386+

387+main :: Effect Unit

388+main = do

389+ args <- Process.argv

390+ maybeCli <- parseFlags args

391+ case maybeCli of

392+ Nothing -> pure unit

393+ Just cli ->

394+ if cli.listRules then

395+ listRules

396+ else if cli.initConfig then

397+ initConfig

398+ else if Array.null cli.paths then

399+ showUsage

400+ else do

401+ -- Load config and filter rules

402+ config <- loadConfig

403+ let enabledRules = filterRules allRules config

404+

405+ if cli.fix then do

406+ -- Fix mode

407+ _ <- Array.foldM (\acc path -> do

408+ count <- fixPath enabledRules path

409+ pure (acc + count)) 0 cli.paths

410+ pure unit

411+ else do

412+ -- Lint mode

413+ totalWarnings <- Array.foldM (\acc path -> do

414+ count <- lintPathWithConfig enabledRules path

415+ pure (acc + count)) 0 cli.paths

416+ when (totalWarnings > 0) do

417+ log ""

418+ log $ "Total: " <> show totalWarnings <> " warning" <> if totalWarnings == 1 then "" else "s"

419+ Process.exit 1

bin/purelint-cli/src/Node/CLI.js → bin/purslint-cli/src/Node/CLI.jsrenamed

The content is the same.

bin/purelint-cli/src/Node/CLI.purs → bin/purslint-cli/src/Node/CLI.pursrenamed

The content is the same.

bin/purelint-cli/src/Node/FS/Simple.js → bin/purslint-cli/src/Node/FS/Simple.jsrenamed

The content is the same.

bin/purelint-cli/src/Node/FS/Simple.purs → bin/purslint-cli/src/Node/FS/Simple.pursrenamed

The content is the same.

bin/purslint-lsp.jsnew file+2

@@ -0,0 +1,2 @@

1+#!/usr/bin/env node

2+import "../dist/purslint-lsp.js";

bin/purelint-lsp/spago.yaml → bin/purslint-lsp/spago.yamlrenamed+2−2

@@ -1,5 +1,5 @@

11package:

2− name: purelint-lsp

2+ name: purslint-lsp

33 dependencies:

44 - arrays

55 - effect

@@ -8,5 +8,5 @@ package:

88 - maybe

99 - newtype

1010 - prelude

11− - purelint

11+ - purslint

1212 - unsafe-coerce

bin/purelint-lsp/src/LSP.js → bin/purslint-lsp/src/LSP.jsrenamed+1−1

@@ -1,4 +1,4 @@

1−// Purelint.LSP FFI for JavaScript

1+// Purslint.LSP FFI for JavaScript

33// Create a null value

44export const mkNull = (_) => null;

bin/purelint-lsp/src/LSP.purs → bin/purslint-lsp/src/LSP.pursrenamed+104−104

@@ -1,4 +1,4 @@

1−module Purelint.LSP where

1+module Purslint.LSP where

33import Prelude

@@ -13,91 +13,91 @@ import Effect.Ref (Ref)

1313import Effect.Ref as Ref

1414import Foreign (Foreign)

1515import LSP.Stdio as Stdio

16−import Purelint.Config (Config, defaultConfig, filterRules)

17−import Purelint.Rule (Rule)

18−import Purelint.Rules.BooleanSimplify (booleanSimplifyRule)

19−import Purelint.Rules.CollapseLambdas (collapseLambdasRule)

20−import Purelint.Rules.ConcatMap (concatMapRule)

21−import Purelint.Rules.EtaReduce (etaReduceRule)

22−import Purelint.Rules.EtaReduceDecl (etaReduceDeclRule)

23−import Purelint.Rules.MapIdentity (mapIdentityRule)

24−import Purelint.Rules.FunctorLaw (functorLawRule)

25−import Purelint.Rules.LetToDo (letToDoRule)

26−import Purelint.Rules.LetToWhere (letToWhereRule)

27−import Purelint.Rules.MapFusion (mapFusionRule)

28−import Purelint.Rules.MonadLaw (monadLawRule)

29−import Purelint.Rules.MonoidIdentity (monoidIdentityRule)

30−import Purelint.Rules.NotEqual (notEqualRule)

31−import Purelint.Rules.RedundantBind (redundantBindRule)

32−import Purelint.Rules.RedundantFlip (redundantFlipRule)

33−import Purelint.Rules.RedundantIf (redundantIfRule)

34−import Purelint.Rules.RedundantNot (redundantNotRule)

35−import Purelint.Rules.UseAll (useAllRule)

36−import Purelint.Rules.UseAny (useAnyRule)

37−import Purelint.Rules.UseConst (useConstRule)

38−import Purelint.Rules.UseFold (useFoldRule)

39−import Purelint.Rules.UseFromMaybe (useFromMaybeRule)

40−import Purelint.Rules.UseFstSnd (useFstSndRule)

41−import Purelint.Rules.UseGuard (useGuardRule)

42−import Purelint.Rules.UseIsJust (useIsJustRule)

43−import Purelint.Rules.UseIsNothing (useIsNothingRule)

44−import Purelint.Rules.UseJoin (useJoinRule)

45−import Purelint.Rules.UseMinMax (useMinMaxRule)

46−import Purelint.Rules.UseNotElem (useNotElemRule)

47−import Purelint.Rules.UseNull (useNullRule)

48−import Purelint.Rules.UseSequence (useSequenceRule)

49−import Purelint.Rules.UseTraverse (useTraverseRule)

50−import Purelint.Rules.UseTraverseSequence (useTraverseSequenceRule)

51−import Purelint.Rules.UseUnless (useUnlessRule)

52−import Purelint.Rules.UseUnwrap (useUnwrapRule)

53−import Purelint.Rules.UseVoid (useVoidRule)

54−import Purelint.Rules.UseWhen (useWhenRule)

55−import Purelint.Rules.UseMapMaybe (useMapMaybeRule)

56−import Purelint.Rules.UseGuardMaybe (useGuardMaybeRule)

57−import Purelint.Rules.UseMaybeMap (useMaybeMapRule)

58−import Purelint.Rules.UseApplicative (useApplicativeRule)

59−import Purelint.Rules.UseApplyFlipped (useApplyFlippedRule)

60−import Purelint.Rules.UseBindFlip (useBindFlipRule)

61−import Purelint.Rules.UseFor (useForRule)

62−import Purelint.Rules.RedundantGuard (redundantGuardRule)

63−import Purelint.Rules.UseComparing (useComparingRule)

64−import Purelint.Rules.UseOn (useOnRule)

65−import Purelint.Rules.UseFindMap (useFindMapRule)

66−import Purelint.Rules.UseLastReverse (useLastReverseRule)

67−import Purelint.Rules.RedundantReverse (redundantReverseRule)

68−import Purelint.Rules.UseBreak (useBreakRule)

69−import Purelint.Rules.UseSpan (useSpanRule)

70−import Purelint.Rules.UseMinimumSort (useMinimumSortRule)

71−import Purelint.Rules.UseBimap (useBimapRule)

72−import Purelint.Rules.UseDollar (useDollarRule)

73−import Purelint.Rules.UseEitherMap (useEitherMapRule)

74−import Purelint.Rules.AlternativeLaw (alternativeLawRule)

75−import Purelint.Rules.EvaluateBool (evaluateBoolRule)

76−import Purelint.Rules.EvaluateConst (evaluateConstRule)

77−import Purelint.Rules.EvaluateEither (evaluateEitherRule)

78−import Purelint.Rules.EvaluateFst (evaluateFstRule)

79−import Purelint.Rules.UseOr (useOrRule)

80−import Purelint.Rules.UseAnd (useAndRule)

81−import Purelint.Rules.UseFoldMap (useFoldMapRule)

82−import Purelint.Rules.UseFoldMapId (useFoldMapIdRule)

83−import Purelint.Rules.WhenNot (whenNotRule)

84−import Purelint.Rules.UnlessNot (unlessNotRule)

85−import Purelint.Rules.UseZip (useZipRule)

86−import Purelint.Rules.UseReplicate (useReplicateRule)

87−import Purelint.Rules.UseUncurry (useUncurryRule)

88−import Purelint.Rules.RedundantNegate (redundantNegateRule)

89−import Purelint.Rules.UseFromJust (useFromJustRule)

90−import Purelint.Rules.UseHead (useHeadRule)

91−import Purelint.Rules.RedundantId (redundantIdRule)

92−import Purelint.Rules.NothingBind (nothingBindRule)

93−import Purelint.Rules.UseElemIndex (useElemIndexRule)

94−import Purelint.Rules.UseFoldBool (useFoldBoolRule)

95−import Purelint.Rules.UsePatternGuards (usePatternGuardsRule)

96−import Purelint.Rules.UseCaseOf (useCaseOfRule)

97−import Purelint.Rules.FlattenCase (flattenCaseRule)

98−import Purelint.Rules.RedundantParens (redundantParensRule)

99−import Purelint.Runner (runRules)

100−import Purelint.Types (LintResult(..), LintWarning(..), RuleId(..), Severity(..), SourceCode(..), Suggestion(..))

16+import Purslint.Config (Config, defaultConfig, filterRules)

17+import Purslint.Rule (Rule)

18+import Purslint.Rules.BooleanSimplify (booleanSimplifyRule)

19+import Purslint.Rules.CollapseLambdas (collapseLambdasRule)

20+import Purslint.Rules.ConcatMap (concatMapRule)

21+import Purslint.Rules.EtaReduce (etaReduceRule)

22+import Purslint.Rules.EtaReduceDecl (etaReduceDeclRule)

23+import Purslint.Rules.MapIdentity (mapIdentityRule)

24+import Purslint.Rules.FunctorLaw (functorLawRule)

25+import Purslint.Rules.LetToDo (letToDoRule)

26+import Purslint.Rules.LetToWhere (letToWhereRule)

27+import Purslint.Rules.MapFusion (mapFusionRule)

28+import Purslint.Rules.MonadLaw (monadLawRule)

29+import Purslint.Rules.MonoidIdentity (monoidIdentityRule)

30+import Purslint.Rules.NotEqual (notEqualRule)

31+import Purslint.Rules.RedundantBind (redundantBindRule)

32+import Purslint.Rules.RedundantFlip (redundantFlipRule)

33+import Purslint.Rules.RedundantIf (redundantIfRule)

34+import Purslint.Rules.RedundantNot (redundantNotRule)

35+import Purslint.Rules.UseAll (useAllRule)

36+import Purslint.Rules.UseAny (useAnyRule)

37+import Purslint.Rules.UseConst (useConstRule)

38+import Purslint.Rules.UseFold (useFoldRule)

39+import Purslint.Rules.UseFromMaybe (useFromMaybeRule)

40+import Purslint.Rules.UseFstSnd (useFstSndRule)

41+import Purslint.Rules.UseGuard (useGuardRule)

42+import Purslint.Rules.UseIsJust (useIsJustRule)

43+import Purslint.Rules.UseIsNothing (useIsNothingRule)

44+import Purslint.Rules.UseJoin (useJoinRule)

45+import Purslint.Rules.UseMinMax (useMinMaxRule)

46+import Purslint.Rules.UseNotElem (useNotElemRule)

47+import Purslint.Rules.UseNull (useNullRule)

48+import Purslint.Rules.UseSequence (useSequenceRule)

49+import Purslint.Rules.UseTraverse (useTraverseRule)

50+import Purslint.Rules.UseTraverseSequence (useTraverseSequenceRule)

51+import Purslint.Rules.UseUnless (useUnlessRule)

52+import Purslint.Rules.UseUnwrap (useUnwrapRule)

53+import Purslint.Rules.UseVoid (useVoidRule)

54+import Purslint.Rules.UseWhen (useWhenRule)

55+import Purslint.Rules.UseMapMaybe (useMapMaybeRule)

56+import Purslint.Rules.UseGuardMaybe (useGuardMaybeRule)

57+import Purslint.Rules.UseMaybeMap (useMaybeMapRule)

58+import Purslint.Rules.UseApplicative (useApplicativeRule)

59+import Purslint.Rules.UseApplyFlipped (useApplyFlippedRule)

60+import Purslint.Rules.UseBindFlip (useBindFlipRule)

61+import Purslint.Rules.UseFor (useForRule)

62+import Purslint.Rules.RedundantGuard (redundantGuardRule)

63+import Purslint.Rules.UseComparing (useComparingRule)

64+import Purslint.Rules.UseOn (useOnRule)

65+import Purslint.Rules.UseFindMap (useFindMapRule)

66+import Purslint.Rules.UseLastReverse (useLastReverseRule)

67+import Purslint.Rules.RedundantReverse (redundantReverseRule)

68+import Purslint.Rules.UseBreak (useBreakRule)

69+import Purslint.Rules.UseSpan (useSpanRule)

70+import Purslint.Rules.UseMinimumSort (useMinimumSortRule)

71+import Purslint.Rules.UseBimap (useBimapRule)

72+import Purslint.Rules.UseDollar (useDollarRule)

73+import Purslint.Rules.UseEitherMap (useEitherMapRule)

74+import Purslint.Rules.AlternativeLaw (alternativeLawRule)

75+import Purslint.Rules.EvaluateBool (evaluateBoolRule)

76+import Purslint.Rules.EvaluateConst (evaluateConstRule)

77+import Purslint.Rules.EvaluateEither (evaluateEitherRule)

78+import Purslint.Rules.EvaluateFst (evaluateFstRule)

79+import Purslint.Rules.UseOr (useOrRule)

80+import Purslint.Rules.UseAnd (useAndRule)

81+import Purslint.Rules.UseFoldMap (useFoldMapRule)

82+import Purslint.Rules.UseFoldMapId (useFoldMapIdRule)

83+import Purslint.Rules.WhenNot (whenNotRule)

84+import Purslint.Rules.UnlessNot (unlessNotRule)

85+import Purslint.Rules.UseZip (useZipRule)

86+import Purslint.Rules.UseReplicate (useReplicateRule)

87+import Purslint.Rules.UseUncurry (useUncurryRule)

88+import Purslint.Rules.RedundantNegate (redundantNegateRule)

89+import Purslint.Rules.UseFromJust (useFromJustRule)

90+import Purslint.Rules.UseHead (useHeadRule)

91+import Purslint.Rules.RedundantId (redundantIdRule)

92+import Purslint.Rules.NothingBind (nothingBindRule)

93+import Purslint.Rules.UseElemIndex (useElemIndexRule)

94+import Purslint.Rules.UseFoldBool (useFoldBoolRule)

95+import Purslint.Rules.UsePatternGuards (usePatternGuardsRule)

96+import Purslint.Rules.UseCaseOf (useCaseOfRule)

97+import Purslint.Rules.FlattenCase (flattenCaseRule)

98+import Purslint.Rules.RedundantParens (redundantParensRule)

99+import Purslint.Runner (runRules)

100+import Purslint.Types (LintResult(..), LintWarning(..), RuleId(..), Severity(..), SourceCode(..), Suggestion(..))

101101import Unsafe.Coerce (unsafeCoerce)

102102

103103-- | All available rules

@@ -208,7 +208,7 @@ warningToDiagnostic (LintWarning w) =

208208 base =

209209 { range: range

210210 , severity: severityToLSP w.severity

211− , source: "purelint"

211+ , source: "purslint"

212212 , message: unwrap w.ruleId <> ": " <> unwrap w.message

213213 }

214214 in case w.suggestion of

@@ -216,7 +216,7 @@ warningToDiagnostic (LintWarning w) =

216216 Just (Suggestion sug) -> unsafeCoerce

217217 { range: range

218218 , severity: severityToLSP w.severity

219− , source: "purelint"

219+ , source: "purslint"

220220 , message: unwrap w.ruleId <> ": " <> unwrap w.message

221221 , data:

222222 { hasFix: true

@@ -273,7 +273,7 @@ mkInitializeResponse reqId =

273273 }

274274 }

275275 , serverInfo:

276− { name: "purelint-lsp"

276+ { name: "purslint-lsp"

277277 , version: "0.1.0"

278278 }

279279 }

@@ -334,32 +334,32 @@ foreign import hasKey :: String -> Foreign -> Boolean

334334foreign import getKey :: String -> Foreign -> Foreign

335335

336336-- | Parse settings to get disabled rules

337−-- | Expected format: { "purelint": { "disabledRules": ["RuleId1", "RuleId2"] } }

338−-- | Or: { "purelint.disabledRules": ["RuleId1", "RuleId2"] }

339−-- | Or: { "purelint.enabled": false } to disable all rules

337+-- | Expected format: { "purslint": { "disabledRules": ["RuleId1", "RuleId2"] } }

338+-- | Or: { "purslint.disabledRules": ["RuleId1", "RuleId2"] }

339+-- | Or: { "purslint.enabled": false } to disable all rules

340340parseSettings :: Foreign -> Config

341341parseSettings settings =

342− -- Try to get purelint.enabled first

343− case getFieldObj "purelint" settings of

344− Just purelintObj ->

342+ -- Try to get purslint.enabled first

343+ case getFieldObj "purslint" settings of

344+ Just purslintObj ->

345345 -- Check if all rules are disabled

346− case getFieldBool "enabled" purelintObj of

346+ case getFieldBool "enabled" purslintObj of

347347 Just false ->

348348 { disabledRules: map (\r -> r.ruleId) allRules } -- Disable all rules

349349 _ ->

350350 -- Get disabled rules list

351− case getFieldArr "disabledRules" purelintObj of

351+ case getFieldArr "disabledRules" purslintObj of

352352 Just arr ->

353353 { disabledRules: Array.mapMaybe parseRuleId arr }

354354 Nothing -> defaultConfig

355355 Nothing ->

356− -- Try flat format: purelint.disabledRules

357− case getFieldArr "purelint.disabledRules" settings of

356+ -- Try flat format: purslint.disabledRules

357+ case getFieldArr "purslint.disabledRules" settings of

358358 Just arr ->

359359 { disabledRules: Array.mapMaybe parseRuleId arr }

360360 Nothing ->

361− -- Try purelint.enabled

362− case getFieldBool "purelint.enabled" settings of

361+ -- Try purslint.enabled

362+ case getFieldBool "purslint.enabled" settings of

363363 Just false ->

364364 { disabledRules: map (\r -> r.ruleId) allRules }

365365 _ -> defaultConfig

@@ -616,7 +616,7 @@ mkDisableRuleAction ruleId diagnostic =

616616 , isPreferred: false

617617 , command:

618618 { title: "Disable rule " <> ruleId

619− , command: "purelint.disableRule"

619+ , command: "purslint.disableRule"

620620 , arguments: [ruleId]

621621 }

622622 }

@@ -644,7 +644,7 @@ mainLoop stateRef = do

644644

645645main :: Effect Unit

646646main = do

647− Stdio.logMessage "purelint-lsp starting..."

647+ Stdio.logMessage "purslint-lsp starting..."

648648 stateRef <- Ref.new { config: defaultConfig, documents: Map.empty }

649649 mainLoop stateRef

650− Stdio.logMessage "purelint-lsp exiting"

650+ Stdio.logMessage "purslint-lsp exiting"

bin/purelint-lsp/src/LSP/Stdio.js → bin/purslint-lsp/src/LSP/Stdio.jsrenamed+1−1

@@ -74,7 +74,7 @@ export const writeMessage = (msg) => () => {

7474

7575// Log a message to stderr (for debugging)

7676export const logMessage = (msg) => () => {

77− process.stderr.write('[purelint-lsp] ' + msg + '\n');

77+ process.stderr.write('[purslint-lsp] ' + msg + '\n');

7878};

7979

8080// Parse JSON string to Foreign (returns Maybe Foreign)

bin/purelint-lsp/src/LSP/Stdio.purs → bin/purslint-lsp/src/LSP/Stdio.pursrenamed

The content is the same.

bin/purelint-lsp/src/Main.purs → bin/purslint-lsp/src/Main.pursrenamed+1−1

@@ -2,7 +2,7 @@ module Main.LSP where

33import Prelude

44import Effect (Effect)

5−import Purelint.LSP as LSP

5+import Purslint.LSP as LSP

77main :: Effect Unit

88main = LSP.main

bin/purslint.jsnew file+2

@@ -0,0 +1,2 @@

1+#!/usr/bin/env node

2+import "../dist/purslint.js";

demo.gifnew file

Binary file not shown.

docs/IMPORT_CHECKING_PLAN.md+8−8

@@ -6,7 +6,7 @@ Make lint rules safer by verifying that identifiers like `map`, `identity`, `<$>

77## Current State

9−- `Purelint.Imports` module exists with:

9+- `Purslint.Imports` module exists with:

1010 - `getImportInfo :: Module Void -> ImportInfo` - extracts import info from a module

1111 - `hasValue :: ImportInfo -> String -> Boolean` - check if a value is imported

1212 - `hasOp :: ImportInfo -> String -> Boolean` - check if an operator is imported

@@ -18,7 +18,7 @@ Make lint rules safer by verifying that identifiers like `map`, `identity`, `<$>

1818### Step 1: Update Rule type to receive ImportInfo

1919

2020```purescript

21−-- In Purelint/Rule.purs

21+-- In Purslint/Rule.purs

2222type RuleContext =

2323 { imports :: ImportInfo

2424 }

@@ -34,7 +34,7 @@ mkRule :: RuleId -> (RuleContext -> Module Void -> Array LintWarning) -> Rule

3434### Step 2: Update Runner to pass context

3535

3636```purescript

37−-- In Purelint/Runner.purs

37+-- In Purslint/Runner.purs

3838runRules :: Array Rule -> SourceCode -> Either String LintResult

3939runRules rules (SourceCode source) = do

4040 mod <- parseModule source

@@ -96,11 +96,11 @@ All rules that check for specific identifiers:

9696

9797## Files to Modify

9898

99−1. `lib/purelint/src/Purelint/Rule.purs` - Add RuleContext

100−2. `lib/purelint/src/Purelint/Runner.purs` - Pass context to rules

101−3. `lib/purelint/src/Purelint/Rules/*.purs` - All 9 rule files

102−4. `bin/purelint-cli/src/Main.purs` - No changes needed (uses Runner)

103−5. `bin/purelint-lsp/src/LSP.purs` - No changes needed (uses Runner)

99+1. `lib/purslint/src/Purslint/Rule.purs` - Add RuleContext

100+2. `lib/purslint/src/Purslint/Runner.purs` - Pass context to rules

101+3. `lib/purslint/src/Purslint/Rules/*.purs` - All 9 rule files

102+4. `bin/purslint-cli/src/Main.purs` - No changes needed (uses Runner)

103+5. `bin/purslint-lsp/src/LSP.purs` - No changes needed (uses Runner)

104104

105105## Testing

106106

lib/purelint/spago.yaml → lib/purslint/spago.yamlrenamed+1−1

@@ -1,5 +1,5 @@

11package:

2− name: purelint

2+ name: purslint

33 dependencies:

44 - arrays

55 - effect

lib/purelint/src/Purelint/Config.purs → lib/purslint/src/Purslint/Config.pursrenamed+2−2

@@ -1,11 +1,11 @@

1−module Purelint.Config where

1+module Purslint.Config where

33import Prelude

55import Data.Array (notElem)

66import Data.Array as Array

77import Data.String as String

8−import Purelint.Types (RuleId(..))

8+import Purslint.Types (RuleId(..))

1010-- | Parsed config - just enabled/disabled rules for now

1111type Config =

lib/purelint/src/Purelint/Fix.purs → lib/purslint/src/Purslint/Fix.pursrenamed+15−12

@@ -1,4 +1,4 @@

1−module Purelint.Fix where

1+module Purslint.Fix where

33import Prelude

@@ -10,8 +10,8 @@ import Data.Newtype (un, unwrap)

1010import Data.String as String

1111import Data.String.CodeUnits as StringCU

1212import PureScript.CST.Types (SourceRange)

13−import Purelint.Types (LintResult(..), LintWarning(..), ReplacementText(..), Suggestion(..))

14−import Purelint.ImportFix (processImports)

13+import Purslint.Types (LintResult(..), LintWarning(..), ReplacementText(..), Suggestion(..))

14+import Purslint.ImportFix (processImports)

1515

1616-- | Extract text at a source range from source code

1717extractRange :: String -> SourceRange -> String

@@ -71,8 +71,9 @@ applyFix :: String -> LintWarning -> Maybe String

7171applyFix source (LintWarning w) = do

7272 Suggestion s <- w.suggestion

7373 let replacement = s.replacement # un ReplacementText

74− let { source: updatedSource, replacement: updatedReplacement, linesAdded } =

75− processImports source replacement s.requiredImports

74+ let

75+ { source: updatedSource, replacement: updatedReplacement, linesAdded } =

76+ processImports source replacement s.requiredImports

7677 let shiftedRange = shiftRange linesAdded w.range

7778 Just $ replaceRange updatedSource shiftedRange updatedReplacement

7879

@@ -101,13 +102,15 @@ applyAllFixes source (LintResult result) =

101102 else case w.suggestion of

102103 Nothing -> acc

103104 Just (Suggestion s) ->

104− let replacement = s.replacement # un ReplacementText

105− importResult = processImports acc.source replacement s.requiredImports

106− shiftedRange = shiftRange importResult.linesAdded w.range

107− updatedSource = replaceRange importResult.source shiftedRange importResult.replacement

108− in { source: updatedSource

109− , appliedRanges: Array.cons shiftedRange acc.appliedRanges

110− }

105+ let

106+ replacement = s.replacement # un ReplacementText

107+ importResult = processImports acc.source replacement s.requiredImports

108+ shiftedRange = shiftRange importResult.linesAdded w.range

109+ updatedSource = replaceRange importResult.source shiftedRange importResult.replacement

110+ in

111+ { source: updatedSource

112+ , appliedRanges: Array.cons shiftedRange acc.appliedRanges

113+ }

111114

112115 -- Check if two ranges overlap

113116 overlaps :: SourceRange -> SourceRange -> Boolean

lib/purelint/src/Purelint/ImportFix.purs → lib/purslint/src/Purslint/ImportFix.pursrenamed+5−8

@@ -1,11 +1,8 @@

1−module Purelint.ImportFix where

2−

3−import Prelude

1+module Purslint.ImportFix where

53import Data.Maybe (Maybe)

6−import PureScript.CST.Types (SourceToken)

7−

8−-- [TODO]: This got lost, I'm not sure what it should do

4+-- NOTE: Import processing is currently a no-op. We assume required imports

5+-- are already present in the source and keep replacements intact.

96processImports :: String -> String -> Array

107 { codeText :: Maybe String

118 , importItem :: Maybe String

@@ -16,5 +13,5 @@ processImports :: String -> String -> Array

1613 , replacement :: String

1714 , source :: String

1815 }

19−processImports source replacement imports = do

20− { linesAdded: 0, replacement: "", source: source }

16+processImports source replacement _imports =

17+ { linesAdded: 0, replacement, source }

lib/purelint/src/Purelint/Imports.purs → lib/purslint/src/Purslint/Imports.pursrenamed+1−1

@@ -1,4 +1,4 @@

1−module Purelint.Imports where

1+module Purslint.Imports where

33import Prelude

lib/purelint/src/Purelint/Print.purs → lib/purslint/src/Purslint/Print.pursrenamed+1−1

@@ -1,4 +1,4 @@

1−module Purelint.Print where

1+module Purslint.Print where

33import Prelude

lib/purelint/src/Purelint/Rule.purs → lib/purslint/src/Purslint/Rule.pursrenamed+3−3

@@ -1,9 +1,9 @@

1−module Purelint.Rule where

1+module Purslint.Rule where

33import Prelude

5−import Purelint.Imports (ImportInfo)

6−import Purelint.Types (LintWarning, RuleId)

5+import Purslint.Imports (ImportInfo)

6+import Purslint.Types (LintWarning, RuleId)

77import PureScript.CST.Types (Module)

88import Data.Void (Void)

lib/purelint/src/Purelint/Rules/AlternativeLaw.purs → lib/purslint/src/Purslint/Rules/AlternativeLaw.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.AlternativeLaw where

1+module Purslint.Rules.AlternativeLaw where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

8−import Purelint.Imports (ImportInfo, hasValue, hasOp)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue, hasOp)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Proper(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/BooleanSimplify.purs → lib/purslint/src/Purslint/Rules/BooleanSimplify.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.BooleanSimplify where

1+module Purslint.Rules.BooleanSimplify where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (Expr(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/CollapseLambdas.purs → lib/purslint/src/Purslint/Rules/CollapseLambdas.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.CollapseLambdas where

1+module Purslint.Rules.CollapseLambdas where

33import Prelude

@@ -6,9 +6,9 @@ import Data.Array as Array

66import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

88import Data.String as String

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (Binder(..), Expr(..), Ident(..), Module, Name(..))

lib/purelint/src/Purelint/Rules/ConcatMap.purs → lib/purslint/src/Purslint/Rules/ConcatMap.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.ConcatMap where

1+module Purslint.Rules.ConcatMap where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/EtaReduce.purs → lib/purslint/src/Purslint/Rules/EtaReduce.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.EtaReduce where

1+module Purslint.Rules.EtaReduce where

33import Prelude

55import Data.Array as Array

66import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Binder(..), Expr(..), Ident(..), Module, Name(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/EtaReduceDecl.purs → lib/purslint/src/Purslint/Rules/EtaReduceDecl.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.EtaReduceDecl where

1+module Purslint.Rules.EtaReduceDecl where

33import Prelude

@@ -7,9 +7,9 @@ import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

88import Data.String as String

99import Data.Void (Void)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types as CST

lib/purelint/src/Purelint/Rules/EvaluateBool.purs → lib/purslint/src/Purslint/Rules/EvaluateBool.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.EvaluateBool where

1+module Purslint.Rules.EvaluateBool where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

8−import Purelint.Imports (ImportInfo, hasOp)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasOp)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (Expr(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/EvaluateConst.purs → lib/purslint/src/Purslint/Rules/EvaluateConst.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.EvaluateConst where

1+module Purslint.Rules.EvaluateConst where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/EvaluateEither.purs → lib/purslint/src/Purslint/Rules/EvaluateEither.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.EvaluateEither where

1+module Purslint.Rules.EvaluateEither where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Proper(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/EvaluateFst.purs → lib/purslint/src/Purslint/Rules/EvaluateFst.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.EvaluateFst where

1+module Purslint.Rules.EvaluateFst where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Proper(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/FlattenCase.purs → lib/purslint/src/Purslint/Rules/FlattenCase.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.FlattenCase where

1+module Purslint.Rules.FlattenCase where

33import Prelude

@@ -8,9 +8,9 @@ import Data.Maybe (Maybe(..))

88import Data.String as String

99import Data.Tuple (Tuple(..))

1010import Data.Void (Void)

11−import Purelint.Print (printBinder, printExpr)

12−import Purelint.Rule (Rule, RuleContext, mkRule)

13−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

11+import Purslint.Print (printBinder, printExpr)

12+import Purslint.Rule (Rule, RuleContext, mkRule)

13+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1414import PureScript.CST.Range (rangeOf)

1515import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1616import PureScript.CST.Types (Binder(..), Expr(..), Guarded(..), Module, Separated(..), Where(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/FunctorLaw.purs → lib/purslint/src/Purslint/Rules/FunctorLaw.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.FunctorLaw where

1+module Purslint.Rules.FunctorLaw where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/LetToDo.purs → lib/purslint/src/Purslint/Rules/LetToDo.pursrenamed+3−3

@@ -1,4 +1,4 @@

1−module Purelint.Rules.LetToDo where

1+module Purslint.Rules.LetToDo where

33import Prelude

@@ -11,8 +11,8 @@ import Data.String (joinWith) as String

1111import Data.String as Str

1212import Data.Tuple.Nested ((/\))

1313import Data.Void (Void, absurd)

14−import Purelint.Rule (Rule, RuleContext, mkRule)

15−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

14+import Purslint.Rule (Rule, RuleContext, mkRule)

15+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1616import PureScript.CST.Print (printToken)

1717import PureScript.CST.Range (rangeOf, tokensOf)

1818import PureScript.CST.Range.TokenList as TokenList

lib/purelint/src/Purelint/Rules/LetToWhere.purs → lib/purslint/src/Purslint/Rules/LetToWhere.pursrenamed+3−3

@@ -1,4 +1,4 @@

1−module Purelint.Rules.LetToWhere where

1+module Purslint.Rules.LetToWhere where

33import Prelude

@@ -10,8 +10,8 @@ import Data.Monoid (power)

1010import Data.String (joinWith) as String

1111import Data.String as Str

1212import Data.Tuple.Nested ((/\))

13−import Purelint.Rule (Rule, RuleContext, mkRule)

14−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

13+import Purslint.Rule (Rule, RuleContext, mkRule)

14+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1515import PureScript.CST.Print (printToken)

1616import PureScript.CST.Range (class RangeOf, rangeOf, tokensOf)

1717import PureScript.CST.Range.TokenList as TokenList

lib/purelint/src/Purelint/Rules/MapFusion.purs → lib/purslint/src/Purslint/Rules/MapFusion.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.MapFusion where

1+module Purslint.Rules.MapFusion where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/MapIdentity.purs → lib/purslint/src/Purslint/Rules/MapIdentity.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.MapIdentity where

1+module Purslint.Rules.MapIdentity where

33import Prelude

@@ -7,10 +7,10 @@ import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

88import Data.Tuple (Tuple(..))

99import Data.Void (Void)

10−import Purelint.Imports (ImportInfo, hasValue, hasOp)

11−import Purelint.Print (printExpr)

12−import Purelint.Rule (Rule, RuleContext, mkRule)

13−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

10+import Purslint.Imports (ImportInfo, hasValue, hasOp)

11+import Purslint.Print (printExpr)

12+import Purslint.Rule (Rule, RuleContext, mkRule)

13+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1414import PureScript.CST.Range (rangeOf)

1515import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1616import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/MonadLaw.purs → lib/purslint/src/Purslint/Rules/MonadLaw.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.MonadLaw where

1+module Purslint.Rules.MonadLaw where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

8−import Purelint.Imports (ImportInfo, hasValue, hasOp)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue, hasOp)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/MonoidIdentity.purs → lib/purslint/src/Purslint/Rules/MonoidIdentity.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.MonoidIdentity where

1+module Purslint.Rules.MonoidIdentity where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/NotEqual.purs → lib/purslint/src/Purslint/Rules/NotEqual.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.NotEqual where

1+module Purslint.Rules.NotEqual where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

8−import Purelint.Imports (ImportInfo, hasValue, hasOp)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue, hasOp)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/NothingBind.purs → lib/purslint/src/Purslint/Rules/NothingBind.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.NothingBind where

1+module Purslint.Rules.NothingBind where

33import Prelude

@@ -6,9 +6,9 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasOp)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasOp)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (Expr(..), Ident(..), Module, Operator(..), Proper(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantBind.purs → lib/purslint/src/Purslint/Rules/RedundantBind.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.RedundantBind where

1+module Purslint.Rules.RedundantBind where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

8−import Purelint.Imports (ImportInfo, hasValue, hasOp)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue, hasOp)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/RedundantFlip.purs → lib/purslint/src/Purslint/Rules/RedundantFlip.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.RedundantFlip where

1+module Purslint.Rules.RedundantFlip where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantGuard.purs → lib/purslint/src/Purslint/Rules/RedundantGuard.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.RedundantGuard where

1+module Purslint.Rules.RedundantGuard where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantId.purs → lib/purslint/src/Purslint/Rules/RedundantId.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.RedundantId where

1+module Purslint.Rules.RedundantId where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantIf.purs → lib/purslint/src/Purslint/Rules/RedundantIf.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.RedundantIf where

1+module Purslint.Rules.RedundantIf where

33import Prelude

55import Data.Maybe (Maybe(..))

66import Data.Void (Void)

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (Expr(..), Module)

lib/purelint/src/Purelint/Rules/RedundantNegate.purs → lib/purslint/src/Purslint/Rules/RedundantNegate.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.RedundantNegate where

1+module Purslint.Rules.RedundantNegate where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantNot.purs → lib/purslint/src/Purslint/Rules/RedundantNot.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.RedundantNot where

1+module Purslint.Rules.RedundantNot where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantParens.purs → lib/purslint/src/Purslint/Rules/RedundantParens.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.RedundantParens where

1+module Purslint.Rules.RedundantParens where

33import Prelude

@@ -7,9 +7,9 @@ import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

88import Data.Tuple (snd)

99import Data.Tuple.Nested ((/\))

10−import Purelint.Print (printBinder, printExpr, printType)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

10+import Purslint.Print (printBinder, printExpr, printType)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Binder(..), Declaration(..), DoStatement(..), Expr(..), Guarded(..), GuardedExpr(..), Labeled(..), LetBinding(..), Module, RecordLabeled(..), Row(..), Separated(..), Type(..), ValueBindingFields, Where(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/RedundantReverse.purs → lib/purslint/src/Purslint/Rules/RedundantReverse.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.RedundantReverse where

1+module Purslint.Rules.RedundantReverse where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UnlessNot.purs → lib/purslint/src/Purslint/Rules/UnlessNot.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UnlessNot where

1+module Purslint.Rules.UnlessNot where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseAll.purs → lib/purslint/src/Purslint/Rules/UseAll.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseAll where

1+module Purslint.Rules.UseAll where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseAnd.purs → lib/purslint/src/Purslint/Rules/UseAnd.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseAnd where

1+module Purslint.Rules.UseAnd where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseAny.purs → lib/purslint/src/Purslint/Rules/UseAny.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseAny where

1+module Purslint.Rules.UseAny where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseApplicative.purs → lib/purslint/src/Purslint/Rules/UseApplicative.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseApplicative where

1+module Purslint.Rules.UseApplicative where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseApplyFlipped.purs → lib/purslint/src/Purslint/Rules/UseApplyFlipped.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseApplyFlipped where

1+module Purslint.Rules.UseApplyFlipped where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Print (printExprNoComments)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Print (printExprNoComments)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Module, Wrapped(..))

lib/purelint/src/Purelint/Rules/UseBimap.purs → lib/purslint/src/Purslint/Rules/UseBimap.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseBimap where

1+module Purslint.Rules.UseBimap where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseBindFlip.purs → lib/purslint/src/Purslint/Rules/UseBindFlip.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseBindFlip where

1+module Purslint.Rules.UseBindFlip where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseBreak.purs → lib/purslint/src/Purslint/Rules/UseBreak.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseBreak where

1+module Purslint.Rules.UseBreak where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseCaseOf.purs → lib/purslint/src/Purslint/Rules/UseCaseOf.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseCaseOf where

1+module Purslint.Rules.UseCaseOf where

33import Prelude

@@ -11,9 +11,9 @@ import Data.String as String

1111import Data.Tuple (Tuple(..))

1212import Data.Tuple.Nested ((/\))

1313import Data.Void (Void, absurd)

14−import Purelint.Print (printBinder, printExpr)

15−import Purelint.Rule (Rule, RuleContext, mkRule)

16−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

14+import Purslint.Print (printBinder, printExpr)

15+import Purslint.Rule (Rule, RuleContext, mkRule)

16+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1717import PureScript.CST.Print (printToken)

1818import PureScript.CST.Range (rangeOf, tokensOf)

1919import PureScript.CST.Range.TokenList as TokenList

lib/purelint/src/Purelint/Rules/UseComparing.purs → lib/purslint/src/Purslint/Rules/UseComparing.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseComparing where

1+module Purslint.Rules.UseComparing where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Binder(..), Expr(..), Ident(..), Module, Name(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseConst.purs → lib/purslint/src/Purslint/Rules/UseConst.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseConst where

1+module Purslint.Rules.UseConst where

33import Prelude

@@ -8,10 +8,10 @@ import Data.Maybe (Maybe(..))

88import Data.Monoid (power)

99import Data.String as String

1010import Data.Void (Void)

11−import Purelint.Imports (ImportInfo, hasValue)

12−import Purelint.Print (printExpr, printExprMultiline)

13−import Purelint.Rule (Rule, RuleContext, mkRule)

14−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

11+import Purslint.Imports (ImportInfo, hasValue)

12+import Purslint.Print (printExpr, printExprMultiline)

13+import Purslint.Rule (Rule, RuleContext, mkRule)

14+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1515import PureScript.CST.Range (rangeOf)

1616import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1717import PureScript.CST.Types (Binder(..), Expr(..), Module)

lib/purelint/src/Purelint/Rules/UseDollar.purs → lib/purslint/src/Purslint/Rules/UseDollar.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseDollar where

1+module Purslint.Rules.UseDollar where

33import Prelude

55import Data.Array as Array

66import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

8−import Purelint.Print (printExpr, printType)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Print (printExpr, printType)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Module, Wrapped(..))

lib/purelint/src/Purelint/Rules/UseEitherMap.purs → lib/purslint/src/Purslint/Rules/UseEitherMap.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseEitherMap where

1+module Purslint.Rules.UseEitherMap where

33import Prelude

@@ -10,10 +10,10 @@ import Data.Void (Void)

1010import PureScript.CST.Range (rangeOf)

1111import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1212import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

13−import Purelint.Imports (ImportInfo, hasValue)

14−import Purelint.Print (printExpr)

15−import Purelint.Rule (Rule, RuleContext, mkRule)

16−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

13+import Purslint.Imports (ImportInfo, hasValue)

14+import Purslint.Print (printExpr)

15+import Purslint.Rule (Rule, RuleContext, mkRule)

16+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1717

1818-- | Rule: either Left (Right <<< f) -> map f

1919useEitherMapRule :: Rule

lib/purelint/src/Purelint/Rules/UseElemIndex.purs → lib/purslint/src/Purslint/Rules/UseElemIndex.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseElemIndex where

1+module Purslint.Rules.UseElemIndex where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Binder(..), Expr(..), Ident(..), Module, Name(..), Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseFindMap.purs → lib/purslint/src/Purslint/Rules/UseFindMap.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseFindMap where

1+module Purslint.Rules.UseFindMap where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseFold.purs → lib/purslint/src/Purslint/Rules/UseFold.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseFold where

1+module Purslint.Rules.UseFold where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseFoldBool.purs → lib/purslint/src/Purslint/Rules/UseFoldBool.pursrenamed+4−4

@@ -1,12 +1,12 @@

1−module Purelint.Rules.UseFoldBool where

1+module Purslint.Rules.UseFoldBool where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Rule (Rule, RuleContext, mkRule)

9−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Rule (Rule, RuleContext, mkRule)

9+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1010import PureScript.CST.Range (rangeOf)

1111import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1212import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseFoldMap.purs → lib/purslint/src/Purslint/Rules/UseFoldMap.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseFoldMap where

1+module Purslint.Rules.UseFoldMap where

33import Prelude

@@ -9,9 +9,9 @@ import Data.Monoid (power)

99import Data.Tuple (Tuple, snd)

1010import Data.Tuple.Nested ((/\))

1111import Data.String as String

12−import Purelint.Print (printExpr, printExprMultiline)

13−import Purelint.Rule (Rule, RuleContext, mkRule)

14−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

12+import Purslint.Print (printExpr, printExprMultiline)

13+import Purslint.Rule (Rule, RuleContext, mkRule)

14+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1515import PureScript.CST.Range (rangeOf)

1616import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1717import PureScript.CST.Types (Binder(..), Expr(..), Guarded(..), Ident(..), Module, Name(..), Proper(..), QualifiedName(..), Separated(..), Where(..), Wrapped(..), AppSpine(..))

lib/purelint/src/Purelint/Rules/UseFoldMapId.purs → lib/purslint/src/Purslint/Rules/UseFoldMapId.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseFoldMapId where

1+module Purslint.Rules.UseFoldMapId where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseFor.purs → lib/purslint/src/Purslint/Rules/UseFor.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseFor where

1+module Purslint.Rules.UseFor where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseFromJust.purs → lib/purslint/src/Purslint/Rules/UseFromJust.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseFromJust where

1+module Purslint.Rules.UseFromJust where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Proper(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseFromMaybe.purs → lib/purslint/src/Purslint/Rules/UseFromMaybe.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseFromMaybe where

1+module Purslint.Rules.UseFromMaybe where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseFstSnd.purs → lib/purslint/src/Purslint/Rules/UseFstSnd.pursrenamed+3−3

@@ -1,12 +1,12 @@

1−module Purelint.Rules.UseFstSnd where

1+module Purslint.Rules.UseFstSnd where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Rule (Rule, RuleContext, mkRule)

9−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Rule (Rule, RuleContext, mkRule)

9+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1010import PureScript.CST.Range (rangeOf)

1111import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1212import PureScript.CST.Types (Binder(..), Expr(..), Ident(..), Module, Name(..), Proper(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseGuard.purs → lib/purslint/src/Purslint/Rules/UseGuard.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseGuard where

1+module Purslint.Rules.UseGuard where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseGuardMaybe.purs → lib/purslint/src/Purslint/Rules/UseGuardMaybe.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseGuardMaybe where

1+module Purslint.Rules.UseGuardMaybe where

33import Prelude

55import Data.Maybe (Maybe(..))

66import Data.Void (Void)

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseHead.purs → lib/purslint/src/Purslint/Rules/UseHead.pursrenamed+4−4

@@ -1,12 +1,12 @@

1−module Purelint.Rules.UseHead where

1+module Purslint.Rules.UseHead where

33import Prelude

55import Data.Maybe (Maybe(..))

66import Data.Void (Void)

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Rule (Rule, RuleContext, mkRule)

9−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Rule (Rule, RuleContext, mkRule)

9+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1010import PureScript.CST.Range (rangeOf)

1111import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1212import PureScript.CST.Types (Expr(..), Ident(..), IntValue(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseIsJust.purs → lib/purslint/src/Purslint/Rules/UseIsJust.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseIsJust where

1+module Purslint.Rules.UseIsJust where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseIsNothing.purs → lib/purslint/src/Purslint/Rules/UseIsNothing.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseIsNothing where

1+module Purslint.Rules.UseIsNothing where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseJoin.purs → lib/purslint/src/Purslint/Rules/UseJoin.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseJoin where

1+module Purslint.Rules.UseJoin where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseLastReverse.purs → lib/purslint/src/Purslint/Rules/UseLastReverse.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseLastReverse where

1+module Purslint.Rules.UseLastReverse where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseMapMaybe.purs → lib/purslint/src/Purslint/Rules/UseMapMaybe.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseMapMaybe where

1+module Purslint.Rules.UseMapMaybe where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseMaybeMap.purs → lib/purslint/src/Purslint/Rules/UseMaybeMap.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseMaybeMap where

1+module Purslint.Rules.UseMaybeMap where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseMinMax.purs → lib/purslint/src/Purslint/Rules/UseMinMax.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseMinMax where

1+module Purslint.Rules.UseMinMax where

33import Prelude

55import Data.Maybe (Maybe(..))

66import Data.Void (Void)

7−import Purelint.Imports (ImportInfo, hasOp)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasOp)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseMinimumSort.purs → lib/purslint/src/Purslint/Rules/UseMinimumSort.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseMinimumSort where

1+module Purslint.Rules.UseMinimumSort where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseNotElem.purs → lib/purslint/src/Purslint/Rules/UseNotElem.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseNotElem where

1+module Purslint.Rules.UseNotElem where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseNull.purs → lib/purslint/src/Purslint/Rules/UseNull.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseNull where

1+module Purslint.Rules.UseNull where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), IntValue(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseOn.purs → lib/purslint/src/Purslint/Rules/UseOn.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseOn where

1+module Purslint.Rules.UseOn where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Binder(..), Expr(..), Ident(..), Module, Name(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseOr.purs → lib/purslint/src/Purslint/Rules/UseOr.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseOr where

1+module Purslint.Rules.UseOr where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UsePatternGuards.purs → lib/purslint/src/Purslint/Rules/UsePatternGuards.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UsePatternGuards where

1+module Purslint.Rules.UsePatternGuards where

33import Prelude

@@ -15,9 +15,9 @@ import PureScript.CST.Range (rangeOf, tokensOf)

1515import PureScript.CST.Range.TokenList as TokenList

1616import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1717import PureScript.CST.Types (Binder(..), Expr(..), Guarded(..), GuardedExpr(..), Module, PatternGuard(..), Separated(..), Where(..), Wrapped(..))

18−import Purelint.Print (printBinder, printExpr, printExprMultiline)

19−import Purelint.Rule (Rule, RuleContext, mkRule)

20−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

18+import Purslint.Print (printBinder, printExpr, printExprMultiline)

19+import Purslint.Rule (Rule, RuleContext, mkRule)

20+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

2121

2222-- | Rule: Nested case expressions with single match + fallback can use pattern guards

2323-- |

lib/purelint/src/Purelint/Rules/UseReplicate.purs → lib/purslint/src/Purslint/Rules/UseReplicate.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseReplicate where

1+module Purslint.Rules.UseReplicate where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseSequence.purs → lib/purslint/src/Purslint/Rules/UseSequence.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseSequence where

1+module Purslint.Rules.UseSequence where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseSpan.purs → lib/purslint/src/Purslint/Rules/UseSpan.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseSpan where

1+module Purslint.Rules.UseSpan where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseTraverse.purs → lib/purslint/src/Purslint/Rules/UseTraverse.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseTraverse where

1+module Purslint.Rules.UseTraverse where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array as Array

66import Data.Array.NonEmpty as NEA

77import Data.Maybe (Maybe(..))

88import Data.Tuple (Tuple(..))

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseTraverseSequence.purs → lib/purslint/src/Purslint/Rules/UseTraverseSequence.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseTraverseSequence where

1+module Purslint.Rules.UseTraverseSequence where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseUncurry.purs → lib/purslint/src/Purslint/Rules/UseUncurry.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseUncurry where

1+module Purslint.Rules.UseUncurry where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Proper(..), QualifiedName(..), Separated(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/UseUnless.purs → lib/purslint/src/Purslint/Rules/UseUnless.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseUnless where

1+module Purslint.Rules.UseUnless where

33import Prelude

55import Data.Maybe (Maybe(..))

66import Data.Void (Void)

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseUnwrap.purs → lib/purslint/src/Purslint/Rules/UseUnwrap.pursrenamed+4−4

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseUnwrap where

1+module Purslint.Rules.UseUnwrap where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseVoid.purs → lib/purslint/src/Purslint/Rules/UseVoid.pursrenamed+5−5

@@ -1,4 +1,4 @@

1−module Purelint.Rules.UseVoid where

1+module Purslint.Rules.UseVoid where

33import Prelude

@@ -6,10 +6,10 @@ import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Tuple (Tuple(..))

88import Data.Void (Void)

9−import Purelint.Imports (ImportInfo, hasValue, hasOp)

10−import Purelint.Print (printExpr)

11−import Purelint.Rule (Rule, RuleContext, mkRule)

12−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

9+import Purslint.Imports (ImportInfo, hasValue, hasOp)

10+import Purslint.Print (printExpr)

11+import Purslint.Rule (Rule, RuleContext, mkRule)

12+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1313import PureScript.CST.Range (rangeOf)

1414import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1515import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Operator(..), QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseWhen.purs → lib/purslint/src/Purslint/Rules/UseWhen.pursrenamed+5−5

@@ -1,13 +1,13 @@

1−module Purelint.Rules.UseWhen where

1+module Purslint.Rules.UseWhen where

33import Prelude

55import Data.Maybe (Maybe(..))

66import Data.Void (Void)

7−import Purelint.Imports (ImportInfo, hasValue)

8−import Purelint.Print (printExpr)

9−import Purelint.Rule (Rule, RuleContext, mkRule)

10−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

7+import Purslint.Imports (ImportInfo, hasValue)

8+import Purslint.Print (printExpr)

9+import Purslint.Rule (Rule, RuleContext, mkRule)

10+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1111import PureScript.CST.Range (rangeOf)

1212import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1313import PureScript.CST.Types (Expr(..), Ident(..), Module, QualifiedName(..))

lib/purelint/src/Purelint/Rules/UseZip.purs → lib/purslint/src/Purslint/Rules/UseZip.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.UseZip where

1+module Purslint.Rules.UseZip where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, Proper(..), QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Rules/WhenNot.purs → lib/purslint/src/Purslint/Rules/WhenNot.pursrenamed+5−5

@@ -1,14 +1,14 @@

1−module Purelint.Rules.WhenNot where

1+module Purslint.Rules.WhenNot where

33import Prelude

55import Data.Array.NonEmpty as NEA

66import Data.Maybe (Maybe(..))

77import Data.Void (Void)

8−import Purelint.Imports (ImportInfo, hasValue)

9−import Purelint.Print (printExpr)

10−import Purelint.Rule (Rule, RuleContext, mkRule)

11−import Purelint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

8+import Purslint.Imports (ImportInfo, hasValue)

9+import Purslint.Print (printExpr)

10+import Purslint.Rule (Rule, RuleContext, mkRule)

11+import Purslint.Types (LintWarning(..), RuleId(..), Severity(..), Suggestion(..), SuggestionDescription(..), ReplacementText(..), WarningMessage(..))

1212import PureScript.CST.Range (rangeOf)

1313import PureScript.CST.Traversal (defaultMonoidalVisitor, foldMapModule)

1414import PureScript.CST.Types (AppSpine(..), Expr(..), Ident(..), Module, QualifiedName(..), Wrapped(..))

lib/purelint/src/Purelint/Runner.purs → lib/purslint/src/Purslint/Runner.pursrenamed+4−4

@@ -1,4 +1,4 @@

1−module Purelint.Runner where

1+module Purslint.Runner where

33import Prelude

@@ -8,9 +8,9 @@ import Data.Newtype (un, unwrap)

88import PureScript.CST (RecoveredParserResult(..), parseModule)

99import PureScript.CST.Errors (printParseError)

1010import PureScript.CST.Types (ImportDecl(..), Module(..), ModuleHeader(..), ModuleName(..), Name(..))

11−import Purelint.Imports (getImportInfo, ImportInfo)

12−import Purelint.Rule (Rule, RuleContext)

13−import Purelint.Types (LintResult(..), SourceCode(..))

11+import Purslint.Imports (getImportInfo, ImportInfo)

12+import Purslint.Rule (Rule, RuleContext)

13+import Purslint.Types (LintResult(..), SourceCode(..))

1414import Unsafe.Coerce (unsafeCoerce)

1515

1616-- | Run a set of rules on source code

lib/purelint/src/Purelint/Tidy.js → lib/purslint/src/Purslint/Tidy.jsrenamed

The content is the same.

lib/purelint/src/Purelint/Tidy.purs → lib/purslint/src/Purslint/Tidy.pursrenamed+1−1

@@ -1,4 +1,4 @@

1−module Purelint.Tidy where

1+module Purslint.Tidy where

33import Prelude

lib/purelint/src/Purelint/Types.purs → lib/purslint/src/Purslint/Types.pursrenamed+1−1

@@ -1,4 +1,4 @@

1−module Purelint.Types where

1+module Purslint.Types where

33import Prelude

package.json+22−7

@@ -1,18 +1,18 @@

11{

2− "name": "purelint",

2+ "name": "purslint",

33 "version": "0.1.0",

44 "description": "A linter for PureScript",

55 "type": "module",

66 "bin": {

7− "purelint": "./dist/purelint.js",

8− "purelint-lsp": "./dist/purelint-lsp.js"

7+ "purslint": "./bin/purslint.js",

8+ "purslint-lsp": "./bin/purslint-lsp.js"

99 },

1010 "scripts": {

11− "build:cli": "spago build -p purelint-cli --output output-cli",

12− "build:lsp": "spago build -p purelint-lsp --output output-lsp",

11+ "build:cli": "spago build -p purslint-cli --output output-cli",

12+ "build:lsp": "spago build -p purslint-lsp --output output-lsp",

1313 "build": "npm run build:cli && npm run build:lsp",

14− "bundle:cli": "purs-backend-es bundle-app --corefn-dir output-cli --main Main --platform node --to dist/purelint.js --int-tags",

15− "bundle:lsp": "purs-backend-es bundle-app --corefn-dir output-lsp --main Main.LSP --platform node --to dist/purelint-lsp.js --int-tags",

14+ "bundle:cli": "purs-backend-es bundle-app --corefn-dir output-cli --main Main --platform node --to dist/purslint.js --int-tags",

15+ "bundle:lsp": "purs-backend-es bundle-app --corefn-dir output-lsp --main Main.LSP --platform node --to dist/purslint-lsp.js --int-tags",

1616 "bundle": "npm run bundle:cli && npm run bundle:lsp",

1717 "dist": "npm run build && npm run bundle",

1818 "test": "spago test",

@@ -24,11 +24,26 @@

2424 "purescript",

2525 "linter"

2626 ],

27+ "repository": {

28+ "type": "git",

29+ "url": "https://github.com/rowtype-yoga/purslint"

30+ },

31+ "homepage": "https://github.com/rowtype-yoga/purslint",

32+ "bugs": {

33+ "url": "https://github.com/rowtype-yoga/purslint/issues"

34+ },

35+ "files": [

36+ "bin",

37+ "dist",

38+ "README.md",

39+ "package.json"

40+ ],

2741 "license": "MIT",

2842 "dependencies": {

2943 "spago": "^0.93.45"

3044 },

3145 "devDependencies": {

46+ "esbuild": "^0.27.2",

3247 "purs-backend-es": "^1.4.3"

3348 }

3449}

purelint-lspdeleted−2

@@ -1,2 +0,0 @@

1−#!/bin/bash

2−exec node /Users/mark/Developer/purelint/dist/purelint-lsp.js "$@"

purslint-lspnew file+2

@@ -0,0 +1,2 @@

1+#!/bin/bash

2+exec node "$(cd "$(dirname "$0")" && pwd)/dist/purslint-lsp.js" "$@"

spago.lock+94−13

@@ -1,8 +1,8 @@

11{

22 "workspace": {

33 "packages": {

4− "purelint": {

5− "path": "lib/purelint",

4+ "purslint": {

5+ "path": "lib/purslint",

66 "core": {

77 "dependencies": [

88 "arrays",

@@ -69,8 +69,8 @@

6969 "build_plan": []

7070 }

7171 },

72− "purelint-cli": {

73− "path": "bin/purelint-cli",

72+ "purslint-cli": {

73+ "path": "bin/purslint-cli",

7474 "core": {

7575 "dependencies": [

7676 "arrays",

@@ -83,8 +83,9 @@

8383 "node-buffer",

8484 "node-fs",

8585 "node-process",

86+ "optparse",

8687 "prelude",

87− "purelint",

88+ "purslint",

8889 "strings"

8990 ],

9091 "build_plan": [

@@ -104,6 +105,7 @@

104105 "enums",

105106 "exceptions",

106107 "exists",

108+ "exitcodes",

107109 "foldable-traversable",

108110 "foreign",

109111 "foreign-object",

@@ -130,6 +132,8 @@

130132 "now",

131133 "nullable",

132134 "numbers",

135+ "open-memoize",

136+ "optparse",

133137 "ordered-collections",

134138 "orders",

135139 "parallel",

@@ -137,7 +141,7 @@

137141 "posix-types",

138142 "prelude",

139143 "profunctor",

140− "purelint",

144+ "purslint",

141145 "refs",

142146 "safe-coerce",

143147 "st",

@@ -156,8 +160,8 @@

156160 "build_plan": []

157161 }

158162 },

159− "purelint-lsp": {

160− "path": "bin/purelint-lsp",

163+ "purslint-lsp": {

164+ "path": "bin/purslint-lsp",

161165 "core": {

162166 "dependencies": [

163167 "arrays",

@@ -167,7 +171,7 @@

167171 "maybe",

168172 "newtype",

169173 "prelude",

170− "purelint",

174+ "purslint",

171175 "unsafe-coerce"

172176 ],

173177 "build_plan": [

@@ -204,7 +208,7 @@

204208 "partial",

205209 "prelude",

206210 "profunctor",

207− "purelint",

211+ "purslint",

208212 "refs",

209213 "safe-coerce",

210214 "st",

@@ -223,7 +227,7 @@

223227 "build_plan": []

224228 }

225229 },

226− "purelint-tests": {

230+ "purslint-tests": {

227231 "path": "./",

228232 "core": {

229233 "dependencies": [

@@ -233,10 +237,13 @@

233237 "either",

234238 "maybe",

235239 "newtype",

240+ "optparse",

236241 "prelude",

237− "purelint"

242+ "purslint"

238243 ],

239244 "build_plan": [

245+ "aff",

246+ "arraybuffer-types",

240247 "arrays",

241248 "bifunctors",

242249 "catenable-lists",

@@ -244,13 +251,17 @@

244251 "const",

245252 "contravariant",

246253 "control",

254+ "datetime",

247255 "distributive",

248256 "effect",

249257 "either",

250258 "enums",

251259 "exceptions",

252260 "exists",

261+ "exitcodes",

253262 "foldable-traversable",

263+ "foreign",

264+ "foreign-object",

254265 "free",

255266 "functions",

256267 "functors",

@@ -263,14 +274,23 @@

263274 "lists",

264275 "maybe",

265276 "newtype",

277+ "node-buffer",

278+ "node-event-emitter",

279+ "node-process",

280+ "node-streams",

266281 "nonempty",

282+ "nullable",

267283 "numbers",

284+ "open-memoize",

285+ "optparse",

268286 "ordered-collections",

269287 "orders",

288+ "parallel",

270289 "partial",

290+ "posix-types",

271291 "prelude",

272292 "profunctor",

273− "purelint",

293+ "purslint",

274294 "refs",

275295 "safe-coerce",

276296 "st",

@@ -1075,6 +1095,14 @@

10751095 "unsafe-coerce"

10761096 ]

10771097 },

1098+ "exitcodes": {

1099+ "type": "registry",

1100+ "version": "4.0.0",

1101+ "integrity": "sha256-4wxViTbyOoyKJ/WaRGI6+hZmgMKI5Miv16lSwefiLSM=",

1102+ "dependencies": [

1103+ "enums"

1104+ ]

1105+ },

10781106 "foldable-traversable": {

10791107 "type": "registry",

10801108 "version": "6.0.0",

@@ -1458,6 +1486,59 @@

14581486 "maybe"

14591487 ]

14601488 },

1489+ "open-memoize": {

1490+ "type": "registry",

1491+ "version": "6.2.0",

1492+ "integrity": "sha256-p1m7wF3aHQ80yUvqMs20OTMl496WS6YpKlmI2Nkg9j0=",

1493+ "dependencies": [

1494+ "either",

1495+ "integers",

1496+ "lazy",

1497+ "lists",

1498+ "maybe",

1499+ "partial",

1500+ "prelude",

1501+ "strings",

1502+ "tuples"

1503+ ]

1504+ },

1505+ "optparse": {

1506+ "type": "registry",

1507+ "version": "5.0.1",

1508+ "integrity": "sha256-cEzEkNW4q0gZlXl4z0zn+H2vs6l2UAp7NPHCsois73k=",

1509+ "dependencies": [

1510+ "aff",

1511+ "arrays",

1512+ "bifunctors",

1513+ "console",

1514+ "control",

1515+ "effect",

1516+ "either",

1517+ "enums",

1518+ "exists",

1519+ "exitcodes",

1520+ "foldable-traversable",

1521+ "free",

1522+ "gen",

1523+ "integers",

1524+ "lazy",

1525+ "lists",

1526+ "maybe",

1527+ "newtype",

1528+ "node-buffer",

1529+ "node-process",

1530+ "node-streams",

1531+ "nonempty",

1532+ "numbers",

1533+ "open-memoize",

1534+ "partial",

1535+ "prelude",

1536+ "strings",

1537+ "tailrec",

1538+ "transformers",

1539+ "tuples"

1540+ ]

1541+ },

14611542 "ordered-collections": {

14621543 "type": "registry",

14631544 "version": "3.2.0",

spago.yaml+3−2

@@ -4,15 +4,16 @@ workspace:

44 extraPackages: {}

66package:

7− name: purelint-tests

7+ name: purslint-tests

88 dependencies:

99 - console

1010 - effect

1111 - either

1212 - maybe

1313 - newtype

14+ - optparse

1415 - prelude

15− - purelint

16+ - purslint

1617 - arrays

1718 test:

1819 main: Test.Main

test/Test/Main.purs+253−86

@@ -10,91 +10,93 @@ import Data.Newtype (unwrap)

1010import Data.Traversable (traverse)

1111import Effect (Effect)

1212import Effect.Class.Console (log)

13−import Purelint.Fix (applyAllFixes)

14−import Purelint.Tidy (formatExpr, formatModule)

15−import Purelint.Rules.MapIdentity (mapIdentityRule)

16−import Purelint.Rules.MapFusion (mapFusionRule)

17−import Purelint.Rules.UseTraverse (useTraverseRule)

18−import Purelint.Rules.ConcatMap (concatMapRule)

19−import Purelint.Rules.NotEqual (notEqualRule)

20−import Purelint.Rules.UseGuard (useGuardRule)

21−import Purelint.Rules.EtaReduce (etaReduceRule)

22−import Purelint.Rules.EtaReduceDecl (etaReduceDeclRule)

23−import Purelint.Rules.RedundantBind (redundantBindRule)

24−import Purelint.Rules.LetToWhere (letToWhereRule)

25−import Purelint.Rules.LetToDo (letToDoRule)

26−import Purelint.Rules.RedundantIf (redundantIfRule)

27−import Purelint.Rules.FunctorLaw (functorLawRule)

28−import Purelint.Rules.UseVoid (useVoidRule)

29−import Purelint.Rules.UseJoin (useJoinRule)

30−import Purelint.Rules.UseAny (useAnyRule)

31−import Purelint.Rules.UseAll (useAllRule)

32−import Purelint.Rules.BooleanSimplify (booleanSimplifyRule)

33−import Purelint.Rules.CollapseLambdas (collapseLambdasRule)

34−import Purelint.Rules.UseConst (useConstRule)

35−import Purelint.Rules.UseNull (useNullRule)

36−import Purelint.Rules.UseFromMaybe (useFromMaybeRule)

37−import Purelint.Rules.UseIsJust (useIsJustRule)

38−import Purelint.Rules.UseIsNothing (useIsNothingRule)

39−import Purelint.Rules.UseWhen (useWhenRule)

40−import Purelint.Rules.UseUnless (useUnlessRule)

41−import Purelint.Rules.RedundantFlip (redundantFlipRule)

42−import Purelint.Rules.UseNotElem (useNotElemRule)

43−import Purelint.Rules.UseMinMax (useMinMaxRule)

44−import Purelint.Rules.MonoidIdentity (monoidIdentityRule)

45−import Purelint.Rules.UseFold (useFoldRule)

46−import Purelint.Rules.UseSequence (useSequenceRule)

47−import Purelint.Rules.UseTraverseSequence (useTraverseSequenceRule)

48−import Purelint.Rules.RedundantNot (redundantNotRule)

49−import Purelint.Rules.UseFstSnd (useFstSndRule)

50−import Purelint.Rules.UseMapMaybe (useMapMaybeRule)

51−import Purelint.Rules.UseGuardMaybe (useGuardMaybeRule)

52−import Purelint.Rules.UseMaybeMap (useMaybeMapRule)

53−import Purelint.Rules.UseApplicative (useApplicativeRule)

54−import Purelint.Rules.UseBindFlip (useBindFlipRule)

55−import Purelint.Rules.UseFor (useForRule)

56−import Purelint.Rules.RedundantGuard (redundantGuardRule)

57−import Purelint.Rules.UseComparing (useComparingRule)

58−import Purelint.Rules.UseOn (useOnRule)

59−import Purelint.Rules.UseFindMap (useFindMapRule)

60−import Purelint.Rules.UseLastReverse (useLastReverseRule)

61−import Purelint.Rules.RedundantReverse (redundantReverseRule)

62−import Purelint.Rules.UseBreak (useBreakRule)

63−import Purelint.Rules.UseSpan (useSpanRule)

64−import Purelint.Rules.UseMinimumSort (useMinimumSortRule)

65−import Purelint.Rules.UseBimap (useBimapRule)

66−import Purelint.Rules.UseEitherMap (useEitherMapRule)

67−import Purelint.Rules.EvaluateFst (evaluateFstRule)

68−import Purelint.Rules.EvaluateConst (evaluateConstRule)

69−import Purelint.Rules.UseOr (useOrRule)

70−import Purelint.Rules.UseAnd (useAndRule)

71−import Purelint.Rules.UseFoldMap (useFoldMapRule)

72−import Purelint.Rules.UseFoldMapId (useFoldMapIdRule)

73−import Purelint.Rules.UseApplyFlipped (useApplyFlippedRule)

74−import Purelint.Rules.WhenNot (whenNotRule)

75−import Purelint.Rules.UnlessNot (unlessNotRule)

76−import Purelint.Rules.UseZip (useZipRule)

77−import Purelint.Rules.UseReplicate (useReplicateRule)

78−import Purelint.Rules.UseUncurry (useUncurryRule)

79−import Purelint.Rules.RedundantNegate (redundantNegateRule)

80−import Purelint.Rules.UseFromJust (useFromJustRule)

81−import Purelint.Rules.UseHead (useHeadRule)

82−import Purelint.Rules.RedundantId (redundantIdRule)

83−import Purelint.Rules.NothingBind (nothingBindRule)

84−import Purelint.Rules.UseElemIndex (useElemIndexRule)

85−import Purelint.Rules.MonadLaw (monadLawRule)

86−import Purelint.Rules.EvaluateBool (evaluateBoolRule)

87−import Purelint.Rules.UseFoldBool (useFoldBoolRule)

88−import Purelint.Rules.AlternativeLaw (alternativeLawRule)

89−import Purelint.Rules.EvaluateEither (evaluateEitherRule)

90−import Purelint.Rules.UseCaseOf (useCaseOfRule)

91−import Purelint.Rules.FlattenCase (flattenCaseRule)

92−import Purelint.Rules.UsePatternGuards (usePatternGuardsRule)

93−import Purelint.Rules.RedundantParens (redundantParensRule)

94−import Purelint.Rule (Rule)

95−import Purelint.Runner (runRules, getImportsFromSource, getModuleNames)

96−import Purelint.Imports (hasValue, isPreludeModule)

97−import Purelint.Types (LintResult(..), LintWarning(..), RuleId(..), SourceCode(..), Suggestion(..))

13+import Purslint.Fix (applyAllFixes)

14+import Purslint.Tidy (formatExpr, formatModule)

15+import Purslint.Rules.MapIdentity (mapIdentityRule)

16+import Purslint.Rules.MapFusion (mapFusionRule)

17+import Purslint.Rules.UseTraverse (useTraverseRule)

18+import Purslint.Rules.ConcatMap (concatMapRule)

19+import Purslint.Rules.NotEqual (notEqualRule)

20+import Purslint.Rules.UseGuard (useGuardRule)

21+import Purslint.Rules.EtaReduce (etaReduceRule)

22+import Purslint.Rules.EtaReduceDecl (etaReduceDeclRule)

23+import Purslint.Rules.RedundantBind (redundantBindRule)

24+import Purslint.Rules.LetToWhere (letToWhereRule)

25+import Purslint.Rules.LetToDo (letToDoRule)

26+import Purslint.Rules.RedundantIf (redundantIfRule)

27+import Purslint.Rules.FunctorLaw (functorLawRule)

28+import Purslint.Rules.UseVoid (useVoidRule)

29+import Purslint.Rules.UseJoin (useJoinRule)

30+import Purslint.Rules.UseAny (useAnyRule)

31+import Purslint.Rules.UseAll (useAllRule)

32+import Purslint.Rules.BooleanSimplify (booleanSimplifyRule)

33+import Purslint.Rules.CollapseLambdas (collapseLambdasRule)

34+import Purslint.Rules.UseConst (useConstRule)

35+import Purslint.Rules.UseDollar (useDollarRule)

36+import Purslint.Rules.UseNull (useNullRule)

37+import Purslint.Rules.UseFromMaybe (useFromMaybeRule)

38+import Purslint.Rules.UseIsJust (useIsJustRule)

39+import Purslint.Rules.UseIsNothing (useIsNothingRule)

40+import Purslint.Rules.UseWhen (useWhenRule)

41+import Purslint.Rules.UseUnless (useUnlessRule)

42+import Purslint.Rules.RedundantFlip (redundantFlipRule)

43+import Purslint.Rules.UseNotElem (useNotElemRule)

44+import Purslint.Rules.UseMinMax (useMinMaxRule)

45+import Purslint.Rules.MonoidIdentity (monoidIdentityRule)

46+import Purslint.Rules.UseFold (useFoldRule)

47+import Purslint.Rules.UseSequence (useSequenceRule)

48+import Purslint.Rules.UseTraverseSequence (useTraverseSequenceRule)

49+import Purslint.Rules.RedundantNot (redundantNotRule)

50+import Purslint.Rules.UseFstSnd (useFstSndRule)

51+import Purslint.Rules.UseMapMaybe (useMapMaybeRule)

52+import Purslint.Rules.UseGuardMaybe (useGuardMaybeRule)

53+import Purslint.Rules.UseMaybeMap (useMaybeMapRule)

54+import Purslint.Rules.UseApplicative (useApplicativeRule)

55+import Purslint.Rules.UseBindFlip (useBindFlipRule)

56+import Purslint.Rules.UseFor (useForRule)

57+import Purslint.Rules.UseUnwrap (useUnwrapRule)

58+import Purslint.Rules.RedundantGuard (redundantGuardRule)

59+import Purslint.Rules.UseComparing (useComparingRule)

60+import Purslint.Rules.UseOn (useOnRule)

61+import Purslint.Rules.UseFindMap (useFindMapRule)

62+import Purslint.Rules.UseLastReverse (useLastReverseRule)

63+import Purslint.Rules.RedundantReverse (redundantReverseRule)

64+import Purslint.Rules.UseBreak (useBreakRule)

65+import Purslint.Rules.UseSpan (useSpanRule)

66+import Purslint.Rules.UseMinimumSort (useMinimumSortRule)

67+import Purslint.Rules.UseBimap (useBimapRule)

68+import Purslint.Rules.UseEitherMap (useEitherMapRule)

69+import Purslint.Rules.EvaluateFst (evaluateFstRule)

70+import Purslint.Rules.EvaluateConst (evaluateConstRule)

71+import Purslint.Rules.UseOr (useOrRule)

72+import Purslint.Rules.UseAnd (useAndRule)

73+import Purslint.Rules.UseFoldMap (useFoldMapRule)

74+import Purslint.Rules.UseFoldMapId (useFoldMapIdRule)

75+import Purslint.Rules.UseApplyFlipped (useApplyFlippedRule)

76+import Purslint.Rules.WhenNot (whenNotRule)

77+import Purslint.Rules.UnlessNot (unlessNotRule)

78+import Purslint.Rules.UseZip (useZipRule)

79+import Purslint.Rules.UseReplicate (useReplicateRule)

80+import Purslint.Rules.UseUncurry (useUncurryRule)

81+import Purslint.Rules.RedundantNegate (redundantNegateRule)

82+import Purslint.Rules.UseFromJust (useFromJustRule)

83+import Purslint.Rules.UseHead (useHeadRule)

84+import Purslint.Rules.RedundantId (redundantIdRule)

85+import Purslint.Rules.NothingBind (nothingBindRule)

86+import Purslint.Rules.UseElemIndex (useElemIndexRule)

87+import Purslint.Rules.MonadLaw (monadLawRule)

88+import Purslint.Rules.EvaluateBool (evaluateBoolRule)

89+import Purslint.Rules.UseFoldBool (useFoldBoolRule)

90+import Purslint.Rules.AlternativeLaw (alternativeLawRule)

91+import Purslint.Rules.EvaluateEither (evaluateEitherRule)

92+import Purslint.Rules.UseCaseOf (useCaseOfRule)

93+import Purslint.Rules.FlattenCase (flattenCaseRule)

94+import Purslint.Rules.UsePatternGuards (usePatternGuardsRule)

95+import Purslint.Rules.RedundantParens (redundantParensRule)

96+import Purslint.Rule (Rule)

97+import Purslint.Runner (runRules, getImportsFromSource, getModuleNames)

98+import Purslint.Imports (hasValue, isPreludeModule)

99+import Purslint.Types (LintResult(..), LintWarning(..), RuleId(..), SourceCode(..), Suggestion(..))

98100

99101-- | Simple test framework

100102type TestResult = { passed :: Boolean, name :: String, message :: String }

@@ -173,7 +175,7 @@ assertFixFormatted name rules source expectedFixed =

173175-- | Run all tests and report results

174176main :: Effect Unit

175177main = do

176− log "Running purelint tests...\n"

178+ log "Running purslint tests...\n"

177179

178180 let results = mapIdentityTests

179181 <> mapFusionTests

@@ -231,6 +233,15 @@ main = do

231233 <> whenNotTests

232234 <> unlessNotTests

233235 <> useZipTests

236+ <> useReplicateTests

237+ <> useUncurryTests

238+ <> useFromJustTests

239+ <> useHeadTests

240+ <> useElemIndexTests

241+ <> useBreakTests

242+ <> useSpanTests

243+ <> useDollarTests

244+ <> useUnwrapTests

234245 <> redundantNegateTests

235246 <> redundantIdTests

236247 <> nothingBindTests

@@ -1338,6 +1349,162 @@ useZipTests =

13381349 (withPrelude "x = zipWith Tuple [1] [2]") "zip [ 1 ] [ 2 ]"

13391350 ]

13401351

1352+-- ============================================================================

1353+-- UseReplicate Tests

1354+-- ============================================================================

1355+

1356+useReplicateTests :: Array TestResult

1357+useReplicateTests =

1358+ [ assertWarningCount "UseReplicate: take n (repeat x)" [useReplicateRule]

1359+ (withPrelude "x = take 3 (repeat 1)") 1

1360+ , assertRuleId "UseReplicate: correct rule id" [useReplicateRule]

1361+ (withPrelude "x = take 3 (repeat 1)") "UseReplicate"

1362+ , assertSuggestion "UseReplicate: suggests replicate" [useReplicateRule]

1363+ (withPrelude "x = take 3 (repeat 1)") "replicate 3 1"

1364+ , assertWarningCount "UseReplicate: no fire on take n xs" [useReplicateRule]

1365+ (withPrelude "x = take 3 xs") 0

1366+ , assertWarningCount "UseReplicate: no fire without import" [useReplicateRule]

1367+ (withoutImports "x = take 3 (repeat 1)") 0

1368+ ]

1369+

1370+-- ============================================================================

1371+-- UseUncurry Tests

1372+-- ============================================================================

1373+

1374+useUncurryTests :: Array TestResult

1375+useUncurryTests =

1376+ [ assertWarningCount "UseUncurry: f (fst p) (snd p)" [useUncurryRule]

1377+ (withPrelude "x = f (fst p) (snd p)") 1

1378+ , assertRuleId "UseUncurry: correct rule id" [useUncurryRule]

1379+ (withPrelude "x = f (fst p) (snd p)") "UseUncurry"

1380+ , assertSuggestion "UseUncurry: suggests uncurry" [useUncurryRule]

1381+ (withPrelude "x = f (fst p) (snd p)") "uncurry f p"

1382+ , assertWarningCount "UseUncurry: no fire on different args" [useUncurryRule]

1383+ (withPrelude "x = f (fst p) (snd q)") 0

1384+ , assertWarningCount "UseUncurry: no fire without import" [useUncurryRule]

1385+ (withoutImports "x = f (fst p) (snd p)") 0

1386+ ]

1387+

1388+-- ============================================================================

1389+-- UseFromJust Tests

1390+-- ============================================================================

1391+

1392+useFromJustTests :: Array TestResult

1393+useFromJustTests =

1394+ [ assertWarningCount "UseFromJust: fromMaybe d (Just x)" [useFromJustRule]

1395+ (withPrelude "x = fromMaybe 0 (Just 1)") 1

1396+ , assertRuleId "UseFromJust: correct rule id" [useFromJustRule]

1397+ (withPrelude "x = fromMaybe 0 (Just 1)") "UseFromJust"

1398+ , assertSuggestion "UseFromJust: simplifies Just" [useFromJustRule]

1399+ (withPrelude "x = fromMaybe 0 (Just 1)") "1"

1400+ , assertWarningCount "UseFromJust: fromMaybe d Nothing" [useFromJustRule]

1401+ (withPrelude "x = fromMaybe 0 Nothing") 1

1402+ , assertSuggestion "UseFromJust: simplifies Nothing" [useFromJustRule]

1403+ (withPrelude "x = fromMaybe 0 Nothing") "0"

1404+ , assertWarningCount "UseFromJust: no fire without import" [useFromJustRule]

1405+ (withoutImports "x = fromMaybe 0 (Just 1)") 0

1406+ ]

1407+

1408+-- ============================================================================

1409+-- UseHead Tests

1410+-- ============================================================================

1411+

1412+useHeadTests :: Array TestResult

1413+useHeadTests =

1414+ [ assertWarningCount "UseHead: xs !! 0" [useHeadRule]

1415+ (withPrelude "x = xs !! 0") 1

1416+ , assertRuleId "UseHead: correct rule id" [useHeadRule]

1417+ (withPrelude "x = xs !! 0") "UseHead"

1418+ , assertSuggestion "UseHead: suggests head" [useHeadRule]

1419+ (withPrelude "x = xs !! 0") "head"

1420+ , assertWarningCount "UseHead: no fire on xs !! 1" [useHeadRule]

1421+ (withPrelude "x = xs !! 1") 0

1422+ , assertWarningCount "UseHead: no fire without import" [useHeadRule]

1423+ (withoutImports "x = xs !! 0") 0

1424+ ]

1425+

1426+-- ============================================================================

1427+-- UseElemIndex Tests

1428+-- ============================================================================

1429+

1430+useElemIndexTests :: Array TestResult

1431+useElemIndexTests =

1432+ [ assertWarningCount "UseElemIndex: findIndex (\\x -> x == a) xs" [useElemIndexRule]

1433+ (withPrelude "x = findIndex (\\y -> y == a) xs") 1

1434+ , assertRuleId "UseElemIndex: correct rule id" [useElemIndexRule]

1435+ (withPrelude "x = findIndex (\\y -> y == a) xs") "UseElemIndex"

1436+ , assertSuggestion "UseElemIndex: suggests elemIndex" [useElemIndexRule]

1437+ (withPrelude "x = findIndex (\\y -> y == a) xs") "elemIndex a xs"

1438+ , assertWarningCount "UseElemIndex: no fire on other predicate" [useElemIndexRule]

1439+ (withPrelude "x = findIndex (\\y -> y > a) xs") 0

1440+ , assertWarningCount "UseElemIndex: no fire without import" [useElemIndexRule]

1441+ (withoutImports "x = findIndex (\\y -> y == a) xs") 0

1442+ ]

1443+

1444+-- ============================================================================

1445+-- UseBreak Tests

1446+-- ============================================================================

1447+

1448+useBreakTests :: Array TestResult

1449+useBreakTests =

1450+ [ assertWarningCount "UseBreak: span (not p) xs" [useBreakRule]

1451+ (withPrelude "x = span (not p) xs") 1

1452+ , assertRuleId "UseBreak: correct rule id" [useBreakRule]

1453+ (withPrelude "x = span (not p) xs") "UseBreak"

1454+ , assertSuggestion "UseBreak: suggests break" [useBreakRule]

1455+ (withPrelude "x = span (not p) xs") "break p xs"

1456+ , assertWarningCount "UseBreak: no fire without import" [useBreakRule]

1457+ (withoutImports "x = span (not p) xs") 0

1458+ ]

1459+

1460+-- ============================================================================

1461+-- UseSpan Tests

1462+-- ============================================================================

1463+

1464+useSpanTests :: Array TestResult

1465+useSpanTests =

1466+ [ assertWarningCount "UseSpan: break (not p) xs" [useSpanRule]

1467+ (withPrelude "x = break (not p) xs") 1

1468+ , assertRuleId "UseSpan: correct rule id" [useSpanRule]

1469+ (withPrelude "x = break (not p) xs") "UseSpan"

1470+ , assertSuggestion "UseSpan: suggests span" [useSpanRule]

1471+ (withPrelude "x = break (not p) xs") "span p xs"

1472+ , assertWarningCount "UseSpan: no fire without import" [useSpanRule]

1473+ (withoutImports "x = break (not p) xs") 0

1474+ ]

1475+

1476+-- ============================================================================

1477+-- UseDollar Tests

1478+-- ============================================================================

1479+

1480+useDollarTests :: Array TestResult

1481+useDollarTests =

1482+ [ assertWarningCount "UseDollar: map f (filter g xs)" [useDollarRule]

1483+ (withPrelude "x = map f (filter g xs)") 1

1484+ , assertRuleId "UseDollar: correct rule id" [useDollarRule]

1485+ (withPrelude "x = map f (filter g xs)") "UseDollar"

1486+ , assertSuggestion "UseDollar: suggests $" [useDollarRule]

1487+ (withPrelude "x = map f (filter g xs)") "map f $ filter g xs"

1488+ , assertWarningCount "UseDollar: no fire on atomic arg" [useDollarRule]

1489+ (withPrelude "x = f (1)") 0

1490+ ]

1491+

1492+-- ============================================================================

1493+-- UseUnwrap Tests

1494+-- ============================================================================

1495+

1496+useUnwrapTests :: Array TestResult

1497+useUnwrapTests =

1498+ [ assertRuleId "UseUnwrap: correct rule id" [useUnwrapRule]

1499+ (withPrelude "x = unwrap foo") "UseUnwrap"

1500+ , assertSuggestion "UseUnwrap: suggests un ?Constructor" [useUnwrapRule]

1501+ (withPrelude "x = unwrap foo") "un ?Constructor foo"

1502+ , assertWarningCount "UseUnwrap: unwrap partial" [useUnwrapRule]

1503+ (withPrelude "x = unwrap") 1

1504+ , assertSuggestion "UseUnwrap: unwrap partial suggestion" [useUnwrapRule]

1505+ (withPrelude "x = unwrap") "un ?Constructor"

1506+ ]

1507+

13411508-- ============================================================================

13421509-- RedundantNegate Tests

13431510-- ============================================================================

vscode-extension/out/extension.js+4−4

@@ -39,15 +39,15 @@ const vscode = __importStar(require("vscode"));

3939const node_1 = require("vscode-languageclient/node");

4040let client;

4141function activate(context) {

42− const config = vscode.workspace.getConfiguration('purelint');

42+ const config = vscode.workspace.getConfiguration('purslint');

4343 if (!config.get('enable', true)) {

4444 return;

4545 }

4646 // Get server path from config or use default

4747 let serverPath = config.get('serverPath', '');

4848 if (!serverPath) {

49− // Default to the purelint project location

50− serverPath = '/Users/mark/Developer/purelint/dist/purelint-lsp.js';

49+ // Default to the purslint project location

50+ serverPath = '/Users/mark/Developer/purslint/dist/purslint-lsp.js';

5151 }

5252 const serverOptions = {

5353 run: {

@@ -65,7 +65,7 @@ function activate(context) {

6565 fileEvents: vscode.workspace.createFileSystemWatcher('**/*.purs')

6666 }

6767 };

68− client = new node_1.LanguageClient('purelint', 'Purelint', serverOptions, clientOptions);

68+ client = new node_1.LanguageClient('purslint', 'Purslint', serverOptions, clientOptions);

6969 client.start();

7070}

7171function deactivate() {

vscode-extension/out/test/suite/extension.test.js+4−4

@@ -36,13 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });

3636const assert = __importStar(require("assert"));

3737const vscode = __importStar(require("vscode"));

3838const path = __importStar(require("path"));

39−suite('Purelint Extension Test Suite', () => {

39+suite('Purslint Extension Test Suite', () => {

4040 vscode.window.showInformationMessage('Start all tests.');

4141 test('Extension should be present', () => {

42− assert.ok(vscode.extensions.getExtension('purelint.purelint'));

42+ assert.ok(vscode.extensions.getExtension('RowtypeYoga.purslint'));

4343 });

4444 test('Extension should activate on PureScript file', async () => {

45− const ext = vscode.extensions.getExtension('purelint.purelint');

45+ const ext = vscode.extensions.getExtension('RowtypeYoga.purslint');

4646 assert.ok(ext);

4747 // Open a PureScript file to trigger activation

4848 const testFile = path.join(__dirname, '../../../test-workspace/Test.purs');

@@ -54,7 +54,7 @@ suite('Purelint Extension Test Suite', () => {

5454 assert.ok(ext.isActive);

5555 });

5656 test('Should provide code actions', async () => {

57− const ext = vscode.extensions.getExtension('purelint.purelint');

57+ const ext = vscode.extensions.getExtension('RowtypeYoga.purslint');

5858 if (!ext?.isActive) {

5959 await ext?.activate();

6060 }

vscode-extension/out/test/suite/extension.test.js.map+1−1

@@ -1 +1 @@

1−{"version":3,"file":"extension.test.js","sourceRoot":"","sources":["../../../src/test/suite/extension.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,+CAAiC;AACjC,2CAA6B;AAE7B,KAAK,CAAC,+BAA+B,EAAE,GAAG,EAAE;IAC1C,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,kBAAkB,CAAC,CAAC;IAEzD,IAAI,CAAC,6BAA6B,EAAE,GAAG,EAAE;QACvC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8CAA8C,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;QAChE,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAEf,+CAA+C;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAE1C,iCAAiC;QACjC,MAAM,GAAG,CAAC,QAAQ,EAAE,CAAC;QACrB,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,6BAA6B,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;QAChE,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC;YACnB,MAAM,GAAG,EAAE,QAAQ,EAAE,CAAC;QACxB,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAE1C,6CAA6C;QAC7C,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;QAExD,iDAAiD;QACjD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QAEvD,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,cAAc,CACtD,kCAAkC,EAClC,GAAG,CAAC,GAAG,EACP,KAAK,CACN,CAAC;QAEF,qEAAqE;QACrE,wCAAwC;QACxC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,WAAW,KAAK,SAAS,EAAE,kCAAkC,CAAC,CAAC;IACzG,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

1+{"version":3,"file":"extension.test.js","sourceRoot":"","sources":["../../../src/test/suite/extension.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,+CAAiC;AACjC,2CAA6B;AAE7B,KAAK,CAAC,+BAA+B,EAAE,GAAG,EAAE;IAC1C,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,kBAAkB,CAAC,CAAC;IAEzD,IAAI,CAAC,6BAA6B,EAAE,GAAG,EAAE;QACvC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8CAA8C,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;QACnE,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAEf,+CAA+C;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAE1C,iCAAiC;QACjC,MAAM,GAAG,CAAC,QAAQ,EAAE,CAAC;QACrB,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,6BAA6B,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;QACnE,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC;YACnB,MAAM,GAAG,EAAE,QAAQ,EAAE,CAAC;QACxB,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAE1C,6CAA6C;QAC7C,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;QAExD,iDAAiD;QACjD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QAEvD,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,cAAc,CACtD,kCAAkC,EAClC,GAAG,CAAC,GAAG,EACP,KAAK,CACN,CAAC;QAEF,qEAAqE;QACrE,wCAAwC;QACxC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,WAAW,KAAK,SAAS,EAAE,kCAAkC,CAAC,CAAC;IACzG,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

vscode-extension/package.json+10−9

@@ -1,9 +1,10 @@

11{

2− "name": "purelint",

3− "displayName": "Purelint",

2+ "name": "purslint",

3+ "displayName": "Purslint",

44 "description": "PureScript linter inspired by hlint",

5− "version": "0.1.0",

6− "publisher": "purelint",

5+ "version": "0.1.1",

6+ "publisher": "RowtypeYoga",

7+ "icon": "purslint.png",

78 "engines": {

89 "vscode": "^1.85.0"

910 },

@@ -18,17 +19,17 @@

1819 "contributes": {

1920 "configuration": {

2021 "type": "object",

21− "title": "Purelint",

22+ "title": "Purslint",

2223 "properties": {

23− "purelint.enable": {

24+ "purslint.enable": {

2425 "type": "boolean",

2526 "default": true,

26− "description": "Enable/disable purelint"

27+ "description": "Enable/disable purslint"

2728 },

28− "purelint.serverPath": {

29+ "purslint.serverPath": {

2930 "type": "string",

3031 "default": "",

31− "description": "Path to purelint-lsp executable (uses bundled version if empty)"

32+ "description": "Path to purslint-lsp executable (uses bundled version if empty)"

3233 }

3334 }

3435 }

vscode-extension/purelint-0.1.0.vsix → vscode-extension/purslint-0.1.1.vsixrenamed

Binary file not shown.

vscode-extension/purslint.pngnew file

Binary file not shown.

vscode-extension/src/extension.ts+5−5

@@ -10,7 +10,7 @@ import {

1010let client: LanguageClient | undefined;

1111

1212export function activate(context: vscode.ExtensionContext) {

13− const config = vscode.workspace.getConfiguration('purelint');

13+ const config = vscode.workspace.getConfiguration('purslint');

1414

1515 if (!config.get<boolean>('enable', true)) {

1616 return;

@@ -19,8 +19,8 @@ export function activate(context: vscode.ExtensionContext) {

1919 // Get server path from config or use default

2020 let serverPath = config.get<string>('serverPath', '');

2121 if (!serverPath) {

22− // Default to the purelint project location

23− serverPath = '/Users/mark/Developer/purelint/dist/purelint-lsp.js';

22+ // Default to the purslint project location

23+ serverPath = '/Users/mark/Developer/purslint/dist/purslint-lsp.js';

2424 }

2525

2626 const serverOptions: ServerOptions = {

@@ -42,8 +42,8 @@ export function activate(context: vscode.ExtensionContext) {

4242 };

4343

4444 client = new LanguageClient(

45− 'purelint',

46− 'Purelint',

45+ 'purslint',

46+ 'Purslint',

4747 serverOptions,

4848 clientOptions

4949 );

vscode-extension/src/test/suite/extension.test.ts+4−4

@@ -2,15 +2,15 @@ import * as assert from 'assert';

22import * as vscode from 'vscode';

33import * as path from 'path';

5−suite('Purelint Extension Test Suite', () => {

5+suite('Purslint Extension Test Suite', () => {

66 vscode.window.showInformationMessage('Start all tests.');

88 test('Extension should be present', () => {

9− assert.ok(vscode.extensions.getExtension('purelint.purelint'));

9+ assert.ok(vscode.extensions.getExtension('RowtypeYoga.purslint'));

1010 });

1111

1212 test('Extension should activate on PureScript file', async () => {

13− const ext = vscode.extensions.getExtension('purelint.purelint');

13+ const ext = vscode.extensions.getExtension('RowtypeYoga.purslint');

1414 assert.ok(ext);

1515

1616 // Open a PureScript file to trigger activation

@@ -25,7 +25,7 @@ suite('Purelint Extension Test Suite', () => {

2525 });

2626

2727 test('Should provide code actions', async () => {

28− const ext = vscode.extensions.getExtension('purelint.purelint');

28+ const ext = vscode.extensions.getExtension('RowtypeYoga.purslint');

2929 if (!ext?.isActive) {

3030 await ext?.activate();

3131 }

zed-extension/Cargo.lock+3−3

@@ -412,7 +412,7 @@ dependencies = [

412412]

413413

414414[[package]]

415−name = "purelint-zed"

415+name = "purslint-zed"

416416version = "0.0.1"

417417dependencies = [

418418 "zed_extension_api",

@@ -818,6 +818,6 @@ dependencies = [

818818

819819[[package]]

820820name = "zmij"

821−version = "1.0.16"

821+version = "1.0.17"

822822source = "registry+https://github.com/rust-lang/crates.io-index"

823−checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65"

823+checksum = "02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439"

zed-extension/Cargo.toml+1−1

@@ -1,5 +1,5 @@

11[package]

2−name = "purelint-zed"

2+name = "purslint-zed"

33version = "0.0.1"

44edition = "2021"

zed-extension/extension.toml+3−3

@@ -1,5 +1,5 @@

1−id = "purelint"

2−name = "Purelint"

1+id = "purslint"

2+name = "Purslint"

33version = "0.0.1"

44schema_version = 1

55authors = ["Mark"]

@@ -9,5 +9,5 @@ description = "PureScript linter inspired by hlint"

99kind = "Rust"

1010version = "0.7.0"

1111

12−[language_servers.purelint]

12+[language_servers.purslint]

1313language = "PureScript"

zed-extension/extension.wasm

Binary file not shown.

zed-extension/src/lib.rs+5−5

@@ -1,10 +1,10 @@

11use zed_extension_api::{self as zed, Result};

3−struct PurelintExtension;

3+struct PurslintExtension;

5−impl zed::Extension for PurelintExtension {

5+impl zed::Extension for PurslintExtension {

66 fn new() -> Self {

7− PurelintExtension

7+ PurslintExtension

88 }

1010 fn language_server_command(

@@ -13,11 +13,11 @@ impl zed::Extension for PurelintExtension {

1313 _worktree: &zed::Worktree,

1414 ) -> Result<zed::Command> {

1515 Ok(zed::Command {

16− command: "/Users/mark/Developer/purelint/purelint-lsp".to_string(),

16+ command: "purslint-lsp".to_string(),

1717 args: vec![],

1818 env: Default::default(),

1919 })

2020 }

2121}

2222

23−zed::register_extension!(PurelintExtension);

23+zed::register_extension!(PurslintExtension);