Rename Data.Syntax.Assignment to Assigning.Assignment.

semantic-diff.cabal

@@ -13,7 +13,9 @@ cabal-version:       >=1.10
 
 library
   hs-source-dirs:      src
-  exposed-modules:     Category
+  exposed-modules:     Assigning.Assignment
+                     , Assigning.Assignment.Table
+                     , Category
                      , Data.Align.Generic
                      , Data.Blob
                      , Data.Diff
@@ -32,8 +34,6 @@ library
                      , Data.Span
                      , Data.SplitDiff
                      , Data.Syntax
-                     , Data.Syntax.Assignment
-                     , Data.Syntax.Assignment.Table
                      , Data.Syntax.Comment
                      , Data.Syntax.Declaration
                      , Data.Syntax.Expression

src/Assigning/Assignment.hs

@@ -59,7 +59,7 @@
 --   AST symbols are classified by their 'symbolType' as either 'Regular', 'Anonymous', or 'Auxiliary'. 'Auxiliary' never appears in ASTs; 'Regular' is for the symbols of explicitly named productions in the grammar, and 'Anonymous' is for unnamed productions of content such as tokens. Most of the time, assignments are only concerned with the named productions, and thus will be using 'Regular' symbols. Therefore, when matching a committed choice of all-'Regular' symbols, nodes with 'Anonymous' symbols will be skipped. However, in some cases grammars don’t provide a named symbol for e.g. every kind of infix operator, and thus the only way to differentiate between them is by means of a 'symbol' rule for an 'Anonymous' token. In these cases, and before every other kind of assignment, the 'Anonymous' nodes will not be skipped so that matching can succeed.
 --
 --   Therefore, in addition to the rule of thumb for committed choices (see above), try to match 'Regular' symbols up front, and only match 'Anonymous' ones in the middle of a chain. That will ensure that you don’t have to make redundant effort to explicitly skip 'Anonymous' nodes ahead of multiple alternatives, and can instead rely on them being automatically skipped except when explicitly required.
-module Data.Syntax.Assignment
+module Assigning.Assignment
 -- Types
 ( Assignment
 , Location
@@ -95,6 +95,7 @@ module Data.Syntax.Assignment
 , module Parsers
 ) where
 
+import qualified Assigning.Assignment.Table as Table
 import Control.Applicative
 import Control.Monad ((<=<), guard)
 import Control.Monad.Error.Class hiding (Error)
@@ -112,7 +113,6 @@ import Data.Maybe
 import Data.Record
 import Data.Semigroup
 import qualified Data.Source as Source (Source, slice, sourceBytes)
-import qualified Data.Syntax.Assignment.Table as Table
 import Data.Term
 import GHC.Stack
 import qualified Info

src/Assigning/Assignment/Table.hs

@@ -1,4 +1,4 @@
-module Data.Syntax.Assignment.Table
+module Assigning.Assignment.Table
 ( Table(tableAddresses)
 , singleton
 , fromListWith

src/Data/Syntax.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE DeriveAnyClass, GADTs, TypeOperators #-}
 module Data.Syntax where
 
+import qualified Assigning.Assignment as Assignment
 import Diffing.Algorithm hiding (Empty)
 import Control.Applicative
 import Control.Monad.Error.Class hiding (Error)
@@ -19,7 +20,6 @@ import Data.Range
 import Data.Record
 import Data.Semigroup
 import Data.Span
-import qualified Data.Syntax.Assignment as Assignment
 import Data.Term
 import Data.Union
 import GHC.Generics

src/Language/JSON/Assignment.hs

@@ -6,11 +6,11 @@ module Language.JSON.Assignment
 , Term)
 where
 
+import Assigning.Assignment hiding (Assignment, Error)
+import qualified Assigning.Assignment as Assignment
 import Data.Record
 import Data.Syntax (makeTerm, parseError)
 import qualified Data.Syntax as Syntax
-import Data.Syntax.Assignment hiding (Assignment, Error)
-import qualified Data.Syntax.Assignment as Assignment
 import qualified Data.Syntax.Literal as Literal
 import qualified Data.Term as Term
 import Data.Union

src/Language/Markdown/Assignment.hs

@@ -6,14 +6,14 @@ module Language.Markdown.Assignment
 , Language.Markdown.Assignment.Term
 ) where
 
+import Assigning.Assignment hiding (Assignment, Error)
+import qualified Assigning.Assignment as Assignment
 import qualified CMarkGFM
 import Data.ByteString (ByteString)
 import Data.Functor (void)
 import Data.Record
 import Data.Syntax (makeTerm)
 import qualified Data.Syntax as Syntax
-import Data.Syntax.Assignment hiding (Assignment, Error)
-import qualified Data.Syntax.Assignment as Assignment
 import Data.Term as Term (Term(..), TermF(..), termFAnnotation, termFOut, termIn)
 import qualified Data.Text as Text
 import Data.Text.Encoding (encodeUtf8)

src/Language/Python/Assignment.hs

