Fix up tests for Name wrapper

test/Data/Functor/Listable.hs

@@ -47,6 +47,7 @@ import qualified Data.Syntax as Syntax
 import qualified Data.Syntax.Comment as Comment
 import qualified Data.Syntax.Declaration as Declaration
 import qualified Data.Syntax.Statement as Statement
+import qualified Data.Abstract.FreeVariables as FV
 import Data.Term
 import Data.Text as T (Text, pack)
 import qualified Data.Text.Encoding as T
@@ -256,6 +257,9 @@ type ListableSyntax = Union
    , []
    ]
 
+instance Listable FV.Name where
+  tiers = cons1 FV.name
+
 instance Listable1 Gram where
   liftTiers tiers = liftCons2 (liftTiers (liftTiers tiers)) (liftTiers (liftTiers tiers)) Gram
 

test/Rendering/TOC/Spec.hs

@@ -166,14 +166,14 @@ programWithChange :: Term' -> Diff'
 programWithChange body = merge (programInfo, programInfo) (inj [ function' ])
   where
     function' = merge (Just (FunctionDeclaration "foo" mempty Nothing) :. emptyInfo, Just (FunctionDeclaration "foo" mempty Nothing) :. emptyInfo) (inj (Declaration.Function [] name' [] (merge (Nothing :. emptyInfo, Nothing :. emptyInfo) (inj [ inserting body ]))))
-    name' = let info = Nothing :. emptyInfo in merge (info, info) (inj (Syntax.Identifier "foo"))
+    name' = let info = Nothing :. emptyInfo in merge (info, info) (inj (Syntax.Identifier (name "foo")))
 
 -- Return a diff where term is inserted in the program, below a function found on both sides of the diff.
 programWithChangeOutsideFunction :: Term' -> Diff'
 programWithChangeOutsideFunction term = merge (programInfo, programInfo) (inj [ function', term' ])
   where
     function' = merge (Just (FunctionDeclaration "foo" mempty Nothing) :. emptyInfo, Just (FunctionDeclaration "foo" mempty Nothing) :. emptyInfo) (inj (Declaration.Function [] name' [] (merge (Nothing :. emptyInfo, Nothing :. emptyInfo) (inj []))))
-    name' = let info = Nothing :. emptyInfo in  merge (info, info) (inj (Syntax.Identifier "foo"))
+    name' = let info = Nothing :. emptyInfo in  merge (info, info) (inj (Syntax.Identifier (name "foo")))
     term' = inserting term
 
 programWithInsert :: Text -> Term' -> Diff'
@@ -191,7 +191,7 @@ programOf diff = merge (programInfo, programInfo) (inj [ diff ])
 functionOf :: Text -> Term' -> Term'
 functionOf n body = termIn (Just (FunctionDeclaration n mempty Nothing) :. emptyInfo) (inj (Declaration.Function [] name' [] (termIn (Nothing :. emptyInfo) (inj [body]))))
   where
-    name' = termIn (Nothing :. emptyInfo) (inj (Syntax.Identifier (encodeUtf8 n)))
+    name' = termIn (Nothing :. emptyInfo) (inj (Syntax.Identifier (name (encodeUtf8 n))))
 
 programInfo :: Record '[Maybe Declaration, Range, Span]
 programInfo = Nothing :. emptyInfo
@@ -218,7 +218,7 @@ blobsForPaths :: Both FilePath -> IO BlobPair
 blobsForPaths = readFilePair . fmap ("test/fixtures/toc/" <>)
 
 blankDiff :: Diff'
-blankDiff = merge (arrayInfo, arrayInfo) (inj [ inserting (termIn literalInfo (inj (Syntax.Identifier "\"a\""))) ])
+blankDiff = merge (arrayInfo, arrayInfo) (inj [ inserting (termIn literalInfo (inj (Syntax.Identifier (name "\"a\"")))) ])
   where
     arrayInfo = Nothing :. Range 0 3 :. Span (Pos 1 1) (Pos 1 5) :. Nil
     literalInfo = Nothing :. Range 1 2 :. Span (Pos 1 2) (Pos 1 4) :. Nil

test/fixtures/go/binary-expressions.diffA-B.txt

@@ -27,19 +27,26 @@
       ->(Identifier) }
       { (Identifier)
       ->(Identifier) })
