feat: render unresolved type

src/renderer/markup/ast-converter/shared/type.ts

@@ -29,6 +29,7 @@ import {
   convertUndefinedType,
   convertUnionType,
   convertUnknownType,
+  convertUnresolvedType,
   convertVoidType
 } from "unwritten:renderer:markup/ast-converter/types/index.js";
 import {
@@ -60,6 +61,7 @@ import {
   isUndefinedType,
   isUnionType,
   isUnknownType,
+  isUnresolvedType,
   isVoidType
 } from "unwritten:typeguards/types.js";
 
@@ -143,6 +145,8 @@ export function convertTypeInline(ctx: MarkupRenderContexts, type: Types): Conve
     return convertObjectType(ctx, type);
   } else if(isTypeParameterType(type)){
     return convertTypeParameterType(ctx, type);
+  } else if(isUnresolvedType(type)){
+    return convertUnresolvedType(ctx, type);
   }
 
   throw new Error(`Type ${type.kind} is not yet implemented`);

src/renderer/markup/ast-converter/types/index.ts

@@ -27,4 +27,5 @@ export * from "./type-reference.js";
 export * from "./undefined.js";
 export * from "./union.js";
 export * from "./unknown.js";
+export * from "./unresolved.js";
 export * from "./void.js";

src/renderer/markup/ast-converter/types/unresolved.test.ts

@@ -0,0 +1,80 @@
+import { expect, it } from "vitest";
+
+import { createTypeAliasEntity } from "unwritten:interpreter/ast/entities/index.js";
+import { TypeKind } from "unwritten:interpreter:enums/types.js";
+import { convertUnresolvedType } from "unwritten:renderer/markup/ast-converter/types/index.js";
+import { isAnchorNode } from "unwritten:renderer/markup/typeguards/renderer.js";
+import { compile } from "unwritten:tests:utils/compile.js";
+import { createRenderContext } from "unwritten:tests:utils/context.js";
+import { scope } from "unwritten:tests:utils/scope.js";
+import { assert } from "unwritten:utils/general.js";
+import { ts } from "unwritten:utils/template.js";
+
+import type { UnresolvedType } from "unwritten:interpreter/type-definitions/types.js";
+
+
+scope("MarkupRenderer", TypeKind.Unresolved, () => {
+
+  {
+
+    const testFileContent = ts`
+      export type StringType = string;
+      export type Type = StringType;
+    `;
+
+    const { exportedSymbols, ctx: compilerContext } = compile(testFileContent);
+
+    const symbol = exportedSymbols.find(s => s.name === "Type")!;
+    const typeAliasEntity = createTypeAliasEntity(compilerContext, symbol);
+
+    const ctx = createRenderContext();
+    const convertedUnresolvedType = convertUnresolvedType(ctx, typeAliasEntity.type as UnresolvedType);
+
+    it("should have the correct name", () => {
+      assert(Array.isArray(convertedUnresolvedType));
+      assert(isAnchorNode(convertedUnresolvedType[0]));
+      expect(convertedUnresolvedType[0].name).to.equal("StringType");
+    });
+
+    it("should link to the actual type", () => {
+      const stringTypeSymbol = exportedSymbols.find(s => s.name === "StringType")!;
+      const stringTypeAliasEntity = createTypeAliasEntity(compilerContext, stringTypeSymbol);
+      assert(Array.isArray(convertedUnresolvedType));
+      assert(isAnchorNode(convertedUnresolvedType[0]));
+      expect(convertedUnresolvedType[0].id).to.equal(stringTypeAliasEntity.symbolId);
+    });
+
+    it("should not have type arguments", () => {
+      expect(convertedUnresolvedType).to.have.lengthOf(1);
+    });
+
+  }
+
+  {
+
+    const testFileContent = ts`
+      export type Type = Array<string>;
+    `;
+
+    const { exportedSymbols, ctx: compilerContext } = compile(testFileContent);
+
+    const symbol = exportedSymbols.find(s => s.name === "Type")!;
+    const typeAliasEntity = createTypeAliasEntity(compilerContext, symbol);
+
+    const ctx = createRenderContext();
+    const convertedUnresolvedType = convertUnresolvedType(ctx, typeAliasEntity.type as UnresolvedType);
+
+    it("should have the correct name", () => {
+      assert(Array.isArray(convertedUnresolvedType));
+      assert(isAnchorNode(convertedUnresolvedType[0]));
+      expect(convertedUnresolvedType[0].name).to.equal("Array");
+    });
+
+    it("should have one type argument", () => {
+      assert(Array.isArray(convertedUnresolvedType));
+      expect(convertedUnresolvedType).to.have.lengthOf(2 + 1);
+    });
+
+  }
+
+});

src/renderer/markup/ast-converter/types/unresolved.ts

@@ -0,0 +1,47 @@
+import { convertTypeInline } from "unwritten:renderer/markup/ast-converter/shared/type.js";
+import { getRenderConfig } from "unwritten:renderer/utils/config.js";
+import { createAnchorNode } from "unwritten:renderer:markup/utils/nodes.js";
+import { encapsulate, spaceBetween } from "unwritten:renderer:markup/utils/renderer.js";
+
+import type { Types, UnresolvedType } from "unwritten:interpreter:type-definitions/types.js";
+import type { MarkupRenderContexts } from "unwritten:renderer:markup/types-definitions/markup.d.js";
+import type { ASTNodes } from "unwritten:renderer:markup/types-definitions/nodes.js";
+import type { ConvertedTypeReferenceType } from "unwritten:renderer:markup/types-definitions/renderer.js";
+
+
+export function convertUnresolvedType(ctx: MarkupRenderContexts, unresolvedType: UnresolvedType): ConvertedTypeReferenceType {
+
+  const name = unresolvedType.name ?? "";
+
+  const anchor = unresolvedType.symbolId
+    ? createAnchorNode(name, unresolvedType.symbolId)
+    : undefined;
+
+  const typeArguments = unresolvedType.typeArguments
+    ? convertTypeArguments(ctx, unresolvedType.typeArguments)
+    : "";
+
+  return spaceBetween(
+    anchor ?? name,
+    typeArguments
+  );
+
+}
+
+
+function convertTypeArguments(ctx: MarkupRenderContexts, typeArguments: Types[]): ASTNodes {
+
+  const renderConfig = getRenderConfig(ctx);
+
+  const convertedTypeArguments = typeArguments.map((typeArgument, index) => {
+    const convertedTypeArgument = convertTypeInline(ctx, typeArgument);
+    if(index === 0){
+      return convertedTypeArgument;
+    } else {
+      return [", ", convertedTypeArgument];
+    }
+  }, []);
+
+  return encapsulate(convertedTypeArguments, renderConfig.typeParameterEncapsulation);
+
+}