Ensure computation does not involved declaredType

Author: jakebailey

src/compiler/checker.ts

@@ -1233,7 +1233,7 @@ const enum TypeSystemPropertyName {
     ResolvedTypeArguments,
     ResolvedBaseTypes,
     WriteType,
-    IsParameterWithUndefinedInAnnotation,
+    ParameterInitializerContainsUndefined,
 }
 
 /** @internal */
@@ -9983,8 +9983,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 return !!(target as InterfaceType).baseTypesResolved;
             case TypeSystemPropertyName.WriteType:
                 return !!getSymbolLinks(target as Symbol).writeType;
-            case TypeSystemPropertyName.IsParameterWithUndefinedInAnnotation:
-                return getNodeLinks(target as VariableDeclaration).isParameterWithUndefinedInAnnotation !== undefined;
+            case TypeSystemPropertyName.ParameterInitializerContainsUndefined:
+                return getNodeLinks(target as ParameterDeclaration).parameterInitializerContainsUndefined !== undefined;
         }
         return Debug.assertNever(propertyName);
     }
@@ -27295,31 +27295,37 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return symbol.flags & SymbolFlags.Variable && (getDeclarationNodeFlagsFromSymbol(symbol) & NodeFlags.Const) !== 0;
     }
 
-    /** remove undefined from the annotated type of a parameter when there is an initializer (that doesn't include undefined) */
-    function removeOptionalityFromDeclaredType(declaredType: Type, declaration: VariableLikeDeclaration): Type {
+    function parameterInitializerContainsUndefined(declaration: ParameterDeclaration): boolean {
         const links = getNodeLinks(declaration);
 
-        if (links.isParameterWithUndefinedInAnnotation === undefined) {
-            if (!pushTypeResolution(declaration, TypeSystemPropertyName.IsParameterWithUndefinedInAnnotation)) {
+        if (links.parameterInitializerContainsUndefined === undefined) {
+            if (!pushTypeResolution(declaration, TypeSystemPropertyName.ParameterInitializerContainsUndefined)) {
                 reportCircularityError(declaration.symbol);
-                return declaredType;
+                return true;
             }
 
-            const annotationIncludesUndefined = strictNullChecks &&
-                declaration.kind === SyntaxKind.Parameter &&
-                declaration.initializer &&
-                getTypeFacts(declaredType) & TypeFacts.IsUndefined &&
-                !(getTypeFacts(checkDeclarationInitializer(declaration, CheckMode.Normal)) & TypeFacts.IsUndefined);
+            const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, CheckMode.Normal)) & TypeFacts.IsUndefined);
 
             if (!popTypeResolution()) {
                 reportCircularityError(declaration.symbol);
-                return declaredType;
+                return true;
             }
 
-            links.isParameterWithUndefinedInAnnotation = !!annotationIncludesUndefined;
+            links.parameterInitializerContainsUndefined = containsUndefined;
         }
 
-        return links.isParameterWithUndefinedInAnnotation ? getTypeWithFacts(declaredType, TypeFacts.NEUndefined) : declaredType;
+        return links.parameterInitializerContainsUndefined;
+    }
+
+    /** remove undefined from the annotated type of a parameter when there is an initializer (that doesn't include undefined) */
+    function removeOptionalityFromDeclaredType(declaredType: Type, declaration: VariableLikeDeclaration): Type {
+        const removeUndefined = strictNullChecks &&
+            declaration.kind === SyntaxKind.Parameter &&
+            declaration.initializer &&
+            getTypeFacts(declaredType) & TypeFacts.IsUndefined &&
+            !parameterInitializerContainsUndefined(declaration);
+
+        return removeUndefined ? getTypeWithFacts(declaredType, TypeFacts.NEUndefined) : declaredType;
     }
 
     function isConstraintPosition(type: Type, node: Node) {

src/compiler/types.ts

@@ -5997,7 +5997,7 @@ export interface NodeLinks {
     declarationRequiresScopeChange?: boolean; // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter.
     serializedTypes?: Map<string, SerializedTypeEntry>; // Collection of types serialized at this location
     decoratorSignature?: Signature;     // Signature for decorator as if invoked by the runtime.
-    isParameterWithUndefinedInAnnotation?: boolean; // True if this is a parameter declaration whose type annotation contains "undefined".
+    parameterInitializerContainsUndefined?: boolean; // True if this is a parameter declaration whose type annotation contains "undefined".
 }
 
 /** @internal */