From 7c073822eed4ff3818dfde460e3287fcae97a80d Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wewigham@microsoft.com>
Date: Tue, 12 Dec 2017 13:10:48 -0800
Subject: [PATCH 1/2] Implement regular expression validated types

---
 src/compiler/checker.ts                       | 64 +++++++++++-
 src/compiler/factory.ts                       |  6 ++
 src/compiler/parser.ts                        | 19 +++-
 src/compiler/transformers/ts.ts               |  1 +
 src/compiler/types.ts                         |  8 +-
 src/lib/es5.d.ts                              |  4 +-
 .../anyAssignabilityInInheritance.types       | 10 +-
 .../reference/anyAssignableToEveryType2.types |  2 +-
 .../reference/api/tsserverlibrary.d.ts        | 10 +-
 tests/baselines/reference/api/typescript.d.ts | 10 +-
 .../assignFromStringInterface2.types          | 40 ++++----
 ...signingFromObjectToAnythingElse.errors.txt |  4 +-
 .../assigningFromObjectToAnythingElse.types   |  6 +-
 .../reference/assignmentLHSIsValue.types      |  6 +-
 .../reference/assignmentTypeNarrowing.types   | 40 ++++----
 .../reference/augmentExportEquals5.types      |  4 +-
 .../baselines/reference/bestChoiceType.types  | 18 ++--
 .../reference/castExpressionParentheses.types |  2 +-
 .../reference/chainedAssignment2.types        |  6 +-
 .../reference/classExtendingBuiltinType.types |  2 +-
 .../commaOperatorLeftSideUnused.types         |  2 +-
 .../compoundAssignmentLHSIsValue.types        | 12 +--
 ...ndExponentiationAssignmentLHSIsValue.types |  6 +-
 ...DeclarationShadowedByVarDeclaration3.types |  6 +-
 .../reference/constructorOverloads5.types     |  8 +-
 ...structorWithIncompleteTypeAnnotation.types |  6 +-
 .../contextualTypingOfTooShortOverloads.types |  4 +-
 .../controlFlowDoWhileStatement.types         | 34 +++----
 .../reference/controlFlowForInStatement.types | 18 ++--
 .../reference/controlFlowForOfStatement.types | 10 +-
 .../reference/controlFlowForStatement.types   |  8 +-
 .../reference/controlFlowIfStatement.types    | 18 ++--
 .../controlFlowPropertyDeclarations.types     | 26 ++---
 .../reference/controlFlowWhileStatement.types | 34 +++----
 ...ernalModuleWithExportAssignedFundule.types |  6 +-
 .../reference/duplicateLocalVariable1.types   | 12 +--
 .../enumAssignabilityInInheritance.types      | 12 +--
 ...sNotASubtypeOfAnythingButNumber.errors.txt |  4 +-
 ...enumIsNotASubtypeOfAnythingButNumber.types |  2 +-
 .../reference/fixSignatureCaching.types       | 30 +++---
 .../reference/for-inStatements.types          |  2 +-
 .../reference/for-inStatementsInvalid.types   |  6 +-
 ...ricCallWithGenericSignatureArguments.types |  4 +-
 ...icCallWithGenericSignatureArguments2.types |  8 +-
 .../reference/ifDoWhileStatements.types       | 16 +--
 .../reference/invalidTypeOfTarget.types       |  2 +-
 .../reference/jsxAndTypeAssertion.types       |  6 +-
 .../reference/jsxParsingError1.types          |  2 +-
 tests/baselines/reference/literals.errors.txt |  8 +-
 tests/baselines/reference/literals.types      | 12 +--
 tests/baselines/reference/literals1.types     | 12 +--
 ...mUsingES6FeaturesWithOnlyES5Lib.errors.txt |  4 +-
 ...orFromUsingES6FeaturesWithOnlyES5Lib.types |  6 +-
 ...eLibrary_NoErrorDuplicateLibOptions1.types |  6 +-
 ...eLibrary_NoErrorDuplicateLibOptions2.types |  6 +-
 ...dularizeLibrary_TargetES5UsingES6Lib.types |  6 +-
 ...dularizeLibrary_TargetES6UsingES6Lib.types |  6 +-
 ...yInContextuallyTypesFunctionParamter.types |  4 +-
 ...ullIsSubtypeOfEverythingButUndefined.types | 12 +--
 .../numericIndexerConstraint.errors.txt       |  4 +-
 .../reference/numericIndexerConstraint.types  |  2 +-
 ...ctTypeWithStringNamedNumericProperty.types | 54 +++++-----
 .../reference/objectTypesIdentity2.types      | 36 +++----
 ...jectTypesIdentityWithCallSignatures2.types | 44 ++++-----
 ...ypesIdentityWithConstructSignatures2.types | 44 ++++-----
 ...CallSignaturesDifferingByConstraints.types | 42 ++++----
 ...allSignaturesDifferingByConstraints2.types | 42 ++++----
 ...cCallSignaturesDifferingByReturnType.types |  4 +-
 ...CallSignaturesDifferingByReturnType2.types |  4 +-
 ...gnaturesDifferingTypeParameterCounts.types | 20 ++--
 ...ructSignaturesDifferingByConstraints.types | 42 ++++----
 ...uctSignaturesDifferingByConstraints2.types | 42 ++++----
 ...tructSignaturesDifferingByReturnType.types |  2 +-
 ...ructSignaturesDifferingByReturnType2.types |  2 +-
 ...gnaturesDifferingTypeParameterCounts.types | 20 ++--
 .../overloadResolutionOverNonCTLambdas.types  |  6 +-
 .../reference/overloadResolutionWithAny.types | 14 +--
 ...seRegularExpressionMixedWithComments.types | 16 +--
 ...rser.numericSeparators.unicodeEscape.types | 24 ++---
 tests/baselines/reference/parser579071.types  |  4 +-
 tests/baselines/reference/parser596700.types  |  4 +-
 tests/baselines/reference/parser630933.types  |  6 +-
 .../baselines/reference/parser645086_1.types  |  6 +-
 .../baselines/reference/parser645086_2.types  |  6 +-
 .../baselines/reference/parser645086_3.types  |  4 +-
 .../baselines/reference/parser645086_4.types  |  4 +-
 tests/baselines/reference/parser768531.types  |  2 +-
 .../reference/parserIndexSignature8.types     |  4 +-
 .../reference/parserMissingToken2.types       |  2 +-
 .../reference/parserRealSource11.types        | 16 +--
 .../reference/parserRegularExpression1.types  |  2 +-
 .../reference/parserRegularExpression2.types  |  2 +-
 .../reference/parserRegularExpression3.types  |  2 +-
 .../reference/parserRegularExpression4.types  | 24 ++---
 .../reference/parserRegularExpression5.types  |  6 +-
 ...gularExpressionDivideAmbiguity3.errors.txt |  4 +-
 ...serRegularExpressionDivideAmbiguity3.types |  2 +-
 ...serRegularExpressionDivideAmbiguity4.types |  2 +-
 .../reference/parserSkippedTokens13.types     |  2 +-
 .../reference/parserSkippedTokens4.types      |  2 +-
 tests/baselines/reference/parserharness.types | 98 +++++++++----------
 .../reference/primitiveMembers.types          | 12 +--
 .../regExpWithSlashInCharClass.types          | 18 ++--
 .../reference/regexValidated.controlFlow.js   | 44 +++++++++
 .../regexValidated.controlFlow.symbols        | 74 ++++++++++++++
 .../regexValidated.controlFlow.types          | 94 ++++++++++++++++++
 .../regexValidated.stringLiterals.js          | 25 +++++
 ...lidated.stringLiterals.negative.errors.txt | 37 +++++++
 .../regexValidated.stringLiterals.negative.js | 25 +++++
 ...xValidated.stringLiterals.negative.symbols | 29 ++++++
 ...gexValidated.stringLiterals.negative.types | 41 ++++++++
 .../regexValidated.stringLiterals.symbols     | 29 ++++++
 .../regexValidated.stringLiterals.types       | 41 ++++++++
 ...regexValidated.unsupportedFlags.errors.txt | 10 ++
 .../regexValidated.unsupportedFlags.js        |  9 ++
 .../regexValidated.unsupportedFlags.symbols   |  7 ++
 .../regexValidated.unsupportedFlags.types     | 13 +++
 tests/baselines/reference/shebangError.types  |  2 +-
 .../stringLiteralTypeIsSubtypeOfString.types  | 10 +-
 tests/baselines/reference/subtypesOfAny.types |  4 +-
 .../reference/subtypesOfTypeParameter.types   | 12 +--
 ...typesOfTypeParameterWithConstraints2.types | 16 +--
 .../reference/subtypesOfUnion.errors.txt      |  8 +-
 .../baselines/reference/subtypesOfUnion.types |  8 +-
 .../reference/switchStatements.types          |  4 +-
 .../baselines/reference/throwStatements.types |  2 +-
 .../reference/tsxAttributeInvalidNames.types  |  2 +-
 .../typeGuardsNestedAssignments.types         |  6 +-
 .../reference/typeGuardsWithInstanceOf.types  |  2 +-
 .../reference/typeParameterConstraints1.types |  4 +-
 .../undefinedIsSubtypeOfEverything.types      |  4 +-
 .../baselines/reference/underscoreTest1.types | 22 ++---
 ...dedEscapesInRegularExpressions01_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions01_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions02_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions02_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions03_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions03_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions04_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions04_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions05_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions05_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions06_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions06_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions07_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions07_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions08_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions08_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions09_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions09_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions10_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions10_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions11_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions11_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions12_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions12_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions13_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions13_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions14_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions14_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions15_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions15_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions16_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions16_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions17_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions17_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions18_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions18_ES6.types |  4 +-
 ...dedEscapesInRegularExpressions19_ES5.types |  4 +-
 ...dedEscapesInRegularExpressions19_ES6.types |  4 +-
 ...IfEveryConstituentTypeIsSubtype.errors.txt |  8 +-
 ...btypeIfEveryConstituentTypeIsSubtype.types |  2 +-
 .../unterminatedRegexAtEndOfSource1.types     |  4 +-
 .../unusedIdentifiersConsolidated1.types      | 14 +--
 .../unusedVariablesinNamespaces1.types        |  4 +-
 .../unusedVariablesinNamespaces2.types        | 14 +--
 .../unusedVariablesinNamespaces3.types        | 14 +--
 tests/baselines/reference/validRegexp.types   | 12 +--
 .../regexValidated.controlFlow.ts             | 22 +++++
 .../regexValidated.stringLiterals.negative.ts | 15 +++
 .../regexValidated.stringLiterals.ts          | 15 +++
 .../regexValidated.unsupportedFlags.ts        |  3 +
 tests/cases/fourslash/indexerReturnTypes1.ts  |  8 +-
 tests/cases/fourslash/regexp.ts               |  2 +-
 184 files changed, 1423 insertions(+), 796 deletions(-)
 create mode 100644 tests/baselines/reference/regexValidated.controlFlow.js
 create mode 100644 tests/baselines/reference/regexValidated.controlFlow.symbols
 create mode 100644 tests/baselines/reference/regexValidated.controlFlow.types
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.js
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.negative.js
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.negative.symbols
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.negative.types
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.symbols
 create mode 100644 tests/baselines/reference/regexValidated.stringLiterals.types
 create mode 100644 tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt
 create mode 100644 tests/baselines/reference/regexValidated.unsupportedFlags.js
 create mode 100644 tests/baselines/reference/regexValidated.unsupportedFlags.symbols
 create mode 100644 tests/baselines/reference/regexValidated.unsupportedFlags.types
 create mode 100644 tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts
 create mode 100644 tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts
 create mode 100644 tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts
 create mode 100644 tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 10bbe62289610..98aaf4948f008 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -34,6 +34,16 @@ 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
+     * - (.*?)$ matches the flags at the end (non-greedy to ensure it goes from final slash)
+     */
+    const regexpFlagExtractionRegExp = /^\/(.*)\/(.*?)$/;
+    const noMatchesRegExp = /.^/; // Start of match after any character matches nothing
     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
@@ -2559,6 +2569,9 @@ namespace ts {
                 if (type.flags & (TypeFlags.StringLiteral)) {
                     return createLiteralTypeNode(setEmitFlags(createLiteral((<StringLiteralType>type).value), EmitFlags.NoAsciiEscaping));
                 }
+                if (type.flags & TypeFlags.RegularExpressionValidated) {
+                    return createLiteralTypeNode(createRegularExpressionLiteral((type as LiteralType).value as string));
+                }
                 if (type.flags & (TypeFlags.NumberLiteral)) {
                     return createLiteralTypeNode((createLiteral((<NumberLiteralType>type).value)));
                 }
@@ -3388,7 +3401,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) {
@@ -8483,6 +8496,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 +8523,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;
         }
@@ -9311,6 +9338,20 @@ namespace ts {
             return true;
         }
 
