Make Data.Source reexport Source.Source.

github · robrix · Sep 20, 2019 · Sep 20, 2019 · Sep 20, 2019 · Sep 20, 2019
commit d929a8c78af916b0a60cad8cd45528c3cc9129bf
diff --git a/src/Analysis/PackageDef.hs b/src/Analysis/PackageDef.hs
@@ -56,7 +56,7 @@ class CustomHasPackageDef syntax where
 instance CustomHasPackageDef Language.Go.Syntax.Package where
   customToPackageDef Blob{..} _ (Language.Go.Syntax.Package (Term (In fromAnn _), _) _)
     = Just $ PackageDef (getSource fromAnn)
-    where getSource = toText . flip Source.slice blobSource . locByteRange
+    where getSource = toText . Source.slice blobSource . locByteRange
 
 -- | Produce a 'PackageDef' for 'Sum's using the 'HasPackageDef' instance & therefore using a 'CustomHasPackageDef' instance when one exists & the type is listed in 'PackageDefStrategy'.
 instance Apply HasPackageDef fs => CustomHasPackageDef (Sum fs) where

diff --git a/src/Assigning/Assignment.hs b/src/Assigning/Assignment.hs
@@ -265,7 +265,7 @@ runAssignment source = \ assignment state -> go assignment state >>= requireExha
                   GetLocals -> yield stateLocals state
                   PutLocals l -> yield () (state { stateLocals = l })
                   CurrentNode -> yield (In node (() <$ f)) state
