support namespaced tsx

Author: mtpc

.gitignore

@@ -1,7 +1,4 @@
-build/node_modules
-build/typings/
+node_modules
 build/*.js
-tests/generated/*
-tests/node_modules
-tests/typings/
-tests/*.js
+tests/*.js
+tests/generated/*

.travis.yml

@@ -0,0 +1,27 @@
+language: node_js
+
+node_js:
+  - 'stable'
+  - '8'
+  
+sudo: false
+
+env:
+  - workerCount=2
+
+matrix:
+  fast_finish: true
+
+branches:
+  only:
+  - master
+
+install:
+  - npm install
+
+cache:
+  directories:
+    - node_modules
+
+git:
+  depth: 1

README.md

@@ -1,5 +1,5 @@
 # TypeScript-TmLanguage
-[![Build status](https://ci.appveyor.com/api/projects/status/i7fp97q9nc5uw5kf?svg=true)](https://ci.appveyor.com/project/zhengbli/typescript-tmlanguage)
+[![Build status](https://travis-ci.org/Microsoft/TypeScript-TmLanguage.svg?branch=master)](https://travis-ci.org/Microsoft/TypeScript-TmLanguage)
 
 This repository contains TmLanguage files that are consumed by TypeScript editors and plugins such as [Visual Studio Code](https://github.com/Microsoft/vscode), [The TypeScript Sublime Plugin](https://github.com/Microsoft/TypeScript-Sublime-Plugin), [Atom TypeScript](https://github.com/TypeStrong/atom-typescript), and possibly others.
 
@@ -9,28 +9,24 @@ Latest version of the grammar can be also found as a [VSCode extension](https://
 
 The XML files are generated from the YAML files, so contributors should hand-modify the YAML files, and XML files should only be generated by running build script.
 
+## Install dependencies
+``` sh
+npm install
+```
+
 ## Build
 
-Update the XML files from within the ```build``` folder
+Compile the yaml file into the tmLanguage and tmTheme files
 
 ``` sh
-cd build
-npm install         # Installs dependencies required for building
-npm start           # Compiles & builds the XML files
+npm run build:grammar
 ```
 
 ## Tests
 
-Test are run from within the ```tests``` folder and depend on build to make sure XML files are upto date
-
 ``` sh
-cd build
-npm install         # Installs dependencies required for building
-
-cd ../tests
-npm install         # Installs dependencies required for testing
 npm test            # Compiles & runs tests
 
 npm run diff        # Diffs the test baselines with generated one using tool set in environment variable DIFF
 npm run accept      # Accepts the test baselines
-```
+```

TypeScript.YAML-tmLanguage

@@ -16,33 +16,45 @@ variables:
   nonIdentifierPropertyName: '{{quotedStrings}}|(\[([^\[\]]|\[[^\[\]]*\])+\])'
   propertyName: (({{identifier}})|{{nonIdentifierPropertyName}})
   constantVar: ({{constantIdentifier}})(?![_$[:alnum:]])
+  nonPropertyLookBehind: '[^\._$[:alnum:]]'
+  lookBehindReturn: '^return|{{nonPropertyLookBehind}}return'
+  lookBehindThrow: '^throw|{{nonPropertyLookBehind}}throw'
+  lookBehindYield: '^yield|{{nonPropertyLookBehind}}yield'
+  lookBehindAwait: '^await|{{nonPropertyLookBehind}}await'
+  lookBehindDefault: '^default|{{nonPropertyLookBehind}}default'
+  lookBehindIn: '^in|{{nonPropertyLookBehind}}in'
+  lookBehindOf: '^of|{{nonPropertyLookBehind}}of'
+  lookBehindTypeof: '^typeof|{{nonPropertyLookBehind}}typeof'
+  lookBehindCase: '^case|{{nonPropertyLookBehind}}case'
   matchingParenthesis: (\([^\(\)]*\))
+  matchingBraces: (\{[^\{\}]*\})
+  matchingBrackets: (\[[^\[\]]*\])
   # Identifier start | matching braces | matching parenthesis | matching square brackets
-  typeParamersStart: ([_$[:alpha:]]|(\{[^\{\}]*\})|{{matchingParenthesis}}|(\[[^\[\]]*\]))
+  typeParamersStart: ([_$[:alpha:]]|{{matchingBraces}}|{{matchingParenthesis}}|{{matchingBrackets}})
   typeParameters: (<\s*{{typeParamersStart}}([^=<>]|=[^<]|\<\s*{{typeParamersStart}}([^=<>]|=[^<])*\>)*>\s*)
   # Identifier start | matching braces | matching parenthesis | matching square brackets | matching strings
   typeArgumentsStart: ({{typeParamersStart}}|(\'[^\']*\')|(\"[^\"]*\")|(\`[^\`]*\`))
-  typeArgumentsInnerExpressionPart: '[^<>\(]|{{matchingParenthesis}}'
-  typeArguments: (<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}}|\<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}})*\>)*>\s*)
+  typeArgumentsInnerExpressionPart: '[^<>\(]|{{matchingParenthesis}}|(?<==)\>'
+  typeArguments: (<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}}|\<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}})*(?!=)\>)*(?!=)>\s*)
   functionCallLookup: \s*(\?\.\s*)?{{typeArguments}}?\(
   arrowLookup: |-
     # sure shot arrow functions even if => is on new line
     (
       [(]\s*
       (
-        ([)]\s*:) |                                                                 # ():
-        ((\.\.\.\s*)?{{identifier}}\s*:)                                            # [(]param: | [(]...param:
+        ([)]\s*:) |                                                                                       # ():
+        ((\.\.\.\s*)?{{identifier}}\s*:)                                                                  # [(]param: | [(]...param:
       )
     ) |
     (
-      [<]\s*{{identifier}}\s+extends\s*[^=>]                                        # < typeparam extends
+      [<]\s*{{identifier}}\s+extends\s*[^=>]                                                              # < typeparam extends
     ) |
     # arrow function possible to detect only with => on same line
     (
-      {{typeParameters}}?                                                           # typeparameters
-      \(\s*([_$[:alpha:]\{\[]([^()]|\((\s*[^()]*)?\))*)?\)                          # parameteres
-      (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
-      \s*=>                                                                         # arrow operator
+      {{typeParameters}}?                                                                                 # typeparameters
+      \(\s*(([_$[:alpha:]]|{{matchingBraces}}|{{matchingBrackets}})([^()]|{{matchingParenthesis}})*)?\)   # parameters
+      (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                                      # return type
+      \s*=>                                                                                               # arrow operator
     )
   functionOrArrowLookup: |-
     \s*(
@@ -70,7 +82,8 @@ variables:
           ([)]\s*=>)
         ))
       ))
-    ))
+    )) |
+    (:\s*(=>|{{matchingParenthesis}}|(<[^<>]*>)|[^<>(),=])+={{functionOrArrowLookup}})
 
 patterns:
 - include: '#directives'
@@ -226,14 +239,14 @@ repository:
   destructuring-variable:
     patterns:
     - name: meta.object-binding-pattern-variable.ts
-      begin: (?<!=|:|of|in)\s*(?=\{)
+      begin: (?<!=|:|{{lookBehindOf}}|{{lookBehindIn}})\s*(?=\{)
       end: (?=$|^|[;,=}]|(\s+(of|in)\s+))
       patterns:
       - include: '#object-binding-pattern'
       - include: '#type-annotation'
       - include: '#comment'
     - name: meta.array-binding-pattern-variable.ts
-      begin: (?<!=|:|of|in)\s*(?=\[)
+      begin: (?<!=|:|{{lookBehindOf}}|{{lookBehindIn}})\s*(?=\[)
       end: (?=$|^|[;,=}]|(\s+(of|in)\s+))
       patterns:
       - include: '#array-binding-pattern'
@@ -886,13 +899,14 @@ repository:
     patterns:
     - include: '#comment'
     #(default|*|name) as alias
-    - match: '{{startOfIdentifier}}(?:(\bdefault)|(\*)|(\b{{identifier}}))\s+(as)\s+(\b{{identifier}})'
+    - match: '{{startOfIdentifier}}(?:(\bdefault)|(\*)|(\b{{identifier}}))\s+(as)\s+(?:(\bdefault{{endOfIdentifier}})|(\b{{identifier}}))'
       captures:
         '1': { name: keyword.control.default.ts }
         '2': { name: constant.language.import-export-all.ts }
         '3': { name: variable.other.readwrite.ts }
         '4': { name: keyword.control.as.ts }
-        '5': { name: variable.other.readwrite.alias.ts }
+        '5': { name: keyword.control.default.ts }
+        '6': { name: variable.other.readwrite.alias.ts }
     - include: '#punctuation-comma'
     - name: constant.language.import-export-all.ts
       match: \*
@@ -965,7 +979,7 @@ repository:
   #object literals
   after-operator-block-as-object-literal:
     name: meta.objectliteral.ts
-    begin: (?<=[=(,\[?+!]|await|return|yield|throw|in|of|typeof|&&|\|\||\*)\s*(\{)
+    begin: (?<=[=(,\[?+!]|{{lookBehindAwait}}|{{lookBehindReturn}}|{{lookBehindYield}}|{{lookBehindThrow}}|{{lookBehindIn}}|{{lookBehindOf}}|{{lookBehindTypeof}}|&&|\|\||\*)\s*(\{)
     beginCaptures:
       '1': { name: punctuation.definition.block.ts }
     end: \}
@@ -1088,7 +1102,7 @@ repository:
     begin: '{{startOfIdentifier}}(new){{endOfIdentifier}}'
     beginCaptures:
       '1': { name: keyword.operator.new.ts }
-    end: (?<=\))|(?=[;),}\]]|$|({{startOfIdentifier}}new{{endOfIdentifier}})|({{startOfIdentifier}}function((\s+{{identifier}})|(\s*[\(]))))
+    end: (?<=\))|(?=[;),}\]:]|$|({{startOfIdentifier}}new{{endOfIdentifier}})|({{startOfIdentifier}}function((\s+{{identifier}})|(\s*[\(]))))
     patterns:
     - include: '#paren-expression'
     - include: '#class-declaration'
@@ -1113,7 +1127,7 @@ repository:
       # If '<' is preceeded by 'return', 'throw', 'yield', or 'await', it's most likely a type assertion
       # If '=', '(', ',', ':', or '>' are followed by a '<', it is also likely a type assertion as otherwise it would be a syntax error
       # '<=' and '<<=' are cannot be type assertions, as they are assignment operators.
-      begin: (?:(?<=return|throw|yield|await|default|[=(,:>*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!<?\=)
+      begin: (?:(?<={{lookBehindReturn}}|{{lookBehindThrow}}|{{lookBehindYield}}|{{lookBehindAwait}}|{{lookBehindDefault}}|[=(,:>*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!<?\=)
       beginCaptures:
         '1': { name: meta.brace.angle.ts }
       end: (\>)\s*
@@ -1221,25 +1235,28 @@ repository:
     - include: '#expression'
     - include: '#punctuation-comma'
 
+  # With respect to seperators, we allow mroe than is syntacically valid below
+  # (multiple consecutive and trailing ones are errors), to be more graceful
+  # when the code contains errors
   numeric-literal:
     patterns:
     - name: constant.numeric.hex.ts
-      match: \b(?<!\$)0(x|X)[0-9a-fA-F]+\b(?!\$)
+      match: \b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$)
     - name: constant.numeric.binary.ts
-      match: \b(?<!\$)0(b|B)[01]+\b(?!\$)
+      match: \b(?<!\$)0(b|B)[01][01_]*\b(?!\$)
     - name: constant.numeric.octal.ts
-      match: \b(?<!\$)0(o|O)?[0-7]+\b(?!\$)
+      match: \b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$)
     - match: |-
         (?x)
         (?<!\$)(?:
-          (?:\b[0-9]+(\.)[0-9]+[eE][+-]?[0-9]+\b)| # 1.1E+3
-          (?:\b[0-9]+(\.)[eE][+-]?[0-9]+\b)|       # 1.E+3
-          (?:\B(\.)[0-9]+[eE][+-]?[0-9]+\b)|       # .1E+3
-          (?:\b[0-9]+[eE][+-]?[0-9]+\b)|           # 1E+3
-          (?:\b[0-9]+(\.)[0-9]+\b)|                # 1.1
-          (?:\b[0-9]+(\.)\B)|                      # 1.
-          (?:\B(\.)[0-9]+\b)|                      # .1
-          (?:\b[0-9]+\b(?!\.))                     # 1
+          (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3
+          (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)|             # 1.E+3
+          (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)|             # .1E+3
+          (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)|                 # 1E+3
+          (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)|                      # 1.1
+          (?:\b[0-9][0-9_]*(\.)\B)|                                  # 1.
+          (?:\B(\.)[0-9][0-9_]*\b)|                                  # .1
+          (?:\b[0-9][0-9_]*\b(?!\.))                                 # 1
         )(?!\$)
       captures:
         '0': {name: constant.numeric.decimal.ts}
@@ -1707,6 +1724,7 @@ repository:
     - include: '#type-parameters'
     - include: '#type-tuple'
     - include: '#type-object'
+    - include: '#type-conditional'
     - include: '#type-operators'
     - include: '#type-fn-type-parameters'
     - include: '#type-paren-or-function-parameters'
@@ -1758,6 +1776,13 @@ repository:
     - include: '#punctuation-semicolon'
     - include: '#type'
 
+  #conditional type
+  type-conditional:
+    match: '{{startOfIdentifier}}({{identifier}})\s+(extends)\s+'
+    captures:
+      '1': { name: entity.name.type.ts }
+      '2': { name: storage.modifier.ts }
+
   # Parenthesis can contain either types and function parameters
   # (number | string) or (param: number, param2: string)
   # and it can be nested, for example
@@ -1856,6 +1881,10 @@ repository:
       end: (?=\S)
     - name: keyword.operator.expression.keyof.ts
       match: '{{startOfIdentifier}}keyof{{endOfIdentifier}}'
+    - name: keyword.operator.ternary.ts
+      match: (\?|\:)
+    - name: keyword.operator.expression.infer.ts
+      match: '{{startOfIdentifier}}infer(?=\s+[_$[:alpha:]])'
 
   type-predicate-operator:
     name: keyword.operator.expression.is.ts
@@ -1951,7 +1980,7 @@ repository:
   regex:
     patterns:
     - name: string.regexp.ts
-      begin: (?<=[=(:,\[?+!]|return|case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/(?![\/*])[gimuy]*(?!\s*[a-zA-Z0-9_$]))
+      begin: (?<=[=(:,\[?+!]|{{lookBehindReturn}}|{{lookBehindCase}}|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/(?![\/*])[gimuy]*(?!\s*[a-zA-Z0-9_$]))
       beginCaptures:
         '1': {name: punctuation.definition.string.begin.ts}
       end: (/)([gimuy]*)

TypeScript.YAML-tmTheme

@@ -49,11 +49,11 @@ settings:
   settings: { vsclassificationtype: identifier }
 
 - scope: entity.name.tag
-  settings: { vsclassificationtype: xml literal - name }
+  settings: { vsclassificationtype: HTML Element Name }
 
 - scope: entity.other.attribute-name
-  settings: { vsclassificationtype: XML Attribute }
+  settings: { vsclassificationtype: HTML Attribute Name }
 
 - scope: meta.tag string.quoted, meta.tag string.quoted punctuation.definition.string, meta.tag string.quoted constant.character.escape
-  settings: { vsclassificationtype: xml literal - attribute value }
+  settings: { vsclassificationtype: HTML Attribute Value }
 ...