haskell-tools-experimental-refactorings 1.0.0.1 → 1.0.0.2

raw patch · 9 files changed

+29/−31 lines, 9 filesdep ~eitherdep ~tastydep ~tasty-hunit

Dependency ranges changed: either, tasty, tasty-hunit

Files

• Language/Haskell/Tools/Refactor/Builtin/DataToNewtype.hs +2/−2
• Language/Haskell/Tools/Refactor/Builtin/DollarApp.hs +6/−7
• Language/Haskell/Tools/Refactor/Builtin/DollarApp1.hs +2/−2
• Language/Haskell/Tools/Refactor/Builtin/DollarApp2.hs +2/−2
• Language/Haskell/Tools/Refactor/Builtin/DollarApp3.hs +5/−6
• Language/Haskell/Tools/Refactor/Builtin/HelloRefactor.hs +2/−2
• Language/Haskell/Tools/Refactor/Builtin/IfToGuards.hs +4/−4
• haskell-tools-experimental-refactorings.cabal +4/−4
• test/Main.hs +2/−2

@@ -6,10 +6,10 @@ tryItOut :: String -> IO ()
 tryItOut moduleName = tryRefactor (\_ -> localRefactoring dataToNewtype) moduleName ""
 
-dataToNewtype :: LocalRefactoring dom
+dataToNewtype :: LocalRefactoring
 dataToNewtype = return . (modDecl & annList .- changeDeclaration)
 
-changeDeclaration :: Decl dom -> Decl dom
+changeDeclaration :: Decl -> Decl
 changeDeclaration dd@(DataDecl DataKeyword _ _ (AnnList [ConDecl _ (AnnList [_])]) _)
   = declNewtype .= mkNewtypeKeyword $ dd
 changeDeclaration decl = decl