-    {+(Not
+      (Not
-      {+(Equal
+        (Equal
-        {+(Identifier)+}
+        { (Identifier)
-        {+(Identifier)+})+})+}
+        ->(Identifier) }
-    {+(LessThan
+        { (Identifier)
-      {+(Identifier)+}
+        ->(Identifier) }))
-      {+(Identifier)+})+}
+      (LessThan
+      { (Identifier)
+      ->(Identifier) }
+      { (Identifier)
+      ->(Identifier) })
     {+(LessThanEqual
       {+(Identifier)+}
       {+(Identifier)+})+}
-    {+(GreaterThan
+    { (LessThanEqual
+      {-(Identifier)-}
+      {-(Identifier)-})
+    ->(GreaterThan
       {+(Identifier)+}
-      {+(Identifier)+})+}
+      {+(Identifier)+}) }
     {+(GreaterThanEqual
       {+(Identifier)+}
       {+(Identifier)+})+}
@@ -76,16 +83,6 @@
     {+(BAnd
       {+(Identifier)+}
       {+(Identifier)+})+}
-    {-(Not
-      {-(Equal
-        {-(Identifier)-}
-        {-(Identifier)-})-})-}
-    {-(LessThan
-      {-(Identifier)-}
-      {-(Identifier)-})-}
-    {-(LessThanEqual
-      {-(Identifier)-}
-      {-(Identifier)-})-}
     {-(GreaterThan
       {-(Identifier)-}
       {-(Identifier)-})-}

test/fixtures/go/binary-expressions.diffB-A.txt

@@ -27,13 +27,17 @@
       ->(Identifier) }
       { (Identifier)
       ->(Identifier) })
-    {+(Not
+      (Not
-      {+(Equal
+        (Equal
-        {+(Identifier)+}
+        { (Identifier)
-        {+(Identifier)+})+})+}
+        ->(Identifier) }
-    {+(LessThan
+        { (Identifier)
-      {+(Identifier)+}
+        ->(Identifier) }))
-      {+(Identifier)+})+}
+      (LessThan
+      { (Identifier)
+      ->(Identifier) }
+      { (Identifier)
+      ->(Identifier) })
     {+(LessThanEqual
       {+(Identifier)+}
       {+(Identifier)+})+}
@@ -76,13 +80,6 @@
     {+(BAnd
       {+(Identifier)+}
       {+(Identifier)+})+}
-    {-(Not
-      {-(Equal
-        {-(Identifier)-}
-        {-(Identifier)-})-})-}
-    {-(LessThan
-      {-(Identifier)-}
-      {-(Identifier)-})-}
     {-(LessThanEqual
       {-(Identifier)-}
       {-(Identifier)-})-}

test/fixtures/go/const-with-implicit-values.diffA-B.txt

@@ -6,15 +6,18 @@
     (Identifier)
     ([])
     (
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Identifier)+})+}
       (Assignment
       { (Identifier)
       ->(Identifier) }
-        (Identifier))
+      { (Identifier)
+      ->([]) })
       (Assignment
       { (Identifier)
       ->(Identifier) }
         ([]))
-      (Assignment
+    {-(Assignment
-      { (Identifier)
+      {-(Identifier)-}
-      ->(Identifier) }
+      {-([])-})-})))
-        ([])))))

test/fixtures/go/const-with-implicit-values.diffB-A.txt

@@ -6,15 +6,20 @@
     (Identifier)
     ([])
     (
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Identifier)+})+}
       (Assignment
       { (Identifier)
       ->(Identifier) }
-        (Identifier))
-      (Assignment
       { (Identifier)
-      ->(Identifier) }
+      ->([]) })
-        ([]))
+    {+(Assignment
-      (Assignment
+      {+(Identifier)+}
-      { (Identifier)
+      {+([])+})+}
-      ->(Identifier) }
+    {-(Assignment
-        ([])))))
+      {-(Identifier)-}
+      {-([])-})-}
+    {-(Assignment
+      {-(Identifier)-}
+      {-([])-})-})))

test/fixtures/go/grouped-import-declarations.diffA-B.txt

