Merge pull request #3612 from hey-api/feat/ts-compiler-1

feat: scaffold ts-compiler folder

Author: mrlubos

packages/openapi-python/src/py-compiler/__snapshots__/nodes/expressions/literal/primitive.py

@@ -1,4 +1,5 @@
 s = "hello"
 n = 123
 b = True
+c = False
 none = None

packages/openapi-python/src/py-compiler/__tests__/nodes/expressions/literal.test.ts

@@ -19,6 +19,11 @@ describe('literal expression', () => {
         undefined,
         py.factory.createLiteral(true),
       ),
+      py.factory.createAssignment(
+        py.factory.createIdentifier('c'),
+        undefined,
+        py.factory.createLiteral(false),
+      ),
       py.factory.createAssignment(
         py.factory.createIdentifier('none'),
         undefined,

packages/openapi-python/src/py-compiler/index.ts

@@ -24,7 +24,10 @@ import type { PyIdentifier as _PyIdentifier } from './nodes/expressions/identifi
 import type { PyKeywordArgument as _PyKeywordArgument } from './nodes/expressions/keywordArg';
 import type { PyLambdaExpression as _PyLambdaExpression } from './nodes/expressions/lambda';
 import type { PyListExpression as _PyListExpression } from './nodes/expressions/list';
-import type { PyLiteral as _PyLiteral } from './nodes/expressions/literal';
+import type {
+  PyLiteral as _PyLiteral,
+  PyLiteralValue as _PyLiteralValue,
+} from './nodes/expressions/literal';
 import type { PyMemberExpression as _PyMemberExpression } from './nodes/expressions/member';
 import type { PySetExpression as _PySetExpression } from './nodes/expressions/set';
 import type { PySubscriptExpression as _PySubscriptExpression } from './nodes/expressions/subscript';
@@ -129,6 +132,9 @@ export namespace py {
 
   // Printer
   export type PrinterOptions = _PyPrinterOptions;
+
+  // Miscellaneous
+  export type LiteralValue = _PyLiteralValue;
 }
 
 export const py = {

packages/openapi-python/src/py-compiler/nodes/declarations/functionParameter.ts

@@ -3,25 +3,25 @@ import type { PyExpression } from '../expression';
 import { PyNodeKind } from '../kinds';
 
 export interface PyFunctionParameter extends PyNodeBase {
-  annotation?: PyExpression;
   defaultValue?: PyExpression;
   kind: PyNodeKind.FunctionParameter;
   name: string;
+  type?: PyExpression;
 }
 
 export function createFunctionParameter(
   name: string,
-  annotation?: PyExpression,
+  type?: PyExpression,
   defaultValue?: PyExpression,
   leadingComments?: ReadonlyArray<string>,
   trailingComments?: ReadonlyArray<string>,
 ): PyFunctionParameter {
   return {
-    annotation,
     defaultValue,
     kind: PyNodeKind.FunctionParameter,
     leadingComments,
     name,
     trailingComments,
+    type,
   };
 }

packages/openapi-python/src/py-compiler/nodes/expressions/literal.ts

@@ -1,15 +1,15 @@
 import type { PyNodeBase } from '../base';
 import { PyNodeKind } from '../kinds';
 
-export type LiteralValue = string | number | boolean | null;
+export type PyLiteralValue = string | number | boolean | null;
 
 export interface PyLiteral extends PyNodeBase {
   kind: PyNodeKind.Literal;
-  value: LiteralValue;
+  value: PyLiteralValue;
 }
 
 export function createLiteral(
-  value: LiteralValue,
+  value: PyLiteralValue,
   leadingComments?: ReadonlyArray<string>,
   trailingComments?: ReadonlyArray<string>,
 ): PyLiteral {

packages/openapi-python/src/py-compiler/nodes/statements/assignment.ts

@@ -3,29 +3,29 @@ import type { PyExpression } from '../expression';
 import { PyNodeKind } from '../kinds';
 
 export interface PyAssignment extends PyNodeBase {
-  annotation?: PyExpression;
   kind: PyNodeKind.Assignment;
   target: PyExpression;
+  type?: PyExpression;
   value?: PyExpression;
 }
 
 export function createAssignment(
   target: PyExpression,
-  annotation?: PyExpression,
+  type?: PyExpression,
   value?: PyExpression,
   leadingComments?: ReadonlyArray<string>,
   trailingComments?: ReadonlyArray<string>,
 ): PyAssignment {
-  if (!annotation && !value) {
-    throw new Error('Assignment requires at least annotation or value');
+  if (!type && !value) {
+    throw new Error('Assignment requires at least type or value');
   }
 
   return {
-    annotation,
     kind: PyNodeKind.Assignment,
     leadingComments,
     target,
     trailingComments,
+    type,
     value,
   };
 }

packages/openapi-python/src/py-compiler/printer.ts

@@ -5,10 +5,11 @@ export interface PyPrinterOptions {
   indentSize?: number;
 }
 
+const DEFAULT_INDENT_SIZE = 4;
 const PARAMS_MULTILINE_THRESHOLD = 3;
 
 export function createPrinter(options?: PyPrinterOptions) {
-  const indentSize = options?.indentSize ?? 4;
+  const indentSize = options?.indentSize ?? DEFAULT_INDENT_SIZE;
 
   let indentLevel = 0;
 
@@ -52,12 +53,12 @@ export function createPrinter(options?: PyPrinterOptions) {
     switch (node.kind) {
       case PyNodeKind.Assignment: {
         const target = printNode(node.target);
-        if (node.annotation) {
-          const annotation = printNode(node.annotation);
+        if (node.type) {
+          const type = printNode(node.type);
           if (node.value) {
-            parts.push(printLine(`${target}: ${annotation} = ${printNode(node.value)}`));
+            parts.push(printLine(`${target}: ${type} = ${printNode(node.value)}`));
           } else {
-            parts.push(printLine(`${target}: ${annotation}`));
+            parts.push(printLine(`${target}: ${type}`));
           }
         } else {
           parts.push(printLine(`${target} = ${printNode(node.value!)}`));
@@ -182,7 +183,7 @@ export function createPrinter(options?: PyPrinterOptions) {
         const defPrefix = modifiers ? `${modifiers} def` : 'def';
         const formatParameter = (parameter: (typeof node.parameters)[number]): string => {
           const children: Array<string> = [parameter.name];
-          if (parameter.annotation) children.push(`: ${printNode(parameter.annotation)}`);
+          if (parameter.type) children.push(`: ${printNode(parameter.type)}`);
           if (parameter.defaultValue) children.push(` = ${printNode(parameter.defaultValue)}`);
           return children.join('');
         };
@@ -272,7 +273,7 @@ export function createPrinter(options?: PyPrinterOptions) {
       case PyNodeKind.LambdaExpression: {
         const parameters = node.parameters.map((parameter) => {
           const children: Array<string> = [parameter.name];
-          if (parameter.annotation) children.push(`: ${printNode(parameter.annotation)}`);
+          if (parameter.type) children.push(`: ${printNode(parameter.type)}`);
           if (parameter.defaultValue) children.push(` = ${printNode(parameter.defaultValue)}`);
           return children.join('');
         });

packages/openapi-python/src/py-dsl/expr/literal.ts

@@ -3,16 +3,14 @@ import type { AnalysisContext } from '@hey-api/codegen-core';
 import { py } from '../../py-compiler';
 import { PyDsl } from '../base';
 
-export type LiteralValue = string | number | boolean | null;
-
 const Mixed = PyDsl<py.Literal>;
 
 export class LiteralPyDsl extends Mixed {
   readonly '~dsl' = 'LiteralPyDsl';
 
-  protected value: LiteralValue;
+  protected value: py.LiteralValue;
 
-  constructor(value: LiteralValue) {
+  constructor(value: py.LiteralValue) {
     super();
     this.value = value;
   }

packages/openapi-python/src/py-dsl/stmt/var.ts

@@ -44,10 +44,10 @@ export class VarPyDsl extends Mixed {
   override toAst() {
     this.$validate();
     const target = this.$node(this.name)!;
-    const annotation = this.$type();
+    const type = this.$type();
     const value = this.$value();
 
-    return py.factory.createAssignment(target, annotation, value);
+    return py.factory.createAssignment(target, type, value);
   }
 
   $validate(): asserts this {

packages/openapi-ts/src/ts-compiler/__snapshots__/nodes/expressions/identifier/identifier.ts

@@ -0,0 +1,4 @@
+let x;
+let y;
+y = 42;
+x = y;