Fix regression in mixin emit by removing unneeded line of code

src/compiler/checker.ts

@@ -4087,8 +4087,6 @@ namespace ts {
                     else if (context.flags & NodeBuilderFlags.WriteClassExpressionAsTypeLiteral &&
                         type.symbol.valueDeclaration &&
                         isClassLike(type.symbol.valueDeclaration) &&
-                        // Use `import` types for refs to other scopes, only anonymize something defined in the same scope
-                        findAncestor(type.symbol.valueDeclaration, d => d === getSourceFileOfNode(context.enclosingDeclaration)) &&
                         !isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)
                     ) {
                         return createAnonymousTypeNode(type);

tests/baselines/reference/anonClassDeclarationEmitIsAnon.js

@@ -0,0 +1,50 @@
+//// [tests/cases/compiler/anonClassDeclarationEmitIsAnon.ts] ////
+
+//// [wrapClass.ts]
+export function wrapClass(param: any) {
+    return class Wrapped {
+        foo() {
+            return param;
+        }
+    }
+}
+
+//// [index.ts]
+import { wrapClass } from "./wrapClass";
+
+export default wrapClass(0);
+
+//// [wrapClass.js]
+"use strict";
+exports.__esModule = true;
+function wrapClass(param) {
+    return /** @class */ (function () {
+        function Wrapped() {
+        }
+        Wrapped.prototype.foo = function () {
+            return param;
+        };
+        return Wrapped;
+    }());
+}
+exports.wrapClass = wrapClass;
+//// [index.js]
+"use strict";
+exports.__esModule = true;
+var wrapClass_1 = require("./wrapClass");
+exports["default"] = wrapClass_1.wrapClass(0);
+
+
+//// [wrapClass.d.ts]
+export declare function wrapClass(param: any): {
+    new (): {
+        foo(): any;
+    };
+};
+//// [index.d.ts]
+declare const _default: {
+    new (): {
+        foo(): any;
+    };
+};
+export default _default;

tests/baselines/reference/anonClassDeclarationEmitIsAnon.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/compiler/wrapClass.ts ===
+export function wrapClass(param: any) {
+>wrapClass : Symbol(wrapClass, Decl(wrapClass.ts, 0, 0))
+>param : Symbol(param, Decl(wrapClass.ts, 0, 26))
+
+    return class Wrapped {
+>Wrapped : Symbol(Wrapped, Decl(wrapClass.ts, 1, 10))
+
+        foo() {
+>foo : Symbol(Wrapped.foo, Decl(wrapClass.ts, 1, 26))
+
+            return param;
+>param : Symbol(param, Decl(wrapClass.ts, 0, 26))
+        }
+    }
+}
+
+=== tests/cases/compiler/index.ts ===
+import { wrapClass } from "./wrapClass";
+>wrapClass : Symbol(wrapClass, Decl(index.ts, 0, 8))
+
+export default wrapClass(0);
+>wrapClass : Symbol(wrapClass, Decl(index.ts, 0, 8))
+

tests/baselines/reference/anonClassDeclarationEmitIsAnon.types

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/wrapClass.ts ===
+export function wrapClass(param: any) {
+>wrapClass : (param: any) => typeof Wrapped
+>param : any
+
+    return class Wrapped {
+>class Wrapped {        foo() {            return param;        }    } : typeof Wrapped
+>Wrapped : typeof Wrapped
+
+        foo() {
+>foo : () => any
+
+            return param;
+>param : any
+        }
+    }
+}
+
+=== tests/cases/compiler/index.ts ===
+import { wrapClass } from "./wrapClass";
+>wrapClass : (param: any) => typeof Wrapped
+
+export default wrapClass(0);
+>wrapClass(0) : typeof Wrapped
+>wrapClass : (param: any) => typeof Wrapped
+>0 : 0
+

tests/cases/compiler/anonClassDeclarationEmitIsAnon.ts

@@ -0,0 +1,14 @@
+// @declaration: true
+// @filename: wrapClass.ts
+export function wrapClass(param: any) {
+    return class Wrapped {
+        foo() {
+            return param;
+        }
+    }
+}
+
+// @filename: index.ts
+import { wrapClass } from "./wrapClass";
+
+export default wrapClass(0);