-                  Source -> yield (Source.sourceBytes (Source.slice (nodeByteRange node) source)) (advanceState state)
+                  Source -> yield (Source.sourceBytes (Source.slice source (nodeByteRange node))) (advanceState state)
                   Children child -> do
                     (a, state') <- go child state { stateNodes = toList f, stateCallSites = maybe id (:) (tracingCallSite t) stateCallSites } >>= requireExhaustive (tracingCallSite t)
                     yield a (advanceState state' { stateNodes = stateNodes, stateCallSites = stateCallSites })

diff --git a/src/Data/Blob.hs b/src/Data/Blob.hs
@@ -31,7 +31,8 @@ import           Data.Aeson
 import qualified Data.ByteString.Lazy as BL
 import           Data.JSON.Fields
 import           Data.Language
-import           Data.Source as Source
+import           Source.Source (Source)
+import qualified Source.Source as Source
 
 -- | A 'FilePath' paired with its corresponding 'Language'.
 -- Unpacked to have the same size overhead as (FilePath, Language).
@@ -70,7 +71,7 @@ instance FromJSON Blob where
     <*> b .: "language"
 
 nullBlob :: Blob -> Bool
-nullBlob Blob{..} = nullSource blobSource
+nullBlob Blob{..} = Source.null blobSource
 
 sourceBlob :: FilePath -> Language -> Source -> Blob
 sourceBlob filepath language source = makeBlob source filepath language mempty

diff --git a/src/Data/Error.hs b/src/Data/Error.hs
@@ -18,10 +18,11 @@ import Data.Ix (inRange)
 import Data.List (intersperse, isSuffixOf)
 import System.Console.ANSI
 
-import Data.Blob
-import Data.Flag as Flag
-import Data.Source
-import Source.Span
+import           Data.Blob
+import           Data.Flag as Flag
+import           Source.Source (Source)
+import qualified Source.Source as Source
+import           Source.Span
 
 data LogPrintSource = LogPrintSource
 data Colourize = Colourize
@@ -61,8 +62,8 @@ showExcerpt colourize Span{..} Blob{..}
   = showString context . (if "\n" `isSuffixOf` context then id else showChar '\n')
   . showString (replicate (caretPaddingWidth + lineNumberDigits) ' ') . withSGRCode colourize [SetColor Foreground Vivid Green] (showString caret) . showChar '\n'
   where context = fold contextLines
-        contextLines = [ showLineNumber i <> ": " <> unpack (sourceBytes l)
-                       | (i, l) <- zip [1..] (sourceLines blobSource)
+        contextLines = [ showLineNumber i <> ": " <> unpack (Source.sourceBytes l)
+                       | (i, l) <- zip [1..] (Source.lines blobSource)
                        , inRange (posLine spanStart - 2, posLine spanStart) i
                        ]
         showLineNumber n = let s = show n in replicate (lineNumberDigits - length s) ' ' <> s

diff --git a/src/Data/Source.hs b/src/Data/Source.hs
@@ -1,127 +1,5 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 module Data.Source
-( Source
-, sourceBytes
-, fromUTF8
--- Measurement
-, sourceLength
-, nullSource
-, totalRange
-, totalSpan
--- En/decoding
-, fromText
-, toText
--- Slicing
-, slice
-, dropSource
--- Splitting
-, sourceLines
-, sourceLineRanges
-, sourceLineRangesWithin
-, newlineIndices
+( module Source.Source
 ) where
 
-import Prologue
-
-import           Data.Aeson (FromJSON (..), withText)
-import qualified Data.ByteString as B
-import           Data.Char (ord)
-import           Data.String (IsString (..))
-import qualified Data.Text as T
-import qualified Data.Text.Encoding as T
-import           Source.Range
-
-
--- | The contents of a source file. This is represented as a UTF-8
--- 'ByteString' under the hood. Construct these with 'fromUTF8'; obviously,
--- passing 'fromUTF8' non-UTF8 bytes will cause crashes.
-newtype Source = Source { sourceBytes :: B.ByteString }
-  deriving (Eq, Semigroup, Monoid, IsString, Show, Generic)
-
-fromUTF8 :: B.ByteString -> Source
-fromUTF8 = Source
-
-instance FromJSON Source where
-  parseJSON = withText "Source" (pure . fromText)
-
--- Measurement
-
-sourceLength :: Source -> Int
-sourceLength = B.length . sourceBytes
-
-nullSource :: Source -> Bool
-nullSource = B.null . sourceBytes
-
--- | Return a 'Range' that covers the entire text.
-totalRange :: Source -> Range
-totalRange = Range 0 . B.length . sourceBytes
-
--- | Return a 'Span' that covers the entire text.
-totalSpan :: Source -> Span
-totalSpan source = Span (Pos 1 1) (Pos (length ranges) (succ (end lastRange - start lastRange)))
-  where ranges = sourceLineRanges source
-        lastRange = fromMaybe lowerBound (getLast (foldMap (Last . Just) ranges))
-
-
--- En/decoding
-
--- | Return a 'Source' from a 'Text'.
-fromText :: T.Text -> Source
-fromText = Source . T.encodeUtf8
-
--- | Return the Text contained in the 'Sou
B41A
rce'.
-toText :: Source -> T.Text
-toText = T.decodeUtf8 . sourceBytes
-
-
--- | Return a 'Source' that contains a slice of the given 'Source'.
-slice :: Range -> Source -> Source
-slice range = take . drop
-  where drop = dropSource (start range)
-        take = takeSource (rangeLength range)
-
-dropSource :: Int -> Source -> Source
-dropSource i = Source . drop . sourceBytes
-  where drop = B.drop i
-
-takeSource :: Int -> Source -> Source
-takeSource i = Source . take . sourceBytes
-  where take = B.take i
-
-
--- Splitting
-
--- | Split the contents of the source after newlines.
-sourceLines :: Source -> [Source]
-sourceLines source = (`slice` source) <$> sourceLineRanges source
-
--- | Compute the 'Range's of each line in a 'Source'.
-sourceLineRanges :: Source -> [Range]
-sourceLineRanges source = sourceLineRangesWithin (totalRange source) source
-
--- | Compute the 'Range's of each line in a 'Range' of a 'Source'.
-sourceLineRangesWithin :: Range -> Source -> [Range]
-sourceLineRangesWithin range = uncurry (zipWith Range)
-                             . ((start range:) &&& (<> [ end range ]))
-                             . fmap (+ succ (start range))
-                             . newlineIndices
-                             . sourceBytes
-                             . slice range
-
--- | Return all indices of newlines ('\n', '\r', and '\r\n') in the 'ByteString'.
-newlineIndices :: B.ByteString -> [Int]
-newlineIndices = go 0
-  where go n bs | B.null bs = []
-                | otherwise = case (searchCR bs, searchLF bs) of
-                    (Nothing, Nothing)  -> []
-                    (Just i, Nothing)   -> recur n i bs
-                    (Nothing, Just i)   -> recur n i bs
-                    (Just crI, Just lfI)
-                      | succ crI == lfI -> recur n lfI bs
-                      | otherwise       -> recur n (min crI lfI) bs
-        recur n i bs = let j = n + i in j : go (succ j) (B.drop (succ i) bs)
-        searchLF = B.elemIndex (toEnum (ord '\n'))
-        searchCR = B.elemIndex (toEnum (ord '\r'))
-
-{-# INLINE newlineIndices #-}
+import Source.Source
diff --git a/src/Parsing/CMark.hs b/src/Parsing/CMark.hs
@@ -5,14 +5,15 @@ module Parsing.CMark
 , toGrammar
 ) where
 
-import CMarkGFM
-import Data.Array
+import           CMarkGFM
+import           Data.Array
 import qualified Data.AST as A
-import Data.Source
-import Data.Term
-import Source.Loc
-import Source.Span hiding (HasSpan(..))
-import TreeSitter.Language (Symbol(..), SymbolType(..))
+import           Data.Term
+import           Source.Loc
+import           Source.Source (Source)
+import qualified Source.Source as Source
+import           Source.Span hiding (HasSpan (..))
+import           TreeSitter.Language (Symbol (..), SymbolType (..))
 
 data Grammar
   = Document
@@ -50,7 +51,7 @@ exts = [
   ]
 
 cmarkParser :: Source -> A.AST (TermF [] NodeType) Grammar
-cmarkParser source = toTerm (totalRange source) (totalSpan source) $ commonmarkToNode [ optSourcePos ] exts (toText source)
+cmarkParser source = toTerm (Source.totalRange source) (Source.totalSpan source) $ commonmarkToNode [ optSourcePos ] exts (Source.toText source)
   where toTerm :: Range -> Span -> Node -> A.AST (TermF [] NodeType) Grammar
         toTerm within withinSpan (Node position t children) =
           let range = maybe within (spanToRangeInLineRanges lineRanges . toSpan) position
@@ -62,30 +63,30 @@ cmarkParser source = toTerm (totalRange source) (totalSpan source) $ commonmarkT
         lineRanges = sourceLineRangesByLineNumber source
 
 toGrammar :: NodeType -> Grammar
-toGrammar DOCUMENT{} = Document
+toGrammar DOCUMENT{}       = Document
 toGrammar THEMATIC_BREAK{} = ThematicBreak
-toGrammar PARAGRAPH{} = Paragraph
-toGrammar BLOCK_QUOTE{} = BlockQuote
-toGrammar HTML_BLOCK{} = HTMLBlock
-toGrammar CUSTOM_BLOCK{} = CustomBlock
-toGrammar CODE_BLOCK{} = CodeBlock
-toGrammar HEADING{} = Heading
-toGrammar LIST{} = List
-toGrammar ITEM{} = Item
-toGrammar TEXT{} = Text
-toGrammar SOFTBREAK{} = SoftBreak
-toGrammar LINEBREAK{} = LineBreak
-toGrammar HTML_INLINE{} = HTMLInline
-toGrammar CUSTOM_INLINE{} = CustomInline
-toGrammar CODE{} = Code
-toGrammar EMPH{} = Emphasis
-toGrammar STRONG{} = Strong
-toGrammar LINK{} = Link
-toGrammar IMAGE{} = Image
-toGrammar STRIKETHROUGH{} = Strikethrough
-toGrammar TABLE{} = Table
-toGrammar TABLE_ROW{} = TableRow
-toGrammar TABLE_CELL{} = TableCell
+toGrammar PARAGRAPH{}      = Paragraph
+toGrammar BLOCK_QUOTE{}    = BlockQuote
+toGrammar HTML_BLOCK{}     = HTMLBlock
+toGrammar CUSTOM_BLOCK{}   = CustomBlock
+toGrammar CODE_BLOCK{}     = CodeBlock
+toGrammar HEADING{}        = Heading
+toGrammar LIST{}           = List
+toGrammar ITEM{}           = Item
+toGrammar TEXT{}           = Text
+toGrammar SOFTBREAK{}      = SoftBreak
+toGrammar LINEBREAK{}      = LineBreak
+toGrammar HTML_INLINE{}    = HTMLInline
+toGrammar CUSTOM_INLINE{}  = CustomInline
+toGrammar CODE{}           = Code
+toGrammar EMPH{}           = Emphasis
+toGrammar STRONG{}         = Strong
+toGrammar LINK{}           = Link
+toGrammar IMAGE{}          = Image
+toGrammar STRIKETHROUGH{}  = Strikethrough
+toGrammar TABLE{}          = Table
+toGrammar TABLE_ROW{}      = TableRow
+toGrammar TABLE_CELL{}     = TableCell
 
 
 instance Symbol Grammar where
@@ -99,4 +100,4 @@ spanToRangeInLineRanges lineRanges Span{..} = Range
 
 sourceLineRangesByLineNumber :: Source -> Array Int Range
 sourceLineRangesByLineNumber source = listArray (1, length lineRanges) lineRanges
-  where lineRanges = sourceLineRanges source
+  where lineRanges = Source.lineRanges source
diff --git a/src/Reprinting/Tokenize.hs b/src/Reprinting/Tokenize.hs
@@ -169,7 +169,7 @@ descend t = do
       let delimiter = Range crs (start r)
       unless (delimiter == Range 0 0) $ do
         log ("slicing: " <> show delimiter)
-        chunk (slice delimiter src)
+        chunk (slice src delimiter)
       move (start r)
       tokenize (fmap (withStrategy PrettyPrinting . into) t)
       move (end r)