+        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;
+        }
+
         function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>, errorReporter?: ErrorReporter) {
             const s = source.flags;
             const t = target.flags;
@@ -9320,6 +9361,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 +9379,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
@@ -19113,6 +19156,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 +19228,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 +19390,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 +25412,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);
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index dfc22e3183374..8e4ad09376422 100644
--- a/src/compiler/factory.ts
+++ b/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
 
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index ce4115b08d439..33a286aa833a7 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -2650,7 +2650,7 @@ 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) {
@@ -2658,9 +2658,9 @@ namespace ts {
                 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>();
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 3c1bba280f0f9..1a4a9d3edbd37 100644
--- a/src/compiler/transformers/ts.ts
+++ b/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:
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index dfd6831be42f7..3180b7dd5e065 100644
--- a/src/compiler/types.ts
+++ b/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;
     }
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 0f1a68de4c20d..f6e9d722814f0 100644
--- a/src/lib/es5.d.ts
+++ b/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;
diff --git a/tests/baselines/reference/anyAssignabilityInInheritance.types b/tests/baselines/reference/anyAssignabilityInInheritance.types
index 925dd5d593e52..6c16b4afc49e5 100644
--- a/tests/baselines/reference/anyAssignabilityInInheritance.types
+++ b/tests/baselines/reference/anyAssignabilityInInheritance.types
@@ -73,13 +73,13 @@ var r3 = foo3(a); // any
 >a : any
 
 declare function foo6(x: RegExp): RegExp;
->foo6 : { (x: RegExp): RegExp; (x: any): any; }
->x : RegExp
->RegExp : RegExp
->RegExp : RegExp
+>foo6 : { (x: RegExp<string>): RegExp<string>; (x: any): any; }
+>x : RegExp<string>
+>RegExp : RegExp<T>
+>RegExp : RegExp<T>
 
 declare function foo6(x: any): any;
->foo6 : { (x: RegExp): RegExp; (x: any): any; }
+>foo6 : { (x: RegExp<string>): RegExp<string>; (x: any): any; }
 >x : any
 
 var r3 = foo3(a); // any
diff --git a/tests/baselines/reference/anyAssignableToEveryType2.types b/tests/baselines/reference/anyAssignableToEveryType2.types
index 564b634cde3d1..75da30fea868a 100644
--- a/tests/baselines/reference/anyAssignableToEveryType2.types
+++ b/tests/baselines/reference/anyAssignableToEveryType2.types
@@ -62,7 +62,7 @@ interface I6 {
 
     [x: string]: RegExp;
 >x : string
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     foo: any;
 >foo : any
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index ad34924a097f9..2fd779aaba5a2 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2014,11 +2014,12 @@ declare namespace ts {
         IndexedAccess = 1048576,
         NonPrimitive = 33554432,
         MarkerType = 134217728,
+        RegularExpressionValidated = 268435456,
         Literal = 224,
         Unit = 13536,
         StringOrNumberLiteral = 96,
         PossiblyFalsy = 14574,
-        StringLike = 524322,
+        StringLike = 268959778,
         NumberLike = 84,
         BooleanLike = 136,
         EnumLike = 272,
@@ -2027,7 +2028,7 @@ declare namespace ts {
         StructuredType = 458752,
         StructuredOrTypeVariable = 2064384,
         TypeVariable = 1081344,
-        Narrowable = 35620607,
+        Narrowable = 304056063,
         NotUnionOrUnit = 33620481,
     }
     type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -2049,6 +2050,10 @@ declare namespace ts {
     interface StringLiteralType extends LiteralType {
         value: string;
     }
+    interface RegularExpressionValidatedLiteralType extends LiteralType {
+        value: string;
+        regex?: RegExp;
+    }
     interface NumberLiteralType extends LiteralType {
         value: number;
     }
@@ -3289,6 +3294,7 @@ declare namespace ts {
     function createLiteral(value: boolean): BooleanLiteral;
     function createLiteral(value: string | number | boolean): PrimaryExpression;
     function createNumericLiteral(value: string): NumericLiteral;
+    function createRegularExpressionLiteral(text: string): RegularExpressionLiteral;
     function createIdentifier(text: string): Identifier;
     function updateIdentifier(node: Identifier, typeArguments: NodeArray<TypeNode> | undefined): Identifier;
     /** Create a unique temporary variable. */
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 4d06e48dc2565..65e7afcb0bc49 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -2014,11 +2014,12 @@ declare namespace ts {
         IndexedAccess = 1048576,
         NonPrimitive = 33554432,
         MarkerType = 134217728,
+        RegularExpressionValidated = 268435456,
         Literal = 224,
         Unit = 13536,
         StringOrNumberLiteral = 96,
         PossiblyFalsy = 14574,
-        StringLike = 524322,
+        StringLike = 268959778,
         NumberLike = 84,
         BooleanLike = 136,
         EnumLike = 272,
@@ -2027,7 +2028,7 @@ declare namespace ts {
         StructuredType = 458752,
         StructuredOrTypeVariable = 2064384,
         TypeVariable = 1081344,
-        Narrowable = 35620607,
+        Narrowable = 304056063,
         NotUnionOrUnit = 33620481,
     }
     type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -2049,6 +2050,10 @@ declare namespace ts {
     interface StringLiteralType extends LiteralType {
         value: string;
     }
+    interface RegularExpressionValidatedLiteralType extends LiteralType {
+        value: string;
+        regex?: RegExp;
+    }
     interface NumberLiteralType extends LiteralType {
         value: number;
     }
@@ -3236,6 +3241,7 @@ declare namespace ts {
     function createLiteral(value: boolean): BooleanLiteral;
     function createLiteral(value: string | number | boolean): PrimaryExpression;
     function createNumericLiteral(value: string): NumericLiteral;
+    function createRegularExpressionLiteral(text: string): RegularExpressionLiteral;
     function createIdentifier(text: string): Identifier;
     function updateIdentifier(node: Identifier, typeArguments: NodeArray<TypeNode> | undefined): Identifier;
     /** Create a unique temporary variable. */
diff --git a/tests/baselines/reference/assignFromStringInterface2.types b/tests/baselines/reference/assignFromStringInterface2.types
index 8ec212babcee8..1976e80c31801 100644
--- a/tests/baselines/reference/assignFromStringInterface2.types
+++ b/tests/baselines/reference/assignFromStringInterface2.types
@@ -42,48 +42,48 @@ interface NotString {
 >that : string
 
     match(regexp: string): string[];
->match : { (regexp: string): string[]; (regexp: RegExp): string[]; }
+>match : { (regexp: string): string[]; (regexp: RegExp<string>): string[]; }
 >regexp : string
 
     match(regexp: RegExp): string[];
->match : { (regexp: string): string[]; (regexp: RegExp): string[]; }
->regexp : RegExp
->RegExp : RegExp
+>match : { (regexp: string): string[]; (regexp: RegExp<string>): string[]; }
+>regexp : RegExp<string>
+>RegExp : RegExp<T>
 
     replace(searchValue: string, replaceValue: string): string;
->replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
+>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp<string>, replaceValue: string): string; (searchValue: RegExp<string>, replaceValue: (substring: string, ...args: any[]) => string): string; }
 >searchValue : string
 >replaceValue : string
 
     replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;
->replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
+>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp<string>, replaceValue: string): string; (searchValue: RegExp<string>, replaceValue: (substring: string, ...args: any[]) => string): string; }
 >searchValue : string
 >replaceValue : (substring: string, ...args: any[]) => string
 >substring : string
 >args : any[]
 
     replace(searchValue: RegExp, replaceValue: string): string;
->replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
->searchValue : RegExp
->RegExp : RegExp
+>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp<string>, replaceValue: string): string; (searchValue: RegExp<string>, replaceValue: (substring: string, ...args: any[]) => string): string; }
+>searchValue : RegExp<string>
+>RegExp : RegExp<T>
 >replaceValue : string
 
     replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
->replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
->searchValue : RegExp
->RegExp : RegExp
+>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp<string>, replaceValue: string): string; (searchValue: RegExp<string>, replaceValue: (substring: string, ...args: any[]) => string): string; }
+>searchValue : RegExp<string>
+>RegExp : RegExp<T>
 >replaceValue : (substring: string, ...args: any[]) => string
 >substring : string
 >args : any[]
 
     search(regexp: string): number;
->search : { (regexp: string): number; (regexp: RegExp): number; }
+>search : { (regexp: string): number; (regexp: RegExp<string>): number; }
 >regexp : string
 
     search(regexp: RegExp): number;
->search : { (regexp: string): number; (regexp: RegExp): number; }
->regexp : RegExp
->RegExp : RegExp
+>search : { (regexp: string): number; (regexp: RegExp<string>): number; }
+>regexp : RegExp<string>
+>RegExp : RegExp<T>
 
     slice(start?: number, end?: number): string;
 >slice : (start?: number, end?: number) => string
@@ -91,14 +91,14 @@ interface NotString {
 >end : number
 
     split(separator: string, limit?: number): string[];
->split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
+>split : { (separator: string, limit?: number): string[]; (separator: RegExp<string>, limit?: number): string[]; }
 >separator : string
 >limit : number
 
     split(separator: RegExp, limit?: number): string[];
->split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
->separator : RegExp
->RegExp : RegExp
+>split : { (separator: string, limit?: number): string[]; (separator: RegExp<string>, limit?: number): string[]; }
+>separator : RegExp<string>
+>RegExp : RegExp<T>
 >limit : number
 
     substring(start: number, end?: number): string;
diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt b/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt
index c8fb57e36160b..ced98b6b31396 100644
--- a/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt
+++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/assigningFromObjectToAnythingElse.ts(3,1): error TS2322: Type 'Object' is not assignable to type 'RegExp'.
+tests/cases/compiler/assigningFromObjectToAnythingElse.ts(3,1): error TS2322: Type 'Object' is not assignable to type 'RegExp<string>'.
   The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
     Property 'exec' is missing in type 'Object'.
 tests/cases/compiler/assigningFromObjectToAnythingElse.ts(5,17): error TS2558: Expected 0 type arguments, but got 1.
@@ -13,7 +13,7 @@ tests/cases/compiler/assigningFromObjectToAnythingElse.ts(8,5): error TS2322: Ty
     var y: RegExp;
     y = x;
     ~
-!!! error TS2322: Type 'Object' is not assignable to type 'RegExp'.
+!!! error TS2322: Type 'Object' is not assignable to type 'RegExp<string>'.
 !!! error TS2322:   The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
 !!! error TS2322:     Property 'exec' is missing in type 'Object'.
     
diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.types b/tests/baselines/reference/assigningFromObjectToAnythingElse.types
index 2b31b0c7673d9..5f2ab134eaba3 100644
--- a/tests/baselines/reference/assigningFromObjectToAnythingElse.types
+++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.types
@@ -4,12 +4,12 @@ var x: Object;
 >Object : Object
 
 var y: RegExp;
->y : RegExp
->RegExp : RegExp
+>y : RegExp<string>
+>RegExp : RegExp<T>
 
 y = x;
 >y = x : Object
->y : RegExp
+>y : RegExp<string>
 >x : Object
 
 var a: String = Object.create<Object>("");
diff --git a/tests/baselines/reference/assignmentLHSIsValue.types b/tests/baselines/reference/assignmentLHSIsValue.types
index b35c15bfe2365..df37c758750f4 100644
--- a/tests/baselines/reference/assignmentLHSIsValue.types
+++ b/tests/baselines/reference/assignmentLHSIsValue.types
@@ -92,7 +92,7 @@ false = value;
 
 /d+/ = value;
 >/d+/ = value : any
->/d+/ : RegExp
+>/d+/ : RegExp</d+/>
 >value : any
 
 // object literals
@@ -213,8 +213,8 @@ foo() = value;
 
 (/d+/) = value;
 >(/d+/) = value : any
->(/d+/) : RegExp
->/d+/ : RegExp
+>(/d+/) : RegExp</d+/>
+>/d+/ : RegExp</d+/>
 >value : any
 
 ({}) = value;
diff --git a/tests/baselines/reference/assignmentTypeNarrowing.types b/tests/baselines/reference/assignmentTypeNarrowing.types
index 5b43771f086a7..92fbfe05c74fe 100644
--- a/tests/baselines/reference/assignmentTypeNarrowing.types
+++ b/tests/baselines/reference/assignmentTypeNarrowing.types
@@ -1,11 +1,11 @@
 === tests/cases/conformance/expressions/assignmentOperator/assignmentTypeNarrowing.ts ===
 let x: string | number | boolean | RegExp;
->x : string | number | boolean | RegExp
->RegExp : RegExp
+>x : string | number | boolean | RegExp<string>
+>RegExp : RegExp<T>
 
 x = "";
 >x = "" : ""
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >"" : ""
 
 x; // string
@@ -13,8 +13,8 @@ x; // string
 
 [x] = [true];
 >[x] = [true] : [boolean]
->[x] : [string | number | boolean | RegExp]
->x : string | number | boolean | RegExp
+>[x] : [string | number | boolean | RegExp<string>]
+>x : string | number | boolean | RegExp<string>
 >[true] : [boolean]
 >true : true
 
@@ -25,7 +25,7 @@ x; // boolean
 >[x = ""] = [1] : [number]
 >[x = ""] : [string]
 >x = "" : ""
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >"" : ""
 >[1] : [number]
 >1 : 1
@@ -36,8 +36,8 @@ x; // string | number
 ({x} = {x: true});
 >({x} = {x: true}) : { x: boolean; }
 >{x} = {x: true} : { x: boolean; }
->{x} : { x: string | number | boolean | RegExp; }
->x : string | number | boolean | RegExp
+>{x} : { x: string | number | boolean | RegExp<string>; }
+>x : string | number | boolean | RegExp<string>
 >{x: true} : { x: boolean; }
 >x : boolean
 >true : true
@@ -48,9 +48,9 @@ x; // boolean
 ({y: x} = {y: 1});
 >({y: x} = {y: 1}) : { y: number; }
 >{y: x} = {y: 1} : { y: number; }
->{y: x} : { y: string | number | boolean | RegExp; }
->y : string | number | boolean | RegExp
->x : string | number | boolean | RegExp
+>{y: x} : { y: string | number | boolean | RegExp<string>; }
+>y : string | number | boolean | RegExp<string>
+>x : string | number | boolean | RegExp<string>
 >{y: 1} : { y: number; }
 >y : number
 >1 : 1
@@ -61,8 +61,8 @@ x; // number
 ({x = ""} = {x: true});
 >({x = ""} = {x: true}) : { x?: boolean; }
 >{x = ""} = {x: true} : { x?: boolean; }
->{x = ""} : { x?: string | number | boolean | RegExp; }
->x : string | number | boolean | RegExp
+>{x = ""} : { x?: string | number | boolean | RegExp<string>; }
+>x : string | number | boolean | RegExp<string>
 >{x: true} : { x?: boolean; }
 >x : boolean
 >true : true
@@ -73,23 +73,23 @@ x; // string | boolean
 ({y: x = /a/} = {y: 1});
 >({y: x = /a/} = {y: 1}) : { y?: number; }
 >{y: x = /a/} = {y: 1} : { y?: number; }
->{y: x = /a/} : { y?: RegExp; }
->y : RegExp
->x = /a/ : RegExp
->x : string | number | boolean | RegExp
->/a/ : RegExp
+>{y: x = /a/} : { y?: RegExp</a/>; }
+>y : RegExp</a/>
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | RegExp<string>
+>/a/ : RegExp</a/>
 >{y: 1} : { y?: number; }
 >y : number
 >1 : 1
 
 x; // number | RegExp
->x : number | RegExp
+>x : number | RegExp<string>
 
 let a: string[];
 >a : string[]
 
 for (x of a) {
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >a : string[]
 
     x; // string
diff --git a/tests/baselines/reference/augmentExportEquals5.types b/tests/baselines/reference/augmentExportEquals5.types
index c0444d35358fc..ac63429b809a9 100644
--- a/tests/baselines/reference/augmentExportEquals5.types
+++ b/tests/baselines/reference/augmentExportEquals5.types
@@ -36,8 +36,8 @@ declare module "express" {
 >T : T
 
             (name: string|RegExp, ...handlers: RequestHandler[]): T;
->name : string | RegExp
->RegExp : RegExp
+>name : string | RegExp<string>
+>RegExp : RegExp<T>
 >handlers : RequestHandler[]
 >RequestHandler : RequestHandler
 >T : T
diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types
index 49997d1e273cc..474632b015aa9 100644
--- a/tests/baselines/reference/bestChoiceType.types
+++ b/tests/baselines/reference/bestChoiceType.types
@@ -7,10 +7,10 @@
 >(''.match(/ /) || []) : RegExpMatchArray
 >''.match(/ /) || [] : RegExpMatchArray
 >''.match(/ /) : RegExpMatchArray | null
->''.match : (regexp: string | RegExp) => RegExpMatchArray | null
+>''.match : (regexp: string | RegExp<string>) => RegExpMatchArray | null
 >'' : ""
->match : (regexp: string | RegExp) => RegExpMatchArray | null
->/ / : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray | null
+>/ / : RegExp</ />
 >[] : never[]
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s => s.toLowerCase() : (s: string) => string
@@ -28,10 +28,10 @@ function f1() {
     let x = ''.match(/ /);
 >x : RegExpMatchArray | null
 >''.match(/ /) : RegExpMatchArray | null
->''.match : (regexp: string | RegExp) => RegExpMatchArray | null
+>''.match : (regexp: string | RegExp<string>) => RegExpMatchArray | null
 >'' : ""
->match : (regexp: string | RegExp) => RegExpMatchArray | null
->/ / : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray | null
+>/ / : RegExp</ />
 
     let y = x || [];
 >y : RegExpMatchArray
@@ -59,10 +59,10 @@ function f2() {
     let x = ''.match(/ /);
 >x : RegExpMatchArray | null
 >''.match(/ /) : RegExpMatchArray | null
->''.match : (regexp: string | RegExp) => RegExpMatchArray | null
+>''.match : (regexp: string | RegExp<string>) => RegExpMatchArray | null
 >'' : ""
->match : (regexp: string | RegExp) => RegExpMatchArray | null
->/ / : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray | null
+>/ / : RegExp</ />
 
     let y = x ? x : [];
 >y : RegExpMatchArray
diff --git a/tests/baselines/reference/castExpressionParentheses.types b/tests/baselines/reference/castExpressionParentheses.types
index 5971b55f10339..2d137d4ef67e6 100644
--- a/tests/baselines/reference/castExpressionParentheses.types
+++ b/tests/baselines/reference/castExpressionParentheses.types
@@ -56,7 +56,7 @@ declare var a;
 (<any>/regexp/g); 
 >(<any>/regexp/g) : any
 ><any>/regexp/g : any
->/regexp/g : RegExp
+>/regexp/g : RegExp</regexp/g>
 
 (<any>false); 
 >(<any>false) : any
diff --git a/tests/baselines/reference/chainedAssignment2.types b/tests/baselines/reference/chainedAssignment2.types
index c53c64143d9d4..ecbfbd91630f9 100644
--- a/tests/baselines/reference/chainedAssignment2.types
+++ b/tests/baselines/reference/chainedAssignment2.types
@@ -13,8 +13,8 @@ var d: Date;
 >Date : Date
 
 var e: RegExp;
->e : RegExp
->RegExp : RegExp
+>e : RegExp<string>
+>RegExp : RegExp<T>
 
 a = b = c = d = e = null;
 >a = b = c = d = e = null : null
@@ -26,7 +26,7 @@ a = b = c = d = e = null;
 >d = e = null : null
 >d : Date
 >e = null : null
->e : RegExp
+>e : RegExp<string>
 >null : null
 
 
diff --git a/tests/baselines/reference/classExtendingBuiltinType.types b/tests/baselines/reference/classExtendingBuiltinType.types
index b50137e58d6f9..32c6dae2b4bb4 100644
--- a/tests/baselines/reference/classExtendingBuiltinType.types
+++ b/tests/baselines/reference/classExtendingBuiltinType.types
@@ -25,7 +25,7 @@ class C6 extends Date { }
 
 class C7 extends RegExp { }
 >C7 : C7
->RegExp : RegExp
+>RegExp : RegExp<string>
 
 class C8 extends Error { }
 >C8 : C8
diff --git a/tests/baselines/reference/commaOperatorLeftSideUnused.types b/tests/baselines/reference/commaOperatorLeftSideUnused.types
index ccfac66e734b0..1303e92aa941e 100644
--- a/tests/baselines/reference/commaOperatorLeftSideUnused.types
+++ b/tests/baselines/reference/commaOperatorLeftSideUnused.types
@@ -85,7 +85,7 @@ xx = (/323/, 5);
 >xx : any
 >(/323/, 5) : 5
 >/323/, 5 : 5
->/323/ : RegExp
+>/323/ : RegExp</323/>
 >5 : 5
 
 xx = (`wat`, 'ok'),
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.types b/tests/baselines/reference/compoundAssignmentLHSIsValue.types
index 7736256f97356..cc1d106dc68a7 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.types
+++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.types
@@ -171,12 +171,12 @@ false += value;
 
 /d+/ *= value;
 >/d+/ *= value : number
->/d+/ : RegExp
+>/d+/ : RegExp</d+/>
 >value : any
 
 /d+/ += value;
 >/d+/ += value : any
->/d+/ : RegExp
+>/d+/ : RegExp</d+/>
 >value : any
 
 // object literals
@@ -408,14 +408,14 @@ foo() += value;
 
 (/d+/) *= value;
 >(/d+/) *= value : number
->(/d+/) : RegExp
->/d+/ : RegExp
+>(/d+/) : RegExp</d+/>
+>/d+/ : RegExp</d+/>
 >value : any
 
 (/d+/) += value;
 >(/d+/) += value : any
->(/d+/) : RegExp
->/d+/ : RegExp
+>(/d+/) : RegExp</d+/>
+>/d+/ : RegExp</d+/>
 >value : any
 
 ({}) *= value;
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.types b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.types
index 982b6b2bdee9e..df172e63f39dc 100644
--- a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.types
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.types
@@ -101,7 +101,7 @@ false **= value;
 
 /d+/ **= value;
 >/d+/ **= value : number
->/d+/ : RegExp
+>/d+/ : RegExp</d+/>
 >value : any
 
 // object literals
@@ -232,8 +232,8 @@ foo() **= value;
 
 (/d+/) **= value;
 >(/d+/) **= value : number
->(/d+/) : RegExp
->/d+/ : RegExp
+>(/d+/) : RegExp</d+/>
+>/d+/ : RegExp</d+/>
 >value : any
 
 ({}) **= value;
diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types
index 919a9eb96f229..5327f5a51ccc7 100644
--- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types
+++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types
@@ -4,9 +4,9 @@ class Rule {
 >Rule : Rule
 
     public regex: RegExp = new RegExp('');
->regex : RegExp
->RegExp : RegExp
->new RegExp('') : RegExp
+>regex : RegExp<string>
+>RegExp : RegExp<T>
+>new RegExp('') : RegExp<string>
 >RegExp : RegExpConstructor
 >'' : ""
 
diff --git a/tests/baselines/reference/constructorOverloads5.types b/tests/baselines/reference/constructorOverloads5.types
index 4ba9293bda16f..1336680a62906 100644
--- a/tests/baselines/reference/constructorOverloads5.types
+++ b/tests/baselines/reference/constructorOverloads5.types
@@ -6,15 +6,15 @@
 >M : typeof M
 
     export function RegExp(pattern: string): RegExp;
->RegExp : { (pattern: string): RegExp; (pattern: string, flags: string): RegExp; }
+>RegExp : { (pattern: string): RegExp<string>; (pattern: string, flags: string): RegExp<string>; }
 >pattern : string
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     export function RegExp(pattern: string, flags: string): RegExp;
->RegExp : { (pattern: string): RegExp; (pattern: string, flags: string): RegExp; }
+>RegExp : { (pattern: string): RegExp<string>; (pattern: string, flags: string): RegExp<string>; }
 >pattern : string
 >flags : string
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     export class RegExp {
 >RegExp : M.RegExp
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types
index d1b7c98087feb..a80135c16b04b 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types
@@ -243,8 +243,8 @@ module TypeScriptAllInOne {
 >"'" : "'"
 
             var reg = /\w*/;
->reg : RegExp
->/\w*/ : RegExp
+>reg : RegExp</\w*/>
+>/\w*/ : RegExp</\w*/>
 
             var objLit = { "var": number = 42, equals: function (x) { return x["var"] === 42; },  instanceof : () => 'objLit{42}' };
 >objLit : { "var": number; equals: (x: any) => boolean; instanceof: () => string; }
@@ -292,7 +292,7 @@ module TypeScriptAllInOne {
 >toString : (radix?: number) => string
 >reg.toString() : string
 >reg.toString : () => string
->reg : RegExp
+>reg : RegExp</\w*/>
 >toString : () => string
 >objLit : { "var": number; equals: (x: any) => boolean; instanceof: () => string; }
 >weekday : Weekdays.Monday
diff --git a/tests/baselines/reference/contextualTypingOfTooShortOverloads.types b/tests/baselines/reference/contextualTypingOfTooShortOverloads.types
index 769bd55d4b57b..262861603516f 100644
--- a/tests/baselines/reference/contextualTypingOfTooShortOverloads.types
+++ b/tests/baselines/reference/contextualTypingOfTooShortOverloads.types
@@ -85,8 +85,8 @@ interface IRouterMatcher<T> {
 
 type PathParams = string | RegExp | (string | RegExp)[];
 >PathParams : PathParams
->RegExp : RegExp
->RegExp : RegExp
+>RegExp : RegExp<T>
+>RegExp : RegExp<T>
 
 type RequestHandlerParams = RequestHandler | ErrorRequestHandler | (RequestHandler | ErrorRequestHandler)[];
 >RequestHandlerParams : RequestHandlerParams
diff --git a/tests/baselines/reference/controlFlowDoWhileStatement.types b/tests/baselines/reference/controlFlowDoWhileStatement.types
index baa585bc14d5e..1d1c7f66eb9e6 100644
--- a/tests/baselines/reference/controlFlowDoWhileStatement.types
+++ b/tests/baselines/reference/controlFlowDoWhileStatement.types
@@ -131,13 +131,13 @@ function f() {
 >f : () => void
 
     let x: string | number | boolean | RegExp | Function;
->x : string | number | boolean | Function | RegExp
->RegExp : RegExp
+>x : string | number | boolean | Function | RegExp<string>
+>RegExp : RegExp<T>
 >Function : Function
 
     x = "";
 >x = "" : ""
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >"" : ""
 
     do {
@@ -146,7 +146,7 @@ function f() {
 
             x = 42;
 >x = 42 : 42
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >42 : 42
 
             break;
@@ -156,33 +156,33 @@ function f() {
 
             x = true;
 >x = true : true
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >true : true
 
             continue;
         }
         x = /a/;
->x = /a/ : RegExp
->x : string | number | boolean | Function | RegExp
->/a/ : RegExp
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | Function | RegExp<string>
+>/a/ : RegExp</a/>
 
     } while (cond)
 >cond : boolean
 
     x; // number | boolean | RegExp
->x : number | true | RegExp
+>x : number | true | RegExp<string>
 }
 function g() {
 >g : () => void
 
     let x: string | number | boolean | RegExp | Function;
->x : string | number | boolean | Function | RegExp
->RegExp : RegExp
+>x : string | number | boolean | Function | RegExp<string>
+>RegExp : RegExp<T>
 >Function : Function
 
     x = "";
 >x = "" : ""
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >"" : ""
 
     do {
@@ -191,7 +191,7 @@ function g() {
 
             x = 42;
 >x = 42 : 42
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >42 : 42
 
             break;
@@ -201,15 +201,15 @@ function g() {
 
             x = true;
 >x = true : true
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >true : true
 
             continue;
         }
         x = /a/;
->x = /a/ : RegExp
->x : string | number | boolean | Function | RegExp
->/a/ : RegExp
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | Function | RegExp<string>
+>/a/ : RegExp</a/>
 
     } while (true)
 >true : true
diff --git a/tests/baselines/reference/controlFlowForInStatement.types b/tests/baselines/reference/controlFlowForInStatement.types
index e3a4407bff36d..05c02e70acb51 100644
--- a/tests/baselines/reference/controlFlowForInStatement.types
+++ b/tests/baselines/reference/controlFlowForInStatement.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/controlFlow/controlFlowForInStatement.ts ===
 let x: string | number | boolean | RegExp | Function;
->x : string | number | boolean | Function | RegExp
->RegExp : RegExp
+>x : string | number | boolean | Function | RegExp<string>
+>RegExp : RegExp<T>
 >Function : Function
 
 let obj: any;
@@ -11,9 +11,9 @@ let cond: boolean;
 >cond : boolean
 
 x = /a/;
->x = /a/ : RegExp
->x : string | number | boolean | Function | RegExp
->/a/ : RegExp
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | Function | RegExp<string>
+>/a/ : RegExp</a/>
 
 for (let y in obj) {
 >y : string
@@ -21,7 +21,7 @@ for (let y in obj) {
 
     x = y;
 >x = y : string
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >y : string
 
     if (cond) {
@@ -29,7 +29,7 @@ for (let y in obj) {
 
         x = 42;
 >x = 42 : 42
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >42 : 42
 
         continue;
@@ -39,12 +39,12 @@ for (let y in obj) {
 
         x = true;
 >x = true : true
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >true : true
 
         break;
     }
 }
 x; // RegExp | string | number | boolean
->x : string | number | true | RegExp
+>x : string | number | true | RegExp<string>
 
diff --git a/tests/baselines/reference/controlFlowForOfStatement.types b/tests/baselines/reference/controlFlowForOfStatement.types
index 91e0d0a57588a..72776a1bdea6b 100644
--- a/tests/baselines/reference/controlFlowForOfStatement.types
+++ b/tests/baselines/reference/controlFlowForOfStatement.types
@@ -3,24 +3,24 @@ let obj: number[];
 >obj : number[]
 
 let x: string | number | boolean | RegExp;
->x : string | number | boolean | RegExp
->RegExp : RegExp
+>x : string | number | boolean | RegExp<string>
+>RegExp : RegExp<T>
 
 function a() {
 >a : () => void
 
     x = true;
 >x = true : true
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >true : true
 
     for (x of obj) {
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >obj : number[]
 
         x = x.toExponential();
 >x = x.toExponential() : string
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >x.toExponential() : string
 >x.toExponential : (fractionDigits?: number) => string
 >x : number
diff --git a/tests/baselines/reference/controlFlowForStatement.types b/tests/baselines/reference/controlFlowForStatement.types
index f82a018573bcc..11de2a4929788 100644
--- a/tests/baselines/reference/controlFlowForStatement.types
+++ b/tests/baselines/reference/controlFlowForStatement.types
@@ -97,12 +97,12 @@ function e() {
 >e : () => void
 
     let x: string | number | boolean | RegExp;
->x : string | number | boolean | RegExp
->RegExp : RegExp
+>x : string | number | boolean | RegExp<string>
+>RegExp : RegExp<T>
 
     for (x = "" || 0; typeof x !== "string"; x = "" || true) {
 >x = "" || 0 : 0
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >"" || 0 : 0
 >"" : ""
 >0 : 0
@@ -111,7 +111,7 @@ function e() {
 >x : number | true
 >"string" : "string"
 >x = "" || true : true
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >"" || true : true
 >"" : ""
 >true : true
diff --git a/tests/baselines/reference/controlFlowIfStatement.types b/tests/baselines/reference/controlFlowIfStatement.types
index 7c745735c9efd..180d88fa0a43c 100644
--- a/tests/baselines/reference/controlFlowIfStatement.types
+++ b/tests/baselines/reference/controlFlowIfStatement.types
@@ -1,22 +1,22 @@
 === tests/cases/conformance/controlFlow/controlFlowIfStatement.ts ===
 let x: string | number | boolean | RegExp;
->x : string | number | boolean | RegExp
->RegExp : RegExp
+>x : string | number | boolean | RegExp<string>
+>RegExp : RegExp<T>
 
 let cond: boolean;
 >cond : boolean
 
 x = /a/;
->x = /a/ : RegExp
->x : string | number | boolean | RegExp
->/a/ : RegExp
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | RegExp<string>
+>/a/ : RegExp</a/>
 
 if (x /* RegExp */, (x = true)) {
 >x /* RegExp */, (x = true) : true
->x : RegExp
+>x : RegExp<string>
 >(x = true) : true
 >x = true : true
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >true : true
 
     x; // boolean
@@ -24,7 +24,7 @@ if (x /* RegExp */, (x = true)) {
 
     x = "";
 >x = "" : ""
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >"" : ""
 }
 else {
@@ -33,7 +33,7 @@ else {
 
     x = 42;
 >x = 42 : 42
->x : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp<string>
 >42 : 42
 }
 x; // string | number
diff --git a/tests/baselines/reference/controlFlowPropertyDeclarations.types b/tests/baselines/reference/controlFlowPropertyDeclarations.types
index 286124ca346ae..4dad3be753a65 100644
--- a/tests/baselines/reference/controlFlowPropertyDeclarations.types
+++ b/tests/baselines/reference/controlFlowPropertyDeclarations.types
@@ -178,7 +178,7 @@ function hyphenToCamelCase(string) {
 >string.replace : any
 >string : any
 >replace : any
->/-(.)/g : RegExp
+>/-(.)/g : RegExp</-(.)/g>
 >function(match, chr) {    return chr.toUpperCase();  } : (match: any, chr: any) => any
 >match : any
 >chr : any
@@ -202,9 +202,9 @@ function isEmpty(string) {
    return !/[^\s]/.test(string);
 >!/[^\s]/.test(string) : boolean
 >/[^\s]/.test(string) : boolean
->/[^\s]/.test : (string: string) => boolean
->/[^\s]/ : RegExp
->test : (string: string) => boolean
+>/[^\s]/.test : (string: string) => string is /[^\s]/
+>/[^\s]/ : RegExp</[^\s]/>
+>test : (string: string) => string is /[^\s]/
 >string : any
 }
 
@@ -221,9 +221,9 @@ function isConvertiblePixelValue(value) {
 
   return /^\d+px$/.test(value);
 >/^\d+px$/.test(value) : boolean
->/^\d+px$/.test : (string: string) => boolean
->/^\d+px$/ : RegExp
->test : (string: string) => boolean
+>/^\d+px$/.test : (string: string) => string is /^\d+px$/
+>/^\d+px$/ : RegExp</^\d+px$/>
+>test : (string: string) => string is /^\d+px$/
 >value : any
 }
 
@@ -295,19 +295,19 @@ export class HTMLtoJSX {
 >text = text        .replace(/\r/g, '')        .replace(/( {2,}|\n|\t|\{|\})/g, function(whitespace) {          return '{' + JSON.stringify(whitespace) + '}';        }) : string
 >text : string
 >text        .replace(/\r/g, '')        .replace(/( {2,}|\n|\t|\{|\})/g, function(whitespace) {          return '{' + JSON.stringify(whitespace) + '}';        }) : string
->text        .replace(/\r/g, '')        .replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>text        .replace(/\r/g, '')        .replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >text        .replace(/\r/g, '') : string
->text        .replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>text        .replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >text : string
 
         .replace(/\r/g, '')
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/\r/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/\r/g : RegExp</\r/g>
 >'' : ""
 
         .replace(/( {2,}|\n|\t|\{|\})/g, function(whitespace) {
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/( {2,}|\n|\t|\{|\})/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/( {2,}|\n|\t|\{|\})/g : RegExp</( {2,}|\n|\t|\{|\})/g>
 >function(whitespace) {          return '{' + JSON.stringify(whitespace) + '}';        } : (whitespace: string) => string
 >whitespace : string
 
diff --git a/tests/baselines/reference/controlFlowWhileStatement.types b/tests/baselines/reference/controlFlowWhileStatement.types
index 4576e1a4f62a3..df0a23a9855a6 100644
--- a/tests/baselines/reference/controlFlowWhileStatement.types
+++ b/tests/baselines/reference/controlFlowWhileStatement.types
@@ -135,13 +135,13 @@ function f() {
 >f : () => void
 
     let x: string | number | boolean | RegExp | Function;
->x : string | number | boolean | Function | RegExp
->RegExp : RegExp
+>x : string | number | boolean | Function | RegExp<string>
+>RegExp : RegExp<T>
 >Function : Function
 
     x = "";
 >x = "" : ""
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >"" : ""
 
     while (cond) {
@@ -152,7 +152,7 @@ function f() {
 
             x = 42;
 >x = 42 : 42
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >42 : 42
 
             break;
@@ -162,30 +162,30 @@ function f() {
 
             x = true;
 >x = true : true
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >true : true
 
             continue;
         }
         x = /a/;
->x = /a/ : RegExp
->x : string | number | boolean | Function | RegExp
->/a/ : RegExp
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | Function | RegExp<string>
+>/a/ : RegExp</a/>
     }
     x; // string | number | boolean | RegExp
->x : string | number | true | RegExp
+>x : string | number | true | RegExp<string>
 }
 function g() {
 >g : () => void
 
     let x: string | number | boolean | RegExp | Function;
->x : string | number | boolean | Function | RegExp
->RegExp : RegExp
+>x : string | number | boolean | Function | RegExp<string>
+>RegExp : RegExp<T>
 >Function : Function
 
     x = "";
 >x = "" : ""
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >"" : ""
 
     while (true) {
@@ -196,7 +196,7 @@ function g() {
 
             x = 42;
 >x = 42 : 42
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >42 : 42
 
             break;
@@ -206,15 +206,15 @@ function g() {
 
             x = true;
 >x = true : true
->x : string | number | boolean | Function | RegExp
+>x : string | number | boolean | Function | RegExp<string>
 >true : true
 
             continue;
         }
         x = /a/;
->x = /a/ : RegExp
->x : string | number | boolean | Function | RegExp
->/a/ : RegExp
+>x = /a/ : RegExp</a/>
+>x : string | number | boolean | Function | RegExp<string>
+>/a/ : RegExp</a/>
     }
     x; // number
 >x : number
diff --git a/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.types b/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.types
index 2206c8044484e..8d020b1ad4c1e 100644
--- a/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.types
+++ b/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.types
@@ -21,9 +21,9 @@ declare module "express" {
 >ExpressServer : ExpressServer
 
             post(path: RegExp, handler: (req: Function) => void ): void;
->post : (path: RegExp, handler: (req: Function) => void) => void
->path : RegExp
->RegExp : RegExp
+>post : (path: RegExp<string>, handler: (req: Function) => void) => void
+>path : RegExp<string>
+>RegExp : RegExp<T>
 >handler : (req: Function) => void
 >req : Function
 >Function : Function
diff --git a/tests/baselines/reference/duplicateLocalVariable1.types b/tests/baselines/reference/duplicateLocalVariable1.types
index e9c475aef696e..5b86dd129ff9b 100644
--- a/tests/baselines/reference/duplicateLocalVariable1.types
+++ b/tests/baselines/reference/duplicateLocalVariable1.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/duplicateLocalVariable1.ts ===
 / /@module: commonjs
->/ / : RegExp
+>/ / : RegExp</ />
 >module : any
 >commonjs : any
 
@@ -148,8 +148,8 @@ export class TestRunner {
 >message : any
 
                         var regex = new RegExp(testcase.errorMessageRegEx);
->regex : RegExp
->new RegExp(testcase.errorMessageRegEx) : RegExp
+>regex : RegExp<string>
+>new RegExp(testcase.errorMessageRegEx) : RegExp<string>
 >RegExp : RegExpConstructor
 >testcase.errorMessageRegEx : string
 >testcase : TestCase
@@ -159,9 +159,9 @@ export class TestRunner {
 >testResult = regex.test(e.message) : boolean
 >testResult : boolean
 >regex.test(e.message) : boolean
->regex.test : (string: string) => boolean
->regex : RegExp
->test : (string: string) => boolean
+>regex.test : (string: string) => string is string
+>regex : RegExp<string>
+>test : (string: string) => string is string
 >e.message : any
 >e : any
 >message : any
diff --git a/tests/baselines/reference/enumAssignabilityInInheritance.types b/tests/baselines/reference/enumAssignabilityInInheritance.types
index 6720a0f9ed957..2ed642fdf23d1 100644
--- a/tests/baselines/reference/enumAssignabilityInInheritance.types
+++ b/tests/baselines/reference/enumAssignabilityInInheritance.types
@@ -111,13 +111,13 @@ var r4 = foo4(E.A);
 >A : E
 
 declare function foo5(x: RegExp): RegExp;
->foo5 : { (x: RegExp): RegExp; (x: E): E; }
->x : RegExp
->RegExp : RegExp
->RegExp : RegExp
+>foo5 : { (x: RegExp<string>): RegExp<string>; (x: E): E; }
+>x : RegExp<string>
+>RegExp : RegExp<T>
+>RegExp : RegExp<T>
 
 declare function foo5(x: E): E;
->foo5 : { (x: RegExp): RegExp; (x: E): E; }
+>foo5 : { (x: RegExp<string>): RegExp<string>; (x: E): E; }
 >x : E
 >E : E
 >E : E
@@ -125,7 +125,7 @@ declare function foo5(x: E): E;
 var r4 = foo5(E.A);
 >r4 : E
 >foo5(E.A) : E
->foo5 : { (x: RegExp): RegExp; (x: E): E; }
+>foo5 : { (x: RegExp<string>): RegExp<string>; (x: E): E; }
 >E.A : E
 >E : typeof E
 >A : E
diff --git a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.errors.txt b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.errors.txt
index 1f8def801cccb..aee9c3266b675 100644
--- a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.errors.txt
+++ b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(18,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'string'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(24,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'boolean'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(30,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'Date'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(36,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'RegExp'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(36,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'RegExp<string>'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(42,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type '{ bar: number; }'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(48,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'number[]'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts(54,5): error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'I8'.
@@ -60,7 +60,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotA
         [x: string]: RegExp;
         foo: E;
         ~~~~~~~
-!!! error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'RegExp'.
+!!! error TS2411: Property 'foo' of type 'E' is not assignable to string index type 'RegExp<string>'.
     }
     
     
diff --git a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.types b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.types
index 12e57e2d50193..82be657f483e2 100644
--- a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.types
+++ b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.types
@@ -71,7 +71,7 @@ interface I6 {
 
     [x: string]: RegExp;
 >x : string
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     foo: E;
 >foo : E
diff --git a/tests/baselines/reference/fixSignatureCaching.types b/tests/baselines/reference/fixSignatureCaching.types
index 60502cae58395..45ea229a7aadc 100644
--- a/tests/baselines/reference/fixSignatureCaching.types
+++ b/tests/baselines/reference/fixSignatureCaching.types
@@ -813,23 +813,23 @@ define(function () {
 
     // following patterns come from http://detectmobilebrowsers.com/
     impl.detectMobileBrowsers = {
->impl.detectMobileBrowsers = {        fullPattern: /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i,        shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i,        tabletPattern: /android|ipad|playbook|silk/i    } : { fullPattern: RegExp; shortPattern: RegExp; tabletPattern: RegExp; }
+>impl.detectMobileBrowsers = {        fullPattern: /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i,        shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i,        tabletPattern: /android|ipad|playbook|silk/i    } : { fullPattern: RegExp</(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i>; shortPattern: RegExp</1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i>; tabletPattern: RegExp</android|ipad|playbook|silk/i>; }
 >impl.detectMobileBrowsers : any
 >impl : {}
 >detectMobileBrowsers : any
->{        fullPattern: /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i,        shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i,        tabletPattern: /android|ipad|playbook|silk/i    } : { fullPattern: RegExp; shortPattern: RegExp; tabletPattern: RegExp; }
+>{        fullPattern: /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i,        shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i,        tabletPattern: /android|ipad|playbook|silk/i    } : { fullPattern: RegExp</(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i>; shortPattern: RegExp</1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i>; tabletPattern: RegExp</android|ipad|playbook|silk/i>; }
 
         fullPattern: /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i,
->fullPattern : RegExp
->/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i : RegExp
+>fullPattern : RegExp</(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i>
+>/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i : RegExp</(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i>
 
         shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i,
->shortPattern : RegExp
->/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i : RegExp
+>shortPattern : RegExp</1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i>
+>/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i : RegExp</1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i>
 
         tabletPattern: /android|ipad|playbook|silk/i
->tabletPattern : RegExp
->/android|ipad|playbook|silk/i : RegExp
+>tabletPattern : RegExp</android|ipad|playbook|silk/i>
+>/android|ipad|playbook|silk/i : RegExp</android|ipad|playbook|silk/i>
 
     };
 
@@ -1021,11 +1021,11 @@ define(function () {
 >key : string
 
                 object[key] = new RegExp(object[key], 'i');
->object[key] = new RegExp(object[key], 'i') : RegExp
+>object[key] = new RegExp(object[key], 'i') : RegExp<string>
 >object[key] : any
 >object : any
 >key : string
->new RegExp(object[key], 'i') : RegExp
+>new RegExp(object[key], 'i') : RegExp<string>
 >RegExp : RegExpConstructor
 >object[key] : any
 >object : any
@@ -1149,11 +1149,11 @@ define(function () {
 >5 : 5
                     }
                     values[i] = new RegExp(value, 'i');
->values[i] = new RegExp(value, 'i') : RegExp
+>values[i] = new RegExp(value, 'i') : RegExp<string>
 >values[i] : any
 >values : any
 >i : any
->new RegExp(value, 'i') : RegExp
+>new RegExp(value, 'i') : RegExp<string>
 >RegExp : RegExpConstructor
 >value : any
 >'i' : "i"
@@ -1485,7 +1485,7 @@ define(function () {
 >version.split : any
 >version : any
 >split : any
->/[a-z._ \/\-]/i : RegExp
+>/[a-z._ \/\-]/i : RegExp</[a-z._ \/\-]/i>
 
         if (numbers.length === 1) {
 >numbers.length === 1 : boolean
@@ -3097,9 +3097,9 @@ define(function () {
 >RegExp : RegExpConstructor
 
                 pattern = new RegExp(pattern, 'i');
->pattern = new RegExp(pattern, 'i') : RegExp
+>pattern = new RegExp(pattern, 'i') : RegExp<string>
 >pattern : any
->new RegExp(pattern, 'i') : RegExp
+>new RegExp(pattern, 'i') : RegExp<string>
 >RegExp : RegExpConstructor
 >pattern : any
 >'i' : "i"
diff --git a/tests/baselines/reference/for-inStatements.types b/tests/baselines/reference/for-inStatements.types
index 97ebc291e8a51..a6d3316e6b05d 100644
--- a/tests/baselines/reference/for-inStatements.types
+++ b/tests/baselines/reference/for-inStatements.types
@@ -40,7 +40,7 @@ for (var x in fn()) { }
 
 for (var x in /[a-z]/) { }
 >x : string
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
 for (var x in new Date()) { }
 >x : string
diff --git a/tests/baselines/reference/for-inStatementsInvalid.types b/tests/baselines/reference/for-inStatementsInvalid.types
index f991c47a3a424..5112c1bbac328 100644
--- a/tests/baselines/reference/for-inStatementsInvalid.types
+++ b/tests/baselines/reference/for-inStatementsInvalid.types
@@ -14,11 +14,11 @@ for (aBoolean in {}) { }
 >{} : {}
 
 var aRegExp: RegExp;
->aRegExp : RegExp
->RegExp : RegExp
+>aRegExp : RegExp<string>
+>RegExp : RegExp<T>
 
 for (aRegExp in {}) { }
->aRegExp : RegExp
+>aRegExp : RegExp<string>
 >{} : {}
 
 for (var idx : number in {}) { }
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments.types b/tests/baselines/reference/genericCallWithGenericSignatureArguments.types
index a9301c526c043..87e43f5e5cb4b 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments.types
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments.types
@@ -204,9 +204,9 @@ function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
 }
 
 function other3<T extends RegExp>(x: T) {
->other3 : <T extends RegExp>(x: T) => void
+>other3 : <T extends RegExp<string>>(x: T) => void
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.types b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.types
index d1ccc28b5071a..b29d28f0bd5f8 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.types
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.types
@@ -98,9 +98,9 @@ module onlyT {
     }
 
     function other3<T extends RegExp>(x: T) {
->other3 : <T extends RegExp>(x: T) => void
+>other3 : <T extends RegExp<string>>(x: T) => void
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 
@@ -278,9 +278,9 @@ module TU {
     }
 
     function other3<T extends RegExp>(x: T) {
->other3 : <T extends RegExp>(x: T) => void
+>other3 : <T extends RegExp<string>>(x: T) => void
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 
diff --git a/tests/baselines/reference/ifDoWhileStatements.types b/tests/baselines/reference/ifDoWhileStatements.types
index 801b4d35f2f7f..4564e1b526c15 100644
--- a/tests/baselines/reference/ifDoWhileStatements.types
+++ b/tests/baselines/reference/ifDoWhileStatements.types
@@ -151,13 +151,13 @@ do { }while('')
 >'' : ""
 
 if (/[a-z]/) { }
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
 while (/[a-z]/) { }
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
 do { }while(/[a-z]/)
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
 if ([]) { }
 >[] : undefined[]
@@ -332,17 +332,17 @@ do { }while(f)
 >f : string
 
 var g = /[a-z]/
->g : RegExp
->/[a-z]/ : RegExp
+>g : RegExp</[a-z]/>
+>/[a-z]/ : RegExp</[a-z]/>
 
 if (g) { }
->g : RegExp
+>g : RegExp</[a-z]/>
 
 while (g) { }
->g : RegExp
+>g : RegExp</[a-z]/>
 
 do { }while(g)
->g : RegExp
+>g : RegExp</[a-z]/>
 
 var h = [];
 >h : any[]
diff --git a/tests/baselines/reference/invalidTypeOfTarget.types b/tests/baselines/reference/invalidTypeOfTarget.types
index 554e6959ec23e..3e1bf161f0149 100644
--- a/tests/baselines/reference/invalidTypeOfTarget.types
+++ b/tests/baselines/reference/invalidTypeOfTarget.types
@@ -36,5 +36,5 @@ var x7: typeof function f() { };
 var x8: typeof /123/;
 >x8 : any
 > : any
->/123/ : RegExp
+>/123/ : RegExp</123/>
 
diff --git a/tests/baselines/reference/jsxAndTypeAssertion.types b/tests/baselines/reference/jsxAndTypeAssertion.types
index b9ba2f93f13a7..ab0a5eb9586da 100644
--- a/tests/baselines/reference/jsxAndTypeAssertion.types
+++ b/tests/baselines/reference/jsxAndTypeAssertion.types
@@ -66,9 +66,9 @@ x = <foo>x</foo>, x = <foo/>;
 >foo : typeof foo
 >/foo/.test(x) ? <foo><foo></foo> : <foo><foo></foo>}</foo>}</foo> : any
 >/foo/.test(x) : boolean
->/foo/.test : (string: string) => boolean
->/foo/ : RegExp
->test : (string: string) => boolean
+>/foo/.test : (string: string) => string is /foo/
+>/foo/ : RegExp</foo/>
+>test : (string: string) => string is /foo/
 >x : any
 ><foo><foo></foo> : <foo><foo></foo>}</foo>}</foo> : any
 >foo : typeof foo
diff --git a/tests/baselines/reference/jsxParsingError1.types b/tests/baselines/reference/jsxParsingError1.types
index 5047237043d4a..97e378745fb2b 100644
--- a/tests/baselines/reference/jsxParsingError1.types
+++ b/tests/baselines/reference/jsxParsingError1.types
@@ -29,5 +29,5 @@ const elem = <div className={class1, class2}/>;
 >className : string
 >class1 : "foo"
 >class2 : true
->/>; : RegExp
+>/>; : RegExp</>;>
 
diff --git a/tests/baselines/reference/literals.errors.txt b/tests/baselines/reference/literals.errors.txt
index 426e832c62227..6f9fc0563df78 100644
--- a/tests/baselines/reference/literals.errors.txt
+++ b/tests/baselines/reference/literals.errors.txt
@@ -4,9 +4,11 @@ tests/cases/conformance/expressions/literals/literals.ts(9,9): error TS2532: Obj
 tests/cases/conformance/expressions/literals/literals.ts(9,21): error TS2532: Object is possibly 'undefined'.
 tests/cases/conformance/expressions/literals/literals.ts(19,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o1'.
 tests/cases/conformance/expressions/literals/literals.ts(24,9): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o3'.
+tests/cases/conformance/expressions/literals/literals.ts(36,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'r' must be of type 'RegExp<string>', but here has type 'RegExp</what/>'.
+tests/cases/conformance/expressions/literals/literals.ts(37,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'r' must be of type 'RegExp<string>', but here has type 'RegExp</\\\\/>'.
 
 
-==== tests/cases/conformance/expressions/literals/literals.ts (6 errors) ====
+==== tests/cases/conformance/expressions/literals/literals.ts (8 errors) ====
     //typeof null is Null
     //typeof true is Boolean
     //typeof false is Boolean
@@ -55,5 +57,9 @@ tests/cases/conformance/expressions/literals/literals.ts(24,9): error TS1085: Oc
     
     var r: RegExp;
     var r = /what/;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'r' must be of type 'RegExp<string>', but here has type 'RegExp</what/>'.
     var r = /\\\\/;
+        ~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'r' must be of type 'RegExp<string>', but here has type 'RegExp</\\\\/>'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/literals.types b/tests/baselines/reference/literals.types
index a54c1dc9fe409..9cf900873f4a0 100644
--- a/tests/baselines/reference/literals.types
+++ b/tests/baselines/reference/literals.types
@@ -100,14 +100,14 @@ var s = "foo\
     bar";
 
 var r: RegExp;
->r : RegExp
->RegExp : RegExp
+>r : RegExp<string>
+>RegExp : RegExp<T>
 
 var r = /what/;
->r : RegExp
->/what/ : RegExp
+>r : RegExp<string>
+>/what/ : RegExp</what/>
 
 var r = /\\\\/;
->r : RegExp
->/\\\\/ : RegExp
+>r : RegExp<string>
+>/\\\\/ : RegExp</\\\\/>
 
diff --git a/tests/baselines/reference/literals1.types b/tests/baselines/reference/literals1.types
index 5b1a5c9cd6810..08223622a2958 100644
--- a/tests/baselines/reference/literals1.types
+++ b/tests/baselines/reference/literals1.types
@@ -44,14 +44,14 @@ var k = 'q\tq';
 >'q\tq' : "q\tq"
 
 var m = /q/;
->m : RegExp
->/q/ : RegExp
+>m : RegExp</q/>
+>/q/ : RegExp</q/>
 
 var n = /\d+/g;
->n : RegExp
->/\d+/g : RegExp
+>n : RegExp</\d+/g>
+>/\d+/g : RegExp</\d+/g>
 
 var o = /[3-5]+/i;
->o : RegExp
->/[3-5]+/i : RegExp
+>o : RegExp</[3-5]+/i>
+>/[3-5]+/i : RegExp</[3-5]+/i>
 
diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt
index b56b03de533f4..2821cb3857fbd 100644
--- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt
+++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt
@@ -6,7 +6,7 @@ tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.t
 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(29,18): error TS2304: Cannot find name 'Symbol'.
 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(33,13): error TS2304: Cannot find name 'Proxy'.
 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(36,1): error TS2304: Cannot find name 'Reflect'.
-tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(40,5): error TS2339: Property 'flags' does not exist on type 'RegExp'.
+tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(40,5): error TS2339: Property 'flags' does not exist on type 'RegExp<string>'.
 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(44,5): error TS2339: Property 'includes' does not exist on type 'string'.
 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(47,9): error TS2304: Cannot find name 'Symbol'.
 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(51,6): error TS2304: Cannot find name 'Symbol'.
@@ -70,7 +70,7 @@ tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.t
     var reg = new RegExp("/s");
     reg.flags;
         ~~~~~
-!!! error TS2339: Property 'flags' does not exist on type 'RegExp'.
+!!! error TS2339: Property 'flags' does not exist on type 'RegExp<string>'.
     
     // Using ES6 string
     var str = "Hello world";
diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.types b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.types
index b3f6a156a755a..3b8bfddd877b2 100644
--- a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.types
@@ -108,14 +108,14 @@ Reflect.isExtensible({});
 
 // Using Es6 regexp
 var reg = new RegExp("/s");
->reg : RegExp
->new RegExp("/s") : RegExp
+>reg : RegExp<string>
+>new RegExp("/s") : RegExp<string>
 >RegExp : RegExpConstructor
 >"/s" : "/s"
 
 reg.flags;
 >reg.flags : any
->reg : RegExp
+>reg : RegExp<string>
 >flags : any
 
 // Using ES6 string
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index 20d0779621c07..6847c185005c8 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -184,14 +184,14 @@ Reflect.isExtensible({});
 
 // Using Es6 regexp
 var reg = new RegExp("/s");
->reg : RegExp
->new RegExp("/s") : RegExp
+>reg : RegExp<string>
+>new RegExp("/s") : RegExp<string>
 >RegExp : RegExpConstructor
 >"/s" : "/s"
 
 reg.flags;
 >reg.flags : string
->reg : RegExp
+>reg : RegExp<string>
 >flags : string
 
 // Using ES6 string
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index 367ac41f246f2..0003b8c23adf9 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -184,14 +184,14 @@ Reflect.isExtensible({});
 
 // Using Es6 regexp
 var reg = new RegExp("/s");
->reg : RegExp
->new RegExp("/s") : RegExp
+>reg : RegExp<string>
+>new RegExp("/s") : RegExp<string>
 >RegExp : RegExpConstructor
 >"/s" : "/s"
 
 reg.flags;
 >reg.flags : string
->reg : RegExp
+>reg : RegExp<string>
 >flags : string
 
 // Using ES6 string
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 8dc959b1afefe..aa648804eaeab 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -184,14 +184,14 @@ Reflect.isExtensible({});
 
 // Using Es6 regexp
 var reg = new RegExp("/s");
->reg : RegExp
->new RegExp("/s") : RegExp
+>reg : RegExp<string>
+>new RegExp("/s") : RegExp<string>
 >RegExp : RegExpConstructor
 >"/s" : "/s"
 
 reg.flags;
 >reg.flags : string
->reg : RegExp
+>reg : RegExp<string>
 >flags : string
 
 // Using ES6 string
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
index 2f1fab30cf79d..50b3b6b0f073a 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
@@ -107,14 +107,14 @@ Reflect.isExtensible({});
 
 // Using Es6 regexp
 var reg = new RegExp("/s");
->reg : RegExp
->new RegExp("/s") : RegExp
+>reg : RegExp<string>
+>new RegExp("/s") : RegExp<string>
 >RegExp : RegExpConstructor
 >"/s" : "/s"
 
 reg.flags;
 >reg.flags : string
->reg : RegExp
+>reg : RegExp<string>
 >flags : string
 
 // Using ES6 string
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
index 93b9020c78c46..2e45c7bf90646 100644
--- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
+++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.types
@@ -13,9 +13,9 @@ regexMatchList.forEach(match => ''.replace(match, ''));
 >match => ''.replace(match, '') : (match: string) => string
 >match : string
 >''.replace(match, '') : string
->''.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>''.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >'' : ""
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >match : string
 >'' : ""
 
diff --git a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.types b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.types
index a65baab444270..376817e54b9d1 100644
--- a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.types
+++ b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.types
@@ -92,18 +92,18 @@ var r4 = true ? null : new Date();
 >Date : DateConstructor
 
 var r5 = true ? /1/ : null;
->r5 : RegExp
->true ? /1/ : null : RegExp
+>r5 : RegExp</1/>
+>true ? /1/ : null : RegExp</1/>
 >true : true
->/1/ : RegExp
+>/1/ : RegExp</1/>
 >null : null
 
 var r5 = true ? null : /1/;
->r5 : RegExp
->true ? null : /1/ : RegExp
+>r5 : RegExp</1/>
+>true ? null : /1/ : RegExp</1/>
 >true : true
 >null : null
->/1/ : RegExp
+>/1/ : RegExp</1/>
 
 var r6 = true ? { foo: 1 } : null;
 >r6 : { foo: number; }
diff --git a/tests/baselines/reference/numericIndexerConstraint.errors.txt b/tests/baselines/reference/numericIndexerConstraint.errors.txt
index af24643310a07..f0384cb96e1c2 100644
--- a/tests/baselines/reference/numericIndexerConstraint.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstraint.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/numericIndexerConstraint.ts(2,5): error TS2412: Property '0' of type 'number' is not assignable to numeric index type 'RegExp'.
+tests/cases/compiler/numericIndexerConstraint.ts(2,5): error TS2412: Property '0' of type 'number' is not assignable to numeric index type 'RegExp<string>'.
 
 
 ==== tests/cases/compiler/numericIndexerConstraint.ts (1 errors) ====
     class C {
         0: number;
         ~~~~~~~~~~
-!!! error TS2412: Property '0' of type 'number' is not assignable to numeric index type 'RegExp'.
+!!! error TS2412: Property '0' of type 'number' is not assignable to numeric index type 'RegExp<string>'.
         [x: number]: RegExp;
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/numericIndexerConstraint.types b/tests/baselines/reference/numericIndexerConstraint.types
index a1d11ae641653..b24da827aad47 100644
--- a/tests/baselines/reference/numericIndexerConstraint.types
+++ b/tests/baselines/reference/numericIndexerConstraint.types
@@ -5,5 +5,5 @@ class C {
     0: number;
     [x: number]: RegExp;
 >x : number
->RegExp : RegExp
+>RegExp : RegExp<T>
 }
diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types
index 98081e6ab6cfb..bd977410bfd68 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types
+++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.types
@@ -17,7 +17,7 @@ class C {
 >Date : Date
 
     "-1.0": RegExp;
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     "-1": Date;
 >Date : Date
@@ -97,8 +97,8 @@ var r7 = i[-1.0];
 >1.0 : 1
 
 var r8 = i["-1.0"];
->r8 : RegExp
->i["-1.0"] : RegExp
+>r8 : RegExp<string>
+>i["-1.0"] : RegExp<string>
 >i : I
 >"-1.0" : "-1.0"
 
@@ -148,7 +148,7 @@ interface I {
 >Date : Date
 
     "-1.0": RegExp;
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     "-1": Date;
 >Date : Date
@@ -228,8 +228,8 @@ var r7 = i[-1.0];
 >1.0 : 1
 
 var r8 = i["-1.0"];
->r8 : RegExp
->i["-1.0"] : RegExp
+>r8 : RegExp<string>
+>i["-1.0"] : RegExp<string>
 >i : I
 >"-1.0" : "-1.0"
 
@@ -266,7 +266,7 @@ var r13 = i[-01]
 >01 : 1
 
 var a: {
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 
     "0.1": void;
     ".1": Object;
@@ -279,7 +279,7 @@ var a: {
 >Date : Date
 
     "-1.0": RegExp;
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     "-1": Date;
 >Date : Date
@@ -288,19 +288,19 @@ var a: {
 var r1 = a['0.1'];
 >r1 : void
 >a['0.1'] : void
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 >'0.1' : "0.1"
 
 var r2 = a['.1'];
 >r2 : Object
 >a['.1'] : Object
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 >'.1' : ".1"
 
 var r3 = a['1'];
 >r3 : number
 >a['1'] : number
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 >'1' : "1"
 
 var r3 = c[1];
@@ -312,7 +312,7 @@ var r3 = c[1];
 var r4 = a['1.'];
 >r4 : string
 >a['1.'] : string
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 >'1.' : "1."
 
 var r3 = c[1.]; // same as indexing by 1 when done numerically
@@ -324,13 +324,13 @@ var r3 = c[1.]; // same as indexing by 1 when done numerically
 var r5 = a['1..'];
 >r5 : boolean
 >a['1..'] : boolean
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 >'1..' : "1.."
 
 var r6 = a['1.0'];
 >r6 : Date
 >a['1.0'] : Date
->a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": Date; }
+>a : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp<string>; "-1": Date; }
 >'1.0' : "1.0"
 
 var r3 = c[1.0]; // same as indexing by 1 when done numerically
@@ -355,8 +355,8 @@ var r7 = i[-1.0];
 >1.0 : 1
 
 var r8 = i["-1.0"];
->r8 : RegExp
->i["-1.0"] : RegExp
+>r8 : RegExp<string>
+>i["-1.0"] : RegExp<string>
 >i : I
 >"-1.0" : "-1.0"
 
@@ -393,8 +393,8 @@ var r13 = i[-01]
 >01 : 1
 
 var b = {
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
->{    "0.1": <void>null,    ".1": new Object(),    "1": 1,    "1.": "",    "1..": true,    "1.0": new Date(),    "-1.0": /123/,    "-1": Date} : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
+>{    "0.1": <void>null,    ".1": new Object(),    "1": 1,    "1.": "",    "1..": true,    "1.0": new Date(),    "-1.0": /123/,    "-1": Date} : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 
     "0.1": <void>null,
 ><void>null : void
@@ -418,7 +418,7 @@ var b = {
 >Date : DateConstructor
 
     "-1.0": /123/,
->/123/ : RegExp
+>/123/ : RegExp</123/>
 
     "-1": Date
 >Date : DateConstructor
@@ -428,19 +428,19 @@ var b = {
 var r1 = b['0.1'];
 >r1 : void
 >b['0.1'] : void
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 >'0.1' : "0.1"
 
 var r2 = b['.1'];
 >r2 : Object
 >b['.1'] : Object
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 >'.1' : ".1"
 
 var r3 = b['1'];
 >r3 : number
 >b['1'] : number
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 >'1' : "1"
 
 var r3 = c[1];
@@ -452,7 +452,7 @@ var r3 = c[1];
 var r4 = b['1.'];
 >r4 : string
 >b['1.'] : string
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 >'1.' : "1."
 
 var r3 = c[1.]; // same as indexing by 1 when done numerically
@@ -464,13 +464,13 @@ var r3 = c[1.]; // same as indexing by 1 when done numerically
 var r5 = b['1..'];
 >r5 : boolean
 >b['1..'] : boolean
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 >'1..' : "1.."
 
 var r6 = b['1.0'];
 >r6 : Date
 >b['1.0'] : Date
->b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp; "-1": DateConstructor; }
+>b : { "0.1": void; ".1": Object; "1": number; "1.": string; "1..": boolean; "1.0": Date; "-1.0": RegExp</123/>; "-1": DateConstructor; }
 >'1.0' : "1.0"
 
 var r3 = c[1.0]; // same as indexing by 1 when done numerically
@@ -495,8 +495,8 @@ var r7 = i[-1.0];
 >1.0 : 1
 
 var r8 = i["-1.0"];
->r8 : RegExp
->i["-1.0"] : RegExp
+>r8 : RegExp<string>
+>i["-1.0"] : RegExp<string>
 >i : I
 >"-1.0" : "-1.0"
 
diff --git a/tests/baselines/reference/objectTypesIdentity2.types b/tests/baselines/reference/objectTypesIdentity2.types
index 1969d55bd11f2..1d41551b39b63 100644
--- a/tests/baselines/reference/objectTypesIdentity2.types
+++ b/tests/baselines/reference/objectTypesIdentity2.types
@@ -33,9 +33,9 @@ interface I {
 }
 
 var a: { foo: RegExp; }
->a : { foo: RegExp; }
->foo : RegExp
->RegExp : RegExp
+>a : { foo: RegExp<string>; }
+>foo : RegExp<string>
+>RegExp : RegExp<T>
 
 enum E { A }
 >E : E
@@ -92,17 +92,17 @@ function foo6(x: any) { }
 >x : any
 
 function foo7(x: A);
->foo7 : { (x: A): any; (x: { foo: RegExp; }): any; }
+>foo7 : { (x: A): any; (x: { foo: RegExp<string>; }): any; }
 >x : A
 >A : A
 
 function foo7(x: typeof a); // ok
->foo7 : { (x: A): any; (x: { foo: RegExp; }): any; }
->x : { foo: RegExp; }
->a : { foo: RegExp; }
+>foo7 : { (x: A): any; (x: { foo: RegExp<string>; }): any; }
+>x : { foo: RegExp<string>; }
+>a : { foo: RegExp<string>; }
 
 function foo7(x: any) { }
->foo7 : { (x: A): any; (x: { foo: RegExp; }): any; }
+>foo7 : { (x: A): any; (x: { foo: RegExp<string>; }): any; }
 >x : any
 
 function foo8(x: B);
@@ -134,17 +134,17 @@ function foo9(x: any) { }
 >x : any
 
 function foo10(x: B);
->foo10 : { (x: B): any; (x: { foo: RegExp; }): any; }
+>foo10 : { (x: B): any; (x: { foo: RegExp<string>; }): any; }
 >x : B
 >B : B
 
 function foo10(x: typeof a); // ok
->foo10 : { (x: B): any; (x: { foo: RegExp; }): any; }
->x : { foo: RegExp; }
->a : { foo: RegExp; }
+>foo10 : { (x: B): any; (x: { foo: RegExp<string>; }): any; }
+>x : { foo: RegExp<string>; }
+>a : { foo: RegExp<string>; }
 
 function foo10(x: any) { }
->foo10 : { (x: B): any; (x: { foo: RegExp; }): any; }
+>foo10 : { (x: B): any; (x: { foo: RegExp<string>; }): any; }
 >x : any
 
 function foo11(x: B);
@@ -176,17 +176,17 @@ function foo12(x: any) { }
 >x : any
 
 function foo13(x: I);
->foo13 : { (x: I): any; (x: { foo: RegExp; }): any; }
+>foo13 : { (x: I): any; (x: { foo: RegExp<string>; }): any; }
 >x : I
 >I : I
 
 function foo13(x: typeof a); // ok
->foo13 : { (x: I): any; (x: { foo: RegExp; }): any; }
->x : { foo: RegExp; }
->a : { foo: RegExp; }
+>foo13 : { (x: I): any; (x: { foo: RegExp<string>; }): any; }
+>x : { foo: RegExp<string>; }
+>a : { foo: RegExp<string>; }
 
 function foo13(x: any) { }
->foo13 : { (x: I): any; (x: { foo: RegExp; }): any; }
+>foo13 : { (x: I): any; (x: { foo: RegExp<string>; }): any; }
 >x : any
 
 function foo14(x: I);
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.types b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.types
index 12ebec233aa43..386e2d0d20fa4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.types
@@ -57,11 +57,11 @@ var a: { foo(x: Date): string }
 >Date : Date
 
 var b = { foo(x: RegExp) { return ''; } };
->b : { foo(x: RegExp): string; }
->{ foo(x: RegExp) { return ''; } } : { foo(x: RegExp): string; }
->foo : (x: RegExp) => string
->x : RegExp
->RegExp : RegExp
+>b : { foo(x: RegExp<string>): string; }
+>{ foo(x: RegExp) { return ''; } } : { foo(x: RegExp<string>): string; }
+>foo : (x: RegExp<string>) => string
+>x : RegExp<string>
+>RegExp : RegExp<T>
 >'' : ""
 
 function foo1(x: A);
@@ -135,17 +135,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: { foo(x: RegExp): string; }): any; (x: { foo(x: RegExp): string; }): any; }
->x : { foo(x: RegExp): string; }
->b : { foo(x: RegExp): string; }
+>foo4 : { (x: { foo(x: RegExp<string>): string; }): any; (x: { foo(x: RegExp<string>): string; }): any; }
+>x : { foo(x: RegExp<string>): string; }
+>b : { foo(x: RegExp<string>): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { foo(x: RegExp): string; }): any; (x: { foo(x: RegExp): string; }): any; }
->x : { foo(x: RegExp): string; }
->b : { foo(x: RegExp): string; }
+>foo4 : { (x: { foo(x: RegExp<string>): string; }): any; (x: { foo(x: RegExp<string>): string; }): any; }
+>x : { foo(x: RegExp<string>): string; }
+>b : { foo(x: RegExp<string>): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { foo(x: RegExp): string; }): any; (x: { foo(x: RegExp): string; }): any; }
+>foo4 : { (x: { foo(x: RegExp<string>): string; }): any; (x: { foo(x: RegExp<string>): string; }): any; }
 >x : any
 
 function foo5(x: A);
@@ -247,17 +247,17 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B);
->foo11 : { (x: B): any; (x: { foo(x: RegExp): string; }): any; }
+>foo11 : { (x: B): any; (x: { foo(x: RegExp<string>): string; }): any; }
 >x : B
 >B : B
 
 function foo11(x: typeof b); // ok
->foo11 : { (x: B): any; (x: { foo(x: RegExp): string; }): any; }
->x : { foo(x: RegExp): string; }
->b : { foo(x: RegExp): string; }
+>foo11 : { (x: B): any; (x: { foo(x: RegExp<string>): string; }): any; }
+>x : { foo(x: RegExp<string>): string; }
+>b : { foo(x: RegExp<string>): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B): any; (x: { foo(x: RegExp): string; }): any; }
+>foo11 : { (x: B): any; (x: { foo(x: RegExp<string>): string; }): any; }
 >x : any
 
 function foo12(x: I);
@@ -303,17 +303,17 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I);
->foo14 : { (x: I): any; (x: { foo(x: RegExp): string; }): any; }
+>foo14 : { (x: I): any; (x: { foo(x: RegExp<string>): string; }): any; }
 >x : I
 >I : I
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I): any; (x: { foo(x: RegExp): string; }): any; }
->x : { foo(x: RegExp): string; }
->b : { foo(x: RegExp): string; }
+>foo14 : { (x: I): any; (x: { foo(x: RegExp<string>): string; }): any; }
+>x : { foo(x: RegExp<string>): string; }
+>b : { foo(x: RegExp<string>): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I): any; (x: { foo(x: RegExp): string; }): any; }
+>foo14 : { (x: I): any; (x: { foo(x: RegExp<string>): string; }): any; }
 >x : any
 
 function foo15(x: I2<string>);
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types
index 4dd31ec26d346..b9355432b5b64 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types
@@ -42,11 +42,11 @@ var a: { new(x: Date): string }
 >Date : Date
 
 var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new
->b : { new(x: RegExp): string; }
->{ new(x: RegExp) { return ''; } } : { new(x: RegExp): string; }
->new : (x: RegExp) => string
->x : RegExp
->RegExp : RegExp
+>b : { new(x: RegExp<string>): string; }
+>{ new(x: RegExp) { return ''; } } : { new(x: RegExp<string>): string; }
+>new : (x: RegExp<string>) => string
+>x : RegExp<string>
+>RegExp : RegExp<T>
 >'' : ""
 
 function foo1b(x: B);
@@ -106,17 +106,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: { new(x: RegExp): string; }): any; (x: { new(x: RegExp): string; }): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>foo4 : { (x: { new(x: RegExp<string>): string; }): any; (x: { new(x: RegExp<string>): string; }): any; }
+>x : { new(x: RegExp<string>): string; }
+>b : { new(x: RegExp<string>): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new(x: RegExp): string; }): any; (x: { new(x: RegExp): string; }): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>foo4 : { (x: { new(x: RegExp<string>): string; }): any; (x: { new(x: RegExp<string>): string; }): any; }
+>x : { new(x: RegExp<string>): string; }
+>b : { new(x: RegExp<string>): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new(x: RegExp): string; }): any; (x: { new(x: RegExp): string; }): any; }
+>foo4 : { (x: { new(x: RegExp<string>): string; }): any; (x: { new(x: RegExp<string>): string; }): any; }
 >x : any
 
 function foo8(x: B);
@@ -162,17 +162,17 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B);
->foo11 : { (x: B): any; (x: { new(x: RegExp): string; }): any; }
+>foo11 : { (x: B): any; (x: { new(x: RegExp<string>): string; }): any; }
 >x : B
 >B : B
 
 function foo11(x: typeof b); // ok
->foo11 : { (x: B): any; (x: { new(x: RegExp): string; }): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>foo11 : { (x: B): any; (x: { new(x: RegExp<string>): string; }): any; }
+>x : { new(x: RegExp<string>): string; }
+>b : { new(x: RegExp<string>): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B): any; (x: { new(x: RegExp): string; }): any; }
+>foo11 : { (x: B): any; (x: { new(x: RegExp<string>): string; }): any; }
 >x : any
 
 function foo12(x: I);
@@ -218,17 +218,17 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I);
->foo14 : { (x: I): any; (x: { new(x: RegExp): string; }): any; }
+>foo14 : { (x: I): any; (x: { new(x: RegExp<string>): string; }): any; }
 >x : I
 >I : I
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I): any; (x: { new(x: RegExp): string; }): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>foo14 : { (x: I): any; (x: { new(x: RegExp<string>): string; }): any; }
+>x : { new(x: RegExp<string>): string; }
+>b : { new(x: RegExp<string>): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I): any; (x: { new(x: RegExp): string; }): any; }
+>foo14 : { (x: I): any; (x: { new(x: RegExp<string>): string; }): any; }
 >x : any
 
 function foo15(x: I2<string>);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.types
index 33598fe815f11..28deaf657587b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.types
@@ -70,11 +70,11 @@ var a: { foo<T extends Array<string>>(x: T): string }
 >T : T
 
 var b = { foo<T extends RegExp>(x: T) { return ''; } };
->b : { foo<T extends RegExp>(x: T): string; }
->{ foo<T extends RegExp>(x: T) { return ''; } } : { foo<T extends RegExp>(x: T): string; }
->foo : <T extends RegExp>(x: T) => string
+>b : { foo<T extends RegExp<string>>(x: T): string; }
+>{ foo<T extends RegExp>(x: T) { return ''; } } : { foo<T extends RegExp<string>>(x: T): string; }
+>foo : <T extends RegExp<string>>(x: T) => string
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 >'' : ""
@@ -156,17 +156,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: { foo<T extends RegExp>(x: T): string; }): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
->x : { foo<T extends RegExp>(x: T): string; }
->b : { foo<T extends RegExp>(x: T): string; }
+>foo4 : { (x: { foo<T extends RegExp<string>>(x: T): string; }): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { foo<T extends RegExp<string>>(x: T): string; }
+>b : { foo<T extends RegExp<string>>(x: T): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { foo<T extends RegExp>(x: T): string; }): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
->x : { foo<T extends RegExp>(x: T): string; }
->b : { foo<T extends RegExp>(x: T): string; }
+>foo4 : { (x: { foo<T extends RegExp<string>>(x: T): string; }): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { foo<T extends RegExp<string>>(x: T): string; }
+>b : { foo<T extends RegExp<string>>(x: T): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { foo<T extends RegExp>(x: T): string; }): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
+>foo4 : { (x: { foo<T extends RegExp<string>>(x: T): string; }): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
 >x : any
 
 function foo5(x: A);
@@ -276,18 +276,18 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Array<number>>);
->foo11 : { (x: B<number[]>): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
+>foo11 : { (x: B<number[]>): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
 >x : B<number[]>
 >B : B<T>
 >Array : T[]
 
 function foo11(x: typeof b); // ok
->foo11 : { (x: B<number[]>): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
->x : { foo<T extends RegExp>(x: T): string; }
->b : { foo<T extends RegExp>(x: T): string; }
+>foo11 : { (x: B<number[]>): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { foo<T extends RegExp<string>>(x: T): string; }
+>b : { foo<T extends RegExp<string>>(x: T): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<number[]>): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
+>foo11 : { (x: B<number[]>): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
 >x : any
 
 function foo12(x: I<Number>);
@@ -337,18 +337,18 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Number>);
->foo14 : { (x: I<Number>): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
+>foo14 : { (x: I<Number>): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
 >x : I<Number>
 >I : I<T>
 >Number : Number
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I<Number>): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
->x : { foo<T extends RegExp>(x: T): string; }
->b : { foo<T extends RegExp>(x: T): string; }
+>foo14 : { (x: I<Number>): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { foo<T extends RegExp<string>>(x: T): string; }
+>b : { foo<T extends RegExp<string>>(x: T): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Number>): any; (x: { foo<T extends RegExp>(x: T): string; }): any; }
+>foo14 : { (x: I<Number>): any; (x: { foo<T extends RegExp<string>>(x: T): string; }): any; }
 >x : any
 
 function foo15(x: I2);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.types
index 265dd91784b75..0162e1e684c5b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints2.types
@@ -110,13 +110,13 @@ var a: { foo<T extends U, U extends Array<string>>(x: T, y: U): string }
 >U : U
 
 var b = { foo<T extends U, U extends RegExp>(x: T, y: U) { return ''; } };
->b : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
->{ foo<T extends U, U extends RegExp>(x: T, y: U) { return ''; } } : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
->foo : <T extends U, U extends RegExp>(x: T, y: U) => string
+>b : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>{ foo<T extends U, U extends RegExp>(x: T, y: U) { return ''; } } : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>foo : <T extends U, U extends RegExp<string>>(x: T, y: U) => string
 >T : T
 >U : U
 >U : U
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 >y : U
@@ -206,17 +206,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo4 : { (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo4 : { (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo4 : { (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo5(x: A);
@@ -369,19 +369,19 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Array<number>, Array<number>>);
->foo11 : { (x: B<number[], number[]>): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : B<number[], number[]>
 >B : B<T, U>
 >Array : T[]
 >Array : T[]
 
 function foo11(x: typeof b); // ok
->foo11 : { (x: B<number[], number[]>): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<number[], number[]>): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo12(x: I<Number, Number>);
@@ -435,19 +435,19 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Number, Number>);
->foo14 : { (x: I<Number, Number>): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Number, Number>): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : I<Number, Number>
 >I : I<T, U>
 >Number : Number
 >Number : Number
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I<Number, Number>): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { foo<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo14 : { (x: I<Number, Number>): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Number, Number>): any; (x: { foo<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Number, Number>): any; (x: { foo<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo15(x: I2);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.types
index ef6799b6ab951..2f0ca3486030b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.types
@@ -51,11 +51,11 @@ interface I2 {
 >I2 : I2
 
     foo<T>(x: T): RegExp;
->foo : <T>(x: T) => RegExp
+>foo : <T>(x: T) => RegExp<string>
 >T : T
 >x : T
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 }
 
 var a: { foo<T>(x: T): T }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.types
index c964cc46cadb6..45116eb8daadf 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.types
@@ -55,12 +55,12 @@ interface I2 {
 >I2 : I2
 
     foo<T extends Date>(x: T): RegExp;
->foo : <T extends Date>(x: T) => RegExp
+>foo : <T extends Date>(x: T) => RegExp<string>
 >T : T
 >Date : Date
 >x : T
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 }
 
 var a: { foo<T extends Date>(x: T): T }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types
index afc2e9ae6cee0..dbc42479bda82 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.types
@@ -326,36 +326,36 @@ function foo12b(x: any) { }
 >x : any
 
 function foo13(x: I<string, Date, RegExp, Date>);
->foo13 : { (x: I<string, Date, RegExp, Date>): any; (x: { foo<Z, A, B, C, D>(x: Z): Z; }): any; }
->x : I<string, Date, RegExp, Date>
+>foo13 : { (x: I<string, Date, RegExp<string>, Date>): any; (x: { foo<Z, A, B, C, D>(x: Z): Z; }): any; }
+>x : I<string, Date, RegExp<string>, Date>
 >I : I<X, Y, Z, A>
 >Date : Date
->RegExp : RegExp
+>RegExp : RegExp<T>
 >Date : Date
 
 function foo13(x: typeof a); // ok
->foo13 : { (x: I<string, Date, RegExp, Date>): any; (x: { foo<Z, A, B, C, D>(x: Z): Z; }): any; }
+>foo13 : { (x: I<string, Date, RegExp<string>, Date>): any; (x: { foo<Z, A, B, C, D>(x: Z): Z; }): any; }
 >x : { foo<Z, A, B, C, D>(x: Z): Z; }
 >a : { foo<Z, A, B, C, D>(x: Z): Z; }
 
 function foo13(x: any) { }
->foo13 : { (x: I<string, Date, RegExp, Date>): any; (x: { foo<Z, A, B, C, D>(x: Z): Z; }): any; }
+>foo13 : { (x: I<string, Date, RegExp<string>, Date>): any; (x: { foo<Z, A, B, C, D>(x: Z): Z; }): any; }
 >x : any
 
 function foo14(x: I<string, Date, RegExp, boolean>);
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { foo<A, B, C, D, E, F>(x: A): A; }): any; }
->x : I<string, Date, RegExp, boolean>
+>foo14 : { (x: I<string, Date, RegExp<string>, boolean>): any; (x: { foo<A, B, C, D, E, F>(x: A): A; }): any; }
+>x : I<string, Date, RegExp<string>, boolean>
 >I : I<X, Y, Z, A>
 >Date : Date
->RegExp : RegExp
+>RegExp : RegExp<T>
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { foo<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo14 : { (x: I<string, Date, RegExp<string>, boolean>): any; (x: { foo<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : { foo<A, B, C, D, E, F>(x: A): A; }
 >b : { foo<A, B, C, D, E, F>(x: A): A; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { foo<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo14 : { (x: I<string, Date, RegExp<string>, boolean>): any; (x: { foo<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : any
 
 function foo15(x: I2);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types
index 40c1733a1e166..121b6de3f8267 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types
@@ -53,11 +53,11 @@ var a: { new<T extends Array<string>>(x: T): string }
 >T : T
 
 var b = { new<T extends RegExp>(x: T) { return ''; } }; // not a construct signature, function called new
->b : { new<T extends RegExp>(x: T): string; }
->{ new<T extends RegExp>(x: T) { return ''; } } : { new<T extends RegExp>(x: T): string; }
->new : <T extends RegExp>(x: T) => string
+>b : { new<T extends RegExp<string>>(x: T): string; }
+>{ new<T extends RegExp>(x: T) { return ''; } } : { new<T extends RegExp<string>>(x: T): string; }
+>new : <T extends RegExp<string>>(x: T) => string
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 >'' : ""
@@ -125,17 +125,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: { new<T extends RegExp>(x: T): string; }): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>foo4 : { (x: { new<T extends RegExp<string>>(x: T): string; }): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { new<T extends RegExp<string>>(x: T): string; }
+>b : { new<T extends RegExp<string>>(x: T): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T extends RegExp>(x: T): string; }): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>foo4 : { (x: { new<T extends RegExp<string>>(x: T): string; }): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { new<T extends RegExp<string>>(x: T): string; }
+>b : { new<T extends RegExp<string>>(x: T): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T extends RegExp>(x: T): string; }): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo4 : { (x: { new<T extends RegExp<string>>(x: T): string; }): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
 >x : any
 
 function foo8(x: B<Array<number>>);
@@ -186,18 +186,18 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Array<number>>);
->foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
 >x : B<number[]>
 >B : B<T>
 >Array : T[]
 
 function foo11(x: typeof b); // ok
->foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { new<T extends RegExp<string>>(x: T): string; }
+>b : { new<T extends RegExp<string>>(x: T): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
 >x : any
 
 function foo12(x: I<Number>);
@@ -247,17 +247,17 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Number>);
->foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
 >x : I<Number>
 >I : I<T>
 >Number : Number
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
+>x : { new<T extends RegExp<string>>(x: T): string; }
+>b : { new<T extends RegExp<string>>(x: T): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp<string>>(x: T): string; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types
index 2c2145658097e..e6f3e2e2b564b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types
@@ -88,13 +88,13 @@ var a: { new<T extends U, U extends Array<string>>(x: T, y: U): string }
 >U : U
 
 var b = { new<T extends U, U extends RegExp>(x: T, y: U) { return ''; } }; // not a construct signature, function called new
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->{ new<T extends U, U extends RegExp>(x: T, y: U) { return ''; } } : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->new : <T extends U, U extends RegExp>(x: T, y: U) => string
+>b : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>{ new<T extends U, U extends RegExp>(x: T, y: U) { return ''; } } : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>new : <T extends U, U extends RegExp<string>>(x: T, y: U) => string
 >T : T
 >U : U
 >U : U
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 >y : U
@@ -170,17 +170,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo4 : { (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo4 : { (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo4 : { (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo5c(x: C<String, String>);
@@ -271,19 +271,19 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Array<number>, Array<number>>);
->foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : B<number[], number[]>
 >B : B<T, U>
 >Array : T[]
 >Array : T[]
 
 function foo11(x: typeof b); // ok
->foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo12(x: I<Number, Number>);
@@ -337,18 +337,18 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Number, Number>);
->foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : I<Number, Number>
 >I : I<T, U>
 >Number : Number
 >Number : Number
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
+>x : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
+>b : { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp<string>>(x: T, y: U): string; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types
index 657c38aae9a1d..0c2e68ffbf2ff 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types
@@ -40,7 +40,7 @@ interface I2 {
 >T : T
 >x : T
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 }
 
 var a: { new<T>(x: T): T }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types
index 181acc2ce91cb..c683ae009b721 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types
@@ -44,7 +44,7 @@ interface I2 {
 >Date : Date
 >x : T
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 }
 
 var a: { new<T extends Date>(x: T): T }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types
index b8e7c15c9b551..2e54dc57fb23c 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types
@@ -244,35 +244,35 @@ function foo12b(x: any) { }
 >x : any
 
 function foo13(x: I<string, Date, RegExp, Date>);
->foo13 : { (x: I<string, Date, RegExp, Date>): any; (x: new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>): any; }
->x : I<string, Date, RegExp, Date>
+>foo13 : { (x: I<string, Date, RegExp<string>, Date>): any; (x: new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>): any; }
+>x : I<string, Date, RegExp<string>, Date>
 >I : I<X, Y, Z, A>
 >Date : Date
->RegExp : RegExp
+>RegExp : RegExp<T>
 >Date : Date
 
 function foo13(x: typeof a); // ok
->foo13 : { (x: I<string, Date, RegExp, Date>): any; (x: new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>): any; }
+>foo13 : { (x: I<string, Date, RegExp<string>, Date>): any; (x: new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>): any; }
 >x : new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>
 >a : new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>
 
 function foo13(x: any) { }
->foo13 : { (x: I<string, Date, RegExp, Date>): any; (x: new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>): any; }
+>foo13 : { (x: I<string, Date, RegExp<string>, Date>): any; (x: new <Z, A, B, CC, D>(x: Z) => C<Z, A, B>): any; }
 >x : any
 
 function foo14(x: I<string, Date, RegExp, boolean>);
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
->x : I<string, Date, RegExp, boolean>
+>foo14 : { (x: I<string, Date, RegExp<string>, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>x : I<string, Date, RegExp<string>, boolean>
 >I : I<X, Y, Z, A>
 >Date : Date
->RegExp : RegExp
+>RegExp : RegExp<T>
 
 function foo14(x: typeof b); // ok
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo14 : { (x: I<string, Date, RegExp<string>, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : { new<A, B, C, D, E, F>(x: A): A; }
 >b : { new<A, B, C, D, E, F>(x: A): A; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo14 : { (x: I<string, Date, RegExp<string>, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.types b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.types
index ce2171f1e9a92..121de4d91124a 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.types
+++ b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.types
@@ -15,10 +15,10 @@ module Bugs {
     var result= message.replace(/\{(\d+)\}/g, function(match, ...rest) {
 >result : string
 >message.replace(/\{(\d+)\}/g, function(match, ...rest) {      var index= rest[0];      return typeof args[index] !== 'undefined'        ? args[index]        : match;    }) : string
->message.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>message.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >message : string
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/\{(\d+)\}/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/\{(\d+)\}/g : RegExp</\{(\d+)\}/g>
 >function(match, ...rest) {      var index= rest[0];      return typeof args[index] !== 'undefined'        ? args[index]        : match;    } : (match: string, ...rest: any[]) => any
 >match : string
 >rest : any[]
diff --git a/tests/baselines/reference/overloadResolutionWithAny.types b/tests/baselines/reference/overloadResolutionWithAny.types
index 362c70f61620b..b267eeae9e525 100644
--- a/tests/baselines/reference/overloadResolutionWithAny.types
+++ b/tests/baselines/reference/overloadResolutionWithAny.types
@@ -29,7 +29,7 @@ func(x); // string
 >x : any
 
 var func2: {
->func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp; (s: any, t: any): string; }
+>func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp<string>; (s: any, t: any): string; }
 
     (s: string, t: string): number;
 >s : string
@@ -42,7 +42,7 @@ var func2: {
     (s: string, t: any): RegExp;
 >s : string
 >t : any
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     (s: any, t: any): string;
 >s : any
@@ -51,25 +51,25 @@ var func2: {
 
 func2(x, x); // string
 >func2(x, x) : string
->func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp; (s: any, t: any): string; }
+>func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp<string>; (s: any, t: any): string; }
 >x : any
 >x : any
 
 func2("", ""); // number
 >func2("", "") : number
->func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp; (s: any, t: any): string; }
+>func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp<string>; (s: any, t: any): string; }
 >"" : ""
 >"" : ""
 
 func2(x, ""); // boolean
 >func2(x, "") : boolean
->func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp; (s: any, t: any): string; }
+>func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp<string>; (s: any, t: any): string; }
 >x : any
 >"" : ""
 
 func2("", x); // RegExp
->func2("", x) : RegExp
->func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp; (s: any, t: any): string; }
+>func2("", x) : RegExp<string>
+>func2 : { (s: string, t: string): number; (s: any, t: string): boolean; (s: string, t: any): RegExp<string>; (s: any, t: any): string; }
 >"" : ""
 >x : any
 
diff --git a/tests/baselines/reference/parseRegularExpressionMixedWithComments.types b/tests/baselines/reference/parseRegularExpressionMixedWithComments.types
index 8df0d68f52c6d..b0a57cc81045e 100644
--- a/tests/baselines/reference/parseRegularExpressionMixedWithComments.types
+++ b/tests/baselines/reference/parseRegularExpressionMixedWithComments.types
@@ -1,11 +1,11 @@
 === tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts ===
 var regex1 = / asdf /;
->regex1 : RegExp
->/ asdf / : RegExp
+>regex1 : RegExp</ asdf />
+>/ asdf / : RegExp</ asdf />
 
 var regex2 = /**// asdf /;
->regex2 : RegExp
->/ asdf / : RegExp
+>regex2 : RegExp</ asdf />
+>/ asdf / : RegExp</ asdf />
 
 var regex3 = /**///**/ asdf /       // should be a comment line
 >regex3 : number
@@ -16,12 +16,12 @@ var regex3 = /**///**/ asdf /       // should be a comment line
 var regex4 = /**// /**/asdf /;
 >regex4 : number
 >/ /**/asdf / : number
->/ / : RegExp
->/asdf / : RegExp
+>/ / : RegExp</ />
+>/asdf / : RegExp</asdf />
 
 var regex5 = /**// asdf/**/ /;
 >regex5 : number
 >/ asdf/**/ / : number
->/ asdf/ : RegExp
->/ / : RegExp
+>/ asdf/ : RegExp</ asdf/>
+>/ / : RegExp</ />
 
diff --git a/tests/baselines/reference/parser.numericSeparators.unicodeEscape.types b/tests/baselines/reference/parser.numericSeparators.unicodeEscape.types
index 052fc3c09cd76..3e6d2b007ba39 100644
--- a/tests/baselines/reference/parser.numericSeparators.unicodeEscape.types
+++ b/tests/baselines/reference/parser.numericSeparators.unicodeEscape.types
@@ -12,7 +12,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/4.ts ===
 /\u{10_ffff}/u
->/\u{10_ffff}/u : RegExp
+>/\u{10_ffff}/u : RegExp</\u{10_ffff}/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/5.ts ===
 "\uff_ff"
@@ -28,7 +28,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/8.ts ===
 /\uff_ff/u
->/\uff_ff/u : RegExp
+>/\uff_ff/u : RegExp</\uff_ff/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/9.ts ===
 "\xf_f"
@@ -44,7 +44,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/12.ts ===
 /\xf_f/u
->/\xf_f/u : RegExp
+>/\xf_f/u : RegExp</\xf_f/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/13.ts ===
 "\u{_10ffff}"
@@ -60,7 +60,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/16.ts ===
 /\u{_10ffff}/u
->/\u{_10ffff}/u : RegExp
+>/\u{_10ffff}/u : RegExp</\u{_10ffff}/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/17.ts ===
 "\u_ffff"
@@ -76,7 +76,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/20.ts ===
 /\u_ffff/u
->/\u_ffff/u : RegExp
+>/\u_ffff/u : RegExp</\u_ffff/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/21.ts ===
 "\x_ff"
@@ -92,7 +92,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/24.ts ===
 /\x_ff/u
->/\x_ff/u : RegExp
+>/\x_ff/u : RegExp</\x_ff/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/25.ts ===
 "\u{10ffff_}"
@@ -108,7 +108,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/28.ts ===
 /\u{10ffff_}/u
->/\u{10ffff_}/u : RegExp
+>/\u{10ffff_}/u : RegExp</\u{10ffff_}/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/29.ts ===
 "\uffff_"
@@ -124,7 +124,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/32.ts ===
 /\uffff_/u
->/\uffff_/u : RegExp
+>/\uffff_/u : RegExp</\uffff_/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/33.ts ===
 "\xff_"
@@ -140,7 +140,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/36.ts ===
 /\xff_/u
->/\xff_/u : RegExp
+>/\xff_/u : RegExp</\xff_/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/37.ts ===
 "\u{10__ffff}"
@@ -156,7 +156,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/40.ts ===
 /\u{10__ffff}/u
->/\u{10__ffff}/u : RegExp
+>/\u{10__ffff}/u : RegExp</\u{10__ffff}/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/41.ts ===
 "\uff__ff"
@@ -172,7 +172,7 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/44.ts ===
 /\uff__ff/u
->/\uff__ff/u : RegExp
+>/\uff__ff/u : RegExp</\uff__ff/u>
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/45.ts ===
 "\xf__f"
@@ -188,5 +188,5 @@
 
 === tests/cases/conformance/parser/ecmascriptnext/numericSeparators/48.ts ===
 /\xf__f/u
->/\xf__f/u : RegExp
+>/\xf__f/u : RegExp</\xf__f/u>
 
diff --git a/tests/baselines/reference/parser579071.types b/tests/baselines/reference/parser579071.types
index bfdece6f7879e..350e1801f0d04 100644
--- a/tests/baselines/reference/parser579071.types
+++ b/tests/baselines/reference/parser579071.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/RegressionTests/parser579071.ts ===
 var x = /fo(o/;
->x : RegExp
->/fo(o/ : RegExp
+>x : RegExp</fo(o/>
+>/fo(o/ : RegExp</fo(o/>
 
diff --git a/tests/baselines/reference/parser596700.types b/tests/baselines/reference/parser596700.types
index b14e28be71684..48428b521b719 100644
--- a/tests/baselines/reference/parser596700.types
+++ b/tests/baselines/reference/parser596700.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/RegressionTests/parser596700.ts ===
 var regex2 = /[a-z/]$/i;
->regex2 : RegExp
->/[a-z/]$/i : RegExp
+>regex2 : RegExp</[a-z/]$/i>
+>/[a-z/]$/i : RegExp</[a-z/]$/i>
 
diff --git a/tests/baselines/reference/parser630933.types b/tests/baselines/reference/parser630933.types
index 7b38c188f2d00..ebf92490edce3 100644
--- a/tests/baselines/reference/parser630933.types
+++ b/tests/baselines/reference/parser630933.types
@@ -6,8 +6,8 @@ var a = "Hello";
 var b = a.match(/\/ver=([^/]+)/);
 >b : RegExpMatchArray
 >a.match(/\/ver=([^/]+)/) : RegExpMatchArray
->a.match : (regexp: string | RegExp) => RegExpMatchArray
+>a.match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >a : string
->match : (regexp: string | RegExp) => RegExpMatchArray
->/\/ver=([^/]+)/ : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/\/ver=([^/]+)/ : RegExp</\/ver=([^/]+)/>
 
diff --git a/tests/baselines/reference/parser645086_1.types b/tests/baselines/reference/parser645086_1.types
index 020e7f02c1409..8797eb521d922 100644
--- a/tests/baselines/reference/parser645086_1.types
+++ b/tests/baselines/reference/parser645086_1.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_1.ts ===
 var v = /[]/]/
->v : RegExp
->/[]/ : RegExp
->/ : RegExp
+>v : RegExp</[]/>
+>/[]/ : RegExp</[]/>
+>/ : RegExp</>
 
diff --git a/tests/baselines/reference/parser645086_2.types b/tests/baselines/reference/parser645086_2.types
index b918ec4a5fed8..2c3d56560e6a1 100644
--- a/tests/baselines/reference/parser645086_2.types
+++ b/tests/baselines/reference/parser645086_2.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_2.ts ===
 var v = /[^]/]/
->v : RegExp
->/[^]/ : RegExp
->/ : RegExp
+>v : RegExp</[^]/>
+>/[^]/ : RegExp</[^]/>
+>/ : RegExp</>
 
diff --git a/tests/baselines/reference/parser645086_3.types b/tests/baselines/reference/parser645086_3.types
index 8cf6c0e73a5b7..f82cb14d3a7ed 100644
--- a/tests/baselines/reference/parser645086_3.types
+++ b/tests/baselines/reference/parser645086_3.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_3.ts ===
 var v = /[\]/]/
->v : RegExp
->/[\]/]/ : RegExp
+>v : RegExp</[\]/]/>
+>/[\]/]/ : RegExp</[\]/]/>
 
diff --git a/tests/baselines/reference/parser645086_4.types b/tests/baselines/reference/parser645086_4.types
index a7c00b04fce4e..57a22c27db450 100644
--- a/tests/baselines/reference/parser645086_4.types
+++ b/tests/baselines/reference/parser645086_4.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_4.ts ===
 var v = /[^\]/]/
->v : RegExp
->/[^\]/]/ : RegExp
+>v : RegExp</[^\]/]/>
+>/[^\]/]/ : RegExp</[^\]/]/>
 
diff --git a/tests/baselines/reference/parser768531.types b/tests/baselines/reference/parser768531.types
index e4b8e1eb70daa..e92dbca573b4b 100644
--- a/tests/baselines/reference/parser768531.types
+++ b/tests/baselines/reference/parser768531.types
@@ -4,5 +4,5 @@
 >3 : 3
 
 /x/
->/x/ : RegExp
+>/x/ : RegExp</x/>
 
diff --git a/tests/baselines/reference/parserIndexSignature8.types b/tests/baselines/reference/parserIndexSignature8.types
index 802eab6dc12b0..0cce3c380fff2 100644
--- a/tests/baselines/reference/parserIndexSignature8.types
+++ b/tests/baselines/reference/parserIndexSignature8.types
@@ -5,6 +5,6 @@ var foo: { [index: any]; }; // expect an error here
 
 var foo2: { [index: RegExp]; }; // expect an error here
 >foo2 : {}
->index : RegExp
->RegExp : RegExp
+>index : RegExp<string>
+>RegExp : RegExp<T>
 
diff --git a/tests/baselines/reference/parserMissingToken2.types b/tests/baselines/reference/parserMissingToken2.types
index f36fb32e9f757..f808f4ea2cf87 100644
--- a/tests/baselines/reference/parserMissingToken2.types
+++ b/tests/baselines/reference/parserMissingToken2.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/MissingTokens/parserMissingToken2.ts ===
 / b;
->/ b; : RegExp
+>/ b; : RegExp</ b;>
 
diff --git a/tests/baselines/reference/parserRealSource11.types b/tests/baselines/reference/parserRealSource11.types
index 389db34d7c6c1..f17b864e9a86d 100644
--- a/tests/baselines/reference/parserRealSource11.types
+++ b/tests/baselines/reference/parserRealSource11.types
@@ -11391,11 +11391,11 @@ module TypeScript {
 >this : this
 >text : string[]
 >this.content.split("\n") : string[]
->this.content.split : (separator: string | RegExp, limit?: number) => string[]
+>this.content.split : (separator: string | RegExp<string>, limit?: number) => string[]
 >this.content : string
 >this : this
 >content : string
->split : (separator: string | RegExp, limit?: number) => string[]
+>split : (separator: string | RegExp<string>, limit?: number) => string[]
 >"\n" : "\n"
 
                     for (var i = 0; i < this.text.length; i++) {
@@ -11419,14 +11419,14 @@ module TypeScript {
 >text : string[]
 >i : number
 >this.text[i].replace(/^\s+|\s+$/g, '') : string
->this.text[i].replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>this.text[i].replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >this.text[i] : string
 >this.text : string[]
 >this : this
 >text : string[]
 >i : number
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/^\s+|\s+$/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/^\s+|\s+$/g : RegExp</^\s+|\s+$/g>
 >'' : ""
                     }
                 }
@@ -11439,12 +11439,12 @@ module TypeScript {
 >[(this.content.replace(/^\s+|\s+$/g, ''))] : string[]
 >(this.content.replace(/^\s+|\s+$/g, '')) : string
 >this.content.replace(/^\s+|\s+$/g, '') : string
->this.content.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>this.content.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >this.content : string
 >this : this
 >content : string
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/^\s+|\s+$/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/^\s+|\s+$/g : RegExp</^\s+|\s+$/g>
 >'' : ""
                 }
             }
diff --git a/tests/baselines/reference/parserRegularExpression1.types b/tests/baselines/reference/parserRegularExpression1.types
index b90cab9b7573b..087304db1081a 100644
--- a/tests/baselines/reference/parserRegularExpression1.types
+++ b/tests/baselines/reference/parserRegularExpression1.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpression1.ts ===
 return /(#?-?\d*\.\d\w*%?)|(@?#?[\w-?]+%?)/g;
->/(#?-?\d*\.\d\w*%?)|(@?#?[\w-?]+%?)/g : RegExp
+>/(#?-?\d*\.\d\w*%?)|(@?#?[\w-?]+%?)/g : RegExp</(#?-?\d*\.\d\w*%?)|(@?#?[\w-?]+%?)/g>
 
diff --git a/tests/baselines/reference/parserRegularExpression2.types b/tests/baselines/reference/parserRegularExpression2.types
index 8108ee3de7820..c2eb46126eaf0 100644
--- a/tests/baselines/reference/parserRegularExpression2.types
+++ b/tests/baselines/reference/parserRegularExpression2.types
@@ -5,6 +5,6 @@ href.match(/:\/\/(.[^/]+)/)[1];
 >href.match : any
 >href : any
 >match : any
->/:\/\/(.[^/]+)/ : RegExp
+>/:\/\/(.[^/]+)/ : RegExp</:\/\/(.[^/]+)/>
 >1 : 1
 
diff --git a/tests/baselines/reference/parserRegularExpression3.types b/tests/baselines/reference/parserRegularExpression3.types
index 38750d16a2b20..40b29bbc24fa9 100644
--- a/tests/baselines/reference/parserRegularExpression3.types
+++ b/tests/baselines/reference/parserRegularExpression3.types
@@ -3,5 +3,5 @@ Foo(!/(\\?|&)adurl=/);
 >Foo(!/(\\?|&)adurl=/) : any
 >Foo : any
 >!/(\\?|&)adurl=/ : boolean
->/(\\?|&)adurl=/ : RegExp
+>/(\\?|&)adurl=/ : RegExp</(\\?|&)adurl=/>
 
diff --git a/tests/baselines/reference/parserRegularExpression4.types b/tests/baselines/reference/parserRegularExpression4.types
index 1a0db05a48e48..ab46aef7d0d50 100644
--- a/tests/baselines/reference/parserRegularExpression4.types
+++ b/tests/baselines/reference/parserRegularExpression4.types
@@ -18,17 +18,17 @@ if (Ca.test(c.href) || Ba.test(c.href) && /(\\?|&)adurl=/.test(c.href) && !/(\\?
 >c : any
 >href : any
 >/(\\?|&)adurl=/.test(c.href) : boolean
->/(\\?|&)adurl=/.test : (string: string) => boolean
->/(\\?|&)adurl=/ : RegExp
->test : (string: string) => boolean
+>/(\\?|&)adurl=/.test : (string: string) => string is /(\\?|&)adurl=/
+>/(\\?|&)adurl=/ : RegExp</(\\?|&)adurl=/>
+>test : (string: string) => string is /(\\?|&)adurl=/
 >c.href : any
 >c : any
 >href : any
 >!/(\\?|&)q=/.test(c.href) : boolean
 >/(\\?|&)q=/.test(c.href) : boolean
->/(\\?|&)q=/.test : (string: string) => boolean
->/(\\?|&)q=/ : RegExp
->test : (string: string) => boolean
+>/(\\?|&)q=/.test : (string: string) => string is /(\\?|&)q=/
+>/(\\?|&)q=/ : RegExp</(\\?|&)q=/>
+>test : (string: string) => string is /(\\?|&)q=/
 >c.href : any
 >c : any
 >href : any
@@ -36,9 +36,9 @@ if (Ca.test(c.href) || Ba.test(c.href) && /(\\?|&)adurl=/.test(c.href) && !/(\\?
 >/ (\\ ? | & ) rct = j / .test(c.href) || (d += "&rct=j"), /(\\?|&)q=/.test(c.href) || (d += "&q=" + encodeURIComponent(W("q") || W("as_q") || A), d = d.substring(0, 1948 - c.href.length)) : any
 >/ (\\ ? | & ) rct = j / .test(c.href) || (d += "&rct=j") : string | true
 >/ (\\ ? | & ) rct = j / .test(c.href) : boolean
->/ (\\ ? | & ) rct = j / .test : (string: string) => boolean
->/ (\\ ? | & ) rct = j / : RegExp
->test : (string: string) => boolean
+>/ (\\ ? | & ) rct = j / .test : (string: string) => string is / (\\ ? | & ) rct = j /
+>/ (\\ ? | & ) rct = j / : RegExp</ (\\ ? | & ) rct = j />
+>test : (string: string) => string is / (\\ ? | & ) rct = j /
 >c.href : any
 >c : any
 >href : any
@@ -48,9 +48,9 @@ if (Ca.test(c.href) || Ba.test(c.href) && /(\\?|&)adurl=/.test(c.href) && !/(\\?
 >"&rct=j" : "&rct=j"
 >/(\\?|&)q=/.test(c.href) || (d += "&q=" + encodeURIComponent(W("q") || W("as_q") || A), d = d.substring(0, 1948 - c.href.length)) : any
 >/(\\?|&)q=/.test(c.href) : boolean
->/(\\?|&)q=/.test : (string: string) => boolean
->/(\\?|&)q=/ : RegExp
->test : (string: string) => boolean
+>/(\\?|&)q=/.test : (string: string) => string is /(\\?|&)q=/
+>/(\\?|&)q=/ : RegExp</(\\?|&)q=/>
+>test : (string: string) => string is /(\\?|&)q=/
 >c.href : any
 >c : any
 >href : any
diff --git a/tests/baselines/reference/parserRegularExpression5.types b/tests/baselines/reference/parserRegularExpression5.types
index 2f1524705571e..7dcc9821a87ef 100644
--- a/tests/baselines/reference/parserRegularExpression5.types
+++ b/tests/baselines/reference/parserRegularExpression5.types
@@ -2,9 +2,9 @@
 if (a) / (\\ ? | & ) rct = j / .test(c.href);
 >a : any
 >/ (\\ ? | & ) rct = j / .test(c.href) : boolean
->/ (\\ ? | & ) rct = j / .test : (string: string) => boolean
->/ (\\ ? | & ) rct = j / : RegExp
->test : (string: string) => boolean
+>/ (\\ ? | & ) rct = j / .test : (string: string) => string is / (\\ ? | & ) rct = j /
+>/ (\\ ? | & ) rct = j / : RegExp</ (\\ ? | & ) rct = j />
+>test : (string: string) => string is / (\\ ? | & ) rct = j /
 >c.href : any
 >c : any
 >href : any
diff --git a/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.errors.txt b/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.errors.txt
index 5a3bfec39e002..ef5597757fa4b 100644
--- a/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.errors.txt
+++ b/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity3.ts(1,18): error TS2339: Property 'foo' does not exist on type 'RegExp'.
+tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity3.ts(1,18): error TS2339: Property 'foo' does not exist on type 'RegExp</regexp/a>'.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity3.ts (1 errors) ====
     if (1) /regexp/a.foo();
                      ~~~
-!!! error TS2339: Property 'foo' does not exist on type 'RegExp'.
\ No newline at end of file
+!!! error TS2339: Property 'foo' does not exist on type 'RegExp</regexp/a>'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.types b/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.types
index ba2b1e077581d..2f10baab239f7 100644
--- a/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.types
+++ b/tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.types
@@ -3,6 +3,6 @@ if (1) /regexp/a.foo();
 >1 : 1
 >/regexp/a.foo() : any
 >/regexp/a.foo : any
->/regexp/a : RegExp
+>/regexp/a : RegExp</regexp/a>
 >foo : any
 
diff --git a/tests/baselines/reference/parserRegularExpressionDivideAmbiguity4.types b/tests/baselines/reference/parserRegularExpressionDivideAmbiguity4.types
index 433696e423443..f0fc374976a96 100644
--- a/tests/baselines/reference/parserRegularExpressionDivideAmbiguity4.types
+++ b/tests/baselines/reference/parserRegularExpressionDivideAmbiguity4.types
@@ -2,5 +2,5 @@
 foo(/notregexp);
 >foo(/notregexp); : any
 >foo : any
->/notregexp); : RegExp
+>/notregexp); : RegExp</notregexp);>
 
diff --git a/tests/baselines/reference/parserSkippedTokens13.types b/tests/baselines/reference/parserSkippedTokens13.types
index 964d9f1067ede..a04cfb1631848 100644
--- a/tests/baselines/reference/parserSkippedTokens13.types
+++ b/tests/baselines/reference/parserSkippedTokens13.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens13.ts ===
 /regexp/ \ ;
->/regexp/ : RegExp
+>/regexp/ : RegExp</regexp/>
 
diff --git a/tests/baselines/reference/parserSkippedTokens4.types b/tests/baselines/reference/parserSkippedTokens4.types
index 3345e1ed1f155..e2c45ffc546c5 100644
--- a/tests/baselines/reference/parserSkippedTokens4.types
+++ b/tests/baselines/reference/parserSkippedTokens4.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens4.ts ===
 \  /regexp/;
->/regexp/ : RegExp
+>/regexp/ : RegExp</regexp/>
 
diff --git a/tests/baselines/reference/parserharness.types b/tests/baselines/reference/parserharness.types
index 284eb887dd484..f2f158232c8c8 100644
--- a/tests/baselines/reference/parserharness.types
+++ b/tests/baselines/reference/parserharness.types
@@ -46,10 +46,10 @@ function switchToForwardSlashes(path: string) {
 
     return path.replace(/\\/g, "/");
 >path.replace(/\\/g, "/") : string
->path.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>path.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >path : string
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/\\/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/\\/g : RegExp</\\/g>
 >"/" : "/"
 }
 
@@ -67,9 +67,9 @@ function filePath(fullPath: string) {
     var components = fullPath.split("/");
 >components : string[]
 >fullPath.split("/") : string[]
->fullPath.split : (separator: string | RegExp, limit?: number) => string[]
+>fullPath.split : (separator: string | RegExp<string>, limit?: number) => string[]
 >fullPath : string
->split : (separator: string | RegExp, limit?: number) => string[]
+>split : (separator: string | RegExp<string>, limit?: number) => string[]
 >"/" : "/"
 
     var path: string[] = components.slice(0, components.length - 1);
@@ -287,10 +287,10 @@ module Harness {
             var bugs = content.match(/\bbug (\d+)/i);
 >bugs : RegExpMatchArray
 >content.match(/\bbug (\d+)/i) : RegExpMatchArray
->content.match : (regexp: string | RegExp) => RegExpMatchArray
+>content.match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >content : string
->match : (regexp: string | RegExp) => RegExpMatchArray
->/\bbug (\d+)/i : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/\bbug (\d+)/i : RegExp</\bbug (\d+)/i>
 
             if (bugs) {
 >bugs : RegExpMatchArray
@@ -535,10 +535,10 @@ module Harness {
 >text1.replace : any
 >text1 : any
 >replace : any
->/^\s+|\s+$/g : RegExp
+>/^\s+|\s+$/g : RegExp</^\s+|\s+$/g>
 >"" : ""
 >replace : any
->/\r\n?/g : RegExp
+>/\r\n?/g : RegExp</\r\n?/g>
 >"\n" : "\n"
 
             text2 = text2.replace(/^\s+|\s+$/g, "").replace(/\r\n?/g, "\n");
@@ -550,10 +550,10 @@ module Harness {
 >text2.replace : any
 >text2 : any
 >replace : any
->/^\s+|\s+$/g : RegExp
+>/^\s+|\s+$/g : RegExp</^\s+|\s+$/g>
 >"" : ""
 >replace : any
->/\r\n?/g : RegExp
+>/\r\n?/g : RegExp</\r\n?/g>
 >"\n" : "\n"
 
             if (text1 !== text2) {
@@ -571,7 +571,7 @@ module Harness {
 >text1.split : any
 >text1 : any
 >split : any
->/\n/ : RegExp
+>/\n/ : RegExp</\n/>
 
                 var text2Lines = text2.split(/\n/);
 >text2Lines : any
@@ -579,7 +579,7 @@ module Harness {
 >text2.split : any
 >text2 : any
 >split : any
->/\n/ : RegExp
+>/\n/ : RegExp</\n/>
 
                 for (var i = 0; i < text1Lines.length; i++) {
 >i : number
@@ -782,9 +782,9 @@ module Harness {
         var lines = content.split('\r\n');
 >lines : string[]
 >content.split('\r\n') : string[]
->content.split : (separator: string | RegExp, limit?: number) => string[]
+>content.split : (separator: string | RegExp<string>, limit?: number) => string[]
 >content : string
->split : (separator: string | RegExp, limit?: number) => string[]
+>split : (separator: string | RegExp<string>, limit?: number) => string[]
 >'\r\n' : "\r\n"
 
         if (lines.length === 1) {
@@ -798,9 +798,9 @@ module Harness {
 >lines = content.split('\n') : string[]
 >lines : string[]
 >content.split('\n') : string[]
->content.split : (separator: string | RegExp, limit?: number) => string[]
+>content.split : (separator: string | RegExp<string>, limit?: number) => string[]
 >content : string
->split : (separator: string | RegExp, limit?: number) => string[]
+>split : (separator: string | RegExp<string>, limit?: number) => string[]
 >'\n' : "\n"
         }
         return lines;
@@ -2925,9 +2925,9 @@ module Harness {
 
             return /\.d\.ts$/.test(filename);
 >/\.d\.ts$/.test(filename) : boolean
->/\.d\.ts$/.test : (string: string) => boolean
->/\.d\.ts$/ : RegExp
->test : (string: string) => boolean
+>/\.d\.ts$/.test : (string: string) => string is /\.d\.ts$/
+>/\.d\.ts$/ : RegExp</\.d\.ts$/>
+>test : (string: string) => string is /\.d\.ts$/
 >filename : string
         }
 
@@ -4940,12 +4940,12 @@ module Harness {
                         var match = errorLines[i].match(/([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/);
 >match : RegExpMatchArray
 >errorLines[i].match(/([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/) : RegExpMatchArray
->errorLines[i].match : (regexp: string | RegExp) => RegExpMatchArray
+>errorLines[i].match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >errorLines[i] : string
 >errorLines : string[]
 >i : number
->match : (regexp: string | RegExp) => RegExpMatchArray
->/([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/ : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/ : RegExp</([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/>
 
                         if (match) {
 >match : RegExpMatchArray
@@ -5374,10 +5374,10 @@ module Harness {
 >filename : string
 >path.match(/[^\/]*$/)[0] : string
 >path.match(/[^\/]*$/) : RegExpMatchArray
->path.match : (regexp: string | RegExp) => RegExpMatchArray
+>path.match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >path : string
->match : (regexp: string | RegExp) => RegExpMatchArray
->/[^\/]*$/ : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/[^\/]*$/ : RegExp</[^\/]*$/>
 >0 : 0
 
             var code = readFile(path);
@@ -5562,14 +5562,14 @@ module Harness {
 >unitName : string
 >switchToForwardSlashes(lastUnit.name).match(/[^\/]*$/)[0] : string
 >switchToForwardSlashes(lastUnit.name).match(/[^\/]*$/) : RegExpMatchArray
->switchToForwardSlashes(lastUnit.name).match : (regexp: string | RegExp) => RegExpMatchArray
+>switchToForwardSlashes(lastUnit.name).match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >switchToForwardSlashes(lastUnit.name) : string
 >switchToForwardSlashes : (path: string) => string
 >lastUnit.name : string
 >lastUnit : TestCaseParser.TestUnitData
 >name : string
->match : (regexp: string | RegExp) => RegExpMatchArray
->/[^\/]*$/ : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/[^\/]*$/ : RegExp</[^\/]*$/>
 >0 : 0
 
             var dependencies = units.slice(0, units.length - 1);
@@ -5936,9 +5936,9 @@ module Harness {
 
         // Regex for parsing options in the format "@Alpha: Value of any sort"
         private optionRegex = /^[\/]{2}\s*@(\w+):\s*(\S*)/gm;  // multiple matches on multiple lines
->optionRegex = /^[\/]{2}\s*@(\w+):\s*(\S*)/gm : RegExp
+>optionRegex = /^[\/]{2}\s*@(\w+):\s*(\S*)/gm : RegExp</^[\/]{2}\s*@(\w+):\s*(\S*)/gm>
 >optionRegex : any
->/^[\/]{2}\s*@(\w+):\s*(\S*)/gm : RegExp
+>/^[\/]{2}\s*@(\w+):\s*(\S*)/gm : RegExp</^[\/]{2}\s*@(\w+):\s*(\S*)/gm>
 
         // List of allowed metadata names
         var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out"];
@@ -6064,9 +6064,9 @@ module Harness {
                 var isTripleSlashReference = /[\/]{3}\s*<reference path/.test(line);
 >isTripleSlashReference : boolean
 >/[\/]{3}\s*<reference path/.test(line) : boolean
->/[\/]{3}\s*<reference path/.test : (string: string) => boolean
->/[\/]{3}\s*<reference path/ : RegExp
->test : (string: string) => boolean
+>/[\/]{3}\s*<reference path/.test : (string: string) => string is /[\/]{3}\s*<reference path/
+>/[\/]{3}\s*<reference path/ : RegExp</[\/]{3}\s*<reference path/>
+>test : (string: string) => string is /[\/]{3}\s*<reference path/
 >line : string
 
                 var testMetaData = optionRegex.exec(line);
@@ -6084,10 +6084,10 @@ module Harness {
                     var isRef = line.match(/reference\spath='(\w*_?\w*\.?d?\.ts)'/);
 >isRef : RegExpMatchArray
 >line.match(/reference\spath='(\w*_?\w*\.?d?\.ts)'/) : RegExpMatchArray
->line.match : (regexp: string | RegExp) => RegExpMatchArray
+>line.match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >line : string
->match : (regexp: string | RegExp) => RegExpMatchArray
->/reference\spath='(\w*_?\w*\.?d?\.ts)'/ : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/reference\spath='(\w*_?\w*\.?d?\.ts)'/ : RegExp</reference\spath='(\w*_?\w*\.?d?\.ts)'/>
 
                     if (isRef) {
 >isRef : RegExpMatchArray
@@ -7840,10 +7840,10 @@ module Harness {
 >path : string
 >path.match(/[^\/]*$/)[0] : string
 >path.match(/[^\/]*$/) : RegExpMatchArray
->path.match : (regexp: string | RegExp) => RegExpMatchArray
+>path.match : (regexp: string | RegExp<string>) => RegExpMatchArray
 >path : string
->match : (regexp: string | RegExp) => RegExpMatchArray
->/[^\/]*$/ : RegExp
+>match : (regexp: string | RegExp<string>) => RegExpMatchArray
+>/[^\/]*$/ : RegExp</[^\/]*$/>
 >0 : 0
 >callback : (error: Error, result: any) => void
         }
@@ -8203,9 +8203,9 @@ module Harness {
 >reportContent = reportContent.replace(htmlTrailer, '') : string
 >reportContent : string
 >reportContent.replace(htmlTrailer, '') : string
->reportContent.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>reportContent.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >reportContent : string
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >htmlTrailer : string
 >'' : ""
 
@@ -8375,20 +8375,20 @@ module Harness {
 >expected = expected.replace(/\r\n?/g, '\n') : string
 >expected : string
 >expected.replace(/\r\n?/g, '\n') : string
->expected.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>expected.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >expected : string
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/\r\n?/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/\r\n?/g : RegExp</\r\n?/g>
 >'\n' : "\n"
 
                 actual = actual.replace(/\r\n?/g, '\n')
 >actual = actual.replace(/\r\n?/g, '\n') : string
 >actual : string
 >actual.replace(/\r\n?/g, '\n') : string
->actual.replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>actual.replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >actual : string
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/\r\n?/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/\r\n?/g : RegExp</\r\n?/g>
 >'\n' : "\n"
             }
 
diff --git a/tests/baselines/reference/primitiveMembers.types b/tests/baselines/reference/primitiveMembers.types
index cb2a6245dd0cc..35fa414a2dccd 100644
--- a/tests/baselines/reference/primitiveMembers.types
+++ b/tests/baselines/reference/primitiveMembers.types
@@ -4,12 +4,12 @@ var x = 5;
 >5 : 5
 
 var r = /yo/;
->r : RegExp
->/yo/ : RegExp
+>r : RegExp</yo/>
+>/yo/ : RegExp</yo/>
 
 r.source;
 >r.source : string
->r : RegExp
+>r : RegExp</yo/>
 >source : string
 
 x.toBAZ();
@@ -57,9 +57,9 @@ var f: Function = (x: string) => x.length;
 >length : number
 
 var r2: RegExp = /./g;
->r2 : RegExp
->RegExp : RegExp
->/./g : RegExp
+>r2 : RegExp<string>
+>RegExp : RegExp<T>
+>/./g : RegExp</./g>
 
 var n2: Number = 34;
 >n2 : Number
diff --git a/tests/baselines/reference/regExpWithSlashInCharClass.types b/tests/baselines/reference/regExpWithSlashInCharClass.types
index 1c980ca8d8bcb..b0f00cdd06a94 100644
--- a/tests/baselines/reference/regExpWithSlashInCharClass.types
+++ b/tests/baselines/reference/regExpWithSlashInCharClass.types
@@ -2,27 +2,27 @@
 var foo1 = "a/".replace(/.[/]/, "");
 >foo1 : string
 >"a/".replace(/.[/]/, "") : string
->"a/".replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>"a/".replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >"a/" : "a/"
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/.[/]/ : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/.[/]/ : RegExp</.[/]/>
 >"" : ""
 
 var foo2 = "a//".replace(/.[//]/g, "");
 >foo2 : string
 >"a//".replace(/.[//]/g, "") : string
->"a//".replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>"a//".replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >"a//" : "a//"
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/.[//]/g : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/.[//]/g : RegExp</.[//]/g>
 >"" : ""
 
 var foo3 = "a/".replace(/.[/no sleep /till/]/, "bugfix");
 >foo3 : string
 >"a/".replace(/.[/no sleep /till/]/, "bugfix") : string
->"a/".replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
+>"a/".replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
 >"a/" : "a/"
->replace : { (searchValue: string | RegExp, replaceValue: string): string; (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; }
->/.[/no sleep /till/]/ : RegExp
+>replace : { (searchValue: string | RegExp<string>, replaceValue: string): string; (searchValue: string | RegExp<string>, replacer: (substring: string, ...args: any[]) => string): string; }
+>/.[/no sleep /till/]/ : RegExp</.[/no sleep /till/]/>
 >"bugfix" : "bugfix"
 
diff --git a/tests/baselines/reference/regexValidated.controlFlow.js b/tests/baselines/reference/regexValidated.controlFlow.js
new file mode 100644
index 0000000000000..62d54af2ea3b1
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.controlFlow.js
@@ -0,0 +1,44 @@
+//// [regexValidated.controlFlow.ts]
+const isA = /a/i;
+let mustBeA: /a/i;
+declare var s: string;
+if (isA.test(s)) {
+    mustBeA = s;
+}
+
+const isB = /b/i;
+let mustBeB: /b/i;
+if (isB.test(s)) {
+    mustBeB = s;
+}
+
+let mustBeBOrA: /b/i | /a/i;
+if (isB.test(s) || isA.test(s)) {
+    mustBeBOrA = s;
+}
+
+let mustBeBAndA: /b/i & /a/i;
+if (isB.test(s) && isA.test(s)) {
+    mustBeBOrA = s;
+}
+
+
+//// [regexValidated.controlFlow.js]
+var isA = /a/i;
+var mustBeA;
+if (isA.test(s)) {
+    mustBeA = s;
+}
+var isB = /b/i;
+var mustBeB;
+if (isB.test(s)) {
+    mustBeB = s;
+}
+var mustBeBOrA;
+if (isB.test(s) || isA.test(s)) {
+    mustBeBOrA = s;
+}
+var mustBeBAndA;
+if (isB.test(s) && isA.test(s)) {
+    mustBeBOrA = s;
+}
diff --git a/tests/baselines/reference/regexValidated.controlFlow.symbols b/tests/baselines/reference/regexValidated.controlFlow.symbols
new file mode 100644
index 0000000000000..50fc2818efe3e
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.controlFlow.symbols
@@ -0,0 +1,74 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts ===
+const isA = /a/i;
+>isA : Symbol(isA, Decl(regexValidated.controlFlow.ts, 0, 5))
+
+let mustBeA: /a/i;
+>mustBeA : Symbol(mustBeA, Decl(regexValidated.controlFlow.ts, 1, 3))
+
+declare var s: string;
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+
+if (isA.test(s)) {
+>isA.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>isA : Symbol(isA, Decl(regexValidated.controlFlow.ts, 0, 5))
+>test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+
+    mustBeA = s;
+>mustBeA : Symbol(mustBeA, Decl(regexValidated.controlFlow.ts, 1, 3))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+}
+
+const isB = /b/i;
+>isB : Symbol(isB, Decl(regexValidated.controlFlow.ts, 7, 5))
+
+let mustBeB: /b/i;
+>mustBeB : Symbol(mustBeB, Decl(regexValidated.controlFlow.ts, 8, 3))
+
+if (isB.test(s)) {
+>isB.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>isB : Symbol(isB, Decl(regexValidated.controlFlow.ts, 7, 5))
+>test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+
+    mustBeB = s;
+>mustBeB : Symbol(mustBeB, Decl(regexValidated.controlFlow.ts, 8, 3))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+}
+
+let mustBeBOrA: /b/i | /a/i;
+>mustBeBOrA : Symbol(mustBeBOrA, Decl(regexValidated.controlFlow.ts, 13, 3))
+
+if (isB.test(s) || isA.test(s)) {
+>isB.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>isB : Symbol(isB, Decl(regexValidated.controlFlow.ts, 7, 5))
+>test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+>isA.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>isA : Symbol(isA, Decl(regexValidated.controlFlow.ts, 0, 5))
+>test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+
+    mustBeBOrA = s;
+>mustBeBOrA : Symbol(mustBeBOrA, Decl(regexValidated.controlFlow.ts, 13, 3))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+}
+
+let mustBeBAndA: /b/i & /a/i;
+>mustBeBAndA : Symbol(mustBeBAndA, Decl(regexValidated.controlFlow.ts, 18, 3))
+
+if (isB.test(s) && isA.test(s)) {
+>isB.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>isB : Symbol(isB, Decl(regexValidated.controlFlow.ts, 7, 5))
+>test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+>isA.test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>isA : Symbol(isA, Decl(regexValidated.controlFlow.ts, 0, 5))
+>test : Symbol(RegExp.test, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+
+    mustBeBOrA = s;
+>mustBeBOrA : Symbol(mustBeBOrA, Decl(regexValidated.controlFlow.ts, 13, 3))
+>s : Symbol(s, Decl(regexValidated.controlFlow.ts, 2, 11))
+}
+
diff --git a/tests/baselines/reference/regexValidated.controlFlow.types b/tests/baselines/reference/regexValidated.controlFlow.types
new file mode 100644
index 0000000000000..eca0e2b1e0bf5
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.controlFlow.types
@@ -0,0 +1,94 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts ===
+const isA = /a/i;
+>isA : RegExp</a/i>
+>/a/i : RegExp</a/i>
+
+let mustBeA: /a/i;
+>mustBeA : /a/i
+>/a/i : RegExp</a/i>
+
+declare var s: string;
+>s : string
+
+if (isA.test(s)) {
+>isA.test(s) : boolean
+>isA.test : (string: string) => string is /a/i
+>isA : RegExp</a/i>
+>test : (string: string) => string is /a/i
+>s : string
+
+    mustBeA = s;
+>mustBeA = s : /a/i
+>mustBeA : /a/i
+>s : /a/i
+}
+
+const isB = /b/i;
+>isB : RegExp</b/i>
+>/b/i : RegExp</b/i>
+
+let mustBeB: /b/i;
+>mustBeB : /b/i
+>/b/i : RegExp</b/i>
+
+if (isB.test(s)) {
+>isB.test(s) : boolean
+>isB.test : (string: string) => string is /b/i
+>isB : RegExp</b/i>
+>test : (string: string) => string is /b/i
+>s : string
+
+    mustBeB = s;
+>mustBeB = s : /b/i
+>mustBeB : /b/i
+>s : /b/i
+}
+
+let mustBeBOrA: /b/i | /a/i;
+>mustBeBOrA : /a/i | /b/i
+>/b/i : RegExp</b/i>
+>/a/i : RegExp</a/i>
+
+if (isB.test(s) || isA.test(s)) {
+>isB.test(s) || isA.test(s) : boolean
+>isB.test(s) : boolean
+>isB.test : (string: string) => string is /b/i
+>isB : RegExp</b/i>
+>test : (string: string) => string is /b/i
+>s : string
+>isA.test(s) : boolean
+>isA.test : (string: string) => string is /a/i
+>isA : RegExp</a/i>
+>test : (string: string) => string is /a/i
+>s : string
+
+    mustBeBOrA = s;
+>mustBeBOrA = s : /a/i | /b/i
+>mustBeBOrA : /a/i | /b/i
+>s : /a/i | /b/i
+}
+
+let mustBeBAndA: /b/i & /a/i;
+>mustBeBAndA : /b/i & /a/i
+>/b/i : RegExp</b/i>
+>/a/i : RegExp</a/i>
+
+if (isB.test(s) && isA.test(s)) {
+>isB.test(s) && isA.test(s) : boolean
+>isB.test(s) : boolean
+>isB.test : (string: string) => string is /b/i
+>isB : RegExp</b/i>
+>test : (string: string) => string is /b/i
+>s : string
+>isA.test(s) : boolean
+>isA.test : (string: string) => string is /a/i
+>isA : RegExp</a/i>
+>test : (string: string) => string is /a/i
+>s : /b/i
+
+    mustBeBOrA = s;
+>mustBeBOrA = s : /b/i & /a/i
+>mustBeBOrA : /a/i | /b/i
+>s : /b/i & /a/i
+}
+
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.js b/tests/baselines/reference/regexValidated.stringLiterals.js
new file mode 100644
index 0000000000000..5797442ad4dea
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.js
@@ -0,0 +1,25 @@
+//// [regexValidated.stringLiterals.ts]
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#000';
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fish,cat';
+
+let digits: /^[0-9]+$/ = '02338374729';
+
+let hexDigits: /^([0-9]|[A-F])+$/ = '0F12A';
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+let address: Email = 'typescript@microsoft.com';
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+let gmailAddress: Gmail = 'example@GMAIL.COM';
+
+
+
+
+//// [regexValidated.stringLiterals.js]
+var fontColor = '#000';
+var catdogfish = 'cat,fish,dog,fish,cat';
+var digits = '02338374729';
+var hexDigits = '0F12A';
+var address = 'typescript@microsoft.com';
+var gmailAddress = 'example@GMAIL.COM';
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt b/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt
new file mode 100644
index 0000000000000..89fd7acf7c86b
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt
@@ -0,0 +1,37 @@
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(1,5): error TS2322: Type '"#0000"' is not assignable to type '/^#([0-9a-f]{3}|[0-9a-f]{6})$/i'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(3,5): error TS2322: Type '"cat,fish,dog,fosh,cat"' is not assignable to type '/^(dog|cat|fish)(,(dog|cat|fish))*$/'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(5,5): error TS2322: Type '"02338374729O"' is not assignable to type '/^[0-9]+$/'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(7,5): error TS2322: Type '"X0F12A"' is not assignable to type '/^([0-9]|[A-F])+$/'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(10,5): error TS2322: Type '"type★script@microsoft.com"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(13,5): error TS2322: Type '"example@GMAIL.ORG"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i'.
+
+
+==== tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts (6 errors) ====
+    let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#0000'; // not 3 or 6 characters
+        ~~~~~~~~~
+!!! error TS2322: Type '"#0000"' is not assignable to type '/^#([0-9a-f]{3}|[0-9a-f]{6})$/i'.
+    
+    let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fosh,cat'; // misspelled fish
+        ~~~~~~~~~~
+!!! error TS2322: Type '"cat,fish,dog,fosh,cat"' is not assignable to type '/^(dog|cat|fish)(,(dog|cat|fish))*$/'.
+    
+    let digits: /^[0-9]+$/ = '02338374729O'; // Capital O isn't 0
+        ~~~~~~
+!!! error TS2322: Type '"02338374729O"' is not assignable to type '/^[0-9]+$/'.
+    
+    let hexDigits: /^([0-9]|[A-F])+$/ = 'X0F12A'; // X isn't a hex digit
+        ~~~~~~~~~
+!!! error TS2322: Type '"X0F12A"' is not assignable to type '/^([0-9]|[A-F])+$/'.
+    
+    type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+    let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
+        ~~~~~~~
+!!! error TS2322: Type '"type★script@microsoft.com"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i'.
+    
+    type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+    let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
+        ~~~~~~~~~~~~
+!!! error TS2322: Type '"example@GMAIL.ORG"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i'.
+    
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.negative.js b/tests/baselines/reference/regexValidated.stringLiterals.negative.js
new file mode 100644
index 0000000000000..5dc04b247aea1
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.negative.js
@@ -0,0 +1,25 @@
+//// [regexValidated.stringLiterals.negative.ts]
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#0000'; // not 3 or 6 characters
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fosh,cat'; // misspelled fish
+
+let digits: /^[0-9]+$/ = '02338374729O'; // Capital O isn't 0
+
+let hexDigits: /^([0-9]|[A-F])+$/ = 'X0F12A'; // X isn't a hex digit
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
+
+
+
+
+//// [regexValidated.stringLiterals.negative.js]
+var fontColor = '#0000'; // not 3 or 6 characters
+var catdogfish = 'cat,fish,dog,fosh,cat'; // misspelled fish
+var digits = '02338374729O'; // Capital O isn't 0
+var hexDigits = 'X0F12A'; // X isn't a hex digit
+var address = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
+var gmailAddress = 'example@GMAIL.ORG'; // wrong tld
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.negative.symbols b/tests/baselines/reference/regexValidated.stringLiterals.negative.symbols
new file mode 100644
index 0000000000000..8234f44e90ac4
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.negative.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts ===
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#0000'; // not 3 or 6 characters
+>fontColor : Symbol(fontColor, Decl(regexValidated.stringLiterals.negative.ts, 0, 3))
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fosh,cat'; // misspelled fish
+>catdogfish : Symbol(catdogfish, Decl(regexValidated.stringLiterals.negative.ts, 2, 3))
+
+let digits: /^[0-9]+$/ = '02338374729O'; // Capital O isn't 0
+>digits : Symbol(digits, Decl(regexValidated.stringLiterals.negative.ts, 4, 3))
+
+let hexDigits: /^([0-9]|[A-F])+$/ = 'X0F12A'; // X isn't a hex digit
+>hexDigits : Symbol(hexDigits, Decl(regexValidated.stringLiterals.negative.ts, 6, 3))
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+>Email : Symbol(Email, Decl(regexValidated.stringLiterals.negative.ts, 6, 45))
+
+let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
+>address : Symbol(address, Decl(regexValidated.stringLiterals.negative.ts, 9, 3))
+>Email : Symbol(Email, Decl(regexValidated.stringLiterals.negative.ts, 6, 45))
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+>Gmail : Symbol(Gmail, Decl(regexValidated.stringLiterals.negative.ts, 9, 49))
+
+let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
+>gmailAddress : Symbol(gmailAddress, Decl(regexValidated.stringLiterals.negative.ts, 12, 3))
+>Gmail : Symbol(Gmail, Decl(regexValidated.stringLiterals.negative.ts, 9, 49))
+
+
+
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.negative.types b/tests/baselines/reference/regexValidated.stringLiterals.negative.types
new file mode 100644
index 0000000000000..cda4f443e501e
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.negative.types
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts ===
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#0000'; // not 3 or 6 characters
+>fontColor : /^#([0-9a-f]{3}|[0-9a-f]{6})$/i
+>/^#([0-9a-f]{3}|[0-9a-f]{6})$/i : RegExp</^#([0-9a-f]{3}|[0-9a-f]{6})$/i>
+>'#0000' : "#0000"
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fosh,cat'; // misspelled fish
+>catdogfish : /^(dog|cat|fish)(,(dog|cat|fish))*$/
+>/^(dog|cat|fish)(,(dog|cat|fish))*$/ : RegExp</^(dog|cat|fish)(,(dog|cat|fish))*$/>
+>'cat,fish,dog,fosh,cat' : "cat,fish,dog,fosh,cat"
+
+let digits: /^[0-9]+$/ = '02338374729O'; // Capital O isn't 0
+>digits : /^[0-9]+$/
+>/^[0-9]+$/ : RegExp</^[0-9]+$/>
+>'02338374729O' : "02338374729O"
+
+let hexDigits: /^([0-9]|[A-F])+$/ = 'X0F12A'; // X isn't a hex digit
+>hexDigits : /^([0-9]|[A-F])+$/
+>/^([0-9]|[A-F])+$/ : RegExp</^([0-9]|[A-F])+$/>
+>'X0F12A' : "X0F12A"
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+>Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i>
+
+let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
+>address : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>'type★script@microsoft.com' : "type★script@microsoft.com"
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+>Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i>
+
+let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
+>gmailAddress : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>'example@GMAIL.ORG' : "example@GMAIL.ORG"
+
+
+
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.symbols b/tests/baselines/reference/regexValidated.stringLiterals.symbols
new file mode 100644
index 0000000000000..85d8ac63e0c7a
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts ===
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#000';
+>fontColor : Symbol(fontColor, Decl(regexValidated.stringLiterals.ts, 0, 3))
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fish,cat';
+>catdogfish : Symbol(catdogfish, Decl(regexValidated.stringLiterals.ts, 2, 3))
+
+let digits: /^[0-9]+$/ = '02338374729';
+>digits : Symbol(digits, Decl(regexValidated.stringLiterals.ts, 4, 3))
+
+let hexDigits: /^([0-9]|[A-F])+$/ = '0F12A';
+>hexDigits : Symbol(hexDigits, Decl(regexValidated.stringLiterals.ts, 6, 3))
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+>Email : Symbol(Email, Decl(regexValidated.stringLiterals.ts, 6, 44))
+
+let address: Email = 'typescript@microsoft.com';
+>address : Symbol(address, Decl(regexValidated.stringLiterals.ts, 9, 3))
+>Email : Symbol(Email, Decl(regexValidated.stringLiterals.ts, 6, 44))
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+>Gmail : Symbol(Gmail, Decl(regexValidated.stringLiterals.ts, 9, 48))
+
+let gmailAddress: Gmail = 'example@GMAIL.COM';
+>gmailAddress : Symbol(gmailAddress, Decl(regexValidated.stringLiterals.ts, 12, 3))
+>Gmail : Symbol(Gmail, Decl(regexValidated.stringLiterals.ts, 9, 48))
+
+
+
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.types b/tests/baselines/reference/regexValidated.stringLiterals.types
new file mode 100644
index 0000000000000..529713cf4650b
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.stringLiterals.types
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts ===
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#000';
+>fontColor : /^#([0-9a-f]{3}|[0-9a-f]{6})$/i
+>/^#([0-9a-f]{3}|[0-9a-f]{6})$/i : RegExp</^#([0-9a-f]{3}|[0-9a-f]{6})$/i>
+>'#000' : "#000"
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fish,cat';
+>catdogfish : /^(dog|cat|fish)(,(dog|cat|fish))*$/
+>/^(dog|cat|fish)(,(dog|cat|fish))*$/ : RegExp</^(dog|cat|fish)(,(dog|cat|fish))*$/>
+>'cat,fish,dog,fish,cat' : "cat,fish,dog,fish,cat"
+
+let digits: /^[0-9]+$/ = '02338374729';
+>digits : /^[0-9]+$/
+>/^[0-9]+$/ : RegExp</^[0-9]+$/>
+>'02338374729' : "02338374729"
+
+let hexDigits: /^([0-9]|[A-F])+$/ = '0F12A';
+>hexDigits : /^([0-9]|[A-F])+$/
+>/^([0-9]|[A-F])+$/ : RegExp</^([0-9]|[A-F])+$/>
+>'0F12A' : "0F12A"
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+>Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i>
+
+let address: Email = 'typescript@microsoft.com';
+>address : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>'typescript@microsoft.com' : "typescript@microsoft.com"
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+>Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i>
+
+let gmailAddress: Gmail = 'example@GMAIL.COM';
+>gmailAddress : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>'example@GMAIL.COM' : "example@GMAIL.COM"
+
+
+
diff --git a/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt b/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt
new file mode 100644
index 0000000000000..956dafb4d8a19
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts(1,5): error TS2322: Type '"a"' is not assignable to type '/a/l'.
+
+
+==== tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts (1 errors) ====
+    let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
+        ~
+!!! error TS2322: Type '"a"' is not assignable to type '/a/l'.
+    
+    let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/regexValidated.unsupportedFlags.js b/tests/baselines/reference/regexValidated.unsupportedFlags.js
new file mode 100644
index 0000000000000..e59fa22e85b95
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.unsupportedFlags.js
@@ -0,0 +1,9 @@
+//// [regexValidated.unsupportedFlags.ts]
+let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
+
+let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
+
+
+//// [regexValidated.unsupportedFlags.js]
+var a = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
+var b = "b"; // Should be fine, cast can work around inoperable flags
diff --git a/tests/baselines/reference/regexValidated.unsupportedFlags.symbols b/tests/baselines/reference/regexValidated.unsupportedFlags.symbols
new file mode 100644
index 0000000000000..fdbfc6c0e21ad
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.unsupportedFlags.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts ===
+let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
+>a : Symbol(a, Decl(regexValidated.unsupportedFlags.ts, 0, 3))
+
+let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
+>b : Symbol(b, Decl(regexValidated.unsupportedFlags.ts, 2, 3))
+
diff --git a/tests/baselines/reference/regexValidated.unsupportedFlags.types b/tests/baselines/reference/regexValidated.unsupportedFlags.types
new file mode 100644
index 0000000000000..7c16570d924d2
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.unsupportedFlags.types
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts ===
+let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
+>a : /a/l
+>/a/l : RegExp</a/l>
+>"a" : "a"
+
+let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
+>b : /b/l
+>/b/l : RegExp</b/l>
+>"b" as /b/l : /b/l
+>"b" : "b"
+>/b/l : RegExp</b/l>
+
diff --git a/tests/baselines/reference/shebangError.types b/tests/baselines/reference/shebangError.types
index 41d5d02cda5f1..df8ae80a73bfe 100644
--- a/tests/baselines/reference/shebangError.types
+++ b/tests/baselines/reference/shebangError.types
@@ -6,7 +6,7 @@ var foo = 'Shebang is only allowed on the first line';
 #!/usr/bin/env node
 >!/usr/bin/env : number
 >!/usr/bin : boolean
->/usr/bin : RegExp
+>/usr/bin : RegExp</usr/bin>
 >env : any
 >node : any
 
diff --git a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types
index e518547617350..85fb45d523c6a 100644
--- a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types
+++ b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.types
@@ -91,16 +91,16 @@ function f7(x: any) { }
 >x : any
 
 function f8(x: 'a');
->f8 : { (x: "a"): any; (x: RegExp): any; }
+>f8 : { (x: "a"): any; (x: RegExp<string>): any; }
 >x : "a"
 
 function f8(x: RegExp);
->f8 : { (x: "a"): any; (x: RegExp): any; }
->x : RegExp
->RegExp : RegExp
+>f8 : { (x: "a"): any; (x: RegExp<string>): any; }
+>x : RegExp<string>
+>RegExp : RegExp<T>
 
 function f8(x: any) { }
->f8 : { (x: "a"): any; (x: RegExp): any; }
+>f8 : { (x: "a"): any; (x: RegExp<string>): any; }
 >x : any
 
 function f9(x: 'a');
diff --git a/tests/baselines/reference/subtypesOfAny.types b/tests/baselines/reference/subtypesOfAny.types
index aebe77df12e6a..8d4427c0648d9 100644
--- a/tests/baselines/reference/subtypesOfAny.types
+++ b/tests/baselines/reference/subtypesOfAny.types
@@ -64,8 +64,8 @@ interface I6 {
 >x : string
 
     foo: RegExp;
->foo : RegExp
->RegExp : RegExp
+>foo : RegExp<string>
+>RegExp : RegExp<T>
 }
 
 
diff --git a/tests/baselines/reference/subtypesOfTypeParameter.types b/tests/baselines/reference/subtypesOfTypeParameter.types
index 58af856e15074..5c90318ea2b11 100644
--- a/tests/baselines/reference/subtypesOfTypeParameter.types
+++ b/tests/baselines/reference/subtypesOfTypeParameter.types
@@ -187,18 +187,18 @@ function f2<T, U>(x: T, y: U) {
 >Date : DateConstructor
 
     var r5 = true ? /1/ : x;
->r5 : RegExp | T
->true ? /1/ : x : RegExp | T
+>r5 : T | RegExp</1/>
+>true ? /1/ : x : T | RegExp</1/>
 >true : true
->/1/ : RegExp
+>/1/ : RegExp</1/>
 >x : T
 
     var r5 = true ? x : /1/;
->r5 : RegExp | T
->true ? x : /1/ : RegExp | T
+>r5 : T | RegExp</1/>
+>true ? x : /1/ : T | RegExp</1/>
 >true : true
 >x : T
->/1/ : RegExp
+>/1/ : RegExp</1/>
 
     var r6 = true ? { foo: 1 } : x;
 >r6 : T | { foo: number; }
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.types b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.types
index e2f294343a573..bcd3228679bcd 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.types
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.types
@@ -319,25 +319,25 @@ function f8<T extends Date>(x: T) {
 }
 
 function f9<T extends RegExp>(x: T) {
->f9 : <T extends RegExp>(x: T) => void
+>f9 : <T extends RegExp<string>>(x: T) => void
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >x : T
 >T : T
 
     var r5 = true ? /1/ : x; // ok
->r5 : RegExp
->true ? /1/ : x : RegExp
+>r5 : T | RegExp</1/>
+>true ? /1/ : x : T | RegExp</1/>
 >true : true
->/1/ : RegExp
+>/1/ : RegExp</1/>
 >x : T
 
     var r5 = true ? x : /1/; // ok
->r5 : RegExp
->true ? x : /1/ : RegExp
+>r5 : T | RegExp</1/>
+>true ? x : /1/ : T | RegExp</1/>
 >true : true
 >x : T
->/1/ : RegExp
+>/1/ : RegExp</1/>
 }
 
 function f10<T extends { foo: number }>(x: T) {
diff --git a/tests/baselines/reference/subtypesOfUnion.errors.txt b/tests/baselines/reference/subtypesOfUnion.errors.txt
index 7cbca6cc409ec..37679fb84b983 100644
--- a/tests/baselines/reference/subtypesOfUnion.errors.txt
+++ b/tests/baselines/reference/subtypesOfUnion.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(16,5): error TS2411: Property 'foo4' of type 'boolean' is not assignable to string index type 'string | number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(18,5): error TS2411: Property 'foo6' of type 'Date' is not assignable to string index type 'string | number'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(19,5): error TS2411: Property 'foo7' of type 'RegExp' is not assignable to string index type 'string | number'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(19,5): error TS2411: Property 'foo7' of type 'RegExp<string>' is not assignable to string index type 'string | number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(20,5): error TS2411: Property 'foo8' of type '{ bar: number; }' is not assignable to string index type 'string | number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(21,5): error TS2411: Property 'foo9' of type 'I8' is not assignable to string index type 'string | number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(22,5): error TS2411: Property 'foo10' of type 'A' is not assignable to string index type 'string | number'.
@@ -15,7 +15,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(35,5): error TS2411: Property 'foo2' of type 'string' is not assignable to string index type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(37,5): error TS2411: Property 'foo4' of type 'boolean' is not assignable to string index type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(39,5): error TS2411: Property 'foo6' of type 'Date' is not assignable to string index type 'number'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(40,5): error TS2411: Property 'foo7' of type 'RegExp' is not assignable to string index type 'number'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(40,5): error TS2411: Property 'foo7' of type 'RegExp<string>' is not assignable to string index type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(41,5): error TS2411: Property 'foo8' of type '{ bar: number; }' is not assignable to string index type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(42,5): error TS2411: Property 'foo9' of type 'I8' is not assignable to string index type 'number'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfUnion.ts(43,5): error TS2411: Property 'foo10' of type 'A' is not assignable to string index type 'number'.
@@ -54,7 +54,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 !!! error TS2411: Property 'foo6' of type 'Date' is not assignable to string index type 'string | number'.
         foo7: RegExp; // error
         ~~~~~~~~~~~~~
-!!! error TS2411: Property 'foo7' of type 'RegExp' is not assignable to string index type 'string | number'.
+!!! error TS2411: Property 'foo7' of type 'RegExp<string>' is not assignable to string index type 'string | number'.
         foo8: { bar: number }; // error
         ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2411: Property 'foo8' of type '{ bar: number; }' is not assignable to string index type 'string | number'.
@@ -105,7 +105,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 !!! error TS2411: Property 'foo6' of type 'Date' is not assignable to string index type 'number'.
         foo7: RegExp; // error
         ~~~~~~~~~~~~~
-!!! error TS2411: Property 'foo7' of type 'RegExp' is not assignable to string index type 'number'.
+!!! error TS2411: Property 'foo7' of type 'RegExp<string>' is not assignable to string index type 'number'.
         foo8: { bar: number }; // error
         ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2411: Property 'foo8' of type '{ bar: number; }' is not assignable to string index type 'number'.
diff --git a/tests/baselines/reference/subtypesOfUnion.types b/tests/baselines/reference/subtypesOfUnion.types
index 02fdd298be1c1..fe07324565ec3 100644
--- a/tests/baselines/reference/subtypesOfUnion.types
+++ b/tests/baselines/reference/subtypesOfUnion.types
@@ -64,8 +64,8 @@ interface I1<T> {
 >Date : Date
 
     foo7: RegExp; // error
->foo7 : RegExp
->RegExp : RegExp
+>foo7 : RegExp<string>
+>RegExp : RegExp<T>
 
     foo8: { bar: number }; // error
 >foo8 : { bar: number; }
@@ -142,8 +142,8 @@ interface I2<T> {
 >Date : Date
 
     foo7: RegExp; // error
->foo7 : RegExp
->RegExp : RegExp
+>foo7 : RegExp<string>
+>RegExp : RegExp<T>
 
     foo8: { bar: number }; // error
 >foo8 : { bar: number; }
diff --git a/tests/baselines/reference/switchStatements.types b/tests/baselines/reference/switchStatements.types
index ea768bf8b2632..ee7fbec81238f 100644
--- a/tests/baselines/reference/switchStatements.types
+++ b/tests/baselines/reference/switchStatements.types
@@ -42,7 +42,7 @@ switch (x) {
 >Object : ObjectConstructor
 
     case /[a-z]/:
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
     case[]:
 >[] : undefined[]
@@ -147,7 +147,7 @@ switch (new Object()) { }
 >Object : ObjectConstructor
 
 switch (/[a-z]/) { }
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
 switch ([]) { }
 >[] : undefined[]
diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types
index 9ad2d954f27d6..2d3ec3fd84433 100644
--- a/tests/baselines/reference/throwStatements.types
+++ b/tests/baselines/reference/throwStatements.types
@@ -246,7 +246,7 @@ throw ['a', ['b']];
 >'b' : "b"
 
 throw /[a-z]/;
->/[a-z]/ : RegExp
+>/[a-z]/ : RegExp</[a-z]/>
 
 throw new Date();
 >new Date() : Date
diff --git a/tests/baselines/reference/tsxAttributeInvalidNames.types b/tests/baselines/reference/tsxAttributeInvalidNames.types
index 540d7a1367b8e..dbdb87d0e6163 100644
--- a/tests/baselines/reference/tsxAttributeInvalidNames.types
+++ b/tests/baselines/reference/tsxAttributeInvalidNames.types
@@ -36,5 +36,5 @@ declare module JSX {
 >test2 : any
 >data : any
 >32 : 32
->/>; : RegExp
+>/>; : RegExp</>;>
 
diff --git a/tests/baselines/reference/typeGuardsNestedAssignments.types b/tests/baselines/reference/typeGuardsNestedAssignments.types
index 6918ed76ca656..642d83af98643 100644
--- a/tests/baselines/reference/typeGuardsNestedAssignments.types
+++ b/tests/baselines/reference/typeGuardsNestedAssignments.types
@@ -118,8 +118,8 @@ function f4() {
 // Repro from #8851
 
 const re = /./g
->re : RegExp
->/./g : RegExp
+>re : RegExp</./g>
+>/./g : RegExp</./g>
 
 let match: RegExpExecArray | null
 >match : RegExpExecArray | null
@@ -133,7 +133,7 @@ while ((match = re.exec("xxx")) != null) {
 >match : RegExpExecArray | null
 >re.exec("xxx") : RegExpExecArray | null
 >re.exec : (string: string) => RegExpExecArray | null
->re : RegExp
+>re : RegExp</./g>
 >exec : (string: string) => RegExpExecArray | null
 >"xxx" : "xxx"
 >null : null
diff --git a/tests/baselines/reference/typeGuardsWithInstanceOf.types b/tests/baselines/reference/typeGuardsWithInstanceOf.types
index 7fce8cd45594e..e50ccb0e8c03e 100644
--- a/tests/baselines/reference/typeGuardsWithInstanceOf.types
+++ b/tests/baselines/reference/typeGuardsWithInstanceOf.types
@@ -26,6 +26,6 @@ if (!(result instanceof RegExp)) {
 } else if (!result.global) {
 >!result.global : boolean
 >result.global : (string & true) | (string & false)
->result : I & RegExp
+>result : I & RegExp<string>
 >global : (string & true) | (string & false)
 }
diff --git a/tests/baselines/reference/typeParameterConstraints1.types b/tests/baselines/reference/typeParameterConstraints1.types
index 26d4f0efb22bd..61bbb212f49f8 100644
--- a/tests/baselines/reference/typeParameterConstraints1.types
+++ b/tests/baselines/reference/typeParameterConstraints1.types
@@ -25,9 +25,9 @@ function foo4<T extends Date>(test: T) { } // valid
 >T : T
 
 function foo5<T extends RegExp>(test: T) { } // valid
->foo5 : <T extends RegExp>(test: T) => void
+>foo5 : <T extends RegExp<string>>(test: T) => void
 >T : T
->RegExp : RegExp
+>RegExp : RegExp<T>
 >test : T
 >T : T
 
diff --git a/tests/baselines/reference/undefinedIsSubtypeOfEverything.types b/tests/baselines/reference/undefinedIsSubtypeOfEverything.types
index c52b7b6211461..860f9aa01f165 100644
--- a/tests/baselines/reference/undefinedIsSubtypeOfEverything.types
+++ b/tests/baselines/reference/undefinedIsSubtypeOfEverything.types
@@ -85,8 +85,8 @@ class D4 extends Base {
 >Base : Base
 
     foo: RegExp;
->foo : RegExp
->RegExp : RegExp
+>foo : RegExp<string>
+>RegExp : RegExp<T>
 }
 
 class D5 extends Base {
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 8c6b2691e4ed6..1e3b5a960d3db 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -1449,7 +1449,7 @@ _.isRegExp(/moe/);
 >_.isRegExp : (object: any) => boolean
 >_ : Underscore.Static
 >isRegExp : (object: any) => boolean
->/moe/ : RegExp
+>/moe/ : RegExp</moe/>
 
 _.isNaN(NaN);
 >_.isNaN(NaN) : boolean
@@ -1688,15 +1688,15 @@ compiled2({ epithet: "stooge" });
 >"stooge" : "stooge"
 
 _.templateSettings = {
->_.templateSettings = {    interpolate: /\{\{(.+?)\}\}/g} : { interpolate: RegExp; }
+>_.templateSettings = {    interpolate: /\{\{(.+?)\}\}/g} : { interpolate: RegExp</\{\{(.+?)\}\}/g>; }
 >_.templateSettings : Underscore.TemplateSettings
 >_ : Underscore.Static
 >templateSettings : Underscore.TemplateSettings
->{    interpolate: /\{\{(.+?)\}\}/g} : { interpolate: RegExp; }
+>{    interpolate: /\{\{(.+?)\}\}/g} : { interpolate: RegExp</\{\{(.+?)\}\}/g>; }
 
     interpolate: /\{\{(.+?)\}\}/g
->interpolate : RegExp
->/\{\{(.+?)\}\}/g : RegExp
+>interpolate : RegExp</\{\{(.+?)\}\}/g>
+>/\{\{(.+?)\}\}/g : RegExp</\{\{(.+?)\}\}/g>
 
 };
 var template2 = _.template("Hello {{ name }}!");
@@ -4061,16 +4061,16 @@ module Underscore {
 >TemplateSettings : TemplateSettings
 
         evaluate?: RegExp;
->evaluate : RegExp
->RegExp : RegExp
+>evaluate : RegExp<string>
+>RegExp : RegExp<T>
 
         interpolate?: RegExp;
->interpolate : RegExp
->RegExp : RegExp
+>interpolate : RegExp<string>
+>RegExp : RegExp<T>
 
         escape?: RegExp;
->escape : RegExp
->RegExp : RegExp
+>escape : RegExp<string>
+>RegExp : RegExp<T>
 
         variable?: string;
 >variable : string
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES5.types
index 2bd61d0010c43..4f6f7cf031cd7 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions01_ES5.ts ===
 var x = /\u{0}/g;
->x : RegExp
->/\u{0}/g : RegExp
+>x : RegExp</\u{0}/g>
+>/\u{0}/g : RegExp</\u{0}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES6.types
index 52446e6de5436..0aa9c84e84cfb 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions01_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions01_ES6.ts ===
 var x = /\u{0}/g;
->x : RegExp
->/\u{0}/g : RegExp
+>x : RegExp</\u{0}/g>
+>/\u{0}/g : RegExp</\u{0}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES5.types
index e57504cd1aece..4e7fa330311a6 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions02_ES5.ts ===
 var x = /\u{00}/g;
->x : RegExp
->/\u{00}/g : RegExp
+>x : RegExp</\u{00}/g>
+>/\u{00}/g : RegExp</\u{00}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES6.types
index 355e5fd61c435..8e850f616d828 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions02_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions02_ES6.ts ===
 var x = /\u{00}/g;
->x : RegExp
->/\u{00}/g : RegExp
+>x : RegExp</\u{00}/g>
+>/\u{00}/g : RegExp</\u{00}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES5.types
index 60e8f86bff49d..d8664e56c5368 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions03_ES5.ts ===
 var x = /\u{0000}/g;
->x : RegExp
->/\u{0000}/g : RegExp
+>x : RegExp</\u{0000}/g>
+>/\u{0000}/g : RegExp</\u{0000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES6.types
index b17f3b6d1aab6..ded423c1a47d7 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions03_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions03_ES6.ts ===
 var x = /\u{0000}/g;
->x : RegExp
->/\u{0000}/g : RegExp
+>x : RegExp</\u{0000}/g>
+>/\u{0000}/g : RegExp</\u{0000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES5.types
index d5075f696fedf..ef35ad7ebb804 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions04_ES5.ts ===
 var x = /\u{00000000}/g;
->x : RegExp
->/\u{00000000}/g : RegExp
+>x : RegExp</\u{00000000}/g>
+>/\u{00000000}/g : RegExp</\u{00000000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES6.types
index 483e24941606d..430913891474d 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions04_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions04_ES6.ts ===
 var x = /\u{00000000}/g;
->x : RegExp
->/\u{00000000}/g : RegExp
+>x : RegExp</\u{00000000}/g>
+>/\u{00000000}/g : RegExp</\u{00000000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES5.types
index 2a30e1783adc4..417e1bde60c04 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions05_ES5.ts ===
 var x = /\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g;
->x : RegExp
->/\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g : RegExp
+>x : RegExp</\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g>
+>/\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g : RegExp</\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES6.types
index ea9d70780f79c..de94b9dd9fe67 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions05_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions05_ES6.ts ===
 var x = /\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g;
->x : RegExp
->/\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g : RegExp
+>x : RegExp</\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g>
+>/\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g : RegExp</\u{48}\u{65}\u{6c}\u{6c}\u{6f}\u{20}\u{77}\u{6f}\u{72}\u{6c}\u{64}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES5.types
index 90720b648b7c0..58189d743d7bd 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES5.types
@@ -2,6 +2,6 @@
 // ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
 //  1. Assert: 0 ≤ cp ≤ 0x10FFFF.
 var x = /\u{10FFFF}/g;
->x : RegExp
->/\u{10FFFF}/g : RegExp
+>x : RegExp</\u{10FFFF}/g>
+>/\u{10FFFF}/g : RegExp</\u{10FFFF}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES6.types
index 398fe0a0f318f..fab04973653cb 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions06_ES6.types
@@ -2,6 +2,6 @@
 // ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
 //  1. Assert: 0 ≤ cp ≤ 0x10FFFF.
 var x = /\u{10FFFF}/g;
->x : RegExp
->/\u{10FFFF}/g : RegExp
+>x : RegExp</\u{10FFFF}/g>
+>/\u{10FFFF}/g : RegExp</\u{10FFFF}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES5.types
index 0190d46ac4dfc..277e2c211cce4 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES5.types
@@ -2,6 +2,6 @@
 // ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
 //  1. Assert: 0 ≤ cp ≤ 0x10FFFF.
 var x = /\u{110000}/g;
->x : RegExp
->/\u{110000}/g : RegExp
+>x : RegExp</\u{110000}/g>
+>/\u{110000}/g : RegExp</\u{110000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES6.types
index 9744d6f1190bb..50b38c6a430db 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions07_ES6.types
@@ -2,6 +2,6 @@
 // ES6 Spec - 10.1.1 Static Semantics: UTF16Encoding (cp)
 //  1. Assert: 0 ≤ cp ≤ 0x10FFFF.
 var x = /\u{110000}/g;
->x : RegExp
->/\u{110000}/g : RegExp
+>x : RegExp</\u{110000}/g>
+>/\u{110000}/g : RegExp</\u{110000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES5.types
index bb99cdf7ddf65..b27a2a34d55ae 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES5.types
@@ -3,6 +3,6 @@
 //  2. If cp ≤ 65535, return cp.
 // (FFFF == 65535)
 var x = /\u{FFFF}/g;
->x : RegExp
->/\u{FFFF}/g : RegExp
+>x : RegExp</\u{FFFF}/g>
+>/\u{FFFF}/g : RegExp</\u{FFFF}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES6.types
index 6520479bdc948..381c915e4fd97 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions08_ES6.types
@@ -3,6 +3,6 @@
 //  2. If cp ≤ 65535, return cp.
 // (FFFF == 65535)
 var x = /\u{FFFF}/g;
->x : RegExp
->/\u{FFFF}/g : RegExp
+>x : RegExp</\u{FFFF}/g>
+>/\u{FFFF}/g : RegExp</\u{FFFF}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES5.types
index 79a7c790c4fd2..bd4368c6287a8 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES5.types
@@ -3,6 +3,6 @@
 //  2. If cp ≤ 65535, return cp.
 // (10000 == 65536)
 var x = /\u{10000}/g;
->x : RegExp
->/\u{10000}/g : RegExp
+>x : RegExp</\u{10000}/g>
+>/\u{10000}/g : RegExp</\u{10000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES6.types
index 89726c02c2c11..5e37f07048f84 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions09_ES6.types
@@ -3,6 +3,6 @@
 //  2. If cp ≤ 65535, return cp.
 // (10000 == 65536)
 var x = /\u{10000}/g;
->x : RegExp
->/\u{10000}/g : RegExp
+>x : RegExp</\u{10000}/g>
+>/\u{10000}/g : RegExp</\u{10000}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES5.types
index 3ebd01bbe1b20..6e9f4f65defd1 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES5.types
@@ -4,6 +4,6 @@
 // Although we should just get back a single code point value of 0xD800,
 // this is a useful edge-case test.
 var x = /\u{D800}/g;
->x : RegExp
->/\u{D800}/g : RegExp
+>x : RegExp</\u{D800}/g>
+>/\u{D800}/g : RegExp</\u{D800}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES6.types
index 506ed072e341d..b476ee212af3c 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions10_ES6.types
@@ -4,6 +4,6 @@
 // Although we should just get back a single code point value of 0xD800,
 // this is a useful edge-case test.
 var x = /\u{D800}/g;
->x : RegExp
->/\u{D800}/g : RegExp
+>x : RegExp</\u{D800}/g>
+>/\u{D800}/g : RegExp</\u{D800}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES5.types
index faa61d0180910..0ecd96bb450d3 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES5.types
@@ -4,6 +4,6 @@
 // Although we should just get back a single code point value of 0xDC00,
 // this is a useful edge-case test.
 var x = /\u{DC00}/g;
->x : RegExp
->/\u{DC00}/g : RegExp
+>x : RegExp</\u{DC00}/g>
+>/\u{DC00}/g : RegExp</\u{DC00}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES6.types
index e94340f83f69e..afb6793276f8f 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions11_ES6.types
@@ -4,6 +4,6 @@
 // Although we should just get back a single code point value of 0xDC00,
 // this is a useful edge-case test.
 var x = /\u{DC00}/g;
->x : RegExp
->/\u{DC00}/g : RegExp
+>x : RegExp</\u{DC00}/g>
+>/\u{DC00}/g : RegExp</\u{DC00}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES5.types
index dfa5a09e61ec6..22fcbf1b8779c 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions12_ES5.ts ===
 var x = /\u{FFFFFFFF}/g;
->x : RegExp
->/\u{FFFFFFFF}/g : RegExp
+>x : RegExp</\u{FFFFFFFF}/g>
+>/\u{FFFFFFFF}/g : RegExp</\u{FFFFFFFF}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES6.types
index 32c2475266fbf..48babfdf95a8a 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions12_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions12_ES6.ts ===
 var x = /\u{FFFFFFFF}/g;
->x : RegExp
->/\u{FFFFFFFF}/g : RegExp
+>x : RegExp</\u{FFFFFFFF}/g>
+>/\u{FFFFFFFF}/g : RegExp</\u{FFFFFFFF}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES5.types
index 48990566053e4..c72bd2f720dc0 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions13_ES5.ts ===
 var x = /\u{DDDDD}/g;
->x : RegExp
->/\u{DDDDD}/g : RegExp
+>x : RegExp</\u{DDDDD}/g>
+>/\u{DDDDD}/g : RegExp</\u{DDDDD}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES6.types
index 33c204d5b4481..9e9eed13e8c19 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions13_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions13_ES6.ts ===
 var x = /\u{DDDDD}/g;
->x : RegExp
->/\u{DDDDD}/g : RegExp
+>x : RegExp</\u{DDDDD}/g>
+>/\u{DDDDD}/g : RegExp</\u{DDDDD}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES5.types
index c98a5370faf33..bdac60a93aa09 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES5.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions14_ES5.ts ===
 // Shouldn't work, negatives are not allowed.
 var x = /\u{-DDDD}/g;
->x : RegExp
->/\u{-DDDD}/g : RegExp
+>x : RegExp</\u{-DDDD}/g>
+>/\u{-DDDD}/g : RegExp</\u{-DDDD}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES6.types
index 58e7f15d7b89f..48ba8d9aedf08 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions14_ES6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions14_ES6.ts ===
 // Shouldn't work, negatives are not allowed.
 var x = /\u{-DDDD}/g;
->x : RegExp
->/\u{-DDDD}/g : RegExp
+>x : RegExp</\u{-DDDD}/g>
+>/\u{-DDDD}/g : RegExp</\u{-DDDD}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES5.types
index f07547f91d1d4..6a9ffea173602 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions15_ES5.ts ===
 var x = /\u{abcd}\u{ef12}\u{3456}\u{7890}/g;
->x : RegExp
->/\u{abcd}\u{ef12}\u{3456}\u{7890}/g : RegExp
+>x : RegExp</\u{abcd}\u{ef12}\u{3456}\u{7890}/g>
+>/\u{abcd}\u{ef12}\u{3456}\u{7890}/g : RegExp</\u{abcd}\u{ef12}\u{3456}\u{7890}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES6.types
index db2e4c572e86a..7196c05d88957 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions15_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions15_ES6.ts ===
 var x = /\u{abcd}\u{ef12}\u{3456}\u{7890}/g;
->x : RegExp
->/\u{abcd}\u{ef12}\u{3456}\u{7890}/g : RegExp
+>x : RegExp</\u{abcd}\u{ef12}\u{3456}\u{7890}/g>
+>/\u{abcd}\u{ef12}\u{3456}\u{7890}/g : RegExp</\u{abcd}\u{ef12}\u{3456}\u{7890}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES5.types
index eb7069c85d8b2..68512c0a4b02a 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions16_ES5.ts ===
 var x = /\u{ABCD}\u{EF12}\u{3456}\u{7890}/g;
->x : RegExp
->/\u{ABCD}\u{EF12}\u{3456}\u{7890}/g : RegExp
+>x : RegExp</\u{ABCD}\u{EF12}\u{3456}\u{7890}/g>
+>/\u{ABCD}\u{EF12}\u{3456}\u{7890}/g : RegExp</\u{ABCD}\u{EF12}\u{3456}\u{7890}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES6.types
index 26e0629569e37..9ddc5ce3dbad2 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions16_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions16_ES6.ts ===
 var x = /\u{ABCD}\u{EF12}\u{3456}\u{7890}/g;
->x : RegExp
->/\u{ABCD}\u{EF12}\u{3456}\u{7890}/g : RegExp
+>x : RegExp</\u{ABCD}\u{EF12}\u{3456}\u{7890}/g>
+>/\u{ABCD}\u{EF12}\u{3456}\u{7890}/g : RegExp</\u{ABCD}\u{EF12}\u{3456}\u{7890}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES5.types
index f55f24a3592cb..26c922b83f1ce 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions17_ES5.ts ===
 var x = /\u{r}\u{n}\u{t}/g;
->x : RegExp
->/\u{r}\u{n}\u{t}/g : RegExp
+>x : RegExp</\u{r}\u{n}\u{t}/g>
+>/\u{r}\u{n}\u{t}/g : RegExp</\u{r}\u{n}\u{t}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES6.types
index bc891c5772742..3810fb4b26775 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions17_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions17_ES6.ts ===
 var x = /\u{r}\u{n}\u{t}/g;
->x : RegExp
->/\u{r}\u{n}\u{t}/g : RegExp
+>x : RegExp</\u{r}\u{n}\u{t}/g>
+>/\u{r}\u{n}\u{t}/g : RegExp</\u{r}\u{n}\u{t}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES5.types
index da231566f899b..1274a0088e055 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions18_ES5.ts ===
 var x = /\u{65}\u{65}/g;
->x : RegExp
->/\u{65}\u{65}/g : RegExp
+>x : RegExp</\u{65}\u{65}/g>
+>/\u{65}\u{65}/g : RegExp</\u{65}\u{65}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES6.types
index e8cd1189015d4..c9345a41a0e29 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions18_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions18_ES6.ts ===
 var x = /\u{65}\u{65}/g;
->x : RegExp
->/\u{65}\u{65}/g : RegExp
+>x : RegExp</\u{65}\u{65}/g>
+>/\u{65}\u{65}/g : RegExp</\u{65}\u{65}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES5.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES5.types
index 8a90f8cc5d3a4..c222376627585 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES5.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES5.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions19_ES5.ts ===
 var x = /\u{}/g;
->x : RegExp
->/\u{}/g : RegExp
+>x : RegExp</\u{}/g>
+>/\u{}/g : RegExp</\u{}/g>
 
diff --git a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES6.types b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES6.types
index 9f4e810d91c22..d0a783d6f13ca 100644
--- a/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES6.types
+++ b/tests/baselines/reference/unicodeExtendedEscapesInRegularExpressions19_ES6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions19_ES6.ts ===
 var x = /\u{}/g;
->x : RegExp
->/\u{}/g : RegExp
+>x : RegExp</\u{}/g>
+>/\u{}/g : RegExp</\u{}/g>
 
diff --git a/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.errors.txt b/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.errors.txt
index ddf5da8881a35..670b0a0c81cd2 100644
--- a/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.errors.txt
+++ b/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.errors.txt
@@ -5,8 +5,8 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubty
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(29,5): error TS2411: Property 'foo2' of type 'number' is not assignable to string index type 'boolean'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(35,5): error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type 'Date'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(36,5): error TS2411: Property 'foo2' of type 'number' is not assignable to string index type 'Date'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(42,5): error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type 'RegExp'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(43,5): error TS2411: Property 'foo2' of type 'number' is not assignable to string index type 'RegExp'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(42,5): error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type 'RegExp<string>'.
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(43,5): error TS2411: Property 'foo2' of type 'number' is not assignable to string index type 'RegExp<string>'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(49,5): error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type '{ bar: number; }'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(50,5): error TS2411: Property 'foo2' of type 'number' is not assignable to string index type '{ bar: number; }'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubtypeIfEveryConstituentTypeIsSubtype.ts(56,5): error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type 'number[]'.
@@ -88,10 +88,10 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/unionSubty
         [x: string]: RegExp;
         foo: string | number;
         ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type 'RegExp'.
+!!! error TS2411: Property 'foo' of type 'string | number' is not assignable to string index type 'RegExp<string>'.
         foo2: e | number;
         ~~~~~~~~~~~~~~~~~
-!!! error TS2411: Property 'foo2' of type 'number' is not assignable to string index type 'RegExp'.
+!!! error TS2411: Property 'foo2' of type 'number' is not assignable to string index type 'RegExp<string>'.
     }
     
     
diff --git a/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.types b/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.types
index 9a578f8302cc4..823ba41c3a476 100644
--- a/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.types
+++ b/tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.types
@@ -89,7 +89,7 @@ interface I6 {
 
     [x: string]: RegExp;
 >x : string
->RegExp : RegExp
+>RegExp : RegExp<T>
 
     foo: string | number;
 >foo : string | number
diff --git a/tests/baselines/reference/unterminatedRegexAtEndOfSource1.types b/tests/baselines/reference/unterminatedRegexAtEndOfSource1.types
index 860d0e2211ae5..5dc52aca8078d 100644
--- a/tests/baselines/reference/unterminatedRegexAtEndOfSource1.types
+++ b/tests/baselines/reference/unterminatedRegexAtEndOfSource1.types
@@ -1,5 +1,5 @@
 === tests/cases/compiler/unterminatedRegexAtEndOfSource1.ts ===
 var a = /
->a : RegExp
->/ : RegExp
+>a : RegExp</>
+>/ : RegExp</>
 
diff --git a/tests/baselines/reference/unusedIdentifiersConsolidated1.types b/tests/baselines/reference/unusedIdentifiersConsolidated1.types
index 64f1155223eda..fc938eb88419e 100644
--- a/tests/baselines/reference/unusedIdentifiersConsolidated1.types
+++ b/tests/baselines/reference/unusedIdentifiersConsolidated1.types
@@ -85,12 +85,12 @@ namespace Validation {
     }
 
     const lettersRegexp = /^[A-Za-z]+$/;
->lettersRegexp : RegExp
->/^[A-Za-z]+$/ : RegExp
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>/^[A-Za-z]+$/ : RegExp</^[A-Za-z]+$/>
 
     const numberRegexp = /^[0-9]+$/;
->numberRegexp : RegExp
->/^[0-9]+$/ : RegExp
+>numberRegexp : RegExp</^[0-9]+$/>
+>/^[0-9]+$/ : RegExp</^[0-9]+$/>
 
     export class LettersOnlyValidator implements StringValidator {
 >LettersOnlyValidator : LettersOnlyValidator
@@ -102,9 +102,9 @@ namespace Validation {
 
             return lettersRegexp.test(s2);
 >lettersRegexp.test(s2) : boolean
->lettersRegexp.test : (string: string) => boolean
->lettersRegexp : RegExp
->test : (string: string) => boolean
+>lettersRegexp.test : (string: string) => string is /^[A-Za-z]+$/
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>test : (string: string) => string is /^[A-Za-z]+$/
 >s2 : string
         }
 
diff --git a/tests/baselines/reference/unusedVariablesinNamespaces1.types b/tests/baselines/reference/unusedVariablesinNamespaces1.types
index 94ddc9657c95c..c602b9013f176 100644
--- a/tests/baselines/reference/unusedVariablesinNamespaces1.types
+++ b/tests/baselines/reference/unusedVariablesinNamespaces1.types
@@ -3,6 +3,6 @@ namespace Validation {
 >Validation : typeof Validation
 
     const lettersRegexp = /^[A-Za-z]+$/;
->lettersRegexp : RegExp
->/^[A-Za-z]+$/ : RegExp
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>/^[A-Za-z]+$/ : RegExp</^[A-Za-z]+$/>
 }
diff --git a/tests/baselines/reference/unusedVariablesinNamespaces2.types b/tests/baselines/reference/unusedVariablesinNamespaces2.types
index 3f6e2c55b6982..a9f20ad3f5b94 100644
--- a/tests/baselines/reference/unusedVariablesinNamespaces2.types
+++ b/tests/baselines/reference/unusedVariablesinNamespaces2.types
@@ -3,12 +3,12 @@ namespace Validation {
 >Validation : typeof Validation
 
     const lettersRegexp = /^[A-Za-z]+$/;
->lettersRegexp : RegExp
->/^[A-Za-z]+$/ : RegExp
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>/^[A-Za-z]+$/ : RegExp</^[A-Za-z]+$/>
 
     const numberRegexp = /^[0-9]+$/;
->numberRegexp : RegExp
->/^[0-9]+$/ : RegExp
+>numberRegexp : RegExp</^[0-9]+$/>
+>/^[0-9]+$/ : RegExp</^[0-9]+$/>
 
     export class LettersOnlyValidator {
 >LettersOnlyValidator : LettersOnlyValidator
@@ -19,9 +19,9 @@ namespace Validation {
 
             return lettersRegexp.test(s2);
 >lettersRegexp.test(s2) : boolean
->lettersRegexp.test : (string: string) => boolean
->lettersRegexp : RegExp
->test : (string: string) => boolean
+>lettersRegexp.test : (string: string) => string is /^[A-Za-z]+$/
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>test : (string: string) => string is /^[A-Za-z]+$/
 >s2 : string
         }
     }
diff --git a/tests/baselines/reference/unusedVariablesinNamespaces3.types b/tests/baselines/reference/unusedVariablesinNamespaces3.types
index 6fd43e9b9ae53..b3d22add1254b 100644
--- a/tests/baselines/reference/unusedVariablesinNamespaces3.types
+++ b/tests/baselines/reference/unusedVariablesinNamespaces3.types
@@ -3,12 +3,12 @@ namespace Validation {
 >Validation : typeof Validation
 
     const lettersRegexp = /^[A-Za-z]+$/;
->lettersRegexp : RegExp
->/^[A-Za-z]+$/ : RegExp
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>/^[A-Za-z]+$/ : RegExp</^[A-Za-z]+$/>
 
     const numberRegexp = /^[0-9]+$/;
->numberRegexp : RegExp
->/^[0-9]+$/ : RegExp
+>numberRegexp : RegExp</^[0-9]+$/>
+>/^[0-9]+$/ : RegExp</^[0-9]+$/>
 
     export const anotherUnusedVariable = "Dummy value";
 >anotherUnusedVariable : "Dummy value"
@@ -23,9 +23,9 @@ namespace Validation {
 
             return lettersRegexp.test(s2);
 >lettersRegexp.test(s2) : boolean
->lettersRegexp.test : (string: string) => boolean
->lettersRegexp : RegExp
->test : (string: string) => boolean
+>lettersRegexp.test : (string: string) => string is /^[A-Za-z]+$/
+>lettersRegexp : RegExp</^[A-Za-z]+$/>
+>test : (string: string) => string is /^[A-Za-z]+$/
 >s2 : string
         }
     }
diff --git a/tests/baselines/reference/validRegexp.types b/tests/baselines/reference/validRegexp.types
index e33b936e64332..ad7df6201b617 100644
--- a/tests/baselines/reference/validRegexp.types
+++ b/tests/baselines/reference/validRegexp.types
@@ -1,14 +1,14 @@
 === tests/cases/compiler/validRegexp.ts ===
 var x = / [a - z /]$ / i;
->x : RegExp
->/ [a - z /]$ / : RegExp
+>x : RegExp</ [a - z /]$ />
+>/ [a - z /]$ / : RegExp</ [a - z /]$ />
 >i : any
 
 var x1 = /[a-z/]$/i;
->x1 : RegExp
->/[a-z/]$/i : RegExp
+>x1 : RegExp</[a-z/]$/i>
+>/[a-z/]$/i : RegExp</[a-z/]$/i>
 
 var x2 = /[a-z/]$ /i;
->x2 : RegExp
->/[a-z/]$ /i : RegExp
+>x2 : RegExp</[a-z/]$ /i>
+>/[a-z/]$ /i : RegExp</[a-z/]$ /i>
 
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts b/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts
new file mode 100644
index 0000000000000..98bfd9e2d6b93
--- /dev/null
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts
@@ -0,0 +1,22 @@
+const isA = /a/i;
+let mustBeA: /a/i;
+declare var s: string;
+if (isA.test(s)) {
+    mustBeA = s;
+}
+
+const isB = /b/i;
+let mustBeB: /b/i;
+if (isB.test(s)) {
+    mustBeB = s;
+}
+
+let mustBeBOrA: /b/i | /a/i;
+if (isB.test(s) || isA.test(s)) {
+    mustBeBOrA = s;
+}
+
+let mustBeBAndA: /b/i & /a/i;
+if (isB.test(s) && isA.test(s)) {
+    mustBeBOrA = s;
+}
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts b/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts
new file mode 100644
index 0000000000000..547a492c40673
--- /dev/null
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts
@@ -0,0 +1,15 @@
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#0000'; // not 3 or 6 characters
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fosh,cat'; // misspelled fish
+
+let digits: /^[0-9]+$/ = '02338374729O'; // Capital O isn't 0
+
+let hexDigits: /^([0-9]|[A-F])+$/ = 'X0F12A'; // X isn't a hex digit
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
+
+
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts b/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts
new file mode 100644
index 0000000000000..44779234611de
--- /dev/null
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts
@@ -0,0 +1,15 @@
+let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#000';
+
+let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fish,cat';
+
+let digits: /^[0-9]+$/ = '02338374729';
+
+let hexDigits: /^([0-9]|[A-F])+$/ = '0F12A';
+
+type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+let address: Email = 'typescript@microsoft.com';
+
+type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+let gmailAddress: Gmail = 'example@GMAIL.COM';
+
+
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts b/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts
new file mode 100644
index 0000000000000..cfcaf9bbb76d5
--- /dev/null
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts
@@ -0,0 +1,3 @@
+let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
+
+let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
diff --git a/tests/cases/fourslash/indexerReturnTypes1.ts b/tests/cases/fourslash/indexerReturnTypes1.ts
index cb38a79598eac..67ea1a8e86c63 100644
--- a/tests/cases/fourslash/indexerReturnTypes1.ts
+++ b/tests/cases/fourslash/indexerReturnTypes1.ts
@@ -64,12 +64,12 @@
 verify.quickInfos({
     1: "var r1: Date",
     2: "var r2: any",
-    3: "var r3: RegExp",
-    4: "var r4: RegExp",
+    3: "var r3: RegExp<string>",
+    4: "var r4: RegExp<string>",
     5: "var r5: Date",
     6: "var r6: any",
-    7: "var r7: RegExp",
-    8: "var r8: RegExp",
+    7: "var r7: RegExp<string>",
+    8: "var r8: RegExp<string>",
     9: "var r9: Date",
     10: "var r10: any",
     11: "var r11: Date",
diff --git a/tests/cases/fourslash/regexp.ts b/tests/cases/fourslash/regexp.ts
index c4b819244bc39..e52c42b4f5d4a 100644
--- a/tests/cases/fourslash/regexp.ts
+++ b/tests/cases/fourslash/regexp.ts
@@ -2,4 +2,4 @@
 
 ////var /**/x = /aa/;
 
-verify.quickInfoAt("", "var x: RegExp");
+verify.quickInfoAt("", "var x: RegExp</aa/>");

From 10dc0f57490f6c03e066c33dae7a279df2f8bf6d Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wewigham@microsoft.com>
Date: Fri, 5 Jan 2018 16:41:00 -0800
Subject: [PATCH 2/2] Improve declaration emit, add quickfix for adding a cast
 to assign to unassignable regex types

---
 src/compiler/checker.ts                       | 61 +++++++++++--------
 src/compiler/diagnosticMessages.json          | 12 ++++
 src/compiler/parser.ts                        |  1 +
 ...RequiredLiteralCastToAssignToRegexpType.ts | 54 ++++++++++++++++
 src/services/codefixes/fixes.ts               |  1 +
 .../reference/regexValidated.controlFlow.js   | 10 +++
 .../reference/regexValidated.declarations.js  | 29 +++++++++
 .../regexValidated.declarations.symbols       | 24 ++++++++
 .../regexValidated.declarations.types         | 34 +++++++++++
 .../regexValidated.stringLiterals.js          | 11 ++++
 ...lidated.stringLiterals.negative.errors.txt |  8 +--
 ...gexValidated.stringLiterals.negative.types | 16 ++---
 .../regexValidated.stringLiterals.types       | 16 ++---
 ...regexValidated.unsupportedFlags.errors.txt |  4 +-
 .../regexValidated.unsupportedFlags.js        |  5 ++
 .../regexValidated.controlFlow.ts             |  1 +
 .../regexValidated.declarations.ts            |  9 +++
 .../regexValidated.stringLiterals.ts          |  1 +
 .../regexValidated.unsupportedFlags.ts        |  1 +
 .../fourslash/regexLiteralCastQuickfix1.ts    |  9 +++
 .../fourslash/regexLiteralCastQuickfix2.ts    |  9 +++
 .../fourslash/regexLiteralCastQuickfix3.ts    | 12 ++++
 .../fourslash/regexLiteralCastQuickfix4.ts    |  9 +++
 .../fourslash/regexLiteralCastQuickfix5.ts    |  9 +++
 .../fourslash/regexLiteralCastQuickfix6.ts    | 12 ++++
 25 files changed, 312 insertions(+), 46 deletions(-)
 create mode 100644 src/services/codefixes/addRequiredLiteralCastToAssignToRegexpType.ts
 create mode 100644 tests/baselines/reference/regexValidated.declarations.js
 create mode 100644 tests/baselines/reference/regexValidated.declarations.symbols
 create mode 100644 tests/baselines/reference/regexValidated.declarations.types
 create mode 100644 tests/cases/conformance/types/regexValidated/regexValidated.declarations.ts
 create mode 100644 tests/cases/fourslash/regexLiteralCastQuickfix1.ts
 create mode 100644 tests/cases/fourslash/regexLiteralCastQuickfix2.ts
 create mode 100644 tests/cases/fourslash/regexLiteralCastQuickfix3.ts
 create mode 100644 tests/cases/fourslash/regexLiteralCastQuickfix4.ts
 create mode 100644 tests/cases/fourslash/regexLiteralCastQuickfix5.ts
 create mode 100644 tests/cases/fourslash/regexLiteralCastQuickfix6.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 98aaf4948f008..a218c43b4c91e 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -40,10 +40,31 @@ namespace ts {
      * - \/ matches opening slash
      * - (.*) matches the contents of the regex
      * - \/ matches the closing slash
-     * - (.*?)$ matches the flags at the end (non-greedy to ensure it goes from final 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 = /^\/(.*)\/(.*?)$/;
+    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
@@ -2569,9 +2590,6 @@ namespace ts {
                 if (type.flags & (TypeFlags.StringLiteral)) {
                     return createLiteralTypeNode(setEmitFlags(createLiteral((<StringLiteralType>type).value), EmitFlags.NoAsciiEscaping));
                 }
-                if (type.flags & TypeFlags.RegularExpressionValidated) {
-                    return createLiteralTypeNode(createRegularExpressionLiteral((type as LiteralType).value as string));
-                }
                 if (type.flags & (TypeFlags.NumberLiteral)) {
                     return createLiteralTypeNode((createLiteral((<NumberLiteralType>type).value)));
                 }
@@ -2607,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);
 
@@ -2619,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);
@@ -5314,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
@@ -9338,20 +9362,6 @@ namespace ts {
             return true;
         }
 
-        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;
-        }
-
         function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>, errorReporter?: ErrorReporter) {
             const s = source.flags;
             const t = target.flags;
@@ -9482,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;
                     }
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 826efa6994b00..bb02fa42b8f5e 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/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
     }
 }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 33a286aa833a7..4168157ac13e6 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -2765,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);
diff --git a/src/services/codefixes/addRequiredLiteralCastToAssignToRegexpType.ts b/src/services/codefixes/addRequiredLiteralCastToAssignToRegexpType.ts
new file mode 100644
index 0000000000000..f4fc2cc99d839
--- /dev/null
+++ b/src/services/codefixes/addRequiredLiteralCastToAssignToRegexpType.ts
@@ -0,0 +1,54 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [
+            Diagnostics.Type_0_is_not_assignable_to_type_1_1_is_not_an_executable_regular_expression_so_a_cast_must_be_performed.code,
+            Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code
+        ],
+        getCodeActions: getActionsForInvalidLiteralUsage
+    });
+
+    function getActionsForInvalidLiteralUsage(context: CodeFixContext): CodeAction[] | undefined {
+        const sourceFile = context.sourceFile;
+
+        const candidate = getTokenAtPosition(sourceFile, context.span.start, /*includeJsDocComment*/ false);
+        if (
+            isIdentifier(candidate) &&
+            (isParameter(candidate.parent) || isVariableDeclaration(candidate.parent)) &&
+            candidate.parent.name === candidate) {
+            return getCodeFixesForStringlyTypedExpression(context, candidate.parent.initializer, sourceFile);
+        }
+        else if (isExpressionNode(candidate)) {
+            return getCodeFixesForStringlyTypedExpression(context, candidate as Expression, sourceFile);
+        }
+        // No quick fix for any other kinds
+        return [];
+    }
+
+    function getCodeFixesForStringlyTypedExpression(context: CodeFixContext, node: Expression, sourceFile: SourceFile) {
+        const checker = context.program.getTypeChecker();
+        const targetType = checker.getContextualType(node);
+        const sourceType = checker.getTypeAtLocation(node);
+        const hasPotentiallyFixableError = sourceType.flags & TypeFlags.StringLiteral && targetType.flags & TypeFlags.RegularExpressionValidated && !getRegularExpressionValidatedTypeIsExecutable(targetType as RegularExpressionValidatedLiteralType);
+        if (!hasPotentiallyFixableError) {
+            // The contextual type won't always be the same type as that which causes the error;
+            // in these cases we can't actually find the type which prodced the error to create a cast
+            // Or it's just a normal assignability error for types we don't care about.
+            return [];
+        }
+        const opts: [Expression, DiagnosticMessage][] = [
+            [createAsExpression(node, checker.typeToTypeNode(targetType)), Diagnostics.Add_as_style_cast],
+            [createTypeAssertion(checker.typeToTypeNode(targetType), node), Diagnostics.Add_style_cast]
+        ];
+        return map(opts, ([replacement, message]) => {
+            const changeTracker = textChanges.ChangeTracker.fromContext(context);
+            changeTracker.replaceNode(sourceFile, node, replacement);
+            const changes = changeTracker.getChanges();
+            const action: CodeAction = {
+                description: getLocaleSpecificMessage(message),
+                changes
+            };
+            return action;
+        });
+    }
+}
\ No newline at end of file
diff --git a/src/services/codefixes/fixes.ts b/src/services/codefixes/fixes.ts
index 5b1ee8ec8572c..d518860ed6b46 100644
--- a/src/services/codefixes/fixes.ts
+++ b/src/services/codefixes/fixes.ts
@@ -15,3 +15,4 @@
 /// <reference path='disableJsDiagnostics.ts' />
 /// <reference path='helpers.ts' />
 /// <reference path='inferFromUsage.ts' />
+/// <reference path="addRequiredLiteralCastToAssignToRegexpType.ts" />
diff --git a/tests/baselines/reference/regexValidated.controlFlow.js b/tests/baselines/reference/regexValidated.controlFlow.js
index 62d54af2ea3b1..6ef5c8b387947 100644
--- a/tests/baselines/reference/regexValidated.controlFlow.js
+++ b/tests/baselines/reference/regexValidated.controlFlow.js
@@ -42,3 +42,13 @@ var mustBeBAndA;
 if (isB.test(s) && isA.test(s)) {
     mustBeBOrA = s;
 }
+
+
+//// [regexValidated.controlFlow.d.ts]
+declare const isA: RegExp</a/i>;
+declare let mustBeA: /a/i;
+declare var s: string;
+declare const isB: RegExp</b/i>;
+declare let mustBeB: /b/i;
+declare let mustBeBOrA: /b/i | /a/i;
+declare let mustBeBAndA: /b/i & /a/i;
diff --git a/tests/baselines/reference/regexValidated.declarations.js b/tests/baselines/reference/regexValidated.declarations.js
new file mode 100644
index 0000000000000..acefdaf005a1d
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.declarations.js
@@ -0,0 +1,29 @@
+//// [regexValidated.declarations.ts]
+type Apple = /apple/i;
+export type Banana = /banana/i;
+const x = {
+    a: "apple" as Apple,
+    b: "banana" as Banana,
+    c: "banana" as /banana/i
+}
+export default x;
+
+//// [regexValidated.declarations.js]
+"use strict";
+exports.__esModule = true;
+var x = {
+    a: "apple",
+    b: "banana",
+    c: "banana"
+};
+exports["default"] = x;
+
+
+//// [regexValidated.declarations.d.ts]
+export declare type Banana = /banana/i;
+declare const x: {
+    a: /apple/i;
+    b: Banana;
+    c: Banana;
+};
+export default x;
diff --git a/tests/baselines/reference/regexValidated.declarations.symbols b/tests/baselines/reference/regexValidated.declarations.symbols
new file mode 100644
index 0000000000000..0b762090697a9
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.declarations.symbols
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.declarations.ts ===
+type Apple = /apple/i;
+>Apple : Symbol(Apple, Decl(regexValidated.declarations.ts, 0, 0))
+
+export type Banana = /banana/i;
+>Banana : Symbol(Banana, Decl(regexValidated.declarations.ts, 0, 22))
+
+const x = {
+>x : Symbol(x, Decl(regexValidated.declarations.ts, 2, 5))
+
+    a: "apple" as Apple,
+>a : Symbol(a, Decl(regexValidated.declarations.ts, 2, 11))
+>Apple : Symbol(Apple, Decl(regexValidated.declarations.ts, 0, 0))
+
+    b: "banana" as Banana,
+>b : Symbol(b, Decl(regexValidated.declarations.ts, 3, 24))
+>Banana : Symbol(Banana, Decl(regexValidated.declarations.ts, 0, 22))
+
+    c: "banana" as /banana/i
+>c : Symbol(c, Decl(regexValidated.declarations.ts, 4, 26))
+}
+export default x;
+>x : Symbol(x, Decl(regexValidated.declarations.ts, 2, 5))
+
diff --git a/tests/baselines/reference/regexValidated.declarations.types b/tests/baselines/reference/regexValidated.declarations.types
new file mode 100644
index 0000000000000..37ce23ba183ea
--- /dev/null
+++ b/tests/baselines/reference/regexValidated.declarations.types
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/types/regexValidated/regexValidated.declarations.ts ===
+type Apple = /apple/i;
+>Apple : /apple/i
+>/apple/i : RegExp</apple/i>
+
+export type Banana = /banana/i;
+>Banana : Banana
+>/banana/i : RegExp<Banana>
+
+const x = {
+>x : { a: /apple/i; b: Banana; c: Banana; }
+>{    a: "apple" as Apple,    b: "banana" as Banana,    c: "banana" as /banana/i} : { a: /apple/i; b: Banana; c: Banana; }
+
+    a: "apple" as Apple,
+>a : /apple/i
+>"apple" as Apple : /apple/i
+>"apple" : "apple"
+>Apple : /apple/i
+
+    b: "banana" as Banana,
+>b : Banana
+>"banana" as Banana : Banana
+>"banana" : "banana"
+>Banana : Banana
+
+    c: "banana" as /banana/i
+>c : Banana
+>"banana" as /banana/i : Banana
+>"banana" : "banana"
+>/banana/i : RegExp<Banana>
+}
+export default x;
+>x : { a: /apple/i; b: Banana; c: Banana; }
+
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.js b/tests/baselines/reference/regexValidated.stringLiterals.js
index 5797442ad4dea..e2e681ea56fc3 100644
--- a/tests/baselines/reference/regexValidated.stringLiterals.js
+++ b/tests/baselines/reference/regexValidated.stringLiterals.js
@@ -23,3 +23,14 @@ var digits = '02338374729';
 var hexDigits = '0F12A';
 var address = 'typescript@microsoft.com';
 var gmailAddress = 'example@GMAIL.COM';
+
+
+//// [regexValidated.stringLiterals.d.ts]
+declare let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+declare let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/;
+declare let digits: /^[0-9]+$/;
+declare let hexDigits: /^([0-9]|[A-F])+$/;
+declare type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
+declare let address: Email;
+declare type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
+declare let gmailAddress: Gmail;
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt b/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt
index 89fd7acf7c86b..71eb2f7684a3f 100644
--- a/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt
+++ b/tests/baselines/reference/regexValidated.stringLiterals.negative.errors.txt
@@ -2,8 +2,8 @@ tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negat
 tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(3,5): error TS2322: Type '"cat,fish,dog,fosh,cat"' is not assignable to type '/^(dog|cat|fish)(,(dog|cat|fish))*$/'.
 tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(5,5): error TS2322: Type '"02338374729O"' is not assignable to type '/^[0-9]+$/'.
 tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(7,5): error TS2322: Type '"X0F12A"' is not assignable to type '/^([0-9]|[A-F])+$/'.
-tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(10,5): error TS2322: Type '"type★script@microsoft.com"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i'.
-tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(13,5): error TS2322: Type '"example@GMAIL.ORG"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(10,5): error TS2322: Type '"type★script@microsoft.com"' is not assignable to type 'Email'.
+tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts(13,5): error TS2322: Type '"example@GMAIL.ORG"' is not assignable to type 'Gmail'.
 
 
 ==== tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negative.ts (6 errors) ====
@@ -26,12 +26,12 @@ tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.negat
     type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
     let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
         ~~~~~~~
-!!! error TS2322: Type '"type★script@microsoft.com"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i'.
+!!! error TS2322: Type '"type★script@microsoft.com"' is not assignable to type 'Email'.
     
     type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
     let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
         ~~~~~~~~~~~~
-!!! error TS2322: Type '"example@GMAIL.ORG"' is not assignable to type '/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i'.
+!!! error TS2322: Type '"example@GMAIL.ORG"' is not assignable to type 'Gmail'.
     
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.negative.types b/tests/baselines/reference/regexValidated.stringLiterals.negative.types
index cda4f443e501e..6c50b055ddc69 100644
--- a/tests/baselines/reference/regexValidated.stringLiterals.negative.types
+++ b/tests/baselines/reference/regexValidated.stringLiterals.negative.types
@@ -20,21 +20,21 @@ let hexDigits: /^([0-9]|[A-F])+$/ = 'X0F12A'; // X isn't a hex digit
 >'X0F12A' : "X0F12A"
 
 type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
->Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
->/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i>
+>Email : Email
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i : RegExp<Email>
 
 let address: Email = 'type★script@microsoft.com'; // ★ isn't part of the validated range for addresses
->address : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
->Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>address : Email
+>Email : Email
 >'type★script@microsoft.com' : "type★script@microsoft.com"
 
 type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
->Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
->/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i>
+>Gmail : Gmail
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i : RegExp<Gmail>
 
 let gmailAddress: Gmail = 'example@GMAIL.ORG'; // wrong tld
->gmailAddress : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
->Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>gmailAddress : Gmail
+>Gmail : Gmail
 >'example@GMAIL.ORG' : "example@GMAIL.ORG"
 
 
diff --git a/tests/baselines/reference/regexValidated.stringLiterals.types b/tests/baselines/reference/regexValidated.stringLiterals.types
index 529713cf4650b..074f0c2c80edf 100644
--- a/tests/baselines/reference/regexValidated.stringLiterals.types
+++ b/tests/baselines/reference/regexValidated.stringLiterals.types
@@ -20,21 +20,21 @@ let hexDigits: /^([0-9]|[A-F])+$/ = '0F12A';
 >'0F12A' : "0F12A"
 
 type Email = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
->Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
->/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i>
+>Email : Email
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i : RegExp<Email>
 
 let address: Email = 'typescript@microsoft.com';
->address : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
->Email : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i
+>address : Email
+>Email : Email
 >'typescript@microsoft.com' : "typescript@microsoft.com"
 
 type Gmail = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i;
->Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
->/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i : RegExp</^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i>
+>Gmail : Gmail
+>/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i : RegExp<Gmail>
 
 let gmailAddress: Gmail = 'example@GMAIL.COM';
->gmailAddress : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
->Gmail : /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@gmail\.com$/i
+>gmailAddress : Gmail
+>Gmail : Gmail
 >'example@GMAIL.COM' : "example@GMAIL.COM"
 
 
diff --git a/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt b/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt
index 956dafb4d8a19..7eb0809839432 100644
--- a/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt
+++ b/tests/baselines/reference/regexValidated.unsupportedFlags.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts(1,5): error TS2322: Type '"a"' is not assignable to type '/a/l'.
+tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts(1,5): error TS2729: Type '"a"' is not assignable to type '/a/l'. '/a/l' is not an executable regular expression, so a cast must be performed.
 
 
 ==== tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts (1 errors) ====
     let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
         ~
-!!! error TS2322: Type '"a"' is not assignable to type '/a/l'.
+!!! error TS2729: Type '"a"' is not assignable to type '/a/l'. '/a/l' is not an executable regular expression, so a cast must be performed.
     
     let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
     
\ No newline at end of file
diff --git a/tests/baselines/reference/regexValidated.unsupportedFlags.js b/tests/baselines/reference/regexValidated.unsupportedFlags.js
index e59fa22e85b95..a83210923aac0 100644
--- a/tests/baselines/reference/regexValidated.unsupportedFlags.js
+++ b/tests/baselines/reference/regexValidated.unsupportedFlags.js
@@ -7,3 +7,8 @@ let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable fl
 //// [regexValidated.unsupportedFlags.js]
 var a = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
 var b = "b"; // Should be fine, cast can work around inoperable flags
+
+
+//// [regexValidated.unsupportedFlags.d.ts]
+declare let a: /a/l;
+declare let b: /b/l;
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts b/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts
index 98bfd9e2d6b93..d5a1d00842529 100644
--- a/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.controlFlow.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 const isA = /a/i;
 let mustBeA: /a/i;
 declare var s: string;
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.declarations.ts b/tests/cases/conformance/types/regexValidated/regexValidated.declarations.ts
new file mode 100644
index 0000000000000..e3f3001c2e563
--- /dev/null
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.declarations.ts
@@ -0,0 +1,9 @@
+// @declaration: true
+type Apple = /apple/i;
+export type Banana = /banana/i;
+const x = {
+    a: "apple" as Apple,
+    b: "banana" as Banana,
+    c: "banana" as /banana/i
+}
+export default x;
\ No newline at end of file
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts b/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts
index 44779234611de..8f70e8533fb77 100644
--- a/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.stringLiterals.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 let fontColor: /^#([0-9a-f]{3}|[0-9a-f]{6})$/i = '#000';
 
 let catdogfish: /^(dog|cat|fish)(,(dog|cat|fish))*$/ = 'cat,fish,dog,fish,cat';
diff --git a/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts b/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts
index cfcaf9bbb76d5..64d5de414367b 100644
--- a/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts
+++ b/tests/cases/conformance/types/regexValidated/regexValidated.unsupportedFlags.ts
@@ -1,3 +1,4 @@
+// @declaration: true
 let a: /a/l = "a"; // Should error, runtime has no `l` flag, so type cannot be matched
 
 let b: /b/l = "b" as /b/l; // Should be fine, cast can work around inoperable flags
diff --git a/tests/cases/fourslash/regexLiteralCastQuickfix1.ts b/tests/cases/fourslash/regexLiteralCastQuickfix1.ts
new file mode 100644
index 0000000000000..9d2222362f731
--- /dev/null
+++ b/tests/cases/fourslash/regexLiteralCastQuickfix1.ts
@@ -0,0 +1,9 @@
+/// <reference path="fourslash.ts" />
+//// type Validator = /something/j;
+//// const x: Validator = "something";
+verify.codeFix({
+    index: 0,
+    description: `Add 'as'-style cast`,
+    newFileContent: `type Validator = /something/j;
+const x: Validator = "something" as Validator;`
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/regexLiteralCastQuickfix2.ts b/tests/cases/fourslash/regexLiteralCastQuickfix2.ts
new file mode 100644
index 0000000000000..c66be02782fee
--- /dev/null
+++ b/tests/cases/fourslash/regexLiteralCastQuickfix2.ts
@@ -0,0 +1,9 @@
+/// <reference path="fourslash.ts" />
+//// type Validator = /something/j;
+//// function doThing(p: Validator = "something") {};
+verify.codeFix({
+    index: 0,
+    description: `Add 'as'-style cast`,
+    newFileContent: `type Validator = /something/j;
+function doThing(p: Validator = "something" as Validator) {};`
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/regexLiteralCastQuickfix3.ts b/tests/cases/fourslash/regexLiteralCastQuickfix3.ts
new file mode 100644
index 0000000000000..52157c012210d
--- /dev/null
+++ b/tests/cases/fourslash/regexLiteralCastQuickfix3.ts
@@ -0,0 +1,12 @@
+/// <reference path="fourslash.ts" />
+//// type Validator = /something/j;
+//// declare function needs(v: Validator): void;
+//// needs(/*1*/"something"/*2*/);
+verify.errorExistsBetweenMarkers("1", "2");
+verify.codeFix({
+    index: 0,
+    description: `Add 'as'-style cast`,
+    newFileContent: `type Validator = /something/j;
+declare function needs(v: Validator): void;
+needs("something" as Validator);`
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/regexLiteralCastQuickfix4.ts b/tests/cases/fourslash/regexLiteralCastQuickfix4.ts
new file mode 100644
index 0000000000000..a9c8516382a62
--- /dev/null
+++ b/tests/cases/fourslash/regexLiteralCastQuickfix4.ts
@@ -0,0 +1,9 @@
+/// <reference path="fourslash.ts" />
+//// type Validator = /something/j;
+//// const x: Validator = "something";
+verify.codeFix({
+    index: 1,
+    description: `Add '<>'-style cast`,
+    newFileContent: `type Validator = /something/j;
+const x: Validator = <Validator>"something";`
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/regexLiteralCastQuickfix5.ts b/tests/cases/fourslash/regexLiteralCastQuickfix5.ts
new file mode 100644
index 0000000000000..7300102086f73
--- /dev/null
+++ b/tests/cases/fourslash/regexLiteralCastQuickfix5.ts
@@ -0,0 +1,9 @@
+/// <reference path="fourslash.ts" />
+//// type Validator = /something/j;
+//// function doThing(p: Validator = "something") {};
+verify.codeFix({
+    index: 1,
+    description: `Add '<>'-style cast`,
+    newFileContent: `type Validator = /something/j;
+function doThing(p: Validator = <Validator>"something") {};`
+});
\ No newline at end of file
diff --git a/tests/cases/fourslash/regexLiteralCastQuickfix6.ts b/tests/cases/fourslash/regexLiteralCastQuickfix6.ts
new file mode 100644
index 0000000000000..050a578566c66
--- /dev/null
+++ b/tests/cases/fourslash/regexLiteralCastQuickfix6.ts
@@ -0,0 +1,12 @@
+/// <reference path="fourslash.ts" />
+//// type Validator = /something/j;
+//// declare function needs(v: Validator): void;
+//// needs(/*1*/"something"/*2*/);
+verify.errorExistsBetweenMarkers("1", "2");
+verify.codeFix({
+    index: 1,
+    description: `Add '<>'-style cast`,
+    newFileContent: `type Validator = /something/j;
+declare function needs(v: Validator): void;
+needs(<Validator>"something");`
+});
\ No newline at end of file