Regex Validated String Types

src/compiler/checker.ts

@@ -34,6 +34,37 @@ namespace ts {
             (preserveConstEnums && moduleState === ModuleInstanceState.ConstEnumOnly);
     }
 
+    /**
+     * A breakdown of the below regex:
+     * - ^ matches start of string
+     * - \/ matches opening slash
+     * - (.*) matches the contents of the regex
+     * - \/ matches the closing slash
+     * - ([im]*?)$ matches the flags at the end (non-greedy to ensure it goes from final slash), but only if they only consist of `m` and/or `i`
+     */
+    const regexpFlagExtractionRegExp = /^\/(.*)\/([im]*?)$/;
+    const noMatchesRegExp = /.^/; // Start of match after any character matches nothing
+
+    /* @internal */
+    export function getRegularExpressionForRegularExpressionValidatedType(t: RegularExpressionValidatedLiteralType) {
+        if (!t.regex) {
+            try {
+                const parts = regexpFlagExtractionRegExp.exec(t.value);
+                t.regex = parts ? new RegExp(parts[1], parts[2]) : noMatchesRegExp;
+            }
+            catch {
+                // RegExp pattern or flags unsupported by host; do not enable matching string literal types for this type
+                t.regex = noMatchesRegExp;
+            }
+        }
+        return t.regex;
+    }
+
+    /* @internal */
+    export function getRegularExpressionValidatedTypeIsExecutable(t: RegularExpressionValidatedLiteralType): boolean {
+        return getRegularExpressionForRegularExpressionValidatedType(t) !== noMatchesRegExp;
+    }
+
     export function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker {
         // Cancellation that controls whether or not we can cancel in the middle of type checking.
         // In general cancelling is *not* safe for the type checker.  We might be in the middle of
@@ -2594,6 +2625,14 @@ namespace ts {
                     }
                     return createThis();
                 }
+                if (!inTypeAlias && type.aliasSymbol && isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration)) {
+                    const name = symbolToTypeReferenceName(type.aliasSymbol);
+                    const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
+                    return createTypeReferenceNode(name, typeArgumentNodes);
+                }
+                if (type.flags & TypeFlags.RegularExpressionValidated) {
+                    return createLiteralTypeNode(createRegularExpressionLiteral((type as LiteralType).value as string));
+                }
 
                 const objectFlags = getObjectFlags(type);
 
@@ -2606,11 +2645,6 @@ namespace ts {
                     // Ignore constraint/default when creating a usage (as opposed to declaration) of a type parameter.
                     return createTypeReferenceNode(name, /*typeArguments*/ undefined);
                 }
-                if (!inTypeAlias && type.aliasSymbol && isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration)) {
-                    const name = symbolToTypeReferenceName(type.aliasSymbol);
-                    const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
-                    return createTypeReferenceNode(name, typeArgumentNodes);
-                }
                 if (type.flags & (TypeFlags.Union | TypeFlags.Intersection)) {
                     const types = type.flags & TypeFlags.Union ? formatUnionTypes((<UnionType>type).types) : (<IntersectionType>type).types;
                     const typeNodes = mapToTypeNodes(types, context);
@@ -3388,7 +3422,7 @@ namespace ts {
                         }
                         writeKeyword(writer, SyntaxKind.SymbolKeyword);
                     }
