diff --git a/src/Algorithm.hs b/src/Algorithm.hs index 5acb32092..cf4e9fede 100644 --- a/src/Algorithm.hs +++ b/src/Algorithm.hs @@ -106,6 +106,36 @@ algorithmForTerms t1@(Term (In ann1 f1)) t2@(Term (In ann2 f2)) <|> insertF . In ann2 <$> subalgorithmFor byInserting ( mergeFor t1) f2 where mergeFor (Term (In ann1 f1)) (Term (In ann2 f2)) = merge (ann1, ann2) <$> algorithmFor f1 f2 +-- | An O(1) relation on terms indicating their non-recursive comparability (i.e. are they of the same “kind” in a way that warrants comparison), defined in terms of the comparability of their respective syntax. +comparableTerms :: Diffable syntax + => TermF syntax ann1 term1 + -> TermF syntax ann2 term2 + -> Bool +comparableTerms (In _ syntax1) (In _ syntax2) = comparableTo syntax1 syntax2 + +-- | An O(n) relation on terms indicating their recursive equivalence (i.e. are they _notionally_ “the same,” as distinct from literal equality), defined at each node in terms of the equivalence of their respective syntax, computed first on a nominated subterm (if any), falling back to substructural equivalence (e.g. equivalence of one term against the subject of the other, annotating term), and finally to equality. +equivalentTerms :: (Diffable syntax, Eq1 syntax) + => Term syntax ann1 + -> Term syntax ann2 + -> Bool +equivalentTerms term1@(Term (In _ syntax1)) term2@(Term (In _ syntax2)) + = fromMaybe False (equivalentTerms <$> equivalentBySubterm syntax1 <*> equivalentBySubterm syntax2) + || runEquivalence (subalgorithmFor pure (Equivalence . flip equivalentTerms term2) syntax1) + || runEquivalence (subalgorithmFor pure (Equivalence . equivalentTerms term1) syntax2) + || liftEq equivalentTerms syntax1 syntax2 + +-- | A constant 'Alternative' functor used by 'equivalentTerms' to compute the substructural equivalence of syntax. +newtype Equivalence a = Equivalence { runEquivalence :: Bool } + deriving (Eq, Functor) + +instance Applicative Equivalence where + pure _ = Equivalence True + Equivalence a <*> Equivalence b = Equivalence (a && b) + +instance Alternative Equivalence where + empty = Equivalence False + Equivalence a <|> Equivalence b = Equivalence (a || b) + -- | A type class for determining what algorithm to use for diffing two terms. class Diffable f where -- | Construct an algorithm to diff a pair of @f@s populated with disjoint terms. @@ -136,22 +166,43 @@ class Diffable f where -> g (f b) -- ^ The resulting algorithm (or other 'Alternative' context), producing the traversed syntax. subalgorithmFor _ _ _ = empty + -- | Syntax having a human-provided identifier, such as function/method definitions, can use equivalence of identifiers as a proxy for their overall equivalence, improving the quality & efficiency of the diff as a whole. + -- + -- This can also be used for annotation nodes to ensure that their subjects’ equivalence is weighed appropriately. + -- + -- Other syntax should use the default definition, and thus have equivalence computed piece-wise. + equivalentBySubterm :: f a -> Maybe a + equivalentBySubterm _ = Nothing + + -- | A relation on syntax values indicating their In general this should be true iff both values have the same constructor (this is the relation computed by the default, generic definition). + -- + -- For syntax with constant fields which serve as a classifier, this method can be overloaded to consider equality on that classifier in addition to/instead of the constructors themselves, and thus limit the comparisons accordingly. + comparableTo :: f term1 -> f term2 -> Bool + default comparableTo :: (Generic1 f, GDiffable (Rep1 f)) => f term1 -> f term2 -> Bool + comparableTo = genericComparableTo + genericAlgorithmFor :: (Generic1 f, GDiffable (Rep1 f)) => f term1 -> f term2 -> Algorithm term1 term2 result (f result) -genericAlgorithmFor a b = to1 <$> galgorithmFor (from1 a) (from1 b) +genericAlgorithmFor a1 a2 = to1 <$> galgorithmFor (from1 a1) (from1 a2) + +genericComparableTo :: (Generic1 f, GDiffable (Rep1 f)) => f term1 -> f term2 -> Bool +genericComparableTo a1 a2 = gcomparableTo (from1 a1) (from1 a2) --- | Diff a Union of Syntax terms. Left is the "rest" of the Syntax terms in the Union, --- Right is the "head" of the Union. 'weaken' relaxes the Union to allow the possible --- diff terms from the "rest" of the Union, and 'inj' adds the diff terms into the Union. --- NB: If Left or Right Syntax terms in our Union don't match, we fail fast by returning Nothing. +-- | 'Diffable' for 'Union's of syntax functors is defined in general by straightforward lifting of each method into the functors in the 'Union'. instance Apply Diffable fs => Diffable (Union fs) where algorithmFor u1 u2 = fromMaybe empty (apply2' (Proxy :: Proxy Diffable) (\ inj f1 f2 -> inj <$> algorithmFor f1 f2) u1 u2) subalgorithmFor blur focus = apply' (Proxy :: Proxy Diffable) (\ inj f -> inj <$> subalgorithmFor blur focus f) + equivalentBySubterm = apply (Proxy :: Proxy Diffable) equivalentBySubterm + + -- | Comparability on 'Union's is defined first by comparability of their contained functors (when they’re the same), falling back to using 'subalgorithmFor' to opt substructurally-diffable syntax into comparisons (e.g. to allow annotating nodes to be compared against the kind of nodes they annotate). + comparableTo u1 u2 = fromMaybe False (apply2 proxy comparableTo u1 u2 <|> True <$ subalgorithmFor pure pure u1 <|> True <$ subalgorithmFor pure pure u2) + where proxy = Proxy :: Proxy Diffable + -- | Diff two 'Maybe's. instance Diffable Maybe where algorithmFor = diffMaybe @@ -168,10 +219,15 @@ instance Diffable NonEmpty where class GDiffable f where galgorithmFor :: f term1 -> f term2 -> Algorithm term1 term2 result (f result) + gcomparableTo :: f term1 -> f term2 -> Bool + gcomparableTo _ _ = True + -- | Diff two constructors (M1 is the Generic1 newtype for meta-information (possibly related to type constructors, record selectors, and data types)) instance GDiffable f => GDiffable (M1 i c f) where galgorithmFor (M1 a1) (M1 a2) = M1 <$> galgorithmFor a1 a2 + gcomparableTo (M1 a1) (M1 a2) = gcomparableTo a1 a2 + -- | Diff the fields of a product type. -- i.e. data Foo a b = Foo a b (the 'Foo a b' is captured by 'a :*: b'). instance (GDiffable f, GDiffable g) => GDiffable (f :*: g) where @@ -184,6 +240,10 @@ instance (GDiffable f, GDiffable g) => GDiffable (f :+: g) where galgorithmFor (R1 b1) (R1 b2) = R1 <$> galgorithmFor b1 b2 galgorithmFor _ _ = empty + gcomparableTo (L1 _) (L1 _) = True + gcomparableTo (R1 _) (R1 _) = True + gcomparableTo _ _ = False + -- | Diff two parameters (Par1 is the Generic1 newtype representing a type parameter). -- i.e. data Foo a = Foo a (the 'a' is captured by Par1). instance GDiffable Par1 where diff --git a/src/Data/Syntax.hs b/src/Data/Syntax.hs index b31498e0f..1184ceeda 100644 --- a/src/Data/Syntax.hs +++ b/src/Data/Syntax.hs @@ -168,7 +168,9 @@ data Context a = Context { contextTerms :: NonEmpty a, contextSubject :: a } deriving (Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable) instance Diffable Context where - subalgorithmFor blur focus (Context n1 s1) = Context <$> traverse blur n1 <*> focus s1 + subalgorithmFor blur focus (Context n s) = Context <$> traverse blur n <*> focus s + + equivalentBySubterm = Just . contextSubject instance Eq1 Context where liftEq = genericLiftEq instance Ord1 Context where liftCompare = genericLiftCompare diff --git a/src/Data/Syntax/Declaration.hs b/src/Data/Syntax/Declaration.hs index 9bb1ef512..6ad6b717d 100644 --- a/src/Data/Syntax/Declaration.hs +++ b/src/Data/Syntax/Declaration.hs @@ -10,7 +10,10 @@ import Data.Mergeable import GHC.Generics data Function a = Function { functionContext :: ![a], functionName :: !a, functionParameters :: ![a], functionBody :: !a } - deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable) + deriving (Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable) + +instance Diffable Function where + equivalentBySubterm = Just . functionName instance Eq1 Function where liftEq = genericLiftEq instance Ord1 Function where liftCompare = genericLiftCompare @@ -19,7 +22,10 @@ instance Show1 Function where liftShowsPrec = genericLiftShowsPrec -- TODO: How should we represent function types, where applicable? data Method a = Method { methodContext :: ![a], methodReceiver :: !a, methodName :: !a, methodParameters :: ![a], methodBody :: !a } - deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable) + deriving (Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable) + +instance Diffable Method where + equivalentBySubterm = Just . methodName instance Eq1 Method where liftEq = genericLiftEq instance Ord1 Method where liftCompare = genericLiftCompare diff --git a/src/Interpreter.hs b/src/Interpreter.hs index 9123f5922..f7eb32fa3 100644 --- a/src/Interpreter.hs +++ b/src/Interpreter.hs @@ -2,8 +2,6 @@ module Interpreter ( diffTerms , diffSyntaxTerms -, comparableByConstructor -, equivalentTerms ) where import Algorithm @@ -13,15 +11,11 @@ import Data.Align.Generic import Data.Diff import Data.Functor.Classes import Data.Hashable (Hashable) -import Data.Maybe (fromMaybe, isJust) +import Data.Maybe (fromMaybe) import Data.Record -import qualified Data.Syntax as Syntax import Data.Syntax.Algebra -import qualified Data.Syntax.Declaration as Declaration import Data.Term import Data.Text (Text) -import Data.These -import Data.Union import Info hiding (Empty, Return) import RWS import Syntax (Syntax(Leaf)) @@ -35,11 +29,11 @@ diffSyntaxTerms :: (HasField fields1 Category, HasField fields2 Category) diffSyntaxTerms = decoratingWith comparableByCategory (equalTerms comparableByCategory) getLabel getLabel -- | Diff two à la carte terms recursively. -diffTerms :: (Declaration.Method :< fs, Declaration.Function :< fs, Syntax.Context :< fs, Apply Diffable fs, Apply Foldable fs, Apply Functor fs, Apply GAlign fs, Apply Show1 fs, Apply Traversable fs) - => Term (Union fs) (Record fields1) - -> Term (Union fs) (Record fields2) - -> Diff (Union fs) (Record fields1) (Record fields2) -diffTerms = decoratingWith comparableByConstructor equivalentTerms constructorNameAndConstantFields constructorNameAndConstantFields +diffTerms :: (Diffable syntax, Eq1 syntax, Foldable syntax, Functor syntax, GAlign syntax, Show1 syntax, Traversable syntax) + => Term syntax (Record fields1) + -> Term syntax (Record fields2) + -> Diff syntax (Record fields1) (Record fields2) +diffTerms = decoratingWith comparableTerms equivalentTerms constructorNameAndConstantFields constructorNameAndConstantFields -- | Diff two terms by decorating with feature vectors computed using the supplied labelling algebra, and stripping the feature vectors from the resulting diff. decoratingWith :: (Hashable label, Diffable syntax, GAlign syntax, Traversable syntax) @@ -101,35 +95,3 @@ getLabel (In h t) = (Info.category h, case t of -- | Test whether two terms are comparable by their Category. comparableByCategory :: (HasField fields1 Category, HasField fields2 Category) => ComparabilityRelation syntax (Record fields1) (Record fields2) comparableByCategory (In a _) (In b _) = category a == category b - --- | Test whether two terms are comparable by their constructor. -comparableByConstructor :: (Syntax.Context :< fs, Apply GAlign fs) => ComparabilityRelation (Union fs) ann1 ann2 -comparableByConstructor (In _ u1) (In _ u2) - | Just Syntax.Context{} <- prj u1 = True - | Just Syntax.Context{} <- prj u2 = True - | otherwise = isJust (galign u1 u2) - --- | Equivalency relation for terms. Equivalence is determined by functions and --- methods with equal identifiers/names and recursively by equivalent terms with --- identical shapes. -equivalentTerms :: (Declaration.Method :< fs, Declaration.Function :< fs, Syntax.Context :< fs, Apply Foldable fs, Apply GAlign fs) - => Term (Union fs) ann1 - -> Term (Union fs) ann2 - -> Bool -equivalentTerms t1@(Term (In _ u1)) t2@(Term (In _ u2)) - | Just (Declaration.Method _ _ identifier1 _ _) <- prj u1 - , Just (Declaration.Method _ _ identifier2 _ _) <- prj u2 - = equivalentTerms identifier1 identifier2 - | Just (Declaration.Function _ identifier1 _ _) <- prj u1 - , Just (Declaration.Function _ identifier2 _ _) <- prj u2 - = equivalentTerms identifier1 identifier2 - | Just (Syntax.Context _ s1) <- prj u1 - , Just (Syntax.Context _ s2) <- prj u2 - = equivalentTerms s1 s2 - | Just (Syntax.Context _ s1) <- prj u1 - = equivalentTerms s1 t2 - | Just (Syntax.Context _ s2) <- prj u2 - = equivalentTerms t1 s2 - | Just aligned <- galignWith (Just . these (const False) (const False) equivalentTerms) u1 u2 - = and aligned - | otherwise = False diff --git a/src/Language/JSON/Syntax.hs b/src/Language/JSON/Syntax.hs index f26ade54d..0a5f77557 100644 --- a/src/Language/JSON/Syntax.hs +++ b/src/Language/JSON/Syntax.hs @@ -11,7 +11,6 @@ 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.Declaration as Declaration import qualified Data.Syntax.Literal as Literal import qualified Data.Term as Term import Data.Union @@ -27,10 +26,6 @@ type Syntax = , Literal.Null , Literal.String , Literal.TextElement - -- NB: Diffing requires Methods, Functions, and Context in the union. - , Declaration.Method - , Declaration.Function - , Syntax.Context , Syntax.Error , [] ] diff --git a/src/Language/Markdown/Syntax.hs b/src/Language/Markdown/Syntax.hs index 214c5deb4..dac54d807 100644 --- a/src/Language/Markdown/Syntax.hs +++ b/src/Language/Markdown/Syntax.hs @@ -14,7 +14,6 @@ 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 qualified Data.Syntax.Declaration as Declaration import qualified Data.Syntax.Markup as Markup import Data.Term as Term (Term(..), TermF(..), termIn, unwrap) import qualified Data.Text as Text @@ -46,10 +45,6 @@ type Syntax = , Markup.Strong , Markup.Text , Markup.Strikethrough - -- NB: Diffing requires Methods, Functions, and Context in the union. - , Declaration.Method - , Declaration.Function - , Syntax.Context -- Assignment errors; cmark does not provide parse errors. , Syntax.Error , [] diff --git a/src/Language/Python/Syntax.hs b/src/Language/Python/Syntax.hs index e49f713b1..b12cb2c1d 100644 --- a/src/Language/Python/Syntax.hs +++ b/src/Language/Python/Syntax.hs @@ -39,7 +39,7 @@ type Syntax = , Declaration.Decorator , Declaration.Function , Declaration.Import - -- NB: Diffing requires Methods in the union. + -- NB: ToC rendering requires Methods in the union. , Declaration.Method , Declaration.Variable , Expression.Arithmetic diff --git a/src/Semantic.hs b/src/Semantic.hs index faaedf31a..7e67bf277 100644 --- a/src/Semantic.hs +++ b/src/Semantic.hs @@ -73,6 +73,7 @@ diffBlobPair :: DiffRenderer output -> Both Blob -> Task output diffBlobPair renderer blobs = case (renderer, effectiveLanguage) of (OldToCDiffRenderer, Just Language.Markdown) -> run (\ blob -> parse markdownParser blob >>= decorate (markupSectionAlgebra blob)) diffTerms (renderToCDiff blobs) (OldToCDiffRenderer, Just Language.Python) -> run (\ blob -> parse pythonParser blob >>= decorate (declarationAlgebra blob)) diffTerms (renderToCDiff blobs) + (OldToCDiffRenderer, Just Language.Ruby) -> run (\ blob -> parse rubyParser blob >>= decorate (declarationAlgebra blob)) diffTerms (renderToCDiff blobs) (OldToCDiffRenderer, lang) | Just syntaxParser <- lang >>= syntaxParserForLanguage -> run (\ blob -> parse syntaxParser blob >>= decorate (syntaxDeclarationAlgebra blob)) diffSyntaxTerms (renderToCDiff blobs) diff --git a/test/Data/RandomWalkSimilarity/Spec.hs b/test/Data/RandomWalkSimilarity/Spec.hs index cb0db7cd2..43167826d 100644 --- a/test/Data/RandomWalkSimilarity/Spec.hs +++ b/test/Data/RandomWalkSimilarity/Spec.hs @@ -1,6 +1,7 @@ {-# LANGUAGE DataKinds #-} module Data.RandomWalkSimilarity.Spec where +import Algorithm import Data.Array.IArray import Data.Bifunctor import Data.Diff @@ -35,12 +36,12 @@ spec = parallel $ do \ (as, bs) -> let tas = decorate <$> (as :: [Term ListableSyntax (Record '[])]) tbs = decorate <$> (bs :: [Term ListableSyntax (Record '[])]) wrap = termIn Nil . inj - diff = merge (Nil, Nil) (inj (stripDiff . diffThese <$> rws comparableByConstructor (equalTerms comparableByConstructor) tas tbs)) in + diff = merge (Nil, Nil) (inj (stripDiff . diffThese <$> rws comparableTerms (equalTerms comparableTerms) tas tbs)) in (beforeTerm diff, afterTerm diff) `shouldBe` (Just (wrap (stripTerm <$> tas)), Just (wrap (stripTerm <$> tbs))) it "produces unbiased insertions within branches" $ let (a, b) = (decorate (termIn Nil (inj [ termIn Nil (inj (Syntax.Identifier "a")) ])), decorate (termIn Nil (inj [ termIn Nil (inj (Syntax.Identifier "b")) ]))) in - fmap (bimap stripTerm stripTerm) (rws comparableByConstructor (equalTerms comparableByConstructor) [ b ] [ a, b ]) `shouldBe` fmap (bimap stripTerm stripTerm) [ That a, These b b ] + fmap (bimap stripTerm stripTerm) (rws comparableTerms (equalTerms comparableTerms) [ b ] [ a, b ]) `shouldBe` fmap (bimap stripTerm stripTerm) [ That a, These b b ] where decorate = defaultFeatureVectorDecorator constructorNameAndConstantFields diff --git a/test/fixtures/javascript/comment.diffA-B.txt b/test/fixtures/javascript/comment.diffA-B.txt index d313b7cf4..ab0622e59 100644 --- a/test/fixtures/javascript/comment.diffA-B.txt +++ b/test/fixtures/javascript/comment.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Context - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/javascript/comment.diffB-A.txt b/test/fixtures/javascript/comment.diffB-A.txt index d313b7cf4..ab0622e59 100644 --- a/test/fixtures/javascript/comment.diffB-A.txt +++ b/test/fixtures/javascript/comment.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Context - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/javascript/constructor-call.diffA-B.txt b/test/fixtures/javascript/constructor-call.diffA-B.txt index 12476992a..4cd5b5e65 100644 --- a/test/fixtures/javascript/constructor-call.diffA-B.txt +++ b/test/fixtures/javascript/constructor-call.diffA-B.txt @@ -5,6 +5,6 @@ (Identifier) (Identifier)) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty)))) diff --git a/test/fixtures/javascript/constructor-call.diffB-A.txt b/test/fixtures/javascript/constructor-call.diffB-A.txt index 12476992a..4cd5b5e65 100644 --- a/test/fixtures/javascript/constructor-call.diffB-A.txt +++ b/test/fixtures/javascript/constructor-call.diffB-A.txt @@ -5,6 +5,6 @@ (Identifier) (Identifier)) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty)))) diff --git a/test/fixtures/javascript/do-while-statement.diffA-B.txt b/test/fixtures/javascript/do-while-statement.diffA-B.txt index cc0d9d703..30c06d609 100644 --- a/test/fixtures/javascript/do-while-statement.diffA-B.txt +++ b/test/fixtures/javascript/do-while-statement.diffA-B.txt @@ -7,6 +7,6 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))) diff --git a/test/fixtures/javascript/do-while-statement.diffB-A.txt b/test/fixtures/javascript/do-while-statement.diffB-A.txt index cc0d9d703..30c06d609 100644 --- a/test/fixtures/javascript/do-while-statement.diffB-A.txt +++ b/test/fixtures/javascript/do-while-statement.diffB-A.txt @@ -7,6 +7,6 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))) diff --git a/test/fixtures/javascript/export.diffA-B.txt b/test/fixtures/javascript/export.diffA-B.txt index 45d600a90..d3c55c9dd 100644 --- a/test/fixtures/javascript/export.diffA-B.txt +++ b/test/fixtures/javascript/export.diffA-B.txt @@ -83,8 +83,8 @@ {+(Identifier)+} {+(Empty)+})+})) (Export - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) {+(Export {+(Function {+(Empty)+} diff --git a/test/fixtures/javascript/export.diffB-A.txt b/test/fixtures/javascript/export.diffB-A.txt index bc3a1ec6d..6629857ba 100644 --- a/test/fixtures/javascript/export.diffB-A.txt +++ b/test/fixtures/javascript/export.diffB-A.txt @@ -81,8 +81,8 @@ {-(Identifier)-} {-(Empty)-})-})) (Export - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) {-(Export {-(Function {-(Empty)-} @@ -111,8 +111,8 @@ {+(Identifier)+} {+(Identifier)+})+})+})+} (Export - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Export (ExportClause (ImportExportSpecifier @@ -131,8 +131,8 @@ {-(ImportExportSpecifier {-(Identifier)-} {-(Empty)-})-}) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) {+(Export {+(ExportClause {+(ImportExportSpecifier diff --git a/test/fixtures/javascript/for-of-statement.diffA-B.txt b/test/fixtures/javascript/for-of-statement.diffA-B.txt index 8fdf44a8b..9886795f9 100644 --- a/test/fixtures/javascript/for-of-statement.diffA-B.txt +++ b/test/fixtures/javascript/for-of-statement.diffA-B.txt @@ -7,7 +7,7 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)))) (Empty)) diff --git a/test/fixtures/javascript/for-of-statement.diffB-A.txt b/test/fixtures/javascript/for-of-statement.diffB-A.txt index 8fdf44a8b..9886795f9 100644 --- a/test/fixtures/javascript/for-of-statement.diffB-A.txt +++ b/test/fixtures/javascript/for-of-statement.diffB-A.txt @@ -7,7 +7,7 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)))) (Empty)) diff --git a/test/fixtures/javascript/function-call-args.diffA-B.txt b/test/fixtures/javascript/function-call-args.diffA-B.txt index 1d17d16e4..fd9317247 100644 --- a/test/fixtures/javascript/function-call-args.diffA-B.txt +++ b/test/fixtures/javascript/function-call-args.diffA-B.txt @@ -2,8 +2,8 @@ (Call (Identifier) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Function (Empty) (Empty) @@ -31,12 +31,12 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Return { (Identifier) ->(Identifier) }))) - {+(Boolean)+} - {-(Boolean)-} + { (Boolean) + ->(Boolean) } (Empty))) diff --git a/test/fixtures/javascript/function-call-args.diffB-A.txt b/test/fixtures/javascript/function-call-args.diffB-A.txt index 2425e211a..4f9a10527 100644 --- a/test/fixtures/javascript/function-call-args.diffB-A.txt +++ b/test/fixtures/javascript/function-call-args.diffB-A.txt @@ -2,8 +2,8 @@ (Call (Identifier) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Function (Empty) (Empty) @@ -26,12 +26,12 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Return { (Identifier) ->(Identifier) }))) - {+(Boolean)+} - {-(Boolean)-} + { (Boolean) + ->(Boolean) } (Empty))) diff --git a/test/fixtures/javascript/function-call.diffA-B.txt b/test/fixtures/javascript/function-call.diffA-B.txt index 50e7600e6..9ff4cf165 100644 --- a/test/fixtures/javascript/function-call.diffA-B.txt +++ b/test/fixtures/javascript/function-call.diffA-B.txt @@ -2,6 +2,6 @@ (Call (Identifier) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/javascript/function-call.diffB-A.txt b/test/fixtures/javascript/function-call.diffB-A.txt index 50e7600e6..9ff4cf165 100644 --- a/test/fixtures/javascript/function-call.diffB-A.txt +++ b/test/fixtures/javascript/function-call.diffB-A.txt @@ -2,6 +2,6 @@ (Call (Identifier) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/javascript/function.diffA-B.txt b/test/fixtures/javascript/function.diffA-B.txt index 961661db8..65fa21e40 100644 --- a/test/fixtures/javascript/function.diffA-B.txt +++ b/test/fixtures/javascript/function.diffA-B.txt @@ -16,6 +16,6 @@ (Identifier) (Empty))) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) diff --git a/test/fixtures/javascript/function.diffB-A.txt b/test/fixtures/javascript/function.diffB-A.txt index 961661db8..65fa21e40 100644 --- a/test/fixtures/javascript/function.diffB-A.txt +++ b/test/fixtures/javascript/function.diffB-A.txt @@ -16,6 +16,6 @@ (Identifier) (Empty))) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) diff --git a/test/fixtures/javascript/identifier.diffA-B.txt b/test/fixtures/javascript/identifier.diffA-B.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/javascript/identifier.diffA-B.txt +++ b/test/fixtures/javascript/identifier.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/javascript/identifier.diffB-A.txt b/test/fixtures/javascript/identifier.diffB-A.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/javascript/identifier.diffB-A.txt +++ b/test/fixtures/javascript/identifier.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/javascript/if.diffA-B.txt b/test/fixtures/javascript/if.diffA-B.txt index c69dacb57..2a90eee30 100644 --- a/test/fixtures/javascript/if.diffA-B.txt +++ b/test/fixtures/javascript/if.diffA-B.txt @@ -7,8 +7,8 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) {+(Identifier)+}) (Empty))) diff --git a/test/fixtures/javascript/if.diffB-A.txt b/test/fixtures/javascript/if.diffB-A.txt index 5795a5f1f..a6742d0e3 100644 --- a/test/fixtures/javascript/if.diffB-A.txt +++ b/test/fixtures/javascript/if.diffB-A.txt @@ -7,8 +7,8 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) {-(Identifier)-}) (Empty))) diff --git a/test/fixtures/javascript/import.diffA-B.txt b/test/fixtures/javascript/import.diffA-B.txt index bea68ce51..a570b2cfa 100644 --- a/test/fixtures/javascript/import.diffA-B.txt +++ b/test/fixtures/javascript/import.diffA-B.txt @@ -2,15 +2,15 @@ (Import (ImportClause (Identifier)) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -18,8 +18,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -31,8 +31,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -45,8 +45,8 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) @@ -60,16 +60,16 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/javascript/import.diffB-A.txt b/test/fixtures/javascript/import.diffB-A.txt index bea68ce51..a570b2cfa 100644 --- a/test/fixtures/javascript/import.diffB-A.txt +++ b/test/fixtures/javascript/import.diffB-A.txt @@ -2,15 +2,15 @@ (Import (ImportClause (Identifier)) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -18,8 +18,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -31,8 +31,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -45,8 +45,8 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) @@ -60,16 +60,16 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/javascript/method-call.diffA-B.txt b/test/fixtures/javascript/method-call.diffA-B.txt index 8430f65f5..04b6484e5 100644 --- a/test/fixtures/javascript/method-call.diffA-B.txt +++ b/test/fixtures/javascript/method-call.diffA-B.txt @@ -4,6 +4,6 @@ (Identifier) (Identifier)) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/javascript/method-call.diffB-A.txt b/test/fixtures/javascript/method-call.diffB-A.txt index 8430f65f5..04b6484e5 100644 --- a/test/fixtures/javascript/method-call.diffB-A.txt +++ b/test/fixtures/javascript/method-call.diffB-A.txt @@ -4,6 +4,6 @@ (Identifier) (Identifier)) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/javascript/nested-do-while-in-function.diffA-B.txt b/test/fixtures/javascript/nested-do-while-in-function.diffA-B.txt index ba5df0f57..df8b4c724 100644 --- a/test/fixtures/javascript/nested-do-while-in-function.diffA-B.txt +++ b/test/fixtures/javascript/nested-do-while-in-function.diffA-B.txt @@ -22,6 +22,6 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/javascript/nested-do-while-in-function.diffB-A.txt b/test/fixtures/javascript/nested-do-while-in-function.diffB-A.txt index ba5df0f57..df8b4c724 100644 --- a/test/fixtures/javascript/nested-do-while-in-function.diffB-A.txt +++ b/test/fixtures/javascript/nested-do-while-in-function.diffB-A.txt @@ -22,6 +22,6 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/javascript/nested-functions.diffA-B.txt b/test/fixtures/javascript/nested-functions.diffA-B.txt index cd11fbc69..66b665736 100644 --- a/test/fixtures/javascript/nested-functions.diffA-B.txt +++ b/test/fixtures/javascript/nested-functions.diffA-B.txt @@ -37,13 +37,13 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Call (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/javascript/nested-functions.diffB-A.txt b/test/fixtures/javascript/nested-functions.diffB-A.txt index cd11fbc69..66b665736 100644 --- a/test/fixtures/javascript/nested-functions.diffB-A.txt +++ b/test/fixtures/javascript/nested-functions.diffB-A.txt @@ -37,13 +37,13 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Call (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/javascript/number.diffA-B.txt b/test/fixtures/javascript/number.diffA-B.txt index 5741a6028..9c7b7f65e 100644 --- a/test/fixtures/javascript/number.diffA-B.txt +++ b/test/fixtures/javascript/number.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Float)+} -{-(Float)-}) +{ (Float) +->(Float) }) diff --git a/test/fixtures/javascript/number.diffB-A.txt b/test/fixtures/javascript/number.diffB-A.txt index 5741a6028..9c7b7f65e 100644 --- a/test/fixtures/javascript/number.diffB-A.txt +++ b/test/fixtures/javascript/number.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Float)+} -{-(Float)-}) +{ (Float) +->(Float) }) diff --git a/test/fixtures/javascript/regex.diffA-B.txt b/test/fixtures/javascript/regex.diffA-B.txt index 91633c360..9c5e630f5 100644 --- a/test/fixtures/javascript/regex.diffA-B.txt +++ b/test/fixtures/javascript/regex.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Regex)+} -{-(Regex)-}) +{ (Regex) +->(Regex) }) diff --git a/test/fixtures/javascript/regex.diffB-A.txt b/test/fixtures/javascript/regex.diffB-A.txt index 91633c360..9c5e630f5 100644 --- a/test/fixtures/javascript/regex.diffB-A.txt +++ b/test/fixtures/javascript/regex.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Regex)+} -{-(Regex)-}) +{ (Regex) +->(Regex) }) diff --git a/test/fixtures/javascript/relational-operator.diffA-B.txt b/test/fixtures/javascript/relational-operator.diffA-B.txt index 3beb3939f..b10fba844 100644 --- a/test/fixtures/javascript/relational-operator.diffA-B.txt +++ b/test/fixtures/javascript/relational-operator.diffA-B.txt @@ -1,7 +1,7 @@ (Program -{+(LessThanEqual - {+(Identifier)+} - {+(Identifier)+})+} -{-(LessThan +{ (LessThan {-(Identifier)-} - {-(Identifier)-})-}) + {-(Identifier)-}) +->(LessThanEqual + {+(Identifier)+} + {+(Identifier)+}) }) diff --git a/test/fixtures/javascript/relational-operator.diffB-A.txt b/test/fixtures/javascript/relational-operator.diffB-A.txt index b08ba1cfd..811022c76 100644 --- a/test/fixtures/javascript/relational-operator.diffB-A.txt +++ b/test/fixtures/javascript/relational-operator.diffB-A.txt @@ -1,7 +1,7 @@ (Program -{+(LessThan - {+(Identifier)+} - {+(Identifier)+})+} -{-(LessThanEqual +{ (LessThanEqual {-(Identifier)-} - {-(Identifier)-})-}) + {-(Identifier)-}) +->(LessThan + {+(Identifier)+} + {+(Identifier)+}) }) diff --git a/test/fixtures/javascript/string.diffA-B.txt b/test/fixtures/javascript/string.diffA-B.txt index 0695d0f25..c368003ca 100644 --- a/test/fixtures/javascript/string.diffA-B.txt +++ b/test/fixtures/javascript/string.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(TextElement)+} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/javascript/string.diffB-A.txt b/test/fixtures/javascript/string.diffB-A.txt index 0695d0f25..c368003ca 100644 --- a/test/fixtures/javascript/string.diffB-A.txt +++ b/test/fixtures/javascript/string.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(TextElement)+} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/javascript/subscript-access-string.diffA-B.txt b/test/fixtures/javascript/subscript-access-string.diffA-B.txt index 3ed3b9d54..e89be8ff9 100644 --- a/test/fixtures/javascript/subscript-access-string.diffA-B.txt +++ b/test/fixtures/javascript/subscript-access-string.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/javascript/subscript-access-string.diffB-A.txt b/test/fixtures/javascript/subscript-access-string.diffB-A.txt index 3ed3b9d54..e89be8ff9 100644 --- a/test/fixtures/javascript/subscript-access-string.diffB-A.txt +++ b/test/fixtures/javascript/subscript-access-string.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/javascript/subscript-access-variable.diffA-B.txt b/test/fixtures/javascript/subscript-access-variable.diffA-B.txt index 52c195a4f..428bf4bf1 100644 --- a/test/fixtures/javascript/subscript-access-variable.diffA-B.txt +++ b/test/fixtures/javascript/subscript-access-variable.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/javascript/subscript-access-variable.diffB-A.txt b/test/fixtures/javascript/subscript-access-variable.diffB-A.txt index 52c195a4f..428bf4bf1 100644 --- a/test/fixtures/javascript/subscript-access-variable.diffB-A.txt +++ b/test/fixtures/javascript/subscript-access-variable.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/javascript/switch-statement.diffA-B.txt b/test/fixtures/javascript/switch-statement.diffA-B.txt index 4d8fab67e..e72d89a5b 100644 --- a/test/fixtures/javascript/switch-statement.diffA-B.txt +++ b/test/fixtures/javascript/switch-statement.diffA-B.txt @@ -10,8 +10,8 @@ (Pattern (Float) ( - {+(Float)+} - {-(Float)-})) + { (Float) + ->(Float) })) (Pattern (Float) ( diff --git a/test/fixtures/javascript/switch-statement.diffB-A.txt b/test/fixtures/javascript/switch-statement.diffB-A.txt index 4d8fab67e..e72d89a5b 100644 --- a/test/fixtures/javascript/switch-statement.diffB-A.txt +++ b/test/fixtures/javascript/switch-statement.diffB-A.txt @@ -10,8 +10,8 @@ (Pattern (Float) ( - {+(Float)+} - {-(Float)-})) + { (Float) + ->(Float) })) (Pattern (Float) ( diff --git a/test/fixtures/javascript/throw-statement.diffA-B.txt b/test/fixtures/javascript/throw-statement.diffA-B.txt index ce5253324..a442e1a04 100644 --- a/test/fixtures/javascript/throw-statement.diffA-B.txt +++ b/test/fixtures/javascript/throw-statement.diffA-B.txt @@ -3,6 +3,6 @@ (New (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))))) diff --git a/test/fixtures/javascript/throw-statement.diffB-A.txt b/test/fixtures/javascript/throw-statement.diffB-A.txt index ce5253324..a442e1a04 100644 --- a/test/fixtures/javascript/throw-statement.diffB-A.txt +++ b/test/fixtures/javascript/throw-statement.diffB-A.txt @@ -3,6 +3,6 @@ (New (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))))) diff --git a/test/fixtures/javascript/try-statement.diffA-B.txt b/test/fixtures/javascript/try-statement.diffA-B.txt index 95160f872..a1448e34d 100644 --- a/test/fixtures/javascript/try-statement.diffA-B.txt +++ b/test/fixtures/javascript/try-statement.diffA-B.txt @@ -5,10 +5,10 @@ (Catch (Empty) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Finally ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) (Empty)) diff --git a/test/fixtures/javascript/try-statement.diffB-A.txt b/test/fixtures/javascript/try-statement.diffB-A.txt index 95160f872..a1448e34d 100644 --- a/test/fixtures/javascript/try-statement.diffB-A.txt +++ b/test/fixtures/javascript/try-statement.diffB-A.txt @@ -5,10 +5,10 @@ (Catch (Empty) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Finally ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) (Empty)) diff --git a/test/fixtures/javascript/variable.diffA-B.txt b/test/fixtures/javascript/variable.diffA-B.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/javascript/variable.diffA-B.txt +++ b/test/fixtures/javascript/variable.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/javascript/variable.diffB-A.txt b/test/fixtures/javascript/variable.diffB-A.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/javascript/variable.diffB-A.txt +++ b/test/fixtures/javascript/variable.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/python/async-function-definition.diffA-B.txt b/test/fixtures/python/async-function-definition.diffA-B.txt index 3630742ea..56b1fa7a3 100644 --- a/test/fixtures/python/async-function-definition.diffA-B.txt +++ b/test/fixtures/python/async-function-definition.diffA-B.txt @@ -8,8 +8,8 @@ (Identifier) {+(Identifier)+} ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) (Identifier)) (Annotation @@ -17,8 +17,8 @@ (Function (Identifier) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) (Identifier)) {+(Annotation diff --git a/test/fixtures/python/async-function-definition.diffB-A.txt b/test/fixtures/python/async-function-definition.diffB-A.txt index 7fa6cb8b7..16c78756e 100644 --- a/test/fixtures/python/async-function-definition.diffB-A.txt +++ b/test/fixtures/python/async-function-definition.diffB-A.txt @@ -14,8 +14,8 @@ (Function (Identifier) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) (Identifier)) (Annotation @@ -23,12 +23,12 @@ (Function { (Identifier) ->(Identifier) } + { (Identifier) + ->(Identifier) } {+(Identifier)+} - {+(Identifier)+} - {-(Identifier)-} ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) (Identifier)) {+(Annotation diff --git a/test/fixtures/python/await.diffA-B.txt b/test/fixtures/python/await.diffA-B.txt index d24a86379..08efc600b 100644 --- a/test/fixtures/python/await.diffA-B.txt +++ b/test/fixtures/python/await.diffA-B.txt @@ -8,6 +8,6 @@ (Empty)) (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))) diff --git a/test/fixtures/python/await.diffB-A.txt b/test/fixtures/python/await.diffB-A.txt index d24a86379..08efc600b 100644 --- a/test/fixtures/python/await.diffB-A.txt +++ b/test/fixtures/python/await.diffB-A.txt @@ -8,6 +8,6 @@ (Empty)) (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))) diff --git a/test/fixtures/python/binary-operator.diffA-B.txt b/test/fixtures/python/binary-operator.diffA-B.txt index e53b7c359..f32a3f3bf 100644 --- a/test/fixtures/python/binary-operator.diffA-B.txt +++ b/test/fixtures/python/binary-operator.diffA-B.txt @@ -32,9 +32,12 @@ {+(DividedBy {+(Identifier)+} {+(Identifier)+})+} -{+(Modulo +{ (DividedBy + {-(Identifier)-} + {-(Identifier)-}) +->(Modulo {+(Identifier)+} - {+(Identifier)+})+} + {+(Identifier)+}) } {+(DividedBy {+(Identifier)+} {+(Identifier)+})+} @@ -47,9 +50,6 @@ {+(Plus {+(Identifier)+} {+(Identifier)+})+} -{-(DividedBy - {-(Identifier)-} - {-(Identifier)-})-} {-(Power {-(Identifier)-} {-(Identifier)-})-} diff --git a/test/fixtures/python/boolean.diffA-B.txt b/test/fixtures/python/boolean.diffA-B.txt index fd4a0f410..79f1741d7 100644 --- a/test/fixtures/python/boolean.diffA-B.txt +++ b/test/fixtures/python/boolean.diffA-B.txt @@ -1,6 +1,6 @@ (Program {-(Boolean)-} (Boolean) -{+(Boolean)+} -{+(Boolean)+} -{-(Boolean)-}) +{ (Boolean) +->(Boolean) } +{+(Boolean)+}) diff --git a/test/fixtures/python/boolean.diffB-A.txt b/test/fixtures/python/boolean.diffB-A.txt index fd4a0f410..79f1741d7 100644 --- a/test/fixtures/python/boolean.diffB-A.txt +++ b/test/fixtures/python/boolean.diffB-A.txt @@ -1,6 +1,6 @@ (Program {-(Boolean)-} (Boolean) -{+(Boolean)+} -{+(Boolean)+} -{-(Boolean)-}) +{ (Boolean) +->(Boolean) } +{+(Boolean)+}) diff --git a/test/fixtures/python/comment.diffB-A.txt b/test/fixtures/python/comment.diffB-A.txt index 0dbbdf0e1..57d15fc24 100644 --- a/test/fixtures/python/comment.diffB-A.txt +++ b/test/fixtures/python/comment.diffB-A.txt @@ -2,6 +2,6 @@ (Context {-(Comment)-} (Comment) - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/python/concatenated-string.diffB-A.txt b/test/fixtures/python/concatenated-string.diffB-A.txt index 88cf4b274..4387d6826 100644 --- a/test/fixtures/python/concatenated-string.diffB-A.txt +++ b/test/fixtures/python/concatenated-string.diffB-A.txt @@ -2,6 +2,6 @@ ( {-(TextElement)-} (TextElement) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (TextElement))) diff --git a/test/fixtures/python/conditional-expression.diffB-A.txt b/test/fixtures/python/conditional-expression.diffB-A.txt index 51ad749da..22eb503ae 100644 --- a/test/fixtures/python/conditional-expression.diffB-A.txt +++ b/test/fixtures/python/conditional-expression.diffB-A.txt @@ -15,8 +15,8 @@ { (Identifier) ->(Identifier) } ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) {-(If {-(Identifier)-} {-(Call diff --git a/test/fixtures/python/decorated-definition.diffA-B.txt b/test/fixtures/python/decorated-definition.diffA-B.txt index 635b5f69e..b65592463 100644 --- a/test/fixtures/python/decorated-definition.diffA-B.txt +++ b/test/fixtures/python/decorated-definition.diffA-B.txt @@ -12,15 +12,15 @@ ([]) (Decorator (ScopeResolution - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) ( {+(Identifier)+} {-(Integer)-}) (Decorator (ScopeResolution - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) ( {+(Identifier)+} {-(Integer)-} diff --git a/test/fixtures/python/decorated-definition.diffB-A.txt b/test/fixtures/python/decorated-definition.diffB-A.txt index d29b48719..b6992d978 100644 --- a/test/fixtures/python/decorated-definition.diffB-A.txt +++ b/test/fixtures/python/decorated-definition.diffB-A.txt @@ -12,15 +12,15 @@ ([]) (Decorator (ScopeResolution - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) ( {+(Integer)+} {-(Identifier)-}) (Decorator (ScopeResolution - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) ( {+(Integer)+} {+(Integer)+} diff --git a/test/fixtures/python/dictionary-comprehension.diffA-B.txt b/test/fixtures/python/dictionary-comprehension.diffA-B.txt index cac4deb1b..9230afb5b 100644 --- a/test/fixtures/python/dictionary-comprehension.diffA-B.txt +++ b/test/fixtures/python/dictionary-comprehension.diffA-B.txt @@ -8,10 +8,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {+( {+(Identifier)+})+})) (Comprehension @@ -23,9 +23,9 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {-( {-(Identifier)-})-}))) diff --git a/test/fixtures/python/dictionary-comprehension.diffB-A.txt b/test/fixtures/python/dictionary-comprehension.diffB-A.txt index a0cbf55b2..a6b913255 100644 --- a/test/fixtures/python/dictionary-comprehension.diffB-A.txt +++ b/test/fixtures/python/dictionary-comprehension.diffB-A.txt @@ -8,10 +8,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {-( {-(Identifier)-})-})) (Comprehension @@ -23,9 +23,9 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {+( {+(Identifier)+})+}))) diff --git a/test/fixtures/python/exec-statement.diffA-B.txt b/test/fixtures/python/exec-statement.diffA-B.txt index 02272e43b..8862037e8 100644 --- a/test/fixtures/python/exec-statement.diffA-B.txt +++ b/test/fixtures/python/exec-statement.diffA-B.txt @@ -1,9 +1,9 @@ (Program (Call (Identifier) - {+(TextElement)+} + { (TextElement) + ->(TextElement) } {+(Identifier)+} - {-(TextElement)-} (Empty)) (Call (Identifier) diff --git a/test/fixtures/python/exec-statement.diffB-A.txt b/test/fixtures/python/exec-statement.diffB-A.txt index 5c7cc1e96..583d2e1de 100644 --- a/test/fixtures/python/exec-statement.diffB-A.txt +++ b/test/fixtures/python/exec-statement.diffB-A.txt @@ -1,8 +1,8 @@ (Program (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } {-(Identifier)-} (Empty)) (Call diff --git a/test/fixtures/python/expression-statement.diffB-A.txt b/test/fixtures/python/expression-statement.diffB-A.txt index 1bbccbc08..3146293b1 100644 --- a/test/fixtures/python/expression-statement.diffB-A.txt +++ b/test/fixtures/python/expression-statement.diffB-A.txt @@ -1,5 +1,6 @@ (Program -{+(Identifier)+} +{ (Identifier) +->(Identifier) } {+(Plus {+(Identifier)+} {+(Identifier)+})+} @@ -11,7 +12,6 @@ {+(Integer)+} {+(Integer)+} {+(Integer)+})+} -{-(Identifier)-} {-( {-(Integer)-} {-(Integer)-} diff --git a/test/fixtures/python/float.diffA-B.txt b/test/fixtures/python/float.diffA-B.txt index 8c49b18b7..52d2dd464 100644 --- a/test/fixtures/python/float.diffA-B.txt +++ b/test/fixtures/python/float.diffA-B.txt @@ -2,18 +2,18 @@ (Negate { (Float) ->(Float) }) +{ (Float) +->(Float) } {+(Float)+} {+(Float)+} {+(Float)+} +{ (Float) +->(Float) } {+(Float)+} {+(Float)+} +{ (Float) +->(Float) } {+(Float)+} -{+(Float)+} -{+(Float)+} -{+(Float)+} -{-(Float)-} -{-(Float)-} -{-(Float)-} {-(Float)-} {-(Float)-} {-(Float)-} diff --git a/test/fixtures/python/float.diffB-A.txt b/test/fixtures/python/float.diffB-A.txt index 8c49b18b7..916dc8f79 100644 --- a/test/fixtures/python/float.diffB-A.txt +++ b/test/fixtures/python/float.diffB-A.txt @@ -2,19 +2,19 @@ (Negate { (Float) ->(Float) }) +{ (Float) +->(Float) } {+(Float)+} {+(Float)+} +{ (Float) +->(Float) } +{ (Float) +->(Float) } +{+(Float)+} +{ (Float) +->(Float) } {+(Float)+} {+(Float)+} -{+(Float)+} -{+(Float)+} -{+(Float)+} -{+(Float)+} -{+(Float)+} -{-(Float)-} -{-(Float)-} -{-(Float)-} -{-(Float)-} {-(Float)-} {-(Float)-} {-(Float)-} diff --git a/test/fixtures/python/for-statement.diffA-B.txt b/test/fixtures/python/for-statement.diffA-B.txt index 2ad4cb300..55c13a7db 100644 --- a/test/fixtures/python/for-statement.diffA-B.txt +++ b/test/fixtures/python/for-statement.diffA-B.txt @@ -15,8 +15,8 @@ (ForEach ( (Identifier) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) (Identifier) ( (Call @@ -26,8 +26,8 @@ (ForEach ( (Identifier) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) (Identifier) ( (Call @@ -37,8 +37,8 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)))) {-(ForEach {-( diff --git a/test/fixtures/python/for-statement.diffB-A.txt b/test/fixtures/python/for-statement.diffB-A.txt index 704fff387..d94cab68b 100644 --- a/test/fixtures/python/for-statement.diffB-A.txt +++ b/test/fixtures/python/for-statement.diffB-A.txt @@ -27,8 +27,8 @@ {+(Empty)+})+})+})+} (ForEach ( - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) (Array (Tuple (Integer)) @@ -37,8 +37,8 @@ (Tuple (Integer))) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) {-(Else {-(ForEach {-( diff --git a/test/fixtures/python/function-definition.diffA-B.txt b/test/fixtures/python/function-definition.diffA-B.txt index 78eebd591..168dad37d 100644 --- a/test/fixtures/python/function-definition.diffA-B.txt +++ b/test/fixtures/python/function-definition.diffA-B.txt @@ -15,13 +15,13 @@ (Annotation (Function (Identifier) - {+(Identifier)+} - {+(Identifier)+} - {-(Identifier)-} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } + { (Identifier) + ->(Identifier) } ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) {+(Annotation {+(Function @@ -55,8 +55,8 @@ ->(Integer) }) { (Identifier) ->(Identifier) }) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } ( (Identifier))) (Empty))) diff --git a/test/fixtures/python/function-definition.diffB-A.txt b/test/fixtures/python/function-definition.diffB-A.txt index d0ff011d2..bf7d101bf 100644 --- a/test/fixtures/python/function-definition.diffB-A.txt +++ b/test/fixtures/python/function-definition.diffB-A.txt @@ -18,19 +18,19 @@ (Identifier) {+(Identifier)+} ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) (Annotation (Function { (Identifier) ->(Identifier) } + { (Identifier) + ->(Identifier) } {+(Identifier)+} - {+(Identifier)+} - {-(Identifier)-} ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) {+(Annotation {+(Function @@ -51,8 +51,8 @@ ->(TextElement) }) { (Identifier) ->(Identifier) }) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } ( (Identifier))) (Empty))) diff --git a/test/fixtures/python/generator-expression.diffA-B.txt b/test/fixtures/python/generator-expression.diffA-B.txt index f100ebddc..889af8894 100644 --- a/test/fixtures/python/generator-expression.diffA-B.txt +++ b/test/fixtures/python/generator-expression.diffA-B.txt @@ -5,10 +5,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }))) (Comprehension { (Identifier) ->(Plus @@ -17,7 +17,7 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-})))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) })))) diff --git a/test/fixtures/python/generator-expression.diffB-A.txt b/test/fixtures/python/generator-expression.diffB-A.txt index c190fac0f..91806a53e 100644 --- a/test/fixtures/python/generator-expression.diffB-A.txt +++ b/test/fixtures/python/generator-expression.diffB-A.txt @@ -5,10 +5,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }))) (Comprehension { (Plus {-(Identifier)-} @@ -17,7 +17,7 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-})))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) })))) diff --git a/test/fixtures/python/global-statement.diffA-B.txt b/test/fixtures/python/global-statement.diffA-B.txt index aeba128f4..9485d606f 100644 --- a/test/fixtures/python/global-statement.diffA-B.txt +++ b/test/fixtures/python/global-statement.diffA-B.txt @@ -6,7 +6,7 @@ (Empty)) (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } {-(Identifier)-} (Empty))) diff --git a/test/fixtures/python/global-statement.diffB-A.txt b/test/fixtures/python/global-statement.diffB-A.txt index 1b90b4ec1..cf5086530 100644 --- a/test/fixtures/python/global-statement.diffB-A.txt +++ b/test/fixtures/python/global-statement.diffB-A.txt @@ -6,7 +6,7 @@ (Empty)) (Call (Identifier) + { (Identifier) + ->(Identifier) } {+(Identifier)+} - {+(Identifier)+} - {-(Identifier)-} (Empty))) diff --git a/test/fixtures/python/identifier.diffA-B.txt b/test/fixtures/python/identifier.diffA-B.txt index e350145f7..e16d74e6a 100644 --- a/test/fixtures/python/identifier.diffA-B.txt +++ b/test/fixtures/python/identifier.diffA-B.txt @@ -1,4 +1,4 @@ (Program -{+(Identifier)+} -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) } +{+(Identifier)+}) diff --git a/test/fixtures/python/identifier.diffB-A.txt b/test/fixtures/python/identifier.diffB-A.txt index 34ff44b49..b35673ab9 100644 --- a/test/fixtures/python/identifier.diffB-A.txt +++ b/test/fixtures/python/identifier.diffB-A.txt @@ -1,4 +1,4 @@ (Program -{+(Identifier)+} -{-(Identifier)-} +{ (Identifier) +->(Identifier) } {-(Identifier)-}) diff --git a/test/fixtures/python/if-statement.diffA-B.txt b/test/fixtures/python/if-statement.diffA-B.txt index 4df75d39b..140ca836c 100644 --- a/test/fixtures/python/if-statement.diffA-B.txt +++ b/test/fixtures/python/if-statement.diffA-B.txt @@ -3,9 +3,9 @@ { (Identifier) ->(Identifier) } ( - {+(Identifier)+} - (Identifier) - {-(Identifier)-}) + { (Identifier) + ->(Identifier) } + (Identifier)) { (If {-(Identifier)-} {-( diff --git a/test/fixtures/python/import-from-statement.diffA-B.txt b/test/fixtures/python/import-from-statement.diffA-B.txt index faee12692..bacc78836 100644 --- a/test/fixtures/python/import-from-statement.diffA-B.txt +++ b/test/fixtures/python/import-from-statement.diffA-B.txt @@ -17,6 +17,6 @@ {+(Identifier)+})+}) (Import (ScopeResolution - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) (Identifier))) diff --git a/test/fixtures/python/import-from-statement.diffB-A.txt b/test/fixtures/python/import-from-statement.diffB-A.txt index 712e6683a..56c486f9e 100644 --- a/test/fixtures/python/import-from-statement.diffB-A.txt +++ b/test/fixtures/python/import-from-statement.diffB-A.txt @@ -15,6 +15,6 @@ (Identifier))) (Import (ScopeResolution - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) (Identifier))) diff --git a/test/fixtures/python/import-statement.diffA-B.txt b/test/fixtures/python/import-statement.diffA-B.txt index be2e4cfdb..84f434a98 100644 --- a/test/fixtures/python/import-statement.diffA-B.txt +++ b/test/fixtures/python/import-statement.diffA-B.txt @@ -14,8 +14,8 @@ { (Identifier) ->(Identifier) } (ScopeResolution - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Identifier)) (Empty)) {-(ScopeResolution diff --git a/test/fixtures/python/import-statement.diffB-A.txt b/test/fixtures/python/import-statement.diffB-A.txt index e744e0340..f9b71efde 100644 --- a/test/fixtures/python/import-statement.diffB-A.txt +++ b/test/fixtures/python/import-statement.diffB-A.txt @@ -14,8 +14,8 @@ { (Identifier) ->(Identifier) } (ScopeResolution - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Identifier)) (Empty)) {+(ScopeResolution diff --git a/test/fixtures/python/integer.diffA-B.txt b/test/fixtures/python/integer.diffA-B.txt index 35436f3e5..8df16fdb3 100644 --- a/test/fixtures/python/integer.diffA-B.txt +++ b/test/fixtures/python/integer.diffA-B.txt @@ -2,7 +2,8 @@ (Negate { (Integer) ->(Integer) }) -{+(Integer)+} +{ (Integer) +->(Integer) } {+(Integer)+} {+(Integer)+} {+(Negate @@ -17,7 +18,6 @@ {+(Integer)+} {-(Integer)-} {-(Integer)-} -{-(Integer)-} {-(Negate {-(Integer)-})-} {-(Integer)-} diff --git a/test/fixtures/python/integer.diffB-A.txt b/test/fixtures/python/integer.diffB-A.txt index 35436f3e5..cac966d3c 100644 --- a/test/fixtures/python/integer.diffB-A.txt +++ b/test/fixtures/python/integer.diffB-A.txt @@ -2,22 +2,22 @@ (Negate { (Integer) ->(Integer) }) -{+(Integer)+} +{ (Integer) +->(Integer) } {+(Integer)+} {+(Integer)+} {+(Negate {+(Integer)+})+} {+(Integer)+} +{ (Integer) +->(Integer) } +{+(Integer)+} +{ (Integer) +->(Integer) } {+(Integer)+} {+(Integer)+} {+(Integer)+} {+(Integer)+} -{+(Integer)+} -{+(Integer)+} -{+(Integer)+} -{-(Integer)-} -{-(Integer)-} -{-(Integer)-} {-(Negate {-(Integer)-})-} {-(Integer)-} diff --git a/test/fixtures/python/list-comprehension.diffA-B.txt b/test/fixtures/python/list-comprehension.diffA-B.txt index 0f524dd87..38547d7f4 100644 --- a/test/fixtures/python/list-comprehension.diffA-B.txt +++ b/test/fixtures/python/list-comprehension.diffA-B.txt @@ -5,10 +5,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {+( {+(Call {+(Identifier)+} @@ -29,9 +29,9 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {-( {-(Identifier)-})-}))) diff --git a/test/fixtures/python/list-comprehension.diffB-A.txt b/test/fixtures/python/list-comprehension.diffB-A.txt index 9e9a52a3b..53ee58672 100644 --- a/test/fixtures/python/list-comprehension.diffB-A.txt +++ b/test/fixtures/python/list-comprehension.diffB-A.txt @@ -5,10 +5,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {-( {-(Call {-(Identifier)-} @@ -29,9 +29,9 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }) {+( {+(Identifier)+})+}))) diff --git a/test/fixtures/python/non-local-statement.diffA-B.txt b/test/fixtures/python/non-local-statement.diffA-B.txt index 51e9d1f45..b0e558bc3 100644 --- a/test/fixtures/python/non-local-statement.diffA-B.txt +++ b/test/fixtures/python/non-local-statement.diffA-B.txt @@ -1,6 +1,6 @@ (Program (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))) diff --git a/test/fixtures/python/non-local-statement.diffB-A.txt b/test/fixtures/python/non-local-statement.diffB-A.txt index 51e9d1f45..b0e558bc3 100644 --- a/test/fixtures/python/non-local-statement.diffB-A.txt +++ b/test/fixtures/python/non-local-statement.diffB-A.txt @@ -1,6 +1,6 @@ (Program (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))) diff --git a/test/fixtures/python/print-statement.diffA-B.txt b/test/fixtures/python/print-statement.diffA-B.txt index c27148c0f..08522ada5 100644 --- a/test/fixtures/python/print-statement.diffA-B.txt +++ b/test/fixtures/python/print-statement.diffA-B.txt @@ -1,14 +1,14 @@ (Program (Call (Identifier) - {+(Identifier)+} + { (Identifier) + ->(Identifier) } (Identifier) - {-(Identifier)-} (Empty)) (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Call (Identifier) diff --git a/test/fixtures/python/print-statement.diffB-A.txt b/test/fixtures/python/print-statement.diffB-A.txt index 8ca2d5ff0..9a797a52d 100644 --- a/test/fixtures/python/print-statement.diffB-A.txt +++ b/test/fixtures/python/print-statement.diffB-A.txt @@ -7,8 +7,8 @@ (Empty)) (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Call (Identifier) diff --git a/test/fixtures/python/raise-statement.diffA-B.txt b/test/fixtures/python/raise-statement.diffA-B.txt index 32c80833c..1df340c41 100644 --- a/test/fixtures/python/raise-statement.diffA-B.txt +++ b/test/fixtures/python/raise-statement.diffA-B.txt @@ -3,17 +3,17 @@ ( (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty)))) (Throw ( (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty)) - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Throw ([]))) diff --git a/test/fixtures/python/return-statement.diffA-B.txt b/test/fixtures/python/return-statement.diffA-B.txt index 20723b2e1..c9e2603b7 100644 --- a/test/fixtures/python/return-statement.diffA-B.txt +++ b/test/fixtures/python/return-statement.diffA-B.txt @@ -6,8 +6,8 @@ ->(Identifier) } { (Identifier) ->(Identifier) }) - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Return (Empty)) {+(Return diff --git a/test/fixtures/python/set-comprehension.diffA-B.txt b/test/fixtures/python/set-comprehension.diffA-B.txt index f100ebddc..889af8894 100644 --- a/test/fixtures/python/set-comprehension.diffA-B.txt +++ b/test/fixtures/python/set-comprehension.diffA-B.txt @@ -5,10 +5,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }))) (Comprehension { (Identifier) ->(Plus @@ -17,7 +17,7 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-})))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) })))) diff --git a/test/fixtures/python/set-comprehension.diffB-A.txt b/test/fixtures/python/set-comprehension.diffB-A.txt index c190fac0f..91806a53e 100644 --- a/test/fixtures/python/set-comprehension.diffB-A.txt +++ b/test/fixtures/python/set-comprehension.diffB-A.txt @@ -5,10 +5,10 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) }))) (Comprehension { (Plus {-(Identifier)-} @@ -17,7 +17,7 @@ ( ( ( - {+(Identifier)+} - {-(Identifier)-}) - {+(Identifier)+} - {-(Identifier)-})))) + { (Identifier) + ->(Identifier) }) + { (Identifier) + ->(Identifier) })))) diff --git a/test/fixtures/python/string.diffA-B.txt b/test/fixtures/python/string.diffA-B.txt index afbe89b51..558b37e44 100644 --- a/test/fixtures/python/string.diffA-B.txt +++ b/test/fixtures/python/string.diffA-B.txt @@ -1,5 +1,6 @@ (Program -{+(TextElement)+} +{ (TextElement) +->(TextElement) } (TextElement) {+(TextElement)+} {+(TextElement)+} @@ -10,7 +11,6 @@ {-(TextElement)-} {-(TextElement)-} {-(TextElement)-} -{-(TextElement)-} {-(TextElement)-} (TextElement) {-(TextElement)-}) diff --git a/test/fixtures/python/string.diffB-A.txt b/test/fixtures/python/string.diffB-A.txt index 3c7a825d6..55414460b 100644 --- a/test/fixtures/python/string.diffB-A.txt +++ b/test/fixtures/python/string.diffB-A.txt @@ -2,13 +2,13 @@ {-(TextElement)-} (TextElement) {+(TextElement)+} +{ (TextElement) +->(TextElement) } {+(TextElement)+} {+(TextElement)+} {+(TextElement)+} -{+(TextElement)+} -{+(TextElement)+} -{-(TextElement)-} -{-(TextElement)-} +{ (TextElement) +->(TextElement) } {-(TextElement)-} {-(TextElement)-} {-(TextElement)-} diff --git a/test/fixtures/python/subscript.diffA-B.txt b/test/fixtures/python/subscript.diffA-B.txt index 3b930367e..2598bfe20 100644 --- a/test/fixtures/python/subscript.diffA-B.txt +++ b/test/fixtures/python/subscript.diffA-B.txt @@ -2,5 +2,5 @@ (Subscript { (Identifier) ->(Identifier) } - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/python/subscript.diffB-A.txt b/test/fixtures/python/subscript.diffB-A.txt index 3b930367e..2598bfe20 100644 --- a/test/fixtures/python/subscript.diffB-A.txt +++ b/test/fixtures/python/subscript.diffB-A.txt @@ -2,5 +2,5 @@ (Subscript { (Identifier) ->(Identifier) } - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/python/with-statement.diffA-B.txt b/test/fixtures/python/with-statement.diffA-B.txt index 39a3ee8f6..7e25d1e9e 100644 --- a/test/fixtures/python/with-statement.diffA-B.txt +++ b/test/fixtures/python/with-statement.diffA-B.txt @@ -5,5 +5,5 @@ { (Identifier) ->(Identifier) } ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) diff --git a/test/fixtures/python/with-statement.diffB-A.txt b/test/fixtures/python/with-statement.diffB-A.txt index 39a3ee8f6..7e25d1e9e 100644 --- a/test/fixtures/python/with-statement.diffB-A.txt +++ b/test/fixtures/python/with-statement.diffB-A.txt @@ -5,5 +5,5 @@ { (Identifier) ->(Identifier) } ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) diff --git a/test/fixtures/ruby/begin-block.diffA-B.txt b/test/fixtures/ruby/begin-block.diffA-B.txt index 25c1fcd5e..bce079417 100644 --- a/test/fixtures/ruby/begin-block.diffA-B.txt +++ b/test/fixtures/ruby/begin-block.diffA-B.txt @@ -1,5 +1,5 @@ (Program {+(Identifier)+} (ScopeEntry - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/ruby/bitwise-operator.diffA-B.txt b/test/fixtures/ruby/bitwise-operator.diffA-B.txt index 9ff097cd4..564f3f500 100644 --- a/test/fixtures/ruby/bitwise-operator.diffA-B.txt +++ b/test/fixtures/ruby/bitwise-operator.diffA-B.txt @@ -1,16 +1,16 @@ (Program -{+(BAnd - {+(Identifier)+} - {+(Identifier)+})+} -{+(LShift - {+(Identifier)+} - {+(Identifier)+})+} -{-(BOr +{ (BOr {-(Identifier)-} - {-(Identifier)-})-} -{-(RShift + {-(Identifier)-}) +->(BAnd + {+(Identifier)+} + {+(Identifier)+}) } +{ (RShift {-(Identifier)-} - {-(Identifier)-})-} + {-(Identifier)-}) +->(LShift + {+(Identifier)+} + {+(Identifier)+}) } {-(BXOr {-(Identifier)-} {-(Identifier)-})-}) diff --git a/test/fixtures/ruby/bitwise-operator.diffB-A.txt b/test/fixtures/ruby/bitwise-operator.diffB-A.txt index 38b0d0ef4..c0f6cdb2e 100644 --- a/test/fixtures/ruby/bitwise-operator.diffB-A.txt +++ b/test/fixtures/ruby/bitwise-operator.diffB-A.txt @@ -1,16 +1,16 @@ (Program -{+(BOr +{ (BAnd + {-(Identifier)-} + {-(Identifier)-}) +->(BOr {+(Identifier)+} - {+(Identifier)+})+} -{+(RShift + {+(Identifier)+}) } +{ (LShift + {-(Identifier)-} + {-(Identifier)-}) +->(RShift {+(Identifier)+} - {+(Identifier)+})+} + {+(Identifier)+}) } {+(BXOr {+(Identifier)+} - {+(Identifier)+})+} -{-(BAnd - {-(Identifier)-} - {-(Identifier)-})-} -{-(LShift - {-(Identifier)-} - {-(Identifier)-})-}) + {+(Identifier)+})+}) diff --git a/test/fixtures/ruby/comment.diffA-B.txt b/test/fixtures/ruby/comment.diffA-B.txt index d313b7cf4..ab0622e59 100644 --- a/test/fixtures/ruby/comment.diffA-B.txt +++ b/test/fixtures/ruby/comment.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Context - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/ruby/comment.diffB-A.txt b/test/fixtures/ruby/comment.diffB-A.txt index d313b7cf4..ab0622e59 100644 --- a/test/fixtures/ruby/comment.diffB-A.txt +++ b/test/fixtures/ruby/comment.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Context - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/ruby/comparision-operator.diffA-B.txt b/test/fixtures/ruby/comparision-operator.diffA-B.txt index 6e5e66dc7..05236df2d 100644 --- a/test/fixtures/ruby/comparision-operator.diffA-B.txt +++ b/test/fixtures/ruby/comparision-operator.diffA-B.txt @@ -1,13 +1,13 @@ (Program -{+(LessThanEqual +{ (LessThan + {-(Identifier)-} + {-(Identifier)-}) +->(LessThanEqual {+(Identifier)+} - {+(Identifier)+})+} + {+(Identifier)+}) } {+(GreaterThanEqual {+(Identifier)+} {+(Identifier)+})+} -{-(LessThan - {-(Identifier)-} - {-(Identifier)-})-} {-(GreaterThan {-(Identifier)-} {-(Identifier)-})-}) diff --git a/test/fixtures/ruby/comparision-operator.diffB-A.txt b/test/fixtures/ruby/comparision-operator.diffB-A.txt index a7175163a..4c2443911 100644 --- a/test/fixtures/ruby/comparision-operator.diffB-A.txt +++ b/test/fixtures/ruby/comparision-operator.diffB-A.txt @@ -1,13 +1,13 @@ (Program -{+(LessThan +{ (LessThanEqual + {-(Identifier)-} + {-(Identifier)-}) +->(LessThan {+(Identifier)+} - {+(Identifier)+})+} + {+(Identifier)+}) } {+(GreaterThan {+(Identifier)+} {+(Identifier)+})+} -{-(LessThanEqual - {-(Identifier)-} - {-(Identifier)-})-} {-(GreaterThanEqual {-(Identifier)-} {-(Identifier)-})-}) diff --git a/test/fixtures/ruby/delimiter.diffA-B.txt b/test/fixtures/ruby/delimiter.diffA-B.txt index cb091f81c..e7e1220f2 100644 --- a/test/fixtures/ruby/delimiter.diffA-B.txt +++ b/test/fixtures/ruby/delimiter.diffA-B.txt @@ -3,10 +3,10 @@ {+(TextElement)+} {+(TextElement)+} {+(TextElement)+} -{+(TextElement)+} -{+(TextElement)+} -{-(TextElement)-} -{-(TextElement)-} +{ (TextElement) +->(TextElement) } +{ (TextElement) +->(TextElement) } {-(TextElement)-} {-(TextElement)-} {-(TextElement)-} diff --git a/test/fixtures/ruby/delimiter.diffB-A.txt b/test/fixtures/ruby/delimiter.diffB-A.txt index cb091f81c..f69979390 100644 --- a/test/fixtures/ruby/delimiter.diffB-A.txt +++ b/test/fixtures/ruby/delimiter.diffB-A.txt @@ -1,12 +1,12 @@ (Program {+(TextElement)+} +{ (TextElement) +->(TextElement) } {+(TextElement)+} {+(TextElement)+} {+(TextElement)+} -{+(TextElement)+} -{+(TextElement)+} -{-(TextElement)-} -{-(TextElement)-} +{ (TextElement) +->(TextElement) } {-(TextElement)-} {-(TextElement)-} {-(TextElement)-} diff --git a/test/fixtures/ruby/element-reference.diffA-B.txt b/test/fixtures/ruby/element-reference.diffA-B.txt index 41e511609..aafa20058 100644 --- a/test/fixtures/ruby/element-reference.diffA-B.txt +++ b/test/fixtures/ruby/element-reference.diffA-B.txt @@ -7,8 +7,8 @@ (Subscript { (Identifier) ->(Identifier) } - {+(Symbol)+} - {-(Symbol)-}) + { (Symbol) + ->(Symbol) }) {-(Assignment {-(Subscript {-(Identifier)-} diff --git a/test/fixtures/ruby/element-reference.diffB-A.txt b/test/fixtures/ruby/element-reference.diffB-A.txt index d8603e4c4..6598ed5e2 100644 --- a/test/fixtures/ruby/element-reference.diffB-A.txt +++ b/test/fixtures/ruby/element-reference.diffB-A.txt @@ -7,8 +7,8 @@ (Subscript { (Identifier) ->(Identifier) } - {+(Symbol)+} - {-(Symbol)-}) + { (Symbol) + ->(Symbol) }) {+(Assignment {+(Subscript {+(Identifier)+} diff --git a/test/fixtures/ruby/end-block.diffA-B.txt b/test/fixtures/ruby/end-block.diffA-B.txt index 81f64fa1a..761acb510 100644 --- a/test/fixtures/ruby/end-block.diffA-B.txt +++ b/test/fixtures/ruby/end-block.diffA-B.txt @@ -1,5 +1,5 @@ (Program {+(Identifier)+} (ScopeExit - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/ruby/for.diffB-A.txt b/test/fixtures/ruby/for.diffB-A.txt index 98916ef1c..396c9dcf2 100644 --- a/test/fixtures/ruby/for.diffB-A.txt +++ b/test/fixtures/ruby/for.diffB-A.txt @@ -12,8 +12,8 @@ {+(Identifier)+})+} (ForEach ( - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) { (Array {-(Integer)-} {-(Integer)-} diff --git a/test/fixtures/ruby/interpolation.diffA-B.txt b/test/fixtures/ruby/interpolation.diffA-B.txt index 8d6ffecdb..c0a24bfee 100644 --- a/test/fixtures/ruby/interpolation.diffA-B.txt +++ b/test/fixtures/ruby/interpolation.diffA-B.txt @@ -1,5 +1,5 @@ (Program -{+(Symbol)+} -{+(TextElement)+} -{-(Symbol)-} -{-(TextElement)-}) +{ (Symbol) +->(Symbol) } +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/ruby/interpolation.diffB-A.txt b/test/fixtures/ruby/interpolation.diffB-A.txt index 8d6ffecdb..c0a24bfee 100644 --- a/test/fixtures/ruby/interpolation.diffB-A.txt +++ b/test/fixtures/ruby/interpolation.diffB-A.txt @@ -1,5 +1,5 @@ (Program -{+(Symbol)+} -{+(TextElement)+} -{-(Symbol)-} -{-(TextElement)-}) +{ (Symbol) +->(Symbol) } +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/ruby/multiple-assignments.diffA-B.txt b/test/fixtures/ruby/multiple-assignments.diffA-B.txt index c2d26304f..8645f3aef 100644 --- a/test/fixtures/ruby/multiple-assignments.diffA-B.txt +++ b/test/fixtures/ruby/multiple-assignments.diffA-B.txt @@ -2,8 +2,8 @@ (Assignment ( (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } {-(Identifier)-}) (Array (Integer) diff --git a/test/fixtures/ruby/multiple-assignments.diffB-A.txt b/test/fixtures/ruby/multiple-assignments.diffB-A.txt index 07ac0d537..9ed61e0d3 100644 --- a/test/fixtures/ruby/multiple-assignments.diffB-A.txt +++ b/test/fixtures/ruby/multiple-assignments.diffB-A.txt @@ -2,9 +2,9 @@ (Assignment ( (Identifier) - {+(Identifier)+} - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) } + {+(Identifier)+}) (Array (Integer) (Integer) diff --git a/test/fixtures/ruby/number.diffA-B.txt b/test/fixtures/ruby/number.diffA-B.txt index 433ee8148..edc5fb6dc 100644 --- a/test/fixtures/ruby/number.diffA-B.txt +++ b/test/fixtures/ruby/number.diffA-B.txt @@ -1,6 +1,7 @@ (Program {+(Integer)+} -{+(Integer)+} +{ (Integer) +->(Integer) } {+(Integer)+} {+(Integer)+} {+(Integer)+} @@ -11,5 +12,4 @@ {-(Integer)-} {-(Integer)-} {-(Integer)-} -{-(Integer)-} {-(Float)-}) diff --git a/test/fixtures/ruby/regex.diffA-B.txt b/test/fixtures/ruby/regex.diffA-B.txt index 732d2e573..fb3fb0954 100644 --- a/test/fixtures/ruby/regex.diffA-B.txt +++ b/test/fixtures/ruby/regex.diffA-B.txt @@ -1,4 +1,4 @@ (Program -{+(Regex)+} -{+(Regex)+} -{-(Regex)-}) +{ (Regex) +->(Regex) } +{+(Regex)+}) diff --git a/test/fixtures/ruby/regex.diffB-A.txt b/test/fixtures/ruby/regex.diffB-A.txt index cfee1709a..0edbcd5e1 100644 --- a/test/fixtures/ruby/regex.diffB-A.txt +++ b/test/fixtures/ruby/regex.diffB-A.txt @@ -1,4 +1,4 @@ (Program -{+(Regex)+} -{-(Regex)-} +{ (Regex) +->(Regex) } {-(Regex)-}) diff --git a/test/fixtures/ruby/string.diffA-B.txt b/test/fixtures/ruby/string.diffA-B.txt index e8dece007..f88ed6117 100644 --- a/test/fixtures/ruby/string.diffA-B.txt +++ b/test/fixtures/ruby/string.diffA-B.txt @@ -1,5 +1,5 @@ (Program -{+(TextElement)+} -{+(TextElement)+} -{-(TextElement)-} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) } +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/ruby/string.diffB-A.txt b/test/fixtures/ruby/string.diffB-A.txt index e8dece007..f88ed6117 100644 --- a/test/fixtures/ruby/string.diffB-A.txt +++ b/test/fixtures/ruby/string.diffB-A.txt @@ -1,5 +1,5 @@ (Program -{+(TextElement)+} -{+(TextElement)+} -{-(TextElement)-} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) } +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/ruby/subshell.diffA-B.txt b/test/fixtures/ruby/subshell.diffA-B.txt index 0695d0f25..c368003ca 100644 --- a/test/fixtures/ruby/subshell.diffA-B.txt +++ b/test/fixtures/ruby/subshell.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(TextElement)+} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/ruby/subshell.diffB-A.txt b/test/fixtures/ruby/subshell.diffB-A.txt index 0695d0f25..c368003ca 100644 --- a/test/fixtures/ruby/subshell.diffB-A.txt +++ b/test/fixtures/ruby/subshell.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(TextElement)+} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/ruby/symbol.diffA-B.txt b/test/fixtures/ruby/symbol.diffA-B.txt index 8be3df5c2..4e4701d0f 100644 --- a/test/fixtures/ruby/symbol.diffA-B.txt +++ b/test/fixtures/ruby/symbol.diffA-B.txt @@ -1,7 +1,7 @@ (Program +{ (Symbol) +->(Symbol) } {+(Symbol)+} -{+(Symbol)+} -{+(Symbol)+} -{-(Symbol)-} -{-(Symbol)-} +{ (Symbol) +->(Symbol) } {-(Symbol)-}) diff --git a/test/fixtures/ruby/symbol.diffB-A.txt b/test/fixtures/ruby/symbol.diffB-A.txt index 8be3df5c2..f78d2a84b 100644 --- a/test/fixtures/ruby/symbol.diffB-A.txt +++ b/test/fixtures/ruby/symbol.diffB-A.txt @@ -1,7 +1,7 @@ (Program +{ (Symbol) +->(Symbol) } {+(Symbol)+} {+(Symbol)+} -{+(Symbol)+} -{-(Symbol)-} {-(Symbol)-} {-(Symbol)-}) diff --git a/test/fixtures/ruby/when-else.diffA-B.txt b/test/fixtures/ruby/when-else.diffA-B.txt index 27858eab3..351ee5af5 100644 --- a/test/fixtures/ruby/when-else.diffA-B.txt +++ b/test/fixtures/ruby/when-else.diffA-B.txt @@ -4,8 +4,8 @@ ( (Pattern ( - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) ( {+(Identifier)+} {+(Identifier)+} diff --git a/test/fixtures/ruby/when-else.diffB-A.txt b/test/fixtures/ruby/when-else.diffB-A.txt index 968de42bc..6faa8148c 100644 --- a/test/fixtures/ruby/when-else.diffB-A.txt +++ b/test/fixtures/ruby/when-else.diffB-A.txt @@ -4,8 +4,8 @@ ( (Pattern ( - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) ( {+(Pattern {+( diff --git a/test/fixtures/typescript/class.diffA-B.txt b/test/fixtures/typescript/class.diffA-B.txt index f476d41be..fb37bba0c 100644 --- a/test/fixtures/typescript/class.diffA-B.txt +++ b/test/fixtures/typescript/class.diffA-B.txt @@ -7,8 +7,8 @@ { (Identifier) ->(Identifier) } (ExtendsClause - {+(TypeIdentifier)+} - {-(TypeIdentifier)-}) + { (TypeIdentifier) + ->(TypeIdentifier) }) {+(Method {+(Empty)+} {+(Empty)+} diff --git a/test/fixtures/typescript/class.diffB-A.txt b/test/fixtures/typescript/class.diffB-A.txt index b2417d64f..ea8642cf5 100644 --- a/test/fixtures/typescript/class.diffB-A.txt +++ b/test/fixtures/typescript/class.diffB-A.txt @@ -7,8 +7,8 @@ { (Identifier) ->(Identifier) } (ExtendsClause - {+(TypeIdentifier)+} - {-(TypeIdentifier)-}) + { (TypeIdentifier) + ->(TypeIdentifier) }) {+(PublicFieldDefinition {+(Empty)+} {+(Empty)+} diff --git a/test/fixtures/typescript/comment.diffA-B.txt b/test/fixtures/typescript/comment.diffA-B.txt index d313b7cf4..ab0622e59 100644 --- a/test/fixtures/typescript/comment.diffA-B.txt +++ b/test/fixtures/typescript/comment.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Context - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/typescript/comment.diffB-A.txt b/test/fixtures/typescript/comment.diffB-A.txt index d313b7cf4..ab0622e59 100644 --- a/test/fixtures/typescript/comment.diffB-A.txt +++ b/test/fixtures/typescript/comment.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Context - {+(Comment)+} - {-(Comment)-} + { (Comment) + ->(Comment) } (Empty))) diff --git a/test/fixtures/typescript/constructor-call.diffA-B.txt b/test/fixtures/typescript/constructor-call.diffA-B.txt index 12476992a..4cd5b5e65 100644 --- a/test/fixtures/typescript/constructor-call.diffA-B.txt +++ b/test/fixtures/typescript/constructor-call.diffA-B.txt @@ -5,6 +5,6 @@ (Identifier) (Identifier)) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty)))) diff --git a/test/fixtures/typescript/constructor-call.diffB-A.txt b/test/fixtures/typescript/constructor-call.diffB-A.txt index 12476992a..4cd5b5e65 100644 --- a/test/fixtures/typescript/constructor-call.diffB-A.txt +++ b/test/fixtures/typescript/constructor-call.diffB-A.txt @@ -5,6 +5,6 @@ (Identifier) (Identifier)) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty)))) diff --git a/test/fixtures/typescript/do-while-statement.diffA-B.txt b/test/fixtures/typescript/do-while-statement.diffA-B.txt index cc0d9d703..30c06d609 100644 --- a/test/fixtures/typescript/do-while-statement.diffA-B.txt +++ b/test/fixtures/typescript/do-while-statement.diffA-B.txt @@ -7,6 +7,6 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))) diff --git a/test/fixtures/typescript/do-while-statement.diffB-A.txt b/test/fixtures/typescript/do-while-statement.diffB-A.txt index cc0d9d703..30c06d609 100644 --- a/test/fixtures/typescript/do-while-statement.diffB-A.txt +++ b/test/fixtures/typescript/do-while-statement.diffB-A.txt @@ -7,6 +7,6 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))) diff --git a/test/fixtures/typescript/export.diffA-B.txt b/test/fixtures/typescript/export.diffA-B.txt index 45d600a90..d3c55c9dd 100644 --- a/test/fixtures/typescript/export.diffA-B.txt +++ b/test/fixtures/typescript/export.diffA-B.txt @@ -83,8 +83,8 @@ {+(Identifier)+} {+(Empty)+})+})) (Export - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) {+(Export {+(Function {+(Empty)+} diff --git a/test/fixtures/typescript/export.diffB-A.txt b/test/fixtures/typescript/export.diffB-A.txt index bc3a1ec6d..6629857ba 100644 --- a/test/fixtures/typescript/export.diffB-A.txt +++ b/test/fixtures/typescript/export.diffB-A.txt @@ -81,8 +81,8 @@ {-(Identifier)-} {-(Empty)-})-})) (Export - {+(Identifier)+} - {-(Identifier)-}) + { (Identifier) + ->(Identifier) }) {-(Export {-(Function {-(Empty)-} @@ -111,8 +111,8 @@ {+(Identifier)+} {+(Identifier)+})+})+})+} (Export - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Export (ExportClause (ImportExportSpecifier @@ -131,8 +131,8 @@ {-(ImportExportSpecifier {-(Identifier)-} {-(Empty)-})-}) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) {+(Export {+(ExportClause {+(ImportExportSpecifier diff --git a/test/fixtures/typescript/for-of-statement.diffA-B.txt b/test/fixtures/typescript/for-of-statement.diffA-B.txt index 8fdf44a8b..9886795f9 100644 --- a/test/fixtures/typescript/for-of-statement.diffA-B.txt +++ b/test/fixtures/typescript/for-of-statement.diffA-B.txt @@ -7,7 +7,7 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)))) (Empty)) diff --git a/test/fixtures/typescript/for-of-statement.diffB-A.txt b/test/fixtures/typescript/for-of-statement.diffB-A.txt index 8fdf44a8b..9886795f9 100644 --- a/test/fixtures/typescript/for-of-statement.diffB-A.txt +++ b/test/fixtures/typescript/for-of-statement.diffB-A.txt @@ -7,7 +7,7 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)))) (Empty)) diff --git a/test/fixtures/typescript/function-call-args.diffA-B.txt b/test/fixtures/typescript/function-call-args.diffA-B.txt index 1d17d16e4..fd9317247 100644 --- a/test/fixtures/typescript/function-call-args.diffA-B.txt +++ b/test/fixtures/typescript/function-call-args.diffA-B.txt @@ -2,8 +2,8 @@ (Call (Identifier) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Function (Empty) (Empty) @@ -31,12 +31,12 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Return { (Identifier) ->(Identifier) }))) - {+(Boolean)+} - {-(Boolean)-} + { (Boolean) + ->(Boolean) } (Empty))) diff --git a/test/fixtures/typescript/function-call-args.diffB-A.txt b/test/fixtures/typescript/function-call-args.diffB-A.txt index 2425e211a..4f9a10527 100644 --- a/test/fixtures/typescript/function-call-args.diffB-A.txt +++ b/test/fixtures/typescript/function-call-args.diffB-A.txt @@ -2,8 +2,8 @@ (Call (Identifier) (Float) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Function (Empty) (Empty) @@ -26,12 +26,12 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Return { (Identifier) ->(Identifier) }))) - {+(Boolean)+} - {-(Boolean)-} + { (Boolean) + ->(Boolean) } (Empty))) diff --git a/test/fixtures/typescript/function-call.diffA-B.txt b/test/fixtures/typescript/function-call.diffA-B.txt index 841f8af73..f2fa351c1 100644 --- a/test/fixtures/typescript/function-call.diffA-B.txt +++ b/test/fixtures/typescript/function-call.diffA-B.txt @@ -1,9 +1,9 @@ (Program (Call - {+(TypeIdentifier)+} - {-(TypeIdentifier)-} + { (TypeIdentifier) + ->(TypeIdentifier) } (Identifier) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/typescript/function-call.diffB-A.txt b/test/fixtures/typescript/function-call.diffB-A.txt index 841f8af73..f2fa351c1 100644 --- a/test/fixtures/typescript/function-call.diffB-A.txt +++ b/test/fixtures/typescript/function-call.diffB-A.txt @@ -1,9 +1,9 @@ (Program (Call - {+(TypeIdentifier)+} - {-(TypeIdentifier)-} + { (TypeIdentifier) + ->(TypeIdentifier) } (Identifier) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/typescript/function.diffA-B.txt b/test/fixtures/typescript/function.diffA-B.txt index d645bc87d..3e30524f1 100644 --- a/test/fixtures/typescript/function.diffA-B.txt +++ b/test/fixtures/typescript/function.diffA-B.txt @@ -23,6 +23,6 @@ (Identifier) (Empty))) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) diff --git a/test/fixtures/typescript/function.diffB-A.txt b/test/fixtures/typescript/function.diffB-A.txt index 4c0aa96d7..4687cb905 100644 --- a/test/fixtures/typescript/function.diffB-A.txt +++ b/test/fixtures/typescript/function.diffB-A.txt @@ -23,6 +23,6 @@ (Identifier) (Empty))) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Empty)) diff --git a/test/fixtures/typescript/identifier.diffA-B.txt b/test/fixtures/typescript/identifier.diffA-B.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/typescript/identifier.diffA-B.txt +++ b/test/fixtures/typescript/identifier.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/typescript/identifier.diffB-A.txt b/test/fixtures/typescript/identifier.diffB-A.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/typescript/identifier.diffB-A.txt +++ b/test/fixtures/typescript/identifier.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/typescript/if.diffA-B.txt b/test/fixtures/typescript/if.diffA-B.txt index c69dacb57..2a90eee30 100644 --- a/test/fixtures/typescript/if.diffA-B.txt +++ b/test/fixtures/typescript/if.diffA-B.txt @@ -7,8 +7,8 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) {+(Identifier)+}) (Empty))) diff --git a/test/fixtures/typescript/if.diffB-A.txt b/test/fixtures/typescript/if.diffB-A.txt index 5795a5f1f..a6742d0e3 100644 --- a/test/fixtures/typescript/if.diffB-A.txt +++ b/test/fixtures/typescript/if.diffB-A.txt @@ -7,8 +7,8 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) {-(Identifier)-}) (Empty))) diff --git a/test/fixtures/typescript/import.diffA-B.txt b/test/fixtures/typescript/import.diffA-B.txt index bea68ce51..a570b2cfa 100644 --- a/test/fixtures/typescript/import.diffA-B.txt +++ b/test/fixtures/typescript/import.diffA-B.txt @@ -2,15 +2,15 @@ (Import (ImportClause (Identifier)) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -18,8 +18,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -31,8 +31,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -45,8 +45,8 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) @@ -60,16 +60,16 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/typescript/import.diffB-A.txt b/test/fixtures/typescript/import.diffB-A.txt index bea68ce51..a570b2cfa 100644 --- a/test/fixtures/typescript/import.diffB-A.txt +++ b/test/fixtures/typescript/import.diffB-A.txt @@ -2,15 +2,15 @@ (Import (ImportClause (Identifier)) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -18,8 +18,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -31,8 +31,8 @@ { (Identifier) ->(Identifier) } (Empty)))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (NamedImports @@ -45,8 +45,8 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) @@ -60,16 +60,16 @@ ->(Identifier) } { (Identifier) ->(Identifier) }))) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import (ImportClause (Identifier) (NamespaceImport { (Identifier) ->(Identifier) })) - {+(TextElement)+} - {-(TextElement)-}) + { (TextElement) + ->(TextElement) }) (Import - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/typescript/method-call.diffA-B.txt b/test/fixtures/typescript/method-call.diffA-B.txt index 8430f65f5..04b6484e5 100644 --- a/test/fixtures/typescript/method-call.diffA-B.txt +++ b/test/fixtures/typescript/method-call.diffA-B.txt @@ -4,6 +4,6 @@ (Identifier) (Identifier)) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/typescript/method-call.diffB-A.txt b/test/fixtures/typescript/method-call.diffB-A.txt index 8430f65f5..04b6484e5 100644 --- a/test/fixtures/typescript/method-call.diffB-A.txt +++ b/test/fixtures/typescript/method-call.diffB-A.txt @@ -4,6 +4,6 @@ (Identifier) (Identifier)) (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))) diff --git a/test/fixtures/typescript/nested-do-while-in-function.diffA-B.txt b/test/fixtures/typescript/nested-do-while-in-function.diffA-B.txt index ba5df0f57..df8b4c724 100644 --- a/test/fixtures/typescript/nested-do-while-in-function.diffA-B.txt +++ b/test/fixtures/typescript/nested-do-while-in-function.diffA-B.txt @@ -22,6 +22,6 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/typescript/nested-do-while-in-function.diffB-A.txt b/test/fixtures/typescript/nested-do-while-in-function.diffB-A.txt index ba5df0f57..df8b4c724 100644 --- a/test/fixtures/typescript/nested-do-while-in-function.diffB-A.txt +++ b/test/fixtures/typescript/nested-do-while-in-function.diffB-A.txt @@ -22,6 +22,6 @@ ( (Call (Identifier) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/typescript/nested-functions.diffA-B.txt b/test/fixtures/typescript/nested-functions.diffA-B.txt index cd11fbc69..66b665736 100644 --- a/test/fixtures/typescript/nested-functions.diffA-B.txt +++ b/test/fixtures/typescript/nested-functions.diffA-B.txt @@ -37,13 +37,13 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Call (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/typescript/nested-functions.diffB-A.txt b/test/fixtures/typescript/nested-functions.diffB-A.txt index cd11fbc69..66b665736 100644 --- a/test/fixtures/typescript/nested-functions.diffB-A.txt +++ b/test/fixtures/typescript/nested-functions.diffB-A.txt @@ -37,13 +37,13 @@ (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty)) (Call (MemberAccess (Identifier) (Identifier)) - {+(Identifier)+} - {-(Identifier)-} + { (Identifier) + ->(Identifier) } (Empty))))))) diff --git a/test/fixtures/typescript/number.diffA-B.txt b/test/fixtures/typescript/number.diffA-B.txt index 5741a6028..9c7b7f65e 100644 --- a/test/fixtures/typescript/number.diffA-B.txt +++ b/test/fixtures/typescript/number.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Float)+} -{-(Float)-}) +{ (Float) +->(Float) }) diff --git a/test/fixtures/typescript/number.diffB-A.txt b/test/fixtures/typescript/number.diffB-A.txt index 5741a6028..9c7b7f65e 100644 --- a/test/fixtures/typescript/number.diffB-A.txt +++ b/test/fixtures/typescript/number.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Float)+} -{-(Float)-}) +{ (Float) +->(Float) }) diff --git a/test/fixtures/typescript/regex.diffA-B.txt b/test/fixtures/typescript/regex.diffA-B.txt index 91633c360..9c5e630f5 100644 --- a/test/fixtures/typescript/regex.diffA-B.txt +++ b/test/fixtures/typescript/regex.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Regex)+} -{-(Regex)-}) +{ (Regex) +->(Regex) }) diff --git a/test/fixtures/typescript/regex.diffB-A.txt b/test/fixtures/typescript/regex.diffB-A.txt index 91633c360..9c5e630f5 100644 --- a/test/fixtures/typescript/regex.diffB-A.txt +++ b/test/fixtures/typescript/regex.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Regex)+} -{-(Regex)-}) +{ (Regex) +->(Regex) }) diff --git a/test/fixtures/typescript/relational-operator.diffA-B.txt b/test/fixtures/typescript/relational-operator.diffA-B.txt index 3beb3939f..b10fba844 100644 --- a/test/fixtures/typescript/relational-operator.diffA-B.txt +++ b/test/fixtures/typescript/relational-operator.diffA-B.txt @@ -1,7 +1,7 @@ (Program -{+(LessThanEqual - {+(Identifier)+} - {+(Identifier)+})+} -{-(LessThan +{ (LessThan {-(Identifier)-} - {-(Identifier)-})-}) + {-(Identifier)-}) +->(LessThanEqual + {+(Identifier)+} + {+(Identifier)+}) }) diff --git a/test/fixtures/typescript/relational-operator.diffB-A.txt b/test/fixtures/typescript/relational-operator.diffB-A.txt index b08ba1cfd..811022c76 100644 --- a/test/fixtures/typescript/relational-operator.diffB-A.txt +++ b/test/fixtures/typescript/relational-operator.diffB-A.txt @@ -1,7 +1,7 @@ (Program -{+(LessThan - {+(Identifier)+} - {+(Identifier)+})+} -{-(LessThanEqual +{ (LessThanEqual {-(Identifier)-} - {-(Identifier)-})-}) + {-(Identifier)-}) +->(LessThan + {+(Identifier)+} + {+(Identifier)+}) }) diff --git a/test/fixtures/typescript/string.diffA-B.txt b/test/fixtures/typescript/string.diffA-B.txt index 0695d0f25..c368003ca 100644 --- a/test/fixtures/typescript/string.diffA-B.txt +++ b/test/fixtures/typescript/string.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(TextElement)+} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/typescript/string.diffB-A.txt b/test/fixtures/typescript/string.diffB-A.txt index 0695d0f25..c368003ca 100644 --- a/test/fixtures/typescript/string.diffB-A.txt +++ b/test/fixtures/typescript/string.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(TextElement)+} -{-(TextElement)-}) +{ (TextElement) +->(TextElement) }) diff --git a/test/fixtures/typescript/subscript-access-string.diffA-B.txt b/test/fixtures/typescript/subscript-access-string.diffA-B.txt index 3ed3b9d54..e89be8ff9 100644 --- a/test/fixtures/typescript/subscript-access-string.diffA-B.txt +++ b/test/fixtures/typescript/subscript-access-string.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/typescript/subscript-access-string.diffB-A.txt b/test/fixtures/typescript/subscript-access-string.diffB-A.txt index 3ed3b9d54..e89be8ff9 100644 --- a/test/fixtures/typescript/subscript-access-string.diffB-A.txt +++ b/test/fixtures/typescript/subscript-access-string.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(TextElement)+} - {-(TextElement)-})) + { (TextElement) + ->(TextElement) })) diff --git a/test/fixtures/typescript/subscript-access-variable.diffA-B.txt b/test/fixtures/typescript/subscript-access-variable.diffA-B.txt index 52c195a4f..428bf4bf1 100644 --- a/test/fixtures/typescript/subscript-access-variable.diffA-B.txt +++ b/test/fixtures/typescript/subscript-access-variable.diffA-B.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/typescript/subscript-access-variable.diffB-A.txt b/test/fixtures/typescript/subscript-access-variable.diffB-A.txt index 52c195a4f..428bf4bf1 100644 --- a/test/fixtures/typescript/subscript-access-variable.diffB-A.txt +++ b/test/fixtures/typescript/subscript-access-variable.diffB-A.txt @@ -1,5 +1,5 @@ (Program (Subscript (Identifier) - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) diff --git a/test/fixtures/typescript/switch-statement.diffA-B.txt b/test/fixtures/typescript/switch-statement.diffA-B.txt index 4d8fab67e..e72d89a5b 100644 --- a/test/fixtures/typescript/switch-statement.diffA-B.txt +++ b/test/fixtures/typescript/switch-statement.diffA-B.txt @@ -10,8 +10,8 @@ (Pattern (Float) ( - {+(Float)+} - {-(Float)-})) + { (Float) + ->(Float) })) (Pattern (Float) ( diff --git a/test/fixtures/typescript/switch-statement.diffB-A.txt b/test/fixtures/typescript/switch-statement.diffB-A.txt index 4d8fab67e..e72d89a5b 100644 --- a/test/fixtures/typescript/switch-statement.diffB-A.txt +++ b/test/fixtures/typescript/switch-statement.diffB-A.txt @@ -10,8 +10,8 @@ (Pattern (Float) ( - {+(Float)+} - {-(Float)-})) + { (Float) + ->(Float) })) (Pattern (Float) ( diff --git a/test/fixtures/typescript/throw-statement.diffA-B.txt b/test/fixtures/typescript/throw-statement.diffA-B.txt index ce5253324..a442e1a04 100644 --- a/test/fixtures/typescript/throw-statement.diffA-B.txt +++ b/test/fixtures/typescript/throw-statement.diffA-B.txt @@ -3,6 +3,6 @@ (New (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))))) diff --git a/test/fixtures/typescript/throw-statement.diffB-A.txt b/test/fixtures/typescript/throw-statement.diffB-A.txt index ce5253324..a442e1a04 100644 --- a/test/fixtures/typescript/throw-statement.diffB-A.txt +++ b/test/fixtures/typescript/throw-statement.diffB-A.txt @@ -3,6 +3,6 @@ (New (Call (Identifier) - {+(TextElement)+} - {-(TextElement)-} + { (TextElement) + ->(TextElement) } (Empty))))) diff --git a/test/fixtures/typescript/try-statement.diffA-B.txt b/test/fixtures/typescript/try-statement.diffA-B.txt index 95160f872..a1448e34d 100644 --- a/test/fixtures/typescript/try-statement.diffA-B.txt +++ b/test/fixtures/typescript/try-statement.diffA-B.txt @@ -5,10 +5,10 @@ (Catch (Empty) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Finally ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) (Empty)) diff --git a/test/fixtures/typescript/try-statement.diffB-A.txt b/test/fixtures/typescript/try-statement.diffB-A.txt index 95160f872..a1448e34d 100644 --- a/test/fixtures/typescript/try-statement.diffB-A.txt +++ b/test/fixtures/typescript/try-statement.diffB-A.txt @@ -5,10 +5,10 @@ (Catch (Empty) ( - {+(Identifier)+} - {-(Identifier)-})) + { (Identifier) + ->(Identifier) })) (Finally ( - {+(Identifier)+} - {-(Identifier)-}))) + { (Identifier) + ->(Identifier) }))) (Empty)) diff --git a/test/fixtures/typescript/variable.diffA-B.txt b/test/fixtures/typescript/variable.diffA-B.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/typescript/variable.diffA-B.txt +++ b/test/fixtures/typescript/variable.diffA-B.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) }) diff --git a/test/fixtures/typescript/variable.diffB-A.txt b/test/fixtures/typescript/variable.diffB-A.txt index 815fc5225..6ac9cd896 100644 --- a/test/fixtures/typescript/variable.diffB-A.txt +++ b/test/fixtures/typescript/variable.diffB-A.txt @@ -1,3 +1,3 @@ (Program -{+(Identifier)+} -{-(Identifier)-}) +{ (Identifier) +->(Identifier) })