@@ -1,5 +1,5 @@ {-# LANGUAGE FlexibleContexts, ConstraintKinds, TypeFamilies #-}
-module Language.Haskell.Tools.Refactor.Builtin.DollarApp (dollarApp, DollarDomain, tryItOut) where
+module Language.Haskell.Tools.Refactor.Builtin.DollarApp (dollarApp, tryItOut) where
 
 import Language.Haskell.Tools.Refactor
 
@@ -17,14 +17,13 @@ tryItOut :: String -> String -> IO ()
 tryItOut = tryRefactor (localRefactoring . dollarApp)
 
-type DollarMonad dom = StateT [SrcSpan] (LocalRefactor dom)
-type DollarDomain dom = (HasImportInfo dom, HasModuleInfo dom, HasFixityInfo dom, HasNameInfo dom)
+type DollarMonad = StateT [SrcSpan] LocalRefactor
 
-dollarApp :: DollarDomain dom => RealSrcSpan -> LocalRefactoring dom
+dollarApp :: RealSrcSpan -> LocalRefactoring
 dollarApp sp = flip evalStateT [] . ((nodesContained sp !~ (\e -> get >>= replaceExpr e))
                                         >=> (biplateRef !~ parenExpr))
 
-replaceExpr :: DollarDomain dom => Expr dom -> [SrcSpan] -> DollarMonad dom (Expr dom)
+replaceExpr :: Expr -> [SrcSpan] -> DollarMonad Expr
 replaceExpr expr@(App _ (Paren (InfixApp _ op arg))) replacedRanges
   | not (getRange arg `elem` replacedRanges)
   , semanticsName (op ^. operatorName) /= Just dollarName
@@ -34,10 +33,10 @@                                          mkInfixApp fun <$> lift (referenceOperator dollarName) <*> pure arg
 replaceExpr e _ = return e
 
-parenExpr :: Expr dom -> DollarMonad dom (Expr dom)
+parenExpr :: Expr -> DollarMonad Expr
 parenExpr e = (exprLhs !~ parenDollar True) =<< (exprRhs !~ parenDollar False $ e)
 
-parenDollar :: Bool -> Expr dom -> DollarMonad dom (Expr dom)
+parenDollar :: Bool -> Expr -> DollarMonad Expr
 parenDollar lhs expr@(InfixApp _ _ arg)
   = do replacedRanges <- get
        if getRange arg `elem` replacedRanges && (lhs || getRange expr `notElem` replacedRanges)

@@ -9,9 +9,9 @@ tryItOut :: String -> String -> IO ()
 tryItOut = tryRefactor (localRefactoring . dollarApp)
 
-dollarApp :: Domain dom => RealSrcSpan -> LocalRefactoring dom
+dollarApp :: RealSrcSpan -> LocalRefactoring
 dollarApp sp = return . (nodesContained sp .- replaceExpr)
 
-replaceExpr :: Expr dom -> Expr dom
+replaceExpr :: Expr -> Expr
 replaceExpr (App fun (Paren arg)) = mkInfixApp fun (mkUnqualOp "$") arg
 replaceExpr e = e

@@ -13,10 +13,10 @@ tryItOut :: String -> String -> IO ()
 tryItOut = tryRefactor (localRefactoring . dollarApp)
 
-dollarApp :: (HasImportInfo dom, HasModuleInfo dom) => RealSrcSpan -> LocalRefactoring dom
+dollarApp :: RealSrcSpan -> LocalRefactoring
 dollarApp sp = nodesContained sp !~ replaceExpr
 
-replaceExpr :: (HasImportInfo dom, HasModuleInfo dom) => Expr dom -> LocalRefactor dom (Expr dom)
+replaceExpr :: Expr -> LocalRefactor Expr
 replaceExpr (App fun (Paren arg)) = mkInfixApp fun <$> referenceOperator dollarName <*> pure arg
 replaceExpr e = pure e
 

@@ -16,22 +16,21 @@ tryItOut :: String -> String -> IO ()
 tryItOut = tryRefactor (localRefactoring . dollarApp)
 
-type DollarMonad dom = StateT [SrcSpan] (LocalRefactor dom)
-type DollarDomain dom = (HasImportInfo dom, HasModuleInfo dom, HasFixityInfo dom, HasNameInfo dom)
+type DollarMonad = StateT [SrcSpan] LocalRefactor
 
-dollarApp :: DollarDomain dom => RealSrcSpan -> LocalRefactoring dom
+dollarApp :: RealSrcSpan -> LocalRefactoring
 dollarApp sp = flip evalStateT [] . ((nodesContained sp !~ (\e -> get >>= replaceExpr e))
                                         >=> (biplateRef !~ parenExpr))
 
-replaceExpr :: DollarDomain dom => Expr dom -> [SrcSpan] -> DollarMonad dom (Expr dom)
+replaceExpr :: Expr -> [SrcSpan] -> DollarMonad Expr
 replaceExpr (App fun (Paren arg)) _ = do modify $ (getRange arg :)
                                          mkInfixApp fun <$> lift (referenceOperator dollarName) <*> pure arg
 replaceExpr e _ = return e
 
-parenExpr :: Expr dom -> DollarMonad dom (Expr dom)
+parenExpr :: Expr -> DollarMonad Expr
 parenExpr e = (exprLhs !~ parenDollar True) =<< (exprRhs !~ parenDollar False $ e)
 
-parenDollar :: Bool -> Expr dom -> DollarMonad dom (Expr dom)
+parenDollar :: Bool -> Expr -> DollarMonad Expr
 parenDollar lhs expr@(InfixApp _ _ arg)
   = do replacedRanges <- get
        if getRange arg `elem` replacedRanges && (lhs || getRange expr `notElem` replacedRanges)

@@ -11,8 +11,8 @@ tryItOut :: String -> String -> IO ()
 tryItOut = tryRefactor (localRefactoring . helloRefactor)
 
-helloRefactor :: Domain dom => RealSrcSpan -> LocalRefactoring dom
+helloRefactor :: RealSrcSpan -> LocalRefactoring
 helloRefactor sp = return . (nodesContained sp .- helloExpr)
 
-helloExpr :: Expr dom -> Expr dom
+helloExpr :: Expr -> Expr
 helloExpr e = trace ("\n### Hello: " ++ prettyPrint e) $ e

@@ -9,20 +9,20 @@ tryItOut :: String -> String -> IO ()
 tryItOut = tryRefactor (localRefactoring . ifToGuards)
 
-ifToGuards :: Domain dom => RealSrcSpan -> LocalRefactoring dom
+ifToGuards :: RealSrcSpan -> LocalRefactoring
 ifToGuards sp = return . (nodesContaining sp .- changeBindings)
 
-changeBindings :: ValueBind dom -> ValueBind dom
+changeBindings :: ValueBind -> ValueBind
 changeBindings (SimpleBind (VarPat name) (UnguardedRhs (If pred thenE elseE)) locals)
   = mkFunctionBind [mkMatch (mkMatchLhs name []) (createSimpleIfRhss pred thenE elseE) (locals ^. annMaybe) ]
 changeBindings fbs@(FunctionBind {})
   = funBindMatches&annList&matchRhs .- trfRhs $ fbs
-  where trfRhs :: Rhs dom -> Rhs dom
+  where trfRhs :: Rhs -> Rhs
         trfRhs (UnguardedRhs (If pred thenE elseE)) = createSimpleIfRhss pred thenE elseE
         trfRhs e = e -- don't transform already guarded right-hand sides to avoid multiple evaluation of the same condition
 changeBindings b = b
 
-createSimpleIfRhss :: Expr dom -> Expr dom -> Expr dom -> Rhs dom
+createSimpleIfRhss :: Expr -> Expr -> Expr -> Rhs
 createSimpleIfRhss pred thenE elseE = mkGuardedRhss [ mkGuardedRhs [mkGuardCheck pred] thenE
                                                     , mkGuardedRhs [mkGuardCheck (mkVar (mkName "otherwise"))] elseE
                                                     ]

@@ -1,5 +1,5 @@ name:                haskell-tools-experimental-refactorings
-version:             1.0.0.1
+version:             1.0.0.2
 synopsis:            Refactoring Tool for Haskell
 description:         Contains experimental refactorings implemented in the Haskell-tools framework for tutorial purposes, or to be added later to the set of mature refactorings.
 homepage:            https://github.com/haskell-tools/haskell-tools
@@ -50,10 +50,10 @@   hs-source-dirs:      test
   main-is:             Main.hs
   build-depends:       base                      >= 4.10  && < 4.11
-                     , tasty                     >= 0.11 && < 0.12
-                     , tasty-hunit               >= 0.9 && < 0.10
+                     , tasty                     >= 0.11 && < 0.13
+                     , tasty-hunit               >= 0.9 && < 0.11
                      , transformers              >= 0.5  && < 0.6
-                     , either                    >= 4.4  && < 4.5
+                     , either                    >= 4.4  && < 5.1
                      , filepath                  >= 1.4  && < 1.5
                      , mtl                       >= 2.2  && < 2.3
                      , uniplate                  >= 1.6  && < 1.7

@@ -39,7 +39,7 @@   , ("Refactor.DollarApp.ImportDollar", \m -> dollarApp (correctRefactorSpan m $ readSrcSpan "6:5-6:12"))
   ]
 
-makeMiscRefactorTest :: (String, UnnamedModule IdDom -> LocalRefactoring IdDom) -> TestTree
+makeMiscRefactorTest :: (String, UnnamedModule -> LocalRefactoring) -> TestTree
 makeMiscRefactorTest (moduleName, refact)
   = testCase moduleName $
       do expected <- loadExpected True rootDir moduleName
@@ -47,7 +47,7 @@          assertEqual "The transformed result is not what is expected" (Right (standardizeLineEndings expected))
                                                                       (mapRight standardizeLineEndings res)
 
-testRefactor :: (UnnamedModule IdDom -> LocalRefactoring IdDom) -> String -> IO (Either String String)
+testRefactor :: (UnnamedModule -> LocalRefactoring) -> String -> IO (Either String String)
 testRefactor refact moduleName
   = runGhc (Just libdir) $ do
       initGhcFlags