feat(typescript): Add references to the new typescript AST library

[ajgateno]

This PR adds references with imports to the typescript AST, which allows for implementing further nodes like function calls, class instantiation, etc.

[github-actions]

🌿 Preview your docs: https://fern-preview-dce3e7dd-afa4-4df1-a435-7e3b21999653.docs.buildwithfern.com/learn

[amckinney]

Thoughts on splitting this up a bit to reduce nesting? It's otherwise a little hard to follow at first glance given that there's a variety of conditions. What about something along the lines of the following?

public addImport(reference: Reference): void {
  if (reference.module == null) {
    return;
  }
  if (reference.module.defaultExport) {
    this.addDefaultExportOrThrow({ reference, moduleName: reference.module.name } );
    return;
  }
  const references = this.imports[reference.module.moduleName] ??= [];
  if (!references.includes(reference.name)) {
    references.push(reference);
  }
}

private addReferenceOrThrow({ reference, moduleName }: { reference: Reference; moduleName: string; }): void {
  if (this.defaultImports[moduleName] != null) {
    throw new Error("Internal error; cannot have multiple default imports for module ...");
  }
  this.defaultImports[moduleName] = reference;
}

[ajgateno]

done

[ajgateno]

Split it up into the different conditions

[ajgateno]

Ended up looking quite different than to this because I added stars

[amckinney]

The functionality looks great, so stamping as-is, but I think we can improve code readability a bit. I trust you to make edits as you see fit, and we can go from there!

[amckinney]

We might be able to reduce nesting here too if we rearrange things a bit.

[dsinghvi]

What about something like this? We basically have a function that can turn a single module + multiple imports into statements. each statement is just an import

type Import = DefaultImport | NamedImport | StartImport; 

export function stringifyImports(): string[] {
  const importsByModule: Record<Module, Import[]>  = getImportsByModule();
  const statements = Object.entries(importsByModule).flatMap((module, imports) => {
     return  generateStatementsForImports(module, imports); 
  });
  return statements;
}

export function generateStatementsForImports(module, imports): string[] {
  const statements = []
  const nonStartImport: string[] = [];
  for (const import of imports) {
    switch (import.type) {
       case "named": 
          nonStartImportStatement.push(named.value);
        case "startImport": 
           statements.push(`import * as ${import.alias} from ${module}`)
    }
  }
  if (nonStarImport.length > 0) {
    statements.push(`import ${nonStartImport.join(", ")} from ${module}`)
  }
  return statements;
}

[amckinney]

There's a fair amount of nesting in these functions - I'd try to reduce nesting as much as possible and split these out into separate functions so that it's a little easier to read and debug later on.

I think we can apply an approach similar to the one outlined in this comment. For example, reversing the if condition at the top would reduce the entire function nesting:

if (reference.importFrom?.type !== "star") {
  return;
}
...

In summary, I'd try to:

1. Reduce nesting and return early as much as possible. Although this guide is focused on Go, the same ideas apply here.
2. Add *OrThrow functions to handle error cases.
3. With the restructured control flow, simplify the conditions used in each if down to a minimum.

[amckinney]

Nice, this AstNode looks great.

[amckinney]

Discussed offline -

We'll need to build this so that it's resilient to import conflicts. For example, consider the following:

export { File } from "./acme/foo/File";
export { File } from "./acme/bar/File";

We don't want to throw in these cases - the generator should handle the alias and assign it as needed.

export { File } from "./acme/foo/File";
export { File as File_ } from "./acme/bar/File";

[amckinney]

Discussed offline - there's some things we'll want to revisit for the import management, but this is a great first step in the right direction. We can handle those changes in a follow-up. Well done!