jfmengels/elm-review
1
1
Fork 0
mirror of https://github.com/jfmengels/elm-review.git synced 2024-12-25 18:51:41 +03:00
Code Issues Packages Projects Releases Wiki Activity
e60ff158a7
elm-review/tests/NoPrematureLetComputation.elm

1072 lines
32 KiB
Elm
Raw Normal View History

Backport rules from elm-review-common
2021-08-19 21:50:50 +03:00
module NoPrematureLetComputation exposing (rule)
{-|
@docs rule
-}
import Dict exposing (Dict)
import Elm.Syntax.Declaration as Declaration exposing (Declaration)
import Elm.Syntax.Expression as Expression exposing (Expression)
import Elm.Syntax.Node as Node exposing (Node(..))
import Elm.Syntax.Pattern as Pattern exposing (Pattern)
import Elm.Syntax.Range as Range exposing (Location, Range)
import RangeDict exposing (RangeDict)
import Review.Fix as Fix exposing (Fix)
import Review.ModuleNameLookupTable as ModuleNameLookupTable exposing (ModuleNameLookupTable)
import Review.Rule as Rule exposing (Rule)
import Set exposing (Set)
{-| Reports let declarations that are computed earlier than needed.
This rule is useful to prevent unnecessary computations and to group related code together.
config =
[ NoPrematureLetComputation.rule
]
🔧 Running with `--fix` will automatically fix almost all of the reported errors.
## Fail
In this example, we compute `value` earlier than needed, and we end up not using it in of the branches.
someFunction n =
let
value =
expensiveComputation n
in
if needToCompute then
value + 1
else
0
## Success
If we take the example from above, this would be the suggested (and automatic) fix:
someFunction n =
if needToCompute then
let
value =
expensiveComputation n
in
value + 1
else
0
A declaration will not be reported if it's used in multiple branches at the same level.
The rule will try to move the declaration as close as possible to the usages.
someFunction n =
let
value =
expensiveComputation n
in
if condition then
value + 1
else
value - 1
Sometimes, when a computation is somewhat expensive, it is done once in a let declaration and then
referenced in a let or anonymous function. This rule does not want to worsen the performance, and therefore
declarations will not be moved to inside a function.
someFunction items n =
let
-- Will stay here
value =
expensiveComputation n
in
List.map
(\item ->
if condition item then
value + item.value
else
0
)
items
There are some exceptions when we know for sure that an anonymous function will only be computed once,
for instance when it is the argument to `Maybe.map`:
someFunction maybeItem n =
let
-- Will be moved from here...
value =
expensiveComputation n
in
Maybe.map
(\item ->
if condition item then
-- ... to here
value + item.value
else
0
)
maybeItem
The rule will also merge adjacent let declarations together:
someFunction n =
let
y =
1
in
let
z =
1
in
y + z
-->
someFunction n =
let
y =
1
z =
1
in
y + z
## Try it out
You can try this rule out by running the following command:
```bash
elm-review --template jfmengels/elm-review-common/example --rules NoPrematureLetComputation
```
-}
rule : Rule
rule =
Rule.newModuleRuleSchemaUsingContextCreator "NoPrematureLetComputation" initialContext
|> Rule.withDeclarationEnterVisitor declarationVisitor
|> Rule.withExpressionEnterVisitor expressionEnterVisitor
|> Rule.withExpressionExitVisitor expressionExitVisitor
|> Rule.fromModuleRuleSchema
type alias Context =
{ lookupTable : ModuleNameLookupTable
, extractSourceCode : Range -> String
, scope : Scope
, branching : Branching
, functionsThatWillOnlyBeComputedOnce : RangeDict ()
}
type alias Branching =
{ full : List Range
, last : Maybe Range
}
type Scope
= Scope ScopeType ScopeData
type ScopeType
= Branch
| LetScope
| Function
| FunctionOkayToMoveInto
type alias ScopeData =
{ letDeclarations : List Declared
, used : Set String
, insertionLocation : LetInsertPosition
, scopes : RangeDict Scope
}
type LetInsertPosition
= InsertNewLet Location
| InsertExistingLet Location
type alias Declared =
{ name : String
, introducesVariablesInImplementation : Bool
, reportRange : Range
, declarationColumn : Int
, declarationRange : Range
, removeRange : Range
}
newBranch : LetInsertPosition -> Scope
newBranch insertionLocation =
Scope
Branch
{ letDeclarations = []
, used = Set.empty
, insertionLocation = insertionLocation
, scopes = RangeDict.empty
}
emptyBranching : Branching
emptyBranching =
{ full = []
, last = Nothing
}
initialContext : Rule.ContextCreator () Context
initialContext =
Rule.initContextCreator
(\lookupTable extractSourceCode () ->
{ lookupTable = lookupTable
, extractSourceCode = extractSourceCode
, scope = newBranch (InsertNewLet { row = 0, column = 0 })
, branching = emptyBranching
, functionsThatWillOnlyBeComputedOnce = RangeDict.empty
}
)
|> Rule.withModuleNameLookupTable
|> Rule.withSourceCodeExtractor
updateCurrentBranch : (ScopeData -> ScopeData) -> List Range -> Scope -> Scope
updateCurrentBranch updateFn currentBranching (Scope type_ segment) =
case currentBranching of
[] ->
Scope type_ (updateFn segment)
range :: restOfSegments ->
Scope
type_
{ segment
| scopes =
RangeDict.modify
range
(updateCurrentBranch updateFn restOfSegments)
segment.scopes
}
updateAllSegmentsOfCurrentBranch : (ScopeData -> ScopeData) -> List Range -> Scope -> Scope
updateAllSegmentsOfCurrentBranch updateFn currentBranching (Scope type_ scope) =
case currentBranching of
[] ->
Scope type_ (updateFn scope)
range :: restOfSegments ->
Scope
type_
(updateFn
{ scope
| scopes =
RangeDict.modify
range
(updateAllSegmentsOfCurrentBranch updateFn restOfSegments)
scope.scopes
}
)
getCurrentBranch : List Range -> Scope -> Maybe Scope
getCurrentBranch currentBranching branch =
case currentBranching of
[] ->
Just branch
range :: restOfBranching ->
RangeDict.get range (getScopes branch)
|> Maybe.andThen (getCurrentBranch restOfBranching)
getScopes : Scope -> RangeDict Scope
getScopes =
getScopeData >> .scopes
getScopeData : Scope -> ScopeData
getScopeData (Scope _ scope) =
scope
declarationVisitor : Node Declaration -> Context -> ( List nothing, Context )
declarationVisitor node context =
case Node.value node of
Declaration.FunctionDeclaration { declaration } ->
( []
, { lookupTable = context.lookupTable
, extractSourceCode = context.extractSourceCode
, scope = newBranch (figureOutInsertionLocation (declaration |> Node.value |> .expression))
, branching = emptyBranching
, functionsThatWillOnlyBeComputedOnce = RangeDict.empty
}
)
_ ->
( [], context )
figureOutInsertionLocation : Node Expression -> LetInsertPosition
figureOutInsertionLocation node =
case Node.value node of
Expression.LetExpression { declarations } ->
case declarations of
first :: _ ->
InsertExistingLet (Node.range first).start
[] ->
-- Should not happen
InsertNewLet (Node.range node).start
_ ->
InsertNewLet (Node.range node).start
expressionEnterVisitor : Node Expression -> Context -> ( List nothing, Context )
expressionEnterVisitor node context =
let
newContext : Context
newContext =
case getCurrentBranch context.branching.full context.scope |> Maybe.map getScopes of
Just scopes ->
if RangeDict.member (Node.range node) scopes then
{ context | branching = addBranching (Node.range node) context.branching }
else
context
Nothing ->
context
in
( [], expressionEnterVisitorHelp node newContext )
addBranching : Range -> Branching -> Branching
addBranching range branching =
{ full = branching.full ++ [ range ]
, last = Just range
}
removeLastBranchIfOnIt : Range -> Branching -> Maybe Branching
removeLastBranchIfOnIt range branching =
if branching.last == Just range then
let
full : List Range
full =
List.take (List.length branching.full - 1) branching.full
in
Just
(removeLastBranchIfOnItRetry
range
{ full = full
, last = getLastListItem full
}
)
else
Nothing
removeLastBranchIfOnItRetry : Range -> Branching -> Branching
removeLastBranchIfOnItRetry range branching =
if branching.last == Just range then
let
full : List Range
full =
List.take (List.length branching.full - 1) branching.full
in
{ full = full
, last = getLastListItem full
}
else
branching
popCurrentNodeFromBranching : Range -> Context -> Context
popCurrentNodeFromBranching range context =
case removeLastBranchIfOnIt range context.branching of
Just newBranching ->
{ context | branching = newBranching }
Nothing ->
context
expressionEnterVisitorHelp : Node Expression -> Context -> Context
expressionEnterVisitorHelp node context =
case Node.value node of
Expression.FunctionOrValue [] name ->
let
branch : Scope
branch =
updateCurrentBranch
(\b -> { b | used = Set.insert name b.used })
context.branching.full
context.scope
in
{ context | scope = branch }
Expression.RecordUpdateExpression name _ ->
let
branch : Scope
branch =
updateCurrentBranch
(\b -> { b | used = Set.insert (Node.value name) b.used })
context.branching.full
context.scope
in
{ context | scope = branch }
Expression.LetExpression { declarations, expression } ->
let
isDeclarationAlone : Bool
isDeclarationAlone =
List.length declarations == 1
letDeclarations : List Declared
letDeclarations =
declarations
|> List.concatMap collectDeclarations
|> List.map
(\( nameNode, expressionRange, declaration ) ->
{ name = Node.value nameNode
, introducesVariablesInImplementation = False
, reportRange = Node.range nameNode
, declarationColumn = (Node.range declaration).start.column
, declarationRange = fullLines { start = (Node.range declaration).start, end = expressionRange.end }
, removeRange =
if isDeclarationAlone then
{ start = (Node.range node).start
, end = (Node.range expression).start
}
else
{ start = { row = (Node.range declaration).start.row, column = 1 }
, end = expressionRange.end
}
}
)
scopes : RangeDict Scope
scopes =
declarations
|> List.filterMap getLetFunctionRange
|> List.map (\range -> ( range, functionScope ))
|> RangeDict.fromList
newScope : Scope
newScope =
Scope
LetScope
{ letDeclarations = letDeclarations
, used = Set.empty
, insertionLocation = figureOutInsertionLocation node
, scopes = scopes
}
contextWithDeclarationsMarked : Context
contextWithDeclarationsMarked =
{ context | scope = markLetDeclarationsAsIntroducingVariables (Node.range node) context }
branch : Scope
branch =
updateCurrentBranch
(\b ->
{ b
| scopes =
RangeDict.insert
(Node.range node)
newScope
b.scopes
}
)
contextWithDeclarationsMarked.branching.full
contextWithDeclarationsMarked.scope
in
{ contextWithDeclarationsMarked
| scope = branch
, branching = addBranching (Node.range node) contextWithDeclarationsMarked.branching
}
Expression.IfBlock _ then_ else_ ->
addBranches [ then_, else_ ] context
Expression.CaseExpression { cases } ->
let
contextWithDeclarationsMarked : Context
contextWithDeclarationsMarked =
if List.any (Tuple.first >> patternIntroducesVariable) cases then
{ context | scope = markLetDeclarationsAsIntroducingVariables (Node.range node) context }
else
context
branchNodes : List (Node Expression)
branchNodes =
List.map (\( _, exprNode ) -> exprNode) cases
in
addBranches branchNodes contextWithDeclarationsMarked
Expression.LambdaExpression { args, expression } ->
let
branch : Scope
branch =
if List.any patternIntroducesVariable args then
markLetDeclarationsAsIntroducingVariables (Node.range node) context
else
context.scope
newScope : Scope
newScope =
Scope
(if RangeDict.member (Node.range node) context.functionsThatWillOnlyBeComputedOnce then
FunctionOkayToMoveInto
else
Function
)
{ letDeclarations = []
, used = Set.empty
, insertionLocation = figureOutInsertionLocation expression
, scopes = RangeDict.empty
}
branchWithAddedScope : Scope
branchWithAddedScope =
updateCurrentBranch
(\b ->
{ b
| scopes =
RangeDict.insert
(Node.range node)
newScope
b.scopes
}
)
context.branching.full
branch
in
{ context
| scope = branchWithAddedScope
, branching = addBranching (Node.range node) context.branching
}
Expression.Application ((Node fnRange (Expression.FunctionOrValue _ fnName)) :: argumentWithParens :: restOfArguments) ->
registerApplicationCall
fnRange
fnName
argumentWithParens
(List.length restOfArguments)
context
Expression.OperatorApplication "|>" _ _ (Node _ (Expression.Application ((Node fnRange (Expression.FunctionOrValue _ fnName)) :: argumentWithParens :: restOfArguments))) ->
registerApplicationCall
fnRange
fnName
argumentWithParens
(List.length restOfArguments + 1)
context
Expression.OperatorApplication "<|" _ (Node _ (Expression.Application ((Node fnRange (Expression.FunctionOrValue _ fnName)) :: argumentWithParens :: restOfArguments))) _ ->
registerApplicationCall
fnRange
fnName
argumentWithParens
(List.length restOfArguments + 1)
context
_ ->
context
registerApplicationCall : Range -> String -> Node Expression -> Int -> Context -> Context
registerApplicationCall fnRange fnName argumentWithParens nbOfOtherArguments context =
let
argument : Node Expression
argument =
removeParens argumentWithParens
in
case Node.value argument of
Expression.LambdaExpression _ ->
case Dict.get fnName knownFunctions of
Just knownModuleNames ->
case
ModuleNameLookupTable.moduleNameAt context.lookupTable fnRange
|> Maybe.andThen (\moduleName -> Dict.get moduleName knownModuleNames)
of
Just expectedNumberOfArguments ->
if nbOfOtherArguments == expectedNumberOfArguments - 1 then
{ context
| functionsThatWillOnlyBeComputedOnce =
RangeDict.insert (Node.range argument) () context.functionsThatWillOnlyBeComputedOnce
}
else
context
_ ->
context
_ ->
context
_ ->
context
knownFunctions : Dict String (Dict (List String) number)
knownFunctions =
Dict.fromList
[ ( "map"
, Dict.fromList
[ ( [ "Maybe" ], 2 )
, ( [ "Html" ], 2 )
, ( [ "Result" ], 2 )
, ( [ "Task" ], 2 )
]
)
, ( "map2"
, Dict.fromList
[ ( [ "Maybe" ], 3 )
, ( [ "Result" ], 3 )
, ( [ "Task" ], 3 )
]
)
, ( "map3"
, Dict.fromList
[ ( [ "Maybe" ], 4 )
, ( [ "Result" ], 4 )
, ( [ "Task" ], 4 )
]
)
, ( "map4"
, Dict.fromList
[ ( [ "Maybe" ], 5 )
, ( [ "Result" ], 5 )
, ( [ "Task" ], 5 )
]
)
, ( "map5"
, Dict.fromList
[ ( [ "Maybe" ], 6 )
, ( [ "Result" ], 6 )
, ( [ "Task" ], 6 )
]
)
, ( "mapError"
, Dict.fromList
[ ( [ "Result" ], 2 )
, ( [ "Task" ], 2 )
]
)
, ( "andThen"
, Dict.fromList
[ ( [ "Maybe" ], 2 )
, ( [ "Result" ], 2 )
, ( [ "Task" ], 2 )
]
)
-- TODO Support mapBoth as well
, ( "mapFirst"
, Dict.singleton [ "Tuple" ] 2
)
, ( "mapSecond"
, Dict.singleton [ "Tuple" ] 2
)
, ( "perform"
, Dict.singleton [ "Task" ] 2
)
, ( "attempt"
, Dict.singleton [ "Task" ] 2
)
, ( "onError"
, Dict.singleton [ "Task" ] 2
)
, ( "update"
, Dict.singleton [ "Dict" ] 4
)
]
removeParens : Node Expression -> Node Expression
removeParens node =
case Node.value node of
Expression.ParenthesizedExpression expr ->
removeParens expr
_ ->
node
functionScope : Scope
functionScope =
Scope
Function
{ letDeclarations = []
, used = Set.empty
, insertionLocation =
-- Will not be used
InsertNewLet { row = 0, column = 0 }
, scopes = RangeDict.empty
}
variablesInPattern : Node Pattern -> List (Node String)
variablesInPattern node =
case Node.value node of
Pattern.ListPattern patterns ->
List.concatMap variablesInPattern patterns
Pattern.TuplePattern patterns ->
List.concatMap variablesInPattern patterns
Pattern.RecordPattern fields ->
fields
Pattern.UnConsPattern left right ->
List.concatMap variablesInPattern [ left, right ]
Pattern.VarPattern name ->
[ Node (Node.range node) name ]
Pattern.NamedPattern _ patterns ->
List.concatMap variablesInPattern patterns
Pattern.AsPattern pattern name ->
name :: variablesInPattern pattern
Pattern.ParenthesizedPattern pattern ->
variablesInPattern pattern
_ ->
[]
patternIntroducesVariable : Node Pattern -> Bool
patternIntroducesVariable node =
case Node.value node of
Pattern.ListPattern patterns ->
List.any patternIntroducesVariable patterns
Pattern.TuplePattern patterns ->
List.any patternIntroducesVariable patterns
Pattern.RecordPattern _ ->
True
Pattern.UnConsPattern left right ->
patternIntroducesVariable left
|| patternIntroducesVariable right
Pattern.VarPattern _ ->
True
Pattern.NamedPattern _ patterns ->
List.any patternIntroducesVariable patterns
Pattern.AsPattern _ _ ->
True
Pattern.ParenthesizedPattern pattern ->
patternIntroducesVariable pattern
_ ->
False
markLetDeclarationsAsIntroducingVariables : Range -> Context -> Scope
markLetDeclarationsAsIntroducingVariables range context =
updateAllSegmentsOfCurrentBranch
(markDeclarationsAsUsed range)
context.branching.full
context.scope
markDeclarationsAsUsed : Range -> ScopeData -> ScopeData
markDeclarationsAsUsed range branchData =
{ branchData | letDeclarations = List.map (markDeclarationAsUsed range) branchData.letDeclarations }
markDeclarationAsUsed : Range -> Declared -> Declared
markDeclarationAsUsed range declared =
if isRangeContained { outer = declared.declarationRange, inner = range } then
{ declared | introducesVariablesInImplementation = True }
else
declared
isRangeContained : { outer : Range, inner : Range } -> Bool
isRangeContained { outer, inner } =
(Range.compareLocations outer.start inner.start /= GT)
&& (Range.compareLocations outer.end inner.end /= LT)
fullLines : Range -> Range
fullLines range =
{ start = { row = range.start.row, column = 1 }
, end = range.end
}
addBranches : List (Node Expression) -> Context -> Context
addBranches nodes context =
let
branch : Scope
branch =
updateCurrentBranch
(\b -> { b | scopes = insertNewBranches nodes b.scopes })
context.branching.full
context.scope
in
{ context | scope = branch }
insertNewBranches : List (Node Expression) -> RangeDict Scope -> RangeDict Scope
insertNewBranches nodes rangeDict =
case nodes of
[] ->
rangeDict
node :: tail ->
insertNewBranches tail
(RangeDict.insert
(Node.range node)
(newBranch (figureOutInsertionLocation node))
rangeDict
)
expressionExitVisitor : Node Expression -> Context -> ( List (Rule.Error {}), Context )
expressionExitVisitor node context =
( expressionExitVisitorHelp node context
, popCurrentNodeFromBranching (Node.range node) context
)
expressionExitVisitorHelp : Node Expression -> Context -> List (Rule.Error {})
expressionExitVisitorHelp node context =
case Node.value node of
Expression.LetExpression _ ->
case getCurrentBranch context.branching.full context.scope of
Just ((Scope LetScope scopeData) as scope) ->
List.filterMap
(\declaration ->
canBeMovedToCloserLocation True declaration.name scope
|> List.head
|> Maybe.map (createError context declaration)
)
scopeData.letDeclarations
_ ->
[]
_ ->
[]
collectDeclarations : Node Expression.LetDeclaration -> List ( Node String, Range, Node Expression.LetDeclaration )
collectDeclarations node =
case Node.value node of
Expression.LetFunction letFunction ->
let
declaration : Expression.FunctionImplementation
declaration =
Node.value letFunction.declaration
in
if List.isEmpty declaration.arguments then
[ ( declaration.name
, Node.range declaration.expression
, node
)
]
else
[]
Expression.LetDestructuring pattern expression ->
case variablesInPattern pattern of
[ name ] ->
[ ( name
, Node.range expression
, node
)
]
_ ->
[]
getLetFunctionRange : Node Expression.LetDeclaration -> Maybe Range
getLetFunctionRange node =
case Node.value node of
Expression.LetFunction { declaration } ->
if List.isEmpty (Node.value declaration).arguments then
Nothing
else
Just (declaration |> Node.value |> .expression |> Node.range)
Expression.LetDestructuring _ _ ->
Nothing
canBeMovedToCloserLocation : Bool -> String -> Scope -> List LetInsertPosition
canBeMovedToCloserLocation isRoot name (Scope type_ scope) =
let
closestLocation : List LetInsertPosition
closestLocation =
canBeMovedToCloserLocationForBranchData isRoot name scope
in
case type_ of
Branch ->
closestLocation
LetScope ->
closestLocation
FunctionOkayToMoveInto ->
closestLocation
Function ->
-- Duplicating so that the parent has to use its insert location,
-- and we don't insert inside the let
closestLocation ++ closestLocation
canBeMovedToCloserLocationForBranchData : Bool -> String -> ScopeData -> List LetInsertPosition
canBeMovedToCloserLocationForBranchData isRoot name branchData =
if Set.member name branchData.used then
emptyIfTrue isRoot [ branchData.insertionLocation ]
else
let
relevantUsages : List LetInsertPosition
relevantUsages =
findRelevantUsages name (RangeDict.values branchData.scopes) []
in
if List.length relevantUsages > 1 then
emptyIfTrue isRoot [ branchData.insertionLocation ]
else
relevantUsages
findRelevantUsages : String -> List Scope -> List LetInsertPosition -> List LetInsertPosition
findRelevantUsages name branches result =
if List.length result > 1 then
-- If we have already found 2 branches with relevant usages, then we don't need to continue
result
else
case branches of
[] ->
result
first :: rest ->
findRelevantUsages name rest (canBeMovedToCloserLocation False name first ++ result)
emptyIfTrue : Bool -> List a -> List a
emptyIfTrue bool list =
if bool then
[]
else
list
createError : Context -> Declared -> LetInsertPosition -> Rule.Error {}
createError context declared letInsertPosition =
let
letInsertLine : Int
letInsertLine =
case letInsertPosition of
InsertNewLet insertLocation ->
insertLocation.row
InsertExistingLet insertLocation ->
insertLocation.row
in
Rule.errorWithFix
{ message = "Let value was declared prematurely"
, details =
[ "This value is only used in some code paths, and it can therefore be computed unnecessarily."
, "Try moving it closer to where it is needed, I recommend to move it to line " ++ String.fromInt letInsertLine ++ "."
]
}
declared.reportRange
(fix context declared letInsertPosition)
fix : Context -> Declared -> LetInsertPosition -> List Fix
fix context declared letInsertPosition =
if declared.introducesVariablesInImplementation then
[]
else
case letInsertPosition of
InsertNewLet insertLocation ->
[ Fix.removeRange declared.removeRange
, context.extractSourceCode declared.declarationRange
|> wrapInLet declared.reportRange.start.column insertLocation.column
|> Fix.insertAt insertLocation
]
InsertExistingLet insertLocation ->
[ Fix.removeRange declared.removeRange
, context.extractSourceCode declared.declarationRange
|> insertInLet declared.declarationColumn insertLocation.column
|> Fix.insertAt insertLocation
]
wrapInLet : Int -> Int -> String -> String
wrapInLet initialPosition column source =
let
padding : String
padding =
String.repeat (column - 1) " "
in
[ [ "let" ]
, source
|> String.lines
|> List.map (\line -> String.repeat (column - initialPosition) " " ++ " " ++ line)
, [ padding ++ "in", padding ]
]
|> List.concat
|> String.join "\n"
insertInLet : Int -> Int -> String -> String
insertInLet initialPosition column source =
case source |> String.trim |> String.lines of
[] ->
""
firstLine :: restOfLines ->
((firstLine :: List.map (\line -> String.repeat (column - initialPosition) " " ++ line) restOfLines)
|> String.join "\n"
)
++ "\n"
++ String.repeat (column - 1) " "
getLastListItem : List a -> Maybe a
getLastListItem =
List.reverse >> List.head
Reference in New Issue Copy Permalink