@@ -2,18 +2,18 @@
   (Package
     (Identifier))
   (
+  {+(QualifiedImport
+    {+(Identifier)+})+}
+  {+(Import
+    {+(TextElement)+})+}
   { (QualifiedImport
     {-(Identifier)-})
   ->(QualifiedImport
     {+(Identifier)+}) }
-  { (Import
+  {-(Import
-    {-(TextElement)-})
+    {-(TextElement)-})-}
-  ->(Import
+  {-(QualifiedImport
-    {+(TextElement)+}) }
+    {-(Identifier)-})-})
-  { (QualifiedImport
-    {-(Identifier)-})
-  ->(QualifiedImport
-    {+(Identifier)+}) })
   (Function
     (Empty)
     (Identifier)

test/fixtures/go/grouped-import-declarations.diffB-A.txt

@@ -2,18 +2,18 @@
   (Package
     (Identifier))
   (
+  {+(QualifiedImport
+    {+(Identifier)+})+}
+  {+(Import
+    {+(TextElement)+})+}
   { (QualifiedImport
     {-(Identifier)-})
   ->(QualifiedImport
     {+(Identifier)+}) }
-  { (Import
+  {-(Import
-    {-(TextElement)-})
+    {-(TextElement)-})-}
-  ->(Import
+  {-(QualifiedImport
-    {+(TextElement)+}) }
+    {-(Identifier)-})-})
-  { (QualifiedImport
-    {-(Identifier)-})
-  ->(QualifiedImport
-    {+(Identifier)+}) })
   (Function
     (Empty)
     (Identifier)

test/fixtures/go/single-import-declarations.diffA-B.txt

@@ -1,18 +1,18 @@
 (Program
   (Package
     (Identifier))
-{ (QualifiedImport
+{+(QualifiedImport
-  {-(Identifier)-})
+  {+(Identifier)+})+}
-->(QualifiedImport
+{+(Import
-  {+(Identifier)+}) }
+  {+(TextElement)+})+}
-{ (Import
+{+(QualifiedImport
-  {-(TextElement)-})
+  {+(Identifier)+})+}
-->(Import
+{-(QualifiedImport
-  {+(TextElement)+}) }
+  {-(Identifier)-})-}
-{ (QualifiedImport
+{-(Import
-  {-(Identifier)-})
+  {-(TextElement)-})-}
-->(QualifiedImport
+{-(QualifiedImport
-  {+(Identifier)+}) }
+  {-(Identifier)-})-}
   (Function
     (Empty)
     (Identifier)

test/fixtures/go/single-import-declarations.diffB-A.txt

@@ -1,18 +1,18 @@
 (Program
   (Package
     (Identifier))
+{+(QualifiedImport
+  {+(Identifier)+})+}
+{+(Import
+  {+(TextElement)+})+}
 { (QualifiedImport
   {-(Identifier)-})
 ->(QualifiedImport
   {+(Identifier)+}) }
-{ (Import
+{-(Import
-  {-(TextElement)-})
+  {-(TextElement)-})-}
-->(Import
+{-(QualifiedImport
-  {+(TextElement)+}) }
+  {-(Identifier)-})-}
-{ (QualifiedImport
-  {-(Identifier)-})
-->(QualifiedImport
-  {+(Identifier)+}) }
   (Function
     (Empty)
     (Identifier)

test/fixtures/go/slice-expressions.diffA-B.txt

@@ -11,11 +11,14 @@
       {+(Integer)+}
       {+(Empty)+}
       {+(Empty)+})+}
-    {+(Slice
+      (Slice
-      {+(Identifier)+}
+      { (Identifier)
-      {+(Empty)+}
+      ->(Identifier) }
-      {+(Integer)+}
+      { (Integer)
-      {+(Empty)+})+}
+      ->(Empty) }
+      { (Empty)
+      ->(Integer) }
+        (Empty))
     {+(Slice
       {+(Identifier)+}
       {+(Integer)+}
@@ -24,9 +27,10 @@
       (Slice
       { (Identifier)
       ->(Identifier) }
-        (Integer)
       { (Empty)
       ->(Integer) }
+      { (Integer)
+      ->(Integer) }
       { (Empty)
       ->(Integer) })
     {+(Slice
@@ -34,11 +38,6 @@
       {+(Integer)+}
       {+(Integer)+}
       {+(Empty)+})+}
-    {-(Slice
-      {-(Identifier)-}
-      {-(Empty)-}
-      {-(Integer)-}
-      {-(Empty)-})-}
     {-(Slice
       {-(Identifier)-}
       {-(Empty)-}

test/fixtures/go/unary-expressions.diffA-B.txt

@@ -8,35 +8,25 @@
     (
     { (Identifier)
     ->(Identifier) }
-    {+(Negate
+      (Negate
-      {+(Identifier)+})+}
+      { (Identifier)
-    {+(Not
+      ->(Identifier) })
-      {+(ReceiveOperator
+      (Not
-        {+(Identifier)+})+})+}
+        (ReceiveOperator
-    {+(Pointer
+        { (Identifier)
-      {+(Call
+        ->(Identifier) }))
-        {+(Identifier)+}
+      (Pointer
-        {+([])+}
+        (Call
-        {+(Empty)+})+})+}
+        { (Identifier)
-    {+(Complement
+        ->(Identifier) }
-      {+(Identifier)+})+}
+          ([])
-    {+(Reference
+          (Empty)))
-      {+(Identifier)+})+}
+      (Complement
-    {+(ReceiveOperator
+      { (Identifier)
-      {+(Identifier)+})+}
+      ->(Identifier) })
-    {-(Negate
+      (Reference
-      {-(Identifier)-})-}
+      { (Identifier)
-    {-(Not
+      ->(Identifier) })
-      {-(ReceiveOperator
+      (ReceiveOperator
-        {-(Identifier)-})-})-}
+      { (Identifier)
-    {-(Pointer
+      ->(Identifier) }))))
-      {-(Call
-        {-(Identifier)-}
-        {-([])-}
-        {-(Empty)-})-})-}
-    {-(Complement
-      {-(Identifier)-})-}
-    {-(Reference
-      {-(Identifier)-})-}
-    {-(ReceiveOperator
-      {-(Identifier)-})-})))

test/fixtures/go/unary-expressions.diffB-A.txt

@@ -8,35 +8,25 @@
     (
     { (Identifier)
     ->(Identifier) }
-    {+(Negate
+      (Negate
-      {+(Identifier)+})+}
+      { (Identifier)
-    {+(Not
+      ->(Identifier) })
-      {+(ReceiveOperator
+      (Not
-        {+(Identifier)+})+})+}
+        (ReceiveOperator
-    {+(Pointer
+        { (Identifier)
-      {+(Call
+        ->(Identifier) }))
-        {+(Identifier)+}
+      (Pointer
-        {+([])+}
+        (Call
-        {+(Empty)+})+})+}
+        { (Identifier)
-    {+(Complement
+        ->(Identifier) }
-      {+(Identifier)+})+}
+          ([])
-    {+(Reference
+          (Empty)))
-      {+(Identifier)+})+}
+      (Complement
-    {+(ReceiveOperator
+      { (Identifier)
-      {+(Identifier)+})+}
+      ->(Identifier) })
-    {-(Negate
+      (Reference
-      {-(Identifier)-})-}
+      { (Identifier)
-    {-(Not
+      ->(Identifier) })
-      {-(ReceiveOperator
+      (ReceiveOperator
-        {-(Identifier)-})-})-}
+      { (Identifier)
-    {-(Pointer
+      ->(Identifier) }))))
-      {-(Call
-        {-(Identifier)-}
-        {-([])-}
-        {-(Empty)-})-})-}
-    {-(Complement
-      {-(Identifier)-})-}
-    {-(Reference
-      {-(Identifier)-})-}
-    {-(ReceiveOperator
-      {-(Identifier)-})-})))

