can parse private names (#1)

do a really rough, quick-and-dirty unblock-people job of letting #foo be parse-able.

steps to test:

npm run lint && npm test
See https://bbgithub.dev.bloomberg.com/javascript-guild/typescript-private-fields/ quick start guide for seeing the AST
CI testing coming soon

Author: Maxwell Heiber

src/compiler/parser.ts

@@ -1335,6 +1335,7 @@ namespace ts {
                 if (token() !== SyntaxKind.Identifier) {
                     node.originalKeywordKind = token();
                 }
+                node.isPrivateName = !!(scanner.getTokenFlags() & TokenFlags.PrivateName);
                 node.escapedText = escapeLeadingUnderscores(internIdentifier(scanner.getTokenValue()));
                 nextToken();
                 return finishNode(node);

src/compiler/scanner.ts

@@ -1723,6 +1723,21 @@ namespace ts {
                         error(Diagnostics.Invalid_character);
                         pos++;
                         return token = SyntaxKind.Unknown;
+                    case CharacterCodes.hash:
+                        pos++;
+                        if (isIdentifierStart(ch = text.charCodeAt(pos), languageVersion)) {
+                            tokenFlags |= TokenFlags.PrivateName;
+                            pos++;
+                            while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos), languageVersion)) pos++;
+                            tokenValue = text.substring(tokenPos, pos);
+                            if (ch === CharacterCodes.backslash) {
+                                tokenValue += scanIdentifierParts();
+                            }
+                            return token = SyntaxKind.Identifier;
+                        }
+                        error(Diagnostics.Invalid_character);
+                        pos++;
+                        return token = SyntaxKind.Unknown;
                     default:
                         if (isIdentifierStart(ch, languageVersion)) {
                             pos++;

src/compiler/types.ts

@@ -680,6 +680,7 @@ namespace ts {
          */
         escapedText: __String;
         originalKeywordKind?: SyntaxKind;                         // Original syntaxKind which get set so that we can report an error later
+        isPrivateName: boolean;                                   // is private name like `this.#foo`
         /*@internal*/ autoGenerateFlags?: GeneratedIdentifierFlags; // Specifies whether to auto-generate the text for an identifier.
         /*@internal*/ autoGenerateId?: number;                    // Ensures unique generated identifiers get unique names, but clones get the same name.
         isInJSDocNamespace?: boolean;                             // if the node is a member in a JSDoc namespace
@@ -1555,6 +1556,7 @@ namespace ts {
         BinarySpecifier = 1 << 7,   // e.g. `0b0110010000000000`
         OctalSpecifier = 1 << 8,    // e.g. `0o777`
         ContainsSeparator = 1 << 9, // e.g. `0b1100_0101`
+        PrivateName = 1 << 10,      // e.g. `#foo`
         BinaryOrOctalSpecifier = BinarySpecifier | OctalSpecifier,
         NumericLiteralFlags = Scientific | Octal | HexSpecifier | BinarySpecifier | OctalSpecifier | ContainsSeparator
     }

src/services/services.ts

@@ -347,6 +347,7 @@ namespace ts {
         public kind: SyntaxKind.Identifier;
         public escapedText: __String;
         public symbol: Symbol;
+        public isPrivateName: boolean;
         public autoGenerateFlags: GeneratedIdentifierFlags;
         _primaryExpressionBrand: any;
         _memberExpressionBrand: any;