feat: generateUseItem

Author: kermanx

packages/language-server/src/codegen.ts

@@ -21,6 +21,9 @@ export function* generateStatement(node: Parser.SyntaxNode): Generator<Code> {
       yield* generateExpression(node.namedChildren[0]);
       yield ";";
       break;
+    case "use_declaration":
+      yield* generateUse(node);
+      break;
     default:
       yield* generateExpression(node);
   }
@@ -271,3 +274,193 @@ function* generateSelf(node: Parser.SyntaxNode): Generator<Code> {
     `this`,
   );
 }
+
+function* generateUse(node: Parser.SyntaxNode): Generator<Code> {
+  const reexportsNamed: Code[] = [];
+  const reexportsAll: string[] = [];
+  yield* generateUseItem(node.childForFieldName("argument")!);
+  if (node.namedChildren[0]?.type === "visibility_modifier") {
+    if (reexportsNamed.length) {
+      yield "export {";
+      yield* reexportsNamed;
+      yield "};\n";
+    }
+    if (reexportsAll.length) {
+      for (const path of reexportsAll) {
+        yield `export * from "`;
+        yield path;
+        yield `";\n`;
+      }
+    }
+  }
+  else {
+    if (reexportsAll.length) {
+      throw new Error("Wildcard import is not supported");
+    }
+  }
+
+  function* generateUseItem(node: Parser.SyntaxNode, base = "", alias?: Code): Generator<Code> {
+    switch (node.type) {
+      case "scoped_use_list": {
+        const path = getPath(node.namedChildren[0]);
+        let wildcard: Code[] | undefined;
+        const named: [original: Code, alias?: Code][] = [];
+        for (const child of node.namedChildren[1].namedChildren) {
+          if (child.type === "self") {
+            wildcard = [...wrapWith(
+              child.startIndex,
+              child.endIndex,
+              codeFeatures.verification,
+              getSelfName(node.namedChildren[0]),
+            )];
+          }
+          else if (child.type === "identifier") {
+            named.push([[child.text, child.startIndex]]);
+          }
+          else if (child.type === "use_as_clause") {
+            const original = child.namedChildren[0];
+            const alias = child.namedChildren[1];
+            if (original.type === "self") {
+              wildcard = [[alias.text, alias.startIndex]];
+            }
+            else if (original.type === "identifier") {
+              named.push([[original.text, original.startIndex], [alias.text, alias.startIndex]]);
+            }
+            else {
+              yield* generateUseItem(original, path, [alias.text, alias.startIndex]);
+            }
+          }
+          else {
+            yield* generateUseItem(child, path);
+          }
+        }
+        if (wildcard) {
+          reexportsNamed.push(...wildcard, ", ");
+          yield `import * as `;
+          yield* wildcard;
+          yield ` from `;
+          yield* generatePath(node, path);
+          yield `;\n`;
+        }
+        if (named.length > 0) {
+          yield "import { ";
+          let isFirst = true;
+          for (const [name, alias] of named) {
+            if (!isFirst)
+              yield `, `;
+            isFirst = false;
+
+            reexportsNamed.push(alias || name, ", ");
+            yield name;
+            if (alias) {
+              yield ` as `;
+              yield alias;
+            }
+          }
+          yield ` } from `;
+          yield* generatePath(node, path);
+          yield `;\n`;
+        }
+        break;
+      }
+      case "scoped_identifier": {
+        const path = getPath(node.namedChildren[0]);
+        const name = node.namedChildren[1];
+        if (name.text === "self") {
+          const nameCode = alias
+            ? [alias]
+            : [...wrapWith(
+                name.startIndex,
+                name.endIndex,
+                codeFeatures.verification,
+                getSelfName(node.namedChildren[0]),
+              )];
+          reexportsNamed.push(...nameCode, ", ");
+          yield `import * as `;
+          yield* nameCode;
+          yield ` from `;
+          yield* generatePath(node, path);
+          yield `;\n`;
+        }
+        else {
+          reexportsNamed.push(alias || [name.text, name.startIndex], ", ");
+          yield `import { `;
+          yield [name.text, name.startIndex];
+          if (alias) {
+            yield ` as `;
+            yield alias;
+          }
+          yield ` } from `;
+          yield* generatePath(node, path);
+          yield `;\n`;
+        }
+        break;
+      }
+      case "identifier": {
+        yield `import * as `;
+        yield [node.text, node.startIndex];
+        yield ` from `;
+        yield* generatePath(node, node.text);
+        yield `;\n`;
+        break;
+      }
+      case "use_as_clause": {
+        const original = node.namedChildren[0];
+        yield* generateUseItem(original, base, alias);
+        break;
+      }
+      case "use_wildcard": {
+        const path = getPath(node.namedChildren[0]);
+        reexportsAll.push(path);
+        break;
+      }
+      default:
+        throw new Error(`Not implemented: ${node.type}`);
+    }
+
+    function getPath(path: Parser.SyntaxNode): string {
+      return base ? `${base}/${getPathImpl(path)}` : getPathImpl(path);
+    }
+
+    function getPathImpl(path: Parser.SyntaxNode): string {
+      if (path.type === "identifier") {
+        return `${path.text}`;
+      }
+      else if (path.type === "scoped_identifier") {
+        return `${getPathImpl(path.namedChildren[0])}/${path.namedChildren[1].text}`;
+      }
+      else if (path.type === "crate") {
+        return `@`;
+      }
+      else {
+        throw new Error(`Not implemented: ${path.type}`);
+      }
+    }
+
+    function getSelfName(path: Parser.SyntaxNode): string {
+      if (path.type === "identifier") {
+        return path.text;
+      }
+      else if (path.type === "scoped_identifier") {
+        return getSelfName(path.namedChildren[1]);
+      }
+      else if (path.type === "crate") {
+        return "crate";
+      }
+      else {
+        throw new Error(`Not implemented: ${path.type}`);
+      }
+    }
+  }
+
+  function generatePath(node: Parser.SyntaxNode, path: string): Generator<Code> {
+    return wrapWith(
+      node.startIndex,
+      node.endIndex,
+      codeFeatures.verification,
+      `"`,
+      path,
+      `"`,
+    );
+  }
+}

packages/language-server/src/utils/index.ts

@@ -1,15 +1,36 @@
 import type { CodeInformation } from "@volar/language-core";
 import type { Code } from "../types";
 
-export function* wrapWith(
+export function wrapWith(
   start: number,
   end: number,
   features: CodeInformation,
   ...codes: Code[]
+): Generator<Code>;
+export function wrapWith(
+  start: number,
+  end: number,
+  features: CodeInformation,
+  codes: () => Iterable<Code>
+): Generator<Code>;
+export function* wrapWith(
+  start: number,
+  end: number,
+  features: CodeInformation,
+  ...codes: Code[] | [() => Iterable<Code>]
 ): Generator<Code> {
   yield [``, start, features];
   let offset = 1;
-  for (const code of codes) {
+
+  let normalized: Iterable<Code>;
+  if (codes.length === 1 && typeof codes[0] === "function") {
+    normalized = codes[0]();
+  }
+  else {
+    normalized = codes as Code[];
+  }
+
+  for (const code of normalized) {
     if (typeof code !== "string") {
       offset++;
     }

playground/basic.jsrs

@@ -1,3 +1,8 @@
+// pub use crate::x::{x::y::{self, y1, y2}, z::self as t, t as h};
+// pub use t::x;
+// pub use s::s;
+// pub use r;
+
 1 + 1;
 let mut a = 1;
 a.toString;