Merge pull request #661 from github/constructors

Add Constructors to Syntax

src/Category.hs

@@ -77,6 +77,8 @@ data Category
   | Object
   -- | A return statement.
   | Return
+  -- | A constructor statement, e.g. new Foo;
+  | Constructor
   -- | A try statement.
   | Try
   -- | A catch statement.

src/DiffSummary.hs

@@ -66,6 +66,7 @@ toTermName source term = case unwrap term of
   S.For exprs _ -> termNameFromChildren term exprs
   S.While expr _ -> toTermName' expr
   S.DoWhile _ expr -> toTermName' expr
+  S.Constructor expr -> toTermName' expr
   S.Try expr _ _ -> toText $ Source.slice (characterRange $ extract expr) source
   S.Array _ -> toText $ Source.slice (characterRange $ extract term) source
   S.Class identifier _ _ -> toTermName' identifier
@@ -120,6 +121,7 @@ instance HasCategory Category where
     C.DoWhile -> "do/while statement"
     C.Object -> "object"
     C.Return -> "return statement"
+    C.Constructor -> "constructor"
     C.Catch -> "catch statement"
     C.Try -> "try statement"
     C.Finally -> "finally statement"
@@ -197,6 +199,7 @@ diffSummaries sources = cata $ \case
   (Free (infos :< S.For exprs body)) -> annotateWithCategory infos <$> join exprs <> body
   (Free (infos :< S.While expr body)) -> annotateWithCategory infos <$> expr <> body
   (Free (infos :< S.DoWhile expr body)) -> annotateWithCategory infos <$> expr <> body
+  (Free (infos :< S.Constructor expr)) -> annotateWithCategory infos <$> expr
   (Free (infos :< S.Try expr catch finally)) -> annotateWithCategory infos <$> expr <> fromMaybe [] catch <> fromMaybe [] finally
   (Free (infos :< S.Array children)) -> annotateWithCategory infos <$> join children
   (Free (infos :< S.Class identifier superclass definitions)) -> annotateWithCategory infos <$> identifier <> fromMaybe [] superclass <> join definitions

src/Parser.hs

@@ -97,6 +97,8 @@ termConstructor source sourceSpan info = cofree . construct
       withDefaultInfo $ S.While expr body
     construct children | DoWhile == (category info), [expr, body] <- children =
       withDefaultInfo $ S.DoWhile expr body
+    construct children | Constructor == category info, [expr] <- children =
+      withDefaultInfo $ S.Constructor expr
     construct children | Try == category info = case children of
       [body] -> withDefaultInfo $ S.Try body Nothing Nothing
       [body, catch] | Catch <- category (extract catch) -> withDefaultInfo $ S.Try body (Just catch) Nothing

src/Renderer/JSON.hs

@@ -85,7 +85,8 @@ termFields info syntax = "range" .= characterRange info : "category" .= category
   S.SubscriptAccess id property -> [ "subscriptId" .= id ] <> [ "property" .= property ]
   S.Object pairs -> childrenFields pairs
   S.Pair a b -> childrenFields [a, b]
-  S.Return expr -> [ "returnExpr" .= expr ]
+  S.Return expr -> [ "returnExpression" .= expr ]
+  S.Constructor expr -> [ "constructorExpression" .= expr ]
   S.Comment _ -> []
   S.Commented comments child -> childrenFields (comments <> maybeToList child)
   S.Error sourceSpan c -> [ "sourceSpan" .= sourceSpan ] <> childrenFields c

src/Renderer/Split.hs

@@ -64,6 +64,7 @@ styleName category = "category-" <> case category of
   C.While -> "while"
   C.DoWhile -> "do_while"
   C.Return -> "return_statement"
+  C.Constructor -> "constructor"
   C.Try -> "try_statement"
   C.Catch -> "catch_statement"
   C.Finally -> "finally_statement"

src/Syntax.hs

@@ -60,6 +60,7 @@ data Syntax
   | DoWhile { doWhileBody :: f, doWhileExpr :: f }
   | While { whileExpr :: f, whileBody :: f }
   | Return (Maybe f)
+  | Constructor f
   | Try f (Maybe f) (Maybe f)
   -- | An array literal with list of children.
   | Array [f]

src/TreeSitter.hs

@@ -46,6 +46,7 @@ categoriesForLanguage language name = case (language, name) of
   (JavaScript, "void_op") -> Operator -- void operator, e.g. void 2.
   (JavaScript, "for_in_statement") -> For
   (JavaScript, "for_of_statement") -> For
+  (JavaScript, "new_expression") -> Constructor
   (JavaScript, "class")  -> Class
   (JavaScript, "catch") -> Catch
   (JavaScript, "finally") -> Finally