Isolated declarations

src/compiler/_namespaces/ts.ts

@@ -57,6 +57,9 @@ export * from "../transformers/module/system";
 export * from "../transformers/module/esnextAnd2015";
 export * from "../transformers/module/node";
 export * from "../transformers/declarations/diagnostics";
+export * from "../transformers/declarations/emitResolver";
+export * from "../transformers/declarations/transpileDeclaration";
+export * from "../transformers/declarations/localInferenceResolver";
 export * from "../transformers/declarations";
 export * from "../transformer";
 export * from "../emitter";

src/compiler/commandLineParser.ts

@@ -816,6 +816,15 @@ const commandOptionsWithoutBuild: CommandLineOption[] = [
         description: Diagnostics.Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting,
         defaultValueDescription: false,
     },
+    {
+        name: "isolatedDeclarations",
+        type: "boolean",
+        category: Diagnostics.Interop_Constraints,
+        description: Diagnostics.Ensure_that_each_file_can_have_declaration_emit_generated_without_type_information,
+        defaultValueDescription: false,
+        affectsBuildInfo: true,
+        affectsEmit: true,
+    },
 
     // Strict Type Checks
     {

src/compiler/debug.ts

@@ -4,6 +4,7 @@ import {
     AssertionLevel,
     BigIntLiteralType,
     CheckMode,
+    Comparer,
     compareValues,
     EmitFlags,
     every,
@@ -386,18 +387,18 @@ export namespace Debug {
      * Formats an enum value as a string for debugging and debug assertions.
      */
     export function formatEnum(value = 0, enumObject: any, isFlags?: boolean) {
-        const members = getEnumMembers(enumObject);
+        const members = getEnumMembers(enumObject, isFlags);
         if (value === 0) {
             return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0";
         }
         if (isFlags) {
             const result: string[] = [];
             let remainingFlags = value;
             for (const [enumValue, enumName] of members) {
-                if (enumValue > value) {
+                if (enumValue > remainingFlags) {
                     break;
                 }
-                if (enumValue !== 0 && enumValue & value) {
+                if (enumValue !== 0 && enumValue & remainingFlags) {
                     result.push(enumName);
                     remainingFlags &= ~enumValue;
                 }
@@ -418,7 +419,7 @@ export namespace Debug {
 
     const enumMemberCache = new Map<any, SortedReadonlyArray<[number, string]>>();
 
-    function getEnumMembers(enumObject: any) {
+    function getEnumMembers(enumObject: any, isFlags?: boolean) {
         // Assuming enum objects do not change at runtime, we can cache the enum members list
         // to reuse later. This saves us from reconstructing this each and every time we call
         // a formatting function (which can be expensive for large enums like SyntaxKind).
@@ -435,7 +436,10 @@ export namespace Debug {
             }
         }
 
-        const sorted = stableSort<[number, string]>(result, (x, y) => compareValues(x[0], y[0]));
+        const comparer: Comparer<[number, string]> = isFlags ?
+            (x, y) => compareValues(x[0] >>> 0, y[0] >>> 0) :
+            (x, y) => compareValues(x[0], y[0]);
+        const sorted = stableSort(result, comparer);
         enumMemberCache.set(enumObject, sorted);
         return sorted;
     }

src/compiler/diagnosticMessages.json

@@ -6227,6 +6227,11 @@
         "category": "Message",
         "code": 6718
     },
+    "Ensure that each file can have declaration emit generated without type information": {
+        "category": "Message",
+        "code": 6719
+    },
+
     "Default catch clause variables as 'unknown' instead of 'any'.": {
         "category": "Message",
         "code": 6803
@@ -6741,6 +6746,130 @@
         "category": "Error",
         "code": 9006
     },
+    "Function must have an explicit return type annotation with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9007
+    },
+    "Method must have an explicit return type annotation with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9008
+    },
+    "At least one accessor must have an explicit return type annotation with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9009
+    },
+    "Variable must have an explicit type annotation with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9010
+    },
+    "Parameter must have an explicit type annotation with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9011
+    },
+    "Property must have an explicit type annotation with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9012
+    },
+    "Expression type can't be inferred with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9013
+    },
+    "Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9014
+    },
+    "Objects that contain spread assignments can't be inferred with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9015
+    },
+    "Objects that contain shorthand properties can't be inferred with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9016
+    },
+    "Only const arrays can be inferred with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9017
+    },
+    "Arrays with spread elements can't inferred with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9018
+    },
+    "Binding elements can't be exported directly with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9019
+    },
+    "Enum member initializers must be computable without references to external symbols with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9020
+    },
+    "Extends clause can't contain an expression with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9021
+    },
+    "Inference from class expressions is not supported with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9022
+    },
+    "Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.": {
+        "category": "Error",
+        "code": 9023
+    },
+    "Declaration emit for this file requires adding a type reference directive which are not supported with --isolatedDeclarations": {
+        "category": "Error",
+        "code": 9024
+    },
+    "Reference directives are not supported with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9025
+    },
+    "Declaration emit for this file requires preserving this import for augmentations. This is not supported with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9026
+    },
+    "Add a type annotation to the variable {0}.": {
+        "category": "Error",
+        "code": 9027
+    },
+    "Add a type annotation to the parameter {0}.": {
+        "category": "Error",
+        "code": 9028
+    },
+    "Add a type annotation to the property {0}.": {
+        "category": "Error",
+        "code": 9029
+    },
+    "Add a return type to the function expression.": {
+        "category": "Error",
+        "code": 9030
+    },
+    "Add a return type to the function declaration.": {
+        "category": "Error",
+        "code": 9031
+    },
+    "Add a return type to the get accessor declaration.": {
+        "category": "Error",
+        "code": 9032
+    },
+    "Add a type to parameter of the set accessor declaration.": {
+        "category": "Error",
+        "code": 9033
+    },
+    "Add a return type to the method": {
+        "category": "Error",
+        "code": 9034
+    },
+    "Add a type assertion to this expression to make type type explicit.": {
+        "category": "Error",
+        "code": 9035
+    },
+    "Move the expression in default export to a variable and add a type annotation to it.": {
+        "category": "Error",
+        "code": 9036
+    },
+    "Default exports can't be inferred with --isolatedDeclarations.": {
+        "category": "Error",
+        "code": 9037
+    },
     "JSX attributes must only be assigned a non-empty 'expression'.": {
         "category": "Error",
         "code": 17000
@@ -7055,6 +7184,42 @@
         "category": "Message",
         "code": 90060
     },
+    "Add annotation of type '{0}'": {
+        "category": "Message",
+        "code": 90061
+    },
+    "Add return type '{0}'": {
+        "category": "Message",
+        "code": 90062
+    },
+    "Extract base class to variable": {
+        "category": "Message",
+        "code": 90064
+    },
+    "Extract default export to variable": {
+        "category": "Message",
+        "code": 90065
+    },
+    "Extract binding expressions to variable": {
+        "category": "Message",
+        "code": 90066
+    },
+    "Add all missing type annotations": {
+        "category": "Message",
+        "code": 90067
+    },
+    "Add inline type assertion to '{0}'": {
+        "category": "Message",
+        "code": 90068
+    },
+    "Extract to variable and replace with '{0} typeof {0}'": {
+        "category": "Message",
+        "code": 90069
+    },
+    "Mark array literal as const": {
+        "category": "Message",
+        "code": 90070
+    },
 
     "Convert function to an ES2015 class": {
         "category": "Message",