-                    else if (type.flags & TypeFlags.StringOrNumberLiteral) {
+                    else if (type.flags & (TypeFlags.StringOrNumberLiteral | TypeFlags.RegularExpressionValidated)) {
                         writer.writeStringLiteral(literalTypeToString(<LiteralType>type));
                     }
                     else if (type.flags & TypeFlags.Index) {
@@ -5301,6 +5335,9 @@ namespace ts {
                 let type = typeNode ? getTypeFromTypeNode(typeNode) : unknownType;
 
                 if (popTypeResolution()) {
+                    if (type.flags & TypeFlags.RegularExpressionValidated && !type.aliasSymbol) {
+                        type.aliasSymbol = symbol;
+                    }
                     const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
                     if (typeParameters) {
                         // Initialize the instantiation cache for generic type aliases. The declared type corresponds to
@@ -8483,6 +8520,15 @@ namespace ts {
             return type.flags & TypeFlags.StringOrNumberLiteral && type.flags & TypeFlags.FreshLiteral ? (<LiteralType>type).regularType : type;
         }
 
+        function getRegularExpressionType(value: string) {
+            const key = "/" + value;
+            let type = literalTypes.get(key);
+            if (!type) {
+                literalTypes.set(key, type = createLiteralType(TypeFlags.RegularExpressionValidated, value, /*symbol*/ undefined));
+            }
+            return type;
+        }
+
         function getLiteralType(value: string | number, enumId?: number, symbol?: Symbol) {
             // We store all literal types in a single map with keys of the form '#NNN' and '@SSS',
             // where NNN is the text representation of a numeric literal and SSS are the characters
@@ -8501,7 +8547,12 @@ namespace ts {
         function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal));
+                if (isRegularExpressionLiteral(node.literal)) {
+                    links.resolvedType = getRegularExpressionType(node.literal.text);
+                }
+                else {
+                    links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal));
+                }
             }
             return links.resolvedType;
         }
@@ -9320,6 +9371,7 @@ namespace ts {
             if (s & TypeFlags.StringLiteral && s & TypeFlags.EnumLiteral &&
                 t & TypeFlags.StringLiteral && !(t & TypeFlags.EnumLiteral) &&
                 (<LiteralType>source).value === (<LiteralType>target).value) return true;
+            if (s & TypeFlags.StringLiteral && t & TypeFlags.RegularExpressionValidated) return getRegularExpressionForRegularExpressionValidatedType(target as RegularExpressionValidatedLiteralType).test((source as StringLiteralType).value);
             if (s & TypeFlags.NumberLike && t & TypeFlags.Number) return true;
             if (s & TypeFlags.NumberLiteral && s & TypeFlags.EnumLiteral &&
                 t & TypeFlags.NumberLiteral && !(t & TypeFlags.EnumLiteral) &&
@@ -9337,6 +9389,7 @@ namespace ts {
             if (s & TypeFlags.Null && (!strictNullChecks || t & TypeFlags.Null)) return true;
             if (s & TypeFlags.Object && t & TypeFlags.NonPrimitive) return true;
             if (s & TypeFlags.UniqueESSymbol || t & TypeFlags.UniqueESSymbol) return false;
+            if (s & TypeFlags.RegularExpressionValidated && t & TypeFlags.RegularExpressionValidated) return false;
             if (relation === assignableRelation || relation === comparableRelation) {
                 if (s & TypeFlags.Any) return true;
                 // Type number or any numeric literal type is assignable to any numeric enum type or any
@@ -9439,6 +9492,9 @@ namespace ts {
                     else if (sourceType === targetType) {
                         message = Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated;
                     }
+                    else if (source.flags & TypeFlags.StringLiteral && target.flags & TypeFlags.RegularExpressionValidated && !getRegularExpressionValidatedTypeIsExecutable(target as RegularExpressionValidatedLiteralType)) {
+                        message = Diagnostics.Type_0_is_not_assignable_to_type_1_1_is_not_an_executable_regular_expression_so_a_cast_must_be_performed;
+                    }
                     else {
                         message = Diagnostics.Type_0_is_not_assignable_to_type_1;
                     }
@@ -19113,6 +19169,13 @@ namespace ts {
             return stringType;
         }
 
+        function checkRegularExpressionLiteral(node: RegularExpressionLiteral): Type {
+            if (length((<InterfaceType>globalRegExpType).typeParameters) !== 1) {
+                return globalRegExpType;
+            }
+            return createTypeFromGenericGlobalType(globalRegExpType as GenericType, [getRegularExpressionType(node.text)]);
+        }
+
         function checkExpressionWithContextualType(node: Expression, contextualType: Type, contextualMapper: TypeMapper | undefined): Type {
             const saveContextualType = node.contextualType;
             const saveContextualMapper = node.contextualMapper;
@@ -19178,7 +19241,7 @@ namespace ts {
                 }
                 // If the contextual type is a literal of a particular primitive type, we consider this a
                 // literal context for all literals of that primitive type.
-                return contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) ||
+                return contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index | TypeFlags.RegularExpressionValidated) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) ||
                     contextualType.flags & TypeFlags.NumberLiteral && maybeTypeOfKind(candidateType, TypeFlags.NumberLiteral) ||
                     contextualType.flags & TypeFlags.BooleanLiteral && maybeTypeOfKind(candidateType, TypeFlags.BooleanLiteral) ||
                     contextualType.flags & TypeFlags.UniqueESSymbol && maybeTypeOfKind(candidateType, TypeFlags.UniqueESSymbol);
@@ -19340,7 +19403,7 @@ namespace ts {
                 case SyntaxKind.TemplateExpression:
                     return checkTemplateExpression(<TemplateExpression>node);
                 case SyntaxKind.RegularExpressionLiteral:
-                    return globalRegExpType;
+                    return checkRegularExpressionLiteral(<RegularExpressionLiteral>node);
                 case SyntaxKind.ArrayLiteralExpression:
                     return checkArrayLiteral(<ArrayLiteralExpression>node, checkMode);
                 case SyntaxKind.ObjectLiteralExpression:
@@ -25362,7 +25425,11 @@ namespace ts {
             globalStringType = getGlobalType("String" as __String, /*arity*/ 0, /*reportErrors*/ true);
             globalNumberType = getGlobalType("Number" as __String, /*arity*/ 0, /*reportErrors*/ true);
             globalBooleanType = getGlobalType("Boolean" as __String, /*arity*/ 0, /*reportErrors*/ true);
-            globalRegExpType = getGlobalType("RegExp" as __String, /*arity*/ 0, /*reportErrors*/ true);
+            // RegExp is handled in a special manner below in order to allow it to be defined as 0-arity or 1-arity. 0-arity will disable a regex-validated guard on `.test`
+            const globalRegExpSymbol = getGlobalTypeSymbol("RegExp" as __String, /*reportErrors*/ true);
+            if (globalRegExpSymbol) {
+                globalRegExpType = getDeclaredTypeOfSymbol(globalRegExpSymbol) as ObjectType;
+            }
             anyArrayType = createArrayType(anyType);
 
             autoArrayType = createArrayType(autoType);

src/compiler/diagnosticMessages.json

@@ -2280,6 +2280,10 @@
         "category": "Error",
         "code": 2720
     },
+    "Type '{0}' is not assignable to type '{1}'. '{1}' is not an executable regular expression, so a cast must be performed.": {
+        "category": "Error",
+        "code": 2729
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -3898,5 +3902,13 @@
     "Install '{0}'": {
         "category": "Message",
         "code": 95014
+    },
+    "Add 'as'-style cast": {
+        "category": "Message",
+        "code": 95020
+    },
+    "Add '<>'-style cast": {
+        "category": "Message",
+        "code": 95021
     }
 }

src/compiler/factory.ts

@@ -107,6 +107,12 @@ namespace ts {
         return node;
     }
 
+    export function createRegularExpressionLiteral(text: string) {
+        const node = <RegularExpressionLiteral>createSynthesizedNode(SyntaxKind.RegularExpressionLiteral);
+        node.text = text;
+        return node;
+    }
+
 
     // Identifiers
 

src/compiler/parser.ts

@@ -2650,17 +2650,17 @@ namespace ts {
             return token() === SyntaxKind.DotToken ? undefined : node;
         }
 
-        function parseLiteralTypeNode(negative?: boolean): LiteralTypeNode {
+        function parseLiteralTypeNode(literalToken: SyntaxKind, negative?: boolean): LiteralTypeNode {
             const node = createNode(SyntaxKind.LiteralType) as LiteralTypeNode;
             let unaryMinusExpression: PrefixUnaryExpression;
             if (negative) {
                 unaryMinusExpression = createNode(SyntaxKind.PrefixUnaryExpression) as PrefixUnaryExpression;
                 unaryMinusExpression.operator = SyntaxKind.MinusToken;
                 nextToken();
             }
-            let expression: BooleanLiteral | LiteralExpression | PrefixUnaryExpression = token() === SyntaxKind.TrueKeyword || token() === SyntaxKind.FalseKeyword
+            let expression: BooleanLiteral | LiteralExpression | PrefixUnaryExpression = literalToken === SyntaxKind.TrueKeyword || literalToken === SyntaxKind.FalseKeyword
                 ? parseTokenNode<BooleanLiteral>()
-                : parseLiteralLikeNode(token()) as LiteralExpression;
+                : parseLiteralLikeNode(literalToken) as LiteralExpression;
             if (negative) {
                 unaryMinusExpression.operand = expression;
                 finishNode(unaryMinusExpression);
@@ -2699,9 +2699,18 @@ namespace ts {
                 case SyntaxKind.NumericLiteral:
                 case SyntaxKind.TrueKeyword:
                 case SyntaxKind.FalseKeyword:
-                    return parseLiteralTypeNode();
+                case SyntaxKind.RegularExpressionLiteral:
+                    return parseLiteralTypeNode(token());
+                case SyntaxKind.SlashEqualsToken:
+                case SyntaxKind.SlashToken:
+                    if (reScanSlashToken() === SyntaxKind.RegularExpressionLiteral) {
+                        return parseLiteralTypeNode(SyntaxKind.RegularExpressionLiteral);
+                    }
+                    else {
+                        return parseTypeReference();
+                    }
                 case SyntaxKind.MinusToken:
-                    return lookAhead(nextTokenIsNumericLiteral) ? parseLiteralTypeNode(/*negative*/ true) : parseTypeReference();
+                    return lookAhead(nextTokenIsNumericLiteral) ? parseLiteralTypeNode(SyntaxKind.NumericLiteral, /*negative*/ true) : parseTypeReference();
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.NullKeyword:
                     return parseTokenNode<TypeNode>();
@@ -2756,6 +2765,7 @@ namespace ts {
                 case SyntaxKind.QuestionToken:
                 case SyntaxKind.ExclamationToken:
                 case SyntaxKind.DotDotDotToken:
+                case SyntaxKind.SlashToken:
                     return true;
                 case SyntaxKind.MinusToken:
                     return !inStartOfParameter && lookAhead(nextTokenIsNumericLiteral);

src/compiler/transformers/ts.ts

@@ -1853,6 +1853,7 @@ namespace ts {
                 case SyntaxKind.LiteralType:
                     switch ((<LiteralTypeNode>node).literal.kind) {
                         case SyntaxKind.StringLiteral:
+                        case SyntaxKind.RegularExpressionLiteral:
                             return createIdentifier("String");
 
                         case SyntaxKind.NumericLiteral:

src/compiler/types.ts

@@ -3403,6 +3403,7 @@ namespace ts {
         /* @internal */
         JsxAttributes           = 1 << 26,  // Jsx attributes type
         MarkerType              = 1 << 27,  // Marker type used for variance probing
+        RegularExpressionValidated = 1 << 28,  // Type for strings matching a specific regular expression
 
         /* @internal */
         Nullable = Undefined | Null,
@@ -3418,7 +3419,7 @@ namespace ts {
         Intrinsic = Any | String | Number | Boolean | BooleanLiteral | ESSymbol | Void | Undefined | Null | Never | NonPrimitive,
         /* @internal */
         Primitive = String | Number | Boolean | Enum | EnumLiteral | ESSymbol | Void | Undefined | Null | Literal | UniqueESSymbol,
-        StringLike = String | StringLiteral | Index,
+        StringLike = String | StringLiteral | Index | RegularExpressionValidated,
         NumberLike = Number | NumberLiteral | Enum,
         BooleanLike = Boolean | BooleanLiteral,
         EnumLike = Enum | EnumLiteral,
@@ -3474,6 +3475,11 @@ namespace ts {
         value: string;
     }
 
+    export interface RegularExpressionValidatedLiteralType extends LiteralType {
+        value: string;
+        regex?: RegExp;
+    }
+
     export interface NumberLiteralType extends LiteralType {
         value: number;
     }

src/lib/es5.d.ts

@@ -808,7 +808,7 @@ interface RegExpExecArray extends Array<string> {
     input: string;
 }
 
-interface RegExp {
+interface RegExp<T extends string = string> {
     /**
       * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
       * @param string The String object or string literal on which to perform the search.
@@ -819,7 +819,7 @@ interface RegExp {
       * Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
       * @param string String on which to perform the search.
       */
-    test(string: string): boolean;
+    test(string: string): string is T;
 
     /** Returns a copy of the text of the regular expression pattern. Read-only. The regExp argument is a Regular expression object. It can be a variable name or a literal. */
     readonly source: string;