Better names everywhere.

bench/Evaluation.hs

@@ -1,13 +1,18 @@
-{-# LANGUAGE DataKinds, FlexibleContexts, PackageImports, PartialTypeSignatures, TypeApplications, TypeFamilies #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE PackageImports #-}
+{-# LANGUAGE PartialTypeSignatures #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeFamilies #-}
 
 module Evaluation (benchmarks) where
 
 import           Control.Carrier.Parse.Simple
-import qualified Data.Duration as Duration
 import           Data.Abstract.Evaluatable
+import           Data.Bifunctor
 import           Data.Blob
 import           Data.Blob.IO (readBlobFromFile')
-import           Data.Bifunctor
+import qualified Data.Duration as Duration
 import           "semantic" Data.Graph (topologicalSort)
 import qualified Data.Language as Language
 import           Data.Project
@@ -18,8 +23,8 @@ import           Semantic.Config (defaultOptions)
 import           Semantic.Graph
 import           Semantic.Task (TaskSession (..), runTask, withOptions)
 import           Semantic.Util
-import qualified System.Path as Path
 import           System.Path ((</>))
+import qualified System.Path as Path
 
 -- Duplicating this stuff from Util to shut off the logging
 
@@ -32,7 +37,7 @@ callGraphProject' :: ( Language.SLanguage lang
                   -> IO (Either String ())
 callGraphProject' session proxy path
   | Just (SomeParser parser) <- parserForLanguage analysisParsers lang = fmap (bimap show (const ())) . runTask session $ do
-  blob <- readBlobFromFile' (fileForTypedPath path)
+  blob <- readBlobFromFile' (File.fromPath path)
   package <- fmap snd <$> runParse (Duration.fromSeconds 10) (parsePackage parser (Project (Path.toString (Path.takeDirectory path)) [blob] lang []))
   modules <- topologicalSort <$> runImportGraphToModules proxy package
   runCallGraph proxy False modules package

bench/Tagging.hs

@@ -1,6 +1,6 @@
-{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE TypeApplications #-}
 
 module Tagging (benchmarks) where
 
@@ -66,7 +66,7 @@ parseSymbolsFilePath ::
   => PerLanguageModes
   -> Path.RelFile
   -> m ParseTreeSymbolResponse
-parseSymbolsFilePath languageModes path = readBlob (fileForTypedPath path) >>= runReader languageModes . parseSymbols . pure @[]
+parseSymbolsFilePath languageModes path = readBlob (File.fromPath path) >>= runReader languageModes . parseSymbols . pure @[]
 
 aLaCarteLanguageModes :: PerLanguageModes
 aLaCarteLanguageModes = PerLanguageModes

semantic-analysis/src/Analysis/File.hs

@@ -3,7 +3,7 @@ module Analysis.File
 ( File(..)
 , fileLanguage
 , fromBody
-, fileForTypedPath
+, fromPath
 ) where
 
 import           Analysis.Language
@@ -28,5 +28,5 @@ fromBody body = File (Path.absRel (srcLocFile srcLoc)) (spanFromSrcLoc srcLoc) b
 fileLanguage :: File a -> Language
 fileLanguage = languageForTypedPath . filePath
 
-fileForTypedPath :: Path.PartClass.AbsRel ar => Path.File ar -> File Language
-fileForTypedPath p = File (Path.toAbsRel p) lowerBound (languageForTypedPath p)
+fromPath :: Path.PartClass.AbsRel ar => Path.File ar -> File Language
+fromPath p = File (Path.toAbsRel p) lowerBound (languageForTypedPath p)

src/Data/Blob.hs

@@ -9,7 +9,7 @@ module Data.Blob
 ( File
 , Analysis.File.fileBody
 , Analysis.File.filePath
-, Analysis.File.fileForTypedPath
+, Analysis.File.fromPath
 , Blob(..)
 , Blobs(..)
 , blobLanguage

src/Data/Blob/IO.hs

@@ -11,7 +11,7 @@ module Data.Blob.IO
 
 import Prologue
 
-import           Analysis.File
+import           Analysis.File as File
 import qualified Control.Concurrent.Async as Async
 import           Data.Blob hiding (File)
 import qualified Data.ByteString as B
@@ -35,12 +35,12 @@ readBlobFromFile' file = do
   maybeM (fail ("cannot read '" <> show file <> "', file not found or language not supported.")) maybeFile
 
 readBlobFromPath :: (MonadFail m, MonadIO m) => Path.AbsRelFile -> m Blob
-readBlobFromPath = readBlobFromFile' . fileForTypedPath
+readBlobFromPath = readBlobFromFile' . File.fromPath
 
 -- | Read all blobs in the directory with Language.supportedExts.
 readBlobsFromDir :: MonadIO m => Path.AbsRelDir -> m [Blob]
 readBlobsFromDir path = liftIO . fmap catMaybes $
-  findFilesInDir path supportedExts mempty >>= Async.mapConcurrently (readBlobFromFile . fileForTypedPath)
+  findFilesInDir path supportedExts mempty >>= Async.mapConcurrently (readBlobFromFile . File.fromPath)
 
 readFilePair :: MonadIO m => File Language -> File Language -> m BlobPair
 readFilePair a b = do

src/Semantic/CLI.hs

@@ -2,6 +2,7 @@
 {-# LANGUAGE FlexibleContexts #-}
 module Semantic.CLI (main) where
 
+import qualified Analysis.File as File
 import qualified Control.Carrier.Parse.Measured as Parse
 import           Control.Carrier.Reader
 import           Data.Blob
@@ -24,7 +25,6 @@ import qualified Semantic.Telemetry.Log as Log
 import           Semantic.Version
 import           Serializing.Format hiding (Options)
 import           System.Exit (die)
-import           System.FilePath
 import qualified System.Path as Path
 import qualified System.Path.PartClass as Path.PartClass
 
@@ -187,7 +187,7 @@ languageModes = Language.PerLanguageModes
                     <> showDefault)
 
 filePathReader :: ReadM File
-filePathReader = fileForTypedPath <$> path
+filePathReader = File.fromPath <$> path
 
 path :: (Path.PartClass.FileDir fd) => ReadM (Path.AbsRel fd)
 path = eitherReader Path.parse

src/Semantic/Resolution.hs

@@ -19,6 +19,7 @@ module Semantic.Resolution
   , ResolutionC(..)
   ) where
 
+import           Analysis.File as File
 import           Control.Algebra
 import           Data.Aeson
 import           Data.Aeson.Types (parseMaybe)
@@ -36,7 +37,7 @@ import qualified System.Path as Path
 nodeJSResolutionMap :: Has Files sig m => FilePath -> Text -> [FilePath] -> m (Map FilePath FilePath)
 nodeJSResolutionMap rootDir prop excludeDirs = do
   files <- findFiles (Path.absRel rootDir) [".json"] (fmap Path.absRel excludeDirs)
-  let packageFiles = fileForTypedPath <$> filter ((==) (Path.relFile "package.json") . Path.takeFileName) files
+  let packageFiles = File.fromPath <$> filter ((==) (Path.relFile "package.json") . Path.takeFileName) files
   blobs <- readBlobs (FilesFromPaths packageFiles)
   pure $ fold (mapMaybe (lookup prop) blobs)
   where

test/Examples.hs

@@ -1,8 +1,8 @@
-{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE RecordWildCards   #-}
-{-# LANGUAGE TypeApplications  #-}
-{-# LANGUAGE AllowAmbiguousTypes  #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE TypeApplications #-}
 
 {-# OPTIONS_GHC -O1 #-}
 {-# OPTIONS_GHC -Wno-unused-top-binds -Wno-unused-imports #-}
@@ -16,9 +16,9 @@ import           Control.Lens
 import           Control.Monad
 import           Data.Blob
 import           Data.Foldable
+import           Data.Int
 import           Data.Language (LanguageMode (..), PerLanguageModes (..))
 import           Data.List
-import           Data.Int
 import qualified Data.Text as Text
 import           Data.Traversable
 import           System.FilePath.Glob
@@ -174,7 +174,7 @@ buildExamples session lang tsDir = do
     assertOK msg = either (\e -> HUnit.assertFailure (msg <> " failed to parse" <> show e)) (refuteErrors msg)
     refuteErrors msg a = case toList (a^.files) of
       [x] | (e:_) <- toList (x^.errors) -> HUnit.assertFailure (msg <> " parse errors " <> show e)
-      _ -> pure ()
+      _                                 -> pure ()
 
     assertMatch a b = case (a, b) of
       (Right a, Right b) -> case (toList (a^.files), toList (b^.files)) of
@@ -307,4 +307,4 @@ parseSymbolsFilePath ::
   => PerLanguageModes
   -> Path.RelFile
   -> m ParseTreeSymbolResponse
-parseSymbolsFilePath languageModes path = readBlob (fileForTypedPath path) >>= runReader languageModes . parseSymbols . pure @[]
+parseSymbolsFilePath languageModes path = readBlob (File.fromPath path) >>= runReader languageModes . parseSymbols . pure @[]

test/Graphing/Calls/Spec.hs

@@ -1,4 +1,8 @@
-{-# LANGUAGE DataKinds, GADTs, OverloadedStrings, PackageImports, TypeApplications #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PackageImports #-}
+{-# LANGUAGE TypeApplications #-}
 
 module Graphing.Calls.Spec ( spec ) where
 
@@ -7,6 +11,7 @@ import SpecHelpers
 
 import Algebra.Graph
 
+import qualified Analysis.File as File
 import           Control.Effect.Parse
 import           "semantic" Data.Graph (Graph (..), topologicalSort)
 import           Data.Graph.ControlFlowVertex
@@ -19,7 +24,7 @@ callGraphPythonProject path = runTaskOrDie $ do
   let proxy = Proxy @'Language.Python
       lang = Language.Python
   SomeParser parser <- pure . fromJust $! parserForLanguage analysisParsers Language.Python
-  blob <- readBlobFromFile' (fileForTypedPath path)
+  blob <- readBlobFromFile' (File.fromPath path)
   package <- fmap snd <$> parsePackage parser (Project (Path.toString (Path.takeDirectory path)) [blob] lang [])
   modules <- topologicalSort <$> runImportGraphToModules proxy package
   runCallGraph proxy False modules package

test/SpecHelpers.hs

@@ -1,4 +1,5 @@
-{-# LANGUAGE DataKinds, FlexibleContexts #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
 module SpecHelpers
@@ -23,63 +24,64 @@ module SpecHelpers
 , evaluateProject
 ) where
 
-import Control.Abstract
-import Control.Carrier.Fresh.Strict
-import Control.Carrier.Parse.Simple
-import Control.Carrier.Reader as X
+import qualified Analysis.File as File
+import           Control.Abstract
+import           Control.Carrier.Fresh.Strict
+import           Control.Carrier.Lift
+import           Control.Carrier.Parse.Simple
+import           Control.Carrier.Reader as X
+import           Control.Carrier.Resumable.Either
+import           Control.Carrier.State.Strict
 import qualified Control.Carrier.Trace.Ignoring as Trace.Ignoring
-import Control.Carrier.Resumable.Either
-import Control.Carrier.Lift
-import Control.Carrier.State.Strict
-import Control.Exception (displayException)
-import Control.Monad as X
-import Data.Abstract.Address.Precise as X
-import Data.Abstract.Evaluatable
-import Data.Abstract.FreeVariables as X
+import           Control.Exception (displayException)
+import           Control.Monad as X
+import           Data.Abstract.Address.Precise as X
+import           Data.Abstract.Evaluatable
+import           Data.Abstract.FreeVariables as X
 import qualified Data.Abstract.Heap as Heap
-import Data.Abstract.Module as X
-import Data.Abstract.ModuleTable as X hiding (lookup)
-import Data.Abstract.Name as X
+import           Data.Abstract.Module as X
+import           Data.Abstract.ModuleTable as X hiding (lookup)
+import           Data.Abstract.Name as X
 import qualified Data.Abstract.ScopeGraph as ScopeGraph
-import Data.Abstract.Value.Concrete (Value(..), ValueError, runValueError)
-import Data.Blob as X
-import Data.Blob.IO as X
-import Data.ByteString as X (ByteString)
-import Data.ByteString.Builder (Builder, toLazyByteString)
-import Data.ByteString.Lazy (toStrict)
-import Data.Edit as X
-import Data.Foldable (toList)
-import Data.Functor.Listable as X
-import Data.Language as X hiding (Precise)
-import Data.List.NonEmpty as X (NonEmpty(..))
-import Data.Maybe as X
-import Data.Monoid as X (Monoid(..), First(..), Last(..))
-import Data.Project as X
-import Data.Proxy as X
-import Data.Semigroup as X (Semigroup(..))
-import Data.Semilattice.Lower as X
-import Data.String
-import Data.Sum as Sum
-import Data.Term as X
-import Data.Traversable as X (for)
-import Debug.Trace as X (traceShowM, traceM)
-import Parsing.Parser as X
-import Semantic.Api hiding (File, Blob, BlobPair)
-import Semantic.Config (Config(..), optionsLogLevel)
-import Semantic.Graph (analysisParsers, runHeap, runScopeGraph)
-import Semantic.Task as X
-import Semantic.Telemetry (LogQueue, StatQueue)
-import Semantic.Util as X
-import Source.Range as X hiding (start, end, point)
-import Source.Source as X (Source)
-import Source.Span as X hiding (HasSpan(..), start, end, point)
-import System.Exit (die)
+import           Data.Abstract.Value.Concrete (Value (..), ValueError, runValueError)
+import           Data.Blob as X
+import           Data.Blob.IO as X
+import           Data.ByteString as X (ByteString)
+import           Data.ByteString.Builder (Builder, toLazyByteString)
+import           Data.ByteString.Lazy (toStrict)
+import           Data.Edit as X
+import           Data.Foldable (toList)
+import           Data.Functor.Listable as X
+import           Data.Language as X hiding (Precise)
+import           Data.List.NonEmpty as X (NonEmpty (..))
+import           Data.Maybe as X
+import           Data.Monoid as X (First (..), Last (..), Monoid (..))
+import           Data.Project as X
+import           Data.Proxy as X
+import           Data.Semigroup as X (Semigroup (..))
+import           Data.Semilattice.Lower as X
+import           Data.String
+import           Data.Sum as Sum
+import           Data.Term as X
+import           Data.Traversable as X (for)
+import           Debug.Trace as X (traceM, traceShowM)
+import           Parsing.Parser as X
+import           Semantic.Api hiding (Blob, BlobPair, File)
+import           Semantic.Config (Config (..), optionsLogLevel)
+import           Semantic.Graph (analysisParsers, runHeap, runScopeGraph)
+import           Semantic.Task as X
+import           Semantic.Telemetry (LogQueue, StatQueue)
+import           Semantic.Util as X
+import           Source.Range as X hiding (end, point, start)
+import           Source.Source as X (Source)
+import           Source.Span as X hiding (HasSpan (..), end, point, start)
+import           System.Exit (die)
 import qualified System.Path as Path
-import Test.Hspec as X (Spec, SpecWith, context, describe, it, xit, parallel, pendingWith, around, runIO)
-import Test.Hspec.Expectations as X
-import Test.Hspec.LeanCheck as X
-import Test.LeanCheck as X
-import Unsafe.Coerce (unsafeCoerce)
+import           Test.Hspec as X (Spec, SpecWith, around, context, describe, it, parallel, pendingWith, runIO, xit)
+import           Test.Hspec.Expectations as X
+import           Test.Hspec.LeanCheck as X
+import           Test.LeanCheck as X
+import           Unsafe.Coerce (unsafeCoerce)
 
 runBuilder :: Builder -> ByteString
 runBuilder = toStrict . toLazyByteString
@@ -99,7 +101,7 @@ diffFilePaths session p1 p2 = do
 -- | Returns an s-expression parse tree for the specified path.
 parseFilePath :: TaskSession -> Path.RelFile -> IO (Either SomeException ByteString)
 parseFilePath session path = do
-  blob <- readBlobFromFile (fileForTypedPath path)
+  blob <- readBlobFromFile (File.fromPath path)
   res <- runTask session . runParse (configTreeSitterParseTimeout (config session)) . runReader defaultLanguageModes $ parseTermBuilder TermSExpression (toList blob)
   pure (runBuilder <$> res)
 
@@ -108,7 +110,7 @@ runParseWithConfig task = asks configTreeSitterParseTimeout >>= \ timeout -> run
 
 -- | Read two files to a BlobPair.
 readFilePathPair :: Path.RelFile -> Path.RelFile -> IO BlobPair
-readFilePathPair p1 p2 = readFilePair (fileForTypedPath p1) (fileForTypedPath p2)
+readFilePathPair p1 p2 = readFilePair (File.fromPath p1) (File.fromPath p2)
 
 -- Run a Task and call `die` if it returns an Exception.
 runTaskOrDie :: ParseC TaskC a -> IO a

test/Tags/Spec.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE OverloadedStrings #-}
 module Tags.Spec (spec) where
 
+import qualified Analysis.File as File
 import           Control.Carrier.Reader
 import           Semantic.Api.Symbols
 import           Source.Loc
@@ -90,4 +91,4 @@ spec = do
         ]
 
 parseTestFile :: Foldable t => t Tags.Kind -> Path.RelFile -> IO [Tag]
-parseTestFile include path = runTaskOrDie $ readBlob (fileForTypedPath path) >>= runReader defaultLanguageModes . fmap (filter ((`elem` include) . kind)) . tagsForBlob
+parseTestFile include path = runTaskOrDie $ readBlob (File.fromPath path) >>= runReader defaultLanguageModes . fmap (filter ((`elem` include) . kind)) . tagsForBlob