From d059c26fbce496f2f75e29011223da9cd45edd7e Mon Sep 17 00:00:00 2001 From: joshvera Date: Mon, 25 Sep 2017 14:07:35 -0400 Subject: [PATCH] bring old typescript term assignment back --- src/Language/TypeScript.hs | 181 +++++++++++++++++++++++++++++++++++++ src/TreeSitter.hs | 2 + 2 files changed, 183 insertions(+) diff --git a/src/Language/TypeScript.hs b/src/Language/TypeScript.hs index 9bf735a26..7a562836c 100644 --- a/src/Language/TypeScript.hs +++ b/src/Language/TypeScript.hs @@ -1,2 +1,183 @@ {-# LANGUAGE DataKinds #-} module Language.TypeScript where + +import Control.Comonad (extract) +import Control.Comonad.Cofree (unwrap) +import Data.Foldable (toList) +import Data.Record +import Data.Source +import Data.Text (Text) +import Info +import Language +import qualified Syntax as S +import Term + +termAssignment + :: Source -- ^ The source of the term. + -> Category -- ^ The category for the term. + -> [ Term S.Syntax (Record DefaultFields) ] -- ^ The child nodes of the term. + -> Maybe (S.Syntax (Term S.Syntax (Record DefaultFields))) -- ^ The resulting term, in Maybe. +termAssignment _ category children = + case (category, children) of + (Assignment, [ identifier, value ]) -> Just $ S.Assignment identifier value + (MathAssignment, [ identifier, value ]) -> Just $ S.OperatorAssignment identifier value + (MemberAccess, [ base, property ]) -> Just $ S.MemberAccess base property + (SubscriptAccess, [ base, element ]) -> Just $ S.SubscriptAccess base element + (CommaOperator, [ a, b ]) + | S.Indexed rest <- unwrap b + -> Just $ S.Indexed $ a : rest + (FunctionCall, id : rest) -> case break ((== Args) . Info.category . extract) rest of + (typeArgs, [ args ]) -> let flatArgs = toList (unwrap args) in + Just $ case unwrap id of + S.MemberAccess target method -> S.MethodCall target method typeArgs flatArgs + _ -> S.FunctionCall id typeArgs flatArgs + _ -> Nothing + (Ternary, condition : cases) -> Just $ S.Ternary condition cases + (Other "variable_declaration", _) -> Just . S.Indexed $ toVarDeclOrAssignment <$> children + (Other "trailing_variable_declaration", _) -> Just . S.Indexed $ toVarDeclOrAssignment <$> children + (Other "lexical_declaration", _) -> Just . S.Indexed $ toVarDeclOrAssignment <$> children + (VarAssignment, [id, assignment]) -> Just $ S.VarAssignment [id] assignment + (FieldDecl, _) -> Just $ S.FieldDecl children + (Object, _) -> Just . S.Object Nothing $ foldMap toTuple children + (DoWhile, [ expr, body ]) -> Just $ S.DoWhile expr body + (Constructor, [ expr ]) -> Just $ S.Constructor expr + (Try, [ body ]) -> Just $ S.Try [body] [] Nothing Nothing + (Try, [ body, catch ]) + | Catch <- Info.category (extract catch) + -> Just $ S.Try [body] [catch] Nothing Nothing + (Try, [ body, finally ]) + | Finally <- Info.category (extract finally) + -> Just $ S.Try [body] [] Nothing (Just finally) + (Try, [ body, catch, finally ]) + | Catch <- Info.category (extract catch) + , Finally <- Info.category (extract finally) + -> Just $ S.Try [body] [catch] Nothing (Just finally) + (ArrayLiteral, _) -> Just $ S.Array Nothing children + (Method, children) -> case break ((== ExpressionStatements) . Info.category . extract) children of + (prev, [body]) -> case break ((== Identifier) . Info.category . extract) prev of + (prev, [id, callSignature]) -> Just $ S.Method prev id Nothing (toList (unwrap callSignature)) (toList (unwrap body)) + _ -> Nothing -- No identifier found or callSignature found. + _ -> Nothing -- No body found.`` + (Class, identifier : rest) -> case break ((== Other "class_body") . Info.category . extract) rest of + (clauses, [ definitions ]) -> Just $ S.Class identifier clauses (toList (unwrap definitions)) + _ -> Nothing + (Module, [ identifier, definitions ]) -> Just $ S.Module identifier (toList (unwrap definitions)) + (Namespace, [ identifier, definitions ]) -> Just $ S.Namespace identifier (toList (unwrap definitions)) + (Import, [ statements, identifier ] ) -> Just $ S.Import identifier (toList (unwrap statements)) + (Import, [ identifier ] ) -> Just $ S.Import identifier [] + (Export, [ statements, identifier] ) -> Just $ S.Export (Just identifier) (toList (unwrap statements)) + (Export, [ statements ] ) + | S.Indexed _ <- unwrap statements + -> Just $ S.Export Nothing (toList (unwrap statements)) + | otherwise -> Just $ S.Export (Just statements) [] + (For, _:_) -> Just $ S.For (init children >>= flattenExpressionStatements) [last children] + (Function, children) -> case break ((== ExpressionStatements) . Info.category . extract) children of + (inits, [body]) -> case inits of + [id, callSignature] -> Just $ S.Function id (toList (unwrap callSignature)) (toList (unwrap body)) + [callSignature] -> Just $ S.AnonymousFunction (toList (unwrap callSignature)) (toList (unwrap body)) + _ -> Nothing -- More than 1 identifier found or no call signature found + _ -> Nothing -- No body found. + (Ty, children) -> Just $ S.Ty children + (Interface, children) -> toInterface children + _ -> Nothing + where flattenExpressionStatements term + | Info.category (extract term) `elem` [ExpressionStatements, CommaOperator] = toList (unwrap term) >>= flattenExpressionStatements + | otherwise = [term] + +categoryForTypeScriptName :: Text -> Category +categoryForTypeScriptName category = case category of + "object" -> Object + "expression_statement" -> ExpressionStatements + "trailing_expression_statement" -> ExpressionStatements + "this_expression" -> Identifier + "null" -> Identifier + "undefined" -> Identifier + "type_identifier" -> Identifier + "property_identifier" -> Identifier + "shorthand_property_identifier" -> Identifier + "nested_identifier" -> Identifier + "arrow_function" -> Function + "generator_function" -> Function + "math_op" -> MathOperator -- math operator, e.g. +, -, *, /. + "update_expression" -> MathOperator -- math operator, e.g. ++, -- + "bool_op" -> BooleanOperator -- boolean operator, e.g. ||, &&. + "comma_op" -> CommaOperator -- comma operator, e.g. expr1, expr2. + "sequence_expression" -> CommaOperator -- comma operator, e.g. expr1, expr2. + "delete_op" -> Operator -- delete operator, e.g. delete x[2]. + "type_op" -> Operator -- type operator, e.g. typeof Object. + "void_op" -> Operator -- void operator, e.g. void 2. + "for_statement" -> For + "trailing_for_statement" -> For + "for_in_statement" -> For + "trailing_for_in_statement" -> For + "for_of_statement" -> For + "trailing_for_of_statement" -> For + "new_expression" -> Constructor + "class" -> Class + "catch" -> Catch + "catch_clause" -> Catch + "finally" -> Finally + "finally_clause" -> Finally + "if_statement" -> If + "trailing_if_statement" -> If + "empty_statement" -> Empty + "program" -> Program + "function_call" -> FunctionCall + "call_expression" -> FunctionCall + "pair" -> Pair + "string" -> StringLiteral + "integer" -> IntegerLiteral + "number" -> NumberLiteral + "float" -> FloatLiteral + "symbol" -> SymbolLiteral + "array" -> ArrayLiteral + "function" -> Function + "identifier" -> Identifier + "formal_parameters" -> Params + "arguments" -> Args + "statement_block" -> ExpressionStatements + "assignment" -> Assignment + "assignment_expression" -> Assignment + "member_access" -> MemberAccess + "member_expression" -> MemberAccess + "op" -> Operator + "subscript_access" -> SubscriptAccess + "subscript_expression" -> SubscriptAccess + "regex" -> Regex + "template_string" -> TemplateString + "switch_statement" -> Switch + "math_assignment" -> MathAssignment + "augmented_assignment_expression" -> MathAssignment + "case" -> Case + "switch_case" -> Case + "true" -> Boolean + "false" -> Boolean + "ternary" -> Ternary + "ternary_expression" -> Ternary + "while_statement" -> While + "trailing_while_statement" -> While + "do_statement" -> DoWhile + "trailing_do_statement" -> DoWhile + "return_statement" -> Return + "trailing_return_statement" -> Return + "throw_statement" -> Throw + "trailing_throw_statement" -> Throw + "try_statement" -> Try + "method_definition" -> Method + "comment" -> Comment + "bitwise_op" -> BitwiseOperator + "rel_op" -> RelationalOperator + "import_statement" -> Import + "export_statement" -> Export + "break_statement" -> Break + "continue_statement" -> Continue + "yield_expression" -> Yield + "public_field_definition" -> FieldDecl + "variable_declarator" -> VarAssignment + "type_annotation" -> Ty + "template_chars" -> TemplateString + "module" -> Module + "internal_module" -> Namespace + "interface_declaration" -> Interface + "parenthesized_expression" -> ParenthesizedExpression + name -> Other name diff --git a/src/TreeSitter.hs b/src/TreeSitter.hs index 7db2a956a..b6ec048e5 100644 --- a/src/TreeSitter.hs +++ b/src/TreeSitter.hs @@ -20,6 +20,7 @@ import Data.Text (Text, pack) import Language import qualified Language.Go as Go import qualified Language.Ruby as Ruby +import qualified Language.Ruby as TypeScript import Foreign import Foreign.C.String (peekCString) import Foreign.Marshal.Array (allocaArray) @@ -114,6 +115,7 @@ assignTerm language source annotation children allChildren = assignTermByLanguage = case languageForTSLanguage language of Just Language.Go -> Go.termAssignment Just Ruby -> Ruby.termAssignment + Just TypeScript -> TypeScript.termAssignment _ -> \ _ _ _ -> Nothing defaultTermAssignment :: Source -> Record DefaultFields -> [ Term S.Syntax (Record DefaultFields) ] -> IO [ Term S.Syntax (Record DefaultFields) ] -> IO (Term S.Syntax (Record DefaultFields))