Implemented qualifiedName visitor

openrewrite/src/javascript/parser.ts

@@ -532,7 +532,14 @@ export class JavaScriptParserVisitor {
     }
 
     visitQualifiedName(node: ts.QualifiedName) {
-        return this.visitUnknown(node);
+        return new J.FieldAccess(
+            randomId(),
+            this.prefix(node),
+            Markers.EMPTY,
+            this.visit(node.left),
+            new JLeftPadded<J.Identifier>(this.suffix(node.left), this.convert<J.Identifier>(node.right), Markers.EMPTY),
+            this.mapType(node)
+        );
     }
 
     visitComputedPropertyName(node: ts.ComputedPropertyName) {

openrewrite/test/javascript/parser/qualifiedName.test.ts

@@ -0,0 +1,50 @@
+import {connect, disconnect, rewriteRun, typeScript} from '../testHarness';
+
+describe('empty mapping', () => {
+    beforeAll(() => connect());
+    afterAll(() => disconnect());
+
+    test('globalThis qualified name', () => {
+        rewriteRun(
+          //language=typescript
+          typeScript('const value: globalThis.Number = 1')
+        );
+    });
+
+    test.skip('nested class qualified name', () => {
+        rewriteRun(
+          //language=typescript
+          typeScript(`
+              class OuterClass {
+                public static InnerClass = class extends Number { };
+              }
+              const a: typeof OuterClass.InnerClass.prototype = 1;
+          `)
+        );
+    });
+
+    test.skip('namespace qualified name', () => {
+        rewriteRun(
+          //language=typescript
+          typeScript(`
+              namespace TestNamespace { 
+                export class Test {} 
+              };
+              const value: TestNamespace.Test = null;
+          `)
+        );
+    });
+
+    test.skip('enum qualified name', () => {
+        rewriteRun(
+          //language=typescript
+          typeScript(`
+              enum Test {
+                  A
+              };
+
+              const val: Test.A = Test.A;
+          `)
+        );
+    });
+});

openrewrite/test/javascript/testHarness.ts

@@ -81,9 +81,12 @@ export async function connect(): Promise<RemotingContext> {
     return new Promise((resolve, reject) => {
         const pathToJar = path.resolve(__dirname, '../../../rewrite-test-engine-remote/build/libs/rewrite-test-engine-remote-fat-jar.jar');
         console.log(pathToJar);
-        const randomPort = getRandomInt(50000, 60000);
+        client = new net.Socket();
+        client.connect(65432, 'localhost');
 
-        getNextPort(randomPort).then(port => {
+        client.once('error', (err) => {
+            const randomPort = getRandomInt(50000, 60000);
+            getNextPort(randomPort).then(port => {
                 javaTestEngine = spawn('java', ['-jar', pathToJar, port.toString()]);
                 const errorfn = (data: string) => {
                     console.error(`stderr: ${data}`);
@@ -110,7 +113,15 @@ export async function connect(): Promise<RemotingContext> {
 
                 javaTestEngine.stdout.once('data', startfn);
                 javaTestEngine.stderr.on('data', errorfn);
+            });
+        });
+        client.once('connect', () => {
+            remoting = new RemotingContext();
+            remoting.connect(client);
+            PrinterFactory.current = new RemotePrinterFactory(remoting.client!);
+            resolve(remoting);
         });
+
     });
 }
 
@@ -123,10 +134,12 @@ export async function disconnect(): Promise<void> {
                 remoting.close();
             }
 
-            javaTestEngine.once('close', (code: string) => {
-                resolve()
-            });
-            javaTestEngine.kill("SIGKILL");
+            if (javaTestEngine) {
+                javaTestEngine.once('close', (code: string) => {
+                    resolve()
+                });
+                javaTestEngine.kill("SIGKILL");
+            }
         } else {
             resolve();
         }