Merge pull request #552 from Microsoft/multiLineArrowParameters

Treat ( followed by new line as parameter context for arrow, falling back to expression

Author: sheetalkamat

TypeScript.YAML-tmLanguage

@@ -31,6 +31,7 @@ variables:
   matchingBraces: (\{([^\{\}]|(\{[^\{\}]*\}))*\})
   matchingBrackets: (\[([^\[\]]|(\[[^\[\]]*\]))*\])
   inlineComment: \/\*([^\*]|(\*[^\/]))*\*\/
+  lookBehindOfPossiblyMultilineArrow: (?<=[(=,]|=>)
   # Identifier start | matching braces | matching parenthesis | matching square brackets
   typeParamersStart: ([_$[:alpha:]]|{{matchingBraces}}|{{matchingParenthesis}}|{{matchingBrackets}})
   typeParameters: (<\s*{{typeParamersStart}}([^=<>]|=[^<]|\<\s*{{typeParamersStart}}([^=<>]|=[^<])*\>)*>\s*)
@@ -39,6 +40,7 @@ variables:
   typeArgumentsInnerExpressionPart: '[^<>\(]|{{matchingParenthesis}}|(?<==)\>'
   typeArguments: '<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}}|\<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}})*(?!=)\>)*(?!=)>'
   functionCallLookup: \s*(\?\.\s*)?({{typeArguments}}\s*)?\(
+  returnTypeOfArrow: \s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+
   arrowLookup: |-
     # sure shot arrow functions even if => is on new line
     (
@@ -55,9 +57,10 @@ variables:
     (
       {{typeParameters}}?                                                                                 # typeparameters
       \(\s*(([_$[:alpha:]]|{{matchingBraces}}|{{matchingBrackets}})([^()]|{{matchingParenthesis}})*)?\)   # parameters
-      (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                                      # return type
+      (\s*:{{returnTypeOfArrow}})?                                                                        # return type
       \s*=>                                                                                               # arrow operator
     )
+  possiblyMultilineArrow: ({{typeParameters}}?[\(]\s*$)  # during lookup treat <typeparameters>?( followed by line end as arrow
   functionOrArrowLookup: |-
     \s*(
       ((async\s+)?(
@@ -66,6 +69,7 @@ variables:
         ({{identifier}}\s*=>)
       )) |
       ((async\s*)?(
+        {{possiblyMultilineArrow}} |
         {{arrowLookup}}
       ))
     )
@@ -86,6 +90,7 @@ variables:
       ))
     )) |
     (:\s*(=>|{{matchingParenthesis}}|(<[^<>]*>)|[^<>(),=])+={{functionOrArrowLookup}})
+  arrowFunctionEnd: (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
 
 patterns:
 - include: '#directives'
@@ -159,6 +164,7 @@ repository:
     - include: '#function-expression'
     - include: '#class-expression'
     - include: '#arrow-function'
+    - include: '#paren-expression-possibly-arrow'
     - include: '#cast'
     - include: '#ternary-expression'
     - include: '#new-expr'
@@ -580,7 +586,7 @@ repository:
         )
       beginCaptures:
         '1': { name: storage.modifier.async.ts }
-      end: (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+      end: '{{arrowFunctionEnd}}'
       patterns:
       - include: '#comment'
       - include: '#type-parameters'
@@ -637,6 +643,10 @@ repository:
     endCaptures:
       '0': { name: punctuation.definition.parameters.end.ts }
     patterns:
+    - include: '#function-parameters-body'
+
+  function-parameters-body:
+    patterns:
     - include: '#comment'
     - include: '#decorator'
     - include: '#destructuring-parameter'
@@ -1098,9 +1108,9 @@ repository:
     begin: (?!\?\.\s*[^[:digit:]])(\?)
     beginCaptures:
       '1': { name: keyword.operator.ternary.ts }
-    end: (:)
+    end: \s*(:)
     endCaptures:
-      '0': { name: keyword.operator.ternary.ts }
+      '1': { name: keyword.operator.ternary.ts }
     patterns:
     - include: '#expression'
 
@@ -1146,6 +1156,42 @@ repository:
     patterns:
     - include: '#type'
 
+  # when ( is followed by end of line, it could be arrow parameter decarations, so inside this match as if parameter falling back to expression
+  # but do this only from expression and as last resort
+  paren-expression-possibly-arrow:
+    patterns:
+    - begin: '{{lookBehindOfPossiblyMultilineArrow}}\s*(async)?(?=\s*{{typeParameters}}\(\s*$)'
+      beginCaptures:
+        '1': { name: storage.modifier.async.ts }
+      end: (?<=\))
+      patterns:
+      - include: '#type-parameters'
+      - begin: \(
+        beginCaptures:
+          '0': { name: meta.brace.round.ts }
+        end: \)
+        endCaptures:
+          '0': { name: meta.brace.round.ts }
+        patterns:
+        - include: '#expression-inside-possibly-arrow-parens'
+    - begin: '{{lookBehindOfPossiblyMultilineArrow}}\s*(async)?\s*(\()(?=\s*$)'
+      beginCaptures:
+        '1': { name: storage.modifier.async.ts }
+        '2': { name: meta.brace.round.ts }
+      end: \)
+      endCaptures:
+        '0': { name: meta.brace.round.ts }
+      patterns:
+      - include: '#expression-inside-possibly-arrow-parens'
+    - include: '#possibly-arrow-return-type'
+
+  expression-inside-possibly-arrow-parens:
+    patterns:
+    - include: '#expressionWithoutIdentifiers'
+    - include: '#function-parameters-body'
+    - include: '#identifiers'
+    - include: '#expressionPunctuations'
+
   paren-expression:
     begin: \(
     beginCaptures:
@@ -1155,7 +1201,6 @@ repository:
       '0': {name: meta.brace.round.ts }
     patterns:
     - include: '#expression'
-    - include: '#punctuation-comma'
 
   #cast expression
   cast:
@@ -1735,7 +1780,21 @@ repository:
     begin: '(?<=\))\s*(:)'
     beginCaptures:
       '1': { name: keyword.operator.type.annotation.ts }
-    end: (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+    end: '{{arrowFunctionEnd}}'
+    patterns:
+    - include: '#arrow-return-type-body'
+
+  #This is the check if the exoression '): something =>'' can be matched as return type of arrow
+  possibly-arrow-return-type:
+    begin: (?<=\))\s*(:)(?={{returnTypeOfArrow}}\s*=>)
+    beginCaptures:
+      '1': { name: meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts }
+    end: '{{arrowFunctionEnd}}'
+    contentName: meta.arrow.ts meta.return.type.arrow.ts
+    patterns:
+    - include: '#arrow-return-type-body'
+
+  arrow-return-type-body:
     patterns:
     # TODO: handle the fn and constructor type specifically.
     # Handle returning of object type specifically here so as to not confuse it with the start of function block