@@ -6,14 +6,14 @@ module Language.Python.Assignment
 , Term
 ) where
 
+import Assigning.Assignment hiding (Assignment, Error)
+import qualified Assigning.Assignment as Assignment
 import Data.Functor (void)
 import Data.List.NonEmpty (some1)
 import Data.Maybe (fromMaybe)
 import Data.Record
 import Data.Syntax (contextualize, emptyTerm, handleError, infixContext, makeTerm, makeTerm', makeTerm1, parseError, postContextualize)
 import qualified Data.Syntax as Syntax
-import Data.Syntax.Assignment hiding (Assignment, Error)
-import qualified Data.Syntax.Assignment as Assignment
 import qualified Data.Syntax.Comment as Comment
 import qualified Data.Syntax.Declaration as Declaration
 import qualified Data.Syntax.Expression as Expression

src/Language/Ruby/Assignment.hs

@@ -6,14 +6,14 @@ module Language.Ruby.Assignment
 , Term
 ) where
 
+import Assigning.Assignment hiding (Assignment, Error)
+import qualified Assigning.Assignment as Assignment
 import Data.Maybe (fromMaybe)
 import Data.Record
 import Data.Functor (void)
 import Data.List.NonEmpty (some1)
 import Data.Syntax (contextualize, postContextualize, emptyTerm, parseError, handleError, infixContext, makeTerm, makeTerm', makeTerm1)
 import qualified Data.Syntax as Syntax
-import Data.Syntax.Assignment hiding (Assignment, Error)
-import qualified Data.Syntax.Assignment as Assignment
 import qualified Data.Syntax.Comment as Comment
 import qualified Data.Syntax.Declaration as Declaration
 import qualified Data.Syntax.Expression as Expression

src/Language/TypeScript/Assignment.hs

@@ -6,12 +6,12 @@ module Language.TypeScript.Assignment
 , Term
 ) where
 
+import Assigning.Assignment hiding (Assignment, Error)
+import qualified Assigning.Assignment as Assignment
 import Data.Maybe (fromMaybe, catMaybes)
 import Data.Record
 import Data.Syntax (emptyTerm, handleError, parseError, infixContext, makeTerm, makeTerm', makeTerm1, contextualize, postContextualize)
 import qualified Data.Syntax as Syntax
-import Data.Syntax.Assignment hiding (Assignment, Error)
-import qualified Data.Syntax.Assignment as Assignment
 import qualified Data.Syntax.Comment as Comment
 import qualified Data.Syntax.Declaration as Declaration
 import qualified Data.Syntax.Expression as Expression

src/Parser.hs

@@ -20,7 +20,7 @@ import Data.Kind
 import Data.Ix
 import Data.Record
 import qualified Data.Syntax as Syntax
-import Data.Syntax.Assignment
+import Assigning.Assignment
 import Data.Term
 import Data.Union
 import Foreign.Ptr

src/Parser/CMark.hs

@@ -9,7 +9,7 @@ import CMarkGFM
 import Data.Ix
 import Data.Source
 import Data.Term
-import qualified Data.Syntax.Assignment as A (AST, Node(..))
+import qualified Assigning.Assignment as A (AST, Node(..))
 import Info
 import TreeSitter.Language (Symbol(..), SymbolType(..))
 

src/Parser/TreeSitter.hs

@@ -4,6 +4,7 @@ module Parser.TreeSitter
 , parseToAST
 ) where
 
+import qualified Assigning.Assignment as A
 import Category
 import Control.Exception
 import Control.Monad ((<=<))
@@ -15,7 +16,6 @@ import Data.Range
 import Data.Record
 import Data.Source
 import Data.Span
-import qualified Data.Syntax.Assignment as A
 import Data.Term
 import Data.Text (Text, pack)
 import Language

src/Semantic/Task.hs

@@ -25,6 +25,7 @@ module Semantic.Task
 , runTaskWithOptions
 ) where
 
+import qualified Assigning.Assignment as Assignment
 import Control.Exception
 import Control.Monad.Error.Class
 import Control.Monad.IO.Class
@@ -41,7 +42,6 @@ import Data.Functor.Both as Both hiding (snd)
 import Data.Functor.Foldable (cata)
 import Data.Record
 import qualified Data.Syntax as Syntax
-import qualified Data.Syntax.Assignment as Assignment
 import Data.Term
 import Data.Union
 import Decorator (RAlgebra, decoratorWithAlgebra)

test/Data/Syntax/Assignment/Spec.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE DataKinds #-}
 module Data.Syntax.Assignment.Spec where
 
+import Assigning.Assignment
 import Data.Bifunctor (first)
 import Data.ByteString.Char8 as B (ByteString, length, words)
 import Data.Ix
@@ -8,7 +9,6 @@ import Data.Range
 import Data.Semigroup ((<>))
 import Data.Source
 import Data.Span
-import Data.Syntax.Assignment
 import Data.Term
 import GHC.Stack (getCallStack)
 import Prelude hiding (words)