feature: implement constructor type

mistlog · Mar 12, 2021 · 259c1a4 · 259c1a4
1 parent 36368d9
commit 259c1a4
Show file tree

Hide file tree

Showing 8 changed files with 74 additions and 3 deletions.
diff --git a/src/generator/generator.ts b/src/generator/generator.ts
@@ -183,10 +183,12 @@ function tsArrayType(ast: IArrayType): t.TSArrayType {
     return _tsArrayType(TSType(ast.elementType), ast.dimension);
 }
 
-function tsFunctionType(ast: IFunctionType): t.TSFunctionType {
+function tsFunctionType(ast: IFunctionType): t.TSFunctionType | t.TSConstructorType {
     const params = tsFunctionParams(ast.params);
     const typeParams = ast.typeParams ? tsTypeParameterDeclaration(ast.typeParams) : null;
-    return t.tsFunctionType(typeParams, params, t.tsTypeAnnotation(TSType(ast.returnType)));
+    const args = [typeParams, params, t.tsTypeAnnotation(TSType(ast.returnType))] as const;
+    const type = ast.isConstructor ? t.tsConstructorType(...args) : t.tsFunctionType(...args);
+    return type;
 }
 
 function tsFunctionParams(params: IFunctionTypeParam[]) {

diff --git a/src/parser/function/function.tsx b/src/parser/function/function.tsx
@@ -8,10 +8,11 @@ export interface IFunctionType {
     params: IFunctionTypeParam[]
     returnType: ITypeExpression
     typeParams?: IParamList
+    isConstructor?: boolean
 }
 
 export function FunctionType() {
-    const action = ({ params, returnType, typeParams }): IFunctionType => {
+    const action = ({ params, returnType, typeParams, isConstructor }): IFunctionType => {
         const type: IFunctionType = {
             kind: "FunctionType",
             params,
@@ -20,12 +21,18 @@ export function FunctionType() {
         if (typeParams) {
             type.typeParams = typeParams
         }
+        if (isConstructor) {
+            type.isConstructor = true;
+        }
         return type
     }
 
     return (
         <pattern action={action}>
             {Text("type")}
+            <opt label="isConstructor">
+                {Text("new")}
+            </opt>
             <_ />
             <opt label="typeParams">
                 <pattern action={({ typeParams }) => typeParams}>

diff --git a/test/__snapshots__/generator.test.ts.snap b/test/__snapshots__/generator.test.ts.snap
@@ -88,6 +88,8 @@ exports[`ts-type ConditionalTypeExpression: 2 1`] = `"T extends string ? \\"stri
 
 exports[`ts-type FunctionType 1`] = `"() => void"`;
 
+exports[`ts-type FunctionType: constructor 1`] = `"new (...arg: any) => any"`;
+
 exports[`ts-type FunctionType: nested 1`] = `"() => (a: number, b: string) => void"`;
 
 exports[`ts-type FunctionType: optional param 1`] = `"(a: number, b?: string) => number"`;

diff --git a/test/assets/ast/FunctionType-Constructor.json b/test/assets/ast/FunctionType-Constructor.json
@@ -0,0 +1,22 @@
+{
+    "kind": "FunctionType",
+    "params": [
+        {
+            "kind": "FunctionTypeParam",
+            "name": {
+                "kind": "Identifier",
+                "name": "arg"
+            },
+            "type": {
+                "kind": "AnyType",
+                "value": "any"
+            },
+            "rest": true
+        }
+    ],
+    "returnType": {
+        "kind": "AnyType",
+        "value": "any"
+    },
+    "isConstructor": true
+}
diff --git a/test/assets/ts-type/FunctionType-Constructor b/test/assets/ts-type/FunctionType-Constructor
@@ -0,0 +1 @@
+new (...arg: any) => any
diff --git a/test/generator.test.ts b/test/generator.test.ts
@@ -88,6 +88,11 @@ describe("ts-type", () => {
         expect(toCode(name)).toMatchSnapshot();
     })
 
+    test("FunctionType: constructor", () => {
+        const name = "FunctionType-Constructor";
+        expect(toCode(name)).toMatchSnapshot();
+    })
+
     test("FunctionType: optional param", () => {
         const name = "FunctionType-OptionalParam";
         expect(toCode(name)).toMatchSnapshot();

diff --git a/test/parser/__snapshots__/function.test.tsx.snap b/test/parser/__snapshots__/function.test.tsx.snap
@@ -11,6 +11,31 @@ Object {
 }
 `;
 
+exports[`parser: function FunctionType: constructor 1`] = `
+Object {
+  "isConstructor": true,
+  "kind": "FunctionType",
+  "params": Array [
+    Object {
+      "kind": "FunctionTypeParam",
+      "name": Object {
+        "kind": "Identifier",
+        "name": "arg",
+      },
+      "rest": true,
+      "type": Object {
+        "kind": "AnyType",
+        "value": "any",
+      },
+    },
+  ],
+  "returnType": Object {
+    "kind": "AnyType",
+    "value": "any",
+  },
+}
+`;
+
 exports[`parser: function FunctionType: nested 1`] = `
 Object {
   "kind": "FunctionType",

diff --git a/test/parser/function.test.tsx b/test/parser/function.test.tsx
@@ -10,6 +10,13 @@ describe("parser: function", () => {
         expect(ast).toMatchSnapshot();
     })
 
+    test("FunctionType: constructor", () => {
+        const parser = ReactPeg.render(<TypeExpression />);
+        const ast = parser.parse(`type new (...arg: any) => any`);
+        saveAST(ast, "FunctionType-Constructor.json");
+        expect(ast).toMatchSnapshot();
+    })
+
     test("FunctionType: optional param", () => {
         const parser = ReactPeg.render(<TypeExpression />);
         const ast = parser.parse(`type (a:number, b?: string) => number`);