Isolated declarations errors

src/compiler/checker.ts

@@ -387,6 +387,7 @@ import {
     hasExtension,
     HasIllegalDecorators,
     HasIllegalModifiers,
+    hasInferredType,
     HasInitializer,
     hasInitializer,
     hasJSDocNodes,
@@ -682,6 +683,7 @@ import {
     isPartOfTypeQuery,
     isPlainJsFile,
     isPrefixUnaryExpression,
+    isPrimitiveLiteralValue,
     isPrivateIdentifier,
     isPrivateIdentifierClassElementDeclaration,
     isPrivateIdentifierPropertyAccessExpression,
@@ -1005,6 +1007,7 @@ import {
     SymbolTable,
     SymbolTracker,
     SymbolVisibilityResult,
+    SyntacticTypeNodeBuilderContext,
     SyntaxKind,
     SyntheticDefaultModuleType,
     SyntheticExpression,
@@ -1100,6 +1103,7 @@ import {
 } from "./_namespaces/ts";
 import * as moduleSpecifiers from "./_namespaces/ts.moduleSpecifiers";
 import * as performance from "./_namespaces/ts.performance";
+import { createSyntacticTypeNodeBuilder } from "./expressionToTypeNode";
 
 const ambientModuleSymbolRegex = /^".+"$/;
 const anon = "(anonymous)" as __String & string;
@@ -1481,6 +1485,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     var checkBinaryExpression = createCheckBinaryExpression();
     var emitResolver = createResolver();
     var nodeBuilder = createNodeBuilder();
+    var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions);
     var evaluate = createEvaluator({
         evaluateElementAccessExpression,
         evaluateEntityNameExpression,
@@ -5862,7 +5867,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return meaning;
     }
 
-    function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
+    function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node, shouldComputeAliasToMakeVisible = true): SymbolVisibilityResult {
         const meaning = getMeaningOfEntityNameReference(entityName);
         const firstIdentifier = getFirstIdentifier(entityName);
         const symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, /*nameNotFoundMessage*/ undefined, /*isUse*/ false);
@@ -5874,7 +5879,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
 
         // Verify if the symbol is accessible
-        return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
+        return (symbol && hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible)) || {
             accessibility: SymbolAccessibility.NotAccessible,
             errorSymbolName: getTextOfNode(firstIdentifier),
             errorNode: firstIdentifier,
@@ -5980,9 +5985,27 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return {
             typeToTypeNode: (type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => typeToTypeNodeHelper(type, context)),
             typePredicateToTypePredicateNode: (typePredicate: TypePredicate, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-            expressionOrTypeToTypeNode: (expr: Expression | JsxAttributeValue | undefined, type: Type, addUndefined?: boolean, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-            serializeTypeForDeclaration: (declaration: Declaration, type: Type, symbol: Symbol, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => serializeTypeForDeclaration(context, declaration, type, symbol)),
-            serializeReturnTypeForSignature: (signature: Signature, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => serializeReturnTypeForSignature(context, signature)),
+            expressionOrTypeToTypeNode: (expr: Expression | JsxAttributeValue | undefined, type: Type, addUndefined?: boolean, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) =>
+                withContext(enclosingDeclaration, flags, tracker, context => {
+                    if (expr) {
+                        syntacticNodeBuilder.serializeTypeOfExpression(expr, context, addUndefined);
+                    }
+                    return expressionOrTypeToTypeNode(context, expr, type, addUndefined);
+                }),
+            serializeTypeForDeclaration: (declaration: Declaration, type: Type, symbol: Symbol, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) =>
+                withContext(enclosingDeclaration, flags, tracker, context => {
+                    if (declaration && hasInferredType(declaration)) {
+                        syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context);
+                    }
+                    return serializeTypeForDeclaration(context, declaration, type, symbol);
+                }),
+            serializeReturnTypeForSignature: (signature: Signature, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) =>
+                withContext(enclosingDeclaration, flags, tracker, context => {
+                    if (signature.declaration) {
+                        syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, context);
+                    }
+                    return serializeReturnTypeForSignature(context, signature);
+                }),
             indexInfoToIndexSignatureDeclaration: (indexInfo: IndexInfo, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, /*typeNode*/ undefined)),
             signatureToSignatureDeclaration: (signature: Signature, kind: SignatureDeclaration["kind"], enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => signatureToSignatureDeclarationHelper(signature, kind, context)),
             symbolToEntityName: (symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => symbolToName(symbol, context, meaning, /*expectsIdentifier*/ false)),
@@ -6112,6 +6135,18 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 approximateLength: 0,
                 trackedSymbols: undefined,
                 bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration)),
+                isEntityNameVisible: (entityName, shouldComputeAliasToMakeVisible) => isEntityNameVisible(entityName, context.enclosingDeclaration!, shouldComputeAliasToMakeVisible),
+                isExpandoFunctionDeclaration,
+                isOptionalParameter,
+                isLiteralComputedName,
+                trackComputedName(accessExpression) {
+                    trackComputedName(accessExpression, context.enclosingDeclaration, context);
+                },
+                getAllAccessorDeclarations: getAllAccessorDeclarationsForDeclaration,
+                requiresAddingImplicitUndefined,
+                isUndefinedIdentifier(node: Identifier) {
+                    return getResolvedSymbol(node) === undefinedSymbol;
+                },
             };
             context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
             const resultingNode = cb(context);
