Merge branch 'isolated-declarations-unity' of https://github.com/bloomberg/TypeScript into isolated-declarations-unity

Author: dragomirtitian

src/compiler/diagnosticMessages.json

@@ -7220,6 +7220,10 @@
         "category": "Message",
         "code": 90070
     },
+    "Annotate types of properties expando function in a namespace": {
+      "category": "Message",
+      "code": 90071
+  },
 
     "Convert function to an ES2015 class": {
         "category": "Message",

src/services/codefixes/fixMissingTypeAnnotationOnExports.ts

@@ -26,6 +26,7 @@ import {
     factory,
     FileTextChanges,
     findAncestor,
+    FunctionDeclaration,
     GeneratedIdentifierFlags,
     getEmitScriptTarget,
     getSourceFileOfNode,
@@ -49,6 +50,7 @@ import {
     isEnumMember,
     isExpandoPropertyDeclaration,
     isExpression,
+    isFunctionDeclaration,
     isFunctionExpressionOrArrowFunction,
     isHeritageClause,
     isIdentifier,
@@ -70,6 +72,7 @@ import {
     isValueSignatureDeclaration,
     isVariableDeclaration,
     ModifierFlags,
+    ModifierLike,
     Node,
     NodeArray,
     NodeBuilderFlags,
@@ -225,6 +228,7 @@ function withChanges<T>(
     const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
     const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
     const fixedNodes = new Set<Node>();
+    const expandoPropertiesAdded = new Set<Node>();
 
     const result = cb({ addFullAnnotation, addInlineAnnotation, extractAsVariable });
     importAdder.writeFixes(changeTracker);
@@ -235,16 +239,63 @@ function withChanges<T>(
 
     function addFullAnnotation(span: TextSpan) {
         const nodeWithDiag = getTokenAtPosition(sourceFile, span.start);
-        const nodeWithNoType = findNearestParentWithTypeAnnotation(nodeWithDiag) ?? findExpandoFunction(nodeWithDiag);
+        const expandoFunction = findExpandoFunction(nodeWithDiag);
+        if (expandoFunction) {
+          if (isFunctionDeclaration(expandoFunction)) {
+            return createNamespaceForExpandoProperties(expandoFunction);
+          }
+          return fixupForIsolatedDeclarations(expandoFunction);
+        }
+        const nodeWithNoType = findNearestParentWithTypeAnnotation(nodeWithDiag)
         if (nodeWithNoType) {
             return fixupForIsolatedDeclarations(nodeWithNoType);
         }
         return undefined;
     }
 
+    function createNamespaceForExpandoProperties(expandoFunc: FunctionDeclaration): DiagnosticOrDiagnosticAndArguments|undefined {
+      if (expandoPropertiesAdded?.has(expandoFunc)) return undefined;
+      expandoPropertiesAdded?.add(expandoFunc);
+      const type = typeChecker.getTypeAtLocation(expandoFunc);
+      const elements = typeChecker.getPropertiesOfType(type);
+      if (!expandoFunc.name || elements.length === 0) return undefined;
+      const newProperties = []
+      for (const symbol of elements) {
+        if (!isIdentifierText(symbol.name, program.getCompilerOptions().target)) continue;
+        // If there's an existing variable declaration for this property - skip.
+        if (symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration)) continue;
+        newProperties.push(factory.createVariableStatement(
+          [factory.createModifier(SyntaxKind.ExportKeyword)],
+          factory.createVariableDeclarationList(
+            [factory.createVariableDeclaration(
+              symbol.name,
+              /*exclamationToken*/ undefined,
+              typeToTypeNode(typeChecker.getTypeOfSymbol(symbol), expandoFunc),
+              /*initializer*/ undefined,
+              )],
+          )
+        ));
+      }
+      if (newProperties.length === 0) return undefined;
+      const modifiers: ModifierLike[] = [];
+      if (expandoFunc.modifiers?.some((modifier)=> modifier.kind === SyntaxKind.ExportKeyword)) {
+        modifiers.push(factory.createModifier(SyntaxKind.ExportKeyword))
+      }
+      modifiers.push(factory.createModifier(SyntaxKind.DeclareKeyword));
+      const namespace = factory.createModuleDeclaration(
+        modifiers,
+        expandoFunc.name,
+        factory.createModuleBlock(newProperties),
+        /*flags*/ NodeFlags.Namespace | NodeFlags.ExportContext | NodeFlags.Ambient | NodeFlags.ContextFlags,
+      );
+      changeTracker.insertNodeAfter(sourceFile, expandoFunc, namespace);
+      return [Diagnostics.Annotate_types_of_properties_expando_function_in_a_namespace];
+    }
+
     function needsParenthesizedExpressionForAssertion(node: Expression) {
         return !isEntityNameExpression(node) && !isCallExpression(node) && !isObjectLiteralExpression(node) && !isArrayLiteralExpression(node);
     }
+
     function createAsExpression(node: Expression, type: TypeNode) {
         if (needsParenthesizedExpressionForAssertion(node)) {
             node = factory.createParenthesizedExpression(node);
@@ -291,7 +342,7 @@ function withChanges<T>(
         // We can't use typeof un an unique symbol. Would result in either
         // const s = Symbol("") as unique symbol
         // const s = Symbol("") as typeof s
-        // both of which are not cirrect
+        // both of which are not correct
         if (type && type.flags & TypeFlags.UniqueESSymbol) {
             return undefined;
         }
@@ -519,8 +570,13 @@ function withChanges<T>(
             const properties = typeChecker.getPropertiesOfType(targetType);
             if (some(properties, p => p.valueDeclaration === expandoDeclaration || p.valueDeclaration === expandoDeclaration.parent)) {
                 const fn = targetType.symbol.valueDeclaration;
-                if (fn && isFunctionExpressionOrArrowFunction(fn) && isVariableDeclaration(fn.parent)) {
+                if (fn) {
+                  if (isFunctionExpressionOrArrowFunction(fn) && isVariableDeclaration(fn.parent)) {
                     return fn.parent;
+                  }
+                  if (isFunctionDeclaration(fn)) {
+                    return fn;
+                  }
                 }
             }
         }

tests/baselines/reference/isolated-declarations/auto-fixed/diff/declarationEmitDefaultExportWithStaticAssignment.d.ts.diff

@@ -1,39 +1,22 @@
-// [[Reason: Function declarations are not fixed]] ////
+// [[Reason: Cannot name internal type]] ////
 
 //// [tests/cases/compiler/declarationEmitExpandoPropertyPrivateName.ts] ////
 
 ===================================================================
 --- TSC	declarations
 +++ DTE	declarations
-@@ -5,20 +5,29 @@
+@@ -5,8 +5,14 @@
  }
  export declare function f(): I;
  export {};
  //# sourceMappingURL=a.d.ts.map
 +//// [b.d.ts]
 +export declare function q(): void;
 +export declare namespace q {
-+    var val: invalid;
++    var val: I;
 +}
 +//# sourceMappingURL=b.d.ts.map
  /// [Errors] ////
 
- b.ts(4,1): error TS4032: Property 'val' of exported interface has or is using name 'I' from private module '"a"'.
-+b.ts(4,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.
- 
- 
- ==== a.ts (0 errors) ====
-     interface I {}
-     export function f(): I { return null as I; }
--==== b.ts (1 errors) ====
-+==== b.ts (2 errors) ====
-     import {f} from "./a";
-     
-     export function q(): void {}
-     q.val = f();
-     ~~~~~
- !!! error TS4032: Property 'val' of exported interface has or is using name 'I' from private module '"a"'.
-+    ~~~~~
-+!!! error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.
-     
-\ No newline at end of file
+ b.ts(5,14): error TS2304: Cannot find name 'I'.
+ b.ts(5,14): error TS4025: Exported variable 'val' has or is using private name 'I'.