feat: more nodes

Author: kermanx

packages/language-server/src/codegen/function.ts

@@ -2,7 +2,7 @@ import type { SyntaxNode } from "tree-sitter";
 import type { Code } from "../types";
 import { generateBlock, generateExpression, generateIdentifier, generateSelf } from ".";
 import { context } from "./context";
-import { generateType } from "./type";
+import { generateType, generateTypeParameters } from "./type";
 import { between, generateChildren } from "./utils";
 
 export enum FunctionKind {
@@ -17,14 +17,19 @@ export function* generateFunction(
   kind: FunctionKind,
   selfType?: SyntaxNode,
 ): Generator<Code> {
-  if (kind === FunctionKind.Declaration && node.namedChildren[0]?.type === "visibility_modifier") {
-    yield `export `;
-  }
-
   if (kind !== FunctionKind.Closure) {
-    yield `function `;
+    if (kind === FunctionKind.Declaration) {
+      if (node.namedChildren[0]?.type === "visibility_modifier") {
+        yield `export `;
+      }
+      yield `function `;
+    }
+
     const name = node.childForFieldName("name")!;
     yield* generateIdentifier(name);
+
+    const typeParams = node.childForFieldName("type_parameters");
+    yield* generateTypeParameters(typeParams);
   }
 
   const parameters = node.childForFieldName("parameters")!;
@@ -77,6 +82,6 @@ function* generateParameter(node: SyntaxNode, selfType: SyntaxNode | undefined):
   yield pattern;
   yield* between(node, pattern, type);
   if (type) {
-    yield type;
+    yield* generateType(type);
   }
 }

packages/language-server/src/codegen/impl.ts

@@ -2,73 +2,76 @@ import type { SyntaxNode } from "tree-sitter";
 import type { Code } from "../types";
 import { escapeCtorName } from "./escaping";
 import { FunctionKind, generateFunction } from "./function";
+import { generateTypeParameters, getTypeParamPlaceholders } from "./type";
 
 export function* generateImpl(node: SyntaxNode): Generator<
   Code
 > {
+  const typeParams = node.childForFieldName("type_parameters");
   const trait = node.childForFieldName("trait");
   const type = node.childForFieldName("type")!;
   const body = node.childForFieldName("body")!;
+  const name = type.text; // FIXME: A::B
 
   const staticMethods: SyntaxNode[] = [];
   const instanceMethods: SyntaxNode[] = [];
-
   for (const child of body.namedChildren) {
     if (child.type === "function_item") {
-      yield* generateFunction(child, FunctionKind.Implementation, type);
-      yield "\n";
-
-      const name = child.childForFieldName("name")!;
       const isStatic = child.childForFieldName("parameters")?.namedChildren[0]?.type !== "self_parameter";
       if (isStatic)
-        staticMethods.push(name);
+        staticMethods.push(child);
       else
-        instanceMethods.push(name);
+        instanceMethods.push(child);
     }
   }
 
-  // TODO: declare module "..." {
+  if (staticMethods.length > 0) {
+    const implName = `__JSRS_impl_${node.startIndex}_static`;
+    yield `function ${implName}`;
+    yield* generateTypeParameters(typeParams);
+    yield `() { return {\n`;
+    for (const method of staticMethods) {
+      yield* generateFunction(method, FunctionKind.Implementation, type);
+      yield ",\n";
+    }
+    yield `} `;
 
-  const name = type.text; // FIXME: A::B
-  if (trait) {
-    const traitName = trait.text;
-    if (staticMethods.length) {
-      yield `;({ `;
-      for (const methodName of staticMethods) {
-        yield methodName;
-        yield ", ";
-      }
-      yield `} satisfies ${escapeCtorName(traitName)})\n`;
+    if (trait) {
+      const traitName = trait.text;
+      yield `satisfies ${escapeCtorName(traitName)}; }\n`;
+      // TODO: declare module "..." {
       yield `interface ${escapeCtorName(name)} extends ${escapeCtorName(traitName)} {}\n`;
     }
-    if (instanceMethods.length) {
-      yield `;({ `;
-      for (const methodName of instanceMethods) {
-        yield methodName;
-        yield ", ";
-      }
-      yield `} satisfies ${traitName})\n`;
-      yield `interface ${name} extends ${traitName} {}\n`;
+    else {
+      yield "}\n";
+      const typeParamPlaceholders = getTypeParamPlaceholders(typeParams);
+      yield `type ${implName}_T${typeParamPlaceholders} = ReturnType<typeof ${implName}${typeParamPlaceholders}>;\n`;
+      yield `interface ${escapeCtorName(name)} extends ${implName}_T${typeParamPlaceholders} {}\n`;
     }
   }
-  else {
-    if (staticMethods.length) {
-      yield `interface ${escapeCtorName(name)} { `;
-      for (const methodName of staticMethods) {
-        yield methodName;
-        yield ": typeof ";
-        yield methodName;
-        yield "; ";
-      }
-      yield "}\n";
+
+  if (instanceMethods.length > 0) {
+    const implName = `__JSRS_impl_${node.startIndex}`;
+    yield `function ${implName}`;
+    yield* generateTypeParameters(typeParams);
+    yield `() { return {\n`;
+    for (const method of instanceMethods) {
+      yield* generateFunction(method, FunctionKind.Implementation, type);
+      yield ",\n";
+    }
+    yield `} `;
+
+    if (trait) {
+      const traitName = trait.text;
+      yield `satisfies ${traitName}; }\n`;
+      // TODO: declare module "..." {
+      yield `interface ${name} extends ${traitName} {}\n`;
     }
-    yield `interface ${name} { `;
-    for (const methodName of instanceMethods) {
-      yield methodName;
-      yield ": typeof ";
-      yield methodName;
-      yield "; ";
+    else {
+      yield "}\n";
+      const typeParamPlaceholders = getTypeParamPlaceholders(typeParams);
+      yield `type ${implName}_T${typeParamPlaceholders} = ReturnType<typeof ${implName}${typeParamPlaceholders}>;\n`;
+      yield `interface ${name} extends ${implName}_T${typeParamPlaceholders} {}\n`;
     }
-    yield "}\n";
   }
 }

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

@@ -6,7 +6,7 @@ import { context } from "./context";
 import { generateEnum } from "./enum";
 import { FunctionKind, generateFunction } from "./function";
 import { generateImpl } from "./impl";
-import { generateMatch } from "./match";
+import { generateMatch, getPatternBindings } from "./match";
 import { generatePrelude } from "./prelude";
 import { generateStruct, generateStructExpression } from "./struct";
 import { generateUse } from "./use";
@@ -182,12 +182,7 @@ export function* generateExpression(node: SyntaxNode): Generator<Code> {
 }
 
 function* generateArrayExpression(node: SyntaxNode): Generator<Code> {
-  yield `[`;
-  for (const child of node.namedChildren) {
-    yield* generateExpression(child);
-    yield `, `;
-  }
-  yield `]`;
+  yield* generateChildren(node, generateExpression, text => text.replace("(", "[").replace(")", "]"));
 }
 
 function* generateBinaryExpression(node: SyntaxNode): Generator<Code> {
@@ -254,12 +249,7 @@ function* generateCallExpression(node: SyntaxNode): Generator<Code> {
   const args = node.childForFieldName("arguments")!;
 
   yield* generateExpression(func);
-  yield `(`;
-  for (const arg of args.namedChildren) {
-    yield* generateExpression(arg);
-    yield `, `;
-  }
-  yield `)`;
+  yield* generateChildren(args, generateExpression);
 }
 
 function* generateFieldExpression(node: SyntaxNode): Generator<Code> {
@@ -332,8 +322,12 @@ function* generateRangeExpression(node: SyntaxNode): Generator<Code> {
   yield `)`;
 }
 
-function* generateReferenceExpression(_node: SyntaxNode): Generator<Code> {
-  // TODO:
+function* generateReferenceExpression(node: SyntaxNode): Generator<Code> {
+  const isMut = node.descendantsOfType("mutable_specifier").length > 0;
+  const value = node.childForFieldName("value")!;
+  yield isMut ? "__JSRS_mutRef(" : "__JSRS_ref(";
+  yield* generateExpression(value);
+  yield ")";
 }
 
 function* generateReturnExpression(node: SyntaxNode): Generator<Code> {
@@ -375,6 +369,45 @@ export function* generateSelf(node: SyntaxNode): Generator<Code> {
   yield ["this", node.startIndex];
 }
 
-function* generateIf(_node: SyntaxNode): Generator<Code> {
-  // TODO:
+function* generateIf(node: SyntaxNode): Generator<Code> {
+  const condition = node.childForFieldName("condition")!;
+  const consequence = node.childForFieldName("consequence")!;
+  const alternative = node.childForFieldName("alternative");
+  if (condition.type === "let_condition") {
+    const pattern = condition.childForFieldName("pattern")!;
+    const value = condition.childForFieldName("value")!;
+    
+    yield "if (__JSRS_any(";
+    yield* generateExpression(value);
+    yield "))";
+
+    const bindings = [...getPatternBindings(pattern)];
+    if (bindings.length) {
+      yield "{ const ";
+      let isFirst = true;
+      for (const binding of bindings) {
+        if (!isFirst) {
+          yield ", ";
+        }
+        isFirst = false;
+        yield binding;
+        yield "!";
+      }
+      yield "; "
+    }
+    yield* generateStatement(consequence);
+    if (bindings.length) {
+      yield " }";
+    }
+  }
+  else {
+    yield "if (";
+    yield* generateExpression(condition);
+    yield ")";
+    yield* generateStatement(consequence);
+  }
+  if (alternative) {
+    yield "else ";
+    yield* generateStatement(alternative.namedChildren[0]);
+  }
 }

packages/language-server/src/codegen/match.ts

@@ -4,3 +4,31 @@ import type { Code } from "../types";
 export function* generateMatch(_node: SyntaxNode): Generator<Code> {
   // TODO:
 }
+
+export function* getPatternBindings(node: SyntaxNode): Generator<Code> {
+  switch (node.type) {
+    case "identifier":
+      yield node;
+      break;
+    case "tuple_struct_pattern":
+      for (const child of node.namedChildren.slice(1)) {
+        yield* getPatternBindings(child);
+      }
+      break;
+    case "or_pattern": {
+      const [left, right] = node.namedChildren;
+      const leftBindings = getPatternBindings(left);
+      const _rightBindings = getPatternBindings(right);
+      // TODO: Check equality of bindings
+      yield* leftBindings;
+      break;
+    }
+    case "slice_pattern":
+    case "tuple_pattern":
+      for (const child of node.namedChildren) {
+        yield* getPatternBindings(child);
+      }
+      break;
+    default:
+  }
+}

packages/language-server/src/codegen/type.ts

@@ -1,9 +1,11 @@
 import type { SyntaxNode } from "tree-sitter";
 import type { Code } from "../types";
 import { generateScopedIdentifier } from ".";
+import { codeFeatures } from "../utils/codeFeatures";
+import { generateChildren, wrapWith } from "./utils";
 
 export function* generateTypeParameters(node: SyntaxNode | null): Generator<Code> {
-  if (!node)
+  if (!node?.namedChildren.length)
     return;
   yield "<";
   for (const child of node.children) {
@@ -15,6 +17,15 @@ export function* generateTypeParameters(node: SyntaxNode | null): Generator<Code
   yield ">";
 }
 
+export function getTypeParamPlaceholders(node: SyntaxNode | null): string {
+  if (!node?.namedChildren.length)
+    return "";
+  return `<${node.namedChildren.map((param) => {
+    // FIXME: complex param
+    return param.text;
+  }).join(", ")}>`;
+}
+
 export function* generateType(node: SyntaxNode): Generator<Code> {
   switch (node.type) {
     case "type_identifier":
@@ -23,5 +34,39 @@ export function* generateType(node: SyntaxNode): Generator<Code> {
     case "scoped_type_identifier":
       yield* generateScopedIdentifier(node);
       break;
+    case "generic_type":
+      yield* generateGenericType(node);
+      break;
+    case "lifetime":
+      yield* generateLifetime(node);
+      break;
+    case "reference_type":
+      yield* generateReferenceType(node);
+      break;
   }
 }
+
+function* generateGenericType(node: SyntaxNode): Generator<Code> {
+  const type = node.childForFieldName("type")!;
+  const args = node.childForFieldName("type_arguments")!;
+
+  yield* generateType(type);
+  yield* generateChildren(args, generateType);
+}
+
+function* generateLifetime(node: SyntaxNode): Generator<Code> {
+  yield* wrapWith(
+    node.startIndex,
+    node.endIndex,
+    codeFeatures.verification,
+    `__JSRS_lifetime_${node.namedChildren[0].text}`,
+  );
+}
+
+function* generateReferenceType(node: SyntaxNode): Generator<Code> {
+  const isMut = node.descendantsOfType("mutable_specifier").length > 0;
+  const type = node.childForFieldName("type")!;
+  yield isMut ? "__JSRS_MutRef<" : "__JSRS_Ref<";
+  yield* generateType(type);
+  yield ">";
+}