@@ -45593,9 +45628,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         result.value,
                         /*isSyntacticallyString*/ false,
                         /*resolvedOtherFiles*/ true,
+                        /*hasExternalReferences*/ true,
                     );
                 }
-                return result;
+                return evaluatorResult(result.value, result.isSyntacticallyString, result.resolvedOtherFiles, /*hasExternalReferences*/ true);
             }
         }
         return evaluatorResult(/*value*/ undefined);
@@ -45627,7 +45663,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
             return evaluatorResult(/*value*/ 0);
         }
-        return getEnumMemberValue(declaration as EnumMember);
+        const value = getEnumMemberValue(declaration as EnumMember);
+        if (location.parent !== declaration.parent) {
+            return evaluatorResult(value.value, value.isSyntacticallyString, value.resolvedOtherFiles, /*hasExternalReferences*/ true);
+        }
+        return value;
     }
 
     function checkEnumDeclaration(node: EnumDeclaration) {
@@ -48243,12 +48283,24 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function isExpandoFunctionDeclaration(node: Declaration): boolean {
-        const declaration = getParseTreeNode(node, isFunctionDeclaration);
+        const declaration = getParseTreeNode(node, (n): n is FunctionDeclaration | VariableDeclaration => isFunctionDeclaration(n) || isVariableDeclaration(n));
         if (!declaration) {
             return false;
         }
-        const symbol = getSymbolOfDeclaration(declaration);
-        if (!symbol || !(symbol.flags & SymbolFlags.Function)) {
+        let symbol: Symbol;
+        if (isVariableDeclaration(declaration)) {
+            if (declaration.type || !isVarConstLike(declaration)) {
+                return false;
+            }
+            if (!(declaration.initializer && isFunctionExpressionOrArrowFunction(declaration.initializer))) {
+                return false;
+            }
+            symbol = getSymbolOfDeclaration(declaration.initializer);
+        }
+        else {
+            symbol = getSymbolOfDeclaration(declaration);
+        }
+        if (!symbol || !(symbol.flags & SymbolFlags.Function | SymbolFlags.Variable)) {
             return false;
         }
         return !!forEachEntry(getExportsOfSymbol(symbol), p => p.flags & SymbolFlags.Value && isExpandoPropertyDeclaration(p.valueDeclaration));
@@ -48585,6 +48637,28 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         return false;
     }
+    function isLiteralComputedName(node: ComputedPropertyName) {
+        const expression = node.expression;
+        if (isPrimitiveLiteralValue(expression, /*includeBigInt*/ false)) {
+            return true;
+        }
+        const type = getTypeOfExpression(expression);
+        if (!isTypeUsableAsPropertyName(type)) {
+            return false;
+        }
+
+        // Only identifiers of the for A.B.C can be used
+        if (!isEntityNameExpression(expression)) {
+            return false;
+        }
+        const symbol = getSymbolAtLocation(expression);
+        if (!symbol) {
+            return false;
+        }
+        // Ensure not type narrowing
+        const declaredType = getTypeOfSymbol(symbol);
+        return declaredType === type;
+    }
 
     function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
         const enumResult = type.flags & TypeFlags.EnumLike ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing, /*flags*/ undefined, tracker)
@@ -48710,6 +48784,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 return node && getExternalModuleFileFromDeclaration(node);
             },
             isLiteralConstDeclaration,
+            isLiteralComputedName,
             isLateBound: (nodeIn: Declaration): nodeIn is LateBoundDeclaration => {
                 const node = getParseTreeNode(nodeIn, isDeclaration);
                 const symbol = node && getSymbolOfDeclaration(node);
@@ -51022,7 +51097,7 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host: TypeCheckerHo
     };
 }
 
-interface NodeBuilderContext {
+interface NodeBuilderContext extends SyntacticTypeNodeBuilderContext {
     enclosingDeclaration: Node | undefined;
     /**
      * `enclosingFile` is generated from the initial `enclosingDeclaration` and
@@ -51146,4 +51221,10 @@ class SymbolTrackerImpl implements SymbolTracker {
     private onDiagnosticReported() {
         this.context.reportedDiagnostic = true;
     }
+
+    reportInferenceFallback(node: Node): void {
+        if (this.inner?.reportInferenceFallback) {
+            this.inner.reportInferenceFallback(node);
+        }
+    }
 }

src/compiler/commandLineParser.ts

@@ -827,6 +827,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/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,126 @@
         "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 parameter requires implicitly adding undefined to it's type. This is 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

src/compiler/emitter.ts

@@ -1114,6 +1114,7 @@ export const notImplementedResolver: EmitResolver = {
     isArgumentsLocalBinding: notImplemented,
     getExternalModuleFileFromDeclaration: notImplemented,
     isLiteralConstDeclaration: notImplemented,
+    isLiteralComputedName: notImplemented,
     getJsxFactoryEntity: notImplemented,
     getJsxFragmentFactoryEntity: notImplemented,
     isBindingCapturedByNode: notImplemented,