test/fixtures/javascript/export.diffA-B.txt

@@ -35,15 +35,15 @@
         (Identifier)
       { (Empty)
       ->(Identifier) })
-    {+(Assignment
-      {+(Empty)+}
-      {+(Identifier)+}
-      {+(Empty)+})+}
       (Assignment
         (Empty)
       { (Identifier)
       ->(Identifier) }
-        (Empty))))
+        (Empty))
+    {+(Assignment
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Empty)+})+}))
   (DefaultExport
   { (Identifier)
   ->(Identifier) })

test/fixtures/javascript/export.diffB-A.txt

@@ -35,14 +35,11 @@
         (Identifier)
       { (Identifier)
       ->(Empty) })
-    {+(Assignment
+      (Assignment
-      {+(Empty)+}
+        (Empty)
-      {+(Identifier)+}
+      { (Identifier)
-      {+(Empty)+})+}
+      ->(Identifier) }
-    {-(Assignment
+        (Empty))
-      {-(Empty)-}
-      {-(Identifier)-}
-      {-(Empty)-})-}
     {-(Assignment
       {-(Empty)-}
       {-(Identifier)-}

test/fixtures/javascript/import.diffA-B.txt

@@ -1,14 +1,11 @@
 (Program
-{ (Import)
+{+(Import)+}
-->(Import) }
+{+(QualifiedAliasedImport
-{ (QualifiedAliasedImport
+  {+(Identifier)+})+}
-  {-(Identifier)-})
+{+(Import)+}
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
 {+(Import)+}
 { (Import)
 ->(Import) }
-{+(Import)+}
 {+(
   {+(Import)+}
   {+(Import)+})+}
@@ -17,6 +14,9 @@
   {+(QualifiedAliasedImport
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
 {-(Import)-}
 {-(Import)-}
 {-(

test/fixtures/javascript/import.diffB-A.txt

@@ -1,10 +1,7 @@
 (Program
-{ (Import)
+{+(Import)+}
-->(Import) }
+{+(QualifiedAliasedImport
-{ (QualifiedAliasedImport
+  {+(Identifier)+})+}
-  {-(Identifier)-})
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
 {+(Import)+}
 {+(Import)+}
 { (Import)
@@ -17,6 +14,9 @@
   {+(QualifiedAliasedImport
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
 {-(Import)-}
 {-(Import)-}
 {-(

test/fixtures/python/assignment.diffA-B.txt

@@ -10,18 +10,14 @@
   { (Identifier)
   ->(Identifier) }
     (Integer))
-{+(Assignment
+  (Assignment
-  {+(Identifier)+}
+  { (
-  {+(
-    {+(Integer)+}
-    {+(Integer)+})+})+}
-{-(Assignment
-  {-(
     {-(Identifier)-}
-    {-(Identifier)-})-}
+    {-(Identifier)-})
-  {-(
+  ->(Identifier) }
-    {-(Integer)-}
+    (
-    {-(Integer)-})-})-}
+      (Integer)
+      (Integer)))
 {-(Assignment
   {-(Identifier)-}
   {-(

test/fixtures/python/augmented-assignment.diffA-B.txt

@@ -7,21 +7,21 @@
   ->(RShift
     {+(Identifier)+}
     {+(Integer)+}) })
-{+(Assignment
-  {+(Identifier)+}
-  {+(DividedBy
-    {+(Identifier)+}
-    {+(Integer)+})+})+}
   (Assignment
-    (Identifier)
+  { (Identifier)
+  ->(Identifier) }
   { (RShift
     {-(Identifier)-}
     {-(Integer)-})
+  ->(DividedBy
+    {+(Identifier)+}
+    {+(Integer)+}) })
+  (Assignment
+  { (Identifier)
+  ->(Identifier) }
+  { (DividedBy
+    {-(Identifier)-}
+    {-(Integer)-})
   ->(Plus
     {+(Identifier)+}
-    {+(Integer)+}) })
+    {+(Integer)+}) }))
-{-(Assignment
-  {-(Identifier)-}
-  {-(DividedBy
-    {-(Identifier)-}
-    {-(Integer)-})-})-})

test/fixtures/python/augmented-assignment.diffB-A.txt

@@ -7,23 +7,21 @@
   ->(Plus
     {+(Identifier)+}
     {+(Integer)+}) })
-{+(Assignment
+  (Assignment
-  {+(Identifier)+}
+  { (Identifier)
-  {+(RShift
+  ->(Identifier) }
-    {+(Identifier)+}
+  { (DividedBy
-    {+(Integer)+})+})+}
-{+(Assignment
-  {+(Identifier)+}
-  {+(DividedBy
-    {+(Identifier)+}
-    {+(Integer)+})+})+}
-{-(Assignment
-  {-(Identifier)-}
-  {-(DividedBy
     {-(Identifier)-}
-    {-(Integer)-})-})-}
+    {-(Integer)-})
-{-(Assignment
+  ->(RShift
-  {-(Identifier)-}
+    {+(Identifier)+}
-  {-(Plus
+    {+(Integer)+}) })
+  (Assignment
+  { (Identifier)
+  ->(Identifier) }
+  { (Plus
     {-(Identifier)-}
-    {-(Integer)-})-})-})
+    {-(Integer)-})
+  ->(DividedBy
+    {+(Identifier)+}
+    {+(Integer)+}) }))

test/fixtures/python/comparison-operator.diffB-A.txt

@@ -5,22 +5,22 @@
 {+(LessThanEqual
   {+(Identifier)+}
   {+(Identifier)+})+}
+{+(Not
+  {+(Equal
+    {+(Identifier)+}
+    {+(Identifier)+})+})+}
+{+(GreaterThanEqual
+  {+(Identifier)+}
+  {+(Identifier)+})+}
+{+(GreaterThan
+  {+(Identifier)+}
+  {+(Identifier)+})+}
   (Not
     (Equal
     { (Identifier)
     ->(Identifier) }
     { (Identifier)
     ->(Identifier) }))
-{+(GreaterThanEqual
-  {+(Identifier)+}
-  {+(Identifier)+})+}
-{+(GreaterThan
-  {+(Identifier)+}
-  {+(Identifier)+})+}
-{+(Not
-  {+(Equal
-    {+(Identifier)+}
-    {+(Identifier)+})+})+}
 {+(Member
   {+(Identifier)+}
   {+(Identifier)+})+}

test/fixtures/python/import-from-statement.diffB-A.txt

@@ -3,10 +3,10 @@
 {+(Import)+}
 { (Import)
 ->(Import) }
-{ (Import)
+{+(Import)+}
-->(Import) }
 {+(Import)+}
 {-(Import)-}
 {-(Import)-}
 {-(Import)-}
+{-(Import)-}
 {-(Import)-})

test/fixtures/python/tuple.diffA-B.txt

@@ -1,11 +1,14 @@
 (Program
-  (Tuple
+{+(Tuple
-  {-(Identifier)-}
-    (Identifier)
   {+(Identifier)+}
-  {+(Identifier)+})
+  {+(Identifier)+}
+  {+(Identifier)+})+}
   (Tuple
   {-(Identifier)-}
     (Identifier)
-    (Identifier))
+  {+(Identifier)+})
-{+(Identifier)+})
+{+(Identifier)+}
+{-(Tuple
+  {-(Identifier)-}
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/python/tuple.diffB-A.txt

@@ -1,11 +1,13 @@
 (Program
-  (Tuple
+{+(Tuple
-  {-(Identifier)-}
+  {+(Identifier)+}
-  {-(Identifier)-}
+  {+(Identifier)+})+}
-    (Identifier)
-  {+(Identifier)+})
   (Tuple
   {+(Identifier)+}
     (Identifier)
-    (Identifier))
+    (Identifier)
+  {-(Identifier)-})
+{-(Tuple
+  {-(Identifier)-}
+  {-(Identifier)-})-}
 {-(Identifier)-})

test/fixtures/ruby/hash.diffA-B.txt

@@ -1,23 +1,20 @@
 (Program
   (Hash
-  {+(KeyValue
+    (KeyValue
-    {+(Identifier)+}
+    { (Symbol)
-    {+(TextElement)+})+}
+    ->(Identifier) }
-  {+(KeyValue
+    { (TextElement)
-    {+(Identifier)+}
+    ->(TextElement) })
-    {+(Integer)+})+}
+    (KeyValue
-  {+(KeyValue
+    { (Symbol)
-    {+(Identifier)+}
+    ->(Identifier) }
-    {+(Boolean)+})+}
+    { (Integer)
-  {-(KeyValue
+    ->(Integer) })
-    {-(Symbol)-}
+    (KeyValue
-    {-(TextElement)-})-}
+    { (TextElement)
-  {-(KeyValue
+    ->(Identifier) }
-    {-(Symbol)-}
+    { (Boolean)
-    {-(Integer)-})-}
+    ->(Boolean) })
-  {-(KeyValue
-    {-(TextElement)-}
-    {-(Boolean)-})-}
   {-(KeyValue
     {-(Symbol)-}
     {-(Integer)-})-})

test/fixtures/ruby/hash.diffB-A.txt

@@ -1,25 +1,23 @@
 (Program
   (Hash
-  {+(KeyValue
+    (KeyValue
-    {+(Symbol)+}
+    { (Identifier)
-    {+(TextElement)+})+}
+    ->(Symbol) }
-  {+(KeyValue
+    { (TextElement)
-    {+(Symbol)+}
+    ->(TextElement) })
-    {+(Integer)+})+}
+    (KeyValue
+    { (Identifier)
+    ->(Symbol) }
+    { (Integer)
+    ->(Integer) })
     (KeyValue
     { (Identifier)
     ->(TextElement) }
-    { (TextElement)
+    { (Boolean)
     ->(Boolean) })
   {+(KeyValue
     {+(Symbol)+}
-    {+(Integer)+})+}
+    {+(Integer)+})+})
-  {-(KeyValue
-    {-(Identifier)-}
-    {-(Integer)-})-}
-  {-(KeyValue
-    {-(Identifier)-}
-    {-(Boolean)-})-})
 {+(Hash)+}
 {+(Hash
   {+(Context

test/fixtures/typescript/export.diffA-B.txt

@@ -35,15 +35,15 @@
         (Identifier)
       { (Empty)
       ->(Identifier) })
-    {+(Assignment
-      {+(Empty)+}
-      {+(Identifier)+}
-      {+(Empty)+})+}
       (Assignment
         (Empty)
       { (Identifier)
       ->(Identifier) }
-        (Empty))))
+        (Empty))
+    {+(Assignment
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Empty)+})+}))
   (DefaultExport
   { (Identifier)
   ->(Identifier) })

test/fixtures/typescript/export.diffB-A.txt

@@ -35,14 +35,11 @@
         (Identifier)
       { (Identifier)
       ->(Empty) })
-    {+(Assignment
+      (Assignment
-      {+(Empty)+}
+        (Empty)
-      {+(Identifier)+}
+      { (Identifier)
-      {+(Empty)+})+}
+      ->(Identifier) }
-    {-(Assignment
+        (Empty))
-      {-(Empty)-}
-      {-(Identifier)-}
-      {-(Empty)-})-}
     {-(Assignment
       {-(Empty)-}
       {-(Identifier)-}

test/fixtures/typescript/import.diffA-B.txt

@@ -1,14 +1,11 @@
 (Program
-{ (Import)
+{+(Import)+}
-->(Import) }
+{+(QualifiedAliasedImport
-{ (QualifiedAliasedImport
+  {+(Identifier)+})+}
-  {-(Identifier)-})
+{+(Import)+}
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
 {+(Import)+}
 { (Import)
 ->(Import) }
-{+(Import)+}
 {+(
   {+(Import)+}
   {+(Import)+})+}
@@ -17,6 +14,9 @@
   {+(QualifiedAliasedImport
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
 {-(Import)-}
 {-(Import)-}
 {-(

test/fixtures/typescript/import.diffB-A.txt

@@ -1,10 +1,7 @@
 (Program
-{ (Import)
+{+(Import)+}
-->(Import) }
+{+(QualifiedAliasedImport
-{ (QualifiedAliasedImport
+  {+(Identifier)+})+}
-  {-(Identifier)-})
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
 {+(Import)+}
 {+(Import)+}
 { (Import)
@@ -17,8 +14,11 @@
   {+(QualifiedAliasedImport
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
-{+(QualifiedAliasedImport
+{ (QualifiedAliasedImport
-  {+(Identifier)+})+}
+  {-(Identifier)-})
+->(QualifiedAliasedImport
+  {+(Identifier)+}) }
+{-(Import)-}
 {-(Import)-}
 {-(Import